-
Notifications
You must be signed in to change notification settings - Fork 0
/
actor-proxy-factory.test.ts
112 lines (99 loc) · 4.28 KB
/
actor-proxy-factory.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
102
103
104
105
106
107
108
109
110
111
112
import 'reflect-metadata';
import { RemoteActorProxyFactory } from './actor-proxy-factory';
import { ContextResolutionStrategy } from '../../context/resolution-strategies/resolution-stategy';
import { DecisionRunContext } from '../../context/decision-run-context';
import {
RemoteActivityAdapterFactory, DefaultRemoteActivityAdapter,
RemoteActivityAdapter,
} from '../activity/adapters/remote-activity-adapter';
import { ActivityDefinition } from '../activity/activity-definition';
import { version, scheduleToCloseTimeout, serializer } from '../activity/decorators/activity-decorators';
import { MockSerializer } from '../../../testing/mocks/serializer';
import { expect } from 'chai';
import { Observable } from 'rxjs';
import * as sinon from 'sinon';
import { getPropertyLevelDefinitionsFromClass } from '../../utils/decorators/utils';
import { RemoteObservableFactory, RemoteActivityObservable } from '../activity/observable/remote-activity-observable';
class MockRemoteActivityAdapterFactory implements RemoteActivityAdapterFactory {
create(contextResolutionStrategy: ContextResolutionStrategy<DecisionRunContext>,
activityDefinition: ActivityDefinition,
taskList: string,
observableFactory?: RemoteObservableFactory): DefaultRemoteActivityAdapter {
return null;
}
}
class MockContextResolutionStrategy implements ContextResolutionStrategy<DecisionRunContext> {
getContext(): DecisionRunContext {
return null;
}
}
class MockRemoteActivityAdapter implements RemoteActivityAdapter {
public createObservable(callParams: any[]): RemoteActivityObservable {
return null;
}
}
const testTaskList = 'test-task-list';
interface Test {
test1(val: any): Observable<any>;
test2(): Observable<any>;
}
class TestImpl implements Test {
@version('1-b')
@scheduleToCloseTimeout('12345')
@serializer(new MockSerializer())
public test1(val: any): Observable<any> {
return null;
}
@version('2')
@scheduleToCloseTimeout('3210')
public test2(): Observable<any> {
return null;
}
}
describe('RemoteActorProxyFactory', () => {
let contextResolutionStrategy: ContextResolutionStrategy<DecisionRunContext>;
let remoteActivityAdapterFactory: RemoteActivityAdapterFactory;
beforeEach(() => {
contextResolutionStrategy = new MockContextResolutionStrategy();
remoteActivityAdapterFactory = new MockRemoteActivityAdapterFactory();
});
it('should create a proxy from the Implementation', () => {
remoteActivityAdapterFactory.create = sinon.stub().returns(new MockRemoteActivityAdapter());
const remoteActorProxyFactory = new RemoteActorProxyFactory(contextResolutionStrategy, remoteActivityAdapterFactory);
const actor = remoteActorProxyFactory.create<Test>(TestImpl, testTaskList);
expect(actor.test1).to.be.a('function');
expect(actor.test2).to.be.a('function');
});
it('should call adapter', () => {
const adapter = new MockRemoteActivityAdapter();
const testResult = {
d: 'test',
};
const createObservableStub = sinon.stub().returns(testResult);
adapter.createObservable = createObservableStub;
remoteActivityAdapterFactory.create = sinon.stub().returns(adapter);
const remoteActorProxyFactory = new RemoteActorProxyFactory(contextResolutionStrategy, remoteActivityAdapterFactory);
const actor = remoteActorProxyFactory.create<Test>(TestImpl, testTaskList);
const test = actor.test1('hello');
expect(test).to.be.eq(testResult);
expect(createObservableStub.getCall(0).args).to.be.eql([['hello']]);
});
it('should create adapter with proper data', () => {
const adapter = new MockRemoteActivityAdapter();
const createStub = sinon.stub().returns(adapter);
remoteActivityAdapterFactory.create = createStub;
const remoteActorProxyFactory = new RemoteActorProxyFactory(contextResolutionStrategy, remoteActivityAdapterFactory);
remoteActorProxyFactory.create<Test>(TestImpl, testTaskList);
const definitions: ActivityDefinition[] = getPropertyLevelDefinitionsFromClass<ActivityDefinition>(TestImpl);
expect(createStub.getCall(0).args).to.be.eql([
contextResolutionStrategy,
definitions[0],
testTaskList,
]);
expect(createStub.getCall(1).args).to.be.eql([
contextResolutionStrategy,
definitions[1],
testTaskList,
]);
});
});