kumogata 0.5.2 → 0.5.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (15) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +2 -0
  3. data/lib/kumogata/argument_parser.rb +1 -0
  4. data/lib/kumogata/client.rb +9 -0
  5. data/lib/kumogata/version.rb +1 -1
  6. data/spec/kumogata_create_spec.rb +249 -249
  7. data/spec/kumogata_delete_spec.rb +12 -12
  8. data/spec/kumogata_export_spec.rb +8 -8
  9. data/spec/kumogata_list_spec.rb +15 -15
  10. data/spec/kumogata_show_events_spec.rb +14 -14
  11. data/spec/kumogata_show_outputs_spec.rb +6 -6
  12. data/spec/kumogata_show_resources_spec.rb +4 -4
  13. data/spec/kumogata_update_spec.rb +257 -200
  14. data/spec/kumogata_validate_spec.rb +55 -4
  15. metadata +2 -2
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: d3d4297faba5052990897c2b20bff4f2df6596c6
4
- data.tar.gz: 85f974cbb9005965628da8426ee9dc388ca526a9
3
+ metadata.gz: 19f66a07b454ab92e7351753a201b112702efcc7
4
+ data.tar.gz: 189130373b0ba7b733acf56ddb4cafc296ccd907
5
5
  SHA512:
6
- metadata.gz: 389adcc45a93fb312a3d3bcc30ad44c677d25e0be5b7a9af1cd08462acf83e9a31a9854abf7247b55a483f7944747e8e226882b367225669fb6c045fe02975b9
7
- data.tar.gz: e9353c00726d0b8699f1957239d17ac51dae691408f3af041a2dc0fd7501522f82e3ee00de3c695c359f217b7d96508c64e722656fec529b275235d962e4380d
6
+ metadata.gz: 66df3ba400dcbb14e5888e3dd125406c594e514633cb6fb3329d02bd85c08c4aa4c5dcfe659392a6b3753a261326272e227a3a241beba68a6df12d6b8a5f2946
7
+ data.tar.gz: 1aa6c374292cf938e5cd2e7d29044dcdc34c0fe444c9ce3a70df1044680a902cd3c1738602eacd43b0f9794cfb6614a2b2ea4987557aa4ac699be94c3e5188e2
data/README.md CHANGED
@@ -98,6 +98,7 @@ Options:
98
98
  --skip-replace-underscore
99
99
  --deletion-policy-retain
100
100
  -p, --parameters KEY_VALUES
101
+ -j, --json-parameters JSON
101
102
  -e, --encrypt-parameters KEYS
102
103
  --encryption-password PASS
103
104
  --skip-send-password
@@ -113,6 +114,7 @@ Options:
113
114
  --color
114
115
  --no-color
115
116
  --debug
117
+ -v, --verbose
116
118
  ```
117
119
 
118
120
  ### KUMOGATA_OPTIONS
data/lib/kumogata/argument_parser.rb CHANGED
@@ -107,6 +107,7 @@ class Kumogata::ArgumentParser
107
107
  opt.on('' , '--color') { options[:color] = true }
108
108
  opt.on('' , '--no-color') { options[:color] = false }
109
109
  opt.on('' , '--debug') { options[:debug] = true }
110
+ opt.on('-v', '--verbose') { options[:verbose] = true }
110
111
  opt.parse!
111
112
 
112
113
  unless (command = ARGV.shift)
data/lib/kumogata/client.rb CHANGED
@@ -521,6 +521,11 @@ class Kumogata::Client
521
521
  def build_update_options(template)
522
522
  opts = {:template => template}
523
523
  add_parameters(opts)
524
+
525
+ [:capabilities].each do |k|
526
+ opts[k] = @options[k] if @options[k]
527
+ end
528
+
524
529
  return opts
525
530
  end
526
531
 
@@ -589,6 +594,10 @@ class Kumogata::Client
589
594
  end
590
595
 
591
596
  Kumogata.logger.info('Template validated successfully'.green)
597
+
598
+ if @options.verbose
599
+ Kumogata.logger.info(JSON.pretty_generate(JSON.parse(result.to_json)).colorize_as(:json))
600
+ end
592
601
  end
593
602
 
594
603
  def events_for(stack)
data/lib/kumogata/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module Kumogata
2
- VERSION = '0.5.2'
2
+ VERSION = '0.5.3'
3
3
  end
data/spec/kumogata_create_spec.rb CHANGED
@@ -22,40 +22,40 @@ end
22
22
 
23
23
  run_client(:create, :template => template) do |client, cf|
24
24
  json = eval_template(template, :update_deletion_policy => true).to_json
25
- client.should_receive(:print_event_log).twice
26
- client.should_receive(:create_event_log).once
25
+ expect(client).to receive(:print_event_log).twice
26
+ expect(client).to receive(:create_event_log).once
27
27
 
28
28
  output = make_double('output') do |obj|
29
- obj.should_receive(:key) { 'AZ' }
30
- obj.should_receive(:value) { 'ap-northeast-1b' }
29
+ expect(obj).to receive(:key) { 'AZ' }
30
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
31
31
  end
32
32
 
33
33
  resource_summary = make_double('resource_summary') do |obj|
34
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
35
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
36
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
37
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
38
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
39
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
34
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
35
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
36
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
37
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
38
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
39
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
40
40
  end
41
41
 
42
42
  stack = make_double('stack') do |obj|
43
- obj.should_receive(:status).and_return(
43
+ expect(obj).to receive(:status).and_return(
44
44
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
45
45
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
46
- obj.should_receive(:outputs) { [output] }
47
- obj.should_receive(:resource_summaries) { [resource_summary] }
48
- obj.should_receive(:delete)
46
+ expect(obj).to receive(:outputs) { [output] }
47
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
48
+ expect(obj).to receive(:delete)
49
49
  end
50
50
 
51
51
  stacks = make_double('stacks') do |obj|
52
- obj.should_receive(:create)
52
+ expect(obj).to receive(:create)
53
53
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
54
- obj.should_receive(:[])
54
+ expect(obj).to receive(:[])
55
55
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
56
56
  end
57
57
 
58
- cf.should_receive(:stacks).twice { stacks }
58
+ expect(cf).to receive(:stacks).twice { stacks }
59
59
  end
60
60
  end
61
61
 
@@ -82,23 +82,23 @@ end
82
82
 
83
83
  out = run_client(:create, :template => template, :options => {:detach => true}) do |client, cf|
84
84
  json = eval_template(template, :update_deletion_policy => true).to_json
85
- client.should_not_receive(:print_event_log)
86
- client.should_not_receive(:create_event_log)
85
+ expect(client).not_to receive(:print_event_log)
86
+ expect(client).not_to receive(:create_event_log)
87
87
 
88
88
  stack = make_double('stack') do |obj|
89
- obj.should_not_receive(:status)
90
- obj.should_not_receive(:outputs)
91
- obj.should_not_receive(:resource_summaries)
92
- obj.should_not_receive(:delete)
89
+ expect(obj).not_to receive(:status)
90
+ expect(obj).not_to receive(:outputs)
91
+ expect(obj).not_to receive(:resource_summaries)
92
+ expect(obj).not_to receive(:delete)
93
93
  end
94
94
 
95
95
  stacks = make_double('stacks') do |obj|
96
- obj.should_receive(:create)
96
+ expect(obj).to receive(:create)
97
97
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
98
- obj.should_not_receive(:[])
98
+ expect(obj).not_to receive(:[])
99
99
  end
100
100
 
101
- cf.should_receive(:stacks).once { stacks }
101
+ expect(cf).to receive(:stacks).once { stacks }
102
102
  end
103
103
 
104
104
  expect(out).to be_nil
@@ -148,72 +148,72 @@ end
148
148
 
149
149
  run_client(:create, :template => template) do |client, cf|
150
150
  json = eval_template(template, :update_deletion_policy => true).to_json
151
- client.should_receive(:print_event_log).twice
152
- client.should_receive(:create_event_log).once
151
+ expect(client).to receive(:print_event_log).twice
152
+ expect(client).to receive(:create_event_log).once
153
153
 
154
154
  output1 = make_double('output') do |obj|
155
- obj.should_receive(:key) { 'AZ' }
156
- obj.should_receive(:value) { 'ap-northeast-1b' }
155
+ expect(obj).to receive(:key) { 'AZ' }
156
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
157
157
  end
158
158
 
159
159
  output2 = make_double('output') do |obj|
160
- obj.should_receive(:key) { 'Region' }
161
- obj.should_receive(:value) { 'ap-northeast-1' }
160
+ expect(obj).to receive(:key) { 'Region' }
161
+ expect(obj).to receive(:value) { 'ap-northeast-1' }
162
162
  end
163
163
 
164
164
  resource_summary = make_double('resource_summary') do |obj|
165
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
166
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
167
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
168
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
169
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
170
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
165
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
166
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
167
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
168
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
169
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
170
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
171
171
  end
172
172
 
173
173
  stack = make_double('stack') do |obj|
174
- obj.should_receive(:status).and_return(
174
+ expect(obj).to receive(:status).and_return(
175
175
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
176
176
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
177
- obj.should_receive(:outputs) { [output1, output2] }
178
- obj.should_receive(:resource_summaries) { [resource_summary] }
179
- obj.should_receive(:delete)
177
+ expect(obj).to receive(:outputs) { [output1, output2] }
178
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
179
+ expect(obj).to receive(:delete)
180
180
  end
181
181
 
182
182
  stacks = make_double('stacks') do |obj|
183
- obj.should_receive(:create)
183
+ expect(obj).to receive(:create)
184
184
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
185
- obj.should_receive(:[])
185
+ expect(obj).to receive(:[])
186
186
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
187
187
  end
188
188
 
189
- cf.should_receive(:stacks).twice { stacks }
189
+ expect(cf).to receive(:stacks).twice { stacks }
190
190
 
191
- process_status1 = make_double('process_status1') {|obj| obj.should_receive(:to_i).and_return(0) }
192
- process_status2 = make_double('process_status2') {|obj| obj.should_receive(:to_i).and_return(0) }
191
+ process_status1 = make_double('process_status1') {|obj| expect(obj).to receive(:to_i).and_return(0) }
192
+ process_status2 = make_double('process_status2') {|obj| expect(obj).to receive(:to_i).and_return(0) }
193
193
 
194
- client.instance_variable_get(:@post_processing)
195
- .should_receive(:run_shell_command)
194
+ expect(client.instance_variable_get(:@post_processing))
195
+ .to receive(:run_shell_command)
196
196
  .with(" echo <%= Key \"AZ\" %>\n echo <%= Key \"Region\" %>\n", {"AZ"=>"ap-northeast-1b", "Region"=>"ap-northeast-1"})
197
197
  .and_return(["ap-northeast-1b\nap-northeast-1\n", "", process_status1])
198
- client.instance_variable_get(:@post_processing)
199
- .should_receive(:run_shell_command)
198
+ expect(client.instance_variable_get(:@post_processing))
199
+ .to receive(:run_shell_command)
200
200
  .with(" echo <%= Key \"Region\" %>\n echo <%= Key \"AZ\" %>\n", {"AZ"=>"ap-northeast-1b", "Region"=>"ap-northeast-1"})
201
201
  .and_return(["ap-northeast-1\nap-northeast-1b\n", "", process_status2])
202
202
 
203
- client.instance_variable_get(:@post_processing)
204
- .should_receive(:print_command).with('command_a')
205
- client.instance_variable_get(:@post_processing)
206
- .should_receive(:print_command).with('command_b')
203
+ expect(client.instance_variable_get(:@post_processing))
204
+ .to receive(:print_command).with('command_a')
205
+ expect(client.instance_variable_get(:@post_processing))
206
+ .to receive(:print_command).with('command_b')
207
207
 
208
- client.instance_variable_get(:@post_processing)
209
- .should_receive(:print_command_result)
208
+ expect(client.instance_variable_get(:@post_processing))
209
+ .to receive(:print_command_result)
210
210
  .with("ap-northeast-1b\nap-northeast-1\n", "", process_status1)
211
- client.instance_variable_get(:@post_processing)
212
- .should_receive(:print_command_result)
211
+ expect(client.instance_variable_get(:@post_processing))
212
+ .to receive(:print_command_result)
213
213
  .with("ap-northeast-1\nap-northeast-1b\n", "", process_status2)
214
214
 
215
- client.instance_variable_get(:@post_processing)
216
- .should_receive(:save_command_results)
215
+ expect(client.instance_variable_get(:@post_processing))
216
+ .to receive(:save_command_results)
217
217
  .with([{'command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\nap-northeast-1\n", 'StdErr' => ""}},
218
218
  {'command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\nap-northeast-1b\n", 'StdErr' => ""}}])
219
219
  end
@@ -254,55 +254,55 @@ end
254
254
 
255
255
  run_client(:create, :template => template) do |client, cf|
256
256
  json = eval_template(template, :update_deletion_policy => true).to_json
257
- client.should_receive(:print_event_log).twice
258
- client.should_receive(:create_event_log).once
257
+ expect(client).to receive(:print_event_log).twice
258
+ expect(client).to receive(:create_event_log).once
259
259
 
260
260
  output = make_double('output') do |obj|
261
- obj.should_receive(:key) { 'PublicIp' }
262
- obj.should_receive(:value) { '127.0.0.1' }
261
+ expect(obj).to receive(:key) { 'PublicIp' }
262
+ expect(obj).to receive(:value) { '127.0.0.1' }
263
263
  end
264
264
 
265
265
  resource_summary = make_double('resource_summary') do |obj|
266
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
267
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
268
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
269
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
270
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
271
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
266
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
267
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
268
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
269
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
270
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
271
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
272
272
  end
273
273
 
274
274
  stack = make_double('stack') do |obj|
275
- obj.should_receive(:status).and_return(
275
+ expect(obj).to receive(:status).and_return(
276
276
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
277
277
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
278
- obj.should_receive(:outputs) { [output] }
279
- obj.should_receive(:resource_summaries) { [resource_summary] }
280
- obj.should_receive(:delete)
278
+ expect(obj).to receive(:outputs) { [output] }
279
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
280
+ expect(obj).to receive(:delete)
281
281
  end
282
282
 
283
283
  stacks = make_double('stacks') do |obj|
284
- obj.should_receive(:create)
284
+ expect(obj).to receive(:create)
285
285
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
286
- obj.should_receive(:[])
286
+ expect(obj).to receive(:[])
287
287
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
288
288
  end
289
289
 
290
- cf.should_receive(:stacks).twice { stacks }
290
+ expect(cf).to receive(:stacks).twice { stacks }
291
291
 
292
- client.instance_variable_get(:@post_processing)
293
- .should_receive(:run_ssh_command)
292
+ expect(client.instance_variable_get(:@post_processing))
293
+ .to receive(:run_ssh_command)
294
294
  .with({"host"=>"<%= Key \"PublicIp\" %>", "user"=>"ec2-user", "request_pty"=>true}, " ls\n", {"PublicIp"=>"127.0.0.1"})
295
295
  .and_return(["file1\nfile2\n", "", 0])
296
296
 
297
- client.instance_variable_get(:@post_processing)
298
- .should_receive(:print_command).with('ssh_command')
297
+ expect(client.instance_variable_get(:@post_processing))
298
+ .to receive(:print_command).with('ssh_command')
299
299
 
300
- client.instance_variable_get(:@post_processing)
301
- .should_receive(:print_command_result)
300
+ expect(client.instance_variable_get(:@post_processing))
301
+ .to receive(:print_command_result)
302
302
  .with("file1\nfile2\n", "", 0)
303
303
 
304
- client.instance_variable_get(:@post_processing)
305
- .should_receive(:save_command_results)
304
+ expect(client.instance_variable_get(:@post_processing))
305
+ .to receive(:save_command_results)
306
306
  .with([{'ssh_command' => {'ExitStatus' => 0, 'StdOut' => "file1\nfile2\n", 'StdErr' => ""}}])
307
307
  end
308
308
  end
@@ -346,55 +346,55 @@ end
346
346
 
347
347
  run_client(:create, :template => template) do |client, cf|
348
348
  json = eval_template(template, :update_deletion_policy => true).to_json
349
- client.should_receive(:print_event_log).twice
350
- client.should_receive(:create_event_log).once
349
+ expect(client).to receive(:print_event_log).twice
350
+ expect(client).to receive(:create_event_log).once
351
351
 
352
352
  output = make_double('output') do |obj|
353
- obj.should_receive(:key) { 'PublicIp' }
354
- obj.should_receive(:value) { '127.0.0.1' }
353
+ expect(obj).to receive(:key) { 'PublicIp' }
354
+ expect(obj).to receive(:value) { '127.0.0.1' }
355
355
  end
356
356
 
357
357
  resource_summary = make_double('resource_summary') do |obj|
358
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
359
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
360
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
361
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
362
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
363
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
358
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
359
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
360
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
361
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
362
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
363
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
364
364
  end
365
365
 
366
366
  stack = make_double('stack') do |obj|
367
- obj.should_receive(:status).and_return(
367
+ expect(obj).to receive(:status).and_return(
368
368
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
369
369
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
370
- obj.should_receive(:outputs) { [output] }
371
- obj.should_receive(:resource_summaries) { [resource_summary] }
372
- obj.should_receive(:delete)
370
+ expect(obj).to receive(:outputs) { [output] }
371
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
372
+ expect(obj).to receive(:delete)
373
373
  end
374
374
 
375
375
  stacks = make_double('stacks') do |obj|
376
- obj.should_receive(:create)
376
+ expect(obj).to receive(:create)
377
377
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
378
- obj.should_receive(:[])
378
+ expect(obj).to receive(:[])
379
379
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
380
380
  end
381
381
 
382
- cf.should_receive(:stacks).twice { stacks }
382
+ expect(cf).to receive(:stacks).twice { stacks }
383
383
 
384
- client.instance_variable_get(:@post_processing)
385
- .should_receive(:run_ssh_command)
384
+ expect(client.instance_variable_get(:@post_processing))
385
+ .to receive(:run_ssh_command)
386
386
  .with({"host"=>"<%= Key \"PublicIp\" %>", "user"=>"ec2-user", "request_pty"=>true}, " ls\n", {"PublicIp"=>"127.0.0.1", "MyOutput"=>100})
387
387
  .and_return(["file1\nfile2\n", "", 0])
388
388
 
389
- client.instance_variable_get(:@post_processing)
390
- .should_receive(:print_command).with('ssh_command')
389
+ expect(client.instance_variable_get(:@post_processing))
390
+ .to receive(:print_command).with('ssh_command')
391
391
 
392
- client.instance_variable_get(:@post_processing)
393
- .should_receive(:print_command_result)
392
+ expect(client.instance_variable_get(:@post_processing))
393
+ .to receive(:print_command_result)
394
394
  .with("file1\nfile2\n", "", 0)
395
395
 
396
- client.instance_variable_get(:@post_processing)
397
- .should_receive(:save_command_results)
396
+ expect(client.instance_variable_get(:@post_processing))
397
+ .to receive(:save_command_results)
398
398
  .with([{'ssh_command' => {'ExitStatus' => 0, 'StdOut' => "file1\nfile2\n", 'StdErr' => ""}}])
399
399
  end
400
400
  end
@@ -445,72 +445,72 @@ end
445
445
 
446
446
  run_client(:create, :template => template) do |client, cf|
447
447
  json = eval_template(template, :update_deletion_policy => true).to_json
448
- client.should_receive(:print_event_log).twice
449
- client.should_receive(:create_event_log).once
448
+ expect(client).to receive(:print_event_log).twice
449
+ expect(client).to receive(:create_event_log).once
450
450
 
451
451
  output1 = make_double('output') do |obj|
452
- obj.should_receive(:key) { 'AZ' }
453
- obj.should_receive(:value) { 'ap-northeast-1b' }
452
+ expect(obj).to receive(:key) { 'AZ' }
453
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
454
454
  end
455
455
 
456
456
  output2 = make_double('output') do |obj|
457
- obj.should_receive(:key) { 'Region' }
458
- obj.should_receive(:value) { 'ap-northeast-1' }
457
+ expect(obj).to receive(:key) { 'Region' }
458
+ expect(obj).to receive(:value) { 'ap-northeast-1' }
459
459
  end
460
460
 
461
461
  resource_summary = make_double('resource_summary') do |obj|
462
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
463
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
464
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
465
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
466
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
467
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
462
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
463
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
464
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
465
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
466
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
467
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
468
468
  end
469
469
 
470
470
  stack = make_double('stack') do |obj|
471
- obj.should_receive(:status).and_return(
471
+ expect(obj).to receive(:status).and_return(
472
472
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
473
473
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
474
- obj.should_receive(:outputs) { [output1, output2] }
475
- obj.should_receive(:resource_summaries) { [resource_summary] }
476
- obj.should_receive(:delete)
474
+ expect(obj).to receive(:outputs) { [output1, output2] }
475
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
476
+ expect(obj).to receive(:delete)
477
477
  end
478
478
 
479
479
  stacks = make_double('stacks') do |obj|
480
- obj.should_receive(:create)
480
+ expect(obj).to receive(:create)
481
481
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
482
- obj.should_receive(:[])
482
+ expect(obj).to receive(:[])
483
483
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
484
484
  end
485
485
 
486
- cf.should_receive(:stacks).twice { stacks }
486
+ expect(cf).to receive(:stacks).twice { stacks }
487
487
 
488
- process_status1 = make_double('process_status1') {|obj| obj.should_receive(:to_i).and_return(0) }
489
- process_status2 = make_double('process_status2') {|obj| obj.should_receive(:to_i).and_return(0) }
488
+ process_status1 = make_double('process_status1') {|obj| expect(obj).to receive(:to_i).and_return(0) }
489
+ process_status2 = make_double('process_status2') {|obj| expect(obj).to receive(:to_i).and_return(0) }
490
490
 
491
- client.instance_variable_get(:@post_processing)
492
- .should_receive(:run_shell_command)
491
+ expect(client.instance_variable_get(:@post_processing))
492
+ .to receive(:run_shell_command)
493
493
  .with(" echo <%= Key \"AZ\" %>\n echo <%= Key \"Region\" %>\n", {"AZ"=>"ap-northeast-1b", "Region"=>"ap-northeast-1"})
494
494
  .and_return(["ap-northeast-1b\nap-northeast-1\n", "", process_status1])
495
- client.instance_variable_get(:@post_processing)
496
- .should_receive(:run_shell_command)
495
+ expect(client.instance_variable_get(:@post_processing))
496
+ .to receive(:run_shell_command)
497
497
  .with(" echo <%= Key \"Region\" %>\n echo <%= Key \"AZ\" %>\n", {"AZ"=>"ap-northeast-1b", "Region"=>"ap-northeast-1"})
498
498
  .and_return(["ap-northeast-1\nap-northeast-1b\n", "", process_status2])
499
499
 
500
- client.instance_variable_get(:@post_processing)
501
- .should_receive(:print_command).with('command_a')
502
- client.instance_variable_get(:@post_processing)
503
- .should_receive(:print_command).with('command_b')
500
+ expect(client.instance_variable_get(:@post_processing))
501
+ .to receive(:print_command).with('command_a')
502
+ expect(client.instance_variable_get(:@post_processing))
503
+ .to receive(:print_command).with('command_b')
504
504
 
505
- client.instance_variable_get(:@post_processing)
506
- .should_receive(:print_command_result)
505
+ expect(client.instance_variable_get(:@post_processing))
506
+ .to receive(:print_command_result)
507
507
  .with("ap-northeast-1b\nap-northeast-1\n", "", process_status1)
508
- client.instance_variable_get(:@post_processing)
509
- .should_receive(:print_command_result)
508
+ expect(client.instance_variable_get(:@post_processing))
509
+ .to receive(:print_command_result)
510
510
  .with("ap-northeast-1\nap-northeast-1b\n", "", process_status2)
511
511
 
512
- client.instance_variable_get(:@post_processing)
513
- .should_receive(:save_command_results)
512
+ expect(client.instance_variable_get(:@post_processing))
513
+ .to receive(:save_command_results)
514
514
  .with([{'command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\nap-northeast-1\n", 'StdErr' => ""}},
515
515
  {'command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\nap-northeast-1b\n", 'StdErr' => ""}}])
516
516
  end
@@ -562,53 +562,53 @@ end
562
562
 
563
563
  run_client(:create, :template => template) do |client, cf|
564
564
  json = eval_template(template, :update_deletion_policy => true).to_json
565
- client.should_receive(:print_event_log).twice
566
- client.should_receive(:create_event_log).once
565
+ expect(client).to receive(:print_event_log).twice
566
+ expect(client).to receive(:create_event_log).once
567
567
 
568
568
  output1 = make_double('output') do |obj|
569
- obj.should_receive(:key) { 'AZ' }
570
- obj.should_receive(:value) { 'ap-northeast-1b' }
569
+ expect(obj).to receive(:key) { 'AZ' }
570
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
571
571
  end
572
572
 
573
573
  output2 = make_double('output') do |obj|
574
- obj.should_receive(:key) { 'Region' }
575
- obj.should_receive(:value) { 'ap-northeast-1' }
574
+ expect(obj).to receive(:key) { 'Region' }
575
+ expect(obj).to receive(:value) { 'ap-northeast-1' }
576
576
  end
577
577
 
578
578
  resource_summary = make_double('resource_summary') do |obj|
579
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
580
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
581
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
582
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
583
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
584
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
579
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
580
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
581
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
582
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
583
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
584
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
585
585
  end
586
586
 
587
587
  stack = make_double('stack') do |obj|
588
- obj.should_receive(:status).and_return(
588
+ expect(obj).to receive(:status).and_return(
589
589
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
590
590
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
591
- obj.should_receive(:outputs) { [output1, output2] }
592
- obj.should_receive(:resource_summaries) { [resource_summary] }
593
- obj.should_receive(:delete)
591
+ expect(obj).to receive(:outputs) { [output1, output2] }
592
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
593
+ expect(obj).to receive(:delete)
594
594
  end
595
595
 
596
596
  stacks = make_double('stacks') do |obj|
597
- obj.should_receive(:create)
597
+ expect(obj).to receive(:create)
598
598
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
599
- obj.should_receive(:[])
599
+ expect(obj).to receive(:[])
600
600
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
601
601
  end
602
602
 
603
- cf.should_receive(:stacks).twice { stacks }
603
+ expect(cf).to receive(:stacks).twice { stacks }
604
604
 
605
- Open3.should_not_receive(:capture3)
605
+ expect(Open3).not_to receive(:capture3)
606
606
 
607
- client.instance_variable_get(:@post_processing)
608
- .should_not_receive(:print_command_result)
607
+ expect(client.instance_variable_get(:@post_processing))
608
+ .not_to receive(:print_command_result)
609
609
 
610
- client.instance_variable_get(:@post_processing)
611
- .should_not_receive(:save_command_results)
610
+ expect(client.instance_variable_get(:@post_processing))
611
+ .not_to receive(:save_command_results)
612
612
  end
613
613
  end
614
614
 
@@ -638,40 +638,40 @@ end
638
638
  template = eval_template(template, :update_deletion_policy => true)
639
639
  expect(template['Resources']['myEC2Instance']['DeletionPolicy']).to eq('Delete')
640
640
  json = template.to_json
641
- client.should_receive(:print_event_log).twice
642
- client.should_receive(:create_event_log).once
641
+ expect(client).to receive(:print_event_log).twice
642
+ expect(client).to receive(:create_event_log).once
643
643
 
644
644
  output = make_double('output') do |obj|
645
- obj.should_receive(:key) { 'AZ' }
646
- obj.should_receive(:value) { 'ap-northeast-1b' }
645
+ expect(obj).to receive(:key) { 'AZ' }
646
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
647
647
  end
648
648
 
649
649
  resource_summary = make_double('resource_summary') do |obj|
650
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
651
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
652
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
653
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
654
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
655
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
650
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
651
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
652
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
653
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
654
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
655
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
656
656
  end
657
657
 
658
658
  stack = make_double('stack') do |obj|
659
- obj.should_receive(:status).and_return(
659
+ expect(obj).to receive(:status).and_return(
660
660
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
661
661
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
662
- obj.should_receive(:outputs) { [output] }
663
- obj.should_receive(:resource_summaries) { [resource_summary] }
664
- obj.should_receive(:delete)
662
+ expect(obj).to receive(:outputs) { [output] }
663
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
664
+ expect(obj).to receive(:delete)
665
665
  end
666
666
 
667
667
  stacks = make_double('stacks') do |obj|
668
- obj.should_receive(:create)
668
+ expect(obj).to receive(:create)
669
669
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {}) { stack }
670
- obj.should_receive(:[])
670
+ expect(obj).to receive(:[])
671
671
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
672
672
  end
673
673
 
674
- cf.should_receive(:stacks).twice { stacks }
674
+ expect(cf).to receive(:stacks).twice { stacks }
675
675
  end
676
676
  end
677
677
 
@@ -706,40 +706,40 @@ end
706
706
 
707
707
  run_client(:create, :template => template, :options => {:parameters => {'InstanceType'=>'m1.large'}}) do |client, cf|
708
708
  json = eval_template(template, :update_deletion_policy => true).to_json
709
- client.should_receive(:print_event_log).twice
710
- client.should_receive(:create_event_log).once
709
+ expect(client).to receive(:print_event_log).twice
710
+ expect(client).to receive(:create_event_log).once
711
711
 
712
712
  output = make_double('output') do |obj|
713
- obj.should_receive(:key) { 'AZ' }
714
- obj.should_receive(:value) { 'ap-northeast-1b' }
713
+ expect(obj).to receive(:key) { 'AZ' }
714
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
715
715
  end
716
716
 
717
717
  resource_summary = make_double('resource_summary') do |obj|
718
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
719
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
720
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
721
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
722
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
723
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
718
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
719
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
720
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
721
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
722
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
723
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
724
724
  end
725
725
 
726
726
  stack = make_double('stack') do |obj|
727
- obj.should_receive(:status).and_return(
727
+ expect(obj).to receive(:status).and_return(
728
728
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
729
729
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
730
- obj.should_receive(:outputs) { [output] }
731
- obj.should_receive(:resource_summaries) { [resource_summary] }
732
- obj.should_receive(:delete)
730
+ expect(obj).to receive(:outputs) { [output] }
731
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
732
+ expect(obj).to receive(:delete)
733
733
  end
734
734
 
735
735
  stacks = make_double('stacks') do |obj|
736
- obj.should_receive(:create)
736
+ expect(obj).to receive(:create)
737
737
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {:parameters=>{"InstanceType"=>"m1.large"}}) { stack }
738
- obj.should_receive(:[])
738
+ expect(obj).to receive(:[])
739
739
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
740
740
  end
741
741
 
742
- cf.should_receive(:stacks).twice { stacks }
742
+ expect(cf).to receive(:stacks).twice { stacks }
743
743
  end
744
744
  end
745
745
 
@@ -766,36 +766,36 @@ end
766
766
 
767
767
  run_client(:create, :arguments => ['MyStack'], :template => template) do |client, cf|
768
768
  json = eval_template(template).to_json
769
- client.should_receive(:print_event_log).once
769
+ expect(client).to receive(:print_event_log).once
770
770
 
771
771
  output = make_double('output') do |obj|
772
- obj.should_receive(:key) { 'AZ' }
773
- obj.should_receive(:value) { 'ap-northeast-1b' }
772
+ expect(obj).to receive(:key) { 'AZ' }
773
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
774
774
  end
775
775
 
776
776
  resource_summary = make_double('resource_summary') do |obj|
777
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
778
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
779
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
780
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
781
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
782
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
777
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
778
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
779
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
780
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
781
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
782
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
783
783
  end
784
784
 
785
785
  stack = make_double('stack') do |obj|
786
- obj.should_receive(:status).and_return(
786
+ expect(obj).to receive(:status).and_return(
787
787
  'CREATE_COMPLETE',
788
788
  'CREATE_COMPLETE')
789
- obj.should_receive(:outputs) { [output] }
790
- obj.should_receive(:resource_summaries) { [resource_summary] }
789
+ expect(obj).to receive(:outputs) { [output] }
790
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
791
791
  end
792
792
 
793
793
  stacks = make_double('status') do |obj|
794
- obj.should_receive(:create)
794
+ expect(obj).to receive(:create)
795
795
  .with('MyStack', json, {}) { stack }
796
796
  end
797
797
 
798
- cf.should_receive(:stacks) { stacks }
798
+ expect(cf).to receive(:stacks) { stacks }
799
799
  end
800
800
  end
801
801
 
@@ -822,36 +822,36 @@ end
822
822
 
823
823
  run_client(:create, :arguments => ['MyStack'], :template => template, :options => {:deletion_policy_retain => true}) do |client, cf|
824
824
  json = eval_template(template, :update_deletion_policy => true).to_json
825
- client.should_receive(:print_event_log).once
825
+ expect(client).to receive(:print_event_log).once
826
826
 
827
827
  output = make_double('output') do |obj|
828
- obj.should_receive(:key) { 'AZ' }
829
- obj.should_receive(:value) { 'ap-northeast-1b' }
828
+ expect(obj).to receive(:key) { 'AZ' }
829
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
830
830
  end
831
831
 
832
832
  resource_summary = make_double('resource_summary') do |obj|
833
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
834
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
835
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
836
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
837
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
838
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
833
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
834
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
835
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
836
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
837
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
838
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
839
839
  end
840
840
 
841
841
  stack = make_double('stack') do |obj|
842
- obj.should_receive(:status).and_return(
842
+ expect(obj).to receive(:status).and_return(
843
843
  'CREATE_COMPLETE',
844
844
  'CREATE_COMPLETE')
845
- obj.should_receive(:outputs) { [output] }
846
- obj.should_receive(:resource_summaries) { [resource_summary] }
845
+ expect(obj).to receive(:outputs) { [output] }
846
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
847
847
  end
848
848
 
849
849
  stacks = make_double('status') do |obj|
850
- obj.should_receive(:create)
850
+ expect(obj).to receive(:create)
851
851
  .with('MyStack', json, {}) { stack }
852
852
  end
853
853
 
854
- cf.should_receive(:stacks) { stacks }
854
+ expect(cf).to receive(:stacks) { stacks }
855
855
  end
856
856
  end
857
857
 
@@ -912,40 +912,40 @@ end
912
912
 
913
913
  run_client(:create, :template => template, :options => {:parameters => {'InstanceType'=>'m1.large'}, :encrypt_parameters => ['Password']}) do |client, cf|
914
914
  json = eval_template(template, :update_deletion_policy => true, :add_encryption_password => true).to_json
915
- client.should_receive(:print_event_log).twice
916
- client.should_receive(:create_event_log).once
915
+ expect(client).to receive(:print_event_log).twice
916
+ expect(client).to receive(:create_event_log).once
917
917
 
918
918
  output = make_double('output') do |obj|
919
- obj.should_receive(:key) { 'AZ' }
920
- obj.should_receive(:value) { 'ap-northeast-1b' }
919
+ expect(obj).to receive(:key) { 'AZ' }
920
+ expect(obj).to receive(:value) { 'ap-northeast-1b' }
921
921
  end
922
922
 
923
923
  resource_summary = make_double('resource_summary') do |obj|
924
- obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
925
- obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
926
- obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
927
- obj.should_receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
928
- obj.should_receive(:[]).with(:resource_status_reason) { nil }
929
- obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
924
+ expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
925
+ expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
926
+ expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
927
+ expect(obj).to receive(:[]).with(:resource_status) { 'CREATE_COMPLETE' }
928
+ expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
929
+ expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
930
930
  end
931
931
 
932
932
  stack = make_double('stack') do |obj|
933
- obj.should_receive(:status).and_return(
933
+ expect(obj).to receive(:status).and_return(
934
934
  'CREATE_COMPLETE', 'CREATE_COMPLETE',
935
935
  'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
936
- obj.should_receive(:outputs) { [output] }
937
- obj.should_receive(:resource_summaries) { [resource_summary] }
938
- obj.should_receive(:delete)
936
+ expect(obj).to receive(:outputs) { [output] }
937
+ expect(obj).to receive(:resource_summaries) { [resource_summary] }
938
+ expect(obj).to receive(:delete)
939
939
  end
940
940
 
941
941
  stacks = make_double('stacks') do |obj|
942
- obj.should_receive(:create)
942
+ expect(obj).to receive(:create)
943
943
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', json, {:parameters=>{"InstanceType"=>"m1.large", "EncryptionPassword"=>"KioqKioqKioqKioqKioqKg=="}}) { stack }
944
- obj.should_receive(:[])
944
+ expect(obj).to receive(:[])
945
945
  .with('kumogata-user-host-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX') { stack }
946
946
  end
947
947
 
948
- cf.should_receive(:stacks).twice { stacks }
948
+ expect(cf).to receive(:stacks).twice { stacks }
949
949
  end
950
950
  end
951
951
  end