Flowable源码注释（十七）事件日志测试类（上）

Flowable源码地址：https://github.com/flowable/flowable-engine

包路径：org.flowable.engine.test.api.event

DatabaseEventLoggerTest 数据库事件日志测试类

public class DatabaseEventLoggerTest extends PluggableFlowableTestCase {

    protected EventLogger databaseEventLogger;

    protected ObjectMapper objectMapper = new ObjectMapper();

    @BeforeEach
    protected void setUp() throws Exception {

        // 数据库事件日志设置
        databaseEventLogger = new EventLogger(processEngineConfiguration.getClock(), processEngineConfiguration.getObjectMapper());
        runtimeService.addEventListener(databaseEventLogger);
    }

    @AfterEach
    protected void tearDown() throws Exception {

        // 数据库事件日志移除
        runtimeService.removeEventListener(databaseEventLogger);

    }

    // 测试数据库事件
    @Test
    @Deployment(resources = { "org/flowable/engine/test/api/event/DatabaseEventLoggerProcess.bpmn20.xml" })
    public void testDatabaseEvents() throws IOException {

        String testTenant = "testTenant";

        String deploymentId = repositoryService.createDeployment()
                .addClasspathResource("org/flowable/engine/test/api/event/DatabaseEventLoggerProcess.bpmn20.xml")
                .tenantId(testTenant)
                .deploy().getId();

        // 运行进程以收集数据
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKeyAndTenantId("DatabaseEventLoggerProcess",
                CollectionUtil.singletonMap("testVar", "helloWorld"), testTenant);

        // 验证事件日志条目
        List<EventLogEntry> eventLogEntries = managementService.getEventLogEntries(null, null);

        String processDefinitionId = processInstance.getProcessDefinitionId();
        Iterator<EventLogEntry> iterator = eventLogEntries.iterator();
        while (iterator.hasNext()) {
            EventLogEntry entry = iterator.next();
            if (entry.getProcessDefinitionId() != null && !entry.getProcessDefinitionId().equals(processDefinitionId)) {
                iterator.remove();
            }
        }

        assertThat(eventLogEntries).hasSize(15);

        long lastLogNr = -1;
        for (int i = 0; i < eventLogEntries.size(); i++) {

            EventLogEntry entry = eventLogEntries.get(i);

            if (i == 0) {

                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.VARIABLE_CREATED.name());
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.PROCESS_INSTANCE_ID,
                                Fields.VALUE_STRING,
                                Fields.TENANT_ID
                        )
                        .containsEntry(Fields.TENANT_ID, testTenant);
            }

            // 进程实例启动
            if (i == 1) {

                assertThat(entry.getType()).isEqualTo("PROCESSINSTANCE_START");
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ID,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.TENANT_ID
                        )
                        .containsEntry(Fields.TENANT_ID, testTenant);

                Map<String, Object> variableMap = (Map<String, Object>) data.get(Fields.VARIABLES);
                assertThat(variableMap)
                        .containsOnly(entry("testVar", "helloWorld"));

                assertThat(data)
                        .doesNotContainKeys(Fields.NAME, Fields.BUSINESS_KEY);
            }

            // 活动开始
            if (i == 2 || i == 5 || i == 9 || i == 12) {
                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.ACTIVITY_STARTED.name());
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ACTIVITY_ID,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.PROCESS_INSTANCE_ID,
                                Fields.EXECUTION_ID,
                                Fields.ACTIVITY_TYPE,
                                Fields.TENANT_ID
                        )
                        .containsEntry(Fields.TENANT_ID, testTenant);
            }

            // 离开开始
            if (i == 3) {

                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.ACTIVITY_COMPLETED.name());
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ACTIVITY_ID,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.PROCESS_INSTANCE_ID,
                                Fields.EXECUTION_ID,
                                Fields.ACTIVITY_TYPE,
                                Fields.TENANT_ID
                        )
                        .contains(
                                entry(Fields.ACTIVITY_ID, "startEvent1"),
                                entry(Fields.TENANT_ID, "testTenant")
                        );
            }

            // 顺序流
            if (i == 4 || i == 7 || i == 8) {
                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.SEQUENCEFLOW_TAKEN.name());
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ID,
                                Fields.SOURCE_ACTIVITY_ID,
                                Fields.SOURCE_ACTIVITY_TYPE,
                                Fields.SOURCE_ACTIVITY_TYPE,
                                Fields.TENANT_ID
                        )
                        .containsEntry(Fields.TENANT_ID, testTenant);
            }

            // 离开并行网关
            if (i == 6) {

                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.ACTIVITY_COMPLETED.name());
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ACTIVITY_ID,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.PROCESS_INSTANCE_ID,
                                Fields.EXECUTION_ID,
                                Fields.ACTIVITY_TYPE,
                                Fields.TENANT_ID
                        );
            }

            // T任务
            if (i == 11|| i == 14) {

                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.TASK_CREATED.name());
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNotNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ID,
                                Fields.NAME,
                                Fields.ASSIGNEE,
                                Fields.CREATE_TIME,
                                Fields.PRIORITY,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.EXECUTION_ID,
                                Fields.TENANT_ID
                        )
                        .doesNotContainKeys(
                                Fields.DESCRIPTION,
                                Fields.CATEGORY,
                                Fields.OWNER,
                                Fields.DUE_DATE,
                                Fields.FORM_KEY,
                                Fields.USER_ID
                        )

                        .containsEntry(Fields.TENANT_ID, testTenant);

            }

            if (i == 10 || i == 13) {

                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.TASK_ASSIGNED.name());
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNotNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ID,
                                Fields.NAME,
                                Fields.ASSIGNEE,
                                Fields.CREATE_TIME,
                                Fields.PRIORITY,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.EXECUTION_ID,
                                Fields.TENANT_ID
                        )
                        .doesNotContainKeys(
                                Fields.DESCRIPTION,
                                Fields.CATEGORY,
                                Fields.OWNER,
                                Fields.DUE_DATE,
                                Fields.FORM_KEY,
                                Fields.USER_ID
                        )

                        .containsEntry(Fields.TENANT_ID, testTenant);
            }

            lastLogNr = entry.getLogNumber();
        }

        // 完成两个任务
        for (org.flowable.task.api.Task task : taskService.createTaskQuery().list()) {
            Authentication.setAuthenticatedUserId(task.getAssignee());
            Map<String, Object> varMap = new HashMap<>();
            varMap.put("test", "test");
            taskService.complete(task.getId(), varMap);
            Authentication.setAuthenticatedUserId(null);
        }

        // 验证事件
        eventLogEntries = managementService.getEventLogEntries(lastLogNr, 100L);
        assertThat(eventLogEntries).hasSize(17);

        for (int i = 0; i < eventLogEntries.size(); i++) {

            EventLogEntry entry = eventLogEntries.get(i);

            // org.flowable.task.service.Task completion
            if (i == 1 || i == 6) {
                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.TASK_COMPLETED.name());
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNotNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ID,
                                Fields.NAME,
                                Fields.ASSIGNEE,
                                Fields.CREATE_TIME,
                                Fields.PRIORITY,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.EXECUTION_ID,
                                Fields.TENANT_ID,
                                Fields.USER_ID
                        );

                Map<String, Object> variableMap = (Map<String, Object>) data.get(Fields.VARIABLES);
                assertThat(variableMap)
                        .containsOnly(entry("test", "test"));

                assertThat(data)
                        .doesNotContainKeys(
                                Fields.DESCRIPTION,
                                Fields.CATEGORY,
                                Fields.OWNER,
                                Fields.DUE_DATE,
                                Fields.FORM_KEY
                        )
                        .containsEntry(Fields.TENANT_ID, testTenant);
            }

            // 已完成的活动
            if (i == 2 || i == 7 || i == 10 || i == 13) {
                assertThat(entry.getType()).isEqualTo(FlowableEngineEventType.ACTIVITY_COMPLETED.name());
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ACTIVITY_ID,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.PROCESS_INSTANCE_ID,
                                Fields.EXECUTION_ID,
                                Fields.ACTIVITY_TYPE,
                                Fields.TENANT_ID,
                                Fields.BEHAVIOR_CLASS
                        )
                        .containsEntry(Fields.TENANT_ID, testTenant);

                if (i == 2) {
                    assertThat(data)
                            .containsEntry(Fields.ACTIVITY_TYPE, "userTask");
                } else if (i == 7) {
                    assertThat(data)
                            .containsEntry(Fields.ACTIVITY_TYPE, "userTask");
                } else if (i == 10) {
                    assertThat(data)
                            .containsEntry(Fields.ACTIVITY_TYPE, "parallelGateway");
                } else if (i == 13) {
                    assertThat(data)
                            .containsEntry(Fields.ACTIVITY_TYPE, "endEvent");
                }

            }

            // 顺序流
            if (i == 3 || i == 8 || i == 11) {
                assertThat(entry.getType()).isNotNull();
                assertThat(FlowableEngineEventType.SEQUENCEFLOW_TAKEN.name()).isEqualTo(entry.getType());
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ID,
                                Fields.SOURCE_ACTIVITY_ID,
                                Fields.SOURCE_ACTIVITY_TYPE,
                                Fields.SOURCE_ACTIVITY_BEHAVIOR_CLASS,
                                Fields.TARGET_ACTIVITY_ID,
                                Fields.TARGET_ACTIVITY_TYPE,
                                Fields.TARGET_ACTIVITY_BEHAVIOR_CLASS
                        )
                        .containsEntry(Fields.TENANT_ID, testTenant);
            }

            if (i == 14 || i == 15) {
                assertThat(entry.getType()).isEqualTo("VARIABLE_DELETED");
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNotNull();
                assertThat(entry.getTaskId()).isNull();
            }

            if (i == 16) {
                assertThat(entry.getType()).isEqualTo("PROCESSINSTANCE_END");
                assertThat(entry.getProcessDefinitionId()).isNotNull();
                assertThat(entry.getProcessInstanceId()).isNotNull();
                assertThat(entry.getTimeStamp()).isNotNull();
                assertThat(entry.getExecutionId()).isNull();
                assertThat(entry.getTaskId()).isNull();

                Map<String, Object> data = objectMapper.readValue(entry.getData(), new TypeReference<HashMap<String, Object>>() {

                });
                assertThat(data)
                        .containsKeys(
                                Fields.ID,
                                Fields.PROCESS_DEFINITION_ID,
                                Fields.TENANT_ID
                        )
                        .doesNotContainKeys(
                                Fields.NAME,
                                Fields.BUSINESS_KEY
                        )
                        .containsEntry(Fields.TENANT_ID, testTenant);
            }
        }

        // 清除
        for (EventLogEntry eventLogEntry : managementService.getEventLogEntries(null, null)) {
            managementService.deleteEventLogEntry(eventLogEntry.getLogNumber());
        }

        repositoryService.deleteDeployment(deploymentId, true);

    }
    
    ...
}