dpl 1.6.1.travis.447.1 → 1.6.1.travis.449.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YWFhNTIzYjc4N2E2ZmJiMTkzYWM2ZjRjNDcxMzcxZjQ3NjY0YjNmMg==
+    ZWU5ZmI4OWQ0OTNlOTA0MmRhZDEwN2QyMjc1YzEyMTc2MTJiZWI3NQ==
   data.tar.gz: !binary |-
-    NzI4NTNkMmQ1MmIyNzUzZTVjMTI2ZThlYmQxN2UzYzdkYTkyODkwYQ==
+    ODBkMzg4MjdiMWM4ODRjYWExMDY2YzMzMDk1ZDQ4NzJlZjE5YWU0Mg==
 SHA512:
   metadata.gz: !binary |-
-    NDc5Y2Y1NmQ1OWFkYjliYzE0MTEyZTkzZWJhZDgxMzExYzRiYmFkOTU4YjFh
-    YjA1NmU0ZDMzYTc2YTk2Y2M1NTU0ZWFiOTUxMjYzNDk0MTAyN2YzZGM1ZjNl
-    YWFkNmExM2ZkYWJjNmFiMGM5ZDZhYjBiY2MyNzRiOWQxZWY0NDI=
+    MzlkMzhiZDdiZjRmODgxZTEyODE1NmFhOGIwZTMwZmE2ZDRjZGQyMWRkZmNh
+    ZDJhMDZmZDVlMmMzMDg3NWNhNTJiMDcwZTg3OTIyZjhlNTkzNGE0M2JjMDIz
+    ZmQ2YWVmYWVjMzI5MGU0ZTgxZDFlYmEzNjE5M2EyYjhkNzA0MTk=
   data.tar.gz: !binary |-
-    NzkyY2Q3Y2M5MTcwYjY1ZDZkNjVmNjZiY2UyMzViNzNjZWJlMzA0N2U3NzMx
-    MmUxYzFjYjQwMzMyOWMzZGIyMTQ5YzU4NzVhOTdjMjU3NThkZDdlZDhhMzJl
-    ZmQzY2ZhYWE5NzA3NzhiYmMxNjNkZWE3NDkxMGIwNTBmNjExYzU=
+    NDYyZGQ3YTVmZjBiMjg2YzA5YzQ4YTFmYzYwZTJjY2EwYjQzMDBmNjZiYzU0
+    MzM0ZTk2ZTY4ZGZmMTIwZTM4NGMyMmUzYzFkODRlNTIwMTkzMTJkM2FkYjJm
+    MTdmOWU1ZTVhZDcwNTIwMTU3MjUzZTVmMjg0ZjdkZWUxZGMwZmI=

data/dpl.gemspec

@@ -16,7 +16,8 @@ Gem::Specification.new do |s|
   s.require_path          = 'lib'
   s.required_ruby_version = '>= 1.8.7'
 
-  s.add_development_dependency 'rspec', '~> 2.99.0'
+  s.add_development_dependency 'rspec', '~> 3.0.0'
+  s.add_development_dependency 'rspec-its'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'json'

data/spec/cli_spec.rb

@@ -2,30 +2,30 @@ require 'spec_helper'
 require 'dpl/cli'
 
 describe DPL::CLI do
-  describe :options do
-    example { described_class.new.options[:app]                           .should be == File.basename(Dir.pwd) }
-    example { described_class.new(:app => 'foo')            .options[:app].should be == 'foo'                  }
-    example { described_class.new("--app=foo")              .options[:app].should be == 'foo'                  }
-    example { described_class.new("--app")                  .options[:app].should be == true                   }
-    example { described_class.new("--app=foo", "--app=bar") .options[:app].should be == ['foo', 'bar']         }
+  describe "#options" do
+    example { expect(described_class.new.options[:app])                           .to eq(File.basename(Dir.pwd)) }
+    example { expect(described_class.new(:app => 'foo')            .options[:app]).to eq('foo')                  }
+    example { expect(described_class.new("--app=foo")              .options[:app]).to eq('foo')                  }
+    example { expect(described_class.new("--app")                  .options[:app]).to eq(true)                   }
+    example { expect(described_class.new("--app=foo", "--app=bar") .options[:app]).to eq(['foo', 'bar'])         }
 
     example "error handling" do
-      $stderr.should_receive(:puts).with('invalid option "app"')
+      expect($stderr).to receive(:puts).with('invalid option "app"')
       expect { described_class.new("app") }.to raise_error(SystemExit)
     end
   end
 
-  describe :run do
+  describe "#run" do
     example "triggers deploy" do
       provider = double('provider')
-      DPL::Provider.should_receive(:new).and_return(provider)
-      provider.should_receive(:deploy)
+      expect(DPL::Provider).to receive(:new).and_return(provider)
+      expect(provider).to receive(:deploy)
 
       described_class.run("--provider=foo")
     end
 
     example "error handling" do
-      $stderr.should_receive(:puts).with('missing provider')
+      expect($stderr).to receive(:puts).with('missing provider')
       expect { described_class.run }.to raise_error(SystemExit)
     end
 

data/spec/provider/appfog_spec.rb

@@ -6,29 +6,29 @@ describe DPL::Provider::Appfog do
     described_class.new(DummyContext.new, :email => 'blah@foo.com', :password => 'bar')
   end
 
-  describe :check_auth do
+  describe "#check_auth" do
     example do
-      provider.context.should_receive(:shell).with("af login --email=blah@foo.com --password=bar")
+      expect(provider.context).to receive(:shell).with("af login --email=blah@foo.com --password=bar")
       provider.check_auth
     end
   end
 
-  describe :needs_key? do
+  describe "#needs_key?" do
     example do
-      provider.needs_key?.should == false
+      expect(provider.needs_key?).to eq(false)
     end
   end
 
-  describe :push_app do
+  describe "#push_app" do
     example "Without :app" do
-      provider.context.should_receive(:shell).with("af update dpl")
-      provider.context.should_receive(:shell).with("af logout")
+      expect(provider.context).to receive(:shell).with("af update dpl")
+      expect(provider.context).to receive(:shell).with("af logout")
       provider.push_app
     end
     example "With :app" do
       provider.options.update(:app => 'test')
-      provider.context.should_receive(:shell).with("af update test")
-      provider.context.should_receive(:shell).with("af logout")
+      expect(provider.context).to receive(:shell).with("af update test")
+      expect(provider.context).to receive(:shell).with("af logout")
       provider.push_app
     end
   end

data/spec/provider/cloud66_spec.rb

@@ -10,12 +10,12 @@ describe DPL::Provider::Cloud66 do
   let(:not_found_response){ double(code: '404') }
   let(:options){ {} }
 
-  describe :push_app do
+  describe "#push_app" do
     context 'with a successful response' do
       let(:options){ {:redeployment_hook => 'https://hooks.cloud66.com/stacks/redeploy/0101010101010101'} }
 
       example do
-        provider.should_receive(:webhook_call).with('https', 'hooks.cloud66.com', 443, '/stacks/redeploy/0101010101010101').and_return(successful_response)
+        expect(provider).to receive(:webhook_call).with('https', 'hooks.cloud66.com', 443, '/stacks/redeploy/0101010101010101').and_return(successful_response)
         provider.push_app
       end
     end
@@ -24,21 +24,21 @@ describe DPL::Provider::Cloud66 do
       let(:options){ {:redeployment_hook => 'https://hooks.cloud66.com/stacks/redeploy/0101010101010101'} }
 
       it 'should raise an error' do
-        provider.should_receive(:webhook_call).with('https', 'hooks.cloud66.com', 443, '/stacks/redeploy/0101010101010101').and_return(not_found_response)
-        lambda { provider.push_app }.should raise_error(DPL::Error, "Redeployment failed [404]")
+        expect(provider).to receive(:webhook_call).with('https', 'hooks.cloud66.com', 443, '/stacks/redeploy/0101010101010101').and_return(not_found_response)
+        expect { provider.push_app }.to raise_error(DPL::Error, "Redeployment failed [404]")
       end
     end
 
     context 'with missing redeployment_hook option' do
       it 'should raise an error' do
-        lambda { provider.push_app }.should raise_error(DPL::Error, "missing redeployment_hook")
+        expect { provider.push_app }.to raise_error(DPL::Error, "missing redeployment_hook")
       end
     end
   end
 
-  describe :needs_key? do
+  describe "#needs_key?" do
     example do
-      provider.needs_key?.should == false
+      expect(provider.needs_key?).to eq(false)
     end
   end
 end

data/spec/provider/cloud_files_spec.rb

@@ -11,65 +11,65 @@ describe DPL::Provider::CloudFiles do
     described_class.new(DummyContext.new, :username => 'username', :api_key => 'api key', :container => 'travis', :region => 'dfw')
   end
 
-  describe :needs_key? do
+  describe "#needs_key?" do
     example do
-      provider.needs_key?.should == false
+      expect(provider.needs_key?).to eq(false)
     end
   end
 
-  describe :api do
+  describe "#api" do
     example do
-      Fog::Storage.should_receive(:new).with(:provider => 'Rackspace', :rackspace_username => 'username', :rackspace_api_key => 'api key', :rackspace_region => 'dfw')
+      expect(Fog::Storage).to receive(:new).with(:provider => 'Rackspace', :rackspace_username => 'username', :rackspace_api_key => 'api key', :rackspace_region => 'dfw')
 
       provider.api
     end
   end
 
-  describe :check_auth do
+  describe "#check_auth" do
     example do
-      provider.should_receive(:log).with('Authenticated as username')
+      expect(provider).to receive(:log).with('Authenticated as username')
 
       provider.check_auth
     end
   end
 
-  describe :push_app do
+  describe "#push_app" do
     let :files do
       files = double
 
       directory = double
-      directory.stub(:files) { files }
+      allow(directory).to receive(:files) { files }
 
       directories = double
-      directories.should_receive(:get).with('travis').and_return(directory)
+      expect(directories).to receive(:get).with('travis').and_return(directory)
 
       service = double(:service)
-      service.stub(:directories) { directories }
-      provider.stub(:api) { service }
+      allow(service).to receive(:directories) { directories }
+      allow(provider).to receive(:api) { service }
 
       files
     end
 
     example do
-      files.should_receive(:create).with(:key => 'a', :body => 'a body')
-      files.should_receive(:create).with(:key => 'b', :body => 'b body')
-      files.should_receive(:create).with(:key => 'c', :body => 'c body')
+      expect(files).to receive(:create).with(:key => 'a', :body => 'a body')
+      expect(files).to receive(:create).with(:key => 'b', :body => 'b body')
+      expect(files).to receive(:create).with(:key => 'c', :body => 'c body')
 
-      Dir.should_receive(:glob).with('**/*').and_return(['a', 'b', 'c'])
-      File.stub(:open) { |name| "#{name} body" }
+      expect(Dir).to receive(:glob).with('**/*').and_return(['a', 'b', 'c'])
+      allow(File).to receive(:open) { |name| "#{name} body" }
 
       provider.push_app
     end
   end
 
-  describe :deploy do
+  describe "#deploy" do
     example 'Not Found' do
       directories = double
-      directories.stub(:get) { nil }
+      allow(directories).to receive(:get) { nil }
 
       service = double(:service)
-      service.stub(:directories) { directories }
-      provider.stub(:api) { service }
+      allow(service).to receive(:directories) { directories }
+      allow(provider).to receive(:api) { service }
 
       expect { provider.deploy }.to raise_error(DPL::Error, 'The specified container does not exist.')
     end

data/spec/provider/cloudcontrol_spec.rb

@@ -20,46 +20,46 @@ describe DPL::Provider::CloudControl do
   end
 
   it '#check_auth should call #headers_with_token' do
-    provider.should receive(:headers_with_token)
-    provider.check_auth.should
+    expect(provider).to receive(:headers_with_token)
+    provider.check_auth
   end
 
   describe '#check_app' do
     it 'on deployment found' do
-      provider.should receive(:api_call).and_return double(
+      expect(provider).to receive(:api_call).and_return double(
         :code => '200',
         :body => '{"branch":"foo_repo.git"}'
       )
-      provider.instance_variable_get(:@repository).should be_nil
+      expect(provider.instance_variable_get(:@repository)).to be_nil
       provider.check_app
-      provider.instance_variable_get(:@repository).should == 'foo_repo.git'
+      expect(provider.instance_variable_get(:@repository)).to eq('foo_repo.git')
     end
 
     it 'on deployment not found' do
-      provider.should receive(:api_call).and_return double(:code => '410')
+      expect(provider).to receive(:api_call).and_return double(:code => '410')
       expect { provider.check_app }.to raise_error(DPL::Error)
     end
   end
 
   describe '#setup_key' do
     before do
-      File.should receive(:read).with('file').and_return('foo_key')
-      provider.should receive(:user).and_return({ 'username' => 'foo_user' })
+      expect(File).to receive(:read).with('file').and_return('foo_key')
+      expect(provider).to receive(:user).and_return({ 'username' => 'foo_user' })
     end
 
     it 'on api success' do
-      provider.should receive(:api_call).with('POST', '/user/foo_user/key', '{"key":"foo_key"}').and_return double(
+      expect(provider).to receive(:api_call).with('POST', '/user/foo_user/key', '{"key":"foo_key"}').and_return double(
           :code => '200',
           :body => '{ "key": "foo_key", "key_id": "foo_key_id"}'
         )
 
-      provider.instance_variable_get(:@ssh_key_id).should be_nil
+      expect(provider.instance_variable_get(:@ssh_key_id)).to be_nil
       provider.setup_key 'file'
-      provider.instance_variable_get(:@ssh_key_id).should == 'foo_key_id'
+      expect(provider.instance_variable_get(:@ssh_key_id)).to eq('foo_key_id')
     end
 
     it 'on api failure' do
-      provider.should receive(:api_call).with('POST', '/user/foo_user/key', '{"key":"foo_key"}').and_return double(:code => '401')
+      expect(provider).to receive(:api_call).with('POST', '/user/foo_user/key', '{"key":"foo_key"}').and_return double(:code => '401')
 
       expect { provider.setup_key 'file' }.to raise_error(DPL::Error)
     end
@@ -68,16 +68,16 @@ describe DPL::Provider::CloudControl do
   describe '#remove_key' do
     before do
       provider.instance_variable_set(:@ssh_key_id, 'foo_key_id')
-      provider.should receive(:user).and_return({ 'username' => 'foo_user' })
+      expect(provider).to receive(:user).and_return({ 'username' => 'foo_user' })
     end
 
     it 'on api success' do
-      provider.should receive(:api_call).with('DELETE', '/user/foo_user/key/foo_key_id').and_return double(:code => '204')
+      expect(provider).to receive(:api_call).with('DELETE', '/user/foo_user/key/foo_key_id').and_return double(:code => '204')
       provider.remove_key
     end
 
     it 'on api failure' do
-      provider.should receive(:api_call).with('DELETE', '/user/foo_user/key/foo_key_id').and_return double(:code => '410')
+      expect(provider).to receive(:api_call).with('DELETE', '/user/foo_user/key/foo_key_id').and_return double(:code => '410')
       expect { provider.remove_key }.to raise_error(DPL::Error)
     end
   end
@@ -85,9 +85,9 @@ describe DPL::Provider::CloudControl do
   it '#push_app shuld deploy the app' do
     provider.instance_variable_set(:@repository, 'foo_repo.git')
     context = double(:shell)
-    context.should receive(:shell).with("git push foo_repo.git HEAD:master -f")
-    provider.should receive(:context).and_return context
-    provider.should receive(:deploy_app)
+    expect(context).to receive(:shell).with("git push foo_repo.git HEAD:master -f")
+    expect(provider).to receive(:context).and_return context
+    expect(provider).to receive(:deploy_app)
 
     provider.push_app
   end
@@ -96,19 +96,19 @@ describe DPL::Provider::CloudControl do
     describe '#get_token' do
       it 'on api success' do
         request = double()
-        request.should receive(:basic_auth).with('foo@test.com', 'password')
-        Net::HTTP::Post.should receive(:new).with('/token/').and_return request
+        expect(request).to receive(:basic_auth).with('foo@test.com', 'password')
+        expect(Net::HTTP::Post).to receive(:new).with('/token/').and_return request
 
-        provider.instance_variable_get(:@http).should receive(:request).and_return double(
+        expect(provider.instance_variable_get(:@http)).to receive(:request).and_return double(
           :code => '200',
           :body => '{ "token": "foo_token"}'
         )
 
-        provider.instance_eval { get_token }.should == { 'token' => 'foo_token' }
+        expect(provider.instance_eval { get_token }).to eq({ 'token' => 'foo_token' })
       end
 
       it 'on api failure' do
-        provider.instance_variable_get(:@http).should receive(:request).and_return double(:code => '401')
+        expect(provider.instance_variable_get(:@http)).to receive(:request).and_return double(:code => '401')
 
         expect do
           provider.instance_eval { get_token }
@@ -117,30 +117,30 @@ describe DPL::Provider::CloudControl do
     end
 
     it '#headers_with_token should return headers' do
-      provider.should receive(:get_token).and_return({ 'token' => 'foo_token' })
+      expect(provider).to receive(:get_token).and_return({ 'token' => 'foo_token' })
       expected_return = {
         'Authorization' => 'cc_auth_token="foo_token"',
         'Content-Type' => 'application/json'
       }
 
-      provider.instance_eval { headers_with_token }.should == expected_return
+      expect(provider.instance_eval { headers_with_token }).to eq(expected_return)
     end
 
     describe '#get_headers' do
       let(:expected_args) { [ 'GET', '/user/', nil, {'foo' => 'headers'} ] }
 
       before do
-        provider.should receive(:headers_with_token).and_return({ 'foo' => 'headers' })
+        expect(provider).to receive(:headers_with_token).and_return({ 'foo' => 'headers' })
       end
 
       it 'on token valid' do
-        provider.should receive(:api_call).with(*expected_args).and_return double(:code => '200')
-        provider.instance_eval { get_headers }.should == { 'foo' => 'headers' }
+        expect(provider).to receive(:api_call).with(*expected_args).and_return double(:code => '200')
+        expect(provider.instance_eval { get_headers }).to eq({ 'foo' => 'headers' })
       end
 
       it 'on token expired' do
-        provider.should receive(:api_call).with(*expected_args).and_return double(:code => '401')
-        provider.should receive(:headers_with_token).with({ :new_token => true})
+        expect(provider).to receive(:api_call).with(*expected_args).and_return double(:code => '401')
+        expect(provider).to receive(:headers_with_token).with({ :new_token => true})
 
         provider.instance_eval { get_headers }
       end
@@ -148,7 +148,7 @@ describe DPL::Provider::CloudControl do
 
     it '#api_call should send request' do
       expected_args = [ "foo_method", "foo_path", "\"foo\":\"data\"", {"foo"=>"headers"} ]
-      provider.instance_variable_get(:@http).should receive(:send_request).with(*expected_args)
+      expect(provider.instance_variable_get(:@http)).to receive(:send_request).with(*expected_args)
 
       provider.instance_eval do
         api_call('foo_method', 'foo_path', '"foo":"data"', { 'foo' => 'headers'})
@@ -157,12 +157,12 @@ describe DPL::Provider::CloudControl do
 
     describe '#deploy_app' do
       it 'on api success' do
-        provider.should receive(:api_call).with('PUT', '/app/foo_app/deployment/default', '{"version":-1}').and_return double(:code => '200')
+        expect(provider).to receive(:api_call).with('PUT', '/app/foo_app/deployment/default', '{"version":-1}').and_return double(:code => '200')
         provider.instance_eval { deploy_app }
       end
 
       it 'on api failure' do
-        provider.should receive(:api_call).with('PUT', '/app/foo_app/deployment/default', '{"version":-1}').and_return double(:code => '410')
+        expect(provider).to receive(:api_call).with('PUT', '/app/foo_app/deployment/default', '{"version":-1}').and_return double(:code => '410')
         expect do
           provider.instance_eval { deploy_app }
         end.to raise_error(DPL::Error)
@@ -171,16 +171,16 @@ describe DPL::Provider::CloudControl do
 
     describe '#user' do
       it 'on api success' do
-        provider.should receive(:api_call).with('GET', '/user/').and_return double(
+        expect(provider).to receive(:api_call).with('GET', '/user/').and_return double(
           :code => '200',
           :body => '["foo_user"]'
         )
 
-        provider.instance_eval { user }.should == 'foo_user'
+        expect(provider.instance_eval { user }).to eq('foo_user')
       end
 
       it 'on api failure' do
-        provider.should receive(:api_call).with('GET', '/user/').and_return double(:code => '410')
+        expect(provider).to receive(:api_call).with('GET', '/user/').and_return double(:code => '410')
 
         expect do
           provider.instance_eval { user }

data/spec/provider/cloudfoundry_spec.rb

@@ -9,7 +9,7 @@ describe DPL::Provider::CloudFoundry do
                         space: 'outer')
   end
 
-  describe :check_auth do
+  describe "#check_auth" do
     example do
       expect(provider.context).to receive(:shell).with('wget http://go-cli.s3-website-us-east-1.amazonaws.com/releases/latest/cf-cli_amd64.deb -qO temp.deb && sudo dpkg -i temp.deb')
       expect(provider.context).to receive(:shell).with('rm temp.deb')
@@ -19,19 +19,19 @@ describe DPL::Provider::CloudFoundry do
     end
   end
 
-  describe :check_app do
+  describe "#check_app" do
     example do
       expect{provider.check_app}.to raise_error('Application must have a manifest.yml for unattended deployment')
     end
   end
 
-  describe :needs_key? do
+  describe "#needs_key?" do
     example do
       expect(provider.needs_key?).to eq(false)
     end
   end
 
-  describe :push_app do
+  describe "#push_app" do
     example do
       expect(provider.context).to receive(:shell).with('cf push')
       expect(provider.context).to receive(:shell).with('cf logout')