/**
  * filter duplicated rules and rulesConfig and return new RuleCreatorSet.
  * @return {RuleCreatorSet}
  */
 withoutDuplicated(): RuleCreatorSet {
     const newRawRules: {
         [index: string]: any;
     } = {};
     const newRawRulesConfig: {
         [index: string]: any;
     } = {};
     // for index
     const addedRuleMap = new MapLike<string, any[]>();
     // if already contain same ruleModule and ruleConfig value
     // Fill following condition, remove it
     // 1. same ruleModule
     // 2. same ruleConfig
     this.ruleNames.forEach(ruleName => {
         const rule = this.rules[ruleName];
         const ruleConfig = this.rulesConfig[ruleName];
         const savedConfigList = addedRuleMap.get(rule) || [];
         // same ruleCreator and ruleConfig
         const hasSameConfig = savedConfigList.some(savedConfig => {
             return deepEqual(savedConfig, ruleConfig, { strict: true });
         });
         if (hasSameConfig) {
             return;
         }
         newRawRules[ruleName] = rule;
         newRawRulesConfig[ruleName] = ruleConfig;
         // saved
         savedConfigList.push(ruleConfig);
         addedRuleMap.set(rule, savedConfigList);
     });
     addedRuleMap.clear();
     return new RuleCreatorSet(newRawRules, newRawRulesConfig);
 }

 it("The user can know that the UseCase is just finished by isUseCaseFinished", () => {
     const dispatcher = new Dispatcher();
     const context = new Context({
         dispatcher,
         store: createStore({ name: "test" })
     });
     const useCase = new DispatchUseCase();
     let callCount = 0;
     const finishedCallback = () => {
         callCount++;
     };
     const calledMap = new MapLike();
     dispatcher.onDispatch((payload, meta) => {
         if (payload instanceof DidExecutedPayload && meta.useCase && meta.isUseCaseFinished) {
             calledMap.set(meta.useCase.id, true);
             finishedCallback();
         } else if (payload instanceof CompletedPayload && meta.useCase && meta.isUseCaseFinished) {
             if (calledMap.has(meta.useCase.id)) {
                 return void calledMap.delete(meta.useCase.id);
             }
             finishedCallback();
         }
         return;
     });
     return context
         .useCase(useCase)
         .execute({ type: "test" })
         .then(() => {
             assert.equal(callCount, 1);
         });
 });

 const onCompleteUseCase = (payload: CompletedPayload, meta: DispatcherPayloadMeta) => {
     const useCase = meta.useCase;
     if (!useCase) {
         return;
     }
     const resultValue = payload.value;
     const logGroup = this.useCaseLogGroupMap.get(useCase);
     if (!logGroup) {
         console.warn("Warning(almin-logger): logGroup is not found. please report as issue.", payload, meta);
         return;
     }
     logGroup.addChunk(
         new LogChunk({
             useCase,
             payload,
             log: [`${useCase.name} is completed:`, resultValue],
             timeStamp: meta.timeStamp
         })
     );
     const transactionLogGroup = getTransactionLogGroup(meta);
     if (!transactionLogGroup) {
         outputLogging(logGroup);
     }
     this.useCaseLogGroupMap.delete(useCase);
 };

 dispatcher.onDispatch((payload, meta) => {
     if (payload instanceof DidExecutedPayload && meta.useCase && meta.isUseCaseFinished) {
         calledMap.set(meta.useCase.id, true);
         finishedCallback();
     } else if (payload instanceof CompletedPayload && meta.useCase && meta.isUseCaseFinished) {
         if (calledMap.has(meta.useCase.id)) {
             return void calledMap.delete(meta.useCase.id);
         }
         finishedCallback();
     }
     return;
 });

 /**
  * End transaction of the useCaseExecutor/UseCase
  */
 close(useCaseExecutor: UseCaseExecutor<any>) {
     const unsubscribe = this.unsubscribeMap.get(useCaseExecutor);
     if (typeof unsubscribe !== "function") {
         console.error(
             "Warning(UnitOfWork): This UseCaseExecutor is not opened or already closed.",
             useCaseExecutor
         );
         return;
     }
     unsubscribe();
     this.unsubscribeMap.delete(useCaseExecutor);
 }

 this.ruleNames.forEach(ruleName => {
     const rule = this.rules[ruleName];
     const ruleConfig = this.rulesConfig[ruleName];
     const savedConfigList = addedRuleMap.get(rule) || [];
     // same ruleCreator and ruleConfig
     const hasSameConfig = savedConfigList.some(savedConfig => {
         return deepEqual(savedConfig, ruleConfig, { strict: true });
     });
     if (hasSameConfig) {
         return;
     }
     newRawRules[ruleName] = rule;
     newRawRulesConfig[ruleName] = ruleConfig;
     // saved
     savedConfigList.push(ruleConfig);
     addedRuleMap.set(rule, savedConfigList);
 });

 const getTransactionLogGroup = (meta: DispatcherPayloadMeta) => {
     // if it is transaction, add this logGroup as child of transaction
     const transactionId = meta.transaction && meta.transaction.id;
     if (transactionId) {
         return this._transactionMap.get(transactionId);
     }
     return;
 };

 const onBeginTransaction = (_payload: TransactionBeganPayload, meta: DispatcherPayloadMeta) => {
     if (!meta.transaction) {
         console.warn("meta.transaction is missing");
         return;
     }
     const logGroup = new LogGroup({ title: meta.transaction.name, isTransaction: true });
     this._transactionMap.set(meta.transaction.id, logGroup);
     // the logGroup is root
     this.currentLogBuffer.push(logGroup);
 };