From 1ec3f0f65ad45434748c2ae4a55a5bcb3a478616 Mon Sep 17 00:00:00 2001 From: Deepika Mahindroo Date: Fri, 15 Mar 2024 15:59:10 +0530 Subject: [PATCH] test(core): add test cases add test cases for coverage GH-78 --- .../lib/builder/group/group.component.spec.ts | 357 ++++++++++++++++++ .../lib/builder/node/node.component.spec.ts | 41 ++ .../tooltip-render.component.spec.ts | 30 ++ .../element/abstract-element.class.spec.ts | 71 ++++ .../nodes/abstract-base-group.class.spec.ts | 61 +++ .../nodes/abstract-list-prompt.class.spec.ts | 31 ++ .../nodes/abstract-list-prompt.class.ts | 4 +- .../nodes/abstract-prompt.class.spec.ts | 54 +++ .../abstract-workflow-action.class.spec.ts | 32 ++ .../abstract-builder-service.class.spec.ts | 72 ++++ .../classes/state/state-node.class.spec.ts | 34 ++ .../src/lib/classes/state/state.class.spec.ts | 53 +++ .../src/lib/classes/state/state.class.ts | 3 + .../statement/statement-node.class.spec.ts | 24 ++ .../classes/statement/statement.class.spec.ts | 27 ++ .../src/lib/errors/base.error.spec.ts | 32 ++ .../interfaces/date-struct.interface.spec.ts | 28 ++ .../element-input.interface.spec.ts | 51 +++ .../link-strategy.interface.spec.ts | 51 +++ .../src/lib/pipes/localization.pipe.spec.ts | 33 ++ .../lib/services/bpmn/element.service.spec.ts | 34 ++ .../bpmn/elements/base/end.element.spec.ts | 46 +++ .../base/start-on-interval.element.spec.ts | 44 +++ .../bpmn/elements/base/start.element.spec.ts | 50 +++ .../elements/gateways/gateway.element.spec.ts | 71 ++++ .../gateways/or-gateway.element.spec.ts | 73 ++++ .../process-properties.element.spec.ts | 57 +++ .../elements/process/process.element.spec.ts | 48 +++ .../tasks/change-column-value.task.spec.ts | 72 ++++ .../elements/tasks/read-column.task.spec.ts | 55 +++ .../elements/tasks/send-email.task.spec.ts | 41 ++ .../tasks/trigger-on-add-item.task.spec.ts | 65 ++++ .../tasks/trigger-on-interval.task.spec.ts | 59 +++ .../trigger-when-column-changes.task.spec.ts | 67 ++++ .../lib/services/bpmn/node.service.spec.ts | 51 +++ .../create/basic-create.strategy.spec.ts | 34 ++ .../basic-interval-create.strategy.spec.ts | 60 +++ .../create/gateway-create.strategy.spec.ts | 42 +++ .../create/task-create.strategy.spec.ts | 33 ++ .../actions/changecolumn.action.spec.ts | 41 ++ .../actions/readcolumn.action.spec.ts | 41 ++ .../statement/actions/sendmail.action.spec.ts | 43 +++ .../statement/events/onadditem.event.spec.ts | 40 ++ .../statement/events/onchange.event.spec.ts | 47 +++ .../statement/events/oninterval.event.spec.ts | 41 ++ .../statement/events/onvalue.event.spec.ts | 42 +++ .../statement/groups/and.group.spec.ts | 34 ++ .../statement/groups/or.group.spec.ts | 33 ++ .../statement/inputs/column.input.spec.ts | 44 +++ .../statement/inputs/condition.input.spec.ts | 59 +++ .../statement/inputs/email.input.spec.ts | 117 ++++++ .../statement/inputs/interval.input.spec.ts | 43 +++ .../statement/inputs/tocolumn.input.spec.ts | 27 ++ .../statement/inputs/tovalue.input.spec.ts | 23 ++ .../inputs/triggercolumn.input.spec.ts | 28 ++ .../statement/inputs/value.input.spec.ts | 61 +++ .../statement/inputs/valuetype.input.spec.ts | 45 +++ .../src/lib/types/event.types.spec.ts | 67 ++++ projects/workflows-element/package.json | 3 +- 59 files changed, 2966 insertions(+), 4 deletions(-) create mode 100644 projects/workflows-creator/src/lib/builder/group/group.component.spec.ts create mode 100644 projects/workflows-creator/src/lib/builder/node/node.component.spec.ts create mode 100644 projects/workflows-creator/src/lib/builder/tooltip-render/tooltip-render.component.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/element/abstract-element.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/nodes/abstract-base-group.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/nodes/abstract-list-prompt.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/nodes/abstract-prompt.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/nodes/abstract-workflow-action.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/services/abstract-builder-service.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/state/state-node.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/state/state.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/statement/statement-node.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/classes/statement/statement.class.spec.ts create mode 100644 projects/workflows-creator/src/lib/errors/base.error.spec.ts create mode 100644 projects/workflows-creator/src/lib/interfaces/date-struct.interface.spec.ts create mode 100644 projects/workflows-creator/src/lib/interfaces/element-input.interface.spec.ts create mode 100644 projects/workflows-creator/src/lib/interfaces/link-strategy.interface.spec.ts create mode 100644 projects/workflows-creator/src/lib/pipes/localization.pipe.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/element.service.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/base/end.element.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/base/start-on-interval.element.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/base/start.element.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/gateways/gateway.element.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/gateways/or-gateway.element.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/process/process-properties.element.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/process/process.element.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/tasks/change-column-value.task.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/tasks/read-column.task.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/tasks/send-email.task.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-on-add-item.task.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-on-interval.task.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-when-column-changes.task.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/node.service.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/strategies/create/basic-create.strategy.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/strategies/create/basic-interval-create.strategy.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/strategies/create/gateway-create.strategy.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/bpmn/strategies/create/task-create.strategy.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/actions/changecolumn.action.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/actions/readcolumn.action.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/actions/sendmail.action.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/events/onadditem.event.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/events/onchange.event.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/events/oninterval.event.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/events/onvalue.event.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/groups/and.group.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/groups/or.group.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/column.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/condition.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/email.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/interval.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/tocolumn.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/tovalue.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/triggercolumn.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/value.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/services/statement/inputs/valuetype.input.spec.ts create mode 100644 projects/workflows-creator/src/lib/types/event.types.spec.ts diff --git a/projects/workflows-creator/src/lib/builder/group/group.component.spec.ts b/projects/workflows-creator/src/lib/builder/group/group.component.spec.ts new file mode 100644 index 0000000..0eaa869 --- /dev/null +++ b/projects/workflows-creator/src/lib/builder/group/group.component.spec.ts @@ -0,0 +1,357 @@ +import {ComponentFixture, TestBed} from '@angular/core/testing'; +import {NgxPopperjsModule, NgxPopperjsContentComponent} from 'ngx-popperjs'; +import { + NodeService, + AbstractBaseGroup, + WorkflowPrompt, + State, + WorkflowEvent, +} from '../../classes'; +import {NodeTypes, ValueTypes, InputTypes} from '../../enum'; +import {InvalidEntityError} from '../../errors'; +import BPMNModdle from 'bpmn-moddle'; +import {LocalizationPipe} from '../../pipes/localization.pipe'; +import { + AndGroup, + BpmnNodesService, + ChangeColumnValueAction, + LocalizationProviderService, + OnAddItemEvent, + OnChangeEvent, + OnIntervalEvent, + OnValueEvent, + OrGroup, + SendEmailAction, + ValueInput, +} from '../../services'; +import {GroupComponent} from './group.component'; +import {TooltipRenderComponent} from '../tooltip-render/tooltip-render.component'; +import {BPMN_NODES} from '../../const'; +import {NodeComponent} from '../node/node.component'; +import { + ElementRef, + Renderer2, + ViewContainerRef, + ChangeDetectorRef, +} from '@angular/core'; +import {AllowedValues, RecordOfAnyType} from '../../types'; +import {popper} from '@popperjs/core'; + +describe('GroupComponent', () => { + let component: GroupComponent; + let fixture: ComponentFixture>; + const mockEvents: any = [ + { + id: 'event1', + trigger: true, + type: 'someType' /* Add other properties as needed */, + }, + { + id: 'event2', + trigger: false, + type: 'someOtherType' /* Add other properties as needed */, + }, + ]; + + const mockActions: any = [ + { + id: 'action1', + trigger: true, + type: 'someActionType' /* Add other properties as needed */, + }, + { + id: 'action2', + trigger: false, + type: 'anotherActionType' /* Add other properties as needed */, + }, + ]; + const eventStub = new OnChangeEvent({}, '', '', ''); + let nodeServiceSpy: any; + beforeEach(async () => { + const nodeServiceMock = { + getActions: () => [], // Implement a mock method to return an empty array or mock data + getEvents: () => [], + getNodeByName: eventStub, + // getIdentifier: () => 'OnChangeEvent', + + getGroupByName: () => {}, + getGroups: () => [], + mapInputs: () => [], + }; + nodeServiceSpy = jasmine.createSpyObj('NodeService', nodeServiceMock); + nodeServiceSpy.getEvents.and.returnValue(mockEvents); + nodeServiceSpy.getActions.and.returnValue(mockActions); + + await TestBed.configureTestingModule({ + declarations: [ + GroupComponent, + NodeComponent, + TooltipRenderComponent, + LocalizationPipe, + ], + providers: [ + {provide: NodeService, useValue: nodeServiceSpy}, + LocalizationProviderService, + LocalizationPipe, + ], + imports: [NgxPopperjsModule], + }).compileComponents(); + }); + + beforeEach(() => { + fixture = TestBed.createComponent(GroupComponent); + component = fixture.componentInstance; + component.group = new AndGroup({}, '', NodeTypes.EVENT, false); + component.isLast = false; + component.isFirst = false; + component.eventGroups = []; + component.nodeType = NodeTypes.ACTION; + component.nodeType = NodeTypes.EVENT; + component.allColumns = []; + + fixture.detectChanges(); + }); + + it('should create', () => { + expect(component).toBeTruthy(); + }); + + it('should initialize events and actions properties', () => { + component.ngOnInit(); + expect(component.events).toEqual(mockEvents); + expect(component.actions).toEqual(mockActions); + }); + + it('should set the templateMap', () => { + component.ngAfterViewInit(); + + expect(component.templateMap).toBeDefined(); + }); + + it('should emit the remove event', () => { + spyOn(component.remove, 'emit'); + component.removeClick(); + expect(component.remove.emit).toHaveBeenCalledWith(true); + }); + + it('should emit the add event', () => { + spyOn(component.add, 'emit'); + component.addClick(); + expect(component.add.emit).toHaveBeenCalledWith(true); + }); + + it('should add the node to the group', () => { + component.onNodeAdd(eventStub, 'groupType', 'groupId', 'id'); + expect(component.group.children.length).toBeGreaterThan(0); + }); + + it('should throw an error if the node type is neither EVENT nor ACTION', () => { + const node = eventStub; + nodeServiceSpy.getNodeByName.and.throwError(''); + expect(() => + component.onNodeAdd(node, 'groupType', 'groupId', 'id'), + ).toThrowError(''); + }); + + it('should remove the node at the given index from the group', () => { + component.group.children.push({ + node: eventStub, + inputs: [], + }); + component.onNodeRemove(0); + expect(component.group.children.length).toEqual(0); + }); + + it('should emit the eventRemoved event', () => { + spyOn(component.eventRemoved, 'emit'); + component.onNodeRemove(0); + expect(component.eventRemoved.emit).toHaveBeenCalled(); + }); + + it('should return a function that hides the popper and emits the value', () => { + const popper = {hide: () => {}} as NgxPopperjsContentComponent; + const callback = component.createCallback( + { + node: eventStub, + inputs: [], + }, + new ValueInput(), + popper, + ); + spyOn(popper, 'hide'); + + callback(); + expect(popper.hide).toHaveBeenCalled(); + }); + + // Create a mock class for NgxPopperjsContentComponent + + // Create a spy object to mock the methods of NgxPopperjsContentComponent + const popperSpy = jasmine.createSpyObj('NgxPopperjsContentComponent', [ + 'show', + 'hide', + ]); + + it('should hide the previous popper and show the current popper', () => { + // Arrange + const event = new MouseEvent('click'); + component.prevPopperRef = popperSpy; // Assign the spy object to prevPopperRef + + // Act + component.onPoperClick(event, popperSpy); + + // Assert + expect(component.prevPopperRef.hide).toHaveBeenCalled(); + expect(popperSpy.show).toHaveBeenCalled(); // Spy on the show method of popperSpy + }); + + it('should set the tooltipText, showsTooltip, topPosition, and leftPosition properties', () => { + const event = new MouseEvent('click'); + component.showTooltip( + event, + { + node: eventStub, + inputs: [], + }, + new ValueInput(), + ); + expect(component.tooltipText).toBe('Select a column first'); + expect(component.showsTooltip).toBe(true); + expect(component.topPosition).toBe(event.clientY + 10); + expect(component.leftPosition).toBe(event.clientX); + }); + + it('should reset the showsTooltip, topPosition, and leftPosition properties', () => { + component.hideTooltip(); + expect(component.showsTooltip).toBe(false); + expect(component.topPosition).toBeNull(); + expect(component.leftPosition).toBeNull(); + }); + + it('should return a function that hides the previous popper', () => { + const mockElementRef = {} as ElementRef; + const mockRenderer = {} as Renderer2; + const mockViewContainerRef = {} as ViewContainerRef; + const mockChangeDetectorRef = {} as ChangeDetectorRef; + + const mockNgxPopperjsContentComponent = jasmine.createSpyObj( + 'NgxPopperjsContentComponent', + ['hide'], + ); + + component.prevPopperRef = mockNgxPopperjsContentComponent; + + const hidePopperFn = component.hidePopper(); + hidePopperFn(); + + expect(component.prevPopperRef.hide).toHaveBeenCalled(); + }); + + it('should set enableActionIcon to false if the node type is OnChangeEvent and the value is ValueTypes.AnyValue', () => { + const element = {node: eventStub, inputs: []}; + const input = new ValueInput(); + element.node.type = NodeTypes.EVENT; + element.node.getIdentifier = () => 'OnChangeEvent'; + element.node.state.change('valueInputType', 'valueInputType'); + spyOn(component.itemChanged, 'emit'); + component.addValue(element, input, ValueTypes.AnyValue); + expect(component.enableActionIcon).toBe(false); + expect(component.itemChanged.emit).toHaveBeenCalledWith({ + field: input.getIdentifier(), + value: ValueTypes.AnyValue, + element: element, + }); + }); + + it('should set enableActionIcon to true if the node type is OnChangeEvent and the value is not ValueTypes.AnyValue', () => { + const element = {node: eventStub, inputs: []}; + const input = new ValueInput(); + + element.node.type = NodeTypes.EVENT; + element.node.getIdentifier = () => 'OnChangeEvent'; + + element.node.state.change('valueInputType', 'valueInputType'); + spyOn(component.itemChanged, 'emit'); + component.addValue(element, input, 'value'); + expect(component.enableActionIcon).toBe(true); + expect(component.itemChanged.emit).toHaveBeenCalledWith({ + field: input.getIdentifier(), + value: 'value', + element: element, + }); + }); + + it('should set the selectedItems to the list of selected items', () => { + // Arrange + const list = [{id: '1'}, {id: '2'}, {id: '3'}]; + + // Act + component.onSelectAll(list as any[]); // Casting to any[] to resolve type issue + + // Assert + expect(component.selectedItems.length).toBe(3); + }); + + it('should prevent the default action if the key is not a digit or backspace/delete', () => { + // Arrange + const event = new KeyboardEvent('keypress', {keyCode: 65}); + spyOn(event, 'preventDefault'); + const targetWithMockedValue = {value: 'test'} as EventTarget & { + value: string; + }; + spyOnProperty(event, 'target', 'get').and.returnValue( + targetWithMockedValue, + ); + + // Act + component.handleKeyPress(event); + + // Assert + expect(event.preventDefault).toHaveBeenCalled(); + }); + it('should prevent the default action if the input value is not a valid number', () => { + // Arrange + const event = new KeyboardEvent('keypress', {keyCode: 48}); + spyOn(event, 'preventDefault'); + const targetWithMockedValue = {value: 'test'} as EventTarget & { + value: string; + }; + spyOnProperty(event, 'target', 'get').and.returnValue( + targetWithMockedValue, + ); + + // Act + component.handleKeyPress(event); + + // Assert + expect(event.preventDefault).toHaveBeenCalled(); + }); + it('should not prevent the default action if the key is a digit or backspace/delete and the input value is a valid number', () => { + // Arrange + const event1 = new KeyboardEvent('keypress', {keyCode: 48}); + const event2 = new KeyboardEvent('keypress', {keyCode: 8}); + const targetWithMockedValue1 = {value: '0'} as EventTarget & { + value: string; + }; + const targetWithMockedValue2 = {value: 'test'} as EventTarget & { + value: string; + }; + spyOnProperty(event1, 'target', 'get').and.returnValue( + targetWithMockedValue1, + ); + spyOnProperty(event2, 'target', 'get').and.returnValue( + targetWithMockedValue2, + ); + + spyOn(event1, 'preventDefault'); + spyOn(event2, 'preventDefault'); + + // Act + component.handleKeyPress(event1); + component.handleKeyPress(event2); + + // Assert + expect(event1.preventDefault).not.toHaveBeenCalled(); + expect(event2.preventDefault).toHaveBeenCalled(); + }); +}); diff --git a/projects/workflows-creator/src/lib/builder/node/node.component.spec.ts b/projects/workflows-creator/src/lib/builder/node/node.component.spec.ts new file mode 100644 index 0000000..766ac38 --- /dev/null +++ b/projects/workflows-creator/src/lib/builder/node/node.component.spec.ts @@ -0,0 +1,41 @@ +import { ComponentFixture, TestBed } from '@angular/core/testing'; +import { Component, EventEmitter, Input, Output, TemplateRef } from '@angular/core'; +import { NgxPopperjsContentComponent } from 'ngx-popperjs'; +import { NodeComponent } from './node.component'; + +describe('NodeComponent', () => { + let component: NodeComponent; + let fixture: ComponentFixture>; + + beforeEach(async () => { + await TestBed.configureTestingModule({ + declarations: [NodeComponent], + }).compileComponents(); + }); + + beforeEach(() => { + fixture = TestBed.createComponent(NodeComponent); + component = fixture.componentInstance; + fixture.detectChanges(); + }); + + it('should create', () => { + expect(component).toBeTruthy(); + }); + + describe('removeClick', () => { + it('should emit true when removeClick is called', () => { + spyOn(component.remove, 'emit'); + component.removeClick(); + expect(component.remove.emit).toHaveBeenCalledWith(true); + }); + }); + + describe('addClick', () => { + it('should emit true when addClick is called', () => { + spyOn(component.add, 'emit'); + component.addClick(); + expect(component.add.emit).toHaveBeenCalledWith(true); + }); + }); +}); \ No newline at end of file diff --git a/projects/workflows-creator/src/lib/builder/tooltip-render/tooltip-render.component.spec.ts b/projects/workflows-creator/src/lib/builder/tooltip-render/tooltip-render.component.spec.ts new file mode 100644 index 0000000..be50ed1 --- /dev/null +++ b/projects/workflows-creator/src/lib/builder/tooltip-render/tooltip-render.component.spec.ts @@ -0,0 +1,30 @@ +import { ComponentFixture, TestBed } from '@angular/core/testing'; +import { TooltipRenderComponent } from './tooltip-render.component'; + +describe('TooltipRenderComponent', () => { + let component: TooltipRenderComponent; + let fixture: ComponentFixture; + + beforeEach(async () => { + await TestBed.configureTestingModule({ + declarations: [TooltipRenderComponent], + }).compileComponents(); + }); + + beforeEach(() => { + fixture = TestBed.createComponent(TooltipRenderComponent); + component = fixture.componentInstance; + fixture.detectChanges(); + }); + + it('should create', () => { + expect(component).toBeTruthy(); + }); + + it('should have default values for inputs', () => { + expect(component.showsTooltip).toBeTrue(); + expect(component.tooltipText).toBe('Default tooltip text'); + expect(component.topPosition).toBe(215); + expect(component.leftPosition).toBe(400); + }); +}); \ No newline at end of file diff --git a/projects/workflows-creator/src/lib/classes/element/abstract-element.class.spec.ts b/projects/workflows-creator/src/lib/classes/element/abstract-element.class.spec.ts new file mode 100644 index 0000000..786572a --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/element/abstract-element.class.spec.ts @@ -0,0 +1,71 @@ +import {CreateStrategy} from '../../interfaces/create-strategy.interface'; +import {LinkStrategy} from '../../interfaces/link-strategy.interface'; +import {StatementNode} from '../statement/statement-node.class'; +import {WorkflowElement} from './abstract-element.class'; + +class TestWorkflowElement extends WorkflowElement { + tag = 'TestTag'; + attributes = {}; + name = 'TestName'; + inputs = {name: 'TestInput', fields: {}}; + outputs = 'TestOutput'; + protected creator: CreateStrategy; + protected linker: LinkStrategy; + + constructor() { + super(); + this.creator = { + execute: jasmine.createSpy('creatorExecute'), + } as unknown as CreateStrategy; + this.linker = { + execute: jasmine.createSpy('linkerExecute'), + } as unknown as LinkStrategy; + } + + getIdentifier(): string { + return 'TestIdentifier'; + } +} + +describe('WorkflowElement', () => { + let testWorkflowElement: TestWorkflowElement; + + beforeEach(() => { + testWorkflowElement = new TestWorkflowElement(); + }); + + it('should create', () => { + expect(testWorkflowElement).toBeTruthy(); + }); + + describe('create', () => { + it('should call creator.execute with correct arguments', () => { + // Arrange + const node = {} as StatementNode; + const attrs = {}; + + // Act + testWorkflowElement.create(node, attrs); + }); + }); + + describe('link', () => { + it('should call linker.execute with correct arguments', () => { + // Arrange + const node = {} as StatementNode; + + // Act + testWorkflowElement.link(node); + }); + }); + + describe('getIdentifier', () => { + it('should return the identifier', () => { + // Act + const identifier = testWorkflowElement.getIdentifier(); + + // Assert + expect(identifier).toBe('TestIdentifier'); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/nodes/abstract-base-group.class.spec.ts b/projects/workflows-creator/src/lib/classes/nodes/abstract-base-group.class.spec.ts new file mode 100644 index 0000000..50fc353 --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/nodes/abstract-base-group.class.spec.ts @@ -0,0 +1,61 @@ +import {NodeTypes} from '../../enum'; +import {NodeWithInput} from '../../types'; +import {AbstractBaseGroup} from './abstract-base-group.class'; + +class MockBaseGroup extends AbstractBaseGroup { + type = NodeTypes.GROUP; + nodeType = NodeTypes.GROUP; + trigger = false; + name = 'MockGroup'; + children: NodeWithInput[] = []; + isElseGroup = false; + id = 'mockGroupId'; + + getIdentifier(): string { + return 'MockGroupIdentifier'; + } +} + +describe('AbstractBaseGroup', () => { + let mockBaseGroup: MockBaseGroup; + + beforeEach(() => { + mockBaseGroup = new MockBaseGroup(); + }); + + it('should create', () => { + expect(mockBaseGroup).toBeTruthy(); + }); + + it('should have correct type', () => { + expect(mockBaseGroup.type).toBe(NodeTypes.GROUP); + }); + + it('should have correct nodeType', () => { + expect(mockBaseGroup.nodeType).toBe(NodeTypes.GROUP); + }); + + it('should have correct trigger value', () => { + expect(mockBaseGroup.trigger).toBe(false); + }); + + it('should have correct name', () => { + expect(mockBaseGroup.name).toBe('MockGroup'); + }); + + it('should have an empty children array', () => { + expect(mockBaseGroup.children).toEqual([]); + }); + + it('should have correct isElseGroup value', () => { + expect(mockBaseGroup.isElseGroup).toBe(false); + }); + + it('should have correct id', () => { + expect(mockBaseGroup.id).toBe('mockGroupId'); + }); + + it('should return correct identifier', () => { + expect(mockBaseGroup.getIdentifier()).toBe('MockGroupIdentifier'); + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/nodes/abstract-list-prompt.class.spec.ts b/projects/workflows-creator/src/lib/classes/nodes/abstract-list-prompt.class.spec.ts new file mode 100644 index 0000000..1a11124 --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/nodes/abstract-list-prompt.class.spec.ts @@ -0,0 +1,31 @@ +import {WorkflowListPrompt, isSelectInput} from './abstract-list-prompt.class'; +import {WorkflowPrompt} from './abstract-prompt.class'; + +describe('WorkflowListPrompt', () => { + let prompt: WorkflowListPrompt; + + beforeEach(() => { + prompt = jasmine.createSpyObj('WorkflowListPrompt', [ + 'listNameField', + 'listValueField', + 'isHidden', + 'options', + ]); + }); + + it('should have listNameField property', () => { + expect(prompt.listNameField).toBeDefined(); + }); + + it('should have listValueField property', () => { + expect(prompt.listValueField).toBeDefined(); + }); + + it('should have isHidden property', () => { + expect(prompt.isHidden).toBeDefined(); + }); + + it('should have options property', () => { + expect(prompt.options).toBeDefined(); + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/nodes/abstract-list-prompt.class.ts b/projects/workflows-creator/src/lib/classes/nodes/abstract-list-prompt.class.ts index 6c4e92c..eb78d19 100644 --- a/projects/workflows-creator/src/lib/classes/nodes/abstract-list-prompt.class.ts +++ b/projects/workflows-creator/src/lib/classes/nodes/abstract-list-prompt.class.ts @@ -1,4 +1,4 @@ -import {BpmnNode} from '../../types'; +import {BpmnNode, RecordOfAnyType} from '../../types'; import {State} from '../state/state.class'; import {WorkflowPrompt} from './abstract-prompt.class'; @@ -6,7 +6,7 @@ export abstract class WorkflowListPrompt extends WorkflowPrompt { abstract listNameField: string; abstract listValueField: string; abstract isHidden?: (node: BpmnNode) => boolean; - abstract options: (state: State) => R[]; + abstract options: (state: State) => R[]; } export function isSelectInput( diff --git a/projects/workflows-creator/src/lib/classes/nodes/abstract-prompt.class.spec.ts b/projects/workflows-creator/src/lib/classes/nodes/abstract-prompt.class.spec.ts new file mode 100644 index 0000000..d4f894e --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/nodes/abstract-prompt.class.spec.ts @@ -0,0 +1,54 @@ +import {State} from '../state'; +import moment from 'moment'; +import {InputTypes} from '../../enum'; +import {RecordOfAnyType} from '../../types'; +import {WorkflowPrompt} from './abstract-prompt.class'; + +// Mock implementation of WorkflowPrompt for testing purposes +class MockWorkflowPrompt extends WorkflowPrompt { + getValue(state: State): any { + throw new Error('Method not implemented.'); + } + suffix?: string | {state: string}; + prefix?: string | {state: string}; + typeFunction: (state: State) => InputTypes; + inputKey: string; + placeholder: string; + + // Implement abstract method + getIdentifier(): string { + return ''; + } +} + +describe('WorkflowPrompt', () => { + let prompt: MockWorkflowPrompt; + let state: State; + + beforeEach(() => { + prompt = new MockWorkflowPrompt(); + state = new State(); // Provide necessary state mock here + }); + + it('should set properties correctly', () => { + expect(prompt.suffix).toBeUndefined(); + expect(prompt.prefix).toBeUndefined(); + expect(prompt.inputKey).toBeUndefined(); + expect(prompt.placeholder).toBeUndefined(); + }); + + it('should format date onDateSelect', () => { + const mockDate = {year: 2022, month: 5, day: 15}; + const formattedDate = prompt['onDateSelect'](mockDate); + expect(formattedDate).toBe('15-05-2022'); + }); + + it('should format date onDateSelect', () => { + const mockDate = {year: 2022, month: 5, day: 15}; + const formattedDate = prompt['onDateSelect'](mockDate); + expect(formattedDate).toBe('15-05-2022'); + }); + it('should set value based on input type', () => { + // Mock implementation based on different input types + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/nodes/abstract-workflow-action.class.spec.ts b/projects/workflows-creator/src/lib/classes/nodes/abstract-workflow-action.class.spec.ts new file mode 100644 index 0000000..759b09c --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/nodes/abstract-workflow-action.class.spec.ts @@ -0,0 +1,32 @@ +import {NodeTypes} from '../../enum'; +import {WorkflowAction} from './abstract-workflow-action.class'; +import {AbstractWorkflowNode} from './abstract-workflow-node.class'; + +describe('WorkflowAction', () => { + let workflowAction: WorkflowAction; // You may replace 'any' with a specific type for your test + + beforeEach(() => { + class MockAbstractWorkflowNode extends AbstractWorkflowNode { + type = NodeTypes.ACTION; + statement: string; + prompts: string[]; + state: any; // Replace 'any' with your specific state type + name: string; + groupType: string; // Add groupType property + groupId: string; // Add groupId property + elements: any[]; + isElseAction: boolean; + getIdentifier(): string { + // Implement the getIdentifier method as needed + return `${this.groupId}_${this.name}`; + } + // Mock other necessary methods or properties of AbstractWorkflowNode + } + + workflowAction = new MockAbstractWorkflowNode(); // You need to implement MockWorkflowAction class + }); + + it('should have type set to NodeTypes.ACTION', () => { + expect(workflowAction.type).toEqual(NodeTypes.ACTION); + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/services/abstract-builder-service.class.spec.ts b/projects/workflows-creator/src/lib/classes/services/abstract-builder-service.class.spec.ts new file mode 100644 index 0000000..7eb49ef --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/services/abstract-builder-service.class.spec.ts @@ -0,0 +1,72 @@ +import {Statement} from '../statement/statement.class'; +import {AbstractBaseGroup} from '../nodes'; +import {BuilderService} from './abstract-builder-service.class'; +import {RecordOfAnyType} from '../../types'; + +// Mock implementation of BuilderService for testing +class MockBuilderService extends BuilderService< + E, + S +> { + async build( + statement: Statement, + elseStatement: Statement, + ): Promise { + // Mock implementation for build method + return 'mocked build result'; + } + + async restore(model: string): Promise<{ + actions: any[]; + elseActions: any[]; + events: any[]; + groups: AbstractBaseGroup[]; + state: any; + process: any; + }> { + // Mock implementation for restore method + return { + actions: [], + elseActions: [], + events: [], + groups: [], + state: {}, + process: {id: 'mocked-id'}, + }; + } +} + +describe('BuilderService', () => { + let builderService: BuilderService; + + beforeEach(() => { + // Create an instance of the BuilderService with the mock implementation + builderService = new MockBuilderService(); + }); + + it('should build and return a string', async () => { + // Create dummy statements + const statement: Statement = {} as any; + const elseStatement: Statement = {} as any; + + // Call the build method + const result = await builderService.build(statement, elseStatement); + + // Check if the result is a string + expect(typeof result).toBe('string'); + }); + + it('should restore and return the expected structure', async () => { + // Call the restore method + const restoredModel = await builderService.restore('mocked-model'); + + // Check if the returned object has the expected properties + expect(restoredModel.actions).toBeDefined(); + expect(restoredModel.elseActions).toBeDefined(); + expect(restoredModel.events).toBeDefined(); + expect(restoredModel.groups).toBeDefined(); + expect(restoredModel.state).toBeDefined(); + expect(restoredModel.process).toBeDefined(); + expect(restoredModel.process.id).toBe('mocked-id'); + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/state/state-node.class.spec.ts b/projects/workflows-creator/src/lib/classes/state/state-node.class.spec.ts new file mode 100644 index 0000000..6179c7c --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/state/state-node.class.spec.ts @@ -0,0 +1,34 @@ +import {StateNode} from './state-node.class'; + +describe('StateNode', () => { + let stateNode: StateNode; + + beforeEach(() => { + // Create a new StateNode instance before each test + stateNode = new StateNode({}); + }); + + it('should have a state property', () => { + expect(stateNode.state).toBeDefined(); + }); + + it('should have a next property', () => { + expect(stateNode.next).toBeUndefined(); + }); + + it('should have a prev property', () => { + expect(stateNode.prev).toBeUndefined(); + }); + + it('should set and get next state correctly', () => { + const nextStateNode = new StateNode({}); + stateNode.next = nextStateNode; + expect(stateNode.next).toBe(nextStateNode); + }); + + it('should set and get prev state correctly', () => { + const prevStateNode = new StateNode({}); + stateNode.prev = prevStateNode; + expect(stateNode.prev).toBe(prevStateNode); + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/state/state.class.spec.ts b/projects/workflows-creator/src/lib/classes/state/state.class.spec.ts new file mode 100644 index 0000000..4b56d65 --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/state/state.class.spec.ts @@ -0,0 +1,53 @@ +import {State} from './state.class'; + +describe('State', () => { + let state: State; + + beforeEach(() => { + // Create a new State instance before each test to ensure a clean state + state = new State(); + }); + + it('should have a current state', () => { + expect(state.get('someKey')).toBeUndefined(); + }); + + it('should change state correctly', () => { + state.change('someKey', 'someValue'); + expect(state.get('someKey')).toBe('someValue'); + }); + + it('should remove state correctly', () => { + state.change('someKey', 'someValue'); + state.remove('someKey'); + expect(state.get('someKey')).toBeUndefined(); + }); + + it('should restore state correctly', () => { + state.change('someKey', 'someValue'); + state.change('anotherKey', 'anotherValue'); + + const map = { + someKey: 'restoredValue', + anotherKey: 'anotherValue', + }; + + state.restore(map); + expect(state.get('someKey')).toBe('restoredValue'); + }); + + it('should undo and redo correctly', () => { + state.change('someKey', 'someValue'); + state.undo(); + expect(state.get('someKey')).toBeUndefined(); + state.redo(); + expect(state.get('someKey')).toBe('someValue'); + }); + + it('should get all keys and values correctly', () => { + state.change('key1', 'value1'); + state.change('key2', 'value2'); + expect(state.getAll()).toEqual({key1: 'value1', key2: 'value2'}); + expect(state.getAll(['key1'])).toEqual({key1: 'value1'}); + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/state/state.class.ts b/projects/workflows-creator/src/lib/classes/state/state.class.ts index 864f6ad..4e789a6 100644 --- a/projects/workflows-creator/src/lib/classes/state/state.class.ts +++ b/projects/workflows-creator/src/lib/classes/state/state.class.ts @@ -5,6 +5,9 @@ import {AllowedValues, RecordOfAnyType} from '../../types'; * The current state of a workflow node. */ export class State { + set(arg0: string, arg1: string) { + throw new Error('Method not implemented.'); + } private state = new Map(); private current: StateNode; diff --git a/projects/workflows-creator/src/lib/classes/statement/statement-node.class.spec.ts b/projects/workflows-creator/src/lib/classes/statement/statement-node.class.spec.ts new file mode 100644 index 0000000..f42da51 --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/statement/statement-node.class.spec.ts @@ -0,0 +1,24 @@ +import {WorkflowNode} from '../../types/base.types'; +import {WorkflowElement} from '../element/abstract-element.class'; +import {WorkflowPrompt} from '../nodes'; +import {StatementNode} from './statement-node.class'; + +describe('StatementNode', () => { + let statementNode: StatementNode; + let mockElement: WorkflowElement; + let mockNode: WorkflowNode; + + beforeEach(() => { + // Create mock instances for WorkflowElement and WorkflowNode + mockElement = {} as WorkflowElement; + mockNode = {} as WorkflowNode; + + // Create a new StatementNode instance before each test + statementNode = new StatementNode(mockElement, mockNode); + }); + + it('should set the tag property correctly', () => { + statementNode.setTag('someTag'); + expect(statementNode.tag).toBe('someTag'); + }); +}); diff --git a/projects/workflows-creator/src/lib/classes/statement/statement.class.spec.ts b/projects/workflows-creator/src/lib/classes/statement/statement.class.spec.ts new file mode 100644 index 0000000..1f6fecf --- /dev/null +++ b/projects/workflows-creator/src/lib/classes/statement/statement.class.spec.ts @@ -0,0 +1,27 @@ +import {Statement} from './statement.class'; + +describe('Statement', () => { + let statement: Statement; + let mockState: any; + + beforeEach(() => { + // Mock state object + mockState = {}; + + // Create a new Statement instance before each test + statement = new Statement(mockState); + }); + + it('should initialize head, tail, and state properties correctly', () => { + expect(statement.head).toEqual([]); + expect(statement.tail).toEqual([]); + expect(statement.state).toBe(mockState); + }); + + it('should set and get the processId property correctly', () => { + statement.processId = 'testId'; + expect(statement.processId).toBe('testId'); + }); + + // Add more test cases as needed for other methods +}); diff --git a/projects/workflows-creator/src/lib/errors/base.error.spec.ts b/projects/workflows-creator/src/lib/errors/base.error.spec.ts new file mode 100644 index 0000000..c223683 --- /dev/null +++ b/projects/workflows-creator/src/lib/errors/base.error.spec.ts @@ -0,0 +1,32 @@ +import {InvalidEntityError, NotProvided, MissingError} from './base.error'; + +describe('Error Classes', () => { + let invalidEntityError: InvalidEntityError; + let notProvidedError: NotProvided; + let missingError: MissingError; + + beforeEach(() => { + // Create instances of error classes before each test + invalidEntityError = new InvalidEntityError('testEntity'); + notProvidedError = new NotProvided('testName'); + missingError = new MissingError('testName'); + }); + + describe('InvalidEntityError', () => { + it('should have the correct message', () => { + expect(invalidEntityError.message).toBe('Invalid Entity: testEntity'); + }); + }); + + describe('NotProvided', () => { + it('should have the correct message', () => { + expect(notProvidedError.message).toBe('No provider found for testName'); + }); + }); + + describe('MissingError', () => { + it('should have the correct message', () => { + expect(missingError.message).toBe('Missing: testName'); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/interfaces/date-struct.interface.spec.ts b/projects/workflows-creator/src/lib/interfaces/date-struct.interface.spec.ts new file mode 100644 index 0000000..ef091fa --- /dev/null +++ b/projects/workflows-creator/src/lib/interfaces/date-struct.interface.spec.ts @@ -0,0 +1,28 @@ +import {DateStruct} from './date-struct.interface'; + +describe('DateStruct', () => { + let dateStruct: DateStruct; + + beforeEach(() => { + dateStruct = { + year: 2021, + month: 10, + day: 15, + }; + }); + + it('should have a year property', () => { + expect(dateStruct.year).toBeDefined(); + expect(typeof dateStruct.year).toBe('number'); + }); + + it('should have a month property', () => { + expect(dateStruct.month).toBeDefined(); + expect(typeof dateStruct.month).toBe('number'); + }); + + it('should have a day property', () => { + expect(dateStruct.day).toBeDefined(); + expect(typeof dateStruct.day).toBe('number'); + }); +}); diff --git a/projects/workflows-creator/src/lib/interfaces/element-input.interface.spec.ts b/projects/workflows-creator/src/lib/interfaces/element-input.interface.spec.ts new file mode 100644 index 0000000..c830c46 --- /dev/null +++ b/projects/workflows-creator/src/lib/interfaces/element-input.interface.spec.ts @@ -0,0 +1,51 @@ +import {State} from '@popperjs/core'; +import { + ParamMap, + isValueParam, + isFromParam, + isStateParam, + isFormattedParam, +} from './element-input.interface'; + +describe('isValueParam', () => { + it('should return true if the param is a ValueParam', () => { + const param: ParamMap = {value: 'test'}; + expect(isValueParam(param)).toBe(true); + }); + + it('should return false if the param is not a ValueParam', () => { + const param: ParamMap = {from: 'test'}; + expect(isValueParam(param)).toBe(false); + }); +}); + +describe('isFromParam', () => { + it('should return true if the param is a FromParam', () => { + const param: ParamMap = {from: 'test'}; + expect(isFromParam(param)).toBe(true); + }); + + it('should return false if the param is not a FromParam', () => { + const param: ParamMap = {value: 'test'}; + expect(isFromParam(param)).toBe(false); + }); +}); + +describe('isStateParam', () => { + it('should return true if the param is a StateParam', () => { + const param: ParamMap = {state: 'test'}; + expect(isStateParam(param)).toBe(true); + }); + + it('should return false if the param is not a StateParam', () => { + const param: ParamMap = {value: 'test'}; + expect(isStateParam(param)).toBe(false); + }); +}); + +describe('isFormattedParam', () => { + it('should return false if the param is not a FormattedParam', () => { + const param: ParamMap = {value: 'test'}; + expect(isFormattedParam(param)).toBe(false); + }); +}); diff --git a/projects/workflows-creator/src/lib/interfaces/link-strategy.interface.spec.ts b/projects/workflows-creator/src/lib/interfaces/link-strategy.interface.spec.ts new file mode 100644 index 0000000..323909b --- /dev/null +++ b/projects/workflows-creator/src/lib/interfaces/link-strategy.interface.spec.ts @@ -0,0 +1,51 @@ +import {StatementNode} from '../classes'; +import {WorkflowElement} from '../classes/element/abstract-element.class'; +import {LinkStrategy} from './link-strategy.interface'; + +// Mock class for WorkflowElement +class MockWorkflowElement extends WorkflowElement { + // Implement any abstract methods with mock implementations + tag: any; + attributes: any; + name: any; + inputs: any; + outputs: any; + creator: any; + linker: any; + getIdentifier(): any { + return ''; + } +} + +describe('LinkStrategy', () => { + let linkStrategy: LinkStrategy; + + beforeEach(() => { + // Initialize any necessary setup before each test + linkStrategy = { + // Mock implementation of the execute method + execute: ( + element: WorkflowElement, + node: StatementNode, + ): any[] => { + // Mock implementation, return an empty array for now + return []; + }, + }; + }); + + it('should implement the execute method', () => { + // Ensure that the execute method is implemented + expect(linkStrategy.execute).toBeDefined(); + }); + + it('execute method should return an empty array', () => { + // Test the behavior of the execute method + const mockElement = new MockWorkflowElement(); // Create a mock WorkflowElement + const mockNode = new StatementNode(mockElement); // Create a mock StatementNode + + // Call the execute method and expect it to return an empty array + const result = linkStrategy.execute(mockElement, mockNode); + expect(result).toEqual([]); + }); +}); diff --git a/projects/workflows-creator/src/lib/pipes/localization.pipe.spec.ts b/projects/workflows-creator/src/lib/pipes/localization.pipe.spec.ts new file mode 100644 index 0000000..bf211b6 --- /dev/null +++ b/projects/workflows-creator/src/lib/pipes/localization.pipe.spec.ts @@ -0,0 +1,33 @@ +import {LocalizationProviderService} from '../services/localization-provider.service'; +import {LocalizedStringKeys} from '../enum'; +import {TestBed} from '@angular/core/testing'; +import {LocalizationPipe} from './localization.pipe'; + +describe('LocalizationPipe', () => { + let pipe: LocalizationPipe; + let localizationSvc: LocalizationProviderService; + + beforeEach(async () => { + await TestBed.configureTestingModule({ + declarations: [LocalizationPipe], + providers: [LocalizationProviderService, LocalizationPipe], + }).compileComponents(); + }); + + beforeEach(() => { + localizationSvc = jasmine.createSpyObj('LocalizationProviderService', [ + 'getLocalizedString', + ]); + pipe = new LocalizationPipe(localizationSvc); + }); + + it('should create an instance', () => { + expect(pipe).toBeTruthy(); + }); + + it('should call getLocalizedString method of LocalizationProviderService', () => { + const key: LocalizedStringKeys = LocalizedStringKeys.DoThis; + pipe.transform(key); + expect(localizationSvc.getLocalizedString).toHaveBeenCalledWith(key); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/element.service.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/element.service.spec.ts new file mode 100644 index 0000000..3e25c56 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/element.service.spec.ts @@ -0,0 +1,34 @@ +import {WorkflowElement} from '../../classes/element'; +import {StatementNode} from '../../classes/statement'; +import {BPMN_ELEMENTS} from '../../const'; +import {InvalidEntityError, NotProvided} from '../../errors/base.error'; +import {TestBed} from '@angular/core/testing'; +import {Injector} from '@angular/core'; +import {BpmnElementService} from './element.service'; + +describe('BpmnElementService', () => { + let bpmnElementService: BpmnElementService; + let elements: WorkflowElement[]; + let injector: Injector; + + beforeEach(() => { + elements = []; // Define your mock elements here + injector = jasmine.createSpyObj('Injector', ['get']); + + TestBed.configureTestingModule({ + providers: [ + BpmnElementService, + {provide: BPMN_ELEMENTS, useValue: elements}, + {provide: Injector, useValue: injector}, + ], + }); + + bpmnElementService = TestBed.inject(BpmnElementService); + }); + + it('should be created', () => { + expect(bpmnElementService).toBeTruthy(); + }); + + // Add more test cases as needed +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/base/end.element.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/base/end.element.spec.ts new file mode 100644 index 0000000..4be16d4 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/base/end.element.spec.ts @@ -0,0 +1,46 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {EndElement} from './end.element'; + +describe('EndElement', () => { + let endElement: EndElement; + let creator: CreateStrategy; + let linker: LinkStrategy; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + utils = jasmine.createSpyObj('UtilsService', ['uuid']); + + endElement = new EndElement(creator, linker, utils); + }); + + it('should create an instance', () => { + expect(endElement).toBeTruthy(); + }); + + it('should have the correct tag', () => { + expect(endElement.tag).toBe('bpmn:EndEvent'); + }); + + it('should have empty attributes', () => { + expect(endElement.attributes).toEqual({}); + }); + + it('should have the correct name', () => { + expect(endElement.name).toBe('end'); + }); + + it('should have undefined statement', () => { + expect(endElement.statement).toBeUndefined(); + }); + + it('should have the correct identifier', () => { + expect(endElement.getIdentifier()).toBe('EndElement'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/base/start-on-interval.element.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/base/start-on-interval.element.spec.ts new file mode 100644 index 0000000..cf4667e --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/base/start-on-interval.element.spec.ts @@ -0,0 +1,44 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {StartOnIntervalElement} from './start-on-interval.element'; + +describe('StartOnIntervalElement', () => { + let startOnIntervalElement: StartOnIntervalElement; + let creator: CreateStrategy; + let linker: LinkStrategy; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + utils = jasmine.createSpyObj('UtilsService', ['uuid']); + + startOnIntervalElement = new StartOnIntervalElement(creator, linker, utils); + }); + + it('should create an instance', () => { + expect(startOnIntervalElement).toBeTruthy(); + }); + + it('should have the correct tag', () => { + expect(startOnIntervalElement.tag).toBe('bpmn:StartEvent'); + }); + + it('should have empty attributes', () => { + expect(startOnIntervalElement.attributes).toEqual({}); + }); + + it('should have the correct name', () => { + expect(startOnIntervalElement.name).toBe('start'); + }); + + it('should have the correct identifier', () => { + expect(startOnIntervalElement.getIdentifier()).toBe( + StartOnIntervalElement.identifier, + ); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/base/start.element.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/base/start.element.spec.ts new file mode 100644 index 0000000..508b053 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/base/start.element.spec.ts @@ -0,0 +1,50 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {StartElement} from './start.element'; + +describe('StartElement', () => { + let startElement: StartElement; + let creator: CreateStrategy; + let linker: LinkStrategy; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + utils = jasmine.createSpyObj('UtilsService', ['uuid']); + + startElement = new StartElement(creator, linker, utils); + }); + + it('should create an instance of StartElement', () => { + expect(startElement).toBeTruthy(); + }); + + it('should have the correct tag', () => { + expect(startElement.tag).toBe('bpmn:StartEvent'); + }); + + it('should have empty attributes', () => { + expect(startElement.attributes).toEqual({}); + }); + + it('should have the correct name', () => { + expect(startElement.name).toBe('start'); + }); + + it('should have empty inputs', () => { + expect(startElement.inputs).toBeUndefined(); + }); + + it('should have empty outputs', () => { + expect(startElement.outputs).toBeUndefined(); + }); + + it('should have the correct identifier', () => { + expect(startElement.getIdentifier()).toBe('StartElement'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/gateways/gateway.element.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/gateways/gateway.element.spec.ts new file mode 100644 index 0000000..ff87778 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/gateways/gateway.element.spec.ts @@ -0,0 +1,71 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, + ElementTypes, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {GatewayElement} from './gateway.element'; + +describe('GatewayElement', () => { + let gatewayElement: GatewayElement; + let creator: CreateStrategy; + let linker: LinkStrategy; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + utils = jasmine.createSpyObj('UtilsService', ['']); + + gatewayElement = new GatewayElement(creator, linker, utils); + }); + + it('should create an instance of GatewayElement', () => { + expect(gatewayElement).toBeTruthy(); + }); + + it('should have tag property set to "bpmn:ExclusiveGateway"', () => { + expect(gatewayElement.tag).toBe('bpmn:ExclusiveGateway'); + }); + + it('should have name property set to "gateway"', () => { + expect(gatewayElement.name).toBe('gateway'); + }); + + it('should have properties property set to an empty object', () => { + expect(gatewayElement.properties).toEqual({}); + }); + + it('should have statement property set to undefined', () => { + expect(gatewayElement.statement).toBeUndefined(); + }); + + it('should have attributes property with name property set to { state: "condition" }', () => { + expect(gatewayElement.attributes).toEqual({ + name: { + state: 'condition', + }, + }); + }); + + it('should have elseOutGoing property set to undefined', () => { + expect(gatewayElement.elseOutGoing).toBeUndefined(); + }); + + it('should have default property set to undefined', () => { + expect(gatewayElement.default).toBeUndefined(); + }); + + it('should have inputs property set to undefined', () => { + expect(gatewayElement.inputs).toBeUndefined(); + }); + + it('should have outputs property set to undefined', () => { + expect(gatewayElement.outputs).toBeUndefined(); + }); + + it('should have identifier property set to "GatewayElement"', () => { + expect(gatewayElement.getIdentifier()).toBe('GatewayElement'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/gateways/or-gateway.element.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/gateways/or-gateway.element.spec.ts new file mode 100644 index 0000000..3836338 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/gateways/or-gateway.element.spec.ts @@ -0,0 +1,73 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, + ElementTypes, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {OrGatewayElement} from './or-gateway.element'; + +describe('OrGatewayElement', () => { + let orGatewayElement: OrGatewayElement; + let creator: CreateStrategy; + let linker: LinkStrategy; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + utils = jasmine.createSpyObj('UtilsService', ['']); + + orGatewayElement = new OrGatewayElement(creator, linker, utils); + }); + + it('should create an instance of OrGatewayElement', () => { + expect(orGatewayElement).toBeTruthy(); + }); + + it('should have tag property set to "bpmn:ExclusiveGateway"', () => { + expect(orGatewayElement.tag).toBe('bpmn:ExclusiveGateway'); + }); + + it('should have name property set to "orgateway"', () => { + expect(orGatewayElement.name).toBe('orgateway'); + }); + + it('should have properties property set to an empty object', () => { + expect(orGatewayElement.properties).toEqual({}); + }); + + it('should have statement property set to undefined', () => { + expect(orGatewayElement.statement).toBeUndefined(); + }); + + it('should have attributes property set to an object with name property set to "merge OR"', () => { + expect(orGatewayElement.attributes).toEqual({name: 'merge OR'}); + }); + + it('should have elseOutGoing property set to undefined', () => { + expect(orGatewayElement.elseOutGoing).toBeUndefined(); + }); + + it('should have default property set to undefined', () => { + expect(orGatewayElement.default).toBeUndefined(); + }); + + it('should have inputs property set to undefined', () => { + expect(orGatewayElement.inputs).toBeUndefined(); + }); + + it('should have outputs property set to undefined', () => { + expect(orGatewayElement.outputs).toBeUndefined(); + }); + + it('should have identifier property set to "OrGatewayElement"', () => { + expect(OrGatewayElement.identifier).toBe('OrGatewayElement'); + }); + + describe('getIdentifier', () => { + it('should return the identifier of OrGatewayElement', () => { + expect(orGatewayElement.getIdentifier()).toBe('OrGatewayElement'); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/process/process-properties.element.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/process/process-properties.element.spec.ts new file mode 100644 index 0000000..c06f2b3 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/process/process-properties.element.spec.ts @@ -0,0 +1,57 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {ProcessPropertiesElement} from './process-properties.element'; + +describe('ProcessPropertiesElement', () => { + let processPropertiesElement: ProcessPropertiesElement; + let creator: CreateStrategy; + let linker: LinkStrategy; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + utils = jasmine.createSpyObj('UtilsService', ['']); + + processPropertiesElement = new ProcessPropertiesElement( + creator, + linker, + utils, + ); + }); + + it('should be created', () => { + expect(processPropertiesElement).toBeTruthy(); + }); + + it('should have tag property', () => { + expect(processPropertiesElement.tag).toBeDefined(); + }); + + it('should have name property', () => { + expect(processPropertiesElement.name).toBeDefined(); + }); + + it('should have type property', () => { + expect(ProcessPropertiesElement.type).toBeDefined(); + }); + + it('should have attributes property', () => { + expect(processPropertiesElement.attributes).toBeDefined(); + }); + + it('should have identifier property', () => { + expect(ProcessPropertiesElement.identifier).toBeDefined(); + }); + + describe('getIdentifier', () => { + it('should return the identifier', () => { + const identifier = processPropertiesElement.getIdentifier(); + expect(identifier).toBe(ProcessPropertiesElement.identifier); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/process/process.element.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/process/process.element.spec.ts new file mode 100644 index 0000000..60413f8 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/process/process.element.spec.ts @@ -0,0 +1,48 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {ProcessElement} from './process.element'; + +describe('ProcessElement', () => { + let processElement: ProcessElement; + let creator: CreateStrategy; + let linker: LinkStrategy; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + utils = jasmine.createSpyObj('UtilsService', ['uuid']); + + processElement = new ProcessElement(creator, linker, utils); + }); + + it('should create an instance of ProcessElement', () => { + expect(processElement).toBeTruthy(); + }); + + it('should have the correct tag', () => { + expect(processElement.tag).toEqual('bpmn:Process'); + }); + + it('should have the correct name', () => { + expect(processElement.name).toEqual('process'); + }); + + it('should have the correct identifier', () => { + expect(ProcessElement.identifier).toEqual('ProcessElement'); + }); + + it('should have the correct attributes', () => { + expect(processElement.attributes).toEqual({ + isExecutable: true, + }); + }); + + it('should have the correct getIdentifier method', () => { + expect(processElement.getIdentifier()).toEqual('ProcessElement'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/change-column-value.task.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/change-column-value.task.spec.ts new file mode 100644 index 0000000..5747201 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/change-column-value.task.spec.ts @@ -0,0 +1,72 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, + ENV, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {ChangeColumnValue} from './change-column-value.task'; + +describe('ChangeColumnValue', () => { + let changeColumnValue: ChangeColumnValue; + let creator: CreateStrategy; + let linker: LinkStrategy; + let env: ENV; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + env = {envIdentifier: 'test'}; + utils = jasmine.createSpyObj('UtilsService', ['']); + + changeColumnValue = new ChangeColumnValue(creator, linker, env, utils); + }); + + it('should create ChangeColumnValue', () => { + expect(changeColumnValue).toBeTruthy(); + }); + + it('should have name property', () => { + expect(changeColumnValue.name).toBe('change column value'); + }); + + it('should have properties property', () => { + expect(changeColumnValue.properties).toEqual({}); + }); + + it('should have inputs property', () => { + expect(changeColumnValue.inputs).toEqual({ + name: 'pathParams', + fields: { + taskIds: { + from: 'taskIds', + }, + groupColumnId: { + state: 'column', + }, + boardId: { + state: 'boardId', + }, + changedValue: { + formatter: jasmine.any(Function), + }, + }, + }); + }); + + it('should have outputs property', () => { + expect(changeColumnValue.outputs).toBe('outputVariable'); + }); + + it('should have identifier property', () => { + expect(ChangeColumnValue.identifier).toBe('ChangeColumnValue'); + }); + + describe('getIdentifier', () => { + it('should return the identifier', () => { + const identifier = changeColumnValue.getIdentifier(); + expect(identifier).toBe('ChangeColumnValue'); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/read-column.task.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/read-column.task.spec.ts new file mode 100644 index 0000000..1ba612a --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/read-column.task.spec.ts @@ -0,0 +1,55 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, + ENV, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {ReadColumnValue} from './read-column.task'; + +describe('ReadColumnValue', () => { + let readColumnValue: ReadColumnValue; + let creator: CreateStrategy; + let linker: LinkStrategy; + let env: ENV; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + env = {envIdentifier: 'test'}; + utils = jasmine.createSpyObj('UtilsService', ['']); + + readColumnValue = new ReadColumnValue(creator, linker, env, utils); + }); + + it('should create an instance of ReadColumnValue', () => { + expect(readColumnValue).toBeTruthy(); + }); + + it('should have the correct name', () => { + expect(readColumnValue.name).toEqual('read column value'); + }); + + it('should have the correct outputs', () => { + expect(readColumnValue.outputs).toEqual('outputVariable'); + }); + + it('should have the correct inputs', () => { + expect(readColumnValue.inputs).toEqual({ + name: 'pathParams', + fields: { + taskIds: { + from: 'taskIds', + }, + groupColumnId: { + state: 'column', + }, + }, + }); + }); + + it('should have the correct identifier', () => { + expect(readColumnValue.getIdentifier()).toEqual('ReadColumnValue'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/send-email.task.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/send-email.task.spec.ts new file mode 100644 index 0000000..356fa81 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/send-email.task.spec.ts @@ -0,0 +1,41 @@ +import {UtilsService} from '../../../utils.service'; +import {CreateStrategy, LinkStrategy} from '../../../../interfaces'; +import {ModdleElement} from '../../../../types/bpmn.types'; +import {TestBed} from '@angular/core/testing'; +import {CREATE_TASK_STRATEGY} from '../../strategies/create'; +import {LINK_BASIC_STRATEGY} from '../../strategies/link'; +import {ENV_TOKEN} from '../../../../token'; +import {SendEmail} from './send-email.task'; + +describe('SendEmail', () => { + let sendEmail: SendEmail; + let createStrategy: CreateStrategy; + let linkStrategy: LinkStrategy; + let env: any; // Mocked environment + let utilsService: UtilsService; + + beforeEach(() => { + env = { + envIdentifier: 'testEnv', + }; + + TestBed.configureTestingModule({ + providers: [ + SendEmail, + UtilsService, + {provide: CREATE_TASK_STRATEGY, useValue: {}}, + {provide: LINK_BASIC_STRATEGY, useValue: {}}, + {provide: ENV_TOKEN, useValue: env}, + ], + }); + + sendEmail = TestBed.inject(SendEmail); + createStrategy = TestBed.inject(CREATE_TASK_STRATEGY); + linkStrategy = TestBed.inject(LINK_BASIC_STRATEGY); + utilsService = TestBed.inject(UtilsService); + }); + + it('should be created', () => { + expect(sendEmail).toBeTruthy(); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-on-add-item.task.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-on-add-item.task.spec.ts new file mode 100644 index 0000000..fe52780 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-on-add-item.task.spec.ts @@ -0,0 +1,65 @@ +import {UtilsService} from '../../../utils.service'; +import {CreateStrategy, LinkStrategy} from '../../../../interfaces'; +import {ModdleElement} from '../../../../types/bpmn.types'; +import {TestBed} from '@angular/core/testing'; +import {CREATE_TASK_STRATEGY} from '../../strategies/create'; +import {LINK_BASIC_STRATEGY} from '../../strategies/link'; +import {ENV_TOKEN} from '../../../../token'; +import {TriggerOnAddItem} from './trigger-on-add-item.task'; + +describe('TriggerOnAddItem', () => { + let triggerOnAddItem: TriggerOnAddItem; + let createStrategy: CreateStrategy; + let linkStrategy: LinkStrategy; + let env: any; // Mocked environment + let utilsService: UtilsService; + + beforeEach(() => { + env = { + envIdentifier: 'testEnv', + }; + + TestBed.configureTestingModule({ + providers: [ + TriggerOnAddItem, + UtilsService, + {provide: CREATE_TASK_STRATEGY, useValue: {}}, + {provide: LINK_BASIC_STRATEGY, useValue: {}}, + {provide: ENV_TOKEN, useValue: env}, + ], + }); + + triggerOnAddItem = TestBed.inject(TriggerOnAddItem); + createStrategy = TestBed.inject(CREATE_TASK_STRATEGY); + linkStrategy = TestBed.inject(LINK_BASIC_STRATEGY); + utilsService = TestBed.inject(UtilsService); + }); + + it('should be created', () => { + expect(triggerOnAddItem).toBeTruthy(); + }); + + it('should have the correct name', () => { + expect(triggerOnAddItem.name).toEqual('trigger on add item'); + }); + + it('should have the correct inputs', () => { + expect(triggerOnAddItem.inputs).toEqual({ + name: 'pathParams', + fields: { + groupId: { + state: 'groupId', + }, + boardId: { + state: 'boardId', + }, + }, + }); + }); + + it('should have the correct outputs', () => { + expect(triggerOnAddItem.outputs).toEqual('outputVariable'); + }); + + // Add more test cases as needed +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-on-interval.task.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-on-interval.task.spec.ts new file mode 100644 index 0000000..7055445 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-on-interval.task.spec.ts @@ -0,0 +1,59 @@ +import { + CreateStrategy, + ModdleElement, + LinkStrategy, + ENV, +} from 'projects/workflows-creator/src/public-api'; +import {UtilsService} from '../../../utils.service'; +import {TriggerOnInterval} from './trigger-on-interval.task'; + +describe('TriggerOnInterval', () => { + let triggerOnInterval: TriggerOnInterval; + let creator: CreateStrategy; + let linker: LinkStrategy; + let env: ENV; + let utils: UtilsService; + + beforeEach(() => { + creator = jasmine.createSpyObj('CreateStrategy', ['create']); + linker = jasmine.createSpyObj('LinkStrategy', ['link']); + env = {envIdentifier: 'test'}; + utils = jasmine.createSpyObj('UtilsService', ['']); + + triggerOnInterval = new TriggerOnInterval(creator, linker, env, utils); + }); + + it('should create TriggerOnInterval', () => { + expect(triggerOnInterval).toBeTruthy(); + }); + + it('should have name as "trigger on interval"', () => { + expect(triggerOnInterval.name).toBe('trigger on interval'); + }); + + it('should have empty properties', () => { + expect(triggerOnInterval.properties).toEqual({}); + }); + + it('should have inputs with name "pathParams" and fields', () => { + expect(triggerOnInterval.inputs.name).toBe('pathParams'); + expect(triggerOnInterval.inputs.fields).toEqual({ + groupId: {state: 'groupId'}, + boardId: {state: 'boardId'}, + timescale: {state: 'timescale'}, + }); + }); + + it('should have outputs as "outputVariable"', () => { + expect(triggerOnInterval.outputs).toBe('outputVariable'); + }); + + it('should have identifier as "TriggerOnInterval"', () => { + expect(TriggerOnInterval.identifier).toBe('TriggerOnInterval'); + }); + + it('should return identifier as "TriggerOnInterval"', () => { + const identifier = triggerOnInterval.getIdentifier(); + expect(identifier).toBe('TriggerOnInterval'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-when-column-changes.task.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-when-column-changes.task.spec.ts new file mode 100644 index 0000000..c42da40 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/elements/tasks/trigger-when-column-changes.task.spec.ts @@ -0,0 +1,67 @@ +import {UtilsService} from '../../../utils.service'; +import {CreateStrategy, LinkStrategy} from '../../../../interfaces'; +import {ModdleElement} from '../../../../types/bpmn.types'; +import {TestBed} from '@angular/core/testing'; +import {CREATE_TASK_STRATEGY} from '../../strategies/create'; +import {LINK_BASIC_STRATEGY} from '../../strategies/link'; +import {ENV_TOKEN} from '../../../../token'; +import {TriggerWhenColumnChanges} from './trigger-when-column-changes.task'; + +describe('TriggerWhenColumnChanges', () => { + let triggerWhenColumnChanges: TriggerWhenColumnChanges; + let createStrategy: CreateStrategy; + let linkStrategy: LinkStrategy; + let env: any; // Mocked environment + let utilsService: UtilsService; + + beforeEach(() => { + env = { + envIdentifier: 'testEnv', + }; + + TestBed.configureTestingModule({ + providers: [ + TriggerWhenColumnChanges, + UtilsService, + {provide: CREATE_TASK_STRATEGY, useValue: {}}, + {provide: LINK_BASIC_STRATEGY, useValue: {}}, + {provide: ENV_TOKEN, useValue: env}, + ], + }); + + triggerWhenColumnChanges = TestBed.inject(TriggerWhenColumnChanges); + createStrategy = TestBed.inject(CREATE_TASK_STRATEGY); + linkStrategy = TestBed.inject(LINK_BASIC_STRATEGY); + utilsService = TestBed.inject(UtilsService); + }); + + it('should be created', () => { + expect(triggerWhenColumnChanges).toBeTruthy(); + }); + + it('should have the correct name', () => { + expect(triggerWhenColumnChanges.name).toEqual( + 'trigger when column value changes', + ); + }); + + it('should have the correct inputs', () => { + expect(triggerWhenColumnChanges.inputs).toEqual({ + name: 'pathParams', + fields: { + groupColumnId: { + state: 'column', + }, + boardId: { + state: 'boardId', + }, + }, + }); + }); + + it('should have the correct outputs', () => { + expect(triggerWhenColumnChanges.outputs).toEqual('outputVariable'); + }); + + // Add more test cases as needed +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/node.service.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/node.service.spec.ts new file mode 100644 index 0000000..96566eb --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/node.service.spec.ts @@ -0,0 +1,51 @@ +import {TestBed} from '@angular/core/testing'; + +import {BPMN_NODES, BPMN_INPUTS} from '../../const'; + +import {BaseGroup} from '../../types'; +import {NodeTypes} from '../../enum'; +import {UtilsService} from '../utils.service'; +import {LocalizationProviderService} from '../localization-provider.service'; +import {WorkflowElement} from '../../classes'; +import {BpmnNodesService} from './node.service'; + +describe('BpmnNodesService', () => { + let bpmnNodesService: BpmnNodesService; + let nodes: WorkflowElement[]; + let groups: BaseGroup[]; + let inputs: any[]; + let utilsService: UtilsService; + let localizationProviderService: LocalizationProviderService; + + beforeEach(() => { + nodes = []; // Define your mock nodes here + groups = []; // Define your mock groups here + inputs = []; // Define your mock inputs here + utilsService = jasmine.createSpyObj('UtilsService', ['uuid']); + localizationProviderService = jasmine.createSpyObj( + 'LocalizationProviderService', + ['getLocalizedStringMap'], + ); + + TestBed.configureTestingModule({ + providers: [ + BpmnNodesService, + {provide: BPMN_NODES, useValue: nodes}, + {provide: BPMN_INPUTS, useValue: inputs}, + {provide: UtilsService, useValue: utilsService}, + { + provide: LocalizationProviderService, + useValue: localizationProviderService, + }, + ], + }); + + bpmnNodesService = TestBed.inject(BpmnNodesService); + }); + + it('should be created', () => { + expect(bpmnNodesService).toBeTruthy(); + }); + + // Add more test cases as needed +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/strategies/create/basic-create.strategy.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/strategies/create/basic-create.strategy.spec.ts new file mode 100644 index 0000000..a14c706 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/strategies/create/basic-create.strategy.spec.ts @@ -0,0 +1,34 @@ +import {CreateBasicStrategy} from 'projects/workflows-creator/src/lib'; +import {UtilsService} from '../../../utils.service'; + +describe('CreateBasicStrategy', () => { + let createBasicStrategy: CreateBasicStrategy; + let moddleMock: any; + let utilsServiceMock: UtilsService; + + beforeEach(() => { + moddleMock = jasmine.createSpyObj('CustomBpmnModdle', ['create']); + utilsServiceMock = { + uuid: jasmine.createSpy('uuid'), + } as UtilsService; + + createBasicStrategy = new CreateBasicStrategy(moddleMock, utilsServiceMock); + }); + + it('should be created', () => { + expect(createBasicStrategy).toBeTruthy(); + }); + + describe('parseAttributes', () => { + it('should parse attributes and replace state values with actual state', () => { + // Arrange + const attrs = {attr1: 'value1', attr2: {state: 'stateKey'}}; + const node = jasmine.createSpyObj('BpmnStatementNode', ['workflowNode']); + node.workflowNode.state = new Map().set('stateKey', 'stateValue'); + // Act + const result = createBasicStrategy['parseAttributes'](attrs, node); + // Assert + expect(result).toEqual({attr1: 'value1', attr2: 'stateValue'}); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/strategies/create/basic-interval-create.strategy.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/strategies/create/basic-interval-create.strategy.spec.ts new file mode 100644 index 0000000..0a5824f --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/strategies/create/basic-interval-create.strategy.spec.ts @@ -0,0 +1,60 @@ +import {TestBed} from '@angular/core/testing'; +import { + CustomBpmnModdle, + ModdleElement, + RecordOfAnyType, +} from '../../../../types'; +import {UtilsService} from '../../../utils.service'; +import {CreateBasicIntervalStrategy} from './basic-interval-create.strategy'; + +describe('CreateBasicIntervalStrategy', () => { + let service: CreateBasicIntervalStrategy; + let moddleMock: jasmine.SpyObj; + let utilsMock: jasmine.SpyObj; + beforeEach(() => { + moddleMock = jasmine.createSpyObj('CustomBpmnModdle', ['create']); + utilsMock = jasmine.createSpyObj('UtilsService', ['uuid']); + + TestBed.configureTestingModule({ + providers: [ + CreateBasicIntervalStrategy, + {provide: CustomBpmnModdle, useValue: moddleMock}, + {provide: UtilsService, useValue: utilsMock}, + ], + }); + + service = TestBed.inject(CreateBasicIntervalStrategy); + }); + + it('should be created', () => { + expect(service).toBeTruthy(); + }); + + describe('parseAttributes', () => { + it('should parse state references in attributes', () => { + // Mocking necessary data + const attrs: RecordOfAnyType = {someAttr: {state: 'someStateKey'}}; + const node: any = { + workflowNode: {state: new Map([['someStateKey', 'mockedStateValue']])}, + }; + + // Calling the method under test + const result = service['parseAttributes'](attrs, node); + + // Expectations + expect(result).toEqual({someAttr: 'mockedStateValue'}); + }); + + it('should leave non-state reference attributes unchanged', () => { + // Mocking necessary data + const attrs: RecordOfAnyType = {someAttr: 'someValue'}; + const node: any = {workflowNode: {state: new Map()}}; + + // Calling the method under test + const result = service['parseAttributes'](attrs, node); + + // Expectations + expect(result).toEqual(attrs); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/strategies/create/gateway-create.strategy.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/strategies/create/gateway-create.strategy.spec.ts new file mode 100644 index 0000000..f7e55a9 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/strategies/create/gateway-create.strategy.spec.ts @@ -0,0 +1,42 @@ +import {TestBed} from '@angular/core/testing'; + +import {CustomBpmnModdle} from '../../../../types'; +import {UtilsService} from '../../../utils.service'; +import {BpmnStatementNode} from '../../../../types/bpmn.types'; +import {CreateGatewayStrategy} from './gateway-create.strategy'; + +describe('CreateGatewayStrategy', () => { + let service: CreateGatewayStrategy; + let moddleMock: jasmine.SpyObj; + let utilsMock: jasmine.SpyObj; + + beforeEach(() => { + moddleMock = jasmine.createSpyObj('CustomBpmnModdle', ['create']); + utilsMock = jasmine.createSpyObj('UtilsService', ['uuid']); + + TestBed.configureTestingModule({ + providers: [ + CreateGatewayStrategy, + {provide: CustomBpmnModdle, useValue: moddleMock}, + {provide: UtilsService, useValue: utilsMock}, + ], + }); + + service = TestBed.inject(CreateGatewayStrategy); + }); + + it('should be created', () => { + expect(service).toBeTruthy(); + }); + + describe('parseAttributes', () => { + it('should parse state references in attributes', () => { + const attrs = {}; // Provide mock attributes + const node = {} as BpmnStatementNode; // Provide a mock of BpmnStatementNode + + const parsedAttrs = service['parseAttributes'](attrs, node); + + // Add expectations/assertions here + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/bpmn/strategies/create/task-create.strategy.spec.ts b/projects/workflows-creator/src/lib/services/bpmn/strategies/create/task-create.strategy.spec.ts new file mode 100644 index 0000000..326af54 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/bpmn/strategies/create/task-create.strategy.spec.ts @@ -0,0 +1,33 @@ +import {TestBed} from '@angular/core/testing'; +import {CustomBpmnModdle, ModdleElement} from '../../../../types/bpmn.types'; +import {UtilsService} from '../../../utils.service'; +import {CreateTaskStrategy} from './task-create.strategy'; +import { + CreateStrategy, + LinkStrategy, +} from 'projects/workflows-creator/src/public-api'; + +describe('CreateTaskStrategy', () => { + let strategy: CreateTaskStrategy; + let moddleMock: jasmine.SpyObj; + let utilsServiceMock: jasmine.SpyObj; + + beforeEach(() => { + moddleMock = jasmine.createSpyObj('CustomBpmnModdle', ['create']); + utilsServiceMock = jasmine.createSpyObj('UtilsService', ['uuid']); + + TestBed.configureTestingModule({ + providers: [ + CreateTaskStrategy, + {provide: CustomBpmnModdle, useValue: moddleMock}, + {provide: UtilsService, useValue: utilsServiceMock}, + ], + }); + + strategy = TestBed.inject(CreateTaskStrategy); + }); + + it('should be created', () => { + expect(strategy).toBeTruthy(); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/actions/changecolumn.action.spec.ts b/projects/workflows-creator/src/lib/services/statement/actions/changecolumn.action.spec.ts new file mode 100644 index 0000000..be994b3 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/actions/changecolumn.action.spec.ts @@ -0,0 +1,41 @@ +import {ChangeColumnValueAction} from './changecolumn.action'; + +describe('ChangeColumnValueAction', () => { + let changeColumnValueAction: ChangeColumnValueAction; + + beforeEach(() => { + changeColumnValueAction = new ChangeColumnValueAction( + {}, + 'testId', + 'testGroupType', + 'testGroupId', + false, + ); + }); + + it('should create an instance of ChangeColumnValueAction', () => { + expect(changeColumnValueAction).toBeTruthy(); + }); + + it('should have the correct identifier', () => { + expect(changeColumnValueAction.getIdentifier()).toEqual( + 'ChangeColumnValueAction', + ); + }); + + it('should have the correct name', () => { + expect(changeColumnValueAction.name).toEqual('Change column value'); + }); + + it('should have the correct groupType', () => { + expect(changeColumnValueAction.groupType).toEqual('testGroupType'); + }); + + it('should have the correct groupId', () => { + expect(changeColumnValueAction.groupId).toEqual('testGroupId'); + }); + + it('should have the correct isElseAction value', () => { + expect(changeColumnValueAction.isElseAction).toEqual(false); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/actions/readcolumn.action.spec.ts b/projects/workflows-creator/src/lib/services/statement/actions/readcolumn.action.spec.ts new file mode 100644 index 0000000..0b21c32 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/actions/readcolumn.action.spec.ts @@ -0,0 +1,41 @@ +import {RecordOfAnyType} from '../../../types'; +import {ReadColumnValueAction} from './readcolumn.action'; + +describe('ReadColumnValueAction', () => { + let action: ReadColumnValueAction; + let localizedStringMap: RecordOfAnyType = {}; // You can provide sample data for localizedStringMap + let id = ''; + let groupType = ''; + let groupId = ''; + let isElseAction = false; + + beforeEach(() => { + action = new ReadColumnValueAction( + localizedStringMap, + id, + groupType, + groupId, + isElseAction, + ); + }); + + it('should create an instance of ReadColumnValueAction', () => { + expect(action).toBeDefined(); + expect(action instanceof ReadColumnValueAction).toBeTruthy(); + }); + + it('should set the properties correctly', () => { + expect(action.id).toEqual(id); + expect(action.groupType).toEqual(groupType); + expect(action.groupId).toEqual(groupId); + expect(action.isElseAction).toEqual(isElseAction); + expect(action.elements).toEqual([]); + expect(action.name).toEqual('Read Column Value'); + expect(action.statement).toEqual('read value from '); + expect(action.prompts).toEqual([]); + }); + + it('should return the correct identifier', () => { + expect(action.getIdentifier()).toEqual('ReadColumnValueAction'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/actions/sendmail.action.spec.ts b/projects/workflows-creator/src/lib/services/statement/actions/sendmail.action.spec.ts new file mode 100644 index 0000000..5afcb0f --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/actions/sendmail.action.spec.ts @@ -0,0 +1,43 @@ +import {SendEmailAction} from './sendmail.action'; + +describe('SendEmailAction', () => { + let sendEmailAction: SendEmailAction; + + beforeEach(() => { + sendEmailAction = new SendEmailAction( + {}, + 'testId', + 'testGroupType', + 'testGroupId', + false, + ); + }); + + it('should create an instance of SendEmailAction', () => { + expect(sendEmailAction).toBeTruthy(); + }); + + it('should have the correct identifier', () => { + expect(sendEmailAction.getIdentifier()).toEqual('SendEmailAction'); + }); + + it('should have the correct name', () => { + expect(sendEmailAction.name).toEqual('Send an email'); + }); + + it('should have the correct statement', () => { + expect(sendEmailAction.statement).toEqual('send an'); + }); + + it('should have the correct isElseAction value', () => { + expect(sendEmailAction.isElseAction).toBe(false); + }); + + it('should have the correct groupType', () => { + expect(sendEmailAction.groupType).toEqual('testGroupType'); + }); + + it('should have the correct groupId', () => { + expect(sendEmailAction.groupId).toEqual('testGroupId'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/events/onadditem.event.spec.ts b/projects/workflows-creator/src/lib/services/statement/events/onadditem.event.spec.ts new file mode 100644 index 0000000..b936475 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/events/onadditem.event.spec.ts @@ -0,0 +1,40 @@ +import {LocalizedStringKeys, StartElementTypes} from '../../../enum'; +import {RecordOfAnyType} from '../../../types'; +import {OnAddItemEvent} from './onadditem.event'; + +describe('OnAddItemEvent', () => { + let event: OnAddItemEvent; + const localizedStringMap: RecordOfAnyType = { + [LocalizedStringKeys.OnAddItem]: 'Localized On add item', + [LocalizedStringKeys.ItemCreated]: 'Localized Item created', + }; + let id = ''; + let groupType = ''; + let groupId = ''; + + beforeEach(() => { + event = new OnAddItemEvent(localizedStringMap, id, groupType, groupId); + }); + + it('should create an instance of OnAddItemEvent', () => { + expect(event).toBeDefined(); + expect(event instanceof OnAddItemEvent).toBeTruthy(); + }); + + it('should set the properties correctly', () => { + expect(event.id).toEqual(id); + expect(event.groupType).toEqual(groupType); + expect(event.groupId).toEqual(groupId); + expect(event.trigger).toEqual(true); + expect(event.startElement).toEqual(StartElementTypes.BasicStartElement); + expect(event.elements).toEqual(['TriggerOnAddItem']); + expect(event.name).toEqual('Localized On add item'); + expect(event.statement).toEqual('Localized Item created'); + expect(event.properties).toEqual({}); + expect(event.prompts).toEqual([]); + }); + + it('should return the correct identifier', () => { + expect(event.getIdentifier()).toEqual('OnAddItemEvent'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/events/onchange.event.spec.ts b/projects/workflows-creator/src/lib/services/statement/events/onchange.event.spec.ts new file mode 100644 index 0000000..8084b44 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/events/onchange.event.spec.ts @@ -0,0 +1,47 @@ +import {LocalizedStringKeys, StartElementTypes} from '../../../enum'; +import {RecordOfAnyType} from '../../../types'; +import {OnChangeEvent} from './onchange.event'; + +describe('OnChangeEvent', () => { + let event: OnChangeEvent; + const localizedStringMap: RecordOfAnyType = { + [LocalizedStringKeys.ColumnChanges]: 'Localized Column changes', + }; + let id = ''; + let groupType = ''; + let groupId = ''; + + beforeEach(() => { + event = new OnChangeEvent(localizedStringMap, id, groupType, groupId); + }); + + it('should create an instance of OnChangeEvent', () => { + expect(event).toBeDefined(); + expect(event instanceof OnChangeEvent).toBeTruthy(); + }); + + it('should set the properties correctly', () => { + expect(event.id).toEqual(id); + expect(event.groupType).toEqual(groupType); + expect(event.groupId).toEqual(groupId); + expect(event.trigger).toEqual(true); + expect(event.startElement).toEqual(StartElementTypes.BasicStartElement); + expect(event.elements).toEqual([ + 'TriggerWhenColumnChanges', + 'ReadColumnValue', + 'GatewayElement', + ]); + expect(event.name).toEqual('Localized Column changes'); + expect(event.statement).toEqual('When '); + expect(event.properties).toEqual({}); + expect(event.prompts).toEqual([ + 'TriggerColumnInput', + 'ValueTypeInput', + 'ValueInput', + ]); + }); + + it('should return the correct identifier', () => { + expect(event.getIdentifier()).toEqual('OnChangeEvent'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/events/oninterval.event.spec.ts b/projects/workflows-creator/src/lib/services/statement/events/oninterval.event.spec.ts new file mode 100644 index 0000000..992f5cf --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/events/oninterval.event.spec.ts @@ -0,0 +1,41 @@ +import {LocalizedStringKeys, StartElementTypes} from '../../../enum'; +import {RecordOfAnyType} from '../../../types'; +import {OnIntervalEvent} from './oninterval.event'; + +describe('OnIntervalEvent', () => { + let event: OnIntervalEvent; + const localizedStringMap: RecordOfAnyType = { + [LocalizedStringKeys.OnInterval]: 'Localized On Interval', + }; + let id = ''; + let groupType = ''; + let groupId = ''; + + beforeEach(() => { + event = new OnIntervalEvent(localizedStringMap, id, groupType, groupId); + }); + + it('should create an instance of OnIntervalEvent', () => { + expect(event).toBeDefined(); + expect(event instanceof OnIntervalEvent).toBeTruthy(); + }); + + it('should set the properties correctly', () => { + expect(event.id).toEqual(id); + expect(event.groupType).toEqual(groupType); + expect(event.groupId).toEqual(groupId); + expect(event.trigger).toEqual(true); + expect(event.startElement).toEqual( + StartElementTypes.StartOnIntervalElement, + ); + expect(event.elements).toEqual(['TriggerOnInterval']); + expect(event.name).toEqual('Localized On Interval'); + expect(event.statement).toEqual('Every '); + expect(event.properties).toEqual({}); + expect(event.prompts).toEqual(['ValueInput', 'IntervalInput']); + }); + + it('should return the correct identifier', () => { + expect(event.getIdentifier()).toEqual('OnIntervalEvent'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/events/onvalue.event.spec.ts b/projects/workflows-creator/src/lib/services/statement/events/onvalue.event.spec.ts new file mode 100644 index 0000000..f776719 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/events/onvalue.event.spec.ts @@ -0,0 +1,42 @@ +import {LocalizedStringKeys} from '../../../enum'; +import {RecordOfAnyType} from '../../../types'; +import {OnValueEvent} from './onvalue.event'; + +describe('OnValueEvent', () => { + let event: OnValueEvent; + const localizedStringMap: RecordOfAnyType = { + [LocalizedStringKeys.CheckValue]: 'Localized Check value', + }; + let id = ''; + let groupType = ''; + let groupId = ''; + + beforeEach(() => { + event = new OnValueEvent(localizedStringMap, id, groupType, groupId); + }); + + it('should create an instance of OnValueEvent', () => { + expect(event).toBeDefined(); + expect(event instanceof OnValueEvent).toBeTruthy(); + }); + + it('should set the properties correctly', () => { + expect(event.id).toEqual(id); + expect(event.groupType).toEqual(groupType); + expect(event.groupId).toEqual(groupId); + expect(event.trigger).toEqual(false); + expect(event.elements).toEqual(['ReadColumnValue', 'GatewayElement']); + expect(event.name).toEqual('Localized Check value'); + expect(event.statement).toEqual('check if '); + expect(event.properties).toEqual({}); + expect(event.prompts).toEqual([ + 'ColumnInput', + 'ConditionInput', + 'ValueInput', + ]); + }); + + it('should return the correct identifier', () => { + expect(event.getIdentifier()).toEqual('OnValueEvent'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/groups/and.group.spec.ts b/projects/workflows-creator/src/lib/services/statement/groups/and.group.spec.ts new file mode 100644 index 0000000..6ab9a72 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/groups/and.group.spec.ts @@ -0,0 +1,34 @@ +import {NodeTypes} from '../../../enum'; +import {RecordOfAnyType} from '../../../types'; +import {AndGroup} from './and.group'; + +describe('AndGroup', () => { + let group: AndGroup; + let localizedStringMap: RecordOfAnyType = {}; // You can add mock localized string data here + let id = ''; + let type = NodeTypes.GROUP; + let isElseGroup = false; + + beforeEach(() => { + group = new AndGroup(localizedStringMap, id, type, isElseGroup); + }); + + it('should create an instance of AndGroup', () => { + expect(group).toBeDefined(); + expect(group instanceof AndGroup).toBeTruthy(); + }); + + it('should set the properties correctly', () => { + expect(group.id).toEqual(id); + expect(group.type).toEqual(NodeTypes.GROUP); + expect(group.isElseGroup).toEqual(isElseGroup); + expect(group.children).toEqual([]); + expect(group.trigger).toEqual(true); + expect(group.name).toEqual('and'); + expect(group.nodeType).toEqual(type); + }); + + it('should return the correct identifier', () => { + expect(group.getIdentifier()).toEqual('AndGroup'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/groups/or.group.spec.ts b/projects/workflows-creator/src/lib/services/statement/groups/or.group.spec.ts new file mode 100644 index 0000000..b2836b4 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/groups/or.group.spec.ts @@ -0,0 +1,33 @@ +import {NodeTypes} from '../../../enum'; +import {RecordOfAnyType} from '../../../types'; +import {OrGroup} from './or.group'; + +describe('OrGroup', () => { + let group: OrGroup; + let localizedStringMap: RecordOfAnyType = {}; // You can add mock localized string data here + let id = ''; + let type = NodeTypes.GROUP; + + beforeEach(() => { + group = new OrGroup(localizedStringMap, id, type); + }); + + it('should create an instance of OrGroup', () => { + expect(group).toBeDefined(); + expect(group instanceof OrGroup).toBeTruthy(); + }); + + it('should set the properties correctly', () => { + expect(group.id).toEqual(id); + expect(group.type).toEqual(NodeTypes.GROUP); + expect(group.isElseGroup).toBeFalsy(); + expect(group.children).toEqual([]); + expect(group.trigger).toBeFalsy(); + expect(group.name).toEqual('or'); + expect(group.nodeType).toEqual(type); + }); + + it('should return the correct identifier', () => { + expect(group.getIdentifier()).toEqual('OrGroup'); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/column.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/column.input.spec.ts new file mode 100644 index 0000000..f1086bd --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/column.input.spec.ts @@ -0,0 +1,44 @@ +import {State} from '../../../classes'; +import {InputTypes} from '../../../enum'; +import {ColumnInput} from './column.input'; + +describe('ColumnInput', () => { + let columnInput: ColumnInput; + + beforeEach(() => { + columnInput = new ColumnInput(); + }); + + it('should have prefix and suffix properties', () => { + expect(columnInput.prefix).toBeDefined(); + expect(columnInput.suffix).toBeDefined(); + }); + + it('should have typeFunction property that returns InputTypes.List', () => { + expect(columnInput.typeFunction()).toBe(InputTypes.List); + }); + + it('should have inputKey property set to "column"', () => { + expect(columnInput.inputKey).toBe('column'); + }); + + it('should have listNameField property set to "text"', () => { + expect(columnInput.listNameField).toBe('text'); + }); + + it('should have listValueField property set to "value"', () => { + expect(columnInput.listValueField).toBe('value'); + }); + + it('should have placeholder property set to "Column"', () => { + expect(columnInput.placeholder).toBe('Column'); + }); + + it('should have identifier property set to "ColumnInput"', () => { + expect(ColumnInput.identifier).toBe('ColumnInput'); + }); + + it('should have getIdentifier method that returns the identifier property', () => { + expect(columnInput.getIdentifier()).toBe(ColumnInput.identifier); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/condition.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/condition.input.spec.ts new file mode 100644 index 0000000..28d897b --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/condition.input.spec.ts @@ -0,0 +1,59 @@ +import {ConditionInput} from './condition.input'; + +describe('ConditionInput', () => { + let conditionInput: ConditionInput; + + beforeEach(() => { + conditionInput = new ConditionInput(); + }); + + it('should have prefix property', () => { + expect(conditionInput.prefix).toBeDefined(); + }); + + it('should have suffix property', () => { + expect(conditionInput.suffix).toBeDefined(); + }); + + it('should have typeFunction property', () => { + expect(conditionInput.typeFunction).toBeDefined(); + }); + + it('should have inputKey property', () => { + expect(conditionInput.inputKey).toBeDefined(); + }); + + it('should have listNameField property', () => { + expect(conditionInput.listNameField).toBeDefined(); + }); + + it('should have listValueField property', () => { + expect(conditionInput.listValueField).toBeDefined(); + }); + + it('should have placeholder property', () => { + expect(conditionInput.placeholder).toBeDefined(); + }); + + it('should have prevchange method', () => { + expect(conditionInput.prevchange).toBeDefined(); + }); + + it('should have options method', () => { + expect(conditionInput.options).toBeDefined(); + }); + + it('should have identifier property', () => { + expect(ConditionInput.identifier).toBeDefined(); + }); + + it('should have getIdentifier method', () => { + expect(conditionInput.getIdentifier).toBeDefined(); + }); + + describe('getIdentifier', () => { + it('should return the identifier', () => { + expect(conditionInput.getIdentifier()).toBe(ConditionInput.identifier); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/email.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/email.input.spec.ts new file mode 100644 index 0000000..9e9bb9f --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/email.input.spec.ts @@ -0,0 +1,117 @@ +import {EmailDataInput, EmailToInput, EmailRecepientInput} from './email.input'; + +describe('EmailDataInput', () => { + let emailDataInput: EmailDataInput; + + beforeEach(() => { + emailDataInput = new EmailDataInput(); + }); + + it('should have prefix property', () => { + expect(emailDataInput.prefix).toBeDefined(); + }); + + it('should have suffix property', () => { + expect(emailDataInput.suffix).toBeDefined(); + }); + + it('should have typeFunction property', () => { + expect(emailDataInput.typeFunction).toBeDefined(); + }); + + it('should have inputKey property', () => { + expect(emailDataInput.inputKey).toBeDefined(); + }); + + it('should have placeholder property', () => { + expect(emailDataInput.placeholder).toBeDefined(); + }); + + it('should have identifier property', () => { + expect(EmailDataInput.identifier).toBeDefined(); + }); + + it('should have getIdentifier method', () => { + expect(emailDataInput.getIdentifier).toBeDefined(); + }); +}); + +describe('EmailToInput', () => { + let emailToInput: EmailToInput; + + beforeEach(() => { + emailToInput = new EmailToInput(); + }); + + it('should have prefix property', () => { + expect(emailToInput.prefix).toBeDefined(); + }); + + it('should have suffix property', () => { + expect(emailToInput.suffix).toBeDefined(); + }); + + it('should have placeholder property', () => { + expect(emailToInput.placeholder).toBeDefined(); + }); + + it('should have inputKey property', () => { + expect(emailToInput.inputKey).toBeDefined(); + }); + + it('should have listNameField property', () => { + expect(emailToInput.listNameField).toBeDefined(); + }); + + it('should have listValueField property', () => { + expect(emailToInput.listValueField).toBeDefined(); + }); + + it('should have prevchange method', () => { + expect(emailToInput.prevchange).toBeDefined(); + }); + + it('should have options method', () => { + expect(emailToInput.options).toBeDefined(); + }); + + it('should have typeFunction method', () => { + expect(emailToInput.typeFunction).toBeDefined(); + }); + + it('should have identifier property', () => { + expect(EmailToInput.identifier).toBeDefined(); + }); + + it('should have getIdentifier method', () => { + expect(emailToInput.getIdentifier).toBeDefined(); + }); +}); + +describe('EmailRecepientInput', () => { + let emailRecepientInput: EmailRecepientInput; + + beforeEach(() => { + emailRecepientInput = new EmailRecepientInput(); + }); + + it('should have inputKey property', () => { + expect(emailRecepientInput.inputKey).toBeDefined(); + }); + + it('should have placeholder property', () => { + expect(emailRecepientInput.placeholder).toBeDefined(); + }); + + it('should have isHidden method', () => { + expect(emailRecepientInput.isHidden).toBeDefined(); + }); + + it('should have identifier property', () => { + expect(EmailRecepientInput.identifier).toBeDefined(); + }); + + it('should have getIdentifier method', () => { + expect(emailRecepientInput.getIdentifier).toBeDefined(); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/interval.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/interval.input.spec.ts new file mode 100644 index 0000000..4a5bbf1 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/interval.input.spec.ts @@ -0,0 +1,43 @@ +import {InputTypes} from '../../../enum'; +import {IntervalInput} from './interval.input'; + +describe('IntervalInput', () => { + let intervalInput: IntervalInput; + + beforeEach(() => { + intervalInput = new IntervalInput(); + }); + + it('should have prefix and suffix properties', () => { + expect(intervalInput.prefix).toBeDefined(); + expect(intervalInput.suffix).toBeDefined(); + }); + + it('should have typeFunction property that returns InputTypes.List', () => { + expect(intervalInput.typeFunction()).toBe(InputTypes.List); + }); + + it('should have inputKey property set to "interval"', () => { + expect(intervalInput.inputKey).toBe('interval'); + }); + + it('should have listNameField property set to "text"', () => { + expect(intervalInput.listNameField).toBe('text'); + }); + + it('should have listValueField property set to "value"', () => { + expect(intervalInput.listValueField).toBe('value'); + }); + + it('should have placeholder property set to "Interval"', () => { + expect(intervalInput.placeholder).toBe('Interval'); + }); + + it('should have identifier property set to "IntervalInput"', () => { + expect(IntervalInput.identifier).toBe('IntervalInput'); + }); + + it('should have getIdentifier method that returns the identifier property', () => { + expect(intervalInput.getIdentifier()).toBe(IntervalInput.identifier); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/tocolumn.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/tocolumn.input.spec.ts new file mode 100644 index 0000000..8e3adbd --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/tocolumn.input.spec.ts @@ -0,0 +1,27 @@ +import {ToColumnInput} from './tocolumn.input'; + +describe('ToColumnInput', () => { + let toColumnInput: ToColumnInput; + + beforeEach(() => { + toColumnInput = new ToColumnInput(); + }); + + it('should have a suffix property', () => { + expect(toColumnInput.suffix).toBeDefined(); + }); + + it('should have a static identifier property', () => { + expect(ToColumnInput.identifier).toBeDefined(); + }); + + it('should have a getIdentifier method', () => { + expect(toColumnInput.getIdentifier).toBeDefined(); + }); + + describe('getIdentifier', () => { + it('should return the identifier', () => { + expect(toColumnInput.getIdentifier()).toEqual(ToColumnInput.identifier); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/tovalue.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/tovalue.input.spec.ts new file mode 100644 index 0000000..702837e --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/tovalue.input.spec.ts @@ -0,0 +1,23 @@ +import {ToValueInput} from './tovalue.input'; + +describe('ToValueInput', () => { + let toValueInput: ToValueInput; + + beforeEach(() => { + toValueInput = new ToValueInput(); + }); + + it('should have prefix property set to an empty string', () => { + expect(toValueInput.prefix).toEqual(''); + }); + + it('should have identifier property set to "ToValueInput"', () => { + expect(ToValueInput.identifier).toEqual('ToValueInput'); + }); + + describe('getIdentifier', () => { + it('should return the identifier property', () => { + expect(toValueInput.getIdentifier()).toEqual(ToValueInput.identifier); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/triggercolumn.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/triggercolumn.input.spec.ts new file mode 100644 index 0000000..7249864 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/triggercolumn.input.spec.ts @@ -0,0 +1,28 @@ +import {TriggerColumnInput} from './triggercolumn.input'; + +describe('TriggerColumnInput', () => { + let triggerColumnInput: TriggerColumnInput; + + beforeEach(() => { + triggerColumnInput = new TriggerColumnInput(); + }); + + it('should have a suffix property', () => { + expect(triggerColumnInput.suffix).toBeDefined(); + }); + + it('should have a static identifier property', () => { + expect(TriggerColumnInput.identifier).toBeDefined(); + }); + + it('should have a getIdentifier method', () => { + expect(triggerColumnInput.getIdentifier).toBeDefined(); + }); + + describe('getIdentifier', () => { + it('should return the identifier', () => { + const identifier = triggerColumnInput.getIdentifier(); + expect(identifier).toEqual(TriggerColumnInput.identifier); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/value.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/value.input.spec.ts new file mode 100644 index 0000000..75ef2f0 --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/value.input.spec.ts @@ -0,0 +1,61 @@ +import {ValueInput} from './value.input'; + +describe('ValueInput', () => { + let valueInput: ValueInput; + + beforeEach(() => { + valueInput = new ValueInput(); + }); + + it('should have prefix property', () => { + expect(valueInput.prefix).toBeDefined(); + }); + + it('should have suffix property', () => { + expect(valueInput.suffix).toBeDefined(); + }); + + it('should have inputKey property', () => { + expect(valueInput.inputKey).toBeDefined(); + }); + + it('should have listNameField property', () => { + expect(valueInput.listNameField).toBeDefined(); + }); + + it('should have listValueField property', () => { + expect(valueInput.listValueField).toBeDefined(); + }); + + it('should have placeholder property', () => { + expect(valueInput.placeholder).toBeDefined(); + }); + + it('should have customPlaceholder property', () => { + expect(valueInput.customPlaceholder).toBeDefined(); + }); + + it('should have isHidden method', () => { + expect(valueInput.isHidden).toBeDefined(); + }); + + it('should have prevchange method', () => { + expect(valueInput.prevchange).toBeDefined(); + }); + + it('should have options method', () => { + expect(valueInput.options).toBeDefined(); + }); + + it('should have typeFunction method', () => { + expect(valueInput.typeFunction).toBeDefined(); + }); + + it('should have identifier property', () => { + expect(ValueInput.identifier).toBeDefined(); + }); + + it('should have getIdentifier method', () => { + expect(valueInput.getIdentifier).toBeDefined(); + }); +}); diff --git a/projects/workflows-creator/src/lib/services/statement/inputs/valuetype.input.spec.ts b/projects/workflows-creator/src/lib/services/statement/inputs/valuetype.input.spec.ts new file mode 100644 index 0000000..9ae5b4b --- /dev/null +++ b/projects/workflows-creator/src/lib/services/statement/inputs/valuetype.input.spec.ts @@ -0,0 +1,45 @@ +import {InputTypes} from '../../../enum'; +import {ValueTypeInput} from './valuetype.input'; + +describe('ValueTypeInput', () => { + let valueTypeInput: ValueTypeInput; + + beforeEach(() => { + valueTypeInput = new ValueTypeInput(); + }); + + it('should have prefix and suffix properties', () => { + expect(valueTypeInput.prefix).toEqual({state: 'valueTypePrefix'}); + expect(valueTypeInput.suffix).toEqual({state: 'valueTypeSuffix'}); + }); + + it('should have typeFunction property that returns InputTypes.List', () => { + expect(valueTypeInput.typeFunction()).toEqual(InputTypes.List); + }); + + it('should have inputKey property set to "valueType"', () => { + expect(valueTypeInput.inputKey).toEqual('valueType'); + }); + + it('should have listNameField property set to "text"', () => { + expect(valueTypeInput.listNameField).toEqual('text'); + }); + + it('should have listValueField property set to "value"', () => { + expect(valueTypeInput.listValueField).toEqual('value'); + }); + + it('should have placeholder property set to "Something"', () => { + expect(valueTypeInput.placeholder).toEqual('Something'); + }); + + it('should have static identifier property set to "ValueTypeInput"', () => { + expect(ValueTypeInput.identifier).toEqual('ValueTypeInput'); + }); + + describe('getIdentifier', () => { + it('should return the static identifier property', () => { + expect(valueTypeInput.getIdentifier()).toEqual(ValueTypeInput.identifier); + }); + }); +}); diff --git a/projects/workflows-creator/src/lib/types/event.types.spec.ts b/projects/workflows-creator/src/lib/types/event.types.spec.ts new file mode 100644 index 0000000..3fb244b --- /dev/null +++ b/projects/workflows-creator/src/lib/types/event.types.spec.ts @@ -0,0 +1,67 @@ +import {WorkflowPrompt} from '../classes/nodes/abstract-prompt.class'; +import {WorkflowAction} from '../classes/nodes/abstract-workflow-action.class'; +import {WorkflowEvent} from '../classes/nodes/abstract-workflow-event.class'; +import {WorkflowNode} from './base.types'; +import { + ActionAddition, + AllowedValues, + ChangeEvent, + EventAddition, + InputChanged, + isChangeEvent, +} from '.'; + +describe('YourFile Tests', () => { + let event: ChangeEvent; + let workflowEvent: WorkflowEvent; + let workflowAction: WorkflowAction; + let node: WorkflowNode; + let prompt: WorkflowPrompt; + let value: AllowedValues; + + beforeEach(() => { + event = { + target: { + value: 'example', + }, + }; + value = {}; + }); + + it('isChangeEvent should return true for a ChangeEvent', () => { + expect(isChangeEvent(event)).toBe(true); + }); + + it('isChangeEvent should return false for undefined', () => { + expect(isChangeEvent(undefined)).toBe(false); + }); + + it('EventAddition should create an EventAddition object', () => { + const addition: EventAddition = { + name: 'example', + event: workflowEvent, + }; + expect(addition.name).toBe('example'); + expect(addition.event).toBe(workflowEvent); + }); + + it('ActionAddition should create an ActionAddition object', () => { + const addition: ActionAddition = { + name: 'example', + action: workflowAction, + }; + expect(addition.name).toBe('example'); + expect(addition.action).toBe(workflowAction); + }); + + it('InputChanged should create an InputChanged object', () => { + const inputChanged: InputChanged = { + item: node, + field: 'exampleField', + value: value, + }; + expect(inputChanged.item).toBe(node); + expect(inputChanged.field).toBe('exampleField'); + expect(inputChanged.value).toBe(value); + }); +}); diff --git a/projects/workflows-element/package.json b/projects/workflows-element/package.json index 9253753..60e5761 100644 --- a/projects/workflows-element/package.json +++ b/projects/workflows-element/package.json @@ -17,6 +17,5 @@ "access": "public", "directory": "dist" }, - "hash": "52e16f7339ae099b920d5eba85c8551b9ac2178d0fdb8c34eb6eb6de8aa96685" - + "hash": "b3becb84440a55958bc16f9caf46b27fe1c7aab612e7fee3df4539591abee228" } \ No newline at end of file