automan 2.3.6 → 2.3.7

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

data/spec/cloudformation/terminator_spec.rb

@@ -1,15 +1,15 @@
 require 'automan'
 
 describe Automan::Cloudformation::Terminator do
-  it { should respond_to :name }
-  it { should respond_to :terminate }
-  it { should respond_to :stack_exists? }
-  it { should respond_to :stack_deleted? }
-  it { should respond_to :delete_stack }
-  it { should respond_to :wait_for_completion }
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :terminate }
+  it { is_expected.to respond_to :stack_exists? }
+  it { is_expected.to respond_to :stack_deleted? }
+  it { is_expected.to respond_to :delete_stack }
+  it { is_expected.to respond_to :wait_for_completion }
 
   describe '#terminate' do
-    subject(:t) do
+    subject() do
       AWS.stub!
       t = Automan::Cloudformation::Terminator.new
       t.logger = Logger.new('/dev/null')
@@ -17,20 +17,20 @@ describe Automan::Cloudformation::Terminator do
     end
 
     it 'should call #delete_stack if the stack exists' do
-      t.stub(:stack_exists?).and_return(true)
-      t.should_receive :delete_stack
-      t.terminate
+      allow(subject).to receive(:stack_exists?).and_return(true)
+      expect(subject).to receive :delete_stack
+      subject.terminate
     end
 
     it 'should not call #delete_stack if the stack does not exist' do
-      t.stub(:stack_exists?).and_return(false)
-      t.should_not_receive :delete_stack
-      t.terminate
+      allow(subject).to receive(:stack_exists?).and_return(false)
+      expect(subject).to_not receive :delete_stack
+      subject.terminate
     end
   end
 
   describe '#stack_deleted?' do
-    subject(:t) do
+    subject() do
       AWS.stub!
       t = Automan::Cloudformation::Terminator.new
       t.logger = Logger.new('/dev/null')
@@ -38,26 +38,26 @@ describe Automan::Cloudformation::Terminator do
     end
 
     it 'returns true if the stack does not exist' do
-      t.stub(:stack_exists?).and_return(false)
-      t.stub(:stack_status).and_raise StandardError
-      t.stack_deleted?('foo').should be_true
+      allow(subject).to receive(:stack_exists?).and_return(false)
+      allow(subject).to receive(:stack_status).and_raise StandardError
+      expect(subject.stack_deleted?('foo')).to be_truthy
     end
 
     it 'returns true when status is DELETE_COMPLETE' do
-      t.stub(:stack_status).and_return('DELETE_COMPLETE')
-      t.stack_deleted?('foo').should be_true
+      allow(subject).to receive(:stack_status).and_return('DELETE_COMPLETE')
+      expect(subject.stack_deleted?('foo')).to be_truthy
     end
 
     it 'raises an error when the delete fails' do
-      t.stub(:stack_status).and_return('DELETE_FAILED')
+      allow(subject).to receive(:stack_status).and_return('DELETE_FAILED')
       expect {
-        t.stack_deleted?('foo')
+        subject.stack_deleted?('foo')
       }.to raise_error Automan::Cloudformation::StackDeletionError
     end
 
     it 'returns false for any other status' do
-      t.stub(:stack_status).and_return('foo')
-      t.stack_deleted?('foo').should be_false
+      allow(subject).to receive(:stack_status).and_return('foo')
+      expect(subject.stack_deleted?('foo')).to be_falsey
     end
   end
 end

data/spec/cloudformation/uploader_spec.rb

@@ -1,11 +1,11 @@
 require 'automan'
 
 describe Automan::Cloudformation::Uploader do
-  subject(:u) do
+  subject() do
     AWS.stub!
     u = Automan::Cloudformation::Uploader.new
     u.logger = Logger.new('/dev/null')
-    u.stub(:templates).and_return(%w[a b c])
+    allow(u).to receive(:templates).and_return(%w[a b c])
     u
   end
 
@@ -16,35 +16,35 @@ describe Automan::Cloudformation::Uploader do
 
   describe '#all_templates_valid?' do
     it "raises error if there are no templates" do
-      u.stub(:templates).and_return([])
+      allow(subject).to receive(:templates).and_return([])
       expect {
-        u.all_templates_valid?
+        subject.all_templates_valid?
       }.to raise_error Automan::Cloudformation::NoTemplatesError
     end
 
     it 'returns true if templates are valid' do
-      u.should_receive(:template_valid?).exactly(3).times.and_return(true)
-      u.all_templates_valid?.should be_true
+      expect(subject).to receive(:template_valid?).exactly(3).times.and_return(true)
+      expect(subject.all_templates_valid?).to be_truthy
     end
 
     it 'returns false if any templates are invalid' do
-      u.stub(:template_valid?).and_return(false)
-      u.all_templates_valid?.should be_false
+      allow(subject).to receive(:template_valid?).and_return(false)
+      expect(subject.all_templates_valid?).to be_falsey
     end
   end
 
   describe '#upload_templates' do
     it 'raises error if any template fails validation' do
-      u.stub(:all_templates_valid?).and_return(false)
+      allow(subject).to receive(:all_templates_valid?).and_return(false)
       expect {
-        u.upload_templates
+        subject.upload_templates
       }.to raise_error(Automan::Cloudformation::InvalidTemplateError)
     end
 
     it 'uploads files if all are valid' do
-      u.stub(:all_templates_valid?).and_return(true)
-      u.should_receive(:upload_file).exactly(3).times
-      u.upload_templates
+      allow(subject).to receive(:all_templates_valid?).and_return(true)
+      expect(subject).to receive(:upload_file).exactly(3).times
+      subject.upload_templates
     end
   end
 end