Skip to content

Commit 3316ddc

Browse files
horike37horike37
committed
add test stateMachine
1 parent 73875aa commit 3316ddc

File tree

4 files changed

+230
-16
lines changed

4 files changed

+230
-16
lines changed

‎lib/index.js‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -159,10 +159,10 @@ class ServerlessStepFunctions {
159159
.then(this.stateMachineRemove),
160160
'invoke:stepf:invoke': () => BbPromise.bind(this)
161161
.then(this.stateMachineInvoke),
162-
'deploy:tasks:deploy': () => BbPromise.bind(this)
163-
.then(this.tasksDeploy),
164-
'remove:tasks:remove': () => BbPromise.bind(this)
165-
.then(this.tasksRemove),
162+
// 'deploy:tasks:deploy': () => BbPromise.bind(this)
163+
// .then(this.tasksDeploy),
164+
// 'remove:tasks:remove': () => BbPromise.bind(this)
165+
// .then(this.tasksRemove),
166166
};
167167
}
168168

‎lib/index.test.js‎

Lines changed: 72 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -46,9 +46,8 @@ describe('ServerlessStepFunctions', () => {
4646
it('should set the provider variable to an instance of AwsProvider', () =>
4747
expect(serverlessStepFunctions.provider).to.be.instanceof(AwsProvider));
4848

49-
it('should have access to the serverless instance', () => {
50-
expect(serverlessStepFunctions.serverless).to.deep.equal(serverless);
51-
});
49+
it('should have access to the serverless instance', () =>
50+
expect(serverlessStepFunctions.serverless).to.deep.equal(serverless));
5251

5352
it('should set the region variable', () =>
5453
expect(serverlessStepFunctions.region).to.be.equal(provider.getRegion()));
@@ -110,7 +109,7 @@ describe('ServerlessStepFunctions', () => {
110109
});
111110

112111
describe('#stateMachineDeploy()', () => {
113-
it('should run promise chain in order', () => {
112+
it('should run promise chain in order when state is given', () => {
114113
const yamlParseStub = sinon
115114
.stub(serverlessStepFunctions, 'yamlParse').returns(BbPromise.resolve());
116115
const getStateMachineArnStub = sinon
@@ -147,8 +146,47 @@ describe('ServerlessStepFunctions', () => {
147146
});
148147
});
149148

149+
it('should run promise chain in order when state is not given', () => {
150+
serverlessStepFunctions.options.state = null;
151+
const yamlParseStub = sinon
152+
.stub(serverlessStepFunctions, 'yamlParse').returns(BbPromise.resolve());
153+
const getStateMachineNamesStub = sinon
154+
.stub(serverlessStepFunctions, 'getStateMachineNames').returns(BbPromise.resolve());
155+
const getFunctionArnsStub = sinon
156+
.stub(serverlessStepFunctions, 'getFunctionArns').returns(BbPromise.resolve());
157+
const compileAllStub = sinon
158+
.stub(serverlessStepFunctions, 'compileAll').returns(BbPromise.resolve());
159+
const getIamRolesStub = sinon
160+
.stub(serverlessStepFunctions, 'getIamRoles').returns(BbPromise.resolve());
161+
const deleteStateMachinesStub = sinon
162+
.stub(serverlessStepFunctions, 'deleteStateMachines').returns(BbPromise.resolve());
163+
const createStateMachinesStub = sinon
164+
.stub(serverlessStepFunctions, 'createStateMachines').returns(BbPromise.resolve());
165+
166+
return serverlessStepFunctions.stateMachineDeploy()
167+
.then(() => {
168+
expect(yamlParseStub.calledOnce).to.be.equal(true);
169+
expect(getStateMachineNamesStub.calledAfter(yamlParseStub)).to.be.equal(true);
170+
expect(getFunctionArnsStub.calledAfter(getStateMachineNamesStub)).to.be.equal(true);
171+
expect(compileAllStub.calledAfter(getFunctionArnsStub)).to.be.equal(true);
172+
expect(getIamRolesStub.calledAfter(compileAllStub)).to.be.equal(true);
173+
expect(deleteStateMachinesStub.calledAfter(getIamRolesStub)).to.be.equal(true);
174+
expect(createStateMachinesStub.calledAfter(deleteStateMachinesStub)).to.be.equal(true);
175+
176+
serverlessStepFunctions.yamlParse.restore();
177+
serverlessStepFunctions.getStateMachineNames.restore();
178+
serverlessStepFunctions.getFunctionArns.restore();
179+
serverlessStepFunctions.compileAll.restore();
180+
serverlessStepFunctions.getIamRoles.restore();
181+
serverlessStepFunctions.deleteStateMachines.restore();
182+
serverlessStepFunctions.createStateMachines.restore();
183+
});
184+
});
185+
150186
describe('#stateMachineRemove()', () => {
151-
it('should run promise chain in order', () => {
187+
it('should run promise chain in order when state is given', () => {
188+
const yamlParseStub = sinon
189+
.stub(serverlessStepFunctions, 'yamlParse').returns(BbPromise.resolve());
152190
const deleteIamRoleStub = sinon
153191
.stub(serverlessStepFunctions, 'deleteIamRole').returns(BbPromise.resolve());
154192
const getStateMachineArnStub = sinon
@@ -158,14 +196,42 @@ describe('ServerlessStepFunctions', () => {
158196

159197
return serverlessStepFunctions.stateMachineRemove()
160198
.then(() => {
161-
expect(deleteIamRoleStub.calledOnce).to.be.equal(true);
199+
expect(yamlParseStub.calledOnce).to.be.equal(true);
200+
expect(deleteIamRoleStub.calledAfter(yamlParseStub)).to.be.equal(true);
162201
expect(getStateMachineArnStub.calledAfter(deleteIamRoleStub)).to.be.equal(true);
163202
expect(deleteStateMachineStub.calledAfter(getStateMachineArnStub)).to.be.equal(true);
164203

204+
serverlessStepFunctions.yamlParse.restore();
205+
serverlessStepFunctions.deleteIamRole.restore();
165206
serverlessStepFunctions.getStateMachineArn.restore();
166207
serverlessStepFunctions.deleteStateMachine.restore();
167208
});
168209
});
210+
211+
it('should run promise chain in order when state is not given', () => {
212+
serverlessStepFunctions.options.state = null;
213+
const yamlParseStub = sinon
214+
.stub(serverlessStepFunctions, 'yamlParse').returns(BbPromise.resolve());
215+
const deleteIamRolesStub = sinon
216+
.stub(serverlessStepFunctions, 'deleteIamRoles').returns(BbPromise.resolve());
217+
const getStateMachineNamesStub = sinon
218+
.stub(serverlessStepFunctions, 'getStateMachineNames').returns(BbPromise.resolve());
219+
const deleteStateMachinesStub = sinon
220+
.stub(serverlessStepFunctions, 'deleteStateMachines').returns(BbPromise.resolve());
221+
222+
return serverlessStepFunctions.stateMachineRemove()
223+
.then(() => {
224+
expect(yamlParseStub.calledOnce).to.be.equal(true);
225+
expect(deleteIamRolesStub.calledAfter(yamlParseStub)).to.be.equal(true);
226+
expect(getStateMachineNamesStub.calledAfter(deleteIamRolesStub)).to.be.equal(true);
227+
expect(deleteStateMachinesStub.calledAfter(getStateMachineNamesStub)).to.be.equal(true);
228+
229+
serverlessStepFunctions.yamlParse.restore();
230+
serverlessStepFunctions.deleteIamRoles.restore();
231+
serverlessStepFunctions.getStateMachineNames.restore();
232+
serverlessStepFunctions.deleteStateMachines.restore();
233+
});
234+
});
169235
});
170236

171237
describe('#stateMachineInvoke()', () => {

‎lib/stateMachine.js‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -82,6 +82,7 @@ module.exports = {
8282
return this.setTimeout()
8383
.then(() => this.createStateMachine(stateMachine));
8484
}
85+
8586
throw new this.serverless.classes.Error(error.message);
8687
});
8788
},

‎lib/stateMachine.test.js‎

Lines changed: 153 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -45,6 +45,23 @@ describe('stateMachine', () => {
4545
.returns(BbPromise.resolve({ Account: 1234 }));
4646
});
4747

48+
it('should getStateMachineStub when correct params is not given'
49+
, () => serverlessStepFunctions.getStateMachineArn()
50+
.then(() => {
51+
expect(getStateMachineStub.calledOnce).to.be.equal(true);
52+
expect(getStateMachineStub.calledWithExactly(
53+
'STS',
54+
'getCallerIdentity',
55+
{},
56+
serverlessStepFunctions.options.stage,
57+
serverlessStepFunctions.options.region
58+
)).to.be.equal(true);
59+
expect(serverlessStepFunctions.stateMachineArns.hellofunc).to.be
60+
.equal('arn:aws:states:us-east-1:1234:stateMachine:step-functions-dev-hellofunc');
61+
serverlessStepFunctions.provider.request.restore();
62+
})
63+
);
64+
4865
it('should getStateMachineStub with correct params'
4966
, () => serverlessStepFunctions.getStateMachineArn('state')
5067
.then(() => {
@@ -78,7 +95,7 @@ describe('stateMachine', () => {
7895
'StepFunctions',
7996
'deleteStateMachine',
8097
{
81-
stateMachineArn: serverlessStepFunctions.stateMachineArn,
98+
stateMachineArn: serverlessStepFunctions.stateMachineArns.hellofunc,
8299
},
83100
serverlessStepFunctions.options.stage,
84101
serverlessStepFunctions.options.region
@@ -93,9 +110,30 @@ describe('stateMachine', () => {
93110
beforeEach(() => {
94111
createStateMachineStub = sinon.stub(serverlessStepFunctions.provider, 'request')
95112
.returns(BbPromise.resolve());
96-
serverlessStepFunctions.serverless.service.stepFunctions = { state: 'state' };
113+
serverless.service.stepFunctions = { state: 'state' };
97114
});
98115

116+
it('should createStateMachine when correct params is not given'
117+
, () => serverlessStepFunctions.createStateMachine()
118+
.then(() => {
119+
const stage = serverlessStepFunctions.options.stage;
120+
expect(createStateMachineStub.calledOnce).to.be.equal(true);
121+
expect(createStateMachineStub.calledWithExactly(
122+
'StepFunctions',
123+
'createStateMachine',
124+
{
125+
definition: serverlessStepFunctions
126+
.serverless.service.stepFunctions.hellofunc,
127+
name: `${serverless.service.service}-${stage}-hellofunc`,
128+
roleArn: serverlessStepFunctions.iamRoleArn.hellofunc,
129+
},
130+
serverlessStepFunctions.options.stage,
131+
serverlessStepFunctions.options.region
132+
)).to.be.equal(true);
133+
serverlessStepFunctions.provider.request.restore();
134+
})
135+
);
136+
99137
it('should createStateMachine with correct params'
100138
, () => serverlessStepFunctions.createStateMachine('state')
101139
.then(() => {
@@ -116,6 +154,33 @@ describe('stateMachine', () => {
116154
serverlessStepFunctions.provider.request.restore();
117155
})
118156
);
157+
158+
it('should throw error when createStateMachineStub throw error', () => {
159+
serverlessStepFunctions.provider.request.restore();
160+
createStateMachineStub = sinon.stub(serverlessStepFunctions.provider, 'request')
161+
.returns(BbPromise.reject(new Error('some error')));
162+
163+
serverlessStepFunctions.createStateMachine().catch((error) => {
164+
expect(error.message).to.be.equal('some error');
165+
serverlessStepFunctions.provider.request.restore();
166+
});
167+
});
168+
169+
it('should do setTimeout when createStateMachineStub throw a certain error',
170+
() => {
171+
serverlessStepFunctions.provider.request.restore();
172+
createStateMachineStub = sinon.stub(serverlessStepFunctions.provider, 'request')
173+
.returns(BbPromise.reject(new Error('some State Machine is being deleted error')));
174+
const setTimeoutStub = sinon.stub(serverlessStepFunctions, 'setTimeout')
175+
.returns(BbPromise.reject());
176+
177+
serverlessStepFunctions.createStateMachine().catch(() => {
178+
expect(createStateMachineStub.calledOnce).to.be.equal(true);
179+
expect(setTimeoutStub.calledOnce).to.be.equal(true);
180+
serverlessStepFunctions.provider.request.restore();
181+
serverlessStepFunctions.setTimeout.restore();
182+
});
183+
});
119184
});
120185

121186
describe('#startExecution()', () => {
@@ -132,7 +197,7 @@ describe('stateMachine', () => {
132197
'StepFunctions',
133198
'startExecution',
134199
{
135-
stateMachineArn: serverlessStepFunctions.stateMachineArn,
200+
stateMachineArn: serverlessStepFunctions.stateMachineArns.hellofunc,
136201
input: serverlessStepFunctions.options.data,
137202
},
138203
serverlessStepFunctions.options.stage,
@@ -165,6 +230,30 @@ describe('stateMachine', () => {
165230
serverlessStepFunctions.provider.request.restore();
166231
});
167232
});
233+
234+
it('should do describeExecution once when status is RUNNING', () => {
235+
describeExecutionStub = sinon.stub(serverlessStepFunctions.provider, 'request')
236+
.returns(BbPromise.resolve({ status: 'RUNNING' }));
237+
const setTimeoutStub = sinon.stub(serverlessStepFunctions, 'setTimeout')
238+
.returns(BbPromise.reject());
239+
240+
serverlessStepFunctions.describeExecution()
241+
.then(() => {
242+
expect(describeExecutionStub.calledOnce).to.be.equal(true);
243+
expect(describeExecutionStub.calledWithExactly(
244+
'StepFunctions',
245+
'describeExecution',
246+
{
247+
executionArn: serverlessStepFunctions.executionArn,
248+
},
249+
serverlessStepFunctions.options.stage,
250+
serverlessStepFunctions.options.region
251+
)).to.be.equal(true);
252+
expect(setTimeoutStub.calledOnce).to.be.equal(true);
253+
serverlessStepFunctions.provider.request.restore();
254+
serverlessStepFunctions.setTimeout.restore();
255+
});
256+
});
168257
});
169258

170259
describe('#getExecutionHistory()', () => {
@@ -193,14 +282,72 @@ describe('stateMachine', () => {
193282
});
194283

195284
describe('#getStateMachineNames()', () => {
196-
// @todo
285+
let getStateMachineNamesStub;
286+
beforeEach(() => {
287+
serverless.service.stepFunctions = {
288+
helloHello: 'value',
289+
};
290+
getStateMachineNamesStub = sinon.stub(serverlessStepFunctions.provider, 'request')
291+
.returns(BbPromise.resolve({ Account: 1234 }));
292+
});
293+
294+
it('should getStateMachineNames with correct params'
295+
, () => serverlessStepFunctions.getStateMachineNames()
296+
.then(() => {
297+
expect(getStateMachineNamesStub.calledOnce).to.be.equal(true);
298+
expect(getStateMachineNamesStub.calledWithExactly(
299+
'STS',
300+
'getCallerIdentity',
301+
{},
302+
serverlessStepFunctions.options.stage,
303+
serverlessStepFunctions.options.region
304+
)).to.be.equal(true);
305+
306+
expect(serverlessStepFunctions.stateMachineArns.helloHello).to.be
307+
.equal('arn:aws:states:us-east-1:1234:stateMachine:step-functions-dev-helloHello');
308+
serverlessStepFunctions.provider.request.restore();
309+
})
310+
);
197311
});
198312

199313
describe('#deleteStateMachines()', () => {
200-
// @todo
314+
let deleteStateMachineStub;
315+
beforeEach(() => {
316+
serverless.service.stepFunctions = {
317+
helloHello: 'value',
318+
hogeHoge: 'value',
319+
};
320+
deleteStateMachineStub = sinon
321+
.stub(serverlessStepFunctions, 'deleteStateMachine').returns(BbPromise.resolve());
322+
});
323+
324+
it('should deleteStateMachines with correct params'
325+
, () => serverlessStepFunctions.deleteStateMachines()
326+
.then(() => {
327+
expect(deleteStateMachineStub.calledTwice).to.be.equal(true);
328+
serverlessStepFunctions.deleteStateMachine.restore();
329+
})
330+
);
201331
});
202332

203333
describe('#createStateMachines()', () => {
204-
// @todo
334+
let createStateMachineStub;
335+
beforeEach(() => {
336+
serverless.service.stepFunctions = {
337+
helloHello: 'value',
338+
hogeHoge: 'value',
339+
sssss: 'value',
340+
};
341+
createStateMachineStub = sinon
342+
.stub(serverlessStepFunctions, 'createStateMachine').returns(BbPromise.resolve());
343+
});
344+
345+
it('should createStateMachines with correct params'
346+
, () => serverlessStepFunctions.createStateMachines()
347+
.then(() => {
348+
expect(createStateMachineStub.calledThrice).to.be.equal(true);
349+
serverlessStepFunctions.createStateMachine.restore();
350+
})
351+
);
205352
});
206353
});

0 commit comments

Comments
 (0)