@orchestrator-ui/orchestrator-ui-components 7.4.0 → 7.5.0

package/src/pages/processes/timelineUtils.spec.ts

@@ -1,203 +1,191 @@
 import { Step, StepStatus } from '../../types';
 import { GroupedStep } from './WfoProcessDetailPage';
 import {
-    convertStepsToGroupedSteps,
-    getMostAccurateTimelineStatus,
-    mapGroupedStepsToTimelineItems,
+  convertStepsToGroupedSteps,
+  getMostAccurateTimelineStatus,
+  mapGroupedStepsToTimelineItems,
 } from './timelineUtils';
 
 const baseStep: Step = {
-    started: 'testStarted',
-    completed: 'testCompleted',
-    name: 'tesName',
-    state: {
-        testKey: 'testValue',
-    },
-    stateDelta: {
-        testKey: 'testValue',
-    },
-    status: StepStatus.SUCCESS,
-    stepId: 'testStepId',
+  started: 'testStarted',
+  completed: 'testCompleted',
+  name: 'tesName',
+  state: {
+    testKey: 'testValue',
+  },
+  stateDelta: {
+    testKey: 'testValue',
+  },
+  status: StepStatus.SUCCESS,
+  stepId: 'testStepId',
 };
 
 describe('getMostAccurateTimelineStatus()', () => {
-    it('returns previous step when current step has status PENDING', () => {
-        const previousStepStatus = StepStatus.COMPLETE;
-        const currentStepStatus = StepStatus.PENDING;
+  it('returns previous step when current step has status PENDING', () => {
+    const previousStepStatus = StepStatus.COMPLETE;
+    const currentStepStatus = StepStatus.PENDING;
 
-        const result = getMostAccurateTimelineStatus(
-            previousStepStatus,
-            currentStepStatus,
-        );
+    const result = getMostAccurateTimelineStatus(previousStepStatus, currentStepStatus);
 
-        expect(result).toEqual(previousStepStatus);
-    });
+    expect(result).toEqual(previousStepStatus);
+  });
 
-    it('returns the current step when current step has a status other than PENDING', () => {
-        const previousStepStatus = StepStatus.FAILED;
-        const currentStepStatus = StepStatus.COMPLETE;
+  it('returns the current step when current step has a status other than PENDING', () => {
+    const previousStepStatus = StepStatus.FAILED;
+    const currentStepStatus = StepStatus.COMPLETE;
 
-        const result = getMostAccurateTimelineStatus(
-            previousStepStatus,
-            currentStepStatus,
-        );
+    const result = getMostAccurateTimelineStatus(previousStepStatus, currentStepStatus);
 
-        expect(result).toEqual(currentStepStatus);
-    });
+    expect(result).toEqual(currentStepStatus);
+  });
 });
 
 describe('convertStepsToGroupedSteps()', () => {
-    it('returns steps grouped by name', () => {
-        // Given
-        const testSteps: Step[] = [
-            {
-                ...baseStep,
-                name: 'testName1',
-                status: StepStatus.FAILED,
-            },
-            {
-                ...baseStep,
-                name: 'testName1',
-                status: StepStatus.SUCCESS,
-            },
-            {
-                ...baseStep,
-                name: 'testName2',
-                status: StepStatus.PENDING,
-            },
-        ];
-
-        // When
-        const result = convertStepsToGroupedSteps(testSteps);
-
-        // Then
-        expect(result.length).toEqual(2);
-
-        const { steps: firstGroupedStepSteps } = result[0];
-        expect(firstGroupedStepSteps.length).toEqual(2);
-        expect(firstGroupedStepSteps[0].name).toEqual('testName1');
-        expect(firstGroupedStepSteps[0].status).toEqual(StepStatus.FAILED);
-        expect(firstGroupedStepSteps[1].name).toEqual('testName1');
-        expect(firstGroupedStepSteps[1].status).toEqual(StepStatus.SUCCESS);
-
-        const { steps: secondGroupedStepSteps } = result[1];
-        expect(secondGroupedStepSteps.length).toEqual(1);
-        expect(secondGroupedStepSteps[0].name).toEqual('testName2');
-        expect(secondGroupedStepSteps[0].status).toEqual(StepStatus.PENDING);
-    });
-    it('returns an empty array if there are no steps', () => {
-        const result = convertStepsToGroupedSteps([]);
-
-        expect(result.length).toEqual(0);
-    });
+  it('returns steps grouped by name', () => {
+    // Given
+    const testSteps: Step[] = [
+      {
+        ...baseStep,
+        name: 'testName1',
+        status: StepStatus.FAILED,
+      },
+      {
+        ...baseStep,
+        name: 'testName1',
+        status: StepStatus.SUCCESS,
+      },
+      {
+        ...baseStep,
+        name: 'testName2',
+        status: StepStatus.PENDING,
+      },
+    ];
+
+    // When
+    const result = convertStepsToGroupedSteps(testSteps);
+
+    // Then
+    expect(result.length).toEqual(2);
+
+    const { steps: firstGroupedStepSteps } = result[0];
+    expect(firstGroupedStepSteps.length).toEqual(2);
+    expect(firstGroupedStepSteps[0].name).toEqual('testName1');
+    expect(firstGroupedStepSteps[0].status).toEqual(StepStatus.FAILED);
+    expect(firstGroupedStepSteps[1].name).toEqual('testName1');
+    expect(firstGroupedStepSteps[1].status).toEqual(StepStatus.SUCCESS);
+
+    const { steps: secondGroupedStepSteps } = result[1];
+    expect(secondGroupedStepSteps.length).toEqual(1);
+    expect(secondGroupedStepSteps[0].name).toEqual('testName2');
+    expect(secondGroupedStepSteps[0].status).toEqual(StepStatus.PENDING);
+  });
+  it('returns an empty array if there are no steps', () => {
+    const result = convertStepsToGroupedSteps([]);
+
+    expect(result.length).toEqual(0);
+  });
 });
 
 describe('getMostAccurateTimelineStatus()', () => {
-    it('returns previous step when current step has status PENDING', () => {
-        const statusPreviousStep: StepStatus = StepStatus.FAILED;
-        const statusCurrentStep: StepStatus = StepStatus.PENDING;
-
-        const result = getMostAccurateTimelineStatus(
-            statusPreviousStep,
-            statusCurrentStep,
-        );
-
-        expect(result).toEqual(statusPreviousStep);
-    });
-    it('returns the current step when current step has a status other than PENDING', () => {
-        const statusPreviousStep: StepStatus = StepStatus.FAILED;
-        const statusCurrentStep: StepStatus = StepStatus.SUCCESS;
-
-        const result = getMostAccurateTimelineStatus(
-            statusPreviousStep,
-            statusCurrentStep,
-        );
-
-        expect(result).toEqual(statusCurrentStep);
-    });
+  it('returns previous step when current step has status PENDING', () => {
+    const statusPreviousStep: StepStatus = StepStatus.FAILED;
+    const statusCurrentStep: StepStatus = StepStatus.PENDING;
+
+    const result = getMostAccurateTimelineStatus(statusPreviousStep, statusCurrentStep);
+
+    expect(result).toEqual(statusPreviousStep);
+  });
+  it('returns the current step when current step has a status other than PENDING', () => {
+    const statusPreviousStep: StepStatus = StepStatus.FAILED;
+    const statusCurrentStep: StepStatus = StepStatus.SUCCESS;
+
+    const result = getMostAccurateTimelineStatus(statusPreviousStep, statusCurrentStep);
+
+    expect(result).toEqual(statusCurrentStep);
+  });
 });
 
 describe('mapGroupedStepsToTimelineItems()', () => {
-    it('maps a grouped-step with a single step to a timeline item', () => {
-        // Given
-        const groupedSteps: GroupedStep[] = [
-            {
-                steps: [baseStep],
-            },
-        ];
-
-        // When
-        const result = mapGroupedStepsToTimelineItems(groupedSteps);
-
-        // Then
-        expect(result.length).toEqual(1);
-
-        const { processStepStatus, stepDetail, id, value } = result[0];
-        expect(processStepStatus).toEqual(baseStep.status);
-        expect(stepDetail).toEqual(baseStep.name);
-        expect(id).toEqual(baseStep.stepId);
-        expect(value).toBeUndefined();
-    });
-
-    it('maps a grouped-step with a multiple steps to a single timeline item', () => {
-        // Given
-        const testStep1: Step = {
-            ...baseStep,
-            status: StepStatus.FAILED,
-            stepId: '111',
-        };
-        const testStep2: Step = {
-            ...baseStep,
-            status: StepStatus.FAILED,
-            stepId: '222',
-        };
-        const testStep3: Step = {
-            ...baseStep,
-            status: StepStatus.SUCCESS,
-            stepId: '333',
-        };
-        const groupedSteps: GroupedStep[] = [
-            {
-                steps: [testStep1, testStep2, testStep3],
-            },
-        ];
-
-        // When
-        const result = mapGroupedStepsToTimelineItems(groupedSteps);
-
-        // Then
-        expect(result.length).toEqual(1);
-
-        const { processStepStatus, stepDetail, id, value } = result[0];
-        expect(processStepStatus).toEqual(StepStatus.SUCCESS);
-        expect(stepDetail).toEqual(testStep3.name);
-        expect(id).toEqual(testStep3.stepId);
-        expect(value).toEqual(2);
-    });
-
-    it('returns an timeline item with value undefined if there are multiple non-failed steps', () => {
-        // Given
-        const testStep1: Step = {
-            ...baseStep,
-            status: StepStatus.PENDING,
-            stepId: '111',
-        };
-        const testStep2: Step = {
-            ...baseStep,
-            status: StepStatus.SUCCESS,
-            stepId: '222',
-        };
-        const groupedSteps: GroupedStep[] = [
-            {
-                steps: [testStep1, testStep2],
-            },
-        ];
-
-        // When
-        const result = mapGroupedStepsToTimelineItems(groupedSteps);
-
-        // Then
-        expect(result.length).toEqual(1);
-        expect(result[0].value).toBeUndefined();
-    });
+  it('maps a grouped-step with a single step to a timeline item', () => {
+    // Given
+    const groupedSteps: GroupedStep[] = [
+      {
+        steps: [baseStep],
+      },
+    ];
+
+    // When
+    const result = mapGroupedStepsToTimelineItems(groupedSteps);
+
+    // Then
+    expect(result.length).toEqual(1);
+
+    const { processStepStatus, stepDetail, id, value } = result[0];
+    expect(processStepStatus).toEqual(baseStep.status);
+    expect(stepDetail).toEqual(baseStep.name);
+    expect(id).toEqual(baseStep.stepId);
+    expect(value).toBeUndefined();
+  });
+
+  it('maps a grouped-step with a multiple steps to a single timeline item', () => {
+    // Given
+    const testStep1: Step = {
+      ...baseStep,
+      status: StepStatus.FAILED,
+      stepId: '111',
+    };
+    const testStep2: Step = {
+      ...baseStep,
+      status: StepStatus.FAILED,
+      stepId: '222',
+    };
+    const testStep3: Step = {
+      ...baseStep,
+      status: StepStatus.SUCCESS,
+      stepId: '333',
+    };
+    const groupedSteps: GroupedStep[] = [
+      {
+        steps: [testStep1, testStep2, testStep3],
+      },
+    ];
+
+    // When
+    const result = mapGroupedStepsToTimelineItems(groupedSteps);
+
+    // Then
+    expect(result.length).toEqual(1);
+
+    const { processStepStatus, stepDetail, id, value } = result[0];
+    expect(processStepStatus).toEqual(StepStatus.SUCCESS);
+    expect(stepDetail).toEqual(testStep3.name);
+    expect(id).toEqual(testStep3.stepId);
+    expect(value).toEqual(2);
+  });
+
+  it('returns an timeline item with value undefined if there are multiple non-failed steps', () => {
+    // Given
+    const testStep1: Step = {
+      ...baseStep,
+      status: StepStatus.PENDING,
+      stepId: '111',
+    };
+    const testStep2: Step = {
+      ...baseStep,
+      status: StepStatus.SUCCESS,
+      stepId: '222',
+    };
+    const groupedSteps: GroupedStep[] = [
+      {
+        steps: [testStep1, testStep2],
+      },
+    ];
+
+    // When
+    const result = mapGroupedStepsToTimelineItems(groupedSteps);
+
+    // Then
+    expect(result.length).toEqual(1);
+    expect(result[0].value).toBeUndefined();
+  });
 });

package/src/pages/processes/timelineUtils.ts

@@ -3,111 +3,87 @@ import { Step, StepStatus } from '../../types';
 import { GroupedStep } from './WfoProcessDetailPage';
 
 export const getMostAccurateTimelineStatus = (
-    statusPreviousStep: StepStatus,
-    statusCurrentStep: StepStatus,
-): StepStatus =>
-    statusCurrentStep !== StepStatus.PENDING
-        ? statusCurrentStep
-        : statusPreviousStep;
+  statusPreviousStep: StepStatus,
+  statusCurrentStep: StepStatus,
+): StepStatus => (statusCurrentStep !== StepStatus.PENDING ? statusCurrentStep : statusPreviousStep);
 
 export const isNonRetryableState = (status: StepStatus): boolean => {
-    return (
-        status === StepStatus.COMPLETE ||
-        status === StepStatus.SUCCESS ||
-        status === StepStatus.SKIPPED
-    );
+  return status === StepStatus.COMPLETE || status === StepStatus.SUCCESS || status === StepStatus.SKIPPED;
 };
 
-export const isFailedStep = (step: Step): boolean =>
-    step.status === StepStatus.FAILED;
+export const isFailedStep = (step: Step): boolean => step.status === StepStatus.FAILED;
 
 const stepsShouldBeMerged = (previousStep: Step, currentStep: Step) =>
-    !isNonRetryableState(previousStep.status) &&
-    previousStep.name === currentStep.name;
+  !isNonRetryableState(previousStep.status) && previousStep.name === currentStep.name;
 
 export const convertStepsToGroupedSteps = (steps: Step[]): GroupedStep[] =>
-    steps.reduce<GroupedStep[]>(
-        (previousGroupedSteps: GroupedStep[], currentStep, index, allSteps) => {
-            const previousGroupedStep = previousGroupedSteps.slice(-1)[0];
-
-            if (
-                index > 0 &&
-                stepsShouldBeMerged(allSteps[index - 1], currentStep)
-            ) {
-                const allGroupedStepsExceptLast = previousGroupedSteps.slice(
-                    0,
-                    -1,
-                );
-
-                const updatedLastGroupedStep: GroupedStep = {
-                    steps: [...previousGroupedStep.steps, currentStep],
-                };
-
-                return [...allGroupedStepsExceptLast, updatedLastGroupedStep];
-            }
-
-            return [
-                ...previousGroupedSteps,
-                {
-                    steps: [currentStep],
-                },
-            ];
-        },
-        [],
-    );
+  steps.reduce<GroupedStep[]>((previousGroupedSteps: GroupedStep[], currentStep, index, allSteps) => {
+    const previousGroupedStep = previousGroupedSteps.slice(-1)[0];
 
-const mapStepToTimelineItem = (processDetailStep: Step): TimelineItem => {
-    return {
-        id: processDetailStep.stepId,
-        processStepStatus: processDetailStep.status,
-        stepDetail: processDetailStep.name,
-    };
-};
+    if (index > 0 && stepsShouldBeMerged(allSteps[index - 1], currentStep)) {
+      const allGroupedStepsExceptLast = previousGroupedSteps.slice(0, -1);
+
+      const updatedLastGroupedStep: GroupedStep = {
+        steps: [...previousGroupedStep.steps, currentStep],
+      };
 
-export const mapGroupedStepToTimelineItem = (
-    groupedStep: GroupedStep,
-): TimelineItem => {
-    if (groupedStep.steps.length === 1) {
-        return mapStepToTimelineItem(groupedStep.steps[0]);
+      return [...allGroupedStepsExceptLast, updatedLastGroupedStep];
     }
 
-    return groupedStep.steps.reduce<TimelineItem>(
-        (previousTimelineItem: TimelineItem, currentStep): TimelineItem => ({
-            ...previousTimelineItem,
-            id: currentStep.stepId ?? previousTimelineItem.id,
-            processStepStatus: getMostAccurateTimelineStatus(
-                previousTimelineItem.processStepStatus,
-                currentStep.status,
-            ),
-        }),
-        {
-            ...mapStepToTimelineItem(groupedStep.steps[0]),
-            value: groupedStep.steps.filter(isFailedStep).length || undefined,
-        },
-    );
+    return [
+      ...previousGroupedSteps,
+      {
+        steps: [currentStep],
+      },
+    ];
+  }, []);
+
+const mapStepToTimelineItem = (processDetailStep: Step): TimelineItem => {
+  return {
+    id: processDetailStep.stepId,
+    processStepStatus: processDetailStep.status,
+    stepDetail: processDetailStep.name,
+  };
 };
 
-export const mapGroupedStepsToTimelineItems = (
-    groupedSteps: GroupedStep[],
-): TimelineItem[] => groupedSteps.map(mapGroupedStepToTimelineItem);
+export const mapGroupedStepToTimelineItem = (groupedStep: GroupedStep): TimelineItem => {
+  if (groupedStep.steps.length === 1) {
+    return mapStepToTimelineItem(groupedStep.steps[0]);
+  }
+
+  return groupedStep.steps.reduce<TimelineItem>(
+    (previousTimelineItem: TimelineItem, currentStep): TimelineItem => ({
+      ...previousTimelineItem,
+      id: currentStep.stepId ?? previousTimelineItem.id,
+      processStepStatus: getMostAccurateTimelineStatus(previousTimelineItem.processStepStatus, currentStep.status),
+    }),
+    {
+      ...mapStepToTimelineItem(groupedStep.steps[0]),
+      value: groupedStep.steps.filter(isFailedStep).length || undefined,
+    },
+  );
+};
+
+export const mapGroupedStepsToTimelineItems = (groupedSteps: GroupedStep[]): TimelineItem[] =>
+  groupedSteps.map(mapGroupedStepToTimelineItem);
 
 export const getIndexOfCurrentStep = (timelineItems: TimelineItem[]) => {
-    const reversedTimelineItems = [...timelineItems].reverse();
-    const reversedIndexOfCurrentStep = reversedTimelineItems.findIndex(
-        (timelineItem) => timelineItem.processStepStatus === StepStatus.RUNNING,
-    );
+  const reversedTimelineItems = [...timelineItems].reverse();
+  const reversedIndexOfCurrentStep = reversedTimelineItems.findIndex(
+    (timelineItem) => timelineItem.processStepStatus === StepStatus.RUNNING,
+  );
 
-    if (reversedIndexOfCurrentStep !== -1) {
-        return timelineItems.length - reversedIndexOfCurrentStep - 1;
-    }
+  if (reversedIndexOfCurrentStep !== -1) {
+    return timelineItems.length - reversedIndexOfCurrentStep - 1;
+  }
 
-    const indexOfFirstPending = timelineItems.findIndex(
-        (timelineItem) => timelineItem.processStepStatus === StepStatus.PENDING,
-    );
+  const indexOfFirstPending = timelineItems.findIndex(
+    (timelineItem) => timelineItem.processStepStatus === StepStatus.PENDING,
+  );
 
-    if (indexOfFirstPending !== -1) {
-        return indexOfFirstPending - 1;
-    }
+  if (indexOfFirstPending !== -1) {
+    return indexOfFirstPending - 1;
+  }
 
-    return timelineItems.length - 1;
+  return timelineItems.length - 1;
 };