automan 2.3.5 → 2.3.6

data/spec/beanstalk/configuration_spec.rb

@@ -23,10 +23,10 @@ describe Automan::Beanstalk::Configuration do
   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')
-      subject.eb = double()
-      allow(subject.eb).to receive(:describe_configuration_settings).and_raise(error)
-      expect(subject.config_template_exists?).to be_falsey
+      c.eb.stub(:describe_configuration_settings).and_raise(error)
+      c.config_template_exists?.should be_false
     end
   end
 
@@ -48,51 +48,51 @@ describe Automan::Beanstalk::Configuration do
         }
       ]
 
-      expect(subject.fix_config_keys(config_before)).to eq(config_after)
+      c.fix_config_keys(config_before).should eq(config_after)
     end
   end
 
   describe '#create' do
     it 'does not create if configuration exists' do
-      allow(subject).to receive(:config_template_exists?).and_return(true)
-      expect(subject).to_not receive(:create_config_template)
-      subject.create
+      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
-      allow(subject).to receive(:config_template_exists?).and_return(false)
-      expect(subject).to receive(:create_config_template)
-      subject.create
+      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
-      allow(subject).to receive(:config_template_exists?).and_return(true)
-      expect(subject).to receive(:delete_config_template)
-      subject.delete
+      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
-      allow(subject).to receive(:config_template_exists?).and_return(false)
-      expect(subject).to_not receive(:delete_config_template)
-      subject.delete
+      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
-      allow(subject).to receive(:config_template_exists?).and_return(true)
-      expect(subject).to receive(:delete_config_template)
-      expect(subject).to receive(:create_config_template)
-      subject.update
+      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
-      allow(subject).to receive(:config_template_exists?).and_return(false)
-      expect(subject).to_not receive(:delete_config_template)
-      expect(subject).to receive(:create_config_template)
-      subject.update
+      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

@@ -2,59 +2,59 @@ require "automan"
 
 describe Automan::Beanstalk::Deployer do
 
-  it { is_expected.to respond_to :name }
-  it { is_expected.to respond_to :version_label }
-  it { is_expected.to respond_to :package }
-  it { is_expected.to respond_to :environment }
-  it { is_expected.to respond_to :manifest }
-  it { is_expected.to respond_to :read_manifest }
-  it { is_expected.to respond_to :manifest_exists? }
-  it { is_expected.to respond_to :package_exists? }
-  it { is_expected.to respond_to :environment_status }
-  it { is_expected.to respond_to :configuration_template }
-  it { is_expected.to respond_to :deploy }
-  it { is_expected.to respond_to :update_environment }
-  it { is_expected.to respond_to :create_environment }
+  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() { Automan::Beanstalk::Deployer.new }
+    subject(:bd) { Automan::Beanstalk::Deployer.new }
 
     it "is at least 4 characters" do
-      subject.name = "a"
-      subject.environment = "a"
-      expect(subject.eb_environment_name.length).to be >= 4
+      bd.name = "a"
+      bd.environment = "a"
+      bd.eb_environment_name.length.should be >= 4
     end
 
     it "is no more than 23 characters" do
-      subject.name = "a" * 23
-      subject.environment = "dev"
-      expect(subject.eb_environment_name.length).to be <= 23
+      bd.name = "a" * 23
+      bd.environment = "dev"
+      bd.eb_environment_name.length.should be <= 23
     end
 
     it "contains only letters, numbers, and hyphens" do
-      subject.name = '@#$%^foo_bar!$%&&E.'
-      subject.environment = 'prod.baz'
-      expect(subject.eb_environment_name).to match(/[a-z0-9-]+/)
+      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
-      subject.name = '--foo'
-      subject.environment = 'bar--'
-      expect(subject.eb_environment_name).to match(/^[^-].*[^-]$/)
+      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
-      subject.name = '--f'
-      subject.environment = '-'
-      expect(subject.eb_environment_name.length).to be >= 4
+      bd.name = '--f'
+      bd.environment = '-'
+      bd.eb_environment_name.length.should be >= 4
     end
   end
 
   describe '#read_manifest' do
-    subject() do
+    subject(:d) do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
@@ -62,23 +62,23 @@ describe Automan::Beanstalk::Deployer do
     end
 
     it 'raises MissingManifestError if the manifest is missing' do
-      expect(subject).to receive(:manifest_exists?).and_return(false)
+      d.stub(:manifest_exists?).and_return(false)
       expect {
-        subject.read_manifest
+        d.read_manifest
       }.to raise_error(Automan::Beanstalk::MissingManifestError)
     end
 
     it 'sets version_label and package properly' do
-      allow(subject).to receive(:manifest_exists?).and_return(true)
-      allow(subject).to receive(:s3_read).and_return('{"version_label": "foo", "package": "bar"}')
-      subject.read_manifest
-      expect(subject.version_label).to eq('foo')
-      expect(subject.package).to eq('bar')
+      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() do
+    subject(:d) do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
@@ -86,22 +86,22 @@ describe Automan::Beanstalk::Deployer do
     end
 
     it 'raises MissingPackageError if the package does not exist' do
-      allow(subject).to receive(:package_exists?).and_return(false)
+      d.stub(:package_exists?).and_return(false)
       expect {
-        subject.deploy
+        d.deploy
       }.to raise_error(Automan::Beanstalk::MissingPackageFileError)
     end
 
     it 'makes sure the application version and environment exists' do
-      allow(subject).to receive(:package_exists?).and_return(true)
-      expect(subject).to receive(:ensure_version_exists)
-      expect(subject).to receive(:create_or_update_environment)
-      subject.deploy
+      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() do
+    subject(:d) do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
@@ -109,51 +109,51 @@ describe Automan::Beanstalk::Deployer do
     end
 
     it 'creates version if it does not exist' do
-      version = double()
-      allow(version).to receive(:exists?).and_return(false)
-      expect(version).to receive(:create)
-      allow(subject).to receive(:get_version).and_return(version)
-      subject.ensure_version_exists
+      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()
-      allow(version).to receive(:exists?).and_return(true)
-      expect(version).to_not receive(:create)
-      allow(subject).to receive(:get_version).and_return(version)
-      subject.ensure_version_exists
+      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() do
+    subject(:d) do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
-      allow(d).to receive(:ensure_version_exists)
+      d.stub(:ensure_version_exists)
       d
     end
 
     [nil, 'Terminated'].each do |state|
       it "creates environment if state is #{state.nil? ? 'nil' : state}" do
-        allow(subject).to receive(:environment_status).and_return(state)
-        expect(subject).to receive(:create_environment)
-        subject.create_or_update_environment
+        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
-        allow(subject).to receive(:environment_status).and_return(state)
-        expect(subject).to receive(:update_environment)
-        subject.create_or_update_environment
+        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
-      allow(subject).to receive(:environment_status).and_return('foo')
+      d.stub(:environment_status).and_return('foo')
       expect {
-        subject.create_or_update_environment
+        d.create_or_update_environment
       }.to raise_error(Automan::Beanstalk::InvalidEnvironmentStatusError)
     end
   end

data/spec/beanstalk/router_spec.rb

@@ -2,14 +2,14 @@ require 'automan'
 require 'wait'
 
 describe Automan::Beanstalk::Router do
-  it { is_expected.to respond_to :run }
-  it { is_expected.to respond_to :environment_name }
-  it { is_expected.to respond_to :hosted_zone_name }
-  it { is_expected.to respond_to :hostname }
+  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() do
+      subject(:r) do
         AWS.stub!
         r = Automan::Beanstalk::Router.new
         r.eb = AWS::ElasticBeanstalk::Client.new
@@ -17,47 +17,48 @@ describe Automan::Beanstalk::Router do
         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
-        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return(nil)
+        r.stub(:elb_cname_from_beanstalk_environment).and_return(nil)
         expect {
-          subject.run
+          r.run
         }.to raise_error Wait::ResultInvalid
       end
 
       it "calls #update_dns_alias if it finds a name" do
-        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return('foo')
-        expect(subject).to receive(:update_dns_alias)
-        subject.run
+        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
-        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return('foo')
-        allow(subject).to receive(:update_dns_alias).and_raise AWS::Route53::Errors::InvalidChangeBatch
+        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
+        r.stub(:update_dns_alias).and_raise AWS::Route53::Errors::InvalidChangeBatch
         expect {
-          subject.run
+          r.run
         }.to raise_error AWS::Route53::Errors::InvalidChangeBatch
-        expect(subject.attempts_made).to eq 5
+        r.attempts_made.should eq 5
       end
 
       it "ignores InvalidChangeBatch until it succeeds" do
-        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return('foo')
+        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
 
         @attempts = 0
-        allow(subject).to receive(:update_dns_alias) do
+        r.stub(:update_dns_alias) do
           @attempts += 1
           raise AWS::Route53::Errors::InvalidChangeBatch if @attempts < 3
         end
 
         expect {
-          subject.run
+          r.run
         }.not_to raise_error
 
-        expect(subject.attempts_made).to eq 3
+        r.attempts_made.should eq 3
       end
     end
   end

data/spec/beanstalk/terminator_spec.rb

@@ -14,33 +14,33 @@ describe Automan::Beanstalk::Terminator do
     end
 
     it "returns false if environment does not exist" do
-      resp = subject.eb.stub_for :describe_environments
+      resp = t.eb.stub_for :describe_environments
       resp.data[:environments] = [{}]
-      expect(subject.environment_exists?('foo')).to be_falsey
+      t.environment_exists?('foo').should be_false
     end
 
     it "returns false if environment is in Terminated state" do
-      resp = subject.eb.stub_for :describe_environments
+      resp = t.eb.stub_for :describe_environments
       resp.data[:environments] = [{environment_name: 'foo', status: 'Terminated'}]
-      expect(subject.environment_exists?('foo')).to be_falsey
+      t.environment_exists?('foo').should be_false
     end
 
     it "returns false if environment is in Terminating state" do
-      resp = subject.eb.stub_for :describe_environments
+      resp = t.eb.stub_for :describe_environments
       resp.data[:environments] = [{environment_name: 'foo', status: 'Terminating'}]
-      expect(subject.environment_exists?('foo')).to be_falsey
+      t.environment_exists?('foo').should be_false
     end
 
     it "returns true if environment does exist" do
-      resp = subject.eb.stub_for :describe_environments
+      resp = t.eb.stub_for :describe_environments
       resp.data[:environments] = [{environment_name: 'foo'}]
-      expect(subject.environment_exists?('foo')).to be_truthy
+      t.environment_exists?('foo').should be_true
     end
 
     it "returns true if environment is in Ready state" do
-      resp = subject.eb.stub_for :describe_environments
+      resp = t.eb.stub_for :describe_environments
       resp.data[:environments] = [{environment_name: 'foo', status: 'Ready'}]
-      expect(subject.environment_exists?('foo')).to be_truthy
+      t.environment_exists?('foo').should be_true
     end
   end
 
@@ -53,15 +53,15 @@ describe Automan::Beanstalk::Terminator do
     end
 
     it 'should call #terminate_environment if the environment exists' do
-      allow(subject).to receive(:environment_exists?).and_return(true)
-      expect(subject).to receive :terminate_environment
-      subject.terminate
+      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
-      allow(subject).to receive(:environment_exists?).and_return(false)
-      expect(subject).to_not receive :terminate_environment
-      subject.terminate
+      t.stub(:environment_exists?).and_return(false)
+      t.should_not_receive :terminate_environment
+      t.terminate
     end
   end
 end