Merge branch 'rs-rspec' into 'master'

Update to RSpec 3

Closes #54

See merge request gitlab-org/gitlab-shell!229

Gemfile

-source "http://rubygems.org"
+source 'https://rubygems.org'
 
 group :development, :test do
-  gem 'guard', '~> 1.5.0'
-  gem 'guard-rspec', '~> 2.1.0'
   gem 'listen', '~> 0.5.0'
-  gem 'rspec', '~> 2.0'
-  gem 'rspec-its', '~> 1.0.0'
+  gem 'rspec', '~> 3.8.0'
   gem 'rubocop', '0.49.1', require: false
   gem 'simplecov', '~> 0.9.0', require: false
-  gem 'vcr', '~> 2.4.0'
-  gem 'webmock', '~> 1.9.0'
+  gem 'vcr', '~> 4.0.0'
+  gem 'webmock', '~> 3.4.0'
 end

Gemfile.lock

 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
     addressable (2.5.2)
       public_suffix (>= 2.0.2, < 4.0)
     ast (2.4.0)
-    coderay (1.1.2)
     crack (0.4.3)
       safe_yaml (~> 1.0.0)
     diff-lcs (1.3)
     docile (1.1.5)
-    guard (1.5.4)
-      listen (>= 0.4.2)
-      lumberjack (>= 1.0.2)
-      pry (>= 0.9.10)
-      thor (>= 0.14.6)
-    guard-rspec (2.1.2)
-      guard (>= 1.1)
-      rspec (~> 2.11)
+    hashdiff (0.3.7)
     listen (0.5.3)
-    lumberjack (1.0.13)
-    method_source (0.9.0)
     multi_json (1.13.1)
     parallel (1.12.1)
     parser (2.5.1.2)
       ast (~> 2.4.0)
     powerpack (0.1.2)
-    pry (0.11.3)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    public_suffix (3.0.2)
+    public_suffix (3.0.3)
     rainbow (2.2.2)
       rake
     rake (12.3.1)
-    rspec (2.99.0)
-      rspec-core (~> 2.99.0)
-      rspec-expectations (~> 2.99.0)
-      rspec-mocks (~> 2.99.0)
-    rspec-core (2.99.2)
-    rspec-expectations (2.99.2)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-its (1.0.1)
-      rspec-core (>= 2.99.0.beta1)
-      rspec-expectations (>= 2.99.0.beta1)
-    rspec-mocks (2.99.4)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
     rubocop (0.49.1)
       parallel (~> 1.10)
       parser (>= 2.3.3.1, < 3.0)
@@ -57,26 +46,23 @@ GEM
       multi_json (~> 1.0)
       simplecov-html (~> 0.9.0)
     simplecov-html (0.9.0)
-    thor (0.20.0)
     unicode-display_width (1.4.0)
-    vcr (2.4.0)
-    webmock (1.9.3)
-      addressable (>= 2.2.7)
+    vcr (4.0.0)
+    webmock (3.4.2)
+      addressable (>= 2.3.6)
       crack (>= 0.3.2)
+      hashdiff
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  guard (~> 1.5.0)
-  guard-rspec (~> 2.1.0)
   listen (~> 0.5.0)
-  rspec (~> 2.0)
-  rspec-its (~> 1.0.0)
+  rspec (~> 3.8.0)
   rubocop (= 0.49.1)
   simplecov (~> 0.9.0)
-  vcr (~> 2.4.0)
-  webmock (~> 1.9.0)
+  vcr (~> 4.0.0)
+  webmock (~> 3.4.0)
 
 BUNDLED WITH
    1.16.3

Guardfile

-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-
-guard 'rspec' do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
-
-  # Rails example
-  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
-  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
-  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
-  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
-  watch('config/routes.rb')                           { "spec/routing" }
-  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
-
-  # Capybara features specs
-  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
-
-  # Turnip features and steps
-  watch(%r{^spec/acceptance/(.+)\.feature$})
-  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
-end

lib/gitlab_init.rb

-ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+ROOT_PATH = File.expand_path('..', __dir__)
 
 require_relative 'gitlab_config'

lib/gitlab_keys.rb

@@ -136,7 +136,7 @@ class GitlabKeys # rubocop:disable Metrics/ClassLength
     lock do
       $logger.info('Removing key', key_id: @key_id)
       open_auth_file('r+') do |f|
-        while line = f.gets # rubocop:disable Style/AssignmentInCondition
+        while line = f.gets # rubocop:disable Lint/AssignmentInCondition
           next unless line.start_with?("command=\"#{self.class.command_key(@key_id)}\"")
           f.seek(-line.length, IO::SEEK_CUR)
           # Overwrite the line with #'s. Because the 'line' variable contains

spec/gitlab_access_spec.rb

@@ -7,7 +7,7 @@ describe GitlabAccess do
   let(:repo_path) { File.join(repository_path, repo_name) + ".git" }
   let(:api) do
     double(GitlabNet).tap do |api|
-      api.stub(check_access: GitAccessStatus.new(true,
+      allow(api).to receive(:check_access).and_return(GitAccessStatus.new(true,
                                                  'ok',
                                                  gl_repository: 'project-1',
                                                  gl_id: 'user-123',
@@ -20,19 +20,19 @@ describe GitlabAccess do
   end
   subject do
     GitlabAccess.new(nil, repo_path, 'key-123', 'wow', 'ssh').tap do |access|
-      access.stub(exec_cmd: :exec_called)
-      access.stub(api: api)
+      allow(access).to receive(:exec_cmd).and_return(:exec_called)
+      allow(access).to receive(:api).and_return(api)
     end
   end
 
   before do
-    GitlabConfig.any_instance.stub(repos_path: repository_path)
+    allow_any_instance_of(GitlabConfig).to receive(:repos_path).and_return(repository_path)
   end
 
   describe :initialize do
-    it { subject.repo_path.should == repo_path }
-    it { subject.changes.should == ['wow'] }
-    it { subject.protocol.should == 'ssh' }
+    it { expect(subject.repo_path).to eq(repo_path) }
+    it { expect(subject.changes).to eq(['wow']) }
+    it { expect(subject.protocol).to eq('ssh') }
   end
 
   describe "#exec" do
@@ -44,7 +44,7 @@ describe GitlabAccess do
 
     context "access is denied" do
       before do
-        api.stub(check_access: GitAccessStatus.new(
+        allow(api).to receive(:check_access).and_return(GitAccessStatus.new(
                   false,
                   'denied',
                   gl_repository: nil,
@@ -64,7 +64,7 @@ describe GitlabAccess do
 
     context "API connection fails" do
       before do
-        api.stub(:check_access).and_raise(GitlabNet::ApiUnreachableError)
+        allow(api).to receive(:check_access).and_raise(GitlabNet::ApiUnreachableError)
       end
 
       it "returns false" do

spec/gitlab_config_spec.rb

@@ -9,27 +9,27 @@ describe GitlabConfig do
     subject { config.gitlab_url }
     before { config.send(:config)['gitlab_url'] = url }
 
-    it { should_not be_empty }
-    it { should eq(url) }
+    it { is_expected.not_to be_empty }
+    it { is_expected.to eq(url) }
 
     context 'remove trailing slashes' do
       before { config.send(:config)['gitlab_url'] = url + '//' }
 
-      it { should eq(url) }
+      it { is_expected.to eq(url) }
     end
   end
 
   describe :audit_usernames do
     subject { config.audit_usernames }
 
-    it("returns false by default") { should eq(false) }
+    it("returns false by default") { is_expected.to eq(false) }
   end
 
   describe :log_format do
     subject { config.log_format }
 
     it 'returns "text" by default' do
-      should eq('text')
+      is_expected.to eq('text')
     end
   end
 end

spec/gitlab_keys_spec.rb

@@ -65,9 +65,9 @@ describe GitlabKeys do
   describe :initialize do
     let(:gitlab_keys) { build_gitlab_keys('add-key', 'key-741', 'ssh-rsa AAAAB3NzaDAxx2E') }
 
-    it { gitlab_keys.key.should == 'ssh-rsa AAAAB3NzaDAxx2E' }
-    it { gitlab_keys.instance_variable_get(:@command).should == 'add-key' }
-    it { gitlab_keys.instance_variable_get(:@key_id).should == 'key-741' }
+    it { expect(gitlab_keys.key).to eq('ssh-rsa AAAAB3NzaDAxx2E') }
+    it { expect(gitlab_keys.instance_variable_get(:@command)).to eq('add-key') }
+    it { expect(gitlab_keys.instance_variable_get(:@key_id)).to eq('key-741') }
   end
 
   describe :add_key do
@@ -77,7 +77,7 @@ describe GitlabKeys do
       create_authorized_keys_fixture
       gitlab_keys.send :add_key
       auth_line = "command=\"#{ROOT_PATH}/bin/gitlab-shell key-741\",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa AAAAB3NzaDAxx2E"
-      File.read(tmp_authorized_keys_path).should == "existing content\n#{auth_line}\n"
+      expect(File.read(tmp_authorized_keys_path)).to eq("existing content\n#{auth_line}\n")
     end
 
     context "without file writing" do
@@ -85,12 +85,12 @@ describe GitlabKeys do
       before { create_authorized_keys_fixture }
 
       it "should log an add-key event" do
-        $logger.should_receive(:info).with("Adding key", {:key_id=>"key-741", :public_key=>"ssh-rsa AAAAB3NzaDAxx2E"})
+        expect($logger).to receive(:info).with("Adding key", {:key_id=>"key-741", :public_key=>"ssh-rsa AAAAB3NzaDAxx2E"})
         gitlab_keys.send :add_key
       end
 
       it "should return true" do
-        gitlab_keys.send(:add_key).should be_truthy
+        expect(gitlab_keys.send(:add_key)).to be_truthy
       end
     end
   end
@@ -104,7 +104,7 @@ describe GitlabKeys do
       create_authorized_keys_fixture
       gitlab_keys.send :add_key
       auth_line1 = 'key-741 AAAAB3NzaDAxx2E'
-      gitlab_keys.send(:list_keys).should == "#{auth_line1}\n"
+      expect(gitlab_keys.send(:list_keys)).to eq("#{auth_line1}\n")
     end
   end
 
@@ -118,10 +118,7 @@ describe GitlabKeys do
     end
 
     it 'outputs the key IDs, separated by newlines' do
-      output = capture_stdout do
-        gitlab_keys.send(:list_key_ids)
-      end
-      output.should match "1\n2\n3\n9000"
+      expect { gitlab_keys.send(:list_key_ids) }.to output("1\n2\n3\n9000\n").to_stdout
     end
   end
 
@@ -130,38 +127,38 @@ describe GitlabKeys do
     let(:fake_stdin) { StringIO.new("key-12\tssh-dsa ASDFASGADG\nkey-123\tssh-rsa GFDGDFSGSDFG\n", 'r') }
     before do
       create_authorized_keys_fixture
-      gitlab_keys.stub(stdin: fake_stdin)
+      allow(gitlab_keys).to receive(:stdin).and_return(fake_stdin)
     end
 
     it "adds lines at the end of the file" do
       gitlab_keys.send :batch_add_keys
       auth_line1 = "command=\"#{ROOT_PATH}/bin/gitlab-shell key-12\",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-dsa ASDFASGADG"
       auth_line2 = "command=\"#{ROOT_PATH}/bin/gitlab-shell key-123\",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty ssh-rsa GFDGDFSGSDFG"
-      File.read(tmp_authorized_keys_path).should == "existing content\n#{auth_line1}\n#{auth_line2}\n"
+      expect(File.read(tmp_authorized_keys_path)).to eq("existing content\n#{auth_line1}\n#{auth_line2}\n")
     end
 
     context "with invalid input" do
       let(:fake_stdin) { StringIO.new("key-12\tssh-dsa ASDFASGADG\nkey-123\tssh-rsa GFDGDFSGSDFG\nfoo\tbar\tbaz\n", 'r') }
 
       it "aborts" do
-        gitlab_keys.should_receive(:abort)
+        expect(gitlab_keys).to receive(:abort)
         gitlab_keys.send :batch_add_keys
       end
     end
 
     context "without file writing" do
       before do
-        gitlab_keys.should_receive(:open).and_yield(double(:file, puts: nil, chmod: nil))
+        expect(gitlab_keys).to receive(:open).and_yield(double(:file, puts: nil, chmod: nil))
       end
 
       it "should log an add-key event" do
-        $logger.should_receive(:info).with("Adding key", key_id: 'key-12', public_key: "ssh-dsa ASDFASGADG")
-        $logger.should_receive(:info).with("Adding key", key_id: 'key-123', public_key: "ssh-rsa GFDGDFSGSDFG")
+        expect($logger).to receive(:info).with("Adding key", key_id: 'key-12', public_key: "ssh-dsa ASDFASGADG")
+        expect($logger).to receive(:info).with("Adding key", key_id: 'key-123', public_key: "ssh-rsa GFDGDFSGSDFG")
         gitlab_keys.send :batch_add_keys
       end
 
       it "should return true" do
-        gitlab_keys.send(:batch_add_keys).should be_truthy
+        expect(gitlab_keys.send(:batch_add_keys)).to be_truthy
       end
     end
   end
@@ -171,7 +168,7 @@ describe GitlabKeys do
     subject { gitlab_keys.send :stdin }
     before { $stdin = 1 }
 
-    it { should equal(1) }
+    it { is_expected.to equal(1) }
   end
 
   describe :rm_key do
@@ -187,22 +184,22 @@ describe GitlabKeys do
       end
       gitlab_keys.send :rm_key
       erased_line = delete_line.gsub(/./, '#')
-      File.read(tmp_authorized_keys_path).should == "existing content\n#{erased_line}\n#{other_line}\n"
+      expect(File.read(tmp_authorized_keys_path)).to eq("existing content\n#{erased_line}\n#{other_line}\n")
     end
 
     context "without file writing" do
       before do
-        gitlab_keys.stub(:open)
-        gitlab_keys.stub(:lock).and_yield
+        allow(gitlab_keys).to receive(:open)
+        allow(gitlab_keys).to receive(:lock).and_yield
       end
 
       it "should log an rm-key event" do
-        $logger.should_receive(:info).with("Removing key", key_id: "key-741")
+        expect($logger).to receive(:info).with("Removing key", key_id: "key-741")
         gitlab_keys.send :rm_key
       end
 
       it "should return true" do
-        gitlab_keys.send(:rm_key).should be_truthy
+        expect(gitlab_keys.send(:rm_key)).to be_truthy
       end
     end
 
@@ -219,7 +216,7 @@ describe GitlabKeys do
         end
         gitlab_keys.send :rm_key
         erased_line = delete_line.gsub(/./, '#')
-        File.read(tmp_authorized_keys_path).should == "existing content\n#{erased_line}\n#{other_line}\n"
+        expect(File.read(tmp_authorized_keys_path)).to eq("existing content\n#{erased_line}\n#{other_line}\n")
       end
     end
   end
@@ -228,8 +225,8 @@ describe GitlabKeys do
     let(:gitlab_keys) { build_gitlab_keys('clear') }
 
     it "should return true" do
-      gitlab_keys.stub(:open)
-      gitlab_keys.send(:clear).should be_truthy
+      allow(gitlab_keys).to receive(:open)
+      expect(gitlab_keys.send(:clear)).to be_truthy
     end
   end
 
@@ -242,7 +239,7 @@ describe GitlabKeys do
     end
 
     it 'returns false if opening raises an exception' do
-      gitlab_keys.should_receive(:open_auth_file).and_raise("imaginary error")
+      expect(gitlab_keys).to receive(:open_auth_file).and_raise("imaginary error")
       expect(gitlab_keys.exec).to eq(false)
     end
 
@@ -257,51 +254,51 @@ describe GitlabKeys do
   describe :exec do
     it 'add-key arg should execute add_key method' do
       gitlab_keys = build_gitlab_keys('add-key')
-      gitlab_keys.should_receive(:add_key)
+      expect(gitlab_keys).to receive(:add_key)
       gitlab_keys.exec
     end
 
     it 'batch-add-keys arg should execute batch_add_keys method' do
       gitlab_keys = build_gitlab_keys('batch-add-keys')
-      gitlab_keys.should_receive(:batch_add_keys)
+      expect(gitlab_keys).to receive(:batch_add_keys)
       gitlab_keys.exec
     end
 
     it 'rm-key arg should execute rm_key method' do
       gitlab_keys = build_gitlab_keys('rm-key')
-      gitlab_keys.should_receive(:rm_key)
+      expect(gitlab_keys).to receive(:rm_key)
       gitlab_keys.exec
     end
 
     it 'clear arg should execute clear method' do
       gitlab_keys = build_gitlab_keys('clear')
-      gitlab_keys.should_receive(:clear)
+      expect(gitlab_keys).to receive(:clear)
       gitlab_keys.exec
     end
 
     it 'check-permissions arg should execute check_permissions method' do
       gitlab_keys = build_gitlab_keys('check-permissions')
-      gitlab_keys.should_receive(:check_permissions)
+      expect(gitlab_keys).to receive(:check_permissions)
       gitlab_keys.exec
     end
 
     it 'should puts message if unknown command arg' do
       gitlab_keys = build_gitlab_keys('change-key')
-      gitlab_keys.should_receive(:puts).with('not allowed')
+      expect(gitlab_keys).to receive(:puts).with('not allowed')
       gitlab_keys.exec
     end
 
     it 'should log a warning on unknown commands' do
       gitlab_keys = build_gitlab_keys('nooope')
-      gitlab_keys.stub(puts: nil)
-      $logger.should_receive(:warn).with("Attempt to execute invalid gitlab-keys command", command: '"nooope"')
+      allow(gitlab_keys).to receive(:puts).and_return(nil)
+      expect($logger).to receive(:warn).with("Attempt to execute invalid gitlab-keys command", command: '"nooope"')
       gitlab_keys.exec
     end
   end
 
   describe :lock do
     before do
-      GitlabKeys.any_instance.stub(lock_file: tmp_lock_file_path)
+      allow_any_instance_of(GitlabKeys).to receive(:lock_file).and_return(tmp_lock_file_path)
     end
 
     it "should raise exception if operation lasts more then timeout" do
@@ -335,7 +332,7 @@ describe GitlabKeys do
       end
 
       thr1.join
-      $global.should == "foobar"
+      expect($global).to eq("foobar")
     end
   end
 
@@ -353,7 +350,7 @@ describe GitlabKeys do
   def create_authorized_keys_fixture(existing_content: 'existing content')
     FileUtils.mkdir_p(File.dirname(tmp_authorized_keys_path))
     open(tmp_authorized_keys_path, 'w') { |file| file.puts(existing_content) }
-    gitlab_keys.stub(auth_file: tmp_authorized_keys_path)
+    allow(gitlab_keys).to receive(:auth_file).and_return(tmp_authorized_keys_path)
   end
 
   def tmp_authorized_keys_path

spec/gitlab_lfs_authentication_spec.rb

@@ -16,22 +16,22 @@ describe GitlabLfsAuthentication do
   end
 
   describe '#build_from_json' do
-    it { subject.username.should == 'dzaporozhets' }
-    it { subject.lfs_token.should == 'wsnys8Zm8Jn7zyhHTAAK' }
-    it { subject.repository_http_path.should == 'http://gitlab.dev/repo' }
+    it { expect(subject.username).to eq('dzaporozhets') }
+    it { expect(subject.lfs_token).to eq('wsnys8Zm8Jn7zyhHTAAK') }
+    it { expect(subject.repository_http_path).to eq('http://gitlab.dev/repo') }
   end
 
   describe '#authentication_payload' do
     result = "{\"header\":{\"Authorization\":\"Basic ZHphcG9yb3poZXRzOndzbnlzOFptOEpuN3p5aEhUQUFL\"},\"href\":\"http://gitlab.dev/repo/info/lfs/\"}"
 
-    it { subject.authentication_payload.should eq(result) }
+    it { expect(subject.authentication_payload).to eq(result) }
 
     it 'should be a proper JSON' do
       payload = subject.authentication_payload
       json_payload = JSON.parse(payload)
 
-      json_payload['header']['Authorization'].should eq('Basic ZHphcG9yb3poZXRzOndzbnlzOFptOEpuN3p5aEhUQUFL')
-      json_payload['href'].should eq('http://gitlab.dev/repo/info/lfs/')
+      expect(json_payload['header']['Authorization']).to eq('Basic ZHphcG9yb3poZXRzOndzbnlzOFptOEpuN3p5aEhUQUFL')
+      expect(json_payload['href']).to eq('http://gitlab.dev/repo/info/lfs/')
     end
   end
 end

spec/gitlab_logger_spec.rb

@@ -6,8 +6,8 @@ describe :convert_log_level do
   subject { convert_log_level :extreme }
 
   it "converts invalid log level to Logger::INFO" do
-    $stderr.should_receive(:puts).at_least(:once)
-    should eq(Logger::INFO)
+    expect($stderr).to receive(:puts).at_least(:once)
+    is_expected.to eq(Logger::INFO)
   end
 end
 

spec/gitlab_net_spec.rb

@@ -14,27 +14,27 @@ describe GitlabNet, vcr: true do
 
   before do
     $logger = double('logger').as_null_object
-    gitlab_net.stub(:base_api_endpoint).and_return(base_api_endpoint)
-    gitlab_net.stub(:secret_token).and_return(secret)
+    allow(gitlab_net).to receive(:base_api_endpoint).and_return(base_api_endpoint)
+    allow(gitlab_net).to receive(:secret_token).and_return(secret)
   end
 
   describe '#check' do
     it 'should return 200 code for gitlab check' do
       VCR.use_cassette("check-ok") do
         result = gitlab_net.check
-        result.code.should == '200'
+        expect(result.code).to eq('200')
       end
     end
 
     it 'adds the secret_token to request' do
       VCR.use_cassette("check-ok") do
-        Net::HTTP::Get.any_instance.should_receive(:set_form_data).with(hash_including(secret_token: secret))
+        expect_any_instance_of(Net::HTTP::Get).to receive(:set_form_data).with(hash_including(secret_token: secret))
         gitlab_net.check
       end
     end
 
     it "raises an exception if the connection fails" do
-      Net::HTTP.any_instance.stub(:request).and_raise(StandardError)
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_raise(StandardError)
       expect { gitlab_net.check }.to raise_error(GitlabNet::ApiUnreachableError)
     end
   end
@@ -43,21 +43,21 @@ describe GitlabNet, vcr: true do
     it 'should return user has based on key id' do
       VCR.use_cassette("discover-ok") do
         user = gitlab_net.discover(key)
-        user['name'].should == 'Administrator'
-        user['username'].should == 'root'
+        expect(user['name']).to eq('Administrator')
+        expect(user['username']).to eq('root')
       end
     end
 
     it 'adds the secret_token to request' do
       VCR.use_cassette("discover-ok") do
-        Net::HTTP::Get.any_instance.should_receive(:set_form_data).with(hash_including(secret_token: secret))
+        expect_any_instance_of(Net::HTTP::Get).to receive(:set_form_data).with(hash_including(secret_token: secret))
         gitlab_net.discover(key)
       end
     end
 
     it "raises an exception if the connection fails" do
       VCR.use_cassette("discover-ok") do
-        Net::HTTP.any_instance.stub(:request).and_raise(StandardError)
+        allow_any_instance_of(Net::HTTP).to receive(:request).and_raise(StandardError)
         expect { gitlab_net.discover(key) }.to raise_error(GitlabNet::ApiUnreachableError)
       end
     end
@@ -68,9 +68,9 @@ describe GitlabNet, vcr: true do
       it 'should return the correct data' do
         VCR.use_cassette('lfs-authenticate-ok') do
           lfs_access = gitlab_net.lfs_authenticate(key, project)
-          lfs_access.username.should == 'root'
-          lfs_access.lfs_token.should == 'Hyzhyde_wLUeyUQsR3tHGTG8eNocVQm4ssioTEsBSdb6KwCSzQ'
-          lfs_access.repository_http_path.should == URI.join(internal_api_endpoint.sub('api/v4', ''), project).to_s
+          expect(lfs_access.username).to eq('root')
+          expect(lfs_access.lfs_token).to eq('Hyzhyde_wLUeyUQsR3tHGTG8eNocVQm4ssioTEsBSdb6KwCSzQ')
+          expect(lfs_access.repository_http_path).to eq(URI.join(internal_api_endpoint.sub('api/v4', ''), project).to_s)
         end
       end
     end
@@ -81,7 +81,7 @@ describe GitlabNet, vcr: true do
       it 'should return message' do
         VCR.use_cassette("broadcast_message-ok") do
           result = gitlab_net.broadcast_message
-          result["message"].should == "Message"
+          expect(result["message"]).to eq("Message")
         end
       end
     end
@@ -90,7 +90,7 @@ describe GitlabNet, vcr: true do
       it 'should return nil' do
         VCR.use_cassette("broadcast_message-none") do
           result = gitlab_net.broadcast_message
-          result.should == {}
+          expect(result).to eq({})
         end
       end
     end
@@ -102,13 +102,13 @@ describe GitlabNet, vcr: true do
     let(:encoded_changes) { "123456%20789012%20refs/heads/test%0A654321%20210987%20refs/tags/tag" }
 
     it "sends the given arguments as encoded URL parameters" do
-      gitlab_net.should_receive(:get).with("#{internal_api_endpoint}/merge_request_urls?project=#{project}&changes=#{encoded_changes}&gl_repository=#{gl_repository}")
+      expect(gitlab_net).to receive(:get).with("#{internal_api_endpoint}/merge_request_urls?project=#{project}&changes=#{encoded_changes}&gl_repository=#{gl_repository}")
 
       gitlab_net.merge_request_urls(gl_repository, project, changes)
     end
 
     it "omits the gl_repository parameter if it's nil" do
-      gitlab_net.should_receive(:get).with("#{internal_api_endpoint}/merge_request_urls?project=#{project}&changes=#{encoded_changes}")
+      expect(gitlab_net).to receive(:get).with("#{internal_api_endpoint}/merge_request_urls?project=#{project}&changes=#{encoded_changes}")
 
       gitlab_net.merge_request_urls(nil, project, changes)
     end
@@ -135,7 +135,7 @@ describe GitlabNet, vcr: true do
     subject { gitlab_net.pre_receive(gl_repository) }
 
     it 'sends the correct parameters and returns the request body parsed' do
-      Net::HTTP::Post.any_instance.should_receive(:set_form_data)
+      expect_any_instance_of(Net::HTTP::Post).to receive(:set_form_data)
         .with(hash_including(params))
 
       VCR.use_cassette("pre-receive") { subject }
@@ -171,7 +171,7 @@ describe GitlabNet, vcr: true do
     subject { gitlab_net.post_receive(gl_repository, key, changes) }
 
     it 'sends the correct parameters' do
-      Net::HTTP::Post.any_instance.should_receive(:set_form_data).with(hash_including(params))
+      expect_any_instance_of(Net::HTTP::Post).to receive(:set_form_data).with(hash_including(params))
 
 
       VCR.use_cassette("post-receive") do
@@ -200,21 +200,21 @@ describe GitlabNet, vcr: true do
     it "should return nil when the resource is not implemented" do
       VCR.use_cassette("ssh-key-not-implemented") do
         result = gitlab_net.authorized_key("whatever")
-        result.should be_nil
+        expect(result).to be_nil
       end
     end
 
     it "should return nil when the fingerprint is not found" do
       VCR.use_cassette("ssh-key-not-found") do
         result = gitlab_net.authorized_key("whatever")
-        result.should be_nil
+        expect(result).to be_nil
       end
     end
 
     it "should return a ssh key with a valid fingerprint" do
       VCR.use_cassette("ssh-key-ok") do
         result = gitlab_net.authorized_key(ssh_key)
-        result.should eq({
+        expect(result).to eq({
           "can_push" => false,
           "created_at" => "2017-06-21T09:50:07.150Z",
           "id" => 99,
@@ -252,7 +252,7 @@ describe GitlabNet, vcr: true do
 
     it 'sets the arguments as form parameters' do
       VCR.use_cassette('notify-post-receive') do
-        Net::HTTP::Post.any_instance.should_receive(:set_form_data).with(hash_including(params))
+        expect_any_instance_of(Net::HTTP::Post).to receive(:set_form_data).with(hash_including(params))
         gitlab_net.notify_post_receive(gl_repository, repo_path)
       end
     end
@@ -269,13 +269,13 @@ describe GitlabNet, vcr: true do
       it 'should allow pull access for host' do
         VCR.use_cassette("allowed-pull") do
           access = gitlab_net.check_access('git-receive-pack', nil, project, key, changes, 'ssh')
-          access.allowed?.should be_truthy
+          expect(access.allowed?).to be_truthy
         end
       end
 
       it 'adds the secret_token to the request' do
         VCR.use_cassette("allowed-pull") do
-          Net::HTTP::Post.any_instance.should_receive(:set_form_data).with(hash_including(secret_token: secret))
+          expect_any_instance_of(Net::HTTP::Post).to receive(:set_form_data).with(hash_including(secret_token: secret))
           gitlab_net.check_access('git-receive-pack', nil, project, key, changes, 'ssh')
         end
       end
@@ -283,7 +283,7 @@ describe GitlabNet, vcr: true do
       it 'should allow push access for host' do
         VCR.use_cassette("allowed-push") do
           access = gitlab_net.check_access('git-upload-pack', nil, project, key, changes, 'ssh')
-          access.allowed?.should be_truthy
+          expect(access.allowed?).to be_truthy
         end
       end
     end
@@ -292,16 +292,16 @@ describe GitlabNet, vcr: true do
       it 'should deny pull access for host' do
         VCR.use_cassette('ssh-pull-disabled') do
           access = gitlab_net.check_access('git-upload-pack', nil, project, key, changes, 'ssh')
-          access.allowed?.should be_falsey
-          access.message.should eq 'Git access over SSH is not allowed'
+          expect(access.allowed?).to be_falsey
+          expect(access.message).to eq 'Git access over SSH is not allowed'
         end
       end
 
       it 'should deny push access for host' do
         VCR.use_cassette('ssh-push-disabled') do
           access = gitlab_net.check_access('git-receive-pack', nil, project, key, changes, 'ssh')
-          access.allowed?.should be_falsey
-          access.message.should eq 'Git access over SSH is not allowed'
+          expect(access.allowed?).to be_falsey
+          expect(access.message).to eq 'Git access over SSH is not allowed'
         end
       end
     end
@@ -310,16 +310,16 @@ describe GitlabNet, vcr: true do
       it 'should deny pull access for host' do
         VCR.use_cassette('http-pull-disabled') do
           access = gitlab_net.check_access('git-upload-pack', nil, project, key, changes, 'http')
-          access.allowed?.should be_falsey
-          access.message.should eq 'Pulling over HTTP is not allowed.'
+          expect(access.allowed?).to be_falsey
+          expect(access.message).to eq 'Pulling over HTTP is not allowed.'
         end
       end
 
       it 'should deny push access for host' do
         VCR.use_cassette("http-push-disabled") do
           access = gitlab_net.check_access('git-receive-pack', nil, project, key, changes, 'http')
-          access.allowed?.should be_falsey
-          access.message.should eq 'Pushing over HTTP is not allowed.'
+          expect(access.allowed?).to be_falsey
+          expect(access.message).to eq 'Pushing over HTTP is not allowed.'
         end
       end
     end
@@ -328,27 +328,27 @@ describe GitlabNet, vcr: true do
       it 'should deny pull access for host' do
         VCR.use_cassette("ssh-pull-project-denied") do
           access = gitlab_net.check_access('git-receive-pack', nil, project, key2, changes, 'ssh')
-          access.allowed?.should be_falsey
+          expect(access.allowed?).to be_falsey
         end
       end
 
       it 'should deny push access for host' do
         VCR.use_cassette("ssh-push-project-denied") do
           access = gitlab_net.check_access('git-upload-pack', nil, project, key2, changes, 'ssh')
-          access.allowed?.should be_falsey
+          expect(access.allowed?).to be_falsey
         end
       end
 
       it 'should deny push access for host (with user)' do
         VCR.use_cassette("ssh-push-project-denied-with-user") do
           access = gitlab_net.check_access('git-upload-pack', nil, project, 'user-2', changes, 'ssh')
-          access.allowed?.should be_falsey
+          expect(access.allowed?).to be_falsey
         end
       end
     end
 
     it "raises an exception if the connection fails" do
-      Net::HTTP.any_instance.stub(:request).and_raise(StandardError)
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_raise(StandardError)
       expect {
         gitlab_net.check_access('git-upload-pack', nil, project, 'user-1', changes, 'ssh')
       }.to raise_error(GitlabNet::ApiUnreachableError)
@@ -361,7 +361,7 @@ describe GitlabNet, vcr: true do
     subject { net.send :base_api_endpoint }
 
     it { is_expected.to include(net.send(:config).gitlab_url) }
-    it("uses API version 4") { should end_with("api/v4") }
+    it("uses API version 4") { is_expected.to end_with("api/v4") }
   end
 
   describe '#internal_api_endpoint' do
@@ -370,18 +370,18 @@ describe GitlabNet, vcr: true do
     subject { net.send :internal_api_endpoint }
 
     it { is_expected.to include(net.send(:config).gitlab_url) }
-    it("uses API version 4") { should end_with("api/v4/internal") }
+    it("uses API version 4") { is_expected.to end_with("api/v4/internal") }
   end
 
   describe '#http_client_for' do
     subject { gitlab_net.send :http_client_for, URI('https://localhost/') }
 
     before do
-      gitlab_net.stub :cert_store
-      gitlab_net.send(:config).stub(:http_settings) { {'self_signed_cert' => true} }
+      allow(gitlab_net).to receive :cert_store
+      allow(gitlab_net.send(:config)).to receive(:http_settings) { {'self_signed_cert' => true} }
     end
 
-    its(:verify_mode) { should eq(OpenSSL::SSL::VERIFY_NONE) }
+    it { expect(subject.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE) }
   end
 
   describe '#http_request_for' do
@@ -398,42 +398,42 @@ describe GitlabNet, vcr: true do
         subject { gitlab_net.send :http_request_for, :get, url }
 
         before do
-          gitlab_net.send(:config).http_settings.stub(:[]).with('user') { user }
-          gitlab_net.send(:config).http_settings.stub(:[]).with('password') { password }
-          Net::HTTP::Get.should_receive(:new).with('/', {}).and_return(get)
-          get.should_receive(:basic_auth).with(user, password).once
-          get.should_receive(:set_form_data).with(hash_including(secret_token: secret)).once
+          allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('user') { user }
+          allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('password') { password }
+          expect(Net::HTTP::Get).to receive(:new).with('/', {}).and_return(get)
+          expect(get).to receive(:basic_auth).with(user, password).once
+          expect(get).to receive(:set_form_data).with(hash_including(secret_token: secret)).once
         end
 
-        it { should_not be_nil }
+        it { is_expected.not_to be_nil }
       end
 
       context 'with params' do
         subject { gitlab_net.send :http_request_for, :get, url, params: params, headers: headers }
 
         before do
-          gitlab_net.send(:config).http_settings.stub(:[]).with('user') { user }
-          gitlab_net.send(:config).http_settings.stub(:[]).with('password') { password }
-          Net::HTTP::Get.should_receive(:new).with('/', headers).and_return(get)
-          get.should_receive(:basic_auth).with(user, password).once
-          get.should_receive(:set_form_data).with({ 'key1' => 'value1', secret_token: secret }).once
+          allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('user') { user }
+          allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('password') { password }
+          expect(Net::HTTP::Get).to receive(:new).with('/', headers).and_return(get)
+          expect(get).to receive(:basic_auth).with(user, password).once
+          expect(get).to receive(:set_form_data).with({ 'key1' => 'value1', secret_token: secret }).once
         end
 
-        it { should_not be_nil }
+        it { is_expected.not_to be_nil }
       end
 
       context 'with headers' do
         subject { gitlab_net.send :http_request_for, :get, url, headers: headers }
 
         before do
-          gitlab_net.send(:config).http_settings.stub(:[]).with('user') { user }
-          gitlab_net.send(:config).http_settings.stub(:[]).with('password') { password }
-          Net::HTTP::Get.should_receive(:new).with('/', headers).and_return(get)
-          get.should_receive(:basic_auth).with(user, password).once
-          get.should_receive(:set_form_data).with(hash_including(secret_token: secret)).once
+          allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('user') { user }
+          allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('password') { password }
+          expect(Net::HTTP::Get).to receive(:new).with('/', headers).and_return(get)
+          expect(get).to receive(:basic_auth).with(user, password).once
+          expect(get).to receive(:set_form_data).with(hash_including(secret_token: secret)).once
         end
 
-        it { should_not be_nil }
+        it { is_expected.not_to be_nil }
       end
 
       context 'with options' do
@@ -441,15 +441,15 @@ describe GitlabNet, vcr: true do
           subject { gitlab_net.send :http_request_for, :get, url, options: options }
 
           before do
-            gitlab_net.send(:config).http_settings.stub(:[]).with('user') { user }
-            gitlab_net.send(:config).http_settings.stub(:[]).with('password') { password }
-            Net::HTTP::Get.should_receive(:new).with('/', {}).and_return(get)
-            get.should_receive(:basic_auth).with(user, password).once
-            get.should_receive(:body=).with({ 'key2' => 'value2', secret_token: secret }.to_json).once
-            get.should_not_receive(:set_form_data)
+            allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('user') { user }
+            allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('password') { password }
+            expect(Net::HTTP::Get).to receive(:new).with('/', {}).and_return(get)
+            expect(get).to receive(:basic_auth).with(user, password).once
+            expect(get).to receive(:body=).with({ 'key2' => 'value2', secret_token: secret }.to_json).once
+            expect(get).not_to receive(:set_form_data)
           end
 
-          it { should_not be_nil }
+          it { is_expected.not_to be_nil }
         end
       end
     end
@@ -457,7 +457,7 @@ describe GitlabNet, vcr: true do
     context 'Unix socket' do
       it 'sets the Host header to "localhost"' do
         gitlab_net = described_class.new
-        gitlab_net.should_receive(:secret_token).and_return(secret)
+        expect(gitlab_net).to receive(:secret_token).and_return(secret)
 
         request = gitlab_net.send(:http_request_for, :get, URI('http+unix://%2Ffoo'))
 
@@ -469,12 +469,12 @@ describe GitlabNet, vcr: true do
   describe '#cert_store' do
     let(:store) do
       double(OpenSSL::X509::Store).tap do |store|
-        OpenSSL::X509::Store.stub(:new) { store }
+        allow(OpenSSL::X509::Store).to receive(:new) { store }
       end
     end
 
     before :each do
-      store.should_receive(:set_default_paths).once
+      expect(store).to receive(:set_default_paths).once
     end
 
     after do
@@ -482,17 +482,17 @@ describe GitlabNet, vcr: true do
     end
 
     it "calls add_file with http_settings['ca_file']" do
-      gitlab_net.send(:config).http_settings.stub(:[]).with('ca_file') { 'test_file' }
-      gitlab_net.send(:config).http_settings.stub(:[]).with('ca_path') { nil }
-      store.should_receive(:add_file).with('test_file')
-      store.should_not_receive(:add_path)
+      allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('ca_file') { 'test_file' }
+      allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('ca_path') { nil }
+      expect(store).to receive(:add_file).with('test_file')
+      expect(store).not_to receive(:add_path)
     end
 
     it "calls add_path with http_settings['ca_path']" do
-      gitlab_net.send(:config).http_settings.stub(:[]).with('ca_file') { nil }
-      gitlab_net.send(:config).http_settings.stub(:[]).with('ca_path') { 'test_path' }
-      store.should_not_receive(:add_file)
-      store.should_receive(:add_path).with('test_path')
+      allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('ca_file') { nil }
+      allow(gitlab_net.send(:config).http_settings).to receive(:[]).with('ca_path') { 'test_path' }
+      expect(store).not_to receive(:add_file)
+      expect(store).to receive(:add_path).with('test_path')
     end
   end
 end

spec/gitlab_post_receive_spec.rb

@@ -31,7 +31,7 @@ describe GitlabPostReceive do
 
   before do
     $logger = double('logger').as_null_object # Global vars are bad
-    GitlabConfig.any_instance.stub(repos_path: repository_path)
+    allow_any_instance_of(GitlabConfig).to receive(:repos_path).and_return(repository_path)
   end
 
   describe "#exec" do

spec/gitlab_shell_spec.rb

@@ -15,8 +15,8 @@ describe GitlabShell do
   subject do
     ARGV[0] = gl_id
     GitlabShell.new(gl_id).tap do |shell|
-      shell.stub(exec_cmd: :exec_called)
-      shell.stub(api: api)
+      allow(shell).to receive(:exec_cmd).and_return(:exec_called)
+      allow(shell).to receive(:api).and_return(api)
     end
   end
 
@@ -37,8 +37,8 @@ describe GitlabShell do
 
   let(:api) do
     double(GitlabNet).tap do |api|
-      api.stub(discover: { 'name' => 'John Doe', 'username' => 'testuser' })
-      api.stub(check_access: GitAccessStatus.new(
+      allow(api).to receive(:discover).and_return({ 'name' => 'John Doe', 'username' => 'testuser' })
+      allow(api).to receive(:check_access).and_return(GitAccessStatus.new(
                 true,
                 'ok',
                 gl_repository: gl_repository,
@@ -48,7 +48,7 @@ describe GitlabShell do
                 repository_path: repo_path,
                 gitaly: nil,
                 git_protocol: git_protocol))
-      api.stub(two_factor_recovery_codes: {
+      allow(api).to receive(:two_factor_recovery_codes).and_return({
                  'success' => true,
                  'recovery_codes' => %w[f67c514de60c4953 41278385fc00c1e0]
                })
@@ -68,13 +68,13 @@ describe GitlabShell do
   let(:git_protocol) { 'version=2' }
 
   before do
-    GitlabConfig.any_instance.stub(audit_usernames: false)
+    allow_any_instance_of(GitlabConfig).to receive(:audit_usernames).and_return(false)
   end
 
   describe :initialize do
     let(:ssh_cmd) { 'git-receive-pack' }
 
-    its(:gl_id) { should == gl_id }
+    it { expect(subject.gl_id).to eq gl_id }
   end
 
   describe :parse_cmd do
@@ -86,8 +86,10 @@ describe GitlabShell do
           subject.send :parse_cmd, ssh_args
         end
 
-        its(:repo_name) { should == 'gitlab-ci.git' }
-        its(:command) { should == 'git-upload-pack' }
+        it 'has the correct attributes' do
+          expect(subject.repo_name).to eq 'gitlab-ci.git'
+          expect(subject.command).to eq 'git-upload-pack'
+        end
       end
 
       context 'namespace' do
@@ -98,8 +100,10 @@ describe GitlabShell do
           subject.send :parse_cmd, ssh_args
         end
 
-        its(:repo_name) { should == 'dmitriy.zaporozhets/gitlab-ci.git' }
-        its(:command) { should == 'git-upload-pack' }
+        it 'has the correct attributes' do
+          expect(subject.repo_name).to eq 'dmitriy.zaporozhets/gitlab-ci.git'
+          expect(subject.command).to eq 'git-upload-pack'
+        end
       end
 
       context 'with an invalid number of arguments' do
@@ -137,9 +141,11 @@ describe GitlabShell do
         subject.send :parse_cmd, ssh_args
       end
 
-      its(:repo_name) { should == 'dzaporozhets/gitlab.git' }
-      its(:command) { should == 'git-lfs-authenticate' }
-      its(:git_access) { should == 'git-upload-pack' }
+      it 'has the correct attributes' do
+        expect(subject.repo_name).to eq 'dzaporozhets/gitlab.git'
+        expect(subject.command).to eq 'git-lfs-authenticate'
+        expect(subject.git_access).to eq 'git-upload-pack'
+      end
     end
 
     describe 'git-lfs old clients' do
@@ -150,9 +156,11 @@ describe GitlabShell do
         subject.send :parse_cmd, ssh_args
       end
 
-      its(:repo_name) { should == 'dzaporozhets/gitlab.git' }
-      its(:command) { should == 'git-lfs-authenticate' }
-      its(:git_access) { should == 'git-upload-pack' }
+      it 'has the correct attributes' do
+        expect(subject.repo_name).to eq 'dzaporozhets/gitlab.git'
+        expect(subject.command).to eq 'git-lfs-authenticate'
+        expect(subject.git_access).to eq 'git-upload-pack'
+      end
     end
   end
 
@@ -177,22 +185,22 @@ describe GitlabShell do
       after { subject.exec(ssh_cmd) }
 
       it "should process the command" do
-        subject.should_receive(:process_cmd).with(%w(git-upload-pack gitlab-ci.git))
+        expect(subject).to receive(:process_cmd).with(%w(git-upload-pack gitlab-ci.git))
       end
 
       it "should execute the command" do
-        subject.should_receive(:exec_cmd).with('git-upload-pack', repo_path)
+        expect(subject).to receive(:exec_cmd).with('git-upload-pack', repo_path)
       end
 
       it "should log the command execution" do
         message = "executing git command"
         user_string = "user with id #{gl_id}"
-        $logger.should_receive(:info).with(message, command: "git-upload-pack #{repo_path}", user: user_string)
+        expect($logger).to receive(:info).with(message, command: "git-upload-pack #{repo_path}", user: user_string)
       end
 
       it "should use usernames if configured to do so" do
-        GitlabConfig.any_instance.stub(audit_usernames: true)
-        $logger.should_receive(:info).with("executing git command", hash_including(user: 'testuser'))
+        allow_any_instance_of(GitlabConfig).to receive(:audit_usernames).and_return(true)
+        expect($logger).to receive(:info).with("executing git command", hash_including(user: 'testuser'))
       end
     end
 
@@ -207,27 +215,27 @@ describe GitlabShell do
     context 'gitaly-upload-pack' do
       let(:ssh_cmd) { "git-upload-pack gitlab-ci.git" }
       before do
-        api.stub(check_access: gitaly_check_access)
+        allow(api).to receive(:check_access).and_return(gitaly_check_access)
       end
       after { subject.exec(ssh_cmd) }
 
       it "should process the command" do
-        subject.should_receive(:process_cmd).with(%w(git-upload-pack gitlab-ci.git))
+        expect(subject).to receive(:process_cmd).with(%w(git-upload-pack gitlab-ci.git))
       end
 
       it "should execute the command" do
-        subject.should_receive(:exec_cmd).with(File.join(ROOT_PATH, "bin/gitaly-upload-pack"), 'unix:gitaly.socket', gitaly_message)
+        expect(subject).to receive(:exec_cmd).with(File.join(ROOT_PATH, "bin/gitaly-upload-pack"), 'unix:gitaly.socket', gitaly_message)
       end
 
       it "should log the command execution" do
         message = "executing git command"
         user_string = "user with id #{gl_id}"
-        $logger.should_receive(:info).with(message, command: "gitaly-upload-pack unix:gitaly.socket #{gitaly_message}", user: user_string)
+        expect($logger).to receive(:info).with(message, command: "gitaly-upload-pack unix:gitaly.socket #{gitaly_message}", user: user_string)
       end
 
       it "should use usernames if configured to do so" do
-        GitlabConfig.any_instance.stub(audit_usernames: true)
-        $logger.should_receive(:info).with("executing git command", hash_including(user: 'testuser'))
+        allow_any_instance_of(GitlabConfig).to receive(:audit_usernames).and_return(true)
+        expect($logger).to receive(:info).with("executing git command", hash_including(user: 'testuser'))
       end
     end
 
@@ -236,44 +244,44 @@ describe GitlabShell do
       after { subject.exec(ssh_cmd) }
 
       it "should process the command" do
-        subject.should_receive(:process_cmd).with(%w(git-receive-pack gitlab-ci.git))
+        expect(subject).to receive(:process_cmd).with(%w(git-receive-pack gitlab-ci.git))
       end
 
       it "should execute the command" do
-        subject.should_receive(:exec_cmd).with('git-receive-pack', repo_path)
+        expect(subject).to receive(:exec_cmd).with('git-receive-pack', repo_path)
       end
 
       it "should log the command execution" do
         message = "executing git command"
         user_string = "user with id #{gl_id}"
-        $logger.should_receive(:info).with(message, command: "git-receive-pack #{repo_path}", user: user_string)
+        expect($logger).to receive(:info).with(message, command: "git-receive-pack #{repo_path}", user: user_string)
       end
     end
 
     context 'gitaly-receive-pack' do
       let(:ssh_cmd) { "git-receive-pack gitlab-ci.git" }
       before do
-        api.stub(check_access: gitaly_check_access)
+        allow(api).to receive(:check_access).and_return(gitaly_check_access)
       end
       after { subject.exec(ssh_cmd) }
 
       it "should process the command" do
-        subject.should_receive(:process_cmd).with(%w(git-receive-pack gitlab-ci.git))
+        expect(subject).to receive(:process_cmd).with(%w(git-receive-pack gitlab-ci.git))
       end
 
       it "should execute the command" do
-        subject.should_receive(:exec_cmd).with(File.join(ROOT_PATH, "bin/gitaly-receive-pack"), 'unix:gitaly.socket', gitaly_message)
+        expect(subject).to receive(:exec_cmd).with(File.join(ROOT_PATH, "bin/gitaly-receive-pack"), 'unix:gitaly.socket', gitaly_message)
       end
 
       it "should log the command execution" do
         message = "executing git command"
         user_string = "user with id #{gl_id}"
-        $logger.should_receive(:info).with(message, command: "gitaly-receive-pack unix:gitaly.socket #{gitaly_message}", user: user_string)
+        expect($logger).to receive(:info).with(message, command: "gitaly-receive-pack unix:gitaly.socket #{gitaly_message}", user: user_string)
       end
 
       it "should use usernames if configured to do so" do
-        GitlabConfig.any_instance.stub(audit_usernames: true)
-        $logger.should_receive(:info).with("executing git command", hash_including(user: 'testuser'))
+        allow_any_instance_of(GitlabConfig).to receive(:audit_usernames).and_return(true)
+        expect($logger).to receive(:info).with("executing git command", hash_including(user: 'testuser'))
       end
     end
 
@@ -285,22 +293,22 @@ describe GitlabShell do
       after { subject.exec(ssh_cmd) }
 
       it "should process the command" do
-        subject.should_receive(:process_cmd).with(%w(git-upload-archive gitlab-ci.git))
+        expect(subject).to receive(:process_cmd).with(%w(git-upload-archive gitlab-ci.git))
       end
 
       it "should execute the command" do
-        subject.should_receive(:exec_cmd).with(*exec_cmd_params)
+        expect(subject).to receive(:exec_cmd).with(*exec_cmd_params)
       end
 
       it "should log the command execution" do
         message = "executing git command"
         user_string = "user with id #{gl_id}"
-        $logger.should_receive(:info).with(message, command: exec_cmd_log_params.join(' '), user: user_string)
+        expect($logger).to receive(:info).with(message, command: exec_cmd_log_params.join(' '), user: user_string)
       end
 
       it "should use usernames if configured to do so" do
-        GitlabConfig.any_instance.stub(audit_usernames: true)
-        $logger.should_receive(:info).with("executing git command", hash_including(user: 'testuser'))
+        allow_any_instance_of(GitlabConfig).to receive(:audit_usernames).and_return(true)
+        expect($logger).to receive(:info).with("executing git command", hash_including(user: 'testuser'))
       end
     end
 
@@ -314,7 +322,7 @@ describe GitlabShell do
 
     context 'gitaly-upload-archive' do
       before do
-        api.stub(check_access: gitaly_check_access)
+        allow(api).to receive(:check_access).and_return(gitaly_check_access)
       end
 
       it_behaves_like 'upload-archive', 'git-upload-archive' do
@@ -337,17 +345,17 @@ describe GitlabShell do
       after { subject.exec(ssh_cmd) }
 
       it "should not process the command" do
-        subject.should_not_receive(:process_cmd)
+        expect(subject).not_to receive(:process_cmd)
       end
 
       it "should not execute the command" do
-        subject.should_not_receive(:exec_cmd)
+        expect(subject).not_to receive(:exec_cmd)
       end
 
       it "should log the attempt" do
         message = 'Denied disallowed command'
         user_string = "user with id #{gl_id}"
-        $logger.should_receive(:warn).with(message, command: 'arbitrary command', user: user_string)
+        expect($logger).to receive(:warn).with(message, command: 'arbitrary command', user: user_string)
       end
     end
 
@@ -355,7 +363,7 @@ describe GitlabShell do
       after { subject.exec(nil) }
 
       it "should call api.discover" do
-        api.should_receive(:discover).with(gl_id)
+        expect(api).to receive(:discover).with(gl_id)
       end
     end
 
@@ -363,16 +371,16 @@ describe GitlabShell do
       let(:ssh_cmd) { 'git-upload-pack gitlab-ci.git' }
 
       before do
-        api.stub(:check_access).and_raise(GitlabNet::ApiUnreachableError)
+        allow(api).to receive(:check_access).and_raise(GitlabNet::ApiUnreachableError)
       end
       after { subject.exec(ssh_cmd) }
 
       it "should not process the command" do
-        subject.should_not_receive(:process_cmd)
+        expect(subject).not_to receive(:process_cmd)
       end
 
       it "should not execute the command" do
-        subject.should_not_receive(:exec_cmd)
+        expect(subject).not_to receive(:exec_cmd)
       end
     end
 
@@ -402,7 +410,7 @@ describe GitlabShell do
 
         context 'when the process is unsuccessful' do
           it 'displays the error to the user' do
-            api.stub(two_factor_recovery_codes: {
+            allow(api).to receive(:two_factor_recovery_codes).and_return({
                        'success' => false,
                        'message' => 'Could not find the given key'
                      })
@@ -422,11 +430,11 @@ describe GitlabShell do
       after { subject.exec(ssh_cmd) }
 
       it "should call api.check_access" do
-        api.should_receive(:check_access).with('git-upload-pack', nil, 'gitlab-ci.git', gl_id, '_any', 'ssh')
+        expect(api).to receive(:check_access).with('git-upload-pack', nil, 'gitlab-ci.git', gl_id, '_any', 'ssh')
       end
 
       it "should disallow access and log the attempt if check_access returns false status" do
-        api.stub(check_access: GitAccessStatus.new(
+        allow(api).to receive(:check_access).and_return(GitAccessStatus.new(
                   false,
                   'denied',
                   gl_repository: nil,
@@ -438,7 +446,7 @@ describe GitlabShell do
                   git_protocol: nil))
         message = 'Access denied'
         user_string = "user with id #{gl_id}"
-        $logger.should_receive(:warn).with(message, command: 'git-upload-pack gitlab-ci.git', user: user_string)
+        expect($logger).to receive(:warn).with(message, command: 'git-upload-pack gitlab-ci.git', user: user_string)
       end
     end
 
@@ -446,16 +454,16 @@ describe GitlabShell do
       context 'with a correct path' do
         before { subject.exec(ssh_cmd) }
 
-        its(:repo_path) { should == repo_path }
+        it { expect(subject.repo_path).to eq repo_path }
       end
 
       context "with a path that doesn't match an absolute path" do
         before do
-          File.stub(:absolute_path) { 'y/gitlab-ci.git' }
+          allow(File).to receive(:absolute_path) { 'y/gitlab-ci.git' }
         end
 
         it "refuses to assign the path" do
-          $stderr.should_receive(:puts).with("GitLab: Invalid repository path")
+          expect($stderr).to receive(:puts).with("GitLab: Invalid repository path")
           expect(subject.exec(ssh_cmd)).to be_falsey
         end
       end
@@ -478,14 +486,14 @@ describe GitlabShell do
     end
     let(:exec_options) { { unsetenv_others: true, chdir: ROOT_PATH } }
     before do
-      Kernel.stub(:exec)
+      allow(Kernel).to receive(:exec)
       shell.gl_repository = gl_repository
       shell.git_protocol = git_protocol
       shell.instance_variable_set(:@username, gl_username)
     end
 
     it "uses Kernel::exec method" do
-      Kernel.should_receive(:exec).with(env, 1, 2, exec_options).once
+      expect(Kernel).to receive(:exec).with(env, 1, 2, exec_options).once
       shell.send :exec_cmd, 1, 2
     end
 
@@ -494,7 +502,7 @@ describe GitlabShell do
     end
 
     it "allows one argument if it is an array" do
-      Kernel.should_receive(:exec).with(env, [1, 2], exec_options).once
+      expect(Kernel).to receive(:exec).with(env, [1, 2], exec_options).once
       shell.send :exec_cmd, [1, 2]
     end
 
@@ -502,7 +510,7 @@ describe GitlabShell do
       let(:git_trace_log_file) { '/tmp/git_trace_performance.log' }
 
       before do
-        GitlabConfig.any_instance.stub(git_trace_log_file: git_trace_log_file)
+        allow_any_instance_of(GitlabConfig).to receive(:git_trace_log_file).and_return(git_trace_log_file)
         shell
       end
 
@@ -512,7 +520,7 @@ describe GitlabShell do
           'GIT_TRACE_PACKET' => git_trace_log_file,
           'GIT_TRACE_PERFORMANCE' => git_trace_log_file
         )
-        Kernel.should_receive(:exec).with(expected_hash, [1, 2], exec_options).once
+        expect(Kernel).to receive(:exec).with(expected_hash, [1, 2], exec_options).once
 
         shell.send :exec_cmd, [1, 2]
       end
@@ -525,7 +533,7 @@ describe GitlabShell do
           expected_hash = hash_excluding(
             'GIT_TRACE', 'GIT_TRACE_PACKET', 'GIT_TRACE_PERFORMANCE'
           )
-          Kernel.should_receive(:exec).with(expected_hash, [1, 2], exec_options).once
+          expect(Kernel).to receive(:exec).with(expected_hash, [1, 2], exec_options).once
 
           shell.send :exec_cmd, [1, 2]
         end
@@ -536,7 +544,7 @@ describe GitlabShell do
           expect($logger).to receive(:warn).
             with(message, git_trace_log_file: git_trace_log_file)
 
-          Kernel.should_receive(:exec).with(env, [1, 2], exec_options).once
+          expect(Kernel).to receive(:exec).with(env, [1, 2], exec_options).once
           shell.send :exec_cmd, [1, 2]
         end
       end
@@ -551,7 +559,7 @@ describe GitlabShell do
           expected_hash = hash_excluding(
             'GIT_TRACE', 'GIT_TRACE_PACKET', 'GIT_TRACE_PERFORMANCE'
           )
-          Kernel.should_receive(:exec).with(expected_hash, [1, 2], exec_options).once
+          expect(Kernel).to receive(:exec).with(expected_hash, [1, 2], exec_options).once
 
           shell.send :exec_cmd, [1, 2]
         end
@@ -563,7 +571,7 @@ describe GitlabShell do
           expect($logger).to receive(:warn).
             with(message, git_trace_log_file: git_trace_log_file, error: error)
 
-          Kernel.should_receive(:exec).with(env, [1, 2], exec_options).once
+          expect(Kernel).to receive(:exec).with(env, [1, 2], exec_options).once
           shell.send :exec_cmd, [1, 2]
         end
       end
@@ -574,6 +582,6 @@ describe GitlabShell do
     let(:shell) { GitlabShell.new(gl_id) }
     subject { shell.send :api }
 
-    it { should be_a(GitlabNet) }
+    it { is_expected.to be_a(GitlabNet) }
   end
 end

spec/httpunix_spec.rb

@@ -6,10 +6,13 @@ describe URI::HTTPUNIX do
     uri = URI::parse('http+unix://%2Fpath%2Fto%2Fsocket/img.jpg')
     subject { uri }
 
-    it { should be_an_instance_of(URI::HTTPUNIX) }
-    its(:scheme) { should eq('http+unix') }
-    its(:hostname) { should eq('/path/to/socket') }
-    its(:path) { should eq('/img.jpg') }
+    it { is_expected.to be_an_instance_of(URI::HTTPUNIX) }
+
+    it 'has the correct attributes' do
+      expect(subject.scheme).to eq('http+unix')
+      expect(subject.hostname).to eq('/path/to/socket')
+      expect(subject.path).to eq('/img.jpg')
+    end
   end
 end
 

spec/names_helper_spec.rb

@@ -5,8 +5,8 @@ describe NamesHelper do
   include NamesHelper
 
   describe :extract_ref_name do
-    it { extract_ref_name('refs/heads/awesome-feature').should == 'awesome-feature' }
-    it { extract_ref_name('refs/tags/v2.2.1').should == 'v2.2.1' }
-    it { extract_ref_name('refs/tags/releases/v2.2.1').should == 'releases/v2.2.1' }
+    it { expect(extract_ref_name('refs/heads/awesome-feature')).to eq('awesome-feature') }
+    it { expect(extract_ref_name('refs/tags/v2.2.1')).to eq('v2.2.1') }
+    it { expect(extract_ref_name('refs/tags/releases/v2.2.1')).to eq('releases/v2.2.1') }
   end
 end

spec/spec_helper.rb

-ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), ".."))
-
-require 'rspec/its'
-
 require 'simplecov'
 SimpleCov.start
 
-require 'vcr'
-require 'webmock'
-require 'webrick'
-
-VCR.configure do |c|
-  c.cassette_library_dir = 'spec/vcr_cassettes'
-  c.hook_into :webmock
-  c.configure_rspec_metadata!
-end
+require 'gitlab_init'
 
-# like WEBrick::HTTPServer, but listens on UNIX socket
-class HTTPUNIXServer < WEBrick::HTTPServer
-  def listen(address, port)
-    socket = Socket.unix_server_socket(address)
-    socket.autoclose = false
-    server = UNIXServer.for_fd(socket.fileno)
-    socket.close
-    @listeners << server
-  end
+Dir[File.expand_path('support/**/*.rb', __dir__)].each { |f| require f }
 
-  # Workaround:
-  # https://bugs.ruby-lang.org/issues/10956
-  # Affecting Ruby 2.2
-  # Fix for 2.2 is at https://github.com/ruby/ruby/commit/ab0a64e1
-  # However, this doesn't work with 2.1. The following should work for both:
-  def start(&block)
-    @shutdown_pipe = IO.pipe
-    shutdown_pipe = @shutdown_pipe
-    super(&block)
-  end
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
 
-  def cleanup_shutdown_pipe(shutdown_pipe)
-    @shutdown_pipe = nil
-    return if !shutdown_pipe
-    super(shutdown_pipe)
+  config.before(:each) do
+    stub_const('ROOT_PATH', File.expand_path('..', __dir__))
   end
 end

spec/support/http_unix_server.rb

+require 'webrick'
+
+# like WEBrick::HTTPServer, but listens on UNIX socket
+class HTTPUNIXServer < WEBrick::HTTPServer
+  def initialize(config = {})
+    null_log = WEBrick::Log.new(IO::NULL, 7)
+
+    super(config.merge(Logger: null_log, AccessLog: null_log))
+  end
+
+  def listen(address, port)
+    socket = Socket.unix_server_socket(address)
+    socket.autoclose = false
+    server = UNIXServer.for_fd(socket.fileno)
+    socket.close
+    @listeners << server
+  end
+
+  # Workaround:
+  # https://bugs.ruby-lang.org/issues/10956
+  # Affecting Ruby 2.2
+  # Fix for 2.2 is at https://github.com/ruby/ruby/commit/ab0a64e1
+  # However, this doesn't work with 2.1. The following should work for both:
+  def start(&block)
+    @shutdown_pipe = IO.pipe
+    shutdown_pipe = @shutdown_pipe
+    super(&block)
+  end
+
+  def cleanup_shutdown_pipe(shutdown_pipe)
+    @shutdown_pipe = nil
+    return if !shutdown_pipe
+    super(shutdown_pipe)
+  end
+end

spec/support/vcr.rb

+require 'vcr'
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/vcr_cassettes'
+  c.hook_into :webmock
+  c.configure_rspec_metadata!
+end

spec/support/webmock.rb

+require 'webmock/rspec'
+
+WebMock.disable_net_connect!(allow_localhost: true)