automan 2.3.1 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e7edc999dc7f9d16861752be4e638d3a38d83a0b
-  data.tar.gz: 41de5287e9f7400481c7448316db256612460c60
+  metadata.gz: 3d5223742567c1e2f6a4d8d4acce6b217b5274b4
+  data.tar.gz: ee52d65bf8bc91b45e6252ecc1c166f214182c35
 SHA512:
-  metadata.gz: 41686b788d734907ead2919efec9c69fbe3e062fddf8a5ce2efab1fcaac92341450e9179bc3f405fbcfdea868df6362c930acb0ee4645c87c93d6c1a969b7ed2
-  data.tar.gz: 82ff62c8fc0f0ce9415b8a9f05ff6f8e749bb1b2833de5527dff1499b41d0cd0427af085a0cacbfba34a2868a5d8b574b15badbff93e869c913b5f8383437cd2
+  metadata.gz: 8243eb955f0b5c3d4fd01c029767454dc4964cc3eb47cd805237e12ebd02bdfecf6a9329cbf5c38d07bfe40aecda27c5f5ea6160e1f11748588208e11b08a4e1
+  data.tar.gz: 406c82dd210f316967ae942c17b6151c57aeb2c372944612632a5e4f851b412e91b9ecf966255d4ff6c6fd56ba343a447889701ea777074d6a1638543f3a73bb

data/.ruby-gemset

@@ -0,0 +1 @@
+automan

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.2

data/automan.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec-core", "~> 2.12.2"
-  spec.add_development_dependency "rspec-mocks", "~> 2.12.2"
-  spec.add_development_dependency "rspec-expectations", "~> 2.12.1"
+  spec.add_development_dependency "rspec-core", "~> 3"
+  spec.add_development_dependency "rspec-mocks", "~> 3"
+  spec.add_development_dependency "rspec-expectations", "~> 3"
   spec.add_dependency "aws-sdk", "< 2.0"
   spec.add_dependency "thor"
   spec.add_dependency "json"

data/lib/automan/version.rb

@@ -1,3 +1,3 @@
 module Automan
-  VERSION = "2.3.1"
+  VERSION = "2.3.2"
 end

data/spec/beanstalk/application_spec.rb

@@ -1,12 +1,12 @@
 require "automan"
 
 describe Automan::Beanstalk::Application do
-  it { should respond_to :name }
-  it { should respond_to :create }
-  it { should respond_to :delete }
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :create }
+  it { is_expected.to respond_to :delete }
 
   describe '#create' do
-    subject(:a) do
+    subject() do
       AWS.stub!
       a = Automan::Beanstalk::Application.new
       a.logger = Logger.new('/dev/null')
@@ -14,20 +14,20 @@ describe Automan::Beanstalk::Application do
     end
 
     it "does not create if the application already exists" do
-      a.stub(:application_exists?).and_return(true)
-      a.should_not_receive(:create_application)
-      a.create
+      allow(subject).to receive(:application_exists?).and_return(true)
+      expect(subject).to_not receive(:create_application)
+      subject.create
     end
 
     it "does create if the application doesn't exist" do
-      a.stub(:application_exists?).and_return(false)
-      a.should_receive(:create_application)
-      a.create
+      allow(subject).to receive(:application_exists?).and_return(false)
+      expect(subject).to receive(:create_application)
+      subject.create
     end
   end
 
   describe '#delete' do
-    subject(:a) do
+    subject() do
       AWS.stub!
       a = Automan::Beanstalk::Application.new
       a.logger = Logger.new('/dev/null')
@@ -35,15 +35,15 @@ describe Automan::Beanstalk::Application do
     end
 
     it "does delete if the application already exists" do
-      a.stub(:application_exists?).and_return(true)
-      a.should_receive(:delete_application)
-      a.delete
+      allow(subject).to receive(:application_exists?).and_return(true)
+      expect(subject).to receive(:delete_application)
+      subject.delete
     end
 
     it "does not delete if the application doesn't exist" do
-      a.stub(:application_exists?).and_return(false)
-      a.should_not_receive(:delete_application)
-      a.delete
+      allow(subject).to receive(:application_exists?).and_return(false)
+      expect(subject).to_not receive(:delete_application)
+      subject.delete
     end
   end
 end

data/spec/beanstalk/configuration_spec.rb

@@ -23,10 +23,10 @@ describe Automan::Beanstalk::Configuration do
   describe '#config_template_exists?' do
 
     it 'returns false if raises InvalidParameterValue with missing config template message' do
-      c.eb = double(:eb)
       error = AWS::ElasticBeanstalk::Errors::InvalidParameterValue.new('No Configuration Template named')
-      c.eb.stub(:describe_configuration_settings).and_raise(error)
-      c.config_template_exists?.should be_false
+      subject.eb = double()
+      allow(subject.eb).to receive(:describe_configuration_settings).and_raise(error)
+      expect(subject.config_template_exists?).to be_falsey
     end
   end
 
@@ -48,51 +48,51 @@ describe Automan::Beanstalk::Configuration do
         }
       ]
 
-      c.fix_config_keys(config_before).should eq(config_after)
+      expect(subject.fix_config_keys(config_before)).to eq(config_after)
     end
   end
 
   describe '#create' do
     it 'does not create if configuration exists' do
-      c.stub(:config_template_exists?).and_return(true)
-      c.should_not_receive(:create_config_template)
-      c.create
+      allow(subject).to receive(:config_template_exists?).and_return(true)
+      expect(subject).to_not receive(:create_config_template)
+      subject.create
     end
 
     it 'does create if configuration does not exist' do
-      c.stub(:config_template_exists?).and_return(false)
-      c.should_receive(:create_config_template)
-      c.create
+      allow(subject).to receive(:config_template_exists?).and_return(false)
+      expect(subject).to receive(:create_config_template)
+      subject.create
     end
   end
 
   describe '#delete' do
     it 'does delete if configuration exists' do
-      c.stub(:config_template_exists?).and_return(true)
-      c.should_receive(:delete_config_template)
-      c.delete
+      allow(subject).to receive(:config_template_exists?).and_return(true)
+      expect(subject).to receive(:delete_config_template)
+      subject.delete
     end
 
     it 'does not delete if configuration does not exist' do
-      c.stub(:config_template_exists?).and_return(false)
-      c.should_not_receive(:delete_config_template)
-      c.delete
+      allow(subject).to receive(:config_template_exists?).and_return(false)
+      expect(subject).to_not receive(:delete_config_template)
+      subject.delete
     end
   end
 
   describe '#update' do
     it 'deletes configuration and recreates it if it exists' do
-      c.stub(:config_template_exists?).and_return(true)
-      c.should_receive(:delete_config_template)
-      c.should_receive(:create_config_template)
-      c.update
+      allow(subject).to receive(:config_template_exists?).and_return(true)
+      expect(subject).to receive(:delete_config_template)
+      expect(subject).to receive(:create_config_template)
+      subject.update
     end
 
     it 'does not try to delete configuration if it does not exist' do
-      c.stub(:config_template_exists?).and_return(false)
-      c.should_not_receive(:delete_config_template)
-      c.should_receive(:create_config_template)
-      c.update
+      allow(subject).to receive(:config_template_exists?).and_return(false)
+      expect(subject).to_not receive(:delete_config_template)
+      expect(subject).to receive(:create_config_template)
+      subject.update
     end
   end
 end

data/spec/beanstalk/deployer_spec.rb

@@ -2,59 +2,59 @@ require "automan"
 
 describe Automan::Beanstalk::Deployer do
 
-  it { should respond_to :name }
-  it { should respond_to :version_label }
-  it { should respond_to :package }
-  it { should respond_to :environment }
-  it { should respond_to :manifest }
-  it { should respond_to :read_manifest }
-  it { should respond_to :manifest_exists? }
-  it { should respond_to :package_exists? }
-  it { should respond_to :environment_status }
-  it { should respond_to :configuration_template }
-  it { should respond_to :deploy }
-  it { should respond_to :update_environment }
-  it { should respond_to :create_environment }
+  it { is_expected.to respond_to :name }
+  it { is_expected.to respond_to :version_label }
+  it { is_expected.to respond_to :package }
+  it { is_expected.to respond_to :environment }
+  it { is_expected.to respond_to :manifest }
+  it { is_expected.to respond_to :read_manifest }
+  it { is_expected.to respond_to :manifest_exists? }
+  it { is_expected.to respond_to :package_exists? }
+  it { is_expected.to respond_to :environment_status }
+  it { is_expected.to respond_to :configuration_template }
+  it { is_expected.to respond_to :deploy }
+  it { is_expected.to respond_to :update_environment }
+  it { is_expected.to respond_to :create_environment }
 
   # Constraint: Must be from 4 to 23 characters in length.
   # The name can contain only letters, numbers, and hyphens.
   # It cannot start or end with a hyphen.
   describe '#eb_environment_name' do
-    subject(:bd) { Automan::Beanstalk::Deployer.new }
+    subject() { Automan::Beanstalk::Deployer.new }
 
     it "is at least 4 characters" do
-      bd.name = "a"
-      bd.environment = "a"
-      bd.eb_environment_name.length.should be >= 4
+      subject.name = "a"
+      subject.environment = "a"
+      expect(subject.eb_environment_name.length).to be >= 4
     end
 
     it "is no more than 23 characters" do
-      bd.name = "a" * 23
-      bd.environment = "dev"
-      bd.eb_environment_name.length.should be <= 23
+      subject.name = "a" * 23
+      subject.environment = "dev"
+      expect(subject.eb_environment_name.length).to be <= 23
     end
 
     it "contains only letters, numbers, and hyphens" do
-      bd.name = '@#$%^foo_bar!$%&&E.'
-      bd.environment = 'prod.baz'
-      bd.eb_environment_name.should match(/[a-z0-9-]+/)
+      subject.name = '@#$%^foo_bar!$%&&E.'
+      subject.environment = 'prod.baz'
+      expect(subject.eb_environment_name).to match(/[a-z0-9-]+/)
     end
 
     it "cannot start or end with a hyphen" do
-      bd.name = '--foo'
-      bd.environment = 'bar--'
-      bd.eb_environment_name.should match(/^[^-].*[^-]$/)
+      subject.name = '--foo'
+      subject.environment = 'bar--'
+      expect(subject.eb_environment_name).to match(/^[^-].*[^-]$/)
     end
 
     it "is still at least 4 characters even after removing restricted strings" do
-      bd.name = '--f'
-      bd.environment = '-'
-      bd.eb_environment_name.length.should be >= 4
+      subject.name = '--f'
+      subject.environment = '-'
+      expect(subject.eb_environment_name.length).to be >= 4
     end
   end
 
   describe '#read_manifest' do
-    subject(:d) do
+    subject() do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
@@ -62,23 +62,23 @@ describe Automan::Beanstalk::Deployer do
     end
 
     it 'raises MissingManifestError if the manifest is missing' do
-      d.stub(:manifest_exists?).and_return(false)
+      expect(subject).to receive(:manifest_exists?).and_return(false)
       expect {
-        d.read_manifest
+        subject.read_manifest
       }.to raise_error(Automan::Beanstalk::MissingManifestError)
     end
 
     it 'sets version_label and package properly' do
-      d.stub(:manifest_exists?).and_return(true)
-      d.stub(:s3_read).and_return('{"version_label": "foo", "package": "bar"}')
-      d.read_manifest
-      d.version_label.should eq('foo')
-      d.package.should eq('bar')
+      allow(subject).to receive(:manifest_exists?).and_return(true)
+      allow(subject).to receive(:s3_read).and_return('{"version_label": "foo", "package": "bar"}')
+      subject.read_manifest
+      expect(subject.version_label).to eq('foo')
+      expect(subject.package).to eq('bar')
     end
   end
 
   describe '#deploy' do
-    subject(:d) do
+    subject() do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
@@ -86,22 +86,22 @@ describe Automan::Beanstalk::Deployer do
     end
 
     it 'raises MissingPackageError if the package does not exist' do
-      d.stub(:package_exists?).and_return(false)
+      allow(subject).to receive(:package_exists?).and_return(false)
       expect {
-        d.deploy
+        subject.deploy
       }.to raise_error(Automan::Beanstalk::MissingPackageFileError)
     end
 
     it 'makes sure the application version and environment exists' do
-      d.stub(:package_exists?).and_return(true)
-      d.should_receive(:ensure_version_exists)
-      d.should_receive(:create_or_update_environment)
-      d.deploy
+      allow(subject).to receive(:package_exists?).and_return(true)
+      expect(subject).to receive(:ensure_version_exists)
+      expect(subject).to receive(:create_or_update_environment)
+      subject.deploy
     end
   end
 
   describe '#ensure_version_exists' do
-    subject(:d) do
+    subject() do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
@@ -109,51 +109,51 @@ describe Automan::Beanstalk::Deployer do
     end
 
     it 'creates version if it does not exist' do
-      version = double(:version)
-      version.stub(:exists?).and_return(false)
-      version.should_receive(:create)
-      d.stub(:get_version).and_return(version)
-      d.ensure_version_exists
+      version = double()
+      allow(version).to receive(:exists?).and_return(false)
+      expect(version).to receive(:create)
+      allow(subject).to receive(:get_version).and_return(version)
+      subject.ensure_version_exists
     end
 
     it 'does not create version if it exists' do
-      version = double(:version)
-      version.stub(:exists?).and_return(true)
-      version.should_not_receive(:create)
-      d.stub(:get_version).and_return(version)
-      d.ensure_version_exists
+      version = double()
+      allow(version).to receive(:exists?).and_return(true)
+      expect(version).to_not receive(:create)
+      allow(subject).to receive(:get_version).and_return(version)
+      subject.ensure_version_exists
     end
   end
 
   describe '#create_or_update_environment' do
-    subject(:d) do
+    subject() do
       AWS.stub!
       d = Automan::Beanstalk::Deployer.new
       d.logger = Logger.new('/dev/null')
-      d.stub(:ensure_version_exists)
+      allow(d).to receive(:ensure_version_exists)
       d
     end
 
     [nil, 'Terminated'].each do |state|
       it "creates environment if state is #{state.nil? ? 'nil' : state}" do
-        d.stub(:environment_status).and_return(state)
-        d.should_receive(:create_environment)
-        d.create_or_update_environment
+        allow(subject).to receive(:environment_status).and_return(state)
+        expect(subject).to receive(:create_environment)
+        subject.create_or_update_environment
       end
     end
 
     ['Ready'].each do |state|
       it "updates environment if state is #{state.nil? ? 'nil' : state}" do
-        d.stub(:environment_status).and_return(state)
-        d.should_receive(:update_environment)
-        d.create_or_update_environment
+        allow(subject).to receive(:environment_status).and_return(state)
+        expect(subject).to receive(:update_environment)
+        subject.create_or_update_environment
       end
     end
 
     it 'raises error if environment state is anything else' do
-      d.stub(:environment_status).and_return('foo')
+      allow(subject).to receive(:environment_status).and_return('foo')
       expect {
-        d.create_or_update_environment
+        subject.create_or_update_environment
       }.to raise_error(Automan::Beanstalk::InvalidEnvironmentStatusError)
     end
   end

data/spec/beanstalk/router_spec.rb

@@ -2,14 +2,14 @@ require 'automan'
 require 'wait'
 
 describe Automan::Beanstalk::Router do
-  it { should respond_to :run }
-  it { should respond_to :environment_name }
-  it { should respond_to :hosted_zone_name }
-  it { should respond_to :hostname }
+  it { is_expected.to respond_to :run }
+  it { is_expected.to respond_to :environment_name }
+  it { is_expected.to respond_to :hosted_zone_name }
+  it { is_expected.to respond_to :hostname }
 
   describe '#run' do
     context 'waiting' do
-      subject(:r) do
+      subject() do
         AWS.stub!
         r = Automan::Beanstalk::Router.new
         r.eb = AWS::ElasticBeanstalk::Client.new
@@ -23,41 +23,41 @@ describe Automan::Beanstalk::Router do
       end
 
       it "raises error if it never finds a name" do
-        r.stub(:elb_cname_from_beanstalk_environment).and_return(nil)
+        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return(nil)
         expect {
-          r.run
+          subject.run
         }.to raise_error Wait::ResultInvalid
       end
 
       it "calls #update_dns_alias if it finds a name" do
-        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
-        r.should_receive(:update_dns_alias)
-        r.run
+        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return('foo')
+        expect(subject).to receive(:update_dns_alias)
+        subject.run
       end
 
       it "ignores InvalidChangeBatch until last attempt" do
-        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
-        r.stub(:update_dns_alias).and_raise AWS::Route53::Errors::InvalidChangeBatch
+        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return('foo')
+        allow(subject).to receive(:update_dns_alias).and_raise AWS::Route53::Errors::InvalidChangeBatch
         expect {
-          r.run
+          subject.run
         }.to raise_error AWS::Route53::Errors::InvalidChangeBatch
-        r.attempts_made.should eq 5
+        expect(subject.attempts_made).to eq 5
       end
 
       it "ignores InvalidChangeBatch until it succeeds" do
-        r.stub(:elb_cname_from_beanstalk_environment).and_return('foo')
+        allow(subject).to receive(:elb_cname_from_beanstalk_environment).and_return('foo')
 
         @attempts = 0
-        r.stub(:update_dns_alias) do
+        allow(subject).to receive(:update_dns_alias) do
           @attempts += 1
           raise AWS::Route53::Errors::InvalidChangeBatch if @attempts < 3
         end
 
         expect {
-          r.run
+          subject.run
         }.not_to raise_error
 
-        r.attempts_made.should eq 3
+        expect(subject.attempts_made).to eq 3
       end
     end
   end