aerosol 0.5.1

data/spec/aerosol/deploy_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Aerosol::Deploy do
+  let!(:ssh) { double(:ssh) }
+  subject { described_class.new(:name => :test) }
+
+  before do
+    subject.stub(:ssh).and_return(ssh)
+  end
+
+  describe '#migration' do
+    context 'by default' do
+      its(:migrate?) { should be_true }
+    end
+
+    context 'when do_not_migrate! has been called' do
+      before { subject.do_not_migrate! }
+
+      its(:migrate?) { should be_false }
+    end
+  end
+
+  describe '#run_post_deploy' do
+    context 'with no post_deploy_command' do
+      before do
+        subject.stub(:post_deploy_command)
+      end
+
+      it "doesn't raises an error" do
+        expect { subject.run_post_deploy }.to_not raise_error
+      end
+
+      it "returns nil" do
+        expect(subject.run_post_deploy).to be_nil
+      end
+    end
+
+    context 'with post_deploy_command' do
+      context 'and post_deploy_command runs correctly' do
+        before do
+          subject.stub(:post_deploy_command).and_return('true')
+        end
+
+        it "doesn't raises an error" do
+          expect { subject.run_post_deploy }.to_not raise_error
+        end
+
+        it "returns true" do
+          expect(subject.run_post_deploy).to be_true
+        end
+      end
+
+      context 'and post_deploy_command runs incorrectly' do
+        before do
+          subject.stub(:post_deploy_command).and_return('false')
+        end
+
+        it 'raises an error' do
+          expect { subject.run_post_deploy }.to raise_error
+        end
+      end
+    end
+  end
+
+  describe '#local_ssh_ref' do
+    context 'when there is no local_ssh' do
+      its(:local_ssh_ref) { should eq(ssh) }
+    end
+
+    context 'when there is a local_ssh' do
+      let!(:local_ssh) { double(:local_ssh) }
+      before do
+        subject.stub(:local_ssh).and_return(local_ssh)
+      end
+
+      its(:local_ssh_ref) { should eq(local_ssh) }
+    end
+  end
+
+  describe '#generate_ssh_command' do
+    let(:ssh_ref) { double(:ssh_ref) }
+    let(:instance) { double(:instance) }
+    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)
+    end
+
+    context 'with a user' do
+      before do
+        ssh_ref.stub(:user).and_return('ubuntu')
+      end
+
+      context 'without a jump server' do
+        before do
+          ssh_ref.stub(:jump)
+        end
+
+        it 'responds with no jump server' do
+          expect(ssh_command).to be =~ /ssh .* ubuntu@hostname.com/
+        end
+      end
+
+      context 'with a jump server' do
+        before do
+          ssh_ref.stub(:jump).and_return(:user => 'candle', :host => 'example.org')
+        end
+
+        it 'responds with a jump server' do
+          expect(ssh_command).to be =~ /ssh .* -o 'ProxyCommand=ssh -W %h:%p candle@example\.org' ubuntu@hostname\.com/
+        end
+      end
+    end
+
+    context 'without a user' do
+      before do
+        ssh_ref.stub(:user)
+      end
+
+      context 'without a jump server' do
+        before do
+          ssh_ref.stub(:jump)
+        end
+
+        it 'responds with no user and no jump' do
+          expect(ssh_command).to be =~ /ssh .* hostname.com/
+        end
+      end
+
+      context 'with a jump server' do
+        before do
+          ssh_ref.stub(:jump).and_return(:user => 'candle', :host => 'example.org')
+        end
+
+        it 'responds with no user and a jump server' do
+          expect(ssh_command).to be =~ /ssh .* -o 'ProxyCommand=ssh -W %h:%p candle@example\.org' hostname\.com/
+        end
+      end
+    end
+  end
+
+  describe '#live_check_url' do
+    context 'when SSL is not enabled' do
+      subject {
+        Aerosol::Deploy.new do
+          app_port 5000
+          live_check '/test'
+        end
+      }
+
+      it 'returns an http url' do
+        expect(subject.live_check_url).to eq('http://localhost:5000/test')
+      end
+    end
+
+    context 'when SSL is enabled' do
+      subject {
+        Aerosol::Deploy.new do
+          app_port 4000
+          live_check 'check'
+          ssl true
+        end
+      }
+
+      it 'returns an https url' do
+        expect(subject.live_check_url).to eq('https://localhost:4000/check')
+      end
+    end
+  end
+
+  describe '#is_alive?' do
+    let(:check) { proc { true } }
+
+    context 'when no argument is given' do
+      before { subject.is_alive?(&check) }
+
+      it 'returns the current value of is_alive?' do
+        expect(subject.is_alive?).to eq(check)
+      end
+    end
+
+    context 'when an argument is given' do
+      it 'sets is_alive? to that value' do
+        expect { subject.is_alive?(&check) }
+          .to change { subject.is_alive? }
+          .from(nil)
+          .to(check)
+      end
+    end
+  end
+end

data/spec/aerosol/env_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Aerosol::Env do
+  describe '#deploy' do
+    let(:name) { "unique_name_#{Time.now.to_i}".to_sym }
+    let!(:deploy) { Aerosol.deploy(name) { } }
+
+
+    it 'adds a deploy to the list of deploys' do
+      expect { subject.deploy(name) }
+        .to change { subject.deploy }
+        .from(nil)
+        .to([deploy])
+    end
+  end
+end

data/spec/aerosol/instance_spec.rb

@@ -0,0 +1,57 @@
+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
+  end
+
+  describe '.all' do
+    subject { described_class.all }
+
+    context 'when there are no instances' do
+      it { should be_empty }
+    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
+        subject.length.should == 10
+        subject.should be_all { |inst| inst.launch_configuration == launch_config }
+        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
+
+    its(:public_hostname) { should_not be_nil }
+    its(:private_ip_address) { should_not be_nil }
+  end
+end

data/spec/aerosol/launch_configuration_spec.rb

@@ -0,0 +1,328 @@
+require 'spec_helper'
+
+describe Aerosol::LaunchConfiguration do
+  subject do
+    described_class.new do
+      name :my_launch_config
+      ami 'ami-123'
+      instance_type 'super-cool-instance-type'
+      user_data <<-END_OF_STRING
+        #!/bin/bash
+        rm -rf /
+      END_OF_STRING
+    end
+  end
+  before { subject.stub(:sleep) }
+
+  describe "#aws_identifier" 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)
+      end
+    end
+
+    context "with a namespace set" do
+      let(:namespace) { "test" }
+      let(:identifier) { "#{namespace}-my_launch_config-#{Aerosol::Util.git_sha}" }
+
+      before { Aerosol.namespace namespace }
+      after { Aerosol.instance_variable_set(:"@namespace", nil) }
+
+      it "returns a namespaced identifier" do
+        expect(subject.aws_identifier).to eq(identifier)
+      end
+    end
+  end
+
+  describe '#security_group' do
+    subject { described_class.new!(:name => 'conf-conf-conf') }
+
+    it 'adds the argument to the list of security groups' do
+      expect { subject.security_group 'my group' }
+          .to change { subject.security_groups.length }
+          .by 1
+    end
+
+    it 'does not the default security group' do
+      expect { subject.security_group 'other test' }
+          .to_not change { described_class.default_values[:security_groups] }
+    end
+  end
+
+  describe '#create!' do
+    context 'when some required fields are nil' do
+      before { subject.instance_variable_set(:@ami, nil) }
+
+      it 'raises an error' do
+        expect { subject.create! }.to raise_error
+      end
+    end
+
+    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
+          expect { subject.create! }.to raise_error
+        end
+      end
+
+      context 'and the launch configuration does not exist yet' do
+        after { subject.destroy! rescue nil }
+
+        it 'creates the launch configuration group' do
+          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) }
+
+      it 'raises an error' do
+        expect { subject.destroy! }.to raise_error
+      end
+    end
+
+    context 'when the aws_identifier is present' do
+      context 'but the launch configuration does not exist' do
+        it 'raises an error' do
+          expect { subject.destroy! }.to raise_error
+        end
+      end
+
+      context 'and the launch configuration exists' do
+        before { subject.create! }
+
+        it 'deletes the launch configuration' do
+          expect { subject.destroy! }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe '#create' do
+    context 'when the aws_identifier is nil' do
+      subject { described_class.new!(:name => :random_test_name) }
+
+      it 'raises an error' do
+        expect { subject.create }.to raise_error
+      end
+    end
+
+    context 'when the aws_identifier is present' do
+      subject do
+        described_class.new! do
+          name :random_test_name_2
+          ami '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!)
+          subject.create
+        end
+      end
+
+      context 'and the launch configuration does not yet exist' do
+        before { subject.destroy }
+
+        it 'creates it' do
+          subject.should_receive(:create!)
+          subject.create
+        end
+      end
+    end
+  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
+      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
+      end
+
+      context 'and the launch configuration already exists' do
+        before { subject.create! }
+
+        it 'calls #destroy!' do
+          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
+          subject.should_not_receive(:destroy!)
+          subject.destroy
+        end
+      end
+    end
+  end
+
+  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!)
+      end
+
+      it 'returns true' do
+        subject.exists?(instance.aws_identifier).should be_true
+      end
+    end
+
+    context 'when the argument does not exist' do
+      let(:instance) { described_class.new!   }
+
+      it 'returns false' do
+        subject.exists?(instance.aws_identifier).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])
+      end
+    end
+  end
+
+  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 }
+
+      its(:all) { should be_empty }
+    end
+
+    context 'when there are launch configurations' do
+
+      before do
+        [
+          {
+            :ami => 'ami1',
+            :instance_type => 'm1.large'
+          },
+          {
+            :ami => 'ami2',
+            :instance_type => 'm1.large'
+          }
+        ].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]
+        subject.all.map(&:instance_type).should == %w[m1.large m1.large]
+      end
+    end
+  end
+
+  describe '.from_hash' do
+    context 'when the launch configuration has not been initialized' 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',
+        }
+      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.instance_type.should == 'm1.large'
+        subject.security_groups.should be_empty
+        subject.user_data.should == 'echo hi'
+        subject.iam_role.should be_nil
+        subject.kernel_id.should == 'kernel-id'
+        subject.spot_price.should == '0.04'
+      end
+
+      it 'generates a name' do
+        subject.name.to_s.should start_with 'LaunchConfiguration_'
+      end
+    end
+
+    context 'when the launch configuration has already been initialized' do
+      let(:old_hash) do
+        {
+          'LaunchConfigurationName' => 'this-aws-id-abc-123',
+          'ImageId' => 'ami-456',
+        }
+      end
+      let(:new_hash) { old_hash.merge('InstanceType' => 'm1.large') }
+      let!(:existing) { described_class.from_hash(old_hash) }
+      let(:new) { described_class.from_hash(new_hash) }
+
+      it 'updates its values' 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'
+      end
+    end
+  end
+end

data/spec/aerosol/rake_task_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Rake' do
+  describe 'load' do
+    before do
+      Aerosol::Util.stub(:git_sha)
+    end
+
+    context 'when the aerosol.rb file does not exist' do
+      before do
+        File.stub(:exist?).and_return(false)
+      end
+
+      it 'raises an error' do
+        lambda { Rake::Task['aerosol:load'].invoke }.should raise_error(RuntimeError, 'No aerosol.rb found!')
+      end
+    end
+  end
+end