automan 2.3.5 → 2.3.6

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'
-    allow(u).to receive(:config_templates).and_return(['foo'])
+    u.stub(: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
-      allow(subject).to receive(:config_templates).and_return([])
+      u.stub(:config_templates).and_return([])
       expect {
-        subject.config_templates_valid?
+        u.config_templates_valid?
       }.to raise_error(Automan::Beanstalk::NoConfigurationTemplatesError)
     end
 
     it 'returns true if config templates are valid json' do
-      allow(subject).to receive(:read_config_template).and_return('[{}]')
-      expect(subject.config_templates_valid?).to be_truthy
+      u.stub(:read_config_template).and_return('[{}]')
+      u.config_templates_valid?.should be_true
     end
 
     it 'returns false if config templates are invalid json' do
-      allow(subject).to receive(:read_config_template).and_return('@#$%#')
-      expect(subject.config_templates_valid?).to be_falsey
+      u.stub(:read_config_template).and_return('@#$%#')
+      u.config_templates_valid?.should be_false
     end
   end
 
   describe '#upload_config_templates' do
     it 'raises error if any config template fails validation' do
-      allow(subject).to receive(:config_templates_valid?).and_return(false)
+      u.stub(:config_templates_valid?).and_return(false)
       expect {
-        subject.upload_config_templates
+        u.upload_config_templates
       }.to raise_error(Automan::Beanstalk::InvalidConfigurationTemplateError)
     end
 
     it 'uploads files if they are valid' do
-      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
+      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
     end
   end
 end

data/spec/beanstalk/version_spec.rb

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

data/spec/cloudformation/launcher_spec.rb

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

data/spec/cloudformation/replacer_spec.rb

@@ -1,15 +1,15 @@
 require 'automan'
 
 describe Automan::Cloudformation::Replacer do
-  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? }
+  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? }
 
   describe '#ok_to_replace_instances?' do
-    subject() do
+    subject(:r) do
       AWS.stub!
-      Automan::Cloudformation::Replacer.new
+      r = 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
-        expect(subject.ok_to_replace_instances?(state, Time.now)).to be_truthy
+        r.ok_to_replace_instances?(state, Time.now).should be_true
       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)
-        expect(subject.ok_to_replace_instances?(state, last_updated)).to be_falsey
+        r.ok_to_replace_instances?(state, last_updated).should be_false
       end
     end
 
     bad_states.each do |state|
       it "raises error when stack is borked (state: #{state})" do
         expect {
-          subject.ok_to_replace_instances?(state, Time.now)
+          r.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
-        expect(subject.ok_to_replace_instances?(state, Time.now)).to be_falsey
+        r.ok_to_replace_instances?(state, Time.now).should be_false
       end
     end
   end

data/spec/cloudformation/terminator_spec.rb

@@ -1,15 +1,15 @@
 require 'automan'
 
 describe Automan::Cloudformation::Terminator do
-  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 }
+  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 }
 
   describe '#terminate' do
-    subject() do
+    subject(:t) 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
-      allow(subject).to receive(:stack_exists?).and_return(true)
-      expect(subject).to receive :delete_stack
-      subject.terminate
+      t.stub(:stack_exists?).and_return(true)
+      t.should_receive :delete_stack
+      t.terminate
     end
 
     it 'should not call #delete_stack if the stack does not exist' do
-      allow(subject).to receive(:stack_exists?).and_return(false)
-      expect(subject).to_not receive :delete_stack
-      subject.terminate
+      t.stub(:stack_exists?).and_return(false)
+      t.should_not_receive :delete_stack
+      t.terminate
     end
   end
 
   describe '#stack_deleted?' do
-    subject() do
+    subject(:t) 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
-      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
+      t.stub(:stack_exists?).and_return(false)
+      t.stub(:stack_status).and_raise StandardError
+      t.stack_deleted?('foo').should be_true
     end
 
     it 'returns true when status is DELETE_COMPLETE' do
-      allow(subject).to receive(:stack_status).and_return('DELETE_COMPLETE')
-      expect(subject.stack_deleted?('foo')).to be_truthy
+      t.stub(:stack_status).and_return('DELETE_COMPLETE')
+      t.stack_deleted?('foo').should be_true
     end
 
     it 'raises an error when the delete fails' do
-      allow(subject).to receive(:stack_status).and_return('DELETE_FAILED')
+      t.stub(:stack_status).and_return('DELETE_FAILED')
       expect {
-        subject.stack_deleted?('foo')
+        t.stack_deleted?('foo')
       }.to raise_error Automan::Cloudformation::StackDeletionError
     end
 
     it 'returns false for any other status' do
-      allow(subject).to receive(:stack_status).and_return('foo')
-      expect(subject.stack_deleted?('foo')).to be_falsey
+      t.stub(:stack_status).and_return('foo')
+      t.stack_deleted?('foo').should be_false
     end
   end
 end