automan 2.3.6 → 2.3.7

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

data/spec/beanstalk/deployer_spec.rb

@@ -2,59 +2,59 @@ 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 }
+  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 }
 
   # 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 }
+    subject() { 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
+      subject.name = "a"
+      subject.environment = "a"
+      expect(subject.eb_environment_name.length).to 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
+      subject.name = "a" * 23
+      subject.environment = "dev"
+      expect(subject.eb_environment_name.length).to 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-]+/)
+      subject.name = '@#$%^foo_bar!$%&&E.'
+      subject.environment = 'prod.baz'
+      expect(subject.eb_environment_name).to 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(/^[^-].*[^-]$/)
+      subject.name = '--foo'
+      subject.environment = 'bar--'
+      expect(subject.eb_environment_name).to 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
+      subject.name = '--f'
+      subject.environment = '-'
+      expect(subject.eb_environment_name.length).to be >= 4
     end
   end
 
   describe '#read_manifest' do
-    subject(:d) do
+    subject() 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
-      d.stub(:manifest_exists?).and_return(false)
+      expect(subject).to receive(:manifest_exists?).and_return(false)
       expect {
-        d.read_manifest
+        subject.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')
+      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')
     end
   end
 
   describe '#deploy' do
-    subject(:d) do
+    subject() 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
-      d.stub(:package_exists?).and_return(false)
+      allow(subject).to receive(:package_exists?).and_return(false)
       expect {
-        d.deploy
+        subject.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
+      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
     end
   end
 
   describe '#ensure_version_exists' do
-    subject(:d) do
+    subject() 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(:version)
-      version.stub(:exists?).and_return(false)
-      version.should_receive(:create)
-      d.stub(:get_version).and_return(version)
-      d.ensure_version_exists
+      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
     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
+      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
     end
   end
 
   describe '#create_or_update_environment' do
-    subject(:d) do
+    subject() do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
-      d.stub(:ensure_version_exists)
+      allow(d).to receive(: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
+        allow(subject).to receive(:environment_status).and_return(state)
+        expect(subject).to receive(:create_environment)
+        subject.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
+        allow(subject).to receive(:environment_status).and_return(state)
+        expect(subject).to receive(:update_environment)
+        subject.create_or_update_environment
       end
     end
 
     it 'raises error if environment state is anything else' do
-      d.stub(:environment_status).and_return('foo')
+      allow(subject).to receive(:environment_status).and_return('foo')
       expect {
-        d.create_or_update_environment
+        subject.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 { should respond_to :run }
-  it { should respond_to :environment_name }
-  it { should respond_to :hosted_zone_name }
-  it { should respond_to :hostname }
+  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 }
 
   describe '#run' do
     context 'waiting' do
-      subject(:r) do
+      subject() do
         AWS.stub!
         r = Automan::Beanstalk::Router.new
         r.eb = AWS::ElasticBeanstalk::Client.new
@@ -17,48 +17,47 @@ 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
-        r.stub(:elb_cname_from_beanstalk_environment).and_return(nil)
+        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return(nil)
         expect {
-          r.run
+          subject.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
+        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return('foo')
+        expect(subject).to receive(:update_dns_alias)
+        subject.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
+        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
         expect {
-          r.run
+          subject.run
         }.to raise_error AWS::Route53::Errors::InvalidChangeBatch
-        r.attempts_made.should eq 5
+        expect(subject.attempts_made).to eq 5
       end
 
       it "ignores InvalidChangeBatch until it succeeds" do
-        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
+        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return('foo')
 
         @attempts = 0
-        r.stub(:update_dns_alias) do
+        allow(subject).to receive(:update_dns_alias) do
           @attempts += 1
           raise AWS::Route53::Errors::InvalidChangeBatch if @attempts < 3
         end
 
         expect {
-          r.run
+          subject.run
         }.not_to raise_error
 
-        r.attempts_made.should eq 3
+        expect(subject.attempts_made).to 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 = t.eb.stub_for :describe_environments
+      resp = subject.eb.stub_for :describe_environments
       resp.data[:environments] = [{}]
-      t.environment_exists?('foo').should be_false
+      expect(subject.environment_exists?('foo')).to be_falsey
     end
 
     it "returns false if environment is in Terminated state" do
-      resp = t.eb.stub_for :describe_environments
+      resp = subject.eb.stub_for :describe_environments
       resp.data[:environments] = [{environment_name: 'foo', status: 'Terminated'}]
-      t.environment_exists?('foo').should be_false
+      expect(subject.environment_exists?('foo')).to be_falsey
     end
 
     it "returns false if environment is in Terminating state" do
-      resp = t.eb.stub_for :describe_environments
+      resp = subject.eb.stub_for :describe_environments
       resp.data[:environments] = [{environment_name: 'foo', status: 'Terminating'}]
-      t.environment_exists?('foo').should be_false
+      expect(subject.environment_exists?('foo')).to be_falsey
     end
 
     it "returns true if environment does exist" do
-      resp = t.eb.stub_for :describe_environments
+      resp = subject.eb.stub_for :describe_environments
       resp.data[:environments] = [{environment_name: 'foo'}]
-      t.environment_exists?('foo').should be_true
+      expect(subject.environment_exists?('foo')).to be_truthy
     end
 
     it "returns true if environment is in Ready state" do
-      resp = t.eb.stub_for :describe_environments
+      resp = subject.eb.stub_for :describe_environments
       resp.data[:environments] = [{environment_name: 'foo', status: 'Ready'}]
-      t.environment_exists?('foo').should be_true
+      expect(subject.environment_exists?('foo')).to be_truthy
     end
   end
 
@@ -53,15 +53,15 @@ describe Automan::Beanstalk::Terminator do
     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
+      allow(subject).to receive(:environment_exists?).and_return(true)
+      expect(subject).to receive :terminate_environment
+      subject.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
+      allow(subject).to receive(:environment_exists?).and_return(false)
+      expect(subject).to_not receive :terminate_environment
+      subject.terminate
     end
   end
 end

data/spec/beanstalk/uploader_spec.rb

@@ -6,7 +6,7 @@ describe Automan::Beanstalk::Uploader do
     u = Automan::Beanstalk::Uploader.new
     u.logger = Logger.new('/dev/null')
     u.template_files = 'foo'
-    u.stub(:config_templates).and_return(['foo'])
+    allow(u).to receive(:config_templates).and_return(['foo'])
     u
   end
 
@@ -18,36 +18,36 @@ describe Automan::Beanstalk::Uploader do
   describe '#config_templates_valid?' do
 
     it 'raises error if config templates do not exist' do
-      u.stub(:config_templates).and_return([])
+      allow(subject).to receive(:config_templates).and_return([])
       expect {
-        u.config_templates_valid?
+        subject.config_templates_valid?
       }.to raise_error(Automan::Beanstalk::NoConfigurationTemplatesError)
     end
 
     it 'returns true if config templates are valid json' do
-      u.stub(:read_config_template).and_return('[{}]')
-      u.config_templates_valid?.should be_true
+      allow(subject).to receive(:read_config_template).and_return('[{}]')
+      expect(subject.config_templates_valid?).to be_truthy
     end
 
     it 'returns false if config templates are invalid json' do
-      u.stub(:read_config_template).and_return('@#$%#')
-      u.config_templates_valid?.should be_false
+      allow(subject).to receive(:read_config_template).and_return('@#$%#')
+      expect(subject.config_templates_valid?).to be_falsey
     end
   end
 
   describe '#upload_config_templates' do
     it 'raises error if any config template fails validation' do
-      u.stub(:config_templates_valid?).and_return(false)
+      allow(subject).to receive(:config_templates_valid?).and_return(false)
       expect {
-        u.upload_config_templates
+        subject.upload_config_templates
       }.to raise_error(Automan::Beanstalk::InvalidConfigurationTemplateError)
     end
 
     it 'uploads files if they are valid' do
-      u.stub(:config_templates).and_return(%w[a b c])
-      u.stub(:config_templates_valid?).and_return(true)
-      u.should_receive(:upload_file).exactly(3).times
-      u.upload_config_templates
+      allow(subject).to receive(:config_templates).and_return(%w[a b c])
+      allow(subject).to receive(:config_templates_valid?).and_return(true)
+      expect(subject).to receive(:upload_file).exactly(3).times
+      subject.upload_config_templates
     end
   end
 end

data/spec/beanstalk/version_spec.rb

@@ -16,25 +16,24 @@ describe Automan::Beanstalk::Version do
       v.eb = AWS::ElasticBeanstalk::Client.new
       v.application = 'foo'
       v.label = 'v4'
-      v.log_aws_calls = false
       v.logger = Logger.new('/dev/null')
       v
     end
 
     it "is true when version exists in response" do
-      resp = v.eb.stub_for :describe_application_versions
+      resp = subject.eb.stub_for :describe_application_versions
       resp.data[:application_versions] = [
-        {application_name: v.application, version_label: v.label}
+        {application_name: subject.application, version_label: subject.label}
       ]
-      v.exists?.should be_true
+      expect(subject.exists?).to be_truthy
     end
 
     it "is false when version is not in response" do
-      resp = v.eb.stub_for :describe_application_versions
+      resp = subject.eb.stub_for :describe_application_versions
       resp.data[:application_versions] = [
         {application_name: '', version_label: ''}
       ]
-      v.exists?.should be_false
+      expect(subject.exists?).to be_falsey
     end
   end
 
@@ -47,11 +46,10 @@ describe Automan::Beanstalk::Version do
     end
 
     it 'ignores AWS::ElasticBeanstalk::Errors::SourceBundleDeletionFailure' do
-      eb = double(:eb)
-      eb.stub(:delete_application_version).and_raise(AWS::ElasticBeanstalk::Errors::SourceBundleDeletionFailure)
-      v.eb = eb
+      subject.eb = double()
+      allow(subject.eb).to receive(:delete_application_version).and_raise(AWS::ElasticBeanstalk::Errors::SourceBundleDeletionFailure)
       expect {
-        v.delete_by_label('foo')
+        subject.delete_by_label('foo')
       }.not_to raise_error
     end