automan 2.1.2

data/spec/beanstalk/application_spec.rb

@@ -0,0 +1,49 @@
+require "automan"
+
+describe Automan::Beanstalk::Application do
+  it { should respond_to :name }
+  it { should respond_to :create }
+  it { should respond_to :delete }
+
+  describe '#create' do
+    subject(:a) do
+      AWS.stub!
+      a = Automan::Beanstalk::Application.new
+      a.logger = Logger.new('/dev/null')
+      a
+    end
+
+    it "does not create if the application already exists" do
+      a.stub(:application_exists?).and_return(true)
+      a.should_not_receive(:create_application)
+      a.create
+    end
+
+    it "does create if the application doesn't exist" do
+      a.stub(:application_exists?).and_return(false)
+      a.should_receive(:create_application)
+      a.create
+    end
+  end
+
+  describe '#delete' do
+    subject(:a) do
+      AWS.stub!
+      a = Automan::Beanstalk::Application.new
+      a.logger = Logger.new('/dev/null')
+      a
+    end
+
+    it "does delete if the application already exists" do
+      a.stub(:application_exists?).and_return(true)
+      a.should_receive(:delete_application)
+      a.delete
+    end
+
+    it "does not delete if the application doesn't exist" do
+      a.stub(:application_exists?).and_return(false)
+      a.should_not_receive(:delete_application)
+      a.delete
+    end
+  end
+end

data/spec/beanstalk/configuration_spec.rb

@@ -0,0 +1,98 @@
+require "automan"
+
+describe Automan::Beanstalk::Configuration do
+  subject(:c) do
+    AWS.stub!
+    c = Automan::Beanstalk::Configuration.new
+    c.logger = Logger.new('/dev/null')
+    c
+  end
+
+  it { should respond_to :name }
+  it { should respond_to :application }
+  it { should respond_to :template }
+  it { should respond_to :platform }
+  it { should respond_to :config_template_exists? }
+  it { should respond_to :create_config_template }
+  it { should respond_to :delete_config_template }
+  it { should respond_to :fix_config_keys }
+  it { should respond_to :create }
+  it { should respond_to :delete }
+  it { should respond_to :update }
+
+  describe '#config_template_exists?' do
+
+    it 'returns false if raises InvalidParameterValue with missing config template message' do
+      c.eb = double(:eb)
+      error = AWS::ElasticBeanstalk::Errors::InvalidParameterValue.new('No Configuration Template named')
+      c.eb.stub(:describe_configuration_settings).and_raise(error)
+      c.config_template_exists?.should be_false
+    end
+  end
+
+  describe '#fix_config_keys' do
+    it 'snake-cases the keys' do
+      config_before = [
+        {
+          "Namespace" => "aws:elasticbeanstalk:application:environment",
+          "OptionName" => "Environment",
+          "Value" => "dev1"
+        }
+      ]
+
+      config_after = [
+        {
+          "namespace" => "aws:elasticbeanstalk:application:environment",
+          "option_name" => "Environment",
+          "value" => "dev1"
+        }
+      ]
+
+      c.fix_config_keys(config_before).should eq(config_after)
+    end
+  end
+
+  describe '#create' do
+    it 'does not create if configuration exists' do
+      c.stub(:config_template_exists?).and_return(true)
+      c.should_not_receive(:create_config_template)
+      c.create
+    end
+
+    it 'does create if configuration does not exist' do
+      c.stub(:config_template_exists?).and_return(false)
+      c.should_receive(:create_config_template)
+      c.create
+    end
+  end
+
+  describe '#delete' do
+    it 'does delete if configuration exists' do
+      c.stub(:config_template_exists?).and_return(true)
+      c.should_receive(:delete_config_template)
+      c.delete
+    end
+
+    it 'does not delete if configuration does not exist' do
+      c.stub(:config_template_exists?).and_return(false)
+      c.should_not_receive(:delete_config_template)
+      c.delete
+    end
+  end
+
+  describe '#update' do
+    it 'deletes configuration and recreates it if it exists' do
+      c.stub(:config_template_exists?).and_return(true)
+      c.should_receive(:delete_config_template)
+      c.should_receive(:create_config_template)
+      c.update
+    end
+
+    it 'does not try to delete configuration if it does not exist' do
+      c.stub(:config_template_exists?).and_return(false)
+      c.should_not_receive(:delete_config_template)
+      c.should_receive(:create_config_template)
+      c.update
+    end
+  end
+end

data/spec/beanstalk/deployer_spec.rb

@@ -0,0 +1,162 @@
+require "automan"
+
+describe Automan::Beanstalk::Deployer do
+
+  it { should respond_to :name }
+  it { should respond_to :version_label }
+  it { should respond_to :package }
+  it { should respond_to :environment }
+  it { should respond_to :manifest }
+  it { should respond_to :read_manifest }
+  it { should respond_to :manifest_exists? }
+  it { should respond_to :package_exists? }
+  it { should respond_to :environment_status }
+  it { should respond_to :configuration_template }
+  it { should respond_to :deploy }
+  it { should respond_to :update_environment }
+  it { should respond_to :create_environment }
+
+  # Constraint: Must be from 4 to 23 characters in length.
+  # The name can contain only letters, numbers, and hyphens.
+  # It cannot start or end with a hyphen.
+  describe '#eb_environment_name' do
+    subject(:bd) { Automan::Beanstalk::Deployer.new }
+
+    it "is at least 4 characters" do
+      bd.name = "a"
+      bd.environment = "a"
+      bd.eb_environment_name.length.should be >= 4
+    end
+
+    it "is no more than 23 characters" do
+      bd.name = "a" * 23
+      bd.environment = "dev"
+      bd.eb_environment_name.length.should be <= 23
+    end
+
+    it "contains only letters, numbers, and hyphens" do
+      bd.name = '@#$%^foo_bar!$%&&E.'
+      bd.environment = 'prod.baz'
+      bd.eb_environment_name.should match(/[a-z0-9-]+/)
+    end
+
+    it "cannot start or end with a hyphen" do
+      bd.name = '--foo'
+      bd.environment = 'bar--'
+      bd.eb_environment_name.should match(/^[^-].*[^-]$/)
+    end
+
+    it "is still at least 4 characters even after removing restricted strings" do
+      bd.name = '--f'
+      bd.environment = '-'
+      bd.eb_environment_name.length.should be >= 4
+    end
+  end
+
+  describe '#read_manifest' do
+    subject(:d) do
+      AWS.stub!
+      d = Automan::Beanstalk::Deployer.new
+      d.logger = Logger.new('/dev/null')
+      d
+    end
+
+    it 'raises MissingManifestError if the manifest is missing' do
+      d.stub(:manifest_exists?).and_return(false)
+      expect {
+        d.read_manifest
+      }.to raise_error(Automan::Beanstalk::MissingManifestError)
+    end
+
+    it 'sets version_label and package properly' do
+      d.stub(:manifest_exists?).and_return(true)
+      d.stub(:s3_read).and_return('{"version_label": "foo", "package": "bar"}')
+      d.read_manifest
+      d.version_label.should eq('foo')
+      d.package.should eq('bar')
+    end
+  end
+
+  describe '#deploy' do
+    subject(:d) do
+      AWS.stub!
+      d = Automan::Beanstalk::Deployer.new
+      d.logger = Logger.new('/dev/null')
+      d
+    end
+
+    it 'raises MissingPackageError if the package does not exist' do
+      d.stub(:package_exists?).and_return(false)
+      expect {
+        d.deploy
+      }.to raise_error(Automan::Beanstalk::MissingPackageFileError)
+    end
+
+    it 'makes sure the application version and environment exists' do
+      d.stub(:package_exists?).and_return(true)
+      d.should_receive(:ensure_version_exists)
+      d.should_receive(:create_or_update_environment)
+      d.deploy
+    end
+  end
+
+  describe '#ensure_version_exists' do
+    subject(:d) do
+      AWS.stub!
+      d = Automan::Beanstalk::Deployer.new
+      d.logger = Logger.new('/dev/null')
+      d
+    end
+
+    it 'creates version if it does not exist' do
+      version = double(:version)
+      version.stub(:exists?).and_return(false)
+      version.should_receive(:create)
+      d.stub(:get_version).and_return(version)
+      d.ensure_version_exists
+    end
+
+    it 'does not create version if it exists' do
+      version = double(:version)
+      version.stub(:exists?).and_return(true)
+      version.should_not_receive(:create)
+      d.stub(:get_version).and_return(version)
+      d.ensure_version_exists
+    end
+  end
+
+  describe '#create_or_update_environment' do
+    subject(:d) do
+      AWS.stub!
+      d = Automan::Beanstalk::Deployer.new
+      d.logger = Logger.new('/dev/null')
+      d.stub(:ensure_version_exists)
+      d
+    end
+
+    [nil, 'Terminated'].each do |state|
+      it "creates environment if state is #{state.nil? ? 'nil' : state}" do
+        d.stub(:environment_status).and_return(state)
+        d.should_receive(:create_environment)
+        d.create_or_update_environment
+      end
+    end
+
+    ['Ready'].each do |state|
+      it "updates environment if state is #{state.nil? ? 'nil' : state}" do
+        d.stub(:environment_status).and_return(state)
+        d.should_receive(:update_environment)
+        d.create_or_update_environment
+      end
+    end
+
+    it 'raises error if environment state is anything else' do
+      d.stub(:environment_status).and_return('foo')
+      expect {
+        d.create_or_update_environment
+      }.to raise_error(Automan::Beanstalk::InvalidEnvironmentStatusError)
+    end
+  end
+
+end
+

data/spec/beanstalk/package_spec.rb

@@ -0,0 +1,9 @@
+require "automan"
+
+describe Automan::Beanstalk::Package do
+  it { should respond_to :upload_package }
+  it { should respond_to :source }
+  it { should respond_to :destination }
+  it { should respond_to :manifest }
+  it { should respond_to :version_label }
+end

data/spec/beanstalk/router_spec.rb

@@ -0,0 +1,65 @@
+require 'automan'
+require 'wait'
+
+describe Automan::Beanstalk::Router do
+  it { should respond_to :run }
+  it { should respond_to :environment_name }
+  it { should respond_to :hosted_zone_name }
+  it { should respond_to :hostname }
+
+  describe '#run' do
+    context 'waiting' do
+      subject(:r) do
+        AWS.stub!
+        r = Automan::Beanstalk::Router.new
+        r.eb = AWS::ElasticBeanstalk::Client.new
+        r.elb = AWS::ELB.new
+        r.environment_name = 'foo'
+        r.hosted_zone_name = 'foo.com'
+        r.hostname         = 'www.foo.com'
+        r.log_aws_calls = false
+        r.logger = Logger.new('/dev/null')
+        r.wait = Wait.new(delay: 0.01, rescuer: WaitRescuer.new(AWS::Route53::Errors::InvalidChangeBatch))
+        r
+      end
+
+      it "raises error if it never finds a name" do
+        r.stub(:elb_cname_from_beanstalk_environment).and_return(nil)
+        expect {
+          r.run
+        }.to raise_error Wait::ResultInvalid
+      end
+
+      it "calls #update_dns_alias if it finds a name" do
+        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
+        r.should_receive(:update_dns_alias)
+        r.run
+      end
+
+      it "ignores InvalidChangeBatch until last attempt" do
+        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
+        r.stub(:update_dns_alias).and_raise AWS::Route53::Errors::InvalidChangeBatch
+        expect {
+          r.run
+        }.to raise_error AWS::Route53::Errors::InvalidChangeBatch
+        r.attempts_made.should eq 5
+      end
+
+      it "ignores InvalidChangeBatch until it succeeds" do
+        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
+
+        @attempts = 0
+        r.stub(:update_dns_alias) do
+          @attempts += 1
+          raise AWS::Route53::Errors::InvalidChangeBatch if @attempts < 3
+        end
+
+        expect {
+          r.run
+        }.not_to raise_error
+
+        r.attempts_made.should eq 3
+      end
+    end
+  end
+end

data/spec/beanstalk/terminator_spec.rb

@@ -0,0 +1,67 @@
+require 'automan'
+
+describe Automan::Beanstalk::Terminator do
+  it { should respond_to :name }
+  it { should respond_to :terminate }
+  it { should respond_to :environment_exists? }
+
+  describe '#environment_exists?' do
+    subject(:t) do
+      AWS.stub!
+      t = Automan::Beanstalk::Terminator.new
+      t.logger = Logger.new('/dev/null')
+      t
+    end
+
+    it "returns false if environment does not exist" do
+      resp = t.eb.stub_for :describe_environments
+      resp.data[:environments] = [{}]
+      t.environment_exists?('foo').should be_false
+    end
+
+    it "returns false if environment is in Terminated state" do
+      resp = t.eb.stub_for :describe_environments
+      resp.data[:environments] = [{environment_name: 'foo', status: 'Terminated'}]
+      t.environment_exists?('foo').should be_false
+    end
+
+    it "returns false if environment is in Terminating state" do
+      resp = t.eb.stub_for :describe_environments
+      resp.data[:environments] = [{environment_name: 'foo', status: 'Terminating'}]
+      t.environment_exists?('foo').should be_false
+    end
+
+    it "returns true if environment does exist" do
+      resp = t.eb.stub_for :describe_environments
+      resp.data[:environments] = [{environment_name: 'foo'}]
+      t.environment_exists?('foo').should be_true
+    end
+
+    it "returns true if environment is in Ready state" do
+      resp = t.eb.stub_for :describe_environments
+      resp.data[:environments] = [{environment_name: 'foo', status: 'Ready'}]
+      t.environment_exists?('foo').should be_true
+    end
+  end
+
+  describe '#terminate' do
+    subject(:t) do
+      AWS.stub!
+      t = Automan::Beanstalk::Terminator.new
+      t.logger = Logger.new('/dev/null')
+      t
+    end
+
+    it 'should call #terminate_environment if the environment exists' do
+      t.stub(:environment_exists?).and_return(true)
+      t.should_receive :terminate_environment
+      t.terminate
+    end
+
+    it 'should not call #terminate_environment if the environment does not exist' do
+      t.stub(:environment_exists?).and_return(false)
+      t.should_not_receive :terminate_environment
+      t.terminate
+    end
+  end
+end