automan 2.3.1 → 2.3.2

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

@@ -21,19 +21,19 @@ describe Automan::Beanstalk::Version do
     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
 
@@ -46,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
 

data/spec/cloudformation/launcher_spec.rb

@@ -17,30 +17,29 @@ describe Automan::Cloudformation::Launcher do
   it { should respond_to :stack_update_complete? }
 
   describe '#read_manifest' do
-    subject(:s) do
+    subject() do
       AWS.stub!
-      s = Automan::Cloudformation::Launcher.new
-      s
+      Automan::Cloudformation::Launcher.new
     end
 
     it 'raises MissingManifestError if manifest does not exist' do
-      s.stub(:manifest_exists?).and_return(false)
+      allow(subject).to receive(:manifest_exists?).and_return(false)
       expect {
-        s.read_manifest
+        subject.read_manifest
       }.to raise_error(Automan::Cloudformation::MissingManifestError)
     end
 
     it 'merges manifest contents into parameters hash' do
-      s.stub(:manifest_exists?).and_return(true)
-      s.stub(:s3_read).and_return('{"foo": "bar", "big": "poppa"}')
-      s.parameters = {'foo'=> 'baz', 'fo'=> 'shizzle'}
-      s.read_manifest
-      s.parameters.should eq({'foo' => 'bar', 'fo' => 'shizzle', 'big' => 'poppa'})
+      allow(subject).to receive(:manifest_exists?).and_return(true)
+      allow(subject).to receive(:s3_read).and_return('{"foo": "bar", "big": "poppa"}')
+      subject.parameters = {'foo'=> 'baz', 'fo'=> 'shizzle'}
+      subject.read_manifest
+      expect(subject.parameters).to eq({'foo' => 'bar', 'fo' => 'shizzle', 'big' => 'poppa'})
     end
   end
 
   describe '#parse_template_parameters' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Cloudformation::Launcher.new
       s.cfn = AWS::CloudFormation.new
@@ -49,31 +48,30 @@ describe Automan::Cloudformation::Launcher do
     end
 
     it "returns a hash" do
-      s.template = File.join(File.dirname(__FILE__), 'templates', 'worker_role.json')
-      result = s.parse_template_parameters
-      result.class.should eq(Hash)
+      subject.template = File.join(File.dirname(__FILE__), 'templates', 'worker_role.json')
+      result = subject.parse_template_parameters
+      expect(result.class).to eq(Hash)
     end
 
   end
 
   describe '#template_handle' do
-    subject(:s) do
+    subject() do
       AWS.stub!
-      s = Automan::Cloudformation::Launcher.new
-      s
+      Automan::Cloudformation::Launcher.new
     end
 
     it "returns an s3 key if it is an s3 path" do
-      s.template_handle("s3://foo/bar/baz").should be_a AWS::S3::S3Object
+      expect(subject.template_handle("s3://foo/bar/baz")).to be_a AWS::S3::S3Object
     end
 
     it "returns a string if it is a local file" do
-      s.template_handle(__FILE__).should be_a String
+      expect(subject.template_handle(__FILE__)).to be_a String
     end
   end
 
   describe '#validate_parameters' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Cloudformation::Launcher.new
       s.logger = Logger.new('/dev/null')
@@ -82,99 +80,99 @@ describe Automan::Cloudformation::Launcher do
     end
 
     it "raises error if no parameters were specified" do
-      s.parameters = nil
+      subject.parameters = nil
       expect {
-        s.validate_parameters
+        subject.validate_parameters
       }.to raise_error Automan::Cloudformation::MissingParametersError
     end
 
     it "raises error if the template doesn't validate" do
-      Automan::Cloudformation::Launcher.any_instance.stub(:parse_template_parameters).and_return({code: 'foo', message: 'bar'})
+      allow(subject).to receive(:parse_template_parameters).and_return({code: 'foo', message: 'bar'})
       expect {
-        s.validate_parameters
+        subject.validate_parameters
       }.to raise_error Automan::Cloudformation::BadTemplateError
     end
 
     it "raises error if a required parameter isn't present" do
-      Automan::Cloudformation::Launcher.any_instance.stub(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo'}])
+      allow(subject).to receive(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo'}])
       expect {
-        s.validate_parameters
+        subject.validate_parameters
       }.to raise_error Automan::Cloudformation::MissingParametersError
     end
 
     it "raises no error if all required parameters are present" do
-      Automan::Cloudformation::Launcher.any_instance.stub(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo'}])
-      s.parameters = {'foo' => 'bar'}
+      allow(subject).to receive(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo'}])
+      subject.parameters = {'foo' => 'bar'}
       expect {
-        s.validate_parameters
+        subject.validate_parameters
       }.not_to raise_error
     end
 
     it "raises no error if there are no required parameters" do
-      Automan::Cloudformation::Launcher.any_instance.stub(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo', default_value: 'bar'}])
+      allow(subject).to receive(:parse_template_parameters).and_return(parameters: [{parameter_key: 'foo', default_value: 'bar'}])
       expect {
-        s.validate_parameters
+        subject.validate_parameters
       }.not_to raise_error
     end
   end
 
   describe '#update' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Cloudformation::Launcher.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:template_handle).and_return('foo')
+      allow(s).to receive(:template_handle).and_return('foo')
       s
     end
 
     it "ignores AWS::CloudFormation::Errors::ValidationError when no updates are to be performed" do
-      s.stub(:update_stack).and_raise AWS::CloudFormation::Errors::ValidationError.new("No updates are to be performed.")
+      allow(subject).to receive(:update_stack).and_raise AWS::CloudFormation::Errors::ValidationError.new("No updates are to be performed.")
       expect {
-        s.update
+        subject.update
       }.to_not raise_error
     end
 
     it 're-raises any other ValidationError' do
-      s.stub(:update_stack).and_raise AWS::CloudFormation::Errors::ValidationError.new("foo")
+      allow(subject).to receive(:update_stack).and_raise AWS::CloudFormation::Errors::ValidationError.new("foo")
       expect {
-        s.update
+        subject.update
       }.to raise_error AWS::CloudFormation::Errors::ValidationError
     end
   end
 
   describe '#launch_or_update' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Cloudformation::Launcher.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:validate_parameters)
+      allow(s).to receive(:validate_parameters)
       s
     end
 
     it "launches a new stack if it does not exist" do
-      s.stub(:stack_exists?).and_return(false)
-      s.should_receive(:launch)
-      s.launch_or_update
+      allow(subject).to receive(:stack_exists?).and_return(false)
+      expect(subject).to receive(:launch)
+      subject.launch_or_update
     end
 
     it "updates an existing stack if update is enabled" do
-      s.stub(:stack_exists?).and_return(true)
-      s.stub(:enable_update).and_return(true)
-      s.should_receive(:update)
-      s.launch_or_update
+      allow(subject).to receive(:stack_exists?).and_return(true)
+      allow(subject).to receive(:enable_update).and_return(true)
+      expect(subject).to receive(:update)
+      subject.launch_or_update
     end
 
     it "raises an error when updating an existing stack w/o update enabled" do
-      s.stub(:stack_exists?).and_return(true)
-      s.stub(:enable_update).and_return(false)
+      allow(subject).to receive(:stack_exists?).and_return(true)
+      allow(subject).to receive(:enable_update).and_return(false)
       expect {
-        s.launch_or_update
+        subject.launch_or_update
       }.to raise_error Automan::Cloudformation::StackExistsError
     end
   end
 
   describe '#stack_launch_complete?' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Cloudformation::Launcher.new
       s.logger = Logger.new('/dev/null')
@@ -182,35 +180,35 @@ describe Automan::Cloudformation::Launcher do
     end
 
     it 'returns true when the stack completes' do
-      s.stub(:stack_status).and_return('CREATE_COMPLETE')
-      s.stack_launch_complete?.should be_true
+      allow(subject).to receive(:stack_status).and_return('CREATE_COMPLETE')
+      expect(subject.stack_launch_complete?).to be_truthy
     end
 
     it 'raises an error when the stack fails' do
-      s.stub(:stack_status).and_return('CREATE_FAILED')
+      allow(subject).to receive(:stack_status).and_return('CREATE_FAILED')
       expect {
-        s.stack_launch_complete?
+        subject.stack_launch_complete?
       }.to raise_error Automan::Cloudformation::StackCreationError
     end
 
     rollback_states = %w[ROLLBACK_COMPLETE ROLLBACK_FAILED ROLLBACK_IN_PROGRESS]
     rollback_states.each do |state|
       it "raises an error when the stack goes into #{state} state" do
-        s.stub(:stack_status).and_return(state)
+        allow(subject).to receive(:stack_status).and_return(state)
         expect {
-          s.stack_launch_complete?
+          subject.stack_launch_complete?
         }.to raise_error Automan::Cloudformation::StackCreationError
       end
     end
 
     it 'returns false for any other state' do
-      s.stub(:stack_status).and_return('foo')
-      s.stack_launch_complete?.should be_false
+      allow(subject).to receive(:stack_status).and_return('foo')
+      expect(subject.stack_launch_complete?).to be_falsey
     end
   end
 
   describe '#stack_update_complete?' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Cloudformation::Launcher.new
       s.logger = Logger.new('/dev/null')
@@ -218,23 +216,23 @@ describe Automan::Cloudformation::Launcher do
     end
 
     it 'returns true when the stack completes' do
-      s.stub(:stack_status).and_return('UPDATE_COMPLETE')
-      s.stack_update_complete?.should be_true
+      allow(subject).to receive(:stack_status).and_return('UPDATE_COMPLETE')
+      expect(subject.stack_update_complete?).to be_truthy
     end
 
     rollback_states = %w[UPDATE_ROLLBACK_COMPLETE UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS UPDATE_ROLLBACK_FAILED UPDATE_ROLLBACK_IN_PROGRESS]
     rollback_states.each do |state|
       it "raises an error when the stack enters #{state} state" do
-        s.stub(:stack_status).and_return(state)
+        allow(subject).to receive(:stack_status).and_return(state)
         expect {
-          s.stack_update_complete?
+          subject.stack_update_complete?
         }.to raise_error Automan::Cloudformation::StackUpdateError
       end
     end
 
     it 'returns false for any other state' do
-      s.stub(:stack_status).and_return('foo')
-      s.stack_update_complete?.should be_false
+      allow(subject).to receive(:stack_status).and_return('foo')
+      expect(subject.stack_update_complete?).to be_falsey
     end
   end
 end

data/spec/cloudformation/replacer_spec.rb

@@ -1,15 +1,15 @@
 require 'automan'
 
 describe Automan::Cloudformation::Replacer do
-  it { should respond_to :name }
-  it { should respond_to :replace_instances }
-  it { should respond_to :ok_to_replace_instances? }
-  it { should respond_to :stack_exists? }
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :replace_instances }
+  it { is_expected.to respond_to :ok_to_replace_instances? }
+  it { is_expected.to respond_to :stack_exists? }
 
   describe '#ok_to_replace_instances?' do
-    subject(:r) do
+    subject() do
       AWS.stub!
-      r = Automan::Cloudformation::Replacer.new
+      Automan::Cloudformation::Replacer.new
     end
 
     good_states = %w[UPDATE_COMPLETE]
@@ -30,28 +30,28 @@ describe Automan::Cloudformation::Replacer do
 
     good_states.each do |state|
       it "returns true when stack is in the right state (state: #{state})" do
-        r.ok_to_replace_instances?(state, Time.now).should be_true
+        expect(subject.ok_to_replace_instances?(state, Time.now)).to be_truthy
       end
     end
 
     good_states.each do |state|
       it "returns false when stack is in the right state but has not been updated in the last 5m" do
         last_updated = Time.now - (5 * 60 + 1)
-        r.ok_to_replace_instances?(state, last_updated).should be_false
+        expect(subject.ok_to_replace_instances?(state, last_updated)).to be_falsey
       end
     end
 
     bad_states.each do |state|
       it "raises error when stack is borked (state: #{state})" do
         expect {
-          r.ok_to_replace_instances?(state, Time.now)
+          subject.ok_to_replace_instances?(state, Time.now)
         }.to raise_error Automan::Cloudformation::StackBrokenError
       end
     end
 
     wait_states.each do |state|
       it "returns false when it is not yet ok to replace (state: #{state})" do
-        r.ok_to_replace_instances?(state, Time.now).should be_false
+        expect(subject.ok_to_replace_instances?(state, Time.now)).to be_falsey
       end
     end
   end