-
Notifications
You must be signed in to change notification settings - Fork 0
/
remote-activity-adapter.test.ts
101 lines (91 loc) · 4.28 KB
/
remote-activity-adapter.test.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import 'reflect-metadata';
import { DefaultRemoteActivityAdapter } from './remote-activity-adapter';
import { ActivityDefinition } from '../activity-definition';
import { ContextResolutionStrategy } from '../../../context/resolution-strategies/resolution-stategy';
import { DecisionRunContext } from '../../../context/decision-run-context';
import { MockDecisionRunContext } from '../../../../testing/mocks/decision-run-context';
import { TestScheduler } from 'rxjs';
import { ChaiTestScheduler } from '../../../../testing/helpers/chai-test-scheduler';
import { Serializer } from '../../../application/serializer';
import { expect } from 'chai';
import * as sinon from 'sinon';
import { ScheduleActivityTaskDecisionAttributes } from '../../../../aws/aws.types';
import { RemoteObservableFactory, RemoteActivityObservable } from '../observable/remote-activity-observable';
import { MockSerializer } from '../../../../testing/mocks/serializer';
class MockContextResolutionStrategy implements ContextResolutionStrategy<DecisionRunContext> {
getContext(): DecisionRunContext {
return null;
}
}
class MockObservableFactory implements RemoteObservableFactory {
create(decisionContext: DecisionRunContext, scheduleParameters: ScheduleActivityTaskDecisionAttributes): RemoteActivityObservable {
return null;
}
}
const testActivityName = 'TestActivityName';
const testActivityVersion = 'test-version-123';
const testTaskList = 'test-task-list';
describe('RemoteActivityAdapter', () => {
let testScheduler: TestScheduler;
let runContext: DecisionRunContext;
let testValue: string;
let contextResolution: ContextResolutionStrategy<DecisionRunContext>;
let mockObservableFactory: RemoteObservableFactory;
let definition: ActivityDefinition;
let mockSerializer: Serializer;
beforeEach(() => {
testScheduler = new ChaiTestScheduler();
runContext = new MockDecisionRunContext();
contextResolution = new MockContextResolutionStrategy();
mockObservableFactory = new MockObservableFactory();
definition = new ActivityDefinition(testActivityName);
mockSerializer = new MockSerializer();
testValue = 'test';
definition.defaultTaskHeartbeatTimeout = '1111';
definition.defaultTaskPriority = ' def task priority';
definition.defaultTaskScheduleToCloseTimeout = '2222';
definition.defaultTaskScheduleToStartTimeout = '3333';
definition.defaultTaskStartToCloseTimeout = '4444';
definition.description = 'description';
definition.heartbeatTimeout = '5555';
definition.scheduleToCloseTimeout = '6666';
definition.scheduleToStartTimeout = '7777';
definition.startToCloseTimeout = '8888';
definition.taskPriority = 'task priority';
definition.version = testActivityVersion;
});
it('should create activity observable with schedule parameters', () => {
const nextId = '12234';
const testInput = 'test-input';
const activityObservable = {};
const createStub = sinon.stub().returns(activityObservable);
const stringifyStub = sinon.stub().returns(testInput);
const getContextStub = sinon.stub().returns(runContext);
const nextIdStub = sinon.stub().returns(nextId);
const testCallAttributes = [100, 'hello'];
const expectedScheduleParameters: ScheduleActivityTaskDecisionAttributes = {
activityType: {
name: testActivityName,
version: testActivityVersion,
},
activityId: nextId,
input: testInput,
scheduleToCloseTimeout: definition.scheduleToCloseTimeout,
taskList: {
name: testTaskList,
},
scheduleToStartTimeout: definition.scheduleToStartTimeout,
startToCloseTimeout: definition.startToCloseTimeout,
heartbeatTimeout: definition.heartbeatTimeout,
};
runContext.getNextId = nextIdStub;
contextResolution.getContext = getContextStub;
mockObservableFactory.create = createStub;
mockSerializer.stringify = stringifyStub;
definition.serializer = mockSerializer;
const remoteActivityAdapter = new DefaultRemoteActivityAdapter(contextResolution, definition, testTaskList, mockObservableFactory);
remoteActivityAdapter.createObservable(testCallAttributes);
expect(createStub.getCall(0).args).to.be.eql([runContext, expectedScheduleParameters, mockSerializer]);
expect(stringifyStub.getCall(0).args).to.be.eql([testCallAttributes]);
});
});