cf_deployer 1.6.0 → 2.0.0

data/spec/unit/driver/auto_scaling_group_spec.rb

@@ -2,38 +2,39 @@ require 'spec_helper'
 
 describe 'Autoscaling group driver' do
   let(:group) { double('group', :desired_capacity => 2, :min_size => 1, :max_size => 4)}
-  let(:scaling) { double('scaling', :groups => { 'myAsg' => group}) }
   let(:ec2_instance1) { double('ec2_instance1') }
   let(:ec2_instance2) { double('ec2_instance2') }
   let(:ec2_instance3) { double('ec2_instance3') }
   let(:ec2_instance4) { double('ec2_instance4') }
-  let(:instance1) { double('instance1', :health_status => 'HEALTHY', :ec2_instance => ec2_instance1)}
-  let(:instance2) { double('instance2', :health_status => 'HEALTHY', :ec2_instance => ec2_instance2)}
-  let(:instance3) { double('instance3', :health_status => 'HEALTHY', :ec2_instance => ec2_instance3)}
-  let(:instance4) { double('instance4', :health_status => 'HEALTHY', :ec2_instance => ec2_instance4)}
+  let(:instance1) { double('instance1', :id => 'instance1', :health_status => 'HEALTHY', :ec2_instance => ec2_instance1)}
+  let(:instance2) { double('instance2', :id => 'instance2', :health_status => 'HEALTHY', :ec2_instance => ec2_instance2)}
+  let(:instance3) { double('instance3', :id => 'instance3', :health_status => 'HEALTHY', :ec2_instance => ec2_instance3)}
+  let(:instance4) { double('instance4', :id => 'instance4', :health_status => 'HEALTHY', :ec2_instance => ec2_instance4)}
   let(:load_balancer) { double('load_balancer', :instances => [instance1, instance2, instance3, instance4]) }
+  let(:elb_driver) { double(Aws::ElasticLoadBalancing::Client) }
 
   before :each do
-    allow(AWS::AutoScaling).to receive(:new) { scaling }
-    allow(group).to receive(:load_balancers) { [] }
-    allow(group).to receive(:auto_scaling_instances) { [] }
-    allow(group).to receive(:ec2_instances) { [] }
+    allow(Aws::ElasticLoadBalancing::Client).to receive(:new) { elb_driver }
+    allow(group).to receive(:load_balancer_names) { [] }
+    allow(group).to receive(:instances) { [] }
+    allow(Aws::AutoScaling::AutoScalingGroup).to receive(:new).with('myAsg') { group }
+    allow(group).to receive(:reload) { group }
     @driver = CfDeployer::Driver::AutoScalingGroup.new('myAsg', 1)
   end
 
   it 'should describe group' do
-    @driver.describe.should eq({ min: 1, max: 4, desired: 2})
+    expect(@driver.describe).to eq({ min: 1, max: 4, desired: 2})
   end
 
   describe '#warm_up' do
     it 'should warm up the group to the desired size' do
-      expect(group).to receive(:set_desired_capacity).with(2)
+      expect(group).to receive(:set_desired_capacity).with({desired_capacity: 2})
       expect(@driver).to receive(:wait_for_desired_capacity)
       @driver.warm_up 2
     end
 
     it 'should wait for the warm up of the group even if desired is the same as the minimum' do
-      expect(group).to receive(:set_desired_capacity).with(1)
+      expect(group).to receive(:set_desired_capacity).with({desired_capacity: 1})
       expect(@driver).to receive(:wait_for_desired_capacity)
       @driver.warm_up 1
     end
@@ -45,7 +46,7 @@ describe 'Autoscaling group driver' do
     end
 
     it 'should warm up to maximum if desired number is greater than maximum size of group' do
-      expect(group).to receive(:set_desired_capacity).with(4)
+      expect(group).to receive(:set_desired_capacity).with({desired_capacity: 4})
       expect(@driver).to receive(:wait_for_desired_capacity)
       @driver.warm_up 5
     end
@@ -57,14 +58,14 @@ describe 'Autoscaling group driver' do
       instance2 =  double('instance2', :health_status => 'HEALTHY', id: 'instance2')
       instance3 =  double('instance3', :health_status => 'UNHEALTHY', id: 'instance3')
       instance4 =  double('instance4', :health_status => 'HEALTHY', id: 'instance4')
-      allow(group).to receive(:auto_scaling_instances){[instance1, instance2, instance3, instance4]}
+      allow(group).to receive(:instances){[instance1, instance2, instance3, instance4]}
 
       expect(@driver.healthy_instance_ids).to eql ['instance1', 'instance2', 'instance4']
     end
 
     it 'returns the ids of all instances that are healthy (case insensitive)' do
       instance1 =  double('instance1', :health_status => 'HealThy', id: 'instance1')
-      allow(group).to receive(:auto_scaling_instances){[instance1]}
+      allow(group).to receive(:instances){[instance1]}
 
       expect(@driver.healthy_instance_ids).to eql ['instance1']
     end
@@ -73,69 +74,80 @@ describe 'Autoscaling group driver' do
   describe '#in_service_instance_ids' do
     context 'when there are no load balancers' do
       it 'returns no ids' do
-        allow(group).to receive(:load_balancers).and_return([])
+        allow(group).to receive(:load_balancer_names).and_return([])
 
         expect(@driver.in_service_instance_ids).to eq []
       end
     end
 
     context 'when there is only 1 elb' do
+      let(:elb1_instance_health) { double('elb1_instance_health') }
+
+      before(:each) do
+        allow(group).to receive(:load_balancer_names).and_return(['elb1'])
+        allow(elb_driver).to receive(:describe_instance_health)
+          .with(hash_including(load_balancer_name: 'elb1')) { elb1_instance_health }
+      end
+
       it 'returns the ids of all instances that are in service' do
-        health1 = { state: 'InService', instance: double('i1', id: 'instance1') }
-        health2 = { state: 'OutOfService', instance: double('i2', id: 'instance2') }
-        health3 = { state: 'InService', instance: double('i3', id: 'instance3') }
-        health4 = { state: 'InService', instance: double('i4', id: 'instance4') }
+        health1 = double(:state => 'InService', instance_id: 'instance1')
+        health2 = double(:state => 'OutOfService', instance_id: 'instance2')
+        health3 = double(:state => 'InService', instance_id: 'instance3')
+        health4 = double(:state => 'InService', instance_id: 'instance4')
 
-        instance_collection = double('instance_collection', health: [health1, health2, health3, health4])
-        elb = double('elb', instances: instance_collection)
-        allow(group).to receive(:load_balancers).and_return([ elb ])
+        allow(elb1_instance_health).to receive(:instance_states) { [health1, health2, health3, health4] }
+        allow(group).to receive(:load_balancer_names).and_return([ 'elb1' ])
 
         expect(@driver.in_service_instance_ids).to eql ['instance1', 'instance3', 'instance4']
       end
     end
 
     context 'when there are multiple elbs' do
+      let(:elb1_instance_health) { double('elb1_instance_health') }
+      let(:elb2_instance_health) { double('elb2_instance_health') }
+      let(:elb3_instance_health) { double('elb3_instance_health') }
+
+      before(:each) do
+        allow(group).to receive(:load_balancer_names).and_return(['elb1', 'elb2', 'elb3'])
+        allow(elb_driver).to receive(:describe_instance_health)
+          .with(hash_including(load_balancer_name: 'elb1')) { elb1_instance_health }
+        allow(elb_driver).to receive(:describe_instance_health)
+          .with(hash_including(load_balancer_name: 'elb2')) { elb2_instance_health }
+        allow(elb_driver).to receive(:describe_instance_health)
+          .with(hash_including(load_balancer_name: 'elb3')) { elb3_instance_health }
+      end
+
       it 'returns only the ids of instances that are in all ELBs' do
-        health1 = { state: 'InService', instance: double('i1', id: 'instance1') }
-        health2 = { state: 'InService', instance: double('i2', id: 'instance2') }
-        health3 = { state: 'InService', instance: double('i3', id: 'instance3') }
-        health4 = { state: 'InService', instance: double('i4', id: 'instance4') }
-        health5 = { state: 'InService', instance: double('i5', id: 'instance5') }
-
-        instance_collection1 = double('instance_collection1', health: [health1, health2, health3])
-        instance_collection2 = double('instance_collection2', health: [health2, health3, health4])
-        instance_collection3 = double('instance_collection3', health: [health2, health3, health5])
-        elb1 = double('elb1', instances: instance_collection1)
-        elb2 = double('elb2', instances: instance_collection2)
-        elb3 = double('elb3', instances: instance_collection3)
-        allow(group).to receive(:load_balancers).and_return([ elb1, elb2, elb3 ])
+        health1 = double(state: 'InService', instance_id: 'instance1')
+        health2 = double(state: 'InService', instance_id: 'instance2')
+        health3 = double(state: 'InService', instance_id: 'instance3')
+        health4 = double(state: 'InService', instance_id: 'instance4')
+        health5 = double(state: 'InService', instance_id: 'instance5')
+
+        allow(elb1_instance_health).to receive(:instance_states) { [health1, health2, health3] }
+        allow(elb2_instance_health).to receive(:instance_states) { [health2, health3, health4] }
+        allow(elb3_instance_health).to receive(:instance_states) { [health2, health3, health5] }
 
         # Only instance 2 and 3 are associated with all ELB's
         expect(@driver.in_service_instance_ids).to eql ['instance2', 'instance3']
       end
 
       it 'returns only the ids instances that are InService in all ELBs' do
-        health11 = { state: 'OutOfService', instance: double('i1', id: 'instance1') }
-        health12 = { state: 'InService', instance: double('i2', id: 'instance2') }
-        health13 = { state: 'InService', instance: double('i3', id: 'instance3') }
-
-        health21 = { state: 'InService', instance: double('i1', id: 'instance1') }
-        health22 = { state: 'InService', instance: double('i2', id: 'instance2') }
-        health23 = { state: 'OutOfService', instance: double('i3', id: 'instance3') }
-
-        health31 = { state: 'InService', instance: double('i1', id: 'instance1') }
-        health32 = { state: 'InService', instance: double('i2', id: 'instance2') }
-        health33 = { state: 'InService', instance: double('i3', id: 'instance3') }
+        health11 = double(state: 'OutOfService', instance_id: 'instance1')
+        health12 = double(state: 'InService', instance_id: 'instance2')
+        health13 = double(state: 'InService', instance_id: 'instance3')
 
-        instance_collection1 = double('instance_collection1', health: [health11, health12, health13])
-        instance_collection2 = double('instance_collection2', health: [health21, health22, health23])
-        instance_collection3 = double('instance_collection3', health: [health31, health32, health33])
+        health21 = double(state: 'InService', instance_id: 'instance1')
+        health22 = double(state: 'InService', instance_id: 'instance2')
+        health23 = double(state: 'OutOfService', instance_id: 'instance3')
 
-        elb1 = double('elb1', instances: instance_collection1)
-        elb2 = double('elb2', instances: instance_collection2)
-        elb3 = double('elb3', instances: instance_collection3)
+        health31 = double(state: 'InService', instance_id: 'instance1')
+        health32 = double(state: 'InService', instance_id: 'instance2')
+        health33 = double(state: 'InService', instance_id: 'instance3')
 
-        allow(group).to receive(:load_balancers).and_return([ elb1, elb2, elb3 ])
+        allow(elb1_instance_health).to receive(:instance_states) { [health11, health12, health13] }
+        allow(elb2_instance_health).to receive(:instance_states) { [health21, health22, health23] }
+        allow(elb3_instance_health).to receive(:instance_states) { [health31, health32, health33] }
 
         # Only instance 2 is InService across all ELB's
         expect(@driver.in_service_instance_ids).to eql ['instance2']
@@ -158,7 +170,7 @@ describe 'Autoscaling group driver' do
       it 'should return the number of instances that are both healthy, and in service' do
         healthy_instance_ids = ['1', '3', '4', '5']
         in_service_instance_ids = ['3', '4']
-        allow(@driver).to receive(:load_balancers).and_return(double('elb', empty?: false))
+        allow(@driver).to receive(:load_balancer_names).and_return(['elb1'])
         expect(@driver).to receive(:healthy_instance_ids).and_return(healthy_instance_ids)
         expect(@driver).to receive(:in_service_instance_ids).and_return(in_service_instance_ids)
 
@@ -176,7 +188,7 @@ describe 'Autoscaling group driver' do
   describe '#cool_down' do
     it 'should cool down group' do
       expect(group).to receive(:update).with({min_size: 0, max_size: 0})
-      expect(group).to receive(:set_desired_capacity).with(0)
+      expect(group).to receive(:set_desired_capacity).with({desired_capacity: 0})
       @driver.cool_down
     end
   end
@@ -184,7 +196,7 @@ describe 'Autoscaling group driver' do
   describe '#warm_up_cooled_group' do
     it 'should set min, max, and desired from a hash' do
       hash = {:max => 5, :min => 2, :desired => 3}
-      allow(group).to receive(:auto_scaling_instances){[instance1, instance2, instance3]}
+      allow(group).to receive(:instances){[instance1, instance2, instance3]}
       expect(group).to receive(:update).with({:min_size => 2, :max_size => 5})
       expect(@driver).to receive(:warm_up).with(3)
       @driver.warm_up_cooled_group hash
@@ -193,15 +205,13 @@ describe 'Autoscaling group driver' do
 
   describe '#instance_statuses' do
     it 'should get the status for any EC2 instances' do
-      aws_instance = double AWS::EC2::Instance
-      expect(aws_instance).to receive(:id) { 'i-abcd1234' }
-      allow(@driver).to receive(:ec2_instances) { [ aws_instance ] }
+      allow(@driver).to receive(:instances) { [ instance1 ] }
 
       returned_status = { :status => :some_status }
       cfd_instance = double CfDeployer::Driver::Instance
-      expect(CfDeployer::Driver::Instance).to receive(:new).with(aws_instance) { cfd_instance }
+      expect(CfDeployer::Driver::Instance).to receive(:new).with(instance1.id) { cfd_instance }
       expect(cfd_instance).to receive(:status) { returned_status }
-      expect(@driver.instance_statuses).to eq( { 'i-abcd1234' => returned_status } )
+      expect(@driver.instance_statuses).to eq( { 'instance1' => returned_status } )
     end
   end
 
@@ -226,7 +236,7 @@ describe 'Autoscaling group driver' do
       expect(group).to receive(:desired_capacity).and_return(expected_number)
       expect(@driver).to receive(:healthy_instance_count).and_return(expected_number)
 
-      expect(@driver.desired_capacity_reached?).to be_true
+      expect(@driver.desired_capacity_reached?).to be_truthy
     end
 
     it 'returns false if healthy instance count is less than desired capacity' do
@@ -235,7 +245,7 @@ describe 'Autoscaling group driver' do
       expect(group).to receive(:desired_capacity).and_return(expected_number)
       expect(@driver).to receive(:healthy_instance_count).and_return(expected_number - 1)
 
-      expect(@driver.desired_capacity_reached?).to be_false
+      expect(@driver.desired_capacity_reached?).to be_falsey
     end
 
     it 'returns true if healthy instance count is more than desired capacity' do
@@ -244,7 +254,7 @@ describe 'Autoscaling group driver' do
       expect(group).to receive(:desired_capacity).and_return(expected_number)
       expect(@driver).to receive(:healthy_instance_count).and_return(expected_number + 1)
 
-      expect(@driver.desired_capacity_reached?).to be_true
+      expect(@driver.desired_capacity_reached?).to be_truthy
     end
   end
 end

data/spec/unit/driver/aws_sdk_v3_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+# Exercises the drivers against real AWS SDK v3 classes backed by stubbed
+# clients, so SDK return types and resource caching behave as they do in AWS.
+describe 'drivers against the AWS SDK v3' do
+  def stub_aws(service, stubs)
+    Aws.config.update(service => { stub_responses: stubs })
+  end
+
+  around(:each) do |example|
+    saved = Aws.config.dup
+    Aws.config.update(region: 'us-east-1', credentials: Aws::Credentials.new('akid', 'secret'))
+    example.run
+  ensure
+    Aws.config = saved
+  end
+
+  it 'configures 20 retries for AWS calls' do
+    expect(Aws::CloudFormation::Client.new(stub_responses: true).config.retry_limit).to eq(20)
+  end
+
+  describe CfDeployer::Driver::AutoScalingGroup do
+    def group(desired:, healthy:)
+      {
+        auto_scaling_group_name: 'myAsg', min_size: 0, max_size: 5, desired_capacity: desired,
+        default_cooldown: 300, availability_zones: ['us-east-1a'], health_check_type: 'EC2', created_time: Time.now,
+        load_balancer_names: [],
+        instances: Array.new(healthy) do |i|
+          { instance_id: "i-#{i}", availability_zone: 'us-east-1a', lifecycle_state: 'InService',
+            health_status: 'Healthy', protected_from_scale_in: false }
+        end
+      }
+    end
+
+    it 'sees fresh group data while waiting for desired capacity' do
+      stub_aws(:autoscaling, describe_auto_scaling_groups: [
+        { auto_scaling_groups: [group(desired: 2, healthy: 0)] },
+        { auto_scaling_groups: [group(desired: 2, healthy: 1)] },
+        { auto_scaling_groups: [group(desired: 2, healthy: 2)] }
+      ])
+      driver = CfDeployer::Driver::AutoScalingGroup.new('myAsg', 5)
+      allow(driver).to receive(:sleep)
+
+      expect { driver.wait_for_desired_capacity }.not_to raise_error
+      expect(driver).to have_received(:sleep).twice
+    end
+  end
+
+  describe CfDeployer::Driver::CloudFormation do
+    let(:stack) do
+      { stack_name: 'myStack', creation_time: Time.now, stack_status: 'UPDATE_COMPLETE',
+        parameters: [{ parameter_key: 'foo', parameter_value: 'bar' }],
+        outputs: [{ output_key: 'elb', output_value: 'my-elb' }] }
+    end
+
+    it 'raises validation errors other than "No updates are to be performed"' do
+      stub_aws(:cloudformation, update_stack: Aws::CloudFormation::Errors::ValidationError.new(nil, 'Template format error'))
+
+      CfDeployer::Driver::DryRun.disable_for do
+        expect { CfDeployer::Driver::CloudFormation.new('myStack').update_stack('{}', {}) }
+          .to raise_error(Aws::CloudFormation::Errors::ValidationError, 'Template format error')
+      end
+    end
+
+    it 'returns false when there are no updates to perform' do
+      stub_aws(:cloudformation, update_stack: Aws::CloudFormation::Errors::ValidationError.new(nil, 'No updates are to be performed.'))
+
+      CfDeployer::Driver::DryRun.disable_for do
+        expect(CfDeployer::Driver::CloudFormation.new('myStack').update_stack('{}', {})).to eq(false)
+      end
+    end
+
+    it 'gets the template body' do
+      stub_aws(:cloudformation, get_template: { template_body: '{"Resources":{}}' })
+      expect(CfDeployer::Driver::CloudFormation.new('myStack').template).to eq('{"Resources":{}}')
+    end
+
+    it 'gets parameters and outputs as hashes' do
+      stub_aws(:cloudformation, describe_stacks: { stacks: [stack] })
+      driver = CfDeployer::Driver::CloudFormation.new('myStack')
+
+      expect(driver.parameters).to eq('foo' => 'bar')
+      expect(driver.outputs).to eq('elb' => 'my-elb')
+      expect(driver.query_output('elb')).to eq('my-elb')
+    end
+
+    it 'treats a missing stack as not existing' do
+      stub_aws(:cloudformation, describe_stacks: Aws::CloudFormation::Errors::ValidationError.new(nil, 'Stack with id myStack does not exist'))
+      driver = CfDeployer::Driver::CloudFormation.new('myStack')
+
+      expect(driver.stack_exists?).to eq(false)
+      expect(driver.stack_status).to be_nil
+      expect { driver.query_output('elb') }.to raise_error(Aws::CloudFormation::Errors::ValidationError)
+    end
+
+    it 'raises other errors when describing the stack' do
+      stub_aws(:cloudformation, describe_stacks: Aws::CloudFormation::Errors::ValidationError.new(nil, 'Rate exceeded'))
+      expect { CfDeployer::Driver::CloudFormation.new('myStack').stack_exists? }.to raise_error(Aws::CloudFormation::Errors::ValidationError, 'Rate exceeded')
+    end
+
+    it 'reads resource statuses from every page' do
+      summary = ->(id) { { logical_resource_id: id, physical_resource_id: id, resource_type: 'AWS::EC2::Instance',
+                           resource_status: 'CREATE_COMPLETE', last_updated_timestamp: Time.now } }
+      stub_aws(:cloudformation, list_stack_resources: [
+        { stack_resource_summaries: [summary.call('i-1')], next_token: 'page2' },
+        { stack_resource_summaries: [summary.call('i-2')] }
+      ])
+
+      statuses = CfDeployer::Driver::CloudFormation.new('myStack').resource_statuses
+      expect(statuses['AWS::EC2::Instance'].keys).to eq(['i-1', 'i-2'])
+    end
+  end
+
+  describe CfDeployer::Driver::Instance do
+    it 'reports the instance state as a symbol' do
+      stub_aws(:ec2, describe_instances: { reservations: [{ instances: [{
+        instance_id: 'i-1', state: { code: 32, name: 'shutting-down' }, key_name: 'my-key',
+        public_ip_address: '1.2.3.4', private_ip_address: '10.0.0.1', image_id: 'ami-1'
+      }] }] })
+
+      status = CfDeployer::Driver::Instance.new('i-1').status
+      expect(status).to eq(status: :shutting_down, key_pair: 'my-key', public_ip_address: '1.2.3.4',
+                           private_ip_address: '10.0.0.1', image_id: 'ami-1')
+    end
+  end
+
+  describe CfDeployer::Driver::Route53 do
+    let(:client) do
+      Aws::Route53::Client.new(stub_responses: {
+        list_hosted_zones_by_name: { hosted_zones: [{ id: '/hostedzone/Z1', name: 'target.com.', caller_reference: 'ref' }],
+                                     is_truncated: false, max_items: 100 },
+        list_resource_record_sets: { resource_record_sets: [
+          { name: 'foo.target.com.', type: 'A', alias_target: { hosted_zone_id: 'Z2', dns_name: 'elb.aws.com.', evaluate_target_health: false } }
+        ], is_truncated: false, max_items: 300 }
+      })
+    end
+    let(:driver) { CfDeployer::Driver::Route53.new(client) }
+
+    it 'looks up the zone and record by name rather than listing everything' do
+      expect(driver.find_alias_target('Target.com', 'Foo.target.com')).to eq('elb.aws.com')
+
+      zone_request = client.api_requests.find { |r| r[:operation_name] == :list_hosted_zones_by_name }
+      record_request = client.api_requests.find { |r| r[:operation_name] == :list_resource_record_sets }
+      expect(zone_request[:params]).to include(dns_name: 'target.com.')
+      expect(record_request[:params]).to include(hosted_zone_id: 'Z1', start_record_name: 'foo.target.com.')
+    end
+
+    it 'deletes a record set' do
+      CfDeployer::Driver::DryRun.disable_for do
+        driver.delete_record_set('target.com', 'foo.target.com')
+      end
+
+      delete = client.api_requests.find { |r| r[:operation_name] == :change_resource_record_sets }
+      expect(delete[:params]).to eq(
+        hosted_zone_id: 'Z1', # the SDK strips the /hostedzone/ prefix
+        change_batch: { changes: [{ action: 'DELETE', resource_record_set: {
+          name: 'foo.target.com.', type: 'A',
+          alias_target: { hosted_zone_id: 'Z2', dns_name: 'elb.aws.com.', evaluate_target_health: false }
+        } }] }
+      )
+    end
+  end
+end

data/spec/unit/driver/cloud_formation_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe 'CloudFormation' do
   let(:outputs) { [output1, output2] }
-  let(:output1) { double('output1', :key => 'key1', :value => 'value1')}
-  let(:output2) { double('output2', :key => 'key2', :value => 'value2')}
-  let(:parameters) { double('parameters')}
+  let(:output1) { double('output1', :output_key => 'key1', :output_value => 'value1')}
+  let(:output2) { double('output2', :output_key => 'key2', :output_value => 'value2')}
+  let(:parameters) { [double('parameter1', :parameter_key => 'param1', :parameter_value => 'value1')] }
   let(:resource_summaries) { [
       {
           :resource_type => 'AWS::AutoScaling::AutoScalingGroup',
@@ -22,24 +22,27 @@ describe 'CloudFormation' do
           :resource_status => 'STATUS_2'
       }
   ] }
-  let(:stack) { double('stack', :outputs => outputs, :parameters => parameters, :resource_summaries => resource_summaries) }
+  let(:stack) { double('stack', :stack_name => 'testStack', :outputs => outputs, :parameters => parameters) }
+  let(:cloudFormationStacks) { [stack] }
   let(:cloudFormation) {
     double('cloudFormation',
-           :stacks =>
-           {'testStack' => stack
-           })
+      :describe_stacks => double(:stacks => cloudFormationStacks),
+      :list_stack_resources => [double(:stack_resource_summaries => resource_summaries)]
+    )
   }
 
   before(:each) do
-    allow(AWS::CloudFormation).to receive(:new) { cloudFormation }
+    allow(Aws::CloudFormation::Client).to receive(:new) { cloudFormation }
+    allow(cloudFormation).to receive(:create_stack)
+    allow(cloudFormation).to receive(:update_stack)
   end
 
   it 'should get outputs of stack' do
-    CfDeployer::Driver::CloudFormation.new('testStack').outputs.should eq({'key1' => 'value1', 'key2' => 'value2'})
+    expect(CfDeployer::Driver::CloudFormation.new('testStack').outputs).to eq({'key1' => 'value1', 'key2' => 'value2'})
   end
 
   it 'should get parameters of stack' do
-    CfDeployer::Driver::CloudFormation.new('testStack').parameters.should eq(parameters)
+    expect(CfDeployer::Driver::CloudFormation.new('testStack').parameters).to eq({'param1' => 'value1'})
   end
 
   context 'update_stack' do
@@ -60,32 +63,31 @@ describe 'CloudFormation' do
         result = cloud_formation.update_stack :template, {}
       end
 
-      expect(result).to be_false
+      expect(result).to be_falsey
     end
 
     it 'returns false if no updates were performed (because no difference in template)' do
       cloud_formation = CfDeployer::Driver::CloudFormation.new 'my_stack'
-      expect(cloud_formation).to receive(:aws_stack).and_raise(AWS::CloudFormation::Errors::ValidationError.new('No updates are to be performed'))
+      expect(cloudFormation).to receive(:update_stack).and_raise(Aws::CloudFormation::Errors::ValidationError.new(nil, 'No updates are to be performed'))
       result = nil
 
       CfDeployer::Driver::DryRun.disable_for do
         result = cloud_formation.update_stack :template, {}
       end
 
-      expect(result).to be_false
+      expect(result).to be_falsey
     end
 
     it 'returns true when updates are performed' do
       cloud_formation = CfDeployer::Driver::CloudFormation.new 'my_stack'
-      aws_stack = double(:update => :did_something)
-      expect(cloud_formation).to receive(:aws_stack).and_return aws_stack
       result = nil
 
       CfDeployer::Driver::DryRun.disable_for do
         result = cloud_formation.update_stack :template, {}
       end
 
-      expect(result).to be_true
+      expect(cloudFormation).to have_received(:update_stack)
+      expect(result).to be_truthy
     end
 
   end
@@ -102,7 +104,7 @@ describe 'CloudFormation' do
           }
       }
 
-      CfDeployer::Driver::CloudFormation.new('testStack').resource_statuses.should eq(expected)
+      expect(CfDeployer::Driver::CloudFormation.new('testStack').resource_statuses).to eq(expected)
     end
   end
 end

data/spec/unit/driver/dry_run_spec.rb

@@ -11,8 +11,8 @@ describe 'DryRun' do
           enabled_in_block = CfDeployer::Driver::DryRun.enabled?
         end
 
-        expect(enabled_in_block).to be_true
-        expect(CfDeployer::Driver::DryRun.enabled?).to be_false
+        expect(enabled_in_block).to be_truthy
+        expect(CfDeployer::Driver::DryRun.enabled?).to be_falsey
       end
     end
 
@@ -27,8 +27,8 @@ describe 'DryRun' do
           end
         end.to raise_error('boom')
 
-        expect(enabled_in_block).to be_true
-        expect(CfDeployer::Driver::DryRun.enabled?).to be_false
+        expect(enabled_in_block).to be_truthy
+        expect(CfDeployer::Driver::DryRun.enabled?).to be_falsey
       end
     end
   end
@@ -42,8 +42,8 @@ describe 'DryRun' do
           enabled_in_block = CfDeployer::Driver::DryRun.enabled?
         end
 
-        expect(enabled_in_block).to be_false
-        expect(CfDeployer::Driver::DryRun.enabled?).to be_true
+        expect(enabled_in_block).to be_falsey
+        expect(CfDeployer::Driver::DryRun.enabled?).to be_truthy
       end
     end
 
@@ -58,8 +58,8 @@ describe 'DryRun' do
           end
         end.to raise_error('boom')
 
-        expect(enabled_in_block).to be_false
-        expect(CfDeployer::Driver::DryRun.enabled?).to be_true
+        expect(enabled_in_block).to be_falsey
+        expect(CfDeployer::Driver::DryRun.enabled?).to be_truthy
       end
     end
   end

data/spec/unit/driver/elb_spec.rb

@@ -2,10 +2,16 @@ require 'spec_helper'
 
 describe CfDeployer::Driver::Elb do
   it 'should get dns name and hosted zone id' do
-    elb = double('elb', :dns_name => 'mydns', :canonical_hosted_zone_name_id => 'zone_id')
-    aws = double('aws', :load_balancers => {'myelb' => elb})
+    elb = double('elasticloadbalancing', :dns_name => 'mydns', :canonical_hosted_zone_name_id => 'zone_id')
+
+    aws = double('aws')
+
     elb_name = 'myelb'
-    expect(AWS::ELB).to receive(:new){aws}
-    CfDeployer::Driver::Elb.new.find_dns_and_zone_id(elb_name).should eq({:dns_name => 'mydns', :canonical_hosted_zone_name_id => 'zone_id'})
+    load_balancer_descriptions = double('elb', :load_balancer_descriptions => [elb])
+
+    expect(Aws::ElasticLoadBalancing::Client).to receive(:new){aws}
+    expect(aws).to receive(:describe_load_balancers).with(hash_including(load_balancer_names: [elb_name])) { load_balancer_descriptions }
+
+    expect(CfDeployer::Driver::Elb.new.find_dns_and_zone_id(elb_name)).to eq({:dns_name => 'mydns', :canonical_hosted_zone_name_id => 'zone_id'})
   end
 end

data/spec/unit/driver/instance_spec.rb

@@ -11,14 +11,8 @@ describe CfDeployer::Driver::Instance do
                  }
 
 
-      aws = double AWS::EC2
-      expect(AWS::EC2).to receive(:new) { aws }
-
-      instance_collection = double AWS::EC2::InstanceCollection
-      expect(aws).to receive(:instances) { instance_collection }
-
       instance = Fakes::Instance.new expected.merge( { :id => 'i-wxyz1234' } )
-      expect(instance_collection).to receive(:[]).with(instance.id) { instance }
+      expect(Aws::EC2::Instance).to receive(:new).with('i-wxyz1234') { instance }
 
       instance_status = CfDeployer::Driver::Instance.new('i-wxyz1234').status