automan 2.3.1 → 2.3.2

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

data/spec/ec2/image_spec.rb

@@ -2,37 +2,37 @@ require 'automan'
 require 'logger'
 
 describe Automan::Ec2::Image do
-  it { should respond_to :ec2 }
-  it { should respond_to :create }
-  it { should respond_to :prune }
-  it { should respond_to :default_image_name }
-  it { should respond_to :image_snapshot_exists? }
-  it { should respond_to :image_snapshot }
-  it { should respond_to :delete_snapshots }
-  it { should respond_to :is_more_than_month_old? }
+  it { is_expected.to respond_to :ec2 }
+  it { is_expected.to respond_to :create }
+  it { is_expected.to respond_to :prune }
+  it { is_expected.to respond_to :default_image_name }
+  it { is_expected.to respond_to :image_snapshot_exists? }
+  it { is_expected.to respond_to :image_snapshot }
+  it { is_expected.to respond_to :delete_snapshots }
+  it { is_expected.to respond_to :is_more_than_month_old? }
 
   describe '#default_image_name' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:name).and_return('skee-lo')
+      allow(s).to receive(:name).and_return('skee-lo')
       s
     end
 
     it "never returns nil" do
-      s.default_image_name().should_not be_nil
+      expect(subject.default_image_name()).to_not be_nil
     end
 
     it "returns name dash iso8601 string" do
-      name = s.default_image_name()
-      name.should match /^skee-lo-(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})[+-](\d{2})-(\d{2})/
+      name = subject.default_image_name()
+      expect(name).to match /^skee-lo-(\d{4})-(\d{2})-(\d{2})T(\d{2})(\d{2})(\d{2})Z/
     end
 
   end
 
   describe '#image_snapshot' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
@@ -41,31 +41,31 @@ describe Automan::Ec2::Image do
 
     it "returns id if the snapshot exists" do
       fake_ami = double("ami")
-      fake_ami.stub(:block_devices) { [ { ebs: {snapshot_id: 'foo' } } ] }
-      s.image_snapshot(fake_ami).should eq('foo')
+      allow(fake_ami).to receive(:block_devices) { [ { ebs: {snapshot_id: 'foo' } } ] }
+      expect(subject.image_snapshot(fake_ami)).to eq('foo')
     end
 
     it "returns nil if the snapshot is nil" do
       fake_ami = double("ami")
-      fake_ami.stub(:block_devices) { [ { ebs: {snapshot_id: nil } } ] }
-      s.image_snapshot(fake_ami).should be_nil
+      allow(fake_ami).to receive(:block_devices) { [ { ebs: {snapshot_id: nil } } ] }
+      expect(subject.image_snapshot(fake_ami)).to be_nil
     end
 
     it "returns nil if the ebs is nil" do
       fake_ami = double("ami")
-      fake_ami.stub(:block_devices) { [ { ebs: nil } ] }
-      s.image_snapshot(fake_ami).should be_nil
+      allow(fake_ami).to receive(:block_devices) { [ { ebs: nil } ] }
+      expect(subject.image_snapshot(fake_ami)).to be_nil
     end
 
     it "returns nil if the device is nil" do
       fake_ami = double("ami")
-      fake_ami.stub(:block_devices) { [ nil ] }
-      s.image_snapshot(fake_ami).should be_nil
+      allow(fake_ami).to receive(:block_devices) { [ nil ] }
+      expect(subject.image_snapshot(fake_ami)).to be_nil
     end
   end
 
   describe '#delete_snapshots' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
@@ -74,67 +74,67 @@ describe Automan::Ec2::Image do
 
     it 'does not delete snapshots with status != :completed' do
       snapshot = double(:snapshot)
-      snapshot.stub(:status).and_return(:foo)
-      snapshot.stub(:id)
-      snapshot.should_not_receive(:delete)
-      s.delete_snapshots( [ snapshot ])
+      allow(snapshot).to receive(:status).and_return(:foo)
+      allow(snapshot).to receive(:id)
+      expect(snapshot).to_not receive(:delete)
+      subject.delete_snapshots( [ snapshot ])
     end
 
     it 'deletes snapshots with status == :completed' do
       snapshot = double(:snapshot)
-      snapshot.stub(:status).and_return(:completed)
-      snapshot.stub(:id)
-      snapshot.should_receive(:delete)
-      s.delete_snapshots( [ snapshot ])
+      allow(snapshot).to receive(:status).and_return(:completed)
+      allow(snapshot).to receive(:id)
+      expect(snapshot).to receive(:delete)
+      subject.delete_snapshots( [ snapshot ])
     end
   end
 
   describe '#deregister_images' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
-      s.stub(:image_snapshot).and_return('foo')
+      allow(s).to receive(:image_snapshot).and_return('foo')
       s
     end
 
     before(:each) do
       @image = double(:image)
-      @image.stub(:id)
-      s.stub(:my_images).and_return( [ @image ] )
+      allow(@image).to receive(:id)
+      allow(subject).to receive(:my_images).and_return( [ @image ] )
     end
 
     it 'does not deregister images with state != :available' do
-      @image.stub(:state).and_return(:foo)
-      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
-      @image.should_not_receive(:delete)
-      s.deregister_images( [ 'foo' ] )
+      allow(@image).to receive(:state).and_return(:foo)
+      allow(@image).to receive(:tags).and_return( {'CanPrune' => 'yes'} )
+      expect(@image).to_not receive(:delete)
+      subject.deregister_images( [ 'foo' ] )
     end
 
     it 'does not deregister images w/o prunable tag' do
-      @image.stub(:state).and_return(:available)
-      @image.stub(:tags).and_return( Hash.new )
-      @image.should_not_receive(:delete)
-      s.deregister_images( [ 'foo' ] )
+      allow(@image).to receive(:state).and_return(:available)
+      allow(@image).to receive(:tags).and_return( Hash.new )
+      expect(@image).to_not receive(:delete)
+      subject.deregister_images( [ 'foo' ] )
     end
 
     it 'does not deregister images whose snapshots are not in the list' do
-      @image.stub(:state).and_return(:available)
-      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
-      @image.should_not_receive(:delete)
-      s.deregister_images( [ 'bar' ] )
+      allow(@image).to receive(:state).and_return(:available)
+      allow(@image).to receive(:tags).and_return( {'CanPrune' => 'yes'} )
+      expect(@image).to_not receive(:delete)
+      subject.deregister_images( [ 'bar' ] )
     end
 
     it 'deletes available, prunable images on the list' do
-      @image.stub(:state).and_return(:available)
-      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
-      @image.should_receive(:delete)
-      s.deregister_images( [ 'foo' ] )
+      allow(@image).to receive(:state).and_return(:available)
+      allow(@image).to receive(:tags).and_return( {'CanPrune' => 'yes'} )
+      expect(@image).to receive(:delete)
+      subject.deregister_images( [ 'foo' ] )
     end
   end
 
   describe '#is_more_than_month_old?' do
-    subject(:s) do
+    subject() do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
@@ -142,17 +142,17 @@ describe Automan::Ec2::Image do
     end
 
     it 'returns false if argument is not a Time object' do
-      s.is_more_than_month_old?(Object.new).should be_false
+      expect(subject.is_more_than_month_old?(Object.new)).to be_falsey
     end
 
     it 'returns true if time is more than 30 days in the past' do
       days_of_yore = Time.now - (60*60*24*30)
-      s.is_more_than_month_old?(days_of_yore).should be_true
+      expect(subject.is_more_than_month_old?(days_of_yore)).to be_truthy
     end
 
     it 'returns false if time is in the last 30 days' do
       just_yesterday = Time.now - (60*60*24)
-      s.is_more_than_month_old?(just_yesterday).should be_false
+      expect(subject.is_more_than_month_old?(just_yesterday)).to be_falsey
     end
   end
 end

data/spec/ec2/instance_spec.rb

@@ -2,14 +2,14 @@ require "automan"
 
 describe Automan::Ec2::Instance do
 
-  it { should respond_to :windows_password }
-  it { should respond_to :password_data }
-  it { should respond_to :decrypt_password }
-  it { should respond_to :windows_name }
-  it { should respond_to :show_env }
+  it { is_expected.to respond_to :windows_password }
+  it { is_expected.to respond_to :password_data }
+  it { is_expected.to respond_to :decrypt_password }
+  it { is_expected.to respond_to :windows_name }
+  it { is_expected.to respond_to :show_env }
 
   describe '#windows_password' do
-    subject(:i) do
+    subject() do
       AWS.stub!
       i = Automan::Ec2::Instance.new
       i.logger = Logger.new('/dev/null')
@@ -17,24 +17,24 @@ describe Automan::Ec2::Instance do
     end
 
     it "returns nil if password could not be found" do
-      i.stub(:password_data).and_return nil
-      i.windows_password('foo','bar').should be_nil
+      allow(subject).to receive(:password_data).and_return nil
+      expect(subject.windows_password('foo','bar')).to be_nil
     end
 
     it "returns nil if the aws request fails" do
-      i.stub(:password_data).and_raise Automan::Ec2::RequestFailedError
-      i.windows_password('foo','bar').should be_nil
+      allow(subject).to receive(:password_data).and_raise Automan::Ec2::RequestFailedError
+      expect(subject.windows_password('foo','bar')).to be_nil
     end
 
     it "returns nil if the decrypt fails" do
-      i.stub(:password_data).and_return 'foo'
-      i.stub(:decrypt_password).and_return nil
-      i.windows_password('foo','bar').should be_nil
+      allow(subject).to receive(:password_data).and_return 'foo'
+      allow(subject).to receive(:decrypt_password).and_return nil
+      expect(subject.windows_password('foo','bar')).to be_nil
     end
   end
 
   describe '#windows_name' do
-    subject(:i) do
+    subject() do
       AWS.stub!
       i = Automan::Ec2::Instance.new
       i.logger = Logger.new('/dev/null')
@@ -42,15 +42,15 @@ describe Automan::Ec2::Instance do
     end
 
     it "returns nil if ip_address is nil" do
-      i.windows_name(nil).should be_nil
+      expect(subject.windows_name(nil)).to be_nil
     end
 
     it "returns nil if ip_address is empty" do
-      i.windows_name("").should be_nil
+      expect(subject.windows_name("")).to be_nil
     end
 
     it "converts ip_address to ip-xxxxxxxx" do
-      i.windows_name('54.56.78.90').should eq 'ip-36384e5a'
+      expect(subject.windows_name('54.56.78.90')).to eq 'ip-36384e5a'
     end
   end
 

data/spec/mixins/aws_caller_spec.rb

@@ -1,39 +1,39 @@
 require 'automan/mixins/aws_caller'
 
 describe Automan::Mixins::AwsCaller do
-  let(:s) { (Class.new { include Automan::Mixins::AwsCaller }).new }
+  subject() { (Class.new { include Automan::Mixins::AwsCaller }).new }
 
   services = [
     :s3, :cfn, :as, :eb, :r53, :elb, :rds, :ec2
   ]
 
   services.each do |svc|
-    it { s.should respond_to svc }
+    it { is_expected.to respond_to svc }
   end
 
-  it { s.should respond_to :parse_s3_path }
+  it { is_expected.to respond_to :parse_s3_path }
 
   describe '#parse_s3_path' do
     it "parses s3 path into bucket and key" do
-      bucket, key = s.parse_s3_path('s3://foo/bar/baz')
-      bucket.should eq('foo')
-      key.should eq ('bar/baz')
+      bucket, key = subject.parse_s3_path('s3://foo/bar/baz')
+      expect(bucket).to eq('foo')
+      expect(key).to eq ('bar/baz')
     end
 
     it "raises error if it doesn't start with s3://" do
       expect {
-        s.parse_s3_path 'foo'
+        subject.parse_s3_path 'foo'
       }.to raise_error ArgumentError
     end
   end
 
   describe '#looks_like_s3_path?' do
     it 'returns true if it begins with "s3://"' do
-      s.looks_like_s3_path?('s3://foo').should be_true
+      expect(subject.looks_like_s3_path?('s3://foo')).to be_truthy
     end
 
     it 'returns false if it does not start with "s3://"' do
-      s.looks_like_s3_path?('foobar').should be_false
+      expect(subject.looks_like_s3_path?('foobar')).to be_falsey
     end
   end
 end