vm_shepherd 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4efffe61b1dadc42e8b80ea6418891f27123a06
-  data.tar.gz: 7939d7f0d8dfb2f0adb5cf189fb548e214e9f55b
+  metadata.gz: 80b5490aee5b7e2b0432d36155d4e6b201692246
+  data.tar.gz: c7e60bc1d890dcb7f568c35f5d65306c4e269671
 SHA512:
-  metadata.gz: f3051aeb00de1e9af855be8b5613304586e598cfc60e4b303f4f0207ec0c83c3c0ccde5059f1c0eb34e790afb719fdea8502614d612d5b009c7238365441834a
-  data.tar.gz: 3a5b21ce773494d42dd0fcd93454d93621e6982a759905167c32991a7d4c471adca20099783ff702d322b24bf0e74e75c77c8cee2c0012b92b8d716362ac8dad
+  metadata.gz: 7af47b2d7345668ef156e44bd9cabd60f15a561e66529f2ae7467af085725da385cae0126d81eee46ef8deab5d4f268e131b81eaea5d49ea9492a415838a38a2
+  data.tar.gz: 488c4b9d8393ce2ad2f93e5076820f9a57f8debb3ebeef571a306d1a8f5db4707f57517af700c4e4138bb1276d77b6c614c40ec4f8186f8e2b6c331910bb211c

data/lib/vm_shepherd/aws_manager.rb

@@ -8,6 +8,7 @@ module VmShepherd
     AWS_REGION = 'us-east-1'
     OPS_MANAGER_INSTANCE_TYPE = 'm3.medium'
     DO_NOT_TERMINATE_TAG_KEY = 'do_not_terminate'
+    ELB_SECURITY_GROUP_NAME = 'ELB Security Group'
 
     def initialize(env_config)
       AWS.config(
@@ -22,7 +23,7 @@ module VmShepherd
       template = File.read(cloudformation_template_file)
 
       cfm = AWS::CloudFormation.new
-      stack = cfm.stacks.create(env_config.fetch(:stack_name), template, :parameters => env_config.fetch(:parameters), capabilities: ['CAPABILITY_IAM'])
+      stack = cfm.stacks.create(env_config.fetch(:stack_name), template, parameters: env_config.fetch(:parameters), capabilities: ['CAPABILITY_IAM'])
 
       retry_until(retry_limit: 360) do
         status = stack.status
@@ -38,6 +39,10 @@ module VmShepherd
             raise "Unexpected status for stack #{env_config.fetch(:stack_name)} : #{status}"
         end
       end
+
+      if (elb_config = env_config[:elb])
+        create_elb(stack, elb_config)
+      end
     end
 
     def deploy(ami_file_path:, vm_config:)
@@ -72,40 +77,21 @@ module VmShepherd
     end
 
     def clean_environment
-      subnets = []
-      subnets << AWS.ec2.subnets[env_config.fetch(:outputs).fetch(:public_subnet_id)] if env_config.fetch(:outputs).fetch(:public_subnet_id)
-      subnets << AWS.ec2.subnets[env_config.fetch(:outputs).fetch(:private_subnet_id)] if env_config.fetch(:outputs).fetch(:private_subnet_id)
+      [:public_subnet_id, :private_subnet_id].each do |subnet_id|
+        subnet_id = env_config.fetch(:outputs).fetch(subnet_id)
+        clear_subnet(subnet_id)
+      end
 
-      volumes = []
-      subnets.each do |subnet|
-        subnet.instances.each do |instance|
-          instance.attachments.each do |_, attachment|
-            volumes.push(attachment.volume) unless attachment.delete_on_termination
-          end
-          instance.terminate
-        end
+      if (elb_config = env_config[:elb])
+        delete_elb(elb_config[:name])
       end
-      destroy_volumes(volumes)
 
-      cfm = AWS::CloudFormation.new
-      stack = cfm.stacks[env_config.fetch(:stack_name)]
-      stack.delete
-      retry_until(retry_limit: 360) do
-        begin
-          status = stack.status
-          case status
-            when 'DELETE_COMPLETE'
-              true
-            when 'DELETE_IN_PROGRESS'
-              false
-            else
-              raise "Unexpected status for stack #{env_config.fetch(:stack_name)} : #{status}"
-          end
-        rescue AWS::CloudFormation::Errors::ValidationError
-          raise if stack.exists?
-          true
-        end
-      end if stack
+      if (bucket_name = env_config.fetch(:outputs, {}).fetch(:s3_bucket_name, nil))
+        bucket = AWS::S3.new.buckets[bucket_name]
+        bucket.clear! if bucket && bucket.exists?
+      end
+
+      delete_stack(env_config.fetch(:stack_name))
     end
 
     def destroy(vm_config)
@@ -124,6 +110,26 @@ module VmShepherd
     private
     attr_reader :env_config
 
+    def subnet_id(stack, elb_config)
+      stack.outputs.detect { |o| o.key == elb_config[:stack_output_keys][:subnet_id] }.value
+    end
+
+    def vpc_id(stack, elb_config)
+      stack.outputs.detect { |o| o.key == elb_config[:stack_output_keys][:vpc_id] }.value
+    end
+
+    def clear_subnet(subnet_id)
+      subnet = AWS.ec2.subnets[subnet_id]
+      volumes = []
+      subnet.instances.each do |instance|
+        instance.attachments.each do |_, attachment|
+          volumes.push(attachment.volume) unless attachment.delete_on_termination
+        end
+        instance.terminate
+      end
+      destroy_volumes(volumes)
+    end
+
     def destroy_volumes(volumes)
       volumes.each do |volume|
         begin
@@ -134,5 +140,75 @@ module VmShepherd
         end
       end
     end
+
+    def delete_elb(elb_name)
+      if (elb = AWS::ELB.new.load_balancers.find { |lb| lb.name == elb_name })
+        sg = elb.security_groups.first
+        net_interfaces = AWS.ec2.network_interfaces.select { |ni| ni.security_groups.map(&:id).include? sg.id }
+        elb.delete
+        retry_until do
+          !elb.exists? && !net_interfaces.map(&:exists?).any?
+        end
+        sg.delete
+      end
+    end
+
+    def create_elb(stack, elb_config)
+      elb = AWS::ELB.new
+      elb_params = {
+        load_balancer_name: elb_config[:name],
+        listeners: [],
+        subnets: [subnet_id(stack, elb_config)],
+        security_groups: [create_security_group(stack, elb_config).security_group_id]
+      }
+
+      elb_config[:port_mappings].each do |port_mapping|
+        elb_params[:listeners] << {
+          protocol: 'TCP', load_balancer_port: port_mapping[0],
+          instance_protocol: 'TCP', instance_port: port_mapping[1]
+        }
+      end
+
+      elb.client.create_load_balancer(elb_params)
+    end
+
+    def create_security_group(stack, elb_config)
+      vpc_id = vpc_id(stack, elb_config)
+      sg_params = {
+        group_name: stack.name,
+        description: 'ELB Security Group',
+        vpc_id: vpc_id,
+      }
+
+      security_group_response = AWS.ec2.client.create_security_group(sg_params)
+
+      AWS.ec2.security_groups[security_group_response[:group_id]].tap do |security_group|
+        elb_config[:port_mappings].each do |port_mapping|
+          security_group.authorize_ingress(:tcp, port_mapping[0], '0.0.0.0/0')
+        end
+      end
+    end
+
+    def delete_stack(stack_name)
+      cfm = AWS::CloudFormation.new
+      stack = cfm.stacks[stack_name]
+      stack.delete
+      retry_until(retry_limit: 360) do
+        begin
+          status = stack.status
+          case status
+            when 'DELETE_COMPLETE'
+              true
+            when 'DELETE_IN_PROGRESS'
+              false
+            else
+              raise "Unexpected status for stack #{stack_name} : #{status}"
+          end
+        rescue AWS::CloudFormation::Errors::ValidationError
+          raise if stack.exists?
+          true
+        end
+      end if stack
+    end
   end
 end

data/lib/vm_shepherd/shepherd.rb

@@ -202,7 +202,12 @@ module VmShepherd
           aws_secret_key: settings.vm_shepherd.env_config.aws_secret_key,
           json_file: settings.vm_shepherd.env_config.json_file,
           parameters: settings.vm_shepherd.env_config.parameters_as_a_hash,
-          outputs: settings.vm_shepherd.env_config.outputs.to_h
+          outputs: settings.vm_shepherd.env_config.outputs.to_h,
+          elb: {
+            name: settings.vm_shepherd.env_config.elb.name,
+            port_mappings: settings.vm_shepherd.env_config.elb.port_mappings,
+            stack_output_keys: settings.vm_shepherd.env_config.elb.stack_output_keys.to_h,
+          },
         }
       )
     end

data/lib/vm_shepherd/version.rb

@@ -1,3 +1,3 @@
 module VmShepherd
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.3.0'.freeze
 end

data/spec/fixtures/shepherd/aws.yml

@@ -13,6 +13,13 @@ vm_shepherd:
       security_group: security-group-id
       public_subnet_id: public-subnet-id
       private_subnet_id: private-subnet-id
+      s3_bucket_name: bucket-name
+    elb:
+      name: some-elb-name
+      port_mappings: [[1111,11]]
+      stack_output_keys:
+        vpc_id: CloudFormationVpcIdOutputKey
+        subnet_id: CloudFormationSubnetIdOutputKey
   vm_configs:
   - vm_name: vm-name
   - vm_name: vm-name-2

data/spec/vm_shepherd/aws_manager_spec.rb

@@ -23,10 +23,13 @@ module VmShepherd
           security_group: 'security-group-id',
           public_subnet_id: 'public-subnet-id',
           private_subnet_id: 'private-subnet-id',
-        },
-      }
+        }.merge(extra_outputs),
+      }.merge(extra_configs)
     end
 
+    let(:extra_outputs) { {} }
+    let(:extra_configs) { {} }
+
     let(:vm_config) do
       {
         vm_name: 'some-vm-name',
@@ -51,43 +54,121 @@ module VmShepherd
       let(:cfm) { instance_double(AWS::CloudFormation, stacks: stack_collection) }
       let(:stack) { instance_double(AWS::CloudFormation::Stack, status: 'CREATE_COMPLETE') }
       let(:stack_collection) { instance_double(AWS::CloudFormation::StackCollection) }
+      let(:elb) { instance_double(AWS::ELB, client: elb_client) }
+      let(:elb_client) { double(AWS::ELB::Client) }
 
       before do
         allow(AWS::CloudFormation).to receive(:new).and_return(cfm)
+        allow(AWS::ELB).to receive(:new).and_return(elb)
         allow(stack_collection).to receive(:create).and_return(stack)
       end
 
-      it 'creates the stack with the correct parameters' do
-        expect(stack_collection).to receive(:create).with(
-            'aws-stack-name',
-            '{}',
-            parameters: {
-              'some_parameter' => 'some-answer',
+      describe 'cloudformation' do
+        it 'creates the stack with the correct parameters' do
+          expect(stack_collection).to receive(:create).with(
+              'aws-stack-name',
+              '{}',
+              parameters: {
+                'some_parameter' => 'some-answer',
+              },
+              capabilities: ['CAPABILITY_IAM']
+            )
+          ami_manager.prepare_environment(cloudformation_template_file.path)
+        end
+
+        it 'waits for the stack to finish creating' do
+          expect(stack).to receive(:status).and_return('CREATE_IN_PROGRESS', 'CREATE_IN_PROGRESS', 'CREATE_IN_PROGRESS', 'CREATE_COMPLETE')
+
+          ami_manager.prepare_environment(cloudformation_template_file.path)
+        end
+
+        it 'stops retrying after 360 times' do
+          expect(stack).to receive(:status).and_return('CREATE_IN_PROGRESS').
+              exactly(360).times
+
+          expect { ami_manager.prepare_environment(cloudformation_template_file.path) }.to raise_error(AwsManager::RetryLimitExceeded)
+        end
+
+        it 'aborts if stack fails to create' do
+          expect(stack).to receive(:status).and_return('CREATE_IN_PROGRESS', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_COMPLETE').ordered
+          expect(stack).to receive(:delete)
+          expect {
+            ami_manager.prepare_environment(cloudformation_template_file.path)
+          }.to raise_error('Unexpected status for stack aws-stack-name : ROLLBACK_COMPLETE')
+        end
+      end
+
+      context 'when the elb setting is present' do
+        let(:extra_configs) do
+          {
+            elb: {
+              name: 'elb-name',
+              port_mappings: [[1111, 11]],
+              stack_output_keys: {
+                vpc_id: 'vpc_id',
+                subnet_id: 'private_subnet',
+              },
             },
-            capabilities: ['CAPABILITY_IAM']
+          }
+        end
+        let(:stack) do
+          instance_double(AWS::CloudFormation::Stack,
+            name: 'fake-stack-name',
+            creation_time: Time.utc(2015, 5, 29),
+            status: 'CREATE_COMPLETE',
+            outputs: stack_outputs
           )
-        ami_manager.prepare_environment(cloudformation_template_file.path)
-      end
+        end
+        let(:stack_outputs) do
+          [
+            instance_double(AWS::CloudFormation::StackOutput, key: 'private_subnet', value: 'fake-subnet-id'),
+            instance_double(AWS::CloudFormation::StackOutput, key: 'vpc_id', value: 'fake-vpc-id'),
+          ]
+        end
+        let(:ec2_client) { double(AWS::EC2::Client) }
+        let(:create_security_group_response) do
+          {:group_id => 'elb-security-group'}
+        end
+        let(:security_groups) do
+          {
+            'elb-security-group' => elb_security_group,
+          }
+        end
+        let(:elb_security_group) { instance_double(AWS::EC2::SecurityGroup, security_group_id: 'elb-security-group-id') }
 
-      it 'waits for the stack to finish creating' do
-        expect(stack).to receive(:status).and_return('CREATE_IN_PROGRESS', 'CREATE_IN_PROGRESS', 'CREATE_IN_PROGRESS', 'CREATE_COMPLETE')
+        before do
+          allow(ec2).to receive(:client).and_return(ec2_client)
+          allow(ec2_client).to receive(:create_security_group).and_return(create_security_group_response)
+          allow(ec2).to receive(:security_groups).and_return(security_groups)
+          allow(elb_security_group).to receive(:authorize_ingress)
+          allow(elb_client).to receive(:create_load_balancer)
+        end
 
-        ami_manager.prepare_environment(cloudformation_template_file.path)
-      end
+        it 'creates and attaches a security group' do
+          security_group_args = {
+            group_name: 'fake-stack-name',
+            description: 'ELB Security Group',
+            vpc_id: 'fake-vpc-id',
+          }
+          expect(ec2_client).to receive(:create_security_group).with(security_group_args).and_return(create_security_group_response)
+          expect(elb_security_group).to receive(:authorize_ingress).with(:tcp, 1111, '0.0.0.0/0')
 
-      it 'stops retrying after 360 times' do
-        expect(stack).to receive(:status).and_return('CREATE_IN_PROGRESS').
-            exactly(360).times
+          ami_manager.prepare_environment(cloudformation_template_file.path)
+        end
 
-        expect { ami_manager.prepare_environment(cloudformation_template_file.path) }.to raise_error(AwsManager::RetryLimitExceeded)
-      end
+        it 'attaches an elb with the name of the stack' do
+          elb_params = {
+            load_balancer_name: 'elb-name',
+            listeners: [
+              {protocol: 'TCP', load_balancer_port: 1111, instance_protocol: 'TCP', instance_port: 11},
+            ],
+            subnets: ['fake-subnet-id'],
+            security_groups: ['elb-security-group-id']
+          }
+          expect(elb_client).to receive(:create_load_balancer).with(elb_params)
 
-      it 'aborts if stack fails to create' do
-        expect(stack).to receive(:status).and_return('CREATE_IN_PROGRESS', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_IN_PROGRESS', 'ROLLBACK_COMPLETE').ordered
-        expect(stack).to receive(:delete)
-        expect {
           ami_manager.prepare_environment(cloudformation_template_file.path)
-        }.to raise_error('Unexpected status for stack aws-stack-name : ROLLBACK_COMPLETE')
+        end
       end
     end
 
@@ -183,6 +264,9 @@ module VmShepherd
         instance_double(AWS::EC2::Attachment, volume: instance1_volume, delete_on_termination: true)
       end
 
+      let(:buckets) { instance_double(AWS::S3::BucketCollection) }
+      let(:s3_client) { instance_double(AWS::S3, buckets: buckets) }
+
       before do
         allow(AWS::CloudFormation).to receive(:new).and_return(cfm)
         allow(stack_collection).to receive(:[]).and_return(stack)
@@ -196,6 +280,9 @@ module VmShepherd
 
         allow(instance1).to receive(:terminate)
         allow(instance2).to receive(:terminate)
+
+        allow(AWS::S3).to receive(:new).and_return(s3_client)
+        allow(buckets).to receive(:[]).and_return(instance_double(AWS::S3::Bucket, exists?: false))
       end
 
       it 'terminates all VMs in the subnet' do
@@ -247,6 +334,118 @@ module VmShepherd
         }.not_to raise_error
       end
 
+      it 'when an elb is not configured' do
+        expect(AWS::ELB).not_to receive(:new)
+        ami_manager.clean_environment
+      end
+
+      it 'when there is no s3 bucket configuration' do
+        expect_any_instance_of(AWS::S3::Bucket).not_to receive(:clear!)
+        ami_manager.clean_environment
+      end
+
+      it 'does not look up buckets when there is no name' do
+        expect(buckets).to_not receive(:[])
+        ami_manager.clean_environment
+      end
+
+      context 'when a subnet is not provided' do
+        #the sdk never returns nil when looking up a subnet and its instances
+        let(:subnet2) { instance_double(AWS::EC2::Subnet, instances: []) }
+
+        it 'only deletes instance 1' do
+          expect(instance1).to receive(:terminate)
+          expect(instance2).not_to receive(:terminate)
+
+          ami_manager.clean_environment
+        end
+      end
+
+      context 'when an elb is configured' do
+        let(:extra_configs) do
+          {
+            elb: {
+              name: 'elb-name',
+              stack_output_keys: {
+                subnet_id: 'private_subnet',
+              },
+            },
+          }
+        end
+
+        let(:elb) { instance_double(AWS::ELB, load_balancers: [load_balancer_to_delete, other_load_balancer]) }
+        let(:load_balancer_to_delete) do
+          instance_double(AWS::ELB::LoadBalancer,
+            name: 'elb-name',
+            security_groups: [elb_security_group],
+            exists?: false,
+          )
+        end
+        let(:other_load_balancer) { instance_double(AWS::ELB::LoadBalancer, name: 'other-elb-name') }
+        let(:elb_security_group) { instance_double(AWS::EC2::SecurityGroup, name: 'elb-security-group', id: 'sg-id') }
+        let(:network_interface_1) do
+          instance_double(AWS::EC2::NetworkInterface,
+            security_groups: [elb_security_group],
+            exists?: false,
+          )
+        end
+        let(:network_interface_2) do
+          instance_double(AWS::EC2::NetworkInterface,
+            security_groups: [elb_security_group],
+            exists?: false,
+          )
+        end
+
+        before do
+          allow(AWS::ELB).to receive(:new).and_return(elb)
+          allow(ec2).to receive(:network_interfaces).and_return([network_interface_1, network_interface_2])
+          allow(load_balancer_to_delete).to receive(:delete)
+          allow(elb_security_group).to receive(:delete)
+        end
+
+        it 'waits for the elb to be deleted' do
+          expect(load_balancer_to_delete).to receive(:exists?).and_return(true).
+              exactly(60).times
+
+          expect(elb_security_group).not_to receive(:delete).ordered
+          expect { ami_manager.clean_environment }.to raise_error(AwsManager::RetryLimitExceeded)
+        end
+
+        it 'waits for the network interfaces to be deleted' do
+          allow(load_balancer_to_delete).to receive(:exists?).and_return(false)
+
+          expect(network_interface_1).to receive(:exists?).and_return(false).
+              exactly(60).times
+
+          expect(network_interface_2).to receive(:exists?).and_return(true).
+              exactly(60).times
+
+          expect(elb_security_group).not_to receive(:delete).ordered
+          expect { ami_manager.clean_environment }.to raise_error(AwsManager::RetryLimitExceeded)
+        end
+
+        it 'terminates the ELB then removes the security group' do
+          expect(load_balancer_to_delete).to receive(:delete).ordered
+          expect(elb_security_group).to receive(:delete).ordered
+
+          ami_manager.clean_environment
+        end
+
+        it 'leaves unknown ELBs alone' do
+          expect(other_load_balancer).not_to receive(:delete)
+
+          ami_manager.clean_environment
+        end
+
+        context 'when the ELB does not exist' do
+          let(:elb) { instance_double(AWS::ELB, load_balancers: []) }
+
+          it 'does not throw an error' do
+            expect { ami_manager.clean_environment }.not_to raise_error
+          end
+        end
+      end
+
       context 'when the instance has volumes that are NOT delete_on_termination' do
         let(:instance1_attachment) do
           instance_double(AWS::EC2::Attachment, volume: instance1_volume, delete_on_termination: false)
@@ -267,7 +466,6 @@ module VmShepherd
           before do
             expect(instance1_volume).to receive(:delete).and_raise(AWS::EC2::Errors::VolumeInUse)
             expect(instance1_volume).to receive(:delete).and_return(nil)
-            allow(ami_manager).to receive(:sleep)
           end
 
           it 'retries the delete' do
@@ -275,6 +473,32 @@ module VmShepherd
           end
         end
       end
+
+      context 'when there is an s3 bucket configuration' do
+        let(:bucket) { instance_double(AWS::S3::Bucket) }
+        let(:extra_outputs) { {s3_bucket_name: bucket_name} }
+        let(:bucket_name) { 'bucket-name' }
+
+        before { allow(buckets).to receive(:[]).with(bucket_name).and_return(bucket) }
+
+        context 'and the bucket does exist' do
+          before { allow(bucket).to receive(:exists?).and_return(true) }
+
+          it 'clears the bucket' do
+            expect(bucket).to receive(:clear!)
+            ami_manager.clean_environment
+          end
+        end
+
+        context 'and the bucket does not exist' do
+          before { allow(bucket).to receive(:exists?).and_return(false) }
+
+          it 'fails silently' do
+            expect(bucket).not_to receive(:clear!)
+            ami_manager.clean_environment
+          end
+        end
+      end
     end
 
     describe '#destroy' do

data/spec/vm_shepherd/shepherd_spec.rb

@@ -9,7 +9,7 @@ module VmShepherd
     let(:settings) do
       RecursiveOpenStruct.new(YAML.load_file(File.join(SPEC_ROOT, 'fixtures', 'shepherd', settings_fixture_name)), recurse_over_arrays: true)
     end
-    let(:env_config) do
+    let(:aws_env_config) do
       {
         stack_name: 'aws-stack-name',
         aws_access_key: 'aws-access-key',
@@ -22,8 +22,17 @@ module VmShepherd
           ssh_key_name: 'ssh-key-name',
           security_group: 'security-group-id',
           public_subnet_id: 'public-subnet-id',
-          private_subnet_id: 'private-subnet-id'
-        }
+          private_subnet_id: 'private-subnet-id',
+          s3_bucket_name: 'bucket-name',
+        },
+        elb: {
+          name: 'some-elb-name',
+          port_mappings: [[1111, 11]],
+          stack_output_keys: {
+            vpc_id: 'CloudFormationVpcIdOutputKey',
+            subnet_id: 'CloudFormationSubnetIdOutputKey',
+          },
+        },
       }
     end
 
@@ -168,7 +177,7 @@ module VmShepherd
         let(:last_aws_options) { {vm_name: 'vm-name-2'} }
 
         it 'uses AwsManager to launch a VM' do
-          expect(AwsManager).to receive(:new).with(env_config).and_return(aws_manager)
+          expect(AwsManager).to receive(:new).with(aws_env_config).and_return(aws_manager)
           expect(aws_manager).to receive(:deploy).with(ami_file_path: first_ami_file_path, vm_config: first_aws_options)
           expect(aws_manager).to receive(:deploy).with(ami_file_path: last_ami_file_path, vm_config: last_aws_options)
 
@@ -333,7 +342,7 @@ module VmShepherd
         let(:last_ami_options) { {vm_name: 'vm-name-2'} }
 
         it 'uses AwsManager to destroy a VM' do
-          expect(AwsManager).to receive(:new).with(env_config).and_return(aws_manager)
+          expect(AwsManager).to receive(:new).with(aws_env_config).and_return(aws_manager)
           expect(aws_manager).to receive(:destroy).with(first_ami_options)
           expect(aws_manager).to receive(:destroy).with(last_ami_options)
 
@@ -500,7 +509,7 @@ module VmShepherd
         let(:aws_manager) { instance_double(AwsManager) }
 
         it 'uses AwsManager to destroy a VM' do
-          expect(AwsManager).to receive(:new).with(env_config).and_return(aws_manager)
+          expect(AwsManager).to receive(:new).with(aws_env_config).and_return(aws_manager)
           expect(aws_manager).to receive(:clean_environment)
           manager.clean_environment
         end
@@ -552,7 +561,7 @@ module VmShepherd
         let(:ams_manager) { instance_double(AwsManager) }
 
         it 'uses AwsManager to create an environment' do
-          expect(AwsManager).to receive(:new).with(env_config).and_return(ams_manager)
+          expect(AwsManager).to receive(:new).with(aws_env_config).and_return(ams_manager)
           expect(ams_manager).to receive(:prepare_environment).with('cloudformation.json')
           manager.prepare_environment
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vm_shepherd
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Ops Manager Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-28 00:00:00.000000000 Z
+date: 2015-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-v1