aerosol 0.5.1 → 1.0.1

data/spec/aerosol/connection_spec.rb

@@ -40,14 +40,20 @@ describe Aerosol::Connection do
 
       context 'when the host is an instance' do
         let(:public_hostname) { nil }
+        let(:host) { Aerosol::Instance.new }
         subject do
           Aerosol::Connection.new.tap do |inst|
             inst.name :connection_for_tim_horton
             inst.user 'tim_horton'
-            inst.host double(:host, :public_hostname => public_hostname, :private_ip_address => '152.60.94.125')
+            inst.host host
           end
         end
 
+        before do
+          allow(host).to receive(:public_hostname).and_return(public_hostname)
+          allow(host).to receive(:private_ip_address).and_return('152.60.94.125')
+        end
+
         context 'when the public_hostname is present' do
           let(:public_hostname) { 'example.com' }
           it 'returns the public_hostname' do
@@ -66,7 +72,7 @@ describe Aerosol::Connection do
 
       context 'when the host is passed into with_connection' do
         let(:public_hostname) { nil }
-        let(:host) { double(:host, :public_hostname => public_hostname, :private_ip_address => '152.60.94.125') }
+        let(:host) { Aerosol::Instance.new }
         subject do
           Aerosol::Connection.new.tap do |inst|
             inst.name :connection_for_tim_horton
@@ -74,6 +80,11 @@ describe Aerosol::Connection do
           end
         end
 
+        before do
+          allow(host).to receive(:public_hostname).and_return(public_hostname)
+          allow(host).to receive(:private_ip_address).and_return('152.60.94.125')
+        end
+
         context 'when the public_hostname is present' do
           let(:public_hostname) { 'example.com' }
           it 'returns the public_hostname' do
@@ -82,6 +93,14 @@ describe Aerosol::Connection do
           end
         end
 
+        context 'when the public_hostname is an empty string' do
+          let(:public_hostname) { '' }
+          it 'returns the private_ip_address' do
+            Net::SSH.should_receive(:start).with('152.60.94.125', 'tim_horton')
+            subject.with_connection(host)
+          end
+        end
+
         context 'when the public_hostname is nil' do
           it 'returns the private_ip_address' do
             Net::SSH.should_receive(:start).with('152.60.94.125', 'tim_horton')

data/spec/aerosol/deploy_spec.rb

@@ -79,12 +79,12 @@ describe Aerosol::Deploy do
 
   describe '#generate_ssh_command' do
     let(:ssh_ref) { double(:ssh_ref) }
-    let(:instance) { double(:instance) }
+    let(:instance) { Aerosol::Instance.new }
     let(:ssh_command) { subject.generate_ssh_command(instance) }
 
     before do
-      instance.stub(:public_hostname).and_return('hostname.com')
-      subject.stub(:local_ssh_ref).and_return(ssh_ref)
+      allow(instance).to receive(:public_hostname).and_return('hostname.com')
+      allow(subject).to receive(:local_ssh_ref).and_return(ssh_ref)
     end
 
     context 'with a user' do

data/spec/aerosol/instance_spec.rb

@@ -1,24 +1,12 @@
 require 'spec_helper'
 
 describe Aerosol::Instance do
-  let!(:launch_config) do
-    Aerosol::LaunchConfiguration.new! do
-      name :launch_config_for_instances
-      ami 'ami-123-abc'
-      instance_type 'm1.large'
-      stub :sleep
-    end
-  end
-
-  let!(:auto_scaling) do
-    Aerosol::AutoScaling.new! do
-      name :as_group_for_instances
-      availability_zones 'us-east-2'
-      launch_configuration :launch_config_for_instances
-      min_size 10
-      max_size 10
-      stub :sleep
-    end
+  let(:launch_configuration) do
+    Aerosol::LaunchConfiguration.new!({
+      name: 'launch_config_for_instances',
+      image_id: 'ami-123-abc',
+      instance_type: 'm1.large'
+    })
   end
 
   describe '.all' do
@@ -29,29 +17,62 @@ describe Aerosol::Instance do
     end
 
     context 'when there are instances' do
-      before { launch_config.create; auto_scaling.create }
-      after { launch_config.destroy; auto_scaling.destroy }
-
       it 'materializes each of them into an object' do
+        Aerosol::AWS.auto_scaling.stub_responses(:describe_auto_scaling_instances, {
+          auto_scaling_instances: 10.times.map do |i|
+            {
+              instance_id: "i-#{1239013 + i}",
+              availability_zone: 'us-east-2',
+              lifecycle_state: 'InService',
+              health_status: 'GOOD',
+              launch_configuration_name: launch_configuration.launch_configuration_name.to_s,
+              auto_scaling_group_name: "test-#{i}"
+            }
+          end
+        })
         subject.length.should == 10
-        subject.should be_all { |inst| inst.launch_configuration == launch_config }
+        subject.should be_all { |inst| inst.launch_configuration == launch_configuration }
         subject.should be_all { |inst| inst.availability_zone == 'us-east-2' }
       end
     end
   end
 
   describe '.description' do
-    before { auto_scaling.create }
-    after { auto_scaling.destroy }
-
     subject { described_class.all.first }
 
     it 'returns additional information about the instance' do
-      subject.description['imageId'].should == launch_config.ami
-      subject.description['instanceType'].should == launch_config.instance_type
-    end
+      Aerosol::AWS.auto_scaling.stub_responses(:describe_auto_scaling_instances, {
+        auto_scaling_instances: [
+          {
+            instance_id: 'i-1239013',
+            availability_zone: 'us-east-2',
+            lifecycle_state: 'InService',
+            health_status: 'GOOD',
+            launch_configuration_name: launch_configuration.launch_configuration_name.to_s,
+            auto_scaling_group_name: 'test'
+          }
+        ]
+      })
+      Aerosol::AWS.compute.stub_responses(:describe_instances, {
+        reservations: [{
+          instances: [{
+            instance_id: 'i-1239013',
+            image_id: launch_configuration.image_id,
+            instance_type: launch_configuration.instance_type,
+            public_dns_name: 'ec2-dns.aws.amazon.com',
+            private_ip_address: '10.0.0.1',
+            state: {
+              code: 99,
+              name: 'running'
+            }
+          }]
+        }]
+      })
 
-    its(:public_hostname) { should_not be_nil }
-    its(:private_ip_address) { should_not be_nil }
+      expect(subject.image_id).to eq(launch_configuration.image_id)
+      expect(subject.description[:instance_type]).to eq(launch_configuration.instance_type)
+      expect(subject.public_hostname).to_not be_nil
+      expect(subject.private_ip_address).to_not be_nil
+    end
   end
 end

data/spec/aerosol/launch_configuration_spec.rb

@@ -4,7 +4,7 @@ describe Aerosol::LaunchConfiguration do
   subject do
     described_class.new do
       name :my_launch_config
-      ami 'ami-123'
+      image_id 'ami-123'
       instance_type 'super-cool-instance-type'
       user_data <<-END_OF_STRING
         #!/bin/bash
@@ -14,11 +14,11 @@ describe Aerosol::LaunchConfiguration do
   end
   before { subject.stub(:sleep) }
 
-  describe "#aws_identifier" do
+  describe "#launch_configuration_name" do
     context "with no namespace set" do
       let(:identifier) { "my_launch_config-#{Aerosol::Util.git_sha}" }
       it "returns a normal identifier" do
-        expect(subject.aws_identifier).to eq(identifier)
+        expect(subject.launch_configuration_name).to eq(identifier)
       end
     end
 
@@ -30,7 +30,7 @@ describe Aerosol::LaunchConfiguration do
       after { Aerosol.instance_variable_set(:"@namespace", nil) }
 
       it "returns a namespaced identifier" do
-        expect(subject.aws_identifier).to eq(identifier)
+        expect(subject.launch_configuration_name).to eq(identifier)
       end
     end
   end
@@ -52,7 +52,7 @@ describe Aerosol::LaunchConfiguration do
 
   describe '#create!' do
     context 'when some required fields are nil' do
-      before { subject.instance_variable_set(:@ami, nil) }
+      before { subject.instance_variable_set(:@image_id, nil) }
 
       it 'raises an error' do
         expect { subject.create! }.to raise_error
@@ -61,10 +61,11 @@ describe Aerosol::LaunchConfiguration do
 
     context 'when everything is present' do
       context 'and the launch configuration already exists' do
-        before { subject.create! rescue nil }
-        after { subject.destroy! rescue nil }
-
         it 'raises an error' do
+          Aerosol::AWS.auto_scaling.stub_responses(
+            :create_launch_configuration,
+            Aws::AutoScaling::Errors::AlreadyExists
+          )
           expect { subject.create! }.to raise_error
         end
       end
@@ -73,41 +74,37 @@ describe Aerosol::LaunchConfiguration do
         after { subject.destroy! rescue nil }
 
         it 'creates the launch configuration group' do
+          Aerosol::AWS.auto_scaling.stub_responses(:create_launch_configuration, [])
           expect { subject.create! }.to_not raise_error
         end
-
-        it 'fixes the user data spacing' do
-          subject.send(:conn).should_receive(:create_launch_configuration)
-                             .with('ami-123', 'super-cool-instance-type',
-                                   subject.aws_identifier,
-                                   'SecurityGroups' => [],
-                                   'UserData' => "#!/bin/bash\nrm -rf /\n")
-          subject.create!
-        end
       end
     end
   end
 
   describe '#destroy!' do
-    context 'when the aws_identifier is nil' do
-      before { subject.instance_variable_set(:@aws_identifier, nil) }
+    context 'when the launch_configuration_name is nil' do
 
       it 'raises an error' do
+        allow(subject).to receive(:launch_configuration_name).and_return(nil)
+        Aerosol::AWS.auto_scaling.stub_responses(:delete_launch_configuration, [])
         expect { subject.destroy! }.to raise_error
       end
     end
 
-    context 'when the aws_identifier is present' do
+    context 'when the launch_configuration_name is present' do
       context 'but the launch configuration does not exist' do
         it 'raises an error' do
+          Aerosol::AWS.auto_scaling.stub_responses(
+            :delete_launch_configuration,
+            Aws::AutoScaling::Errors::ValidationError
+          )
           expect { subject.destroy! }.to raise_error
         end
       end
 
       context 'and the launch configuration exists' do
-        before { subject.create! }
-
         it 'deletes the launch configuration' do
+          Aerosol::AWS.auto_scaling.stub_responses(:delete_launch_configuration, [])
           expect { subject.destroy! }.to_not raise_error
         end
       end
@@ -115,36 +112,56 @@ describe Aerosol::LaunchConfiguration do
   end
 
   describe '#create' do
-    context 'when the aws_identifier is nil' do
-      subject { described_class.new!(:name => :random_test_name) }
+    context 'when the launch_configuration_name is nil' do
+      subject do
+        described_class.new! do
+          name :random_test_name
+          image_id 'test-ami-who-even-cares-really'
+          instance_type 'm1.large'
+        end
+      end
 
       it 'raises an error' do
+        allow(subject).to receive(:launch_configuration_name).and_return(nil)
+        Aerosol::AWS.auto_scaling.stub_responses(:create_launch_configuration, [])
+        Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+          launch_configurations: [], next_token: nil
+        })
         expect { subject.create }.to raise_error
       end
     end
 
-    context 'when the aws_identifier is present' do
+    context 'when the launch_configuration_name is present' do
       subject do
         described_class.new! do
           name :random_test_name_2
-          ami 'test-ami-who-even-cares-really'
+          image_id 'test-ami-who-even-cares-really'
           instance_type 'm1.large'
         end
       end
 
       context 'but the launch configuration already exists' do
-        before { subject.create! }
-
         it 'does not call #create!' do
-          subject.should_not_receive(:create!)
+          Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+            launch_configurations: [{
+              launch_configuration_name: subject.launch_configuration_name,
+              image_id: 'ami-1235535',
+              instance_type: 'm3.large',
+              created_time: Time.at(1)
+            }],
+            next_token: nil
+          })
+          expect(subject).to_not receive(:create!)
           subject.create
         end
       end
 
       context 'and the launch configuration does not yet exist' do
-        before { subject.destroy }
-
         it 'creates it' do
+          Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+            launch_configurations: [],
+            next_token: nil
+          })
           subject.should_receive(:create!)
           subject.create
         end
@@ -153,36 +170,49 @@ describe Aerosol::LaunchConfiguration do
   end
 
   describe '#destroy' do
-    context 'when the aws_identifier is nil' do
-      subject { described_class.new!(:name => :random_test_name_3) }
-
-      it 'raises an error' do
-        expect { subject.create }.to raise_error
+    subject do
+      described_class.new! do
+        name :random_test_name_3
+        image_id 'awesome-ami'
+        instance_type 'm1.large'
       end
     end
 
-    context 'when the aws_identifier is present' do
-      subject do
-        described_class.new! do
-          name :random_test_name_4
-          ami 'awesome-ami'
-          instance_type 'm1.large'
-        end
+    context 'when the launch_configuration_name is nil' do
+      it 'raises an error' do
+        allow(subject).to receive(:launch_configuration_name).and_return(nil)
+        Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+          launch_configurations: [],
+          next_token: nil
+        })
+        expect { subject.create }.to raise_error(ArgumentError)
       end
+    end
 
+    context 'when the launch_configuration_name is present' do
       context 'and the launch configuration already exists' do
-        before { subject.create! }
 
         it 'calls #destroy!' do
+          Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+            launch_configurations: [{
+              launch_configuration_name: subject.launch_configuration_name,
+              image_id: 'ami-1235535',
+              instance_type: 'm3.large',
+              created_time: Time.at(1)
+            }],
+            next_token: nil
+          })
           subject.should_receive(:destroy!)
           subject.destroy
         end
       end
 
       context 'but the launch configuration does not yet exist' do
-        before { subject.destroy! rescue nil }
-
         it 'does not call #destroy!' do
+          Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+            launch_configurations: [],
+            next_token: nil
+          })
           subject.should_not_receive(:destroy!)
           subject.destroy
         end
@@ -192,19 +222,27 @@ describe Aerosol::LaunchConfiguration do
 
   describe '.exists?' do
     subject { described_class }
-
-    context 'when the argument exists' do
-      let(:instance) do
-        subject.new! do
-          name :exists_test_name
-          ami 'ami123'
-          instance_type 'm1.large'
-          stub(:sleep)
-        end.tap(&:create!)
+    let(:instance) do
+      subject.new! do
+        name :exists_test_name
+        image_id 'ami123'
+        instance_type 'm1.large'
+        stub(:sleep)
       end
+    end
 
+    context 'when the argument exists' do
       it 'returns true' do
-        subject.exists?(instance.aws_identifier).should be_true
+        Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+          launch_configurations: [{
+            launch_configuration_name: instance.launch_configuration_name,
+            image_id: 'ami-1235535',
+            instance_type: 'm3.large',
+            created_time: Time.at(1)
+          }],
+          next_token: nil
+        })
+        subject.exists?(instance.launch_configuration_name).should be_true
       end
     end
 
@@ -212,25 +250,53 @@ describe Aerosol::LaunchConfiguration do
       let(:instance) { described_class.new!   }
 
       it 'returns false' do
-        subject.exists?(instance.aws_identifier).should be_false
+        Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+          launch_configurations: [],
+          next_token: nil
+        })
+        subject.exists?(instance.launch_configuration_name).should be_false
       end
     end
   end
 
   describe '.request_all' do
     describe 'repeats until no NextToken' do
-      before do
-        allow(Aerosol::LaunchConfiguration).to receive(:request_all_for_token).with(nil) do
-          { 'LaunchConfigurations' => [1, 4], 'NextToken' => 'token' }
-        end
-
-        allow(Aerosol::LaunchConfiguration).to receive(:request_all_for_token).with('token') do
-          { 'LaunchConfigurations' => [2, 3], 'NextToken' => nil }
-        end
-      end
-
       it 'should include both autoscaling groups lists' do
-        expect(Aerosol::LaunchConfiguration.request_all).to eq([1,4,2,3])
+        Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, [
+          {
+            launch_configurations: [
+              {
+                launch_configuration_name: '1',
+                image_id: 'ami-1235535',
+                instance_type: 'm3.large',
+                created_time: Time.at(1)
+              }, {
+                launch_configuration_name: '4',
+                image_id: 'ami-1235535',
+                instance_type: 'm3.large',
+                created_time: Time.at(1)
+              }
+            ],
+            next_token: 'yes'
+          },
+          {
+            launch_configurations: [
+              {
+                launch_configuration_name: '2',
+                image_id: 'ami-1235535',
+                instance_type: 'm3.large',
+                created_time: Time.at(1)
+              }, {
+                launch_configuration_name: '3',
+                image_id: 'ami-1235535',
+                instance_type: 'm3.large',
+                created_time: Time.at(1)
+              }
+            ],
+            next_token: nil
+          }
+        ])
+        expect(Aerosol::LaunchConfiguration.request_all.map(&:launch_configuration_name)).to eq(['1','4','2','3'])
       end
     end
   end
@@ -238,37 +304,39 @@ describe Aerosol::LaunchConfiguration do
   describe '.all' do
     subject { described_class }
 
-    def destroy_all
-      Aerosol::LaunchConfiguration.instances.values.each do |instance|
-        instance.destroy! rescue nil
-      end
-    end
-
-    after { destroy_all }
-
     context 'when there are no launch configurations' do
-      before { destroy_all }
-
+      before do
+        Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, [
+          { launch_configurations: [], next_token: nil }
+        ])
+      end
       its(:all) { should be_empty }
     end
 
     context 'when there are launch configurations' do
-
-      before do
+      let(:insts) {
         [
           {
-            :ami => 'ami1',
-            :instance_type => 'm1.large'
+            launch_configuration_name: 'test',
+            image_id: 'ami1',
+            instance_type: 'm1.large',
+            created_time: Time.at(1)
           },
           {
-            :ami => 'ami2',
-            :instance_type => 'm1.large'
+            launch_configuration_name: 'test2',
+            image_id: 'ami2',
+            instance_type: 'm1.large',
+            created_time: Time.at(1)
           }
-        ].each { |hash| subject.new!(hash).tap { |inst| inst.stub(:sleep) }.create! }
-      end
+        ]
+      }
 
       it 'returns each of them' do
-        subject.all.map(&:ami).should == %w[ami1 ami2]
+        Aerosol::AWS.auto_scaling.stub_responses(:describe_launch_configurations, {
+          launch_configurations: insts,
+          next_token: nil
+        })
+        subject.all.map(&:image_id).should == %w[ami1 ami2]
         subject.all.map(&:instance_type).should == %w[m1.large m1.large]
       end
     end
@@ -279,27 +347,28 @@ describe Aerosol::LaunchConfiguration do
       subject { described_class.from_hash(hash) }
       let(:hash) do
         {
-          'LaunchConfigurationName' => '~test-launch-config~',
-          'ImageId' => 'ami-123',
-          'InstanceType' => 'm1.large',
-          'SecurityGroups' => [],
-          'UserData' => 'echo hi',
-          'IamInstanceProfile' => nil,
-          'KernelId' => 'kernel-id',
-          'KeyName' => 'key-name',
-          'SpotPrice' => '0.04',
+          launch_configuration_name: '~test-launch-config~',
+          image_id: 'ami-123',
+          instance_type: 'm1.large',
+          security_groups: [],
+          user_data: 'echo hi',
+          iam_instance_profile: nil,
+          kernel_id: 'kernel-id',
+          key_name: 'key-name',
+          spot_price: '0.04',
         }
       end
 
       it 'creates a new launch configuration with the specified values' do
-        subject.aws_identifier.should == '~test-launch-config~'
-        subject.ami.should == 'ami-123'
+        subject.launch_configuration_name.should == '~test-launch-config~'
+        subject.image_id.should == 'ami-123'
         subject.instance_type.should == 'm1.large'
         subject.security_groups.should be_empty
         subject.user_data.should == 'echo hi'
-        subject.iam_role.should be_nil
+        subject.iam_instance_profile.should be_nil
         subject.kernel_id.should == 'kernel-id'
         subject.spot_price.should == '0.04'
+        subject.from_aws = true
       end
 
       it 'generates a name' do
@@ -310,18 +379,18 @@ describe Aerosol::LaunchConfiguration do
     context 'when the launch configuration has already been initialized' do
       let(:old_hash) do
         {
-          'LaunchConfigurationName' => 'this-aws-id-abc-123',
-          'ImageId' => 'ami-456',
+          launch_configuration_name: 'this-aws-id-abc-123',
+          image_id: 'ami-456',
         }
       end
-      let(:new_hash) { old_hash.merge('InstanceType' => 'm1.large') }
+      let(:new_hash) { old_hash.merge(instance_type: 'm1.large') }
       let!(:existing) { described_class.from_hash(old_hash) }
       let(:new) { described_class.from_hash(new_hash) }
 
-      it 'updates its values' do
+      it 'makes a new instance' do
         expect { new }.to change { described_class.instances.length }.by(1)
-        new.aws_identifier.should == 'this-aws-id-abc-123'
-        new.ami.should == 'ami-456'
+        new.launch_configuration_name.should == 'this-aws-id-abc-123'
+        new.image_id.should == 'ami-456'
       end
     end
   end