3923 client - Add tests

Author: ivicac

client/src/ee/shared/queries/embedded/tests/workflowExecutions.queries.test.ts

@@ -0,0 +1,60 @@
+import {describe, expect, it} from 'vitest';
+
+import {WorkflowExecutionKeys} from '../workflowExecutions.queries';
+
+describe('workflowExecutions.queries (embedded)', () => {
+    describe('WorkflowExecutionKeys', () => {
+        it('generates correct base key for workflow executions', () => {
+            expect(WorkflowExecutionKeys.workflowExecutions).toEqual(['integrationWorkflowExecutions']);
+        });
+
+        it('generates correct key for workflow execution by id', () => {
+            const result = WorkflowExecutionKeys.workflowExecution(123);
+
+            expect(result).toEqual(['integrationWorkflowExecutions', 123]);
+        });
+
+        it('generates correct key for filtered workflow executions', () => {
+            const request = {
+                integrationId: 1,
+                pageNumber: 0,
+                pageSize: 10,
+            };
+
+            const result = WorkflowExecutionKeys.filteredWorkflowExecutions(request);
+
+            expect(result).toEqual(['integrationWorkflowExecutions', request]);
+        });
+
+        it('generates unique keys for different workflow execution ids', () => {
+            const key1 = WorkflowExecutionKeys.workflowExecution(1);
+            const key2 = WorkflowExecutionKeys.workflowExecution(2);
+
+            expect(key1).not.toEqual(key2);
+            expect(key1).toEqual(['integrationWorkflowExecutions', 1]);
+            expect(key2).toEqual(['integrationWorkflowExecutions', 2]);
+        });
+
+        it('generates unique keys for different filter requests', () => {
+            const request1 = {integrationId: 1, pageNumber: 0};
+            const request2 = {integrationId: 2, pageNumber: 0};
+
+            const key1 = WorkflowExecutionKeys.filteredWorkflowExecutions(request1);
+            const key2 = WorkflowExecutionKeys.filteredWorkflowExecutions(request2);
+
+            expect(key1).not.toEqual(key2);
+        });
+
+        it('workflow execution key includes base workflow executions key', () => {
+            const executionKey = WorkflowExecutionKeys.workflowExecution(123);
+
+            expect(executionKey[0]).toBe(WorkflowExecutionKeys.workflowExecutions[0]);
+        });
+
+        it('filtered workflow executions key includes base workflow executions key', () => {
+            const filteredKey = WorkflowExecutionKeys.filteredWorkflowExecutions({pageNumber: 0});
+
+            expect(filteredKey[0]).toBe(WorkflowExecutionKeys.workflowExecutions[0]);
+        });
+    });
+});

client/src/shared/components/workflow-executions/tests/WorkflowTaskExecutionItem.test.tsx

@@ -0,0 +1,112 @@
+import {TaskExecution} from '@/shared/middleware/platform/workflow/execution';
+import {render, screen} from '@/shared/util/test-utils';
+import {describe, expect, it} from 'vitest';
+
+import WorkflowTaskExecutionItem from '../WorkflowTaskExecutionItem';
+
+function createTaskExecution(overrides: Partial<TaskExecution> = {}): TaskExecution {
+    return {
+        priority: 1,
+        startDate: new Date('2024-01-01T10:00:00'),
+        status: 'COMPLETED',
+        title: 'Test Task',
+        workflowTask: {
+            label: 'Test Task Label',
+            name: 'testTask',
+            type: 'test/v1/testAction',
+        },
+        ...overrides,
+    } as TaskExecution;
+}
+
+describe('WorkflowTaskExecutionItem', () => {
+    describe('status icon integration', () => {
+        it('should render status icon from utility for completed task', () => {
+            const taskExecution = createTaskExecution({
+                endDate: new Date('2024-01-01T10:00:05'),
+                status: 'COMPLETED',
+            });
+
+            const {container} = render(<WorkflowTaskExecutionItem taskExecution={taskExecution} />);
+
+            expect(container.querySelector('.text-success')).toBeInTheDocument();
+        });
+
+        it('should render status icon from utility for started task', () => {
+            const taskExecution = createTaskExecution({
+                endDate: undefined,
+                status: 'STARTED',
+            });
+
+            const {container} = render(<WorkflowTaskExecutionItem taskExecution={taskExecution} />);
+
+            expect(container.querySelector('.animate-spin.text-primary')).toBeInTheDocument();
+        });
+
+        it('should render status icon from utility for failed task', () => {
+            const taskExecution = createTaskExecution({
+                endDate: new Date('2024-01-01T10:00:05'),
+                status: 'FAILED',
+            });
+
+            const {container} = render(<WorkflowTaskExecutionItem taskExecution={taskExecution} />);
+
+            expect(container.querySelector('.text-destructive')).toBeInTheDocument();
+        });
+    });
+
+    describe('task details display', () => {
+        it('should display task label from workflowTask', () => {
+            const taskExecution = createTaskExecution({
+                title: 'Fallback Title',
+                workflowTask: {
+                    label: 'Task Label',
+                    name: 'taskName',
+                    type: 'test/v1/action',
+                },
+            });
+
+            render(<WorkflowTaskExecutionItem taskExecution={taskExecution} />);
+
+            expect(screen.getByText('Task Label')).toBeInTheDocument();
+        });
+
+        it('should display title when workflowTask label is not available', () => {
+            const taskExecution = createTaskExecution({
+                title: 'Fallback Title',
+                workflowTask: {
+                    name: 'taskName',
+                    type: 'test/v1/action',
+                },
+            });
+
+            render(<WorkflowTaskExecutionItem taskExecution={taskExecution} />);
+
+            expect(screen.getByText('Fallback Title')).toBeInTheDocument();
+        });
+
+        it('should display duration when start and end dates are provided', () => {
+            const taskExecution = createTaskExecution({
+                endDate: new Date('2024-01-01T10:00:05'),
+                startDate: new Date('2024-01-01T10:00:00'),
+                status: 'COMPLETED',
+            });
+
+            render(<WorkflowTaskExecutionItem taskExecution={taskExecution} />);
+
+            expect(screen.getByText('5000ms')).toBeInTheDocument();
+        });
+
+        it('should display 0ms when end date is not available', () => {
+            const taskExecution = createTaskExecution({
+                endDate: undefined,
+                startDate: new Date('2024-01-01T10:00:00'),
+                status: 'STARTED',
+            });
+
+            render(<WorkflowTaskExecutionItem taskExecution={taskExecution} />);
+
+            expect(screen.getByText('0ms')).toBeInTheDocument();
+        });
+    });
+});

client/src/shared/components/workflow-executions/tests/WorkflowTriggerExecutionItem.test.tsx

@@ -0,0 +1,112 @@
+import {TriggerExecution} from '@/shared/middleware/automation/workflow/execution';
+import {render, screen} from '@/shared/util/test-utils';
+import {describe, expect, it} from 'vitest';
+
+import WorkflowTriggerExecutionItem from '../WorkflowTriggerExecutionItem';
+
+function createTriggerExecution(overrides: Partial<TriggerExecution> = {}): TriggerExecution {
+    return {
+        priority: 1,
+        startDate: new Date('2024-01-01T10:00:00'),
+        status: 'COMPLETED',
+        title: 'Test Trigger',
+        workflowTrigger: {
+            label: 'Test Trigger Label',
+            name: 'testTrigger',
+            type: 'test/v1/testTrigger',
+        },
+        ...overrides,
+    } as TriggerExecution;
+}
+
+describe('WorkflowTriggerExecutionItem', () => {
+    describe('status icon integration', () => {
+        it('should render status icon from utility for completed trigger', () => {
+            const triggerExecution = createTriggerExecution({
+                endDate: new Date('2024-01-01T10:00:05'),
+                status: 'COMPLETED',
+            });
+
+            const {container} = render(<WorkflowTriggerExecutionItem triggerExecution={triggerExecution} />);
+
+            expect(container.querySelector('.text-success')).toBeInTheDocument();
+        });
+
+        it('should render status icon from utility for started trigger', () => {
+            const triggerExecution = createTriggerExecution({
+                endDate: undefined,
+                status: 'STARTED',
+            });
+
+            const {container} = render(<WorkflowTriggerExecutionItem triggerExecution={triggerExecution} />);
+
+            expect(container.querySelector('.animate-spin.text-primary')).toBeInTheDocument();
+        });
+
+        it('should render status icon from utility for failed trigger', () => {
+            const triggerExecution = createTriggerExecution({
+                endDate: new Date('2024-01-01T10:00:05'),
+                status: 'FAILED',
+            });
+
+            const {container} = render(<WorkflowTriggerExecutionItem triggerExecution={triggerExecution} />);
+
+            expect(container.querySelector('.text-destructive')).toBeInTheDocument();
+        });
+    });
+
+    describe('trigger details display', () => {
+        it('should display trigger label from workflowTrigger', () => {
+            const triggerExecution = createTriggerExecution({
+                title: 'Fallback Title',
+                workflowTrigger: {
+                    label: 'Trigger Label',
+                    name: 'triggerName',
+                    type: 'test/v1/trigger',
+                },
+            });
+
+            render(<WorkflowTriggerExecutionItem triggerExecution={triggerExecution} />);
+
+            expect(screen.getByText('Trigger Label')).toBeInTheDocument();
+        });
+
+        it('should display title when workflowTrigger label is not available', () => {
+            const triggerExecution = createTriggerExecution({
+                title: 'Fallback Title',
+                workflowTrigger: {
+                    name: 'triggerName',
+                    type: 'test/v1/trigger',
+                },
+            });
+
+            render(<WorkflowTriggerExecutionItem triggerExecution={triggerExecution} />);
+
+            expect(screen.getByText('Fallback Title')).toBeInTheDocument();
+        });
+
+        it('should display duration when start and end dates are provided', () => {
+            const triggerExecution = createTriggerExecution({
+                endDate: new Date('2024-01-01T10:00:05'),
+                startDate: new Date('2024-01-01T10:00:00'),
+                status: 'COMPLETED',
+            });
+
+            render(<WorkflowTriggerExecutionItem triggerExecution={triggerExecution} />);
+
+            expect(screen.getByText('5000ms')).toBeInTheDocument();
+        });
+
+        it('should display 0ms when end date is not available', () => {
+            const triggerExecution = createTriggerExecution({
+                endDate: undefined,
+                startDate: new Date('2024-01-01T10:00:00'),
+                status: 'STARTED',
+            });
+
+            render(<WorkflowTriggerExecutionItem triggerExecution={triggerExecution} />);
+
+            expect(screen.getByText('0ms')).toBeInTheDocument();
+        });
+    });
+});