Change calculations for hasMissingEvents (#840)

* change calculations for hasMissingEvents

* lint fix

* fix hasMissingEvents for timeouts

* better conditional reading

Author: Assem-Uber

Diff for: src/views/workflow-history/helpers/get-history-group-from-events/__tests__/get-activity-group-from-events.test.ts

@@ -48,27 +48,47 @@ describe('getActivityGroupFromEvents', () => {
     expect(timedoutActivitygroup.label).toBe('');
   });
 
-  it('should return a group with hasMissingEvents set to true when scheduled event is missing', () => {
-    const completeEvents: ActivityHistoryEvent[] = [
-      startActivityTaskEvent,
-      completeActivityTaskEvent,
+  it('should return a group with hasMissingEvents when any event is missing', () => {
+    const assertions: Array<{
+      name: string;
+      events: ActivityHistoryEvent[];
+      assertionValue: boolean;
+    }> = [
+      {
+        name: 'missingCloseEvent',
+        events: [scheduleActivityTaskEvent, startActivityTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingScheduleEvent',
+        events: [startActivityTaskEvent, failedActivityTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingTimoutAndCloseEvent',
+        events: [scheduleActivityTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'completeEvents',
+        events: [
+          scheduleActivityTaskEvent,
+          startActivityTaskEvent,
+          completeActivityTaskEvent,
+        ],
+        assertionValue: false,
+      },
+      {
+        name: 'timedoutEvents',
+        events: [scheduleActivityTaskEvent, timeoutActivityTaskEvent],
+        assertionValue: false,
+      },
     ];
-    const completedActivitygroup = getActivityGroupFromEvents(completeEvents);
-    expect(completedActivitygroup.hasMissingEvents).toBe(true);
 
-    const failureEvents: ActivityHistoryEvent[] = [
-      startActivityTaskEvent,
-      failedActivityTaskEvent,
-    ];
-    const failedActivitygroup = getActivityGroupFromEvents(failureEvents);
-    expect(failedActivitygroup.hasMissingEvents).toBe(true);
-
-    const timeoutEvents: ActivityHistoryEvent[] = [
-      startActivityTaskEvent,
-      timeoutActivityTaskEvent,
-    ];
-    const timedoutActivitygroup = getActivityGroupFromEvents(timeoutEvents);
-    expect(timedoutActivitygroup.hasMissingEvents).toBe(true);
+    assertions.forEach(({ name, events, assertionValue }) => {
+      const group = getActivityGroupFromEvents(events);
+      expect([name, group.hasMissingEvents]).toEqual([name, assertionValue]);
+    });
   });
 
   it('should return a group with groupType equal to Activity', () => {

Diff for: src/views/workflow-history/helpers/get-history-group-from-events/__tests__/get-child-workflow-execution-group-from-events.test.ts

@@ -26,45 +26,43 @@ describe('getChildWorkflowExecutionGroupFromEvents', () => {
     expect(group.label).toBe(expectedLabel);
   });
 
-  it('should return a group with hasMissingEvents set to true when initiate event is missing', () => {
-    const intiateFailedEvents: ChildWorkflowExecutionHistoryEvent[] = [
-      initiateFailureChildWorkflowEvent,
-    ];
-    const intiateFailedChildWorkflowgroup =
-      getChildWorkflowExecutionGroupFromEvents(intiateFailedEvents);
-    expect(intiateFailedChildWorkflowgroup.hasMissingEvents).toBe(true);
-
-    const completeEvents: ChildWorkflowExecutionHistoryEvent[] = [
-      startChildWorkflowEvent,
-      completeChildWorkflowEvent,
-    ];
-    const completedChildWorkflowgroup =
-      getChildWorkflowExecutionGroupFromEvents(completeEvents);
-    expect(completedChildWorkflowgroup.hasMissingEvents).toBe(true);
-
-    const failureEvents: ChildWorkflowExecutionHistoryEvent[] = [
-      startChildWorkflowEvent,
-      failChildWorkflowEvent,
-    ];
-    const failedChildWorkflowgroup =
-      getChildWorkflowExecutionGroupFromEvents(failureEvents);
-    expect(failedChildWorkflowgroup.hasMissingEvents).toBe(true);
-
-    const timeoutEvents: ChildWorkflowExecutionHistoryEvent[] = [
-      startChildWorkflowEvent,
-      timeoutChildWorkflowEvent,
-    ];
-    const timedoutChildWorkflowgroup =
-      getChildWorkflowExecutionGroupFromEvents(timeoutEvents);
-    expect(timedoutChildWorkflowgroup.hasMissingEvents).toBe(true);
-
-    const cancelEvents: ChildWorkflowExecutionHistoryEvent[] = [
-      startChildWorkflowEvent,
-      cancelChildWorkflowEvent,
-    ];
-    const cancelChildWorkflowgroup =
-      getChildWorkflowExecutionGroupFromEvents(cancelEvents);
-    expect(cancelChildWorkflowgroup.hasMissingEvents).toBe(true);
+  it('should return a group with hasMissingEvents set to true when any event is missing', () => {
+    const assertions: Array<{
+      name: string;
+      events: ChildWorkflowExecutionHistoryEvent[];
+      assertionValue: boolean;
+    }> = [
+      {
+        name: 'missingInitiatedEvent',
+        events: [initiateFailureChildWorkflowEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingInitiationFailureAndCloseEvent',
+        events: [initiateChildWorkflowEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingCloseEvent',
+        events: [initiateChildWorkflowEvent, startChildWorkflowEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingStartEvent',
+        events: [initiateChildWorkflowEvent, completeChildWorkflowEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'completedFailedInitiationEvent',
+        events: [initiateChildWorkflowEvent, initiateFailureChildWorkflowEvent],
+        assertionValue: false,
+      },
+    ];
+
+    assertions.forEach(({ name, events, assertionValue }) => {
+      const group = getChildWorkflowExecutionGroupFromEvents(events);
+      expect([name, group.hasMissingEvents]).toEqual([name, assertionValue]);
+    });
   });
 
   it('should return a group with groupType equal to ChildWorkflow', () => {

Diff for: src/views/workflow-history/helpers/get-history-group-from-events/__tests__/get-decision-group-from-events.test.ts

@@ -24,27 +24,52 @@ describe('getDecisionGroupFromEvents', () => {
     expect(group.label).toBe('Decision Task');
   });
 
-  it('should return a group with hasMissingEvents set to true when scheduled event is missing', () => {
-    const completeEvents: ExtendedDecisionHistoryEvent[] = [
-      startDecisionTaskEvent,
-      completeDecisionTaskEvent,
-    ];
-    const completedDecisiongroup = getDecisionGroupFromEvents(completeEvents);
-    expect(completedDecisiongroup.hasMissingEvents).toBe(true);
-
-    const failureEvents: ExtendedDecisionHistoryEvent[] = [
-      startDecisionTaskEvent,
-      failedDecisionTaskEvent,
+  it('should return a group with hasMissingEvents set to true when any event is missing', () => {
+    const assertions: Array<{
+      name: string;
+      events: ExtendedDecisionHistoryEvent[];
+      assertionValue: boolean;
+    }> = [
+      {
+        name: 'missingScheduleEvent',
+        events: [startDecisionTaskEvent, completeDecisionTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingTimoutAndCloseEvent',
+        events: [scheduleDecisionTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingStartEvent',
+        events: [scheduleDecisionTaskEvent, completeDecisionTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingCompleteEvent',
+        events: [scheduleDecisionTaskEvent, startDecisionTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'completeEvents',
+        events: [
+          scheduleDecisionTaskEvent,
+          startDecisionTaskEvent,
+          completeDecisionTaskEvent,
+        ],
+        assertionValue: false,
+      },
+      {
+        name: 'timedoutEvents',
+        events: [scheduleDecisionTaskEvent, timeoutDecisionTaskEvent],
+        assertionValue: false,
+      },
     ];
-    const failedDecisiongroup = getDecisionGroupFromEvents(failureEvents);
-    expect(failedDecisiongroup.hasMissingEvents).toBe(true);
 
-    const timeoutEvents: ExtendedDecisionHistoryEvent[] = [
-      startDecisionTaskEvent,
-      timeoutDecisionTaskEvent,
-    ];
-    const timedoutDecisiongroup = getDecisionGroupFromEvents(timeoutEvents);
-    expect(timedoutDecisiongroup.hasMissingEvents).toBe(true);
+    assertions.forEach(({ name, events, assertionValue }) => {
+      const group = getDecisionGroupFromEvents(events);
+      expect([name, group.hasMissingEvents]).toEqual([name, assertionValue]);
+    });
   });
 
   it('should return a group with groupType equal to Decision', () => {

Diff for: src/views/workflow-history/helpers/get-history-group-from-events/__tests__/get-request-cancel-external-workflow-execution-group-from-events.test.ts

@@ -22,12 +22,37 @@ describe('getRequestCancelExternalWorkflowExecutionGroupFromEvents', () => {
     expect(group.label).toBe(expectedLabel);
   });
 
-  it('should return a group with hasMissingEvents set to true when initiated event is missing', () => {
-    const requestEvents: RequestCancelExternalWorkflowExecutionHistoryEvent[] =
-      [requestCancelExternalWorkflowEvent];
-    const requestGroup =
-      getRequestCancelExternalWorkflowExecutionGroupFromEvents(requestEvents);
-    expect(requestGroup.hasMissingEvents).toBe(true);
+  it('should return a group with hasMissingEvents set to true when any event is missing', () => {
+    const assertions: Array<{
+      name: string;
+      events: RequestCancelExternalWorkflowExecutionHistoryEvent[];
+      assertionValue: boolean;
+    }> = [
+      {
+        name: 'missingInitiatedEvent',
+        events: [requestCancelExternalWorkflowEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingCloseEvent',
+        events: [initiateRequestCancelExternalWorkflowEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'completedEvent',
+        events: [
+          initiateRequestCancelExternalWorkflowEvent,
+          requestCancelExternalWorkflowEvent,
+        ],
+        assertionValue: false,
+      },
+    ];
+
+    assertions.forEach(({ name, events, assertionValue }) => {
+      const group =
+        getRequestCancelExternalWorkflowExecutionGroupFromEvents(events);
+      expect([name, group.hasMissingEvents]).toEqual([name, assertionValue]);
+    });
   });
 
   it('should return a group with groupType equal to RequestCancelExternalWorkflowExecution', () => {

Diff for: src/views/workflow-history/helpers/get-history-group-from-events/__tests__/get-signal-external-workflow-execution-group-from-events.test.ts

@@ -22,20 +22,36 @@ describe('getSignalExternalWorkflowExecutionGroupFromEvents', () => {
     expect(group.label).toBe(expectedLabel);
   });
 
-  it('should return a group with hasMissingEvents set to true when initiate event is missing', () => {
-    const signalEvents: SignalExternalWorkflowExecutionHistoryEvent[] = [
-      signalExternalWorkflowEvent,
+  it('should return a group with hasMissingEvents set to true when any event is missing', () => {
+    const assertions: Array<{
+      name: string;
+      events: SignalExternalWorkflowExecutionHistoryEvent[];
+      assertionValue: boolean;
+    }> = [
+      {
+        name: 'missingInitiatedEvent',
+        events: [signalExternalWorkflowEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingCloseEvent',
+        events: [initiateSignalExternalWorkflowEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'completeEvents',
+        events: [
+          initiateSignalExternalWorkflowEvent,
+          signalExternalWorkflowEvent,
+        ],
+        assertionValue: false,
+      },
     ];
-    const signalGroup =
-      getSignalExternalWorkflowExecutionGroupFromEvents(signalEvents);
-    expect(signalGroup.hasMissingEvents).toBe(true);
 
-    const failEvents: SignalExternalWorkflowExecutionHistoryEvent[] = [
-      failSignalExternalWorkflowEvent,
-    ];
-    const failedGroup =
-      getSignalExternalWorkflowExecutionGroupFromEvents(failEvents);
-    expect(failedGroup.hasMissingEvents).toBe(true);
+    assertions.forEach(({ name, events, assertionValue }) => {
+      const group = getSignalExternalWorkflowExecutionGroupFromEvents(events);
+      expect([name, group.hasMissingEvents]).toEqual([name, assertionValue]);
+    });
   });
 
   it('should return a group with groupType equal to SignalExternalWorkflowExecution', () => {

Diff for: src/views/workflow-history/helpers/get-history-group-from-events/__tests__/get-timer-group-from-events.test.ts

@@ -20,14 +20,33 @@ describe('getTimerGroupFromEvents', () => {
     expect(group.label).toBe(expectedLabel);
   });
 
-  it('should return a group with hasMissingEvents set to true when start event is missing', () => {
-    const fireEvents: TimerHistoryEvent[] = [fireTimerTaskEvent];
-    const firedTimerGroup = getTimerGroupFromEvents(fireEvents);
-    expect(firedTimerGroup.hasMissingEvents).toBe(true);
+  it('should return a group with hasMissingEvents set to true when any event is missing', () => {
+    const assertions: Array<{
+      name: string;
+      events: TimerHistoryEvent[];
+      assertionValue: boolean;
+    }> = [
+      {
+        name: 'missingStartEvent',
+        events: [fireTimerTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'missingCloseEvent',
+        events: [startTimerTaskEvent],
+        assertionValue: true,
+      },
+      {
+        name: 'completeEvents',
+        events: [startTimerTaskEvent, fireTimerTaskEvent],
+        assertionValue: false,
+      },
+    ];
 
-    const cancelEvents: TimerHistoryEvent[] = [cancelTimerTaskEvent];
-    const canceledTimerGroup = getTimerGroupFromEvents(cancelEvents);
-    expect(canceledTimerGroup.hasMissingEvents).toBe(true);
+    assertions.forEach(({ name, events, assertionValue }) => {
+      const group = getTimerGroupFromEvents(events);
+      expect([name, group.hasMissingEvents]).toEqual([name, assertionValue]);
+    });
   });
 
   it('should return a group with groupType equal to Timer', () => {