kumogata 0.5.2 → 0.5.3

data/spec/kumogata_delete_spec.rb

@@ -1,40 +1,40 @@
 describe 'Kumogata::Client#delete' do
   it 'update a stack from Ruby template' do
     run_client(:delete, :arguments => ['MyStack'], :options => {:force => true}) do |client, cf|
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:delete).with(no_args())
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:delete).with(no_args())
+        expect(obj).to receive(:status).and_return(
             'DELETE_COMPLETE', 'DELETE_COMPLETE', 'DELETE_COMPLETE')
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
   end
 
   it 'update a stack from Ruby template (detach)' do
     out = run_client(:delete, :arguments => ['MyStack'], :options => {:force => true, :detach => true}) do |client, cf|
-      client.should_not_receive(:print_event_log)
-      client.should_receive(:create_event_log).once
+      expect(client).not_to receive(:print_event_log)
+      expect(client).to receive(:create_event_log).once
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:delete).with(no_args())
-        obj.should_receive(:status).once
+        expect(obj).to receive(:delete).with(no_args())
+        expect(obj).to receive(:status).once
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
 
     expect(out).to be_nil

data/spec/kumogata_export_spec.rb

@@ -26,15 +26,15 @@ describe 'Kumogata::Client#export' do
 
     template = run_client(:export, :arguments => ['MyStack']) do |client, cf|
       stack = make_double('stack') do |obj|
-        obj.should_receive(:status) { 'CREATE_COMPLETE' }
-        obj.should_receive(:template) { json }
+        expect(obj).to receive(:status) { 'CREATE_COMPLETE' }
+        expect(obj).to receive(:template) { json }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[]).with('MyStack') { stack }
+        expect(obj).to receive(:[]).with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
 
     expect(template).to eq((<<-EOS).chomp)
@@ -84,15 +84,15 @@ end
 
     template = run_client(:export, :arguments => ['MyStack'], :options => {:format => :json}) do |client, cf|
       stack = make_double('stack') do |obj|
-        obj.should_receive(:status) { 'CREATE_COMPLETE' }
-        obj.should_receive(:template) { json }
+        expect(obj).to receive(:status) { 'CREATE_COMPLETE' }
+        expect(obj).to receive(:template) { json }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[]).with('MyStack') { stack }
+        expect(obj).to receive(:[]).with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
 
     expect(template).to eq((<<-EOS).chomp)

data/spec/kumogata_list_spec.rb

@@ -2,20 +2,20 @@ describe 'Kumogata::Client#list' do
   it 'list stacks' do
     json = run_client(:list) do |client, cf|
       stack1 = make_double('stack1') do |obj|
-        obj.should_receive(:name) { 'stack1' }
-        obj.should_receive(:creation_time) { '2014-03-02 16:17:18 UTC' }
-        obj.should_receive(:status) { 'CREATE_COMPLETE' }
-        obj.should_receive(:description) { nil }
+        expect(obj).to receive(:name) { 'stack1' }
+        expect(obj).to receive(:creation_time) { '2014-03-02 16:17:18 UTC' }
+        expect(obj).to receive(:status) { 'CREATE_COMPLETE' }
+        expect(obj).to receive(:description) { nil }
       end
 
       stack2 = make_double('stack2') do |obj|
-        obj.should_receive(:name) { 'stack2' }
-        obj.should_receive(:creation_time) { '2014-03-02 16:17:19 UTC' }
-        obj.should_receive(:status) { 'CREATE_COMPLETE' }
-        obj.should_receive(:description) { nil }
+        expect(obj).to receive(:name) { 'stack2' }
+        expect(obj).to receive(:creation_time) { '2014-03-02 16:17:19 UTC' }
+        expect(obj).to receive(:status) { 'CREATE_COMPLETE' }
+        expect(obj).to receive(:description) { nil }
       end
 
-      cf.should_receive(:stacks) { [stack1, stack2] }
+      expect(cf).to receive(:stacks) { [stack1, stack2] }
     end
 
     expect(json).to eq((<<-EOS).chomp)
@@ -39,17 +39,17 @@ describe 'Kumogata::Client#list' do
   it 'list a specified stack' do
     json = run_client(:list, :arguments => ['stack1']) do |client, cf|
       stack1 = make_double('stack1') do |obj|
-        obj.should_receive(:name).twice { 'stack1' }
-        obj.should_receive(:creation_time) { '2014-03-02 16:17:18 UTC' }
-        obj.should_receive(:status) { 'CREATE_COMPLETE' }
-        obj.should_receive(:description) { nil }
+        expect(obj).to receive(:name).twice { 'stack1' }
+        expect(obj).to receive(:creation_time) { '2014-03-02 16:17:18 UTC' }
+        expect(obj).to receive(:status) { 'CREATE_COMPLETE' }
+        expect(obj).to receive(:description) { nil }
       end
 
       stack2 = make_double('stack2') do |obj|
-        obj.should_receive(:name) { 'stack2' }
+        expect(obj).to receive(:name) { 'stack2' }
       end
 
-      cf.should_receive(:stacks) { [stack1, stack2] }
+      expect(cf).to receive(:stacks) { [stack1, stack2] }
     end
 
     expect(json).to eq((<<-EOS).chomp)

data/spec/kumogata_show_events_spec.rb

@@ -3,28 +3,28 @@ describe 'Kumogata::Client#show_events' do
 
     resources = run_client(:show_events, :arguments => ['MyStack']) do |client, cf|
       event = make_double('event') do |obj|
-        obj.should_receive(:event_id) { "f45e6070-a4f7-11e3-9326-5088487c4896" }
-        obj.should_receive(:logical_resource_id) { "kumogata-f11118a4-a4f7-11e3-8183-98fe943e66ca" }
-        obj.should_receive(:physical_resource_id) { "arn:aws:cloudformation:ap-northeast-1:822997939312:stack/kumogata-f11118a4-a4f7-11e3-8183-98fe943e66ca/f1381a30-a4f7-11e3-a340-506cf9a1c096" }
-        obj.should_receive(:resource_properties) { nil }
-        obj.should_receive(:resource_status) { "CREATE_FAILED" }
-        obj.should_receive(:resource_status_reason) { "The following resource(s) failed to create: [myEC2Instance]. " }
-        obj.should_receive(:resource_type) { "AWS::CloudFormation::Stack" }
-        obj.should_receive(:stack_id) { "arn:aws:cloudformation:ap-northeast-1:822997939312:stack/kumogata-f11118a4-a4f7-11e3-8183-98fe943e66ca/f1381a30-a4f7-11e3-a340-506cf9a1c096" }
-        obj.should_receive(:stack_name) { "kumogata-f11118a4-a4f7-11e3-8183-98fe943e66ca" }
-        obj.should_receive(:timestamp) { "2014-03-06 06:24:21 UTC" }
+        expect(obj).to receive(:event_id) { "f45e6070-a4f7-11e3-9326-5088487c4896" }
+        expect(obj).to receive(:logical_resource_id) { "kumogata-f11118a4-a4f7-11e3-8183-98fe943e66ca" }
+        expect(obj).to receive(:physical_resource_id) { "arn:aws:cloudformation:ap-northeast-1:822997939312:stack/kumogata-f11118a4-a4f7-11e3-8183-98fe943e66ca/f1381a30-a4f7-11e3-a340-506cf9a1c096" }
+        expect(obj).to receive(:resource_properties) { nil }
+        expect(obj).to receive(:resource_status) { "CREATE_FAILED" }
+        expect(obj).to receive(:resource_status_reason) { "The following resource(s) failed to create: [myEC2Instance]. " }
+        expect(obj).to receive(:resource_type) { "AWS::CloudFormation::Stack" }
+        expect(obj).to receive(:stack_id) { "arn:aws:cloudformation:ap-northeast-1:822997939312:stack/kumogata-f11118a4-a4f7-11e3-8183-98fe943e66ca/f1381a30-a4f7-11e3-a340-506cf9a1c096" }
+        expect(obj).to receive(:stack_name) { "kumogata-f11118a4-a4f7-11e3-8183-98fe943e66ca" }
+        expect(obj).to receive(:timestamp) { "2014-03-06 06:24:21 UTC" }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:status) { 'CREATE_COMPLETE' }
-        obj.should_receive(:events).and_return([event])
+        expect(obj).to receive(:status) { 'CREATE_COMPLETE' }
+        expect(obj).to receive(:events).and_return([event])
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[]).with('MyStack') { stack }
+        expect(obj).to receive(:[]).with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
 
     expect(resources).to eq((<<-EOS).chomp)

data/spec/kumogata_show_outputs_spec.rb

@@ -3,20 +3,20 @@ describe 'Kumogata::Client#show_outputs' do
 
     outputs = run_client(:show_outputs, :arguments => ['MyStack']) do |client, cf|
       output = make_double('output') do |obj|
-        obj.should_receive(:key) { 'AZ' }
-        obj.should_receive(:value) { 'ap-northeast-1a' }
+        expect(obj).to receive(:key) { 'AZ' }
+        expect(obj).to receive(:value) { 'ap-northeast-1a' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:status) { 'CREATE_COMPLETE' }
-        obj.should_receive(:outputs) { [output] }
+        expect(obj).to receive(:status) { 'CREATE_COMPLETE' }
+        expect(obj).to receive(:outputs) { [output] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[]).with('MyStack') { stack }
+        expect(obj).to receive(:[]).with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
 
     expect(outputs).to eq((<<-EOS).chomp)

data/spec/kumogata_show_resources_spec.rb

@@ -3,8 +3,8 @@ describe 'Kumogata::Client#show_resources' do
 
     resources = run_client(:show_resources, :arguments => ['MyStack']) do |client, cf|
       stack = make_double('stack') do |obj|
-        obj.should_receive(:status) { 'CREATE_COMPLETE' }
-        obj.should_receive(:resource_summaries).and_return([
+        expect(obj).to receive(:status) { 'CREATE_COMPLETE' }
+        expect(obj).to receive(:resource_summaries).and_return([
           {
             :logical_resource_id    => 'myEC2Instance',
             :physical_resource_id   => 'i-XXXXXXXX',
@@ -17,10 +17,10 @@ describe 'Kumogata::Client#show_resources' do
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[]).with('MyStack') { stack }
+        expect(obj).to receive(:[]).with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
 
     expect(resources).to eq((<<-EOS).chomp)

data/spec/kumogata_update_spec.rb

@@ -22,37 +22,94 @@ end
 
     run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
       json = eval_template(template).to_json
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       output = make_double('output') do |obj|
-        obj.should_receive(:key) { 'AZ' }
-        obj.should_receive(:value) { 'ap-northeast-1b' }
+        expect(obj).to receive(:key) { 'AZ' }
+        expect(obj).to receive(:value) { 'ap-northeast-1b' }
       end
 
       resource_summary = make_double('resource_summary') do |obj|
-        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-        obj.should_receive(:[]).with(:resource_status_reason) { nil }
-        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json)
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:update).with(:template => json)
+        expect(obj).to receive(:status).and_return(
             'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-        obj.should_receive(:outputs) { [output] }
-        obj.should_receive(:resource_summaries) { [resource_summary] }
+        expect(obj).to receive(:outputs) { [output] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
+    end
+  end
+
+  it 'update a stack from Ruby template (with capabilities option)' do
+    template = <<-EOS
+Resources do
+  myEC2Instance do
+    Type "AWS::EC2::Instance"
+    Properties do
+      ImageId "ami-XXXXXXXX"
+      InstanceType "t1.micro"
+    end
+  end
+end
+
+Outputs do
+  AZ do
+    Value do
+      Fn__GetAtt "myEC2Instance", "AvailabilityZone"
+    end
+  end
+end
+    EOS
+
+    run_client(:update, :arguments => ['MyStack'], :template => template, :options => {:capabilities => ['AWS::CloudFormation::Stack']}) do |client, cf|
+      json = eval_template(template).to_json
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
+
+      output = make_double('output') do |obj|
+        expect(obj).to receive(:key) { 'AZ' }
+        expect(obj).to receive(:value) { 'ap-northeast-1b' }
+      end
+
+      resource_summary = make_double('resource_summary') do |obj|
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+      end
+
+      stack = make_double('stack') do |obj|
+        expect(obj).to receive(:update).with(:template => json, :capabilities => ['AWS::CloudFormation::Stack'])
+        expect(obj).to receive(:status).and_return(
+            'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
+        expect(obj).to receive(:outputs) { [output] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
+      end
+
+      stacks = make_double('stacks') do |obj|
+        expect(obj).to receive(:[])
+           .with('MyStack') { stack }
+      end
+
+      expect(cf).to receive(:stacks) { stacks }
     end
   end
 
@@ -79,22 +136,22 @@ end
 
     out = run_client(:update, :arguments => ['MyStack'], :template => template, :options => {:detach => true}) do |client, cf|
       json = eval_template(template).to_json
-      client.should_not_receive(:print_event_log)
-      client.should_receive(:create_event_log).once
+      expect(client).not_to receive(:print_event_log)
+      expect(client).to receive(:create_event_log).once
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json)
-        obj.should_receive(:status).once
-        obj.should_not_receive(:outputs)
-        obj.should_not_receive(:resource_summaries)
+        expect(obj).to receive(:update).with(:template => json)
+        expect(obj).to receive(:status).once
+        expect(obj).not_to receive(:outputs)
+        expect(obj).not_to receive(:resource_summaries)
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
 
     expect(out).to be_nil
@@ -128,37 +185,37 @@ end
           "DeletionPolicyUpdateKeyForKumogata" => "DeletionPolicyUpdateValueForKumogata1388534400"
         }
         json = template.to_json
-        client.should_receive(:print_event_log).once
-        client.should_receive(:create_event_log).once
+        expect(client).to receive(:print_event_log).once
+        expect(client).to receive(:create_event_log).once
 
         output = make_double('output') do |obj|
-          obj.should_receive(:key) { 'AZ' }
-          obj.should_receive(:value) { 'ap-northeast-1b' }
+          expect(obj).to receive(:key) { 'AZ' }
+          expect(obj).to receive(:value) { 'ap-northeast-1b' }
         end
 
         resource_summary = make_double('resource_summary') do |obj|
-          obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-          obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-          obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-          obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-          obj.should_receive(:[]).with(:resource_status_reason) { nil }
-          obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+          expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+          expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+          expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+          expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+          expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+          expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
         end
 
         stack = make_double('stack') do |obj|
-          obj.should_receive(:update).with(:template => json)
-          obj.should_receive(:status).and_return(
+          expect(obj).to receive(:update).with(:template => json)
+          expect(obj).to receive(:status).and_return(
               'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-          obj.should_receive(:outputs) { [output] }
-          obj.should_receive(:resource_summaries) { [resource_summary] }
+          expect(obj).to receive(:outputs) { [output] }
+          expect(obj).to receive(:resource_summaries) { [resource_summary] }
         end
 
         stacks = make_double('stacks') do |obj|
-          obj.should_receive(:[])
+          expect(obj).to receive(:[])
              .with('MyStack') { stack }
         end
 
-        cf.should_receive(:stacks) { stacks }
+        expect(cf).to receive(:stacks) { stacks }
       end
     end
   end
@@ -207,53 +264,53 @@ end
 
     run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
       json = eval_template(template).to_json
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       output1 = make_double('output') do |obj|
-        obj.should_receive(:key) { 'AZ' }
-        obj.should_receive(:value) { 'ap-northeast-1b' }
+        expect(obj).to receive(:key) { 'AZ' }
+        expect(obj).to receive(:value) { 'ap-northeast-1b' }
       end
 
       output2 = make_double('output') do |obj|
-        obj.should_receive(:key) { 'Region' }
-        obj.should_receive(:value) { 'ap-northeast-1' }
+        expect(obj).to receive(:key) { 'Region' }
+        expect(obj).to receive(:value) { 'ap-northeast-1' }
       end
 
       resource_summary = make_double('resource_summary') do |obj|
-        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-        obj.should_receive(:[]).with(:resource_status_reason) { nil }
-        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json)
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:update).with(:template => json)
+        expect(obj).to receive(:status).and_return(
             'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-        obj.should_receive(:outputs) { [output1, output2] }
-        obj.should_receive(:resource_summaries) { [resource_summary] }
+        expect(obj).to receive(:outputs) { [output1, output2] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
 
       process_status1 = double('process_status1')
       process_status2 = double('process_status2')
 
-      Open3.should_not_receive(:capture3)
+      expect(Open3).not_to receive(:capture3)
 
-      client.instance_variable_get(:@post_processing)
-            .should_not_receive(:print_command_result)
+      expect(client.instance_variable_get(:@post_processing))
+            .not_to receive(:print_command_result)
 
-      client.instance_variable_get(:@post_processing)
-            .should_not_receive(:save_command_results)
+      expect(client.instance_variable_get(:@post_processing))
+            .not_to receive(:save_command_results)
     end
   end
 
@@ -293,52 +350,52 @@ end
 
     run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
       json = eval_template(template).to_json
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       output = make_double('output') do |obj|
-        obj.should_receive(:key) { 'PublicIp' }
-        obj.should_receive(:value) { '127.0.0.1' }
+        expect(obj).to receive(:key) { 'PublicIp' }
+        expect(obj).to receive(:value) { '127.0.0.1' }
       end
 
       resource_summary = make_double('resource_summary') do |obj|
-        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-        obj.should_receive(:[]).with(:resource_status_reason) { nil }
-        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json)
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:update).with(:template => json)
+        expect(obj).to receive(:status).and_return(
             'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-        obj.should_receive(:outputs) { [output] }
-        obj.should_receive(:resource_summaries) { [resource_summary] }
+        expect(obj).to receive(:outputs) { [output] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
 
-      client.instance_variable_get(:@post_processing)
-           .should_receive(:run_ssh_command)
+      expect(client.instance_variable_get(:@post_processing))
+           .to receive(:run_ssh_command)
            .with({"host"=>"<%= Key \"PublicIp\" %>", "user"=>"ec2-user", "request_pty"=>true}, "      ls\n", {"PublicIp"=>"127.0.0.1"})
            .and_return(["file1\nfile2\n", "", 0])
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:print_command).with('ssh_command')
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:print_command).with('ssh_command')
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:print_command_result)
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:print_command_result)
             .with("file1\nfile2\n", "", 0)
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:save_command_results)
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:save_command_results)
             .with([{'ssh_command' => {'ExitStatus' => 0, 'StdOut' => "file1\nfile2\n", 'StdErr' => ""}}])
     end
   end
@@ -383,52 +440,52 @@ end
 
     run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
       json = eval_template(template).to_json
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       output = make_double('output') do |obj|
-        obj.should_receive(:key) { 'PublicIp' }
-        obj.should_receive(:value) { '127.0.0.1' }
+        expect(obj).to receive(:key) { 'PublicIp' }
+        expect(obj).to receive(:value) { '127.0.0.1' }
       end
 
       resource_summary = make_double('resource_summary') do |obj|
-        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-        obj.should_receive(:[]).with(:resource_status_reason) { nil }
-        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json)
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:update).with(:template => json)
+        expect(obj).to receive(:status).and_return(
             'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-        obj.should_receive(:outputs) { [output] }
-        obj.should_receive(:resource_summaries) { [resource_summary] }
+        expect(obj).to receive(:outputs) { [output] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
 
-      client.instance_variable_get(:@post_processing)
-           .should_receive(:run_ssh_command)
+      expect(client.instance_variable_get(:@post_processing))
+           .to receive(:run_ssh_command)
            .with({"host"=>"<%= Key \"PublicIp\" %>", "user"=>"ec2-user", "request_pty"=>true}, "      ls\n", {"PublicIp"=>"127-0-0-1"})
            .and_return(["file1\nfile2\n", "", 0])
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:print_command).with('ssh_command')
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:print_command).with('ssh_command')
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:print_command_result)
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:print_command_result)
             .with("file1\nfile2\n", "", 0)
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:save_command_results)
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:save_command_results)
             .with([{'ssh_command' => {'ExitStatus' => 0, 'StdOut' => "file1\nfile2\n", 'StdErr' => ""}}])
     end
   end
@@ -479,70 +536,70 @@ end
 
     run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
       json = eval_template(template).to_json
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       output1 = make_double('output') do |obj|
-        obj.should_receive(:key) { 'AZ' }
-        obj.should_receive(:value) { 'ap-northeast-1b' }
+        expect(obj).to receive(:key) { 'AZ' }
+        expect(obj).to receive(:value) { 'ap-northeast-1b' }
       end
 
       output2 = make_double('output') do |obj|
-        obj.should_receive(:key) { 'Region' }
-        obj.should_receive(:value) { 'ap-northeast-1' }
+        expect(obj).to receive(:key) { 'Region' }
+        expect(obj).to receive(:value) { 'ap-northeast-1' }
       end
 
       resource_summary = make_double('resource_summary') do |obj|
-        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-        obj.should_receive(:[]).with(:resource_status_reason) { nil }
-        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json)
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:update).with(:template => json)
+        expect(obj).to receive(:status).and_return(
             'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-        obj.should_receive(:outputs) { [output1, output2] }
-        obj.should_receive(:resource_summaries) { [resource_summary] }
+        expect(obj).to receive(:outputs) { [output1, output2] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
 
 
-      process_status1 = make_double('process_status1') {|obj| obj.should_receive(:to_i).and_return(0) }
-      process_status2 = make_double('process_status2') {|obj| obj.should_receive(:to_i).and_return(0) }
+      process_status1 = make_double('process_status1') {|obj| expect(obj).to receive(:to_i).and_return(0) }
+      process_status2 = make_double('process_status2') {|obj| expect(obj).to receive(:to_i).and_return(0) }
 
-      client.instance_variable_get(:@post_processing)
-           .should_receive(:run_shell_command)
+      expect(client.instance_variable_get(:@post_processing))
+           .to receive(:run_shell_command)
            .with("      echo <%= Key \"AZ\" %>\n      echo <%= Key \"Region\" %>\n", {"AZ"=>"ap-northeast-1b", "Region"=>"ap-northeast-1"})
            .and_return(["ap-northeast-1b\nap-northeast-1\n", "", process_status1])
-      client.instance_variable_get(:@post_processing)
-           .should_receive(:run_shell_command)
+      expect(client.instance_variable_get(:@post_processing))
+           .to receive(:run_shell_command)
            .with("      echo <%= Key \"Region\" %>\n      echo <%= Key \"AZ\" %>\n", {"AZ"=>"ap-northeast-1b", "Region"=>"ap-northeast-1"})
            .and_return(["ap-northeast-1\nap-northeast-1b\n", "", process_status2])
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:print_command).with('command_a')
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:print_command).with('command_b')
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:print_command).with('command_a')
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:print_command).with('command_b')
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:print_command_result)
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:print_command_result)
             .with("ap-northeast-1b\nap-northeast-1\n", "", process_status1)
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:print_command_result)
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:print_command_result)
             .with("ap-northeast-1\nap-northeast-1b\n", "", process_status2)
 
-      client.instance_variable_get(:@post_processing)
-            .should_receive(:save_command_results)
+      expect(client.instance_variable_get(:@post_processing))
+            .to receive(:save_command_results)
             .with([{'command_a' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1b\nap-northeast-1\n", 'StdErr' => ""}},
                    {'command_b' => {'ExitStatus' => 0, 'StdOut' => "ap-northeast-1\nap-northeast-1b\n", 'StdErr' => ""}}])
     end
@@ -594,53 +651,53 @@ end
 
     run_client(:update, :arguments => ['MyStack'], :template => template) do |client, cf|
       json = eval_template(template).to_json
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       output1 = make_double('output') do |obj|
-        obj.should_receive(:key) { 'AZ' }
-        obj.should_receive(:value) { 'ap-northeast-1b' }
+        expect(obj).to receive(:key) { 'AZ' }
+        expect(obj).to receive(:value) { 'ap-northeast-1b' }
       end
 
       output2 = make_double('output') do |obj|
-        obj.should_receive(:key) { 'Region' }
-        obj.should_receive(:value) { 'ap-northeast-1' }
+        expect(obj).to receive(:key) { 'Region' }
+        expect(obj).to receive(:value) { 'ap-northeast-1' }
       end
 
       resource_summary = make_double('resource_summary') do |obj|
-        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-        obj.should_receive(:[]).with(:resource_status_reason) { nil }
-        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json)
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:update).with(:template => json)
+        expect(obj).to receive(:status).and_return(
             'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-        obj.should_receive(:outputs) { [output1, output2] }
-        obj.should_receive(:resource_summaries) { [resource_summary] }
+        expect(obj).to receive(:outputs) { [output1, output2] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
 
       process_status1 = double('process_status1')
       process_status2 = double('process_status2')
 
-      Open3.should_not_receive(:capture3)
+      expect(Open3).not_to receive(:capture3)
 
-      client.instance_variable_get(:@post_processing)
-            .should_not_receive(:print_command_result)
+      expect(client.instance_variable_get(:@post_processing))
+            .not_to receive(:print_command_result)
 
-      client.instance_variable_get(:@post_processing)
-            .should_not_receive(:save_command_results)
+      expect(client.instance_variable_get(:@post_processing))
+            .not_to receive(:save_command_results)
     end
   end
 
@@ -675,37 +732,37 @@ end
 
     run_client(:update, :arguments => ['MyStack'], :template => template, :options => {:parameters => {'InstanceType'=>'m1.large'}}) do |client, cf|
       json = eval_template(template).to_json
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       output = make_double('output') do |obj|
-        obj.should_receive(:key) { 'AZ' }
-        obj.should_receive(:value) { 'ap-northeast-1b' }
+        expect(obj).to receive(:key) { 'AZ' }
+        expect(obj).to receive(:value) { 'ap-northeast-1b' }
       end
 
       resource_summary = make_double('resource_summary') do |obj|
-        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-        obj.should_receive(:[]).with(:resource_status_reason) { nil }
-        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json, :parameters=>{"InstanceType"=>"m1.large"})
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:update).with(:template => json, :parameters=>{"InstanceType"=>"m1.large"})
+        expect(obj).to receive(:status).and_return(
             'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-        obj.should_receive(:outputs) { [output] }
-        obj.should_receive(:resource_summaries) { [resource_summary] }
+        expect(obj).to receive(:outputs) { [output] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
   end
 
@@ -765,37 +822,37 @@ end
 
     run_client(:update, :arguments => ['MyStack'], :template => template, :options => {:parameters => {'InstanceType'=>'m1.large'}, :encrypt_parameters => ['Password']}) do |client, cf|
       json = eval_template(template, :add_encryption_password => true).to_json
-      client.should_receive(:print_event_log).once
-      client.should_receive(:create_event_log).once
+      expect(client).to receive(:print_event_log).once
+      expect(client).to receive(:create_event_log).once
 
       output = make_double('output') do |obj|
-        obj.should_receive(:key) { 'AZ' }
-        obj.should_receive(:value) { 'ap-northeast-1b' }
+        expect(obj).to receive(:key) { 'AZ' }
+        expect(obj).to receive(:value) { 'ap-northeast-1b' }
       end
 
       resource_summary = make_double('resource_summary') do |obj|
-        obj.should_receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
-        obj.should_receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
-        obj.should_receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
-        obj.should_receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
-        obj.should_receive(:[]).with(:resource_status_reason) { nil }
-        obj.should_receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
+        expect(obj).to receive(:[]).with(:logical_resource_id) { 'myEC2Instance' }
+        expect(obj).to receive(:[]).with(:physical_resource_id) { 'i-XXXXXXXX' }
+        expect(obj).to receive(:[]).with(:resource_type) { 'AWS::EC2::Instance' }
+        expect(obj).to receive(:[]).with(:resource_status) { 'UPDATE_COMPLETE' }
+        expect(obj).to receive(:[]).with(:resource_status_reason) { nil }
+        expect(obj).to receive(:[]).with(:last_updated_timestamp) { '2014-03-02 04:35:12 UTC' }
       end
 
       stack = make_double('stack') do |obj|
-        obj.should_receive(:update).with(:template => json, :parameters=>{"InstanceType"=>"m1.large", "EncryptionPassword"=>"KioqKioqKioqKioqKioqKg=="})
-        obj.should_receive(:status).and_return(
+        expect(obj).to receive(:update).with(:template => json, :parameters=>{"InstanceType"=>"m1.large", "EncryptionPassword"=>"KioqKioqKioqKioqKioqKg=="})
+        expect(obj).to receive(:status).and_return(
             'UPDATE_COMPLETE', 'UPDATE_COMPLETE', 'UPDATE_COMPLETE')
-        obj.should_receive(:outputs) { [output] }
-        obj.should_receive(:resource_summaries) { [resource_summary] }
+        expect(obj).to receive(:outputs) { [output] }
+        expect(obj).to receive(:resource_summaries) { [resource_summary] }
       end
 
       stacks = make_double('stacks') do |obj|
-        obj.should_receive(:[])
+        expect(obj).to receive(:[])
            .with('MyStack') { stack }
       end
 
-      cf.should_receive(:stacks) { stacks }
+      expect(cf).to receive(:stacks) { stacks }
     end
   end
 end