cf_deployer 1.6.0 → 2.0.0

data/spec/unit/config_loader_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 describe "load config settings" do
 
   before :each do
-    Dir.mkdir 'tmp' unless Dir.exists?('tmp')
+    Dir.mkdir 'tmp' unless Dir.exist?('tmp')
     @config_file = File.expand_path("../../../tmp/test_config.yml", __FILE__)
     @base_json = File.expand_path("../../../tmp/base.json", __FILE__)
     @api_json = File.expand_path("../../../tmp/api.json", __FILE__)
@@ -146,143 +146,143 @@ environments:
 
   it "all the keys should be symbols in config" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:base][:'deployment-strategy'].should eq('create-or-update')
-    config['components'].should be_nil
+    expect(config[:components][:base][:'deployment-strategy']).to eq('create-or-update')
+    expect(config['components']).to be_nil
   end
 
   it "should copy application, environment, component to component settings" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'uat'})
-    config[:components][:api][:settings][:application].should eq("myApp")
-    config[:components][:api][:settings][:component].should eq("api")
-    config[:components][:api][:settings][:environment].should eq("uat")
-    config[:components][:base][:settings][:application].should eq("myApp")
-    config[:components][:base][:settings][:component].should eq("base")
-    config[:components][:base][:settings][:environment].should eq("uat")
+    expect(config[:components][:api][:settings][:application]).to eq("myApp")
+    expect(config[:components][:api][:settings][:component]).to eq("api")
+    expect(config[:components][:api][:settings][:environment]).to eq("uat")
+    expect(config[:components][:base][:settings][:application]).to eq("myApp")
+    expect(config[:components][:base][:settings][:component]).to eq("base")
+    expect(config[:components][:base][:settings][:environment]).to eq("uat")
   end
 
   it "should copy region to coponent settings" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'uat', :region => 'us-west-1'})
-    config[:components][:api][:settings][:region].should eq("us-west-1")
-    config[:components][:base][:settings][:region].should eq("us-west-1")
+    expect(config[:components][:api][:settings][:region]).to eq("us-west-1")
+    expect(config[:components][:base][:settings][:region]).to eq("us-west-1")
   end
 
   it "should copy application, environment, component to component inputs" do
       config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'uat'})
-      config[:components][:api][:inputs][:application].should eq("myApp")
-      config[:components][:api][:inputs][:component].should eq("api")
-      config[:components][:api][:inputs][:environment].should eq("uat")
-      config[:components][:base][:inputs][:application].should eq("myApp")
-      config[:components][:base][:inputs][:component].should eq("base")
-      config[:components][:base][:inputs][:environment].should eq("uat")
+      expect(config[:components][:api][:inputs][:application]).to eq("myApp")
+      expect(config[:components][:api][:inputs][:component]).to eq("api")
+      expect(config[:components][:api][:inputs][:environment]).to eq("uat")
+      expect(config[:components][:base][:inputs][:application]).to eq("myApp")
+      expect(config[:components][:base][:inputs][:component]).to eq("base")
+      expect(config[:components][:base][:inputs][:environment]).to eq("uat")
   end
 
   it "should copy region to coponent inputs" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'uat', :region => 'us-west-1'})
-    config[:components][:api][:inputs][:region].should eq("us-west-1")
-    config[:components][:base][:inputs][:region].should eq("us-west-1")
+    expect(config[:components][:api][:inputs][:region]).to eq("us-west-1")
+    expect(config[:components][:base][:inputs][:region]).to eq("us-west-1")
   end
 
   it "config_dir option should be copied to component context" do
     config_dir = File.dirname(@config_file)
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'uat'})
-    config[:components][:api][:config_dir].should eq(config_dir)
-    config[:components][:base][:config_dir].should eq(config_dir)
-    config[:components][:'front-end'][:config_dir].should eq(config_dir)
+    expect(config[:components][:api][:config_dir]).to eq(config_dir)
+    expect(config[:components][:base][:config_dir]).to eq(config_dir)
+    expect(config[:components][:'front-end'][:config_dir]).to eq(config_dir)
   end
 
   it "notify option should be merged to component context" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'dev'})
-    config[:components][:base][:notify].should eq(['arn:root', 'arn:base', 'arn:dev'])
-    config[:components][:api][:notify].should eq(['arn:root', 'arn:api', 'arn:dev'])
-    config[:components][:'front-end'][:notify].should eq(['arn:root', 'arn:base', 'arn:dev'])
+    expect(config[:components][:base][:notify]).to eq(['arn:root', 'arn:base', 'arn:dev'])
+    expect(config[:components][:api][:notify]).to eq(['arn:root', 'arn:api', 'arn:dev'])
+    expect(config[:components][:'front-end'][:notify]).to eq(['arn:root', 'arn:base', 'arn:dev'])
   end
 
   it "notify option should be merged to environment context" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'uat'})
-    config[:components][:base][:notify].should eq(['arn:root', 'arn:base'])
-    config[:components][:api][:notify].should eq(['arn:root', 'arn:api'])
-    config[:components][:'front-end'][:notify].should eq(['arn:root', 'arn:base'])
+    expect(config[:components][:base][:notify]).to eq(['arn:root', 'arn:base'])
+    expect(config[:components][:api][:notify]).to eq(['arn:root', 'arn:api'])
+    expect(config[:components][:'front-end'][:notify]).to eq(['arn:root', 'arn:base'])
   end
 
   it "tags option should be copied to component context" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'uat'})
-    config[:components][:api][:tags].should eq({:version => 'v1.1'})
-    config[:components][:base][:tags].should eq({:version => 'v1.1', :component => 'base'})
-    config[:components][:'front-end'][:tags].should eq({:version => 'v1.1'})
+    expect(config[:components][:api][:tags]).to eq({:version => 'v1.1'})
+    expect(config[:components][:base][:tags]).to eq({:version => 'v1.1', :component => 'base'})
+    expect(config[:components][:'front-end'][:tags]).to eq({:version => 'v1.1'})
   end
 
 
   it "component's settings should be merged to common settings" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'uat'})
-    config[:components][:api][:inputs][:'timeout'].should eq(90)
-    config[:components][:api][:inputs][:'require-basic-auth'].should eq(true)
-    config[:components][:api][:inputs][:'mail-server'].should eq('http://api.abc.com')
+    expect(config[:components][:api][:inputs][:'timeout']).to eq(90)
+    expect(config[:components][:api][:inputs][:'require-basic-auth']).to eq(true)
+    expect(config[:components][:api][:inputs][:'mail-server']).to eq('http://api.abc.com')
   end
 
 
    it "environment's settings should be merged to component settings" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'dev'})
-    config[:components][:api][:inputs][:'timeout'].should eq(60)
-    config[:components][:api][:inputs][:'require-basic-auth'].should eq(true)
-    config[:components][:api][:inputs][:'mail-server'].should eq('http://dev.abc.com')
+    expect(config[:components][:api][:inputs][:'timeout']).to eq(60)
+    expect(config[:components][:api][:inputs][:'require-basic-auth']).to eq(true)
+    expect(config[:components][:api][:inputs][:'mail-server']).to eq('http://dev.abc.com')
   end
 
   it "should merge environment's components to component settings" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'production'})
-    config[:components][:'front-end'][:inputs][:'cname'].should eq('prod-front-end.myserver.com')
-    config[:components][:api][:inputs][:'cname'].should eq('myserver.com')
+    expect(config[:components][:'front-end'][:inputs][:'cname']).to eq('prod-front-end.myserver.com')
+    expect(config[:components][:api][:inputs][:'cname']).to eq('myserver.com')
   end
 
   it "environment variables without prefix 'cfdeploy_settings_' should not be merged to components settings" do
     ENV['timeout'] = "180"
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'dev'})
-    config[:components][:api][:inputs][:'timeout'].should eq(60)
+    expect(config[:components][:api][:inputs][:'timeout']).to eq(60)
   end
 
   it "should merge environment variables should be merged to components settings" do
     ENV['cfdeploy_inputs_timeout'] = "180"
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'dev'})
-    config[:components][:api][:inputs][:'timeout'].should eq("180")
+    expect(config[:components][:api][:inputs][:'timeout']).to eq("180")
   end
 
   it "cli settings should be merged to components settings" do
     ENV['cfdeploy_settings_timeout'] = "180"
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file, :environment => 'dev',:cli_overrides => {:settings => {:timeout => 45}}})
-    config[:components][:api][:settings][:'timeout'].should eq(45)
+    expect(config[:components][:api][:settings][:'timeout']).to eq(45)
   end
 
   it "should set cloudFormation parameter names into each component" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:base][:defined_parameters].should eq({})
-    config[:components][:api][:defined_parameters].should eq({:'require-basic-auth' => {:Default => "true"}})
-    config[:components][:'front-end'][:defined_parameters].should eq({:'require-basic-auth' => {}, :'mail-server' => {}})
+    expect(config[:components][:base][:defined_parameters]).to eq({})
+    expect(config[:components][:api][:defined_parameters]).to eq({:'require-basic-auth' => {:Default => "true"}})
+    expect(config[:components][:'front-end'][:defined_parameters]).to eq({:'require-basic-auth' => {}, :'mail-server' => {}})
   end
 
   it "should set cloudFormation output names into each component" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:base][:defined_outputs].should eq({:'vpc-id' => {}, :'AutoScalingGroupName'=>{}, :'public-subnet-id'=>{}})
-    config[:components][:api][:defined_outputs].should eq({})
-    config[:components][:'front-end'][:defined_outputs].should eq({:'AutoScalingGroupName'=>{}, :'elb-cname' => {}})
+    expect(config[:components][:base][:defined_outputs]).to eq({:'vpc-id' => {}, :'AutoScalingGroupName'=>{}, :'public-subnet-id'=>{}})
+    expect(config[:components][:api][:defined_outputs]).to eq({})
+    expect(config[:components][:'front-end'][:defined_outputs]).to eq({:'AutoScalingGroupName'=>{}, :'elb-cname' => {}})
   end
 
   it "should remove common settings in order not to confuse us" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:settings].should be_nil
+    expect(config[:settings]).to be_nil
   end
 
   it "should set default elb-name-output for cname-swap strategy" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:'front-end'][:settings][:'elb-name-output'].should eq('ELBName')
+    expect(config[:components][:'front-end'][:settings][:'elb-name-output']).to eq('ELBName')
   end
 
   it "should set default auto-scaling-group-name-output for cname-swap strategy" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:api][:settings][:'auto-scaling-group-name-output'].should eq([ CfDeployer::Defaults::AutoScalingGroupName ])
+    expect(config[:components][:api][:settings][:'auto-scaling-group-name-output']).to eq([ CfDeployer::Defaults::AutoScalingGroupName ])
   end
 
   it "should set auto-scaling-group-name-output to default if auto-scaling-group-name exists in output for create-or-update strategy" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:base][:settings][:'auto-scaling-group-name-output'].should eq([ CfDeployer::Defaults::AutoScalingGroupName ])
+    expect(config[:components][:base][:settings][:'auto-scaling-group-name-output']).to eq([ CfDeployer::Defaults::AutoScalingGroupName ])
   end
 
   it "should not set auto-scaling-group-name-output to default if auto-scaling-group-name does not exists in output for create-or-update strategy" do
@@ -295,17 +295,17 @@ environments:
 
     File.open(@base_json, 'w') {|f| f.write(base_json) }
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:'base'][:settings][:'auto-scaling-group-name-output'].should be_nil
+    expect(config[:components][:'base'][:settings][:'auto-scaling-group-name-output']).to be_nil
   end
 
   it "should set auto-scaling-group-name-output to default if auto-scaling-group-name exists in output for cname-swap strategy" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:'front-end'][:settings][:'auto-scaling-group-name-output'].should eq([ CfDeployer::Defaults::AutoScalingGroupName ])
+    expect(config[:components][:'front-end'][:settings][:'auto-scaling-group-name-output']).to eq([ CfDeployer::Defaults::AutoScalingGroupName ])
   end
 
   it "should set raise-error-for-unused-inputs to default" do
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:'front-end'][:settings][:'raise-error-for-unused-inputs'].should eq(CfDeployer::Defaults::RaiseErrorForUnusedInputs)
+    expect(config[:components][:'front-end'][:settings][:'raise-error-for-unused-inputs']).to eq(CfDeployer::Defaults::RaiseErrorForUnusedInputs)
   end
 
   it "should not set auto-scaling-group-name-output to default if auto-scaling-group-name does not exists in output for cname-swap strategy" do
@@ -319,23 +319,23 @@ environments:
 
     File.open(@front_end_json, 'w') {|f| f.write(front_end_json) }
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:'front-end'][:settings][:'auto-scaling-group-name-output'].should be_nil
+    expect(config[:components][:'front-end'][:settings][:'auto-scaling-group-name-output']).to be_nil
   end
 
   it "should ERB the config file and provide the environment in the binding" do
     config =  CfDeployer::ConfigLoader.new.load(:'config-file' => @config_file, :environment => 'DrWho')
-    config[:components][:base][:inputs][:'foobar'].should eq('DrWho.IsGreat')
+    expect(config[:components][:base][:inputs][:'foobar']).to eq('DrWho.IsGreat')
   end
 
   it "should ERB the component JSON and make the parsed template available" do
     config =  CfDeployer::ConfigLoader.new.load(:'config-file' => @config_file, :environment => 'DrWho')
-    CfDeployer::ConfigLoader.erb_to_json('json-with-erb', config[:components][:'json-with-erb']).should include('DrWho')
+    expect(CfDeployer::ConfigLoader.erb_to_json('json-with-erb', config[:components][:'json-with-erb'])).to include('DrWho')
   end
 
   it 'should use error_document to show the broken document when parsing broken ERB' do
     config = { :config_dir => File.dirname(@config_file) }
-    CfDeployer::ConfigLoader.any_instance.should_receive(:error_document)
-    expect { CfDeployer::ConfigLoader.erb_to_json('broken_erb', config) }.to raise_error
+    allow_any_instance_of(CfDeployer::ConfigLoader).to receive(:error_document)
+    expect { CfDeployer::ConfigLoader.erb_to_json('broken_erb', config) }.to raise_error(TypeError)
   end
 
   it 'should use error_document to show the broken document when parsing broken json' do
@@ -347,35 +347,36 @@ environments:
       :defined_parameters => {},
       :defined_outputs => {}
     }
-    CfDeployer::ConfigLoader.any_instance.should_receive(:error_document)
-    expect { loader.send(:cf_template, 'broken_json') }.to raise_error
+    allow_any_instance_of(CfDeployer::ConfigLoader).to receive(:error_document)
+
+    expect { loader.send(:cf_template, 'broken_json') }.to raise_error(RuntimeError)
   end
 
   it 'should use error_document to show the broken document when parsing broken yaml' do
-    CfDeployer::ConfigLoader.any_instance.should_receive(:error_document)
-    expect { CfDeployer::ConfigLoader.new.send(:load_yaml, @broken_yaml) }.to raise_error
+    allow_any_instance_of(CfDeployer::ConfigLoader).to receive(:error_document)
+    expect { CfDeployer::ConfigLoader.new.send(:load_yaml, @broken_yaml) }.to raise_error(Psych::SyntaxError)
   end
 
   it 'should set default keep-previous-stack to true' do
     config =  CfDeployer::ConfigLoader.new.load(:'config-file' => @config_file)
-    config[:components][:api][:settings][:'keep-previous-stack'].should eq(CfDeployer::Defaults::KeepPreviousStack)
+    expect(config[:components][:api][:settings][:'keep-previous-stack']).to eq(CfDeployer::Defaults::KeepPreviousStack)
   end
 
   it 'should keep keep-previous-stack setting' do
     config =  CfDeployer::ConfigLoader.new.load(:'config-file' => @config_file)
-    config[:components][:'front-end'][:settings][:'keep-previous-stack'].should be_false
+    expect(config[:components][:'front-end'][:settings][:'keep-previous-stack']).to be_falsey
   end
 
   context 'targets' do
 
     it 'should use all components as targets if no targets are specified' do
     config =  CfDeployer::ConfigLoader.new.load(:'config-file' => @config_file)
-    config[:targets].should eq(['base', 'api', 'front-end', 'very-simple', 'json-with-erb'])
+    expect(config[:targets]).to eq(['base', 'api', 'front-end', 'very-simple', 'json-with-erb'])
     end
 
     it 'should keep targets if targets are specified' do
     config =  CfDeployer::ConfigLoader.new.load(:'config-file' => @config_file, :component => ['api', 'web'])
-    config[:targets].should eq(['api', 'web'])
+    expect(config[:targets]).to eq(['api', 'web'])
     end
 
   end
@@ -418,7 +419,7 @@ components:
     File.open(@config_file, 'w') {|f| f.write(config) }
 
     config =  CfDeployer::ConfigLoader.new.load({:'config-file' => @config_file})
-    config[:components][:'api'][:defined_parameters].should eq({ db:'base::elb-cname', url:'http://abc.com'})
+    expect(config[:components][:'api'][:defined_parameters]).to eq({ db:'base::elb-cname', url:'http://abc.com'})
   end
 
   end

data/spec/unit/deployment_strategy/auto_scaling_group_swap_spec.rb

@@ -35,18 +35,18 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
     it 'no if no G and B stacks exist' do
       blue_stack.die!
       green_stack.die!
-      CfDeployer::DeploymentStrategy.create(app, env, component, context).exists?.should be_false
+      expect(CfDeployer::DeploymentStrategy.create(app, env, component, context).exists?).to be_falsey
     end
 
     it 'yes if B stacks exist' do
       blue_stack.live!
       green_stack.die!
-      CfDeployer::DeploymentStrategy.create(app, env, component, context).exists?.should be_true
+      expect(CfDeployer::DeploymentStrategy.create(app, env, component, context).exists?).to be_truthy
     end
     it 'yes if G  stacks exist' do
       blue_stack.die!
       green_stack.live!
-      CfDeployer::DeploymentStrategy.create(app, env, component, context).exists?.should be_true
+      expect(CfDeployer::DeploymentStrategy.create(app, env, component, context).exists?).to be_truthy
     end
 
   end
@@ -123,7 +123,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
         @log += "#{arg[:parameters][:name]} deleted."
       end
       CfDeployer::DeploymentStrategy.create(app, env, component, context).destroy
-      @log.should eq('green deleted.blue deleted.')
+      expect(@log).to eq('green deleted.blue deleted.')
     end
   end
 
@@ -601,7 +601,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
       allow(green_asg_driver).to receive(:describe) {{desired: 0, min: 0, max: 0}}
       allow(blue_asg_driver).to receive(:describe) {{desired: 3, min: 1, max: 5}}
       asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
-      asg_swap.output_value("AutoScalingGroupID").should eq("blueASG")
+      expect(asg_swap.output_value("AutoScalingGroupID")).to eq("blueASG")
     end
 
     it 'should get the information where the value comes from if the active stack does not exist' do
@@ -612,7 +612,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
       allow(green_asg_driver).to receive(:describe) {{desired: 0, min: 0, max: 0}}
       allow(blue_asg_driver).to receive(:describe) {{desired: 0, min: 0, max: 0}}
       asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
-      asg_swap.output_value(:a_key).should eq("The value will be referenced from the output a_key of undeployed component worker")
+      expect(asg_swap.output_value(:a_key)).to eq("The value will be referenced from the output a_key of undeployed component worker")
     end
   end
 
@@ -642,7 +642,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
               :status => 'green deployed'
           }
       }
-      asg_swap.status.should eq(expected_result)
+      expect(asg_swap.status).to eq(expected_result)
     end
 
     it 'should get status for both green and blue stacks including resources info' do
@@ -667,7 +667,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
               }
           }
       }
-      asg_swap.status(true).should eq(expected_result)
+      expect(asg_swap.status(true)).to eq(expected_result)
     end
   end
 
@@ -686,7 +686,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
       allow(blue_stack).to receive(:resource_statuses) { asg_ids('foo', 'bar') }
 
       asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
-      asg_swap.send(:get_active_asgs, blue_stack).should eq(['foo'])
+      expect(asg_swap.send(:get_active_asgs, blue_stack)).to eq(['foo'])
     end
   end
 
@@ -700,7 +700,7 @@ describe 'Auto Scaling Group Swap Deployment Strategy' do
       allow(green_asg_driver).to receive(:describe) { {min: 0, desired: 0, max: 0} }
 
       asg_swap = CfDeployer::DeploymentStrategy.create(app, env, component, context)
-      asg_swap.send(:stack_active?, blue_stack).should be(true)
+      expect(asg_swap.send(:stack_active?, blue_stack)).to be(true)
     end
   end
 

data/spec/unit/deployment_strategy/base_spec.rb

@@ -57,12 +57,11 @@ describe 'Base Deployment Strategy' do
 
     it "should return nil if there is no active stack" do
       the_stack = double()
-      the_stack.should_receive(:exists?).and_return(false)
-      the_stack.should_not_receive(:template)
+      expect(the_stack).to receive(:exists?).and_return(false)
+      expect(the_stack).not_to receive(:template)
 
       strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', @context[:components][:web])
-      strategy.should_receive(:active_stack).and_return(the_stack)
-      # strategy.should_not_receive(:get_parameters_outputs)
+      expect(strategy).to receive(:active_stack).and_return(the_stack)
 
       expect( strategy.active_template ).to eq(nil)
     end
@@ -71,11 +70,11 @@ describe 'Base Deployment Strategy' do
       the_template = double
 
       the_stack = double
-      the_stack.should_receive(:exists?).and_return(true)
-      the_stack.should_receive(:template).and_return(the_template)
+      expect(the_stack).to receive(:exists?).and_return(true)
+      expect(the_stack).to receive(:template).and_return(the_template)
 
       strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', @context[:components][:web])
-      strategy.should_receive(:active_stack).and_return(the_stack)
+      expect(strategy).to receive(:active_stack).and_return(the_stack)
 
       expect( strategy.active_template ).to eq(the_template)
     end
@@ -96,8 +95,8 @@ describe 'Base Deployment Strategy' do
 
     it "should run the specified hook" do
       hook = double()
-      CfDeployer::Hook.should_receive(:new).and_return(hook)
-      hook.should_receive(:run)
+      expect(CfDeployer::Hook).to receive(:new).and_return(hook)
+      expect(hook).to receive(:run)
 
       strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', @context[:components][:web])
       strategy.instance_variable_set('@params_and_outputs_resolved', true)
@@ -107,30 +106,30 @@ describe 'Base Deployment Strategy' do
     it "should not try to resolve parameters and outputs they're already initialized" do
       strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', @context[:components][:web])
       strategy.instance_variable_set('@params_and_outputs_resolved', true)
-      strategy.should_not_receive(:get_parameters_outputs)
+      expect(strategy).not_to receive(:get_parameters_outputs)
       strategy.run_hook(:some_hook)
     end
 
     it "should not try to resolve parameters and outputs if there's no running stack" do
       the_stack = double()
-      the_stack.should_receive(:exists?).and_return(false)
-      the_stack.should_receive(:name).and_return("thestack")
+      expect(the_stack).to receive(:exists?).and_return(false)
+      expect(the_stack).to receive(:name).and_return("thestack")
 
       strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', @context[:components][:web])
-      strategy.should_receive(:active_stack).and_return(the_stack)
-      strategy.should_not_receive(:get_parameters_outputs)
+      expect(strategy).to receive(:active_stack).and_return(the_stack)
+      expect(strategy).not_to receive(:get_parameters_outputs)
       strategy.run_hook(:some_hook)
     end
 
     it "should not try to run a hook if there's no running stack" do
-      CfDeployer::Hook.should_not_receive(:new)
+      expect(CfDeployer::Hook).not_to receive(:new)
 
       the_stack = double()
-      the_stack.should_receive(:exists?).and_return(false)
-      the_stack.should_receive(:name).and_return("thestack")
+      expect(the_stack).to receive(:exists?).and_return(false)
+      expect(the_stack).to receive(:name).and_return("thestack")
 
       strategy = CfDeployer::DeploymentStrategy.create('myApp', 'uat', 'web', @context[:components][:web])
-      strategy.should_receive(:active_stack).and_return(the_stack)
+      expect(strategy).to receive(:active_stack).and_return(the_stack)
       strategy.run_hook(:some_hook)
     end
   end

data/spec/unit/deployment_strategy/cname_swap_spec.rb

@@ -66,7 +66,7 @@ describe CfDeployer::DeploymentStrategy::CnameSwap do
       end
       expect(dns_driver).to receive(:delete_record_set).with('foobar.com', 'test.foobar.com')
       cname_swap.destroy
-      @log.should eq('green deleted.blue deleted.')
+      expect(@log).to eq('green deleted.blue deleted.')
     end
   end
 
@@ -188,19 +188,19 @@ describe CfDeployer::DeploymentStrategy::CnameSwap do
       blue_stack.die!
       green_stack.die!
       cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
-      cname_swap.exists?.should be_false
+      expect(cname_swap.exists?).to be_falsey
     end
 
     it 'yes, if green stack exists and blue stack does not' do
       blue_stack.die!
       cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
-      cname_swap.exists?.should be_true
+      expect(cname_swap.exists?).to be_truthy
     end
 
     it 'yes, if blue stack exists and green stack does not' do
       green_stack.die!
       cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
-      cname_swap.exists?.should be_true
+      expect(cname_swap.exists?).to be_truthy
     end
   end
 
@@ -220,7 +220,7 @@ describe CfDeployer::DeploymentStrategy::CnameSwap do
       my_context.delete :dns_driver
       my_context[:settings][:'dns-driver'] = 'CfDeployer::Driver::Verisign'
       cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', my_context)
-      cname_swap.send(:dns_driver).class.to_s.should eq(my_context[:settings][:'dns-driver'])
+      expect(cname_swap.send(:dns_driver).class.to_s).to eq(my_context[:settings][:'dns-driver'])
     end
   end
 
@@ -283,14 +283,14 @@ describe CfDeployer::DeploymentStrategy::CnameSwap do
 
     it 'should get stack output if active stack exists' do
       allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ 'BLUE-elb.aws.amazon.com' }
-       cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
-      cname_swap.output_value("AutoScalingGroupID").should eq("blueASG")
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      expect(cname_swap.output_value("AutoScalingGroupID")).to eq("blueASG")
     end
 
     it 'should get the information where the value comes from if the active stack does not exist' do
       allow(dns_driver).to receive(:find_alias_target).with('foobar.com', 'test.foobar.com'){ '' }
-       cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
-      cname_swap.output_value(:a_key).should eq("The value will be referenced from the output a_key of undeployed component web")
+      cname_swap = CfDeployer::DeploymentStrategy.create('myapp', 'dev', 'web', @context)
+      expect(cname_swap.output_value(:a_key)).to eq("The value will be referenced from the output a_key of undeployed component web")
     end
   end
 end

data/spec/unit/deployment_strategy/create_or_update_spec.rb

@@ -33,7 +33,7 @@ describe 'CreateOrUpdate Strategy' do
     expect(@after_create_hook).to receive(:run) do |given_context|
       hook_context = given_context
     end
-    @stack.should_receive(:exists?).and_return(false)
+    expect(@stack).to receive(:exists?).and_return(false)
     expect(@stack).to receive(:deploy)
     @create_or_update.deploy
     expect(hook_context[:parameters]).to eq( {'vpc' => 'myvpc'} )
@@ -45,7 +45,7 @@ describe 'CreateOrUpdate Strategy' do
     expect(@after_update_hook).to receive(:run) do |given_context|
       hook_context = given_context
     end
-    @stack.should_receive(:exists?).and_return(true)
+    expect(@stack).to receive(:exists?).and_return(true)
     expect(@stack).to receive(:deploy)
     @create_or_update.deploy
     expect(hook_context[:parameters]).to eq( {'vpc' => 'myvpc'} )
@@ -60,7 +60,7 @@ describe 'CreateOrUpdate Strategy' do
       context = @context[:components][:base]
       context[:settings] = {}
       context[:settings][:'auto-scaling-group-name-output'] = ['AutoScalingGroupID']
-      @stack.should_receive(:exists?).and_return(false)
+      expect(@stack).to receive(:exists?).and_return(false)
       allow(@stack).to receive(:find_output).with('AutoScalingGroupID') { 'asg_name' }
       allow(CfDeployer::Driver::AutoScalingGroup).to receive(:new).with('asg_name') { asg_driver }
       allow(asg_driver).to receive(:describe) { {desired:2, min:1, max:3} }
@@ -74,19 +74,19 @@ describe 'CreateOrUpdate Strategy' do
 
   it 'should tell if stack exists' do
     expect(@stack).to receive(:exists?){true}
-    @create_or_update.exists?.should eq(true)
+    expect(@create_or_update.exists?).to eq(true)
   end
 
   it 'should get stack output' do
     allow(@stack).to receive(:exists?){true}
     expect(@stack).to receive(:output).with(:a_key){ "output_value" }
-    @create_or_update.output_value(:a_key).should eq("output_value")
+    expect(@create_or_update.output_value(:a_key)).to eq("output_value")
   end
 
   it 'should get the information where the value comes from if the stack does not exist' do
     allow(@stack).to receive(:exists?){false}
     expect(@stack).not_to receive(:output).with(anything)
-    @create_or_update.output_value(:a_key).should eq("The value will be referenced from the output a_key of undeployed component base")
+    expect(@create_or_update.output_value(:a_key)).to eq("The value will be referenced from the output a_key of undeployed component base")
   end
 
   context '#destroy' do
@@ -119,11 +119,11 @@ describe 'CreateOrUpdate Strategy' do
       allow(@stack).to receive(:exists?) { true }
     end
     it 'should get status from stack' do
-      @create_or_update.status.should eq({ 'base-uat' => {status: 'deployed'}})
+      expect(@create_or_update.status).to eq({ 'base-uat' => {status: 'deployed'}})
     end
     it 'should get status from stack including resource info' do
       allow(@stack).to receive(:resource_statuses) { 'resource1' }
-      @create_or_update.status(true).should eq({ 'base-uat' => {status: 'deployed', resources: 'resource1'}})
+      expect(@create_or_update.status(true)).to eq({ 'base-uat' => {status: 'deployed', resources: 'resource1'}})
     end
   end
 end