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

data/spec/provider/npm.rb

@@ -6,27 +6,27 @@ describe DPL::Provider::NPM do
     described_class.new(DummyContext.new, :email => 'foo@blah.com', :api_key => 'test')
   end
 
-  describe :check_auth do
+  describe "#check_auth" do
     example do
-      provider.should_receive(:setup_auth)
-      provider.should_receive(:log).with("Authenticated with email foo@blah.com")
+      expect(provider).to receive(:setup_auth)
+      expect(provider).to receive(:log).with("Authenticated with email foo@blah.com")
       provider.check_auth
     end
   end
 
-  describe :push_app do
+  describe "#push_app" do
     example do
-      provider.context.should_receive(:shell).with("npm publish")
+      expect(provider.context).to receive(:shell).with("npm publish")
       provider.push_app
     end
   end
 
-  describe :setup_auth do
+  describe "#setup_auth" do
     example do
       f = double(:npmrc)
-      File.should_receive(:open).with(File.expand_path(DPL::Provider::NPM::NPMRC_FILE)).and_return(f)
-      f.should_receive(:puts).with("_auth = test")
-      f.should_receive(:puts).with("email = foo@blah.com")
+      expect(File).to receive(:open).with(File.expand_path(DPL::Provider::NPM::NPMRC_FILE)).and_return(f)
+      expect(f).to receive(:puts).with("_auth = test")
+      expect(f).to receive(:puts).with("email = foo@blah.com")
       provider.setup_auth
     end
   end

data/spec/provider/openshift_spec.rb

@@ -7,12 +7,12 @@ describe DPL::Provider::Openshift do
     described_class.new(DummyContext.new, :user => 'foo', :password => 'foo', :domain => 'foo', :app => 'example', :key_name => 'key')
   end
 
-  describe :api do
+  describe "#api" do
     it 'accepts a user and a password' do
       api = double(:api)
       provider.options.update(:user => "foo", :password => "bar")
-      ::RHC::Rest::Client.should_receive(:new).with(:user => "foo", :password => "bar", :server => "openshift.redhat.com").and_return(api)
-      provider.api.should be == api
+      expect(::RHC::Rest::Client).to receive(:new).with(:user => "foo", :password => "bar", :server => "openshift.redhat.com").and_return(api)
+      expect(provider.api).to eq(api)
     end
   end
 
@@ -29,60 +29,60 @@ describe DPL::Provider::Openshift do
     end
 
     before do
-      ::RHC::Rest::Client.should_receive(:new).at_most(:once).and_return(api)
+      expect(::RHC::Rest::Client).to receive(:new).at_most(:once).and_return(api)
       provider.api
     end
 
     its(:api) {should be == api}
 
-    describe :check_auth do
+    describe "#check_auth" do
       example do
-        provider.should_receive(:log).with("authenticated as foo@bar.com")
+        expect(provider).to receive(:log).with("authenticated as foo@bar.com")
         provider.check_auth
       end
     end
 
-    describe :check_app do
+    describe "#check_app" do
       example do
-        provider.should_receive(:log).with("found app example")
+        expect(provider).to receive(:log).with("found app example")
         provider.check_app
       end
     end
 
-    describe :setup_key do
+    describe "#setup_key" do
       example do
-        File.should_receive(:read).with("the file").and_return("ssh-rsa\nfoo")
-        api.should_receive(:add_key).with("key", "foo", "ssh-rsa")
+        expect(File).to receive(:read).with("the file").and_return("ssh-rsa\nfoo")
+        expect(api).to receive(:add_key).with("key", "foo", "ssh-rsa")
         provider.setup_key("the file")
       end
     end
 
-    describe :remove_key do
+    describe "#remove_key" do
       example do
-        api.should_receive(:delete_key).with("key")
+        expect(api).to receive(:delete_key).with("key")
         provider.remove_key
       end
     end
 
-    describe :push_app do
+    describe "#push_app" do
       example "when app.deployment_branch is not set" do
-        provider.app.should_receive :deployment_branch
-        provider.context.should_receive(:shell).with("git push git://something -f")
+        expect(provider.app).to receive :deployment_branch
+        expect(provider.context).to receive(:shell).with("git push git://something -f")
         provider.push_app
       end
 
       example "when app.deployment_branch is set" do
-        provider.app.stub(:deployment_branch) { "test-branch" }
+        allow(provider.app).to receive(:deployment_branch) { "test-branch" }
 
-        provider.context.should_receive(:shell).with("rhc app configure example --deployment-branch test-branch")
-        provider.context.should_receive(:shell).with("git push git://something -f test-branch")
+        expect(provider.context).to receive(:shell).with("rhc app configure example --deployment-branch test-branch")
+        expect(provider.context).to receive(:shell).with("git push git://something -f test-branch")
         provider.push_app
       end
     end
 
-    describe :restart do
+    describe "#restart" do
       example do
-        provider.app.should_receive(:restart)
+        expect(provider.app).to receive(:restart)
         provider.restart
       end
     end

data/spec/provider/ops_works_spec.rb

@@ -13,42 +13,42 @@ describe DPL::Provider::OpsWorks do
     described_class.new(DummyContext.new, :access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz', :bucket => 'my-bucket')
   end
 
-  describe :check_auth do
+  describe "#check_auth" do
     example do
-      provider.should_receive(:setup_auth)
-      provider.should_receive(:log).with('Logging in with Access Key: ****************jklz')
+      expect(provider).to receive(:setup_auth)
+      expect(provider).to receive(:log).with('Logging in with Access Key: ****************jklz')
       provider.check_auth
     end
   end
 
-  describe :setup_auth do
+  describe "#setup_auth" do
     example do
-      AWS.should_receive(:config).with(:access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz').once.and_call_original
+      expect(AWS).to receive(:config).with(:access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz').once.and_call_original
       provider.setup_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
     let(:client) { double(:ops_works_client) }
     let(:ops_works_app) { {shortname: 'app', stack_id: 'stack-id'} }
     before do
-      provider.should_receive(:current_sha).and_return('sha')
-      provider.api.should_receive(:client).and_return(client)
-      ENV.should_receive(:[]).with('TRAVIS_BUILD_NUMBER').and_return('123')
+      expect(provider).to receive(:current_sha).and_return('sha')
+      expect(provider.api).to receive(:client).and_return(client)
+      expect(ENV).to receive(:[]).with('TRAVIS_BUILD_NUMBER').and_return('123')
     end
 
     let(:custom_json) { "{\"deploy\":{\"app\":{\"migrate\":false,\"scm\":{\"revision\":\"sha\"}}}}" }
     example 'without :migrate option' do
       provider.options.update(app_id: 'app-id')
-      client.should_receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]}
+      expect(client).to receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]}
       )
-      client.should_receive(:create_deployment).with(
+      expect(client).to receive(:create_deployment).with(
         stack_id: 'stack-id', app_id: 'app-id', command: {name: 'deploy'}, comment: 'Deploy build 123 via Travis CI', custom_json: custom_json
       ).and_return({})
       provider.push_app
@@ -57,8 +57,8 @@ describe DPL::Provider::OpsWorks do
     let(:custom_json_with_migrate) { "{\"deploy\":{\"app\":{\"migrate\":true,\"scm\":{\"revision\":\"sha\"}}}}" }
     example 'with :migrate option' do
       provider.options.update(app_id: 'app-id', migrate: true)
-      client.should_receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
-      client.should_receive(:create_deployment).with(
+      expect(client).to receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
+      expect(client).to receive(:create_deployment).with(
         stack_id: 'stack-id', app_id: 'app-id', command: {name: 'deploy'}, comment: 'Deploy build 123 via Travis CI', custom_json: custom_json_with_migrate
       ).and_return({})
       provider.push_app
@@ -66,16 +66,16 @@ describe DPL::Provider::OpsWorks do
 
     example 'with :wait_until_deployed' do
       provider.options.update(app_id: 'app-id', wait_until_deployed: true)
-      client.should_receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
-      client.should_receive(:create_deployment).and_return({deployment_id: 'deployment_id'})
-      client.should_receive(:describe_deployments).with({deployment_ids: ['deployment_id']}).and_return({deployments: [status: 'running']}, {deployments: [status: 'successful']})
+      expect(client).to receive(:describe_apps).with(app_ids: ['app-id']).and_return({apps: [ops_works_app]})
+      expect(client).to receive(:create_deployment).and_return({deployment_id: 'deployment_id'})
+      expect(client).to receive(:describe_deployments).with({deployment_ids: ['deployment_id']}).and_return({deployments: [status: 'running']}, {deployments: [status: 'successful']})
       provider.push_app
     end
   end
 
-  describe :api do
+  describe "#api" do
     example do
-      AWS::OpsWorks.should_receive(:new)
+      expect(AWS::OpsWorks).to receive(:new)
       provider.api
     end
   end

data/spec/provider/pypi_spec.rb

@@ -6,66 +6,66 @@ describe DPL::Provider::PyPI do
     described_class.new(DummyContext.new, :user => 'foo', :password => 'bar')
   end
 
-  describe :config do
+  describe "#config" do
     it 'accepts a user and a password' do
-      provider.config[:servers]['pypi'].should include 'username: foo'
-      provider.config[:servers]['pypi'].should include 'password: bar'
+      expect(provider.config[:servers]['pypi']).to include 'username: foo'
+      expect(provider.config[:servers]['pypi']).to include 'password: bar'
     end
   end
 
-  describe :initialize do
+  describe "#initialize" do
     example "with :distributions option containing 'bdist_wheel'" do
-      described_class.should_receive(:pip).with("wheel")
+      expect(described_class).to receive(:pip).with("wheel")
       described_class.new(DummyContext.new, :user => 'foo', :password => 'bar', :distributions => 'bdist_wheel sdist')
     end
   end
 
-  describe :check_auth do
+  describe "#check_auth" do
     example do
-      provider.should_receive(:log).with("Authenticated as foo")
+      expect(provider).to receive(:log).with("Authenticated as foo")
       provider.check_auth
     end
   end
 
-  describe :push_app do
+  describe "#push_app" do
     example do
-      provider.context.should_receive(:shell).with("python setup.py register -r pypi")
-      provider.context.should_receive(:shell).with("python setup.py sdist upload -r pypi")
-      provider.context.should_receive(:shell).with("python setup.py upload_docs --upload-dir build/docs")
+      expect(provider.context).to receive(:shell).with("python setup.py register -r pypi")
+      expect(provider.context).to receive(:shell).with("python setup.py sdist upload -r pypi")
+      expect(provider.context).to receive(:shell).with("python setup.py upload_docs --upload-dir build/docs")
       provider.push_app
     end
 
     example "with :distributions option" do
       provider.options.update(:distributions => 'sdist bdist')
-      provider.context.should_receive(:shell).with("python setup.py register -r pypi")
-      provider.context.should_receive(:shell).with("python setup.py sdist bdist upload -r pypi")
-      provider.context.should_receive(:shell).with("python setup.py upload_docs --upload-dir build/docs")
+      expect(provider.context).to receive(:shell).with("python setup.py register -r pypi")
+      expect(provider.context).to receive(:shell).with("python setup.py sdist bdist upload -r pypi")
+      expect(provider.context).to receive(:shell).with("python setup.py upload_docs --upload-dir build/docs")
       provider.push_app
     end
 
     example "with :server option" do
       provider.options.update(:server => 'http://blah.com')
-      provider.context.should_receive(:shell).with("python setup.py register -r http://blah.com")
-      provider.context.should_receive(:shell).with("python setup.py sdist upload -r http://blah.com")
-      provider.context.should_receive(:shell).with("python setup.py upload_docs --upload-dir build/docs")
+      expect(provider.context).to receive(:shell).with("python setup.py register -r http://blah.com")
+      expect(provider.context).to receive(:shell).with("python setup.py sdist upload -r http://blah.com")
+      expect(provider.context).to receive(:shell).with("python setup.py upload_docs --upload-dir build/docs")
       provider.push_app
     end
 
     example "with :docs_dir option" do
       provider.options.update(:docs_dir => 'some/dir')
-      provider.context.should_receive(:shell).with("python setup.py register -r pypi")
-      provider.context.should_receive(:shell).with("python setup.py sdist upload -r pypi")
-      provider.context.should_receive(:shell).with("python setup.py upload_docs --upload-dir some/dir")
+      expect(provider.context).to receive(:shell).with("python setup.py register -r pypi")
+      expect(provider.context).to receive(:shell).with("python setup.py sdist upload -r pypi")
+      expect(provider.context).to receive(:shell).with("python setup.py upload_docs --upload-dir some/dir")
       provider.push_app
     end
   end
 
-  describe :write_servers do
+  describe "#write_servers" do
     example do
       f = double(:f)
-      f.should_receive(:puts).with("    pypi")
-      f.should_receive(:puts).with("[pypi]")
-      f.should_receive(:puts).with(["repository: http://pypi.python.org/pypi",
+      expect(f).to receive(:puts).with("    pypi")
+      expect(f).to receive(:puts).with("[pypi]")
+      expect(f).to receive(:puts).with(["repository: http://pypi.python.org/pypi",
                                     "username: foo",
                                     "password: bar"
                                    ])

data/spec/provider/releases_spec.rb

@@ -7,11 +7,11 @@ describe DPL::Provider::Releases do
     described_class.new(DummyContext.new, :api_key => '0123445789qwertyuiop0123445789qwertyuiop', :file => 'blah.txt')
   end
 
-  describe :api do
+  describe "#api" do
     example "With API key" do
       api = double(:api)
-      ::Octokit::Client.should_receive(:new).with(:access_token => '0123445789qwertyuiop0123445789qwertyuiop').and_return(api)
-      provider.api.should be == api
+      expect(::Octokit::Client).to receive(:new).with(:access_token => '0123445789qwertyuiop0123445789qwertyuiop').and_return(api)
+      expect(provider.api).to eq(api)
     end
 
     example "With username and password" do
@@ -19,75 +19,75 @@ describe DPL::Provider::Releases do
       provider.options.update(:user => 'foo')
       provider.options.update(:password => 'bar')
 
-      ::Octokit::Client.should_receive(:new).with(:login => 'foo', :password  => 'bar').and_return(api)
-      provider.api.should be == api
+      expect(::Octokit::Client).to receive(:new).with(:login => 'foo', :password  => 'bar').and_return(api)
+      expect(provider.api).to eq(api)
     end
   end
 
-  describe :releases do
+  describe "#releases" do
     example "With ENV Slug" do
-      provider.stub(:slug).and_return("foo/bar")
+      allow(provider).to receive(:slug).and_return("foo/bar")
 
-      provider.api.should_receive(:releases).with("foo/bar")
+      expect(provider.api).to receive(:releases).with("foo/bar")
       provider.releases
     end
 
     example "With repo option" do
       provider.options.update(:repo => 'bar/foo')
 
-      provider.api.should_receive(:releases).with('bar/foo')
+      expect(provider.api).to receive(:releases).with('bar/foo')
       provider.releases
     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 :check_auth do
+  describe "#check_auth" do
     example "With proper permissions" do
       allow_message_expectations_on_nil
-      provider.stub(:user)
-      provider.stub(:setup_auth)
-      provider.api.should_receive(:scopes).and_return(["public_repo"])
-      provider.user.should_receive(:name).and_return("foo")
-      provider.should_receive(:log).with("Logged in as foo")
+      allow(provider).to receive(:user)
+      allow(provider).to receive(:setup_auth)
+      expect(provider.api).to receive(:scopes).and_return(["public_repo"])
+      expect(provider.user).to receive(:name).and_return("foo")
+      expect(provider).to receive(:log).with("Logged in as foo")
       provider.check_auth
     end
 
     example "With improper permissions" do
       allow_message_expectations_on_nil
-      provider.stub(:user)
-      provider.stub(:setup_auth)
-      provider.api.should_receive(:scopes).exactly(2).times.and_return([])
+      allow(provider).to receive(:user)
+      allow(provider).to receive(:setup_auth)
+      expect(provider.api).to receive(:scopes).exactly(2).times.and_return([])
       expect { provider.check_auth }.to raise_error(DPL::Error)
     end
   end
 
-  describe :push_app do
+  describe "#push_app" do
     example "When Release Exists but has no Files" do
       allow_message_expectations_on_nil
 
       provider.options.update(:file => ["test/foo.bar", "bar.foo"])
 
-      provider.stub(:releases).and_return([""])
-      provider.stub(:get_tag).and_return("v0.0.0")
+      allow(provider).to receive(:releases).and_return([""])
+      allow(provider).to receive(:get_tag).and_return("v0.0.0")
 
-      provider.releases.map do |release| 
-        release.stub(:tag_name).and_return("v0.0.0")
-        release.stub(:rels).and_return({:self => nil})
-        release.rels[:self].stub(:href)
+      provider.releases.map do |release|
+        allow(release).to receive(:tag_name).and_return("v0.0.0")
+        allow(release).to receive(:rels).and_return({:self => nil})
+        allow(release.rels[:self]).to receive(:href)
       end
 
-      provider.api.stub(:release)
-      provider.api.release.stub(:rels).and_return({:assets => nil})
-      provider.api.release.rels[:assets].stub(:get).and_return({:data => [""]})
-      provider.api.release.rels[:assets].get.stub(:data).and_return([])
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => [""]})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([])
 
-      provider.api.should_receive(:upload_asset).with(anything, "test/foo.bar", {:name=>"foo.bar", :content_type=>""})
-      provider.api.should_receive(:upload_asset).with(anything, "bar.foo", {:name=>"bar.foo", :content_type=>""})
+      expect(provider.api).to receive(:upload_asset).with(anything, "test/foo.bar", {:name=>"foo.bar", :content_type=>""})
+      expect(provider.api).to receive(:upload_asset).with(anything, "bar.foo", {:name=>"bar.foo", :content_type=>""})
 
       provider.push_app
     end
@@ -97,22 +97,22 @@ describe DPL::Provider::Releases do
 
       provider.options.update(:file => ["test/foo.bar", "bar.foo"])
 
-      provider.stub(:releases).and_return([""])
-      provider.stub(:get_tag).and_return("v0.0.0")
+      allow(provider).to receive(:releases).and_return([""])
+      allow(provider).to receive(:get_tag).and_return("v0.0.0")
 
-      provider.releases.map do |release| 
-        release.stub(:tag_name).and_return("v0.0.0")
-        release.stub(:rels).and_return({:self => nil})
-        release.rels[:self].stub(:href)
+      provider.releases.map do |release|
+        allow(release).to receive(:tag_name).and_return("v0.0.0")
+        allow(release).to receive(:rels).and_return({:self => nil})
+        allow(release.rels[:self]).to receive(:href)
       end
 
-      provider.api.stub(:release)
-      provider.api.release.stub(:rels).and_return({:assets => nil})
-      provider.api.release.rels[:assets].stub(:get).and_return({:data => [""]})
-      provider.api.release.rels[:assets].get.stub(:data).and_return([double(:name => "foo.bar"), double(:name => "foo.foo")])
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => [""]})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([double(:name => "foo.bar"), double(:name => "foo.foo")])
 
-      provider.api.should_receive(:upload_asset).with(anything, "bar.foo", {:name=>"bar.foo", :content_type=>""})
-      provider.should_receive(:log).with("foo.bar already exists, skipping.")
+      expect(provider.api).to receive(:upload_asset).with(anything, "bar.foo", {:name=>"bar.foo", :content_type=>""})
+      expect(provider).to receive(:log).with("foo.bar already exists, skipping.")
 
       provider.push_app
     end
@@ -122,25 +122,25 @@ describe DPL::Provider::Releases do
 
       provider.options.update(:file => ["test/foo.bar", "bar.foo"])
 
-      provider.stub(:releases).and_return([""])
-      
-      provider.releases.map do |release| 
-        release.stub(:tag_name).and_return("foo")
-        release.stub(:rels).and_return({:self => nil})
-        release.rels[:self].stub(:href)
+      allow(provider).to receive(:releases).and_return([""])
+
+      provider.releases.map do |release|
+        allow(release).to receive(:tag_name).and_return("foo")
+        allow(release).to receive(:rels).and_return({:self => nil})
+        allow(release.rels[:self]).to receive(:href)
       end
 
-      provider.api.stub(:create_release)
-      provider.api.create_release.stub(:rels).and_return({:self => nil})
-      provider.api.create_release.rels[:slef].stub(:href)
+      allow(provider.api).to receive(:create_release)
+      allow(provider.api.create_release).to receive(:rels).and_return({:self => nil})
+      allow(provider.api.create_release.rels[:slef]).to receive(:href)
 
-      provider.api.stub(:release)
-      provider.api.release.stub(:rels).and_return({:assets => nil})
-      provider.api.release.rels[:assets].stub(:get).and_return({:data => nil})
-      provider.api.release.rels[:assets].get.stub(:data).and_return([])
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => nil})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([])
 
-      provider.api.should_receive(:upload_asset).with(anything, "test/foo.bar", {:name=>"foo.bar", :content_type=>""})
-      provider.api.should_receive(:upload_asset).with(anything, "bar.foo", {:name=>"bar.foo", :content_type=>""})
+      expect(provider.api).to receive(:upload_asset).with(anything, "test/foo.bar", {:name=>"foo.bar", :content_type=>""})
+      expect(provider.api).to receive(:upload_asset).with(anything, "bar.foo", {:name=>"bar.foo", :content_type=>""})
 
       provider.push_app
     end
@@ -151,14 +151,14 @@ describe DPL::Provider::Releases do
       provider.options.update(:file => ["bar.foo"])
       provider.options.update(:release_number => "1234")
 
-      provider.stub(:slug).and_return("foo/bar")
+      allow(provider).to receive(:slug).and_return("foo/bar")
 
-      provider.api.stub(:release)
-      provider.api.release.stub(:rels).and_return({:assets => nil})
-      provider.api.release.rels[:assets].stub(:get).and_return({:data => nil})
-      provider.api.release.rels[:assets].get.stub(:data).and_return([])
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => nil})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([])
 
-      provider.api.should_receive(:upload_asset).with("https://api.github.com/repos/foo/bar/releases/1234", "bar.foo", {:name=>"bar.foo", :content_type=>""})
+      expect(provider.api).to receive(:upload_asset).with("https://api.github.com/repos/foo/bar/releases/1234", "bar.foo", {:name=>"bar.foo", :content_type=>""})
 
       provider.push_app
     end