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

data/spec/provider/rubygems_spec.rb

@@ -8,98 +8,98 @@ describe DPL::Provider::RubyGems do
     described_class.new(DummyContext.new, :app => 'example', :api_key => 'foo')
   end
 
-  describe :api do
+  describe "#api" do
     example "with an api key" do
-      ::Gems.should_receive(:key=).with('foo')
+      expect(::Gems).to receive(:key=).with('foo')
       provider.setup_auth
     end
 
     example "with a username and password" do
       provider.options.update(:user => 'test', :password => 'blah')
       provider.options.delete(:api_key)
-      ::Gems.should_receive(:username=).with('test')
-      ::Gems.should_receive(:password=).with('blah')
+      expect(::Gems).to receive(:username=).with('test')
+      expect(::Gems).to receive(:password=).with('blah')
       provider.setup_auth
     end
   end
 
-  describe :check_auth do
+  describe "#check_auth" do
     example do
       provider.options.update(:user => 'test', :password => 'blah')
       provider.options.delete(:api_key)
-      provider.should_receive(:log).with("Authenticated with username test")
+      expect(provider).to receive(:log).with("Authenticated with username test")
       provider.check_auth
     end
   end
 
-  describe :check_app do
+  describe "#check_app" do
     example do
-      ::Gems.should_receive(:info).with('example').and_return({'name' => 'example'})
-      provider.should_receive(:log).with("Found gem example")
+      expect(::Gems).to receive(:info).with('example').and_return({'name' => 'example'})
+      expect(provider).to receive(:log).with("Found gem example")
       provider.check_app
     end
   end
 
-  describe :push_app do
+  describe "#push_app" do
     after(:each) do
-      File.should_receive(:new).with('File').and_return('Test file')
-      provider.should_receive(:log).with('Yes!')
+      expect(File).to receive(:new).with('File').and_return('Test file')
+      expect(provider).to receive(:log).with('Yes!')
       provider.push_app
     end
 
     example "with options[:app]" do
       provider.options.update(:app => 'example')
-      provider.context.should_receive(:shell).with("gem build example.gemspec")
-      Dir.should_receive(:glob).with('example-*.gem').and_yield('File')
-      ::Gems.should_receive(:push).with('Test file').and_return('Yes!')
+      expect(provider.context).to receive(:shell).with("gem build example.gemspec")
+      expect(Dir).to receive(:glob).with('example-*.gem').and_yield('File')
+      expect(::Gems).to receive(:push).with('Test file').and_return('Yes!')
     end
 
     example "with options[:gem]" do
       provider.options.update(:gem => 'example-gem')
-      provider.context.should_receive(:shell).with("gem build example-gem.gemspec")
-      Dir.should_receive(:glob).with('example-gem-*.gem').and_yield('File')
-      ::Gems.should_receive(:push).with('Test file').and_return('Yes!')
+      expect(provider.context).to receive(:shell).with("gem build example-gem.gemspec")
+      expect(Dir).to receive(:glob).with('example-gem-*.gem').and_yield('File')
+      expect(::Gems).to receive(:push).with('Test file').and_return('Yes!')
     end
 
     example "with options[:gemspec]" do
       provider.options.update(:gemspec => 'blah.gemspec')
-      provider.context.should_receive(:shell).with("gem build blah.gemspec")
-      Dir.should_receive(:glob).with('blah-*.gem').and_yield('File')
-      ::Gems.should_receive(:push).with('Test file').and_return('Yes!')
+      expect(provider.context).to receive(:shell).with("gem build blah.gemspec")
+      expect(Dir).to receive(:glob).with('blah-*.gem').and_yield('File')
+      expect(::Gems).to receive(:push).with('Test file').and_return('Yes!')
     end
 
     example "with options[:host]" do
       provider.options.update(:host => 'http://example.com')
-      provider.context.should_receive(:shell).with("gem build example.gemspec")
-      Dir.should_receive(:glob).with('example-*.gem').and_yield('File')
-      ::Gems.should_receive(:push).with('Test file', host='http://example.com').and_return('Yes!')
+      expect(provider.context).to receive(:shell).with("gem build example.gemspec")
+      expect(Dir).to receive(:glob).with('example-*.gem').and_yield('File')
+      expect(::Gems).to receive(:push).with('Test file', host='http://example.com').and_return('Yes!')
     end
   end
 
-  describe :setup_gem do
+  describe "#setup_gem" do
     example "with options[:gem] and options[:app] set" do
       provider.options.update(:gem => 'test', :app => 'blah')
       provider.setup_gem
-      provider.options[:gem].should be == 'test'
+      expect(provider.options[:gem]).to eq('test')
     end
 
     example "with options[:app] set" do
       provider.options.update(:app => 'foo')
       provider.setup_gem
-      provider.options[:gem].should be == 'foo'
+      expect(provider.options[:gem]).to eq('foo')
     end
 
     example "with options[:gem] set" do
       provider.options.update(:gem => 'bar')
       provider.setup_gem
-      provider.options[:gem].should be == 'bar'
+      expect(provider.options[:gem]).to eq('bar')
     end
   end
 
-  describe :gemspec do
+  describe "#gemspec" do
     example do
       provider.options.update(:gemspec => 'test.gemspec')
-      provider.gemspec.should be == 'test'
+      expect(provider.gemspec).to eq('test')
     end
   end
 end

data/spec/provider/s3_spec.rb

@@ -3,85 +3,85 @@ require 'aws-sdk'
 require 'dpl/provider/s3'
 
 describe DPL::Provider::S3 do
-  
+
   before (:each) do
     AWS.stub!
   end
-  
+
   subject :provider 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 :upload_path do
+  describe "#upload_path" do
     example "Without :upload_dir"do
       filename = "testfile.file"
 
-      provider.upload_path(filename).should == "testfile.file"
+      expect(provider.upload_path(filename)).to eq("testfile.file")
     end
 
     example "With :upload_dir" do
       provider.options.update(:upload_dir => 'BUILD3')
       filename = "testfile.file"
 
-      provider.upload_path(filename).should == "BUILD3/testfile.file"
+      expect(provider.upload_path(filename)).to eq("BUILD3/testfile.file")
     end
   end
 
-  describe :setup_auth do
+  describe "#setup_auth" do
     example "Without :region" do
-      AWS.should_receive(:config).with(:access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz', :region => 'us-east-1').once.and_call_original
+      expect(AWS).to receive(:config).with(:access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz', :region => 'us-east-1').once.and_call_original
       provider.setup_auth
     end
     example "With :region" do
       provider.options.update(:region => 'us-west-2')
 
-      AWS.should_receive(:config).with(:access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz', :region => 'us-west-2').once
+      expect(AWS).to receive(:config).with(:access_key_id => 'qwertyuiopasdfghjklz', :secret_access_key => 'qwertyuiopasdfghjklzqwertyuiopasdfghjklz', :region => 'us-west-2').once
       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
     example "Without local_dir" do
-      Dir.should_receive(:chdir).with(Dir.pwd)
+      expect(Dir).to receive(:chdir).with(Dir.pwd)
       provider.push_app
     end
 
     example "With local_dir" do
       provider.options.update(:local_dir => 'BUILD')
-      
-      Dir.should_receive(:chdir).with('BUILD')
+
+      expect(Dir).to receive(:chdir).with('BUILD')
       provider.push_app
     end
 
     example "Sends MIME type" do
-      Dir.should_receive(:glob).and_yield(__FILE__)
-      AWS::S3::ObjectCollection.any_instance.should_receive(:create).with(anything(), anything(), hash_including(:content_type => 'application/x-ruby'))
+      expect(Dir).to receive(:glob).and_yield(__FILE__)
+      expect_any_instance_of(AWS::S3::ObjectCollection).to receive(:create).with(anything(), anything(), hash_including(:content_type => 'application/x-ruby'))
       provider.push_app
     end
   end
 
-  describe :api do   
+  describe "#api" do
     example "Without Endpoint" do
-      AWS::S3.should_receive(:new).with(:endpoint => 's3.amazonaws.com')
+      expect(AWS::S3).to receive(:new).with(:endpoint => 's3.amazonaws.com')
       provider.api
     end
     example "With Endpoint" do
       provider.options.update(:endpoint => 's3test.com.s3-website-us-west-2.amazonaws.com')
-      AWS::S3.should_receive(:new).with(:endpoint => 's3test.com.s3-website-us-west-2.amazonaws.com')
+      expect(AWS::S3).to receive(:new).with(:endpoint => 's3test.com.s3-website-us-west-2.amazonaws.com')
       provider.api
     end
   end

data/spec/provider_spec.rb

@@ -7,154 +7,154 @@ describe DPL::Provider do
 
   before { stub_const "DPL::Provider::Example", example_provider }
 
-  describe :new do
-    example { described_class.new(DummyContext.new, :provider => "example") .should be_an(example_provider) }
-    example { described_class.new(DummyContext.new, :provider => "Example") .should be_an(example_provider) }
-    example { described_class.new(DummyContext.new, :provider => "exa_mple").should be_an(example_provider) }
-    example { described_class.new(DummyContext.new, :provider => "exa-mple").should be_an(example_provider) }
+  describe "#new" do
+    example { expect(described_class.new(DummyContext.new, :provider => "example")) .to be_an(example_provider) }
+    example { expect(described_class.new(DummyContext.new, :provider => "Example")) .to be_an(example_provider) }
+    example { expect(described_class.new(DummyContext.new, :provider => "exa_mple")).to be_an(example_provider) }
+    example { expect(described_class.new(DummyContext.new, :provider => "exa-mple")).to be_an(example_provider) }
   end
 
-  describe :requires do
+  describe "#requires" do
     before do
-      example_provider.should_receive(:require).with("foo")
+      expect(example_provider).to receive(:require).with("foo")
     end
 
     example "installed" do
-      example_provider.should_receive(:gem).with("foo", "~> 1.4")
+      expect(example_provider).to receive(:gem).with("foo", "~> 1.4")
       example_provider.requires("foo", :version => "~> 1.4")
     end
 
     example "missing" do
-      example_provider.should_receive(:gem).with("foo", "~> 1.4").and_raise(LoadError)
-      example_provider.context.should_receive(:shell).with('gem install foo -v "~> 1.4"', retry: true)
+      expect(example_provider).to receive(:gem).with("foo", "~> 1.4").and_raise(LoadError)
+      expect(example_provider.context).to receive(:shell).with('gem install foo -v "~> 1.4"', retry: true)
       example_provider.requires("foo", :version => "~> 1.4")
     end
   end
 
-  describe :apt_get do
+  describe "#apt_get" do
     example "installed" do
-      example_provider.should_receive(:`).with("which foo").and_return("/bin/foo\n")
-      example_provider.should_not_receive(:system)
+      expect(example_provider).to receive(:`).with("which foo").and_return("/bin/foo\n")
+      expect(example_provider).not_to receive(:system)
       example_provider.apt_get("foo")
     end
 
     example "missing" do
-      example_provider.should_receive(:`).with("which foo").and_return("")
-      example_provider.context.should_receive(:shell).with("sudo apt-get -qq install foo", retry: true)
+      expect(example_provider).to receive(:`).with("which foo").and_return("")
+      expect(example_provider.context).to receive(:shell).with("sudo apt-get -qq install foo", retry: true)
       example_provider.apt_get("foo")
     end
   end
 
-  describe :pip do
+  describe "#pip" do
     example "installed" do
-      example_provider.should_receive(:`).with("which foo").and_return("/bin/foo\n")
-      example_provider.should_not_receive(:system)
+      expect(example_provider).to receive(:`).with("which foo").and_return("/bin/foo\n")
+      expect(example_provider).not_to receive(:system)
       example_provider.pip("foo")
     end
 
     example "missing" do
-      example_provider.should_receive(:`).with("which foo").and_return("")
-      example_provider.context.should_receive(:shell).with("sudo pip install foo", retry: true)
+      expect(example_provider).to receive(:`).with("which foo").and_return("")
+      expect(example_provider.context).to receive(:shell).with("sudo pip install foo", retry: true)
       example_provider.pip("foo")
     end
   end
 
-  describe :deploy do
+  describe "#deploy" do
     before do
-      provider.should_receive(:check_auth)
-      provider.should_receive(:check_app)
-      provider.should_receive(:push_app)
-      provider.should_receive(:run).with("foo")
-      provider.should_receive(:run).with("bar")
+      expect(provider).to receive(:check_auth)
+      expect(provider).to receive(:check_app)
+      expect(provider).to receive(:push_app)
+      expect(provider).to receive(:run).with("foo")
+      expect(provider).to receive(:run).with("bar")
     end
 
     example "needs key" do
-      provider.should_receive(:remove_key)
-      provider.should_receive(:create_key)
-      provider.should_receive(:setup_key)
-      provider.should_receive(:setup_git_ssh)
+      expect(provider).to receive(:remove_key)
+      expect(provider).to receive(:create_key)
+      expect(provider).to receive(:setup_key)
+      expect(provider).to receive(:setup_git_ssh)
       provider.deploy
     end
 
     example "does not need key" do
-      provider.stub(:needs_key? => false)
+      allow(provider).to receive_messages(:needs_key? => false)
       provider.deploy
     end
   end
 
-  describe :cleanup do
+  describe "#cleanup" do
     example do
-      provider.context.should_receive(:shell).with('mv .dpl ~/dpl')
-      provider.context.should_receive(:shell).with('git stash --all')
-      provider.context.should_receive(:shell).with('mv ~/dpl .dpl')
+      expect(provider.context).to receive(:shell).with('mv .dpl ~/dpl')
+      expect(provider.context).to receive(:shell).with('git stash --all')
+      expect(provider.context).to receive(:shell).with('mv ~/dpl .dpl')
       provider.cleanup
     end
 
     example "skip cleanup" do
-      provider.options.should_receive(:[]).with(:skip_cleanup).and_return("true")
-      provider.context.should_not_receive(:shell)
+      expect(provider.options).to receive(:[]).with(:skip_cleanup).and_return("true")
+      expect(provider.context).not_to receive(:shell)
       provider.cleanup
     end
   end
 
-  describe :uncleanup do
+  describe "#uncleanup" do
     example do
-      provider.context.should_receive(:shell).with('git stash pop')
+      expect(provider.context).to receive(:shell).with('git stash pop')
       provider.uncleanup
     end
 
     example "skip cleanup" do
-      provider.options.should_receive(:[]).with(:skip_cleanup).and_return("true")
-      provider.context.should_not_receive(:shell)
+      expect(provider.options).to receive(:[]).with(:skip_cleanup).and_return("true")
+      expect(provider.context).not_to receive(:shell)
       provider.uncleanup
     end
   end
 
-  describe :create_key do
+  describe "#create_key" do
     example do
-      provider.context.should_receive(:shell).with('ssh-keygen -t rsa -N "" -C foo -f thekey')
+      expect(provider.context).to receive(:shell).with('ssh-keygen -t rsa -N "" -C foo -f thekey')
       provider.create_key('thekey')
     end
   end
 
-  describe :setup_git_ssh do
+  describe "#setup_git_ssh" do
     after { FileUtils.rm ENV.delete('GIT_SSH') }
 
     example do
       provider.setup_git_ssh('foo', 'bar')
-      ENV['GIT_SSH'].should be == File.expand_path('foo')
+      expect(ENV['GIT_SSH']).to eq(File.expand_path('foo'))
     end
   end
 
-  describe :log do
+  describe "#log" do
     example do
-      $stderr.should_receive(:puts).with("foo")
+      expect($stderr).to receive(:puts).with("foo")
       provider.log("foo")
     end
   end
 
-  describe :shell do
+  describe "#shell" do
     example do
-      example_provider.should_receive(:system).with("command")
+      expect(example_provider).to receive(:system).with("command")
       example_provider.shell("command")
     end
   end
 
-  describe :npm_g do
+  describe "#npm_g" do
     example do
-      example_provider.context.should_receive(:shell).with("npm install -g foo", retry: true)
+      expect(example_provider.context).to receive(:shell).with("npm install -g foo", retry: true)
       example_provider.npm_g("foo")
     end
   end
 
-  describe :run do
+  describe "#run" do
     example do
-      provider.should_receive(:error).with("running commands not supported")
+      expect(provider).to receive(:error).with("running commands not supported")
       provider.run "blah"
     end
   end
 
-  describe :error do
+  describe "#error" do
     example do
       expect { provider.error("Foo") }.to raise_error("Foo")
     end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'simplecov'
 require 'dpl/error'
 require 'dpl/provider'
+require 'rspec/its'
 
 SimpleCov.start do
   coverage_dir '.coverage'