automan 2.3.5 → 2.3.6

data/spec/cloudformation/uploader_spec.rb

@@ -1,11 +1,11 @@
 require 'automan'
 
 describe Automan::Cloudformation::Uploader do
-  subject() do
+  subject(:u) do
     AWS.stub!
     u = Automan::Cloudformation::Uploader.new
     u.logger = Logger.new('/dev/null')
-    allow(u).to receive(:templates).and_return(%w[a b c])
+    u.stub(: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
-      allow(subject).to receive(:templates).and_return([])
+      u.stub(:templates).and_return([])
       expect {
-        subject.all_templates_valid?
+        u.all_templates_valid?
       }.to raise_error Automan::Cloudformation::NoTemplatesError
     end
 
     it 'returns true if templates are valid' do
-      expect(subject).to receive(:template_valid?).exactly(3).times.and_return(true)
-      expect(subject.all_templates_valid?).to be_truthy
+      u.should_receive(:template_valid?).exactly(3).times.and_return(true)
+      u.all_templates_valid?.should be_true
     end
 
     it 'returns false if any templates are invalid' do
-      allow(subject).to receive(:template_valid?).and_return(false)
-      expect(subject.all_templates_valid?).to be_falsey
+      u.stub(:template_valid?).and_return(false)
+      u.all_templates_valid?.should be_false
     end
   end
 
   describe '#upload_templates' do
     it 'raises error if any template fails validation' do
-      allow(subject).to receive(:all_templates_valid?).and_return(false)
+      u.stub(:all_templates_valid?).and_return(false)
       expect {
-        subject.upload_templates
+        u.upload_templates
       }.to raise_error(Automan::Cloudformation::InvalidTemplateError)
     end
 
     it 'uploads files if all are valid' do
-      allow(subject).to receive(:all_templates_valid?).and_return(true)
-      expect(subject).to receive(:upload_file).exactly(3).times
-      subject.upload_templates
+      u.stub(:all_templates_valid?).and_return(true)
+      u.should_receive(:upload_file).exactly(3).times
+      u.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 { 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? }
+  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? }
 
   describe '#default_image_name' do
-    subject() do
+    subject(:s) do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
-      allow(s).to receive(:name).and_return('skee-lo')
+      s.stub(:name).and_return('skee-lo')
       s
     end
 
     it "never returns nil" do
-      expect(subject.default_image_name()).to_not be_nil
+      s.default_image_name().should_not be_nil
     end
 
     it "returns name dash iso8601 string" do
-      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/
+      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})/
     end
 
   end
 
   describe '#image_snapshot' do
-    subject() do
+    subject(:s) 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")
-      allow(fake_ami).to receive(:block_devices) { [ { ebs: {snapshot_id: 'foo' } } ] }
-      expect(subject.image_snapshot(fake_ami)).to eq('foo')
+      fake_ami.stub(:block_devices) { [ { ebs: {snapshot_id: 'foo' } } ] }
+      s.image_snapshot(fake_ami).should eq('foo')
     end
 
     it "returns nil if the snapshot is nil" do
       fake_ami = double("ami")
-      allow(fake_ami).to receive(:block_devices) { [ { ebs: {snapshot_id: nil } } ] }
-      expect(subject.image_snapshot(fake_ami)).to be_nil
+      fake_ami.stub(:block_devices) { [ { ebs: {snapshot_id: nil } } ] }
+      s.image_snapshot(fake_ami).should be_nil
     end
 
     it "returns nil if the ebs is nil" do
       fake_ami = double("ami")
-      allow(fake_ami).to receive(:block_devices) { [ { ebs: nil } ] }
-      expect(subject.image_snapshot(fake_ami)).to be_nil
+      fake_ami.stub(:block_devices) { [ { ebs: nil } ] }
+      s.image_snapshot(fake_ami).should be_nil
     end
 
     it "returns nil if the device is nil" do
       fake_ami = double("ami")
-      allow(fake_ami).to receive(:block_devices) { [ nil ] }
-      expect(subject.image_snapshot(fake_ami)).to be_nil
+      fake_ami.stub(:block_devices) { [ nil ] }
+      s.image_snapshot(fake_ami).should be_nil
     end
   end
 
   describe '#delete_snapshots' do
-    subject() do
+    subject(:s) 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)
-      allow(snapshot).to receive(:status).and_return(:foo)
-      allow(snapshot).to receive(:id)
-      expect(snapshot).to_not receive(:delete)
-      subject.delete_snapshots( [ snapshot ])
+      snapshot.stub(:status).and_return(:foo)
+      snapshot.stub(:id)
+      snapshot.should_not_receive(:delete)
+      s.delete_snapshots( [ snapshot ])
     end
 
     it 'deletes snapshots with status == :completed' do
       snapshot = double(:snapshot)
-      allow(snapshot).to receive(:status).and_return(:completed)
-      allow(snapshot).to receive(:id)
-      expect(snapshot).to receive(:delete)
-      subject.delete_snapshots( [ snapshot ])
+      snapshot.stub(:status).and_return(:completed)
+      snapshot.stub(:id)
+      snapshot.should_receive(:delete)
+      s.delete_snapshots( [ snapshot ])
     end
   end
 
   describe '#deregister_images' do
-    subject() do
+    subject(:s) do
       AWS.stub!
       s = Automan::Ec2::Image.new
       s.logger = Logger.new('/dev/null')
-      allow(s).to receive(:image_snapshot).and_return('foo')
+      s.stub(:image_snapshot).and_return('foo')
       s
     end
 
     before(:each) do
       @image = double(:image)
-      allow(@image).to receive(:id)
-      allow(subject).to receive(:my_images).and_return( [ @image ] )
+      @image.stub(:id)
+      s.stub(:my_images).and_return( [ @image ] )
     end
 
     it 'does not deregister images with state != :available' do
-      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' ] )
+      @image.stub(:state).and_return(:foo)
+      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
+      @image.should_not_receive(:delete)
+      s.deregister_images( [ 'foo' ] )
     end
 
     it 'does not deregister images w/o prunable tag' do
-      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' ] )
+      @image.stub(:state).and_return(:available)
+      @image.stub(:tags).and_return( Hash.new )
+      @image.should_not_receive(:delete)
+      s.deregister_images( [ 'foo' ] )
     end
 
     it 'does not deregister images whose snapshots are not in the list' do
-      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' ] )
+      @image.stub(:state).and_return(:available)
+      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
+      @image.should_not_receive(:delete)
+      s.deregister_images( [ 'bar' ] )
     end
 
     it 'deletes available, prunable images on the list' do
-      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' ] )
+      @image.stub(:state).and_return(:available)
+      @image.stub(:tags).and_return( {'CanPrune' => 'yes'} )
+      @image.should_receive(:delete)
+      s.deregister_images( [ 'foo' ] )
     end
   end
 
   describe '#is_more_than_month_old?' do
-    subject() do
+    subject(:s) 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
-      expect(subject.is_more_than_month_old?(Object.new)).to be_falsey
+      s.is_more_than_month_old?(Object.new).should be_false
     end
 
     it 'returns true if time is more than 30 days in the past' do
       days_of_yore = Time.now - (60*60*24*30)
-      expect(subject.is_more_than_month_old?(days_of_yore)).to be_truthy
+      s.is_more_than_month_old?(days_of_yore).should be_true
     end
 
     it 'returns false if time is in the last 30 days' do
       just_yesterday = Time.now - (60*60*24)
-      expect(subject.is_more_than_month_old?(just_yesterday)).to be_falsey
+      s.is_more_than_month_old?(just_yesterday).should be_false
     end
   end
 end

data/spec/ec2/instance_spec.rb

@@ -2,14 +2,14 @@ require "automan"
 
 describe Automan::Ec2::Instance do
 
-  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 }
+  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 }
 
   describe '#windows_password' do
-    subject() do
+    subject(:i) 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
-      allow(subject).to receive(:password_data).and_return nil
-      expect(subject.windows_password('foo','bar')).to be_nil
+      i.stub(:password_data).and_return nil
+      i.windows_password('foo','bar').should be_nil
     end
 
     it "returns nil if the aws request fails" do
-      allow(subject).to receive(:password_data).and_raise Automan::Ec2::RequestFailedError
-      expect(subject.windows_password('foo','bar')).to be_nil
+      i.stub(:password_data).and_raise Automan::Ec2::RequestFailedError
+      i.windows_password('foo','bar').should be_nil
     end
 
     it "returns nil if the decrypt fails" do
-      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
+      i.stub(:password_data).and_return 'foo'
+      i.stub(:decrypt_password).and_return nil
+      i.windows_password('foo','bar').should be_nil
     end
   end
 
   describe '#windows_name' do
-    subject() do
+    subject(:i) 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
-      expect(subject.windows_name(nil)).to be_nil
+      i.windows_name(nil).should be_nil
     end
 
     it "returns nil if ip_address is empty" do
-      expect(subject.windows_name("")).to be_nil
+      i.windows_name("").should be_nil
     end
 
     it "converts ip_address to ip-xxxxxxxx" do
-      expect(subject.windows_name('54.56.78.90')).to eq 'ip-36384e5a'
+      i.windows_name('54.56.78.90').should 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
-  subject() { (Class.new { include Automan::Mixins::AwsCaller }).new }
+  let(:s) { (Class.new { include Automan::Mixins::AwsCaller }).new }
 
   services = [
     :s3, :cfn, :as, :eb, :r53, :elb, :rds, :ec2
   ]
 
   services.each do |svc|
-    it { is_expected.to respond_to svc }
+    it { s.should respond_to svc }
   end
 
-  it { is_expected.to respond_to :parse_s3_path }
+  it { s.should respond_to :parse_s3_path }
 
   describe '#parse_s3_path' do
     it "parses s3 path into bucket and key" do
-      bucket, key = subject.parse_s3_path('s3://foo/bar/baz')
-      expect(bucket).to eq('foo')
-      expect(key).to eq ('bar/baz')
+      bucket, key = s.parse_s3_path('s3://foo/bar/baz')
+      bucket.should eq('foo')
+      key.should eq ('bar/baz')
     end
 
     it "raises error if it doesn't start with s3://" do
       expect {
-        subject.parse_s3_path 'foo'
+        s.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
-      expect(subject.looks_like_s3_path?('s3://foo')).to be_truthy
+      s.looks_like_s3_path?('s3://foo').should be_true
     end
 
     it 'returns false if it does not start with "s3://"' do
-      expect(subject.looks_like_s3_path?('foobar')).to be_falsey
+      s.looks_like_s3_path?('foobar').should be_false
     end
   end
 end

data/spec/mixins/utils_spec.rb

@@ -1,43 +1,44 @@
 require 'automan/mixins/utils'
 
 describe Automan::Mixins::Utils do
-  subject() { (Class.new { include Automan::Mixins::Utils }).new }
+  let(:s) { (Class.new { include Automan::Mixins::Utils }).new }
 
   it "adds String#underscore" do
-    expect(String.new).to respond_to :underscore
+    s = String.new
+    s.should respond_to :underscore
   end
 
   describe "String#underscore" do
     it "underscore's like a boss" do
-      expect("Namespace".underscore).to eq "namespace"
-      expect("OptionName".underscore).to eq "option_name"
-      expect("Value".underscore).to eq "value"
+      "Namespace".underscore.should eq "namespace"
+      "OptionName".underscore.should eq "option_name"
+      "Value".underscore.should eq "value"
     end
   end
 
-  it { is_expected.to respond_to :region_from_az }
+  it { s.should respond_to :region_from_az }
 
   it "returns az properly" do
-    expect(subject.region_from_az("us-east-1a")).to eq 'us-east-1'
-    expect(subject.region_from_az("us-east-1b")).to eq 'us-east-1'
-    expect(subject.region_from_az("us-east-1c")).to eq 'us-east-1'
-    expect(subject.region_from_az("us-east-1d")).to eq 'us-east-1'
-    expect(subject.region_from_az("ap-northeast-1a")).to eq 'ap-northeast-1'
-    expect(subject.region_from_az("ap-northeast-1b")).to eq 'ap-northeast-1'
-    expect(subject.region_from_az("ap-northeast-1c")).to eq 'ap-northeast-1'
-    expect(subject.region_from_az("sa-east-1a")).to eq 'sa-east-1'
-    expect(subject.region_from_az("sa-east-1b")).to eq 'sa-east-1'
-    expect(subject.region_from_az("ap-southeast-1a")).to eq 'ap-southeast-1'
-    expect(subject.region_from_az("ap-southeast-1b")).to eq 'ap-southeast-1'
-    expect(subject.region_from_az("ap-southeast-2a")).to eq 'ap-southeast-2'
-    expect(subject.region_from_az("ap-southeast-2b")).to eq 'ap-southeast-2'
-    expect(subject.region_from_az("us-west-2a")).to eq 'us-west-2'
-    expect(subject.region_from_az("us-west-2b")).to eq 'us-west-2'
-    expect(subject.region_from_az("us-west-2c")).to eq 'us-west-2'
-    expect(subject.region_from_az("us-west-1a")).to eq 'us-west-1'
-    expect(subject.region_from_az("us-west-1c")).to eq 'us-west-1'
-    expect(subject.region_from_az("eu-west-1a")).to eq 'eu-west-1'
-    expect(subject.region_from_az("eu-west-1b")).to eq 'eu-west-1'
-    expect(subject.region_from_az("eu-west-1c")).to eq 'eu-west-1'
+    s.region_from_az("us-east-1a").should eq 'us-east-1'
+    s.region_from_az("us-east-1b").should eq 'us-east-1'
+    s.region_from_az("us-east-1c").should eq 'us-east-1'
+    s.region_from_az("us-east-1d").should eq 'us-east-1'
+    s.region_from_az("ap-northeast-1a").should eq 'ap-northeast-1'
+    s.region_from_az("ap-northeast-1b").should eq 'ap-northeast-1'
+    s.region_from_az("ap-northeast-1c").should eq 'ap-northeast-1'
+    s.region_from_az("sa-east-1a").should eq 'sa-east-1'
+    s.region_from_az("sa-east-1b").should eq 'sa-east-1'
+    s.region_from_az("ap-southeast-1a").should eq 'ap-southeast-1'
+    s.region_from_az("ap-southeast-1b").should eq 'ap-southeast-1'
+    s.region_from_az("ap-southeast-2a").should eq 'ap-southeast-2'
+    s.region_from_az("ap-southeast-2b").should eq 'ap-southeast-2'
+    s.region_from_az("us-west-2a").should eq 'us-west-2'
+    s.region_from_az("us-west-2b").should eq 'us-west-2'
+    s.region_from_az("us-west-2c").should eq 'us-west-2'
+    s.region_from_az("us-west-1a").should eq 'us-west-1'
+    s.region_from_az("us-west-1c").should eq 'us-west-1'
+    s.region_from_az("eu-west-1a").should eq 'eu-west-1'
+    s.region_from_az("eu-west-1b").should eq 'eu-west-1'
+    s.region_from_az("eu-west-1c").should eq 'eu-west-1'
   end
 end