From 0c4a70a306b871899bf87ce4673918abfee4d95f Mon Sep 17 00:00:00 2001
From: Jeroen van Baarsen <jeroenvanbaarsen@gmail.com>
Date: Thu, 12 Feb 2015 19:17:35 +0100
Subject: Updated rspec to rspec 3.x syntax

Signed-off-by: Jeroen van Baarsen <jeroenvanbaarsen@gmail.com>
---
 spec/requests/api/api_helpers_spec.rb       |  78 +++----
 spec/requests/api/branches_spec.rb          |  80 +++----
 spec/requests/api/commits_spec.rb           |  70 +++----
 spec/requests/api/doorkeeper_access_spec.rb |   6 +-
 spec/requests/api/files_spec.rb             |  36 ++--
 spec/requests/api/fork_spec.rb              |  44 ++--
 spec/requests/api/group_members_spec.rb     |  44 ++--
 spec/requests/api/groups_spec.rb            |  62 +++---
 spec/requests/api/internal_spec.rb          |  62 +++---
 spec/requests/api/issues_spec.rb            | 213 +++++++++----------
 spec/requests/api/labels_spec.rb            |  84 ++++----
 spec/requests/api/merge_requests_spec.rb    | 197 +++++++++---------
 spec/requests/api/milestones_spec.rb        |  52 ++---
 spec/requests/api/namespaces_spec.rb        |   8 +-
 spec/requests/api/notes_spec.rb             |  78 +++----
 spec/requests/api/project_hooks_spec.rb     |  44 ++--
 spec/requests/api/project_members_spec.rb   |  68 +++---
 spec/requests/api/projects_spec.rb          | 310 ++++++++++++++--------------
 spec/requests/api/repositories_spec.rb      | 132 ++++++------
 spec/requests/api/services_spec.rb          |  18 +-
 spec/requests/api/session_spec.rb           |  30 +--
 spec/requests/api/system_hooks_spec.rb      |  20 +-
 spec/requests/api/users_spec.rb             | 260 +++++++++++------------
 23 files changed, 999 insertions(+), 997 deletions(-)

(limited to 'spec/requests')

diff --git a/spec/requests/api/api_helpers_spec.rb b/spec/requests/api/api_helpers_spec.rb
index cc071342d7c..20cb30a39bb 100644
--- a/spec/requests/api/api_helpers_spec.rb
+++ b/spec/requests/api/api_helpers_spec.rb
@@ -41,33 +41,33 @@ describe API, api: true do
   describe ".current_user" do
     it "should return nil for an invalid token" do
       env[API::APIHelpers::PRIVATE_TOKEN_HEADER] = 'invalid token'
-      self.class.any_instance.stub(:doorkeeper_guard){ false }
-      current_user.should be_nil
+      allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
+      expect(current_user).to be_nil
     end
 
     it "should return nil for a user without access" do
       env[API::APIHelpers::PRIVATE_TOKEN_HEADER] = user.private_token
       Gitlab::UserAccess.stub(allowed?: false)
-      current_user.should be_nil
+      expect(current_user).to be_nil
     end
 
     it "should leave user as is when sudo not specified" do
       env[API::APIHelpers::PRIVATE_TOKEN_HEADER] = user.private_token
-      current_user.should == user
+      expect(current_user).to eq(user)
       clear_env
       params[API::APIHelpers::PRIVATE_TOKEN_PARAM] = user.private_token
-      current_user.should == user
+      expect(current_user).to eq(user)
     end
 
     it "should change current user to sudo when admin" do
       set_env(admin, user.id)
-      current_user.should == user
+      expect(current_user).to eq(user)
       set_param(admin, user.id)
-      current_user.should == user
+      expect(current_user).to eq(user)
       set_env(admin, user.username)
-      current_user.should == user
+      expect(current_user).to eq(user)
       set_param(admin, user.username)
-      current_user.should == user
+      expect(current_user).to eq(user)
     end
 
     it "should throw an error when the current user is not an admin and attempting to sudo" do
@@ -83,8 +83,8 @@ describe API, api: true do
 
     it "should throw an error when the user cannot be found for a given id" do
       id = user.id + admin.id
-      user.id.should_not == id
-      admin.id.should_not == id
+      expect(user.id).not_to eq(id)
+      expect(admin.id).not_to eq(id)
       set_env(admin, id)
       expect { current_user }.to raise_error
 
@@ -94,8 +94,8 @@ describe API, api: true do
 
     it "should throw an error when the user cannot be found for a given username" do
       username = "#{user.username}#{admin.username}"
-      user.username.should_not == username
-      admin.username.should_not == username
+      expect(user.username).not_to eq(username)
+      expect(admin.username).not_to eq(username)
       set_env(admin, username)
       expect { current_user }.to raise_error
 
@@ -105,69 +105,69 @@ describe API, api: true do
 
     it "should handle sudo's to oneself" do
       set_env(admin, admin.id)
-      current_user.should == admin
+      expect(current_user).to eq(admin)
       set_param(admin, admin.id)
-      current_user.should == admin
+      expect(current_user).to eq(admin)
       set_env(admin, admin.username)
-      current_user.should == admin
+      expect(current_user).to eq(admin)
       set_param(admin, admin.username)
-      current_user.should == admin
+      expect(current_user).to eq(admin)
     end
 
     it "should handle multiple sudo's to oneself" do
       set_env(admin, user.id)
-      current_user.should == user
-      current_user.should == user
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
       set_env(admin, user.username)
-      current_user.should == user
-      current_user.should == user
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
 
       set_param(admin, user.id)
-      current_user.should == user
-      current_user.should == user
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
       set_param(admin, user.username)
-      current_user.should == user
-      current_user.should == user
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
     end
 
     it "should handle multiple sudo's to oneself using string ids" do
       set_env(admin, user.id.to_s)
-      current_user.should == user
-      current_user.should == user
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
 
       set_param(admin, user.id.to_s)
-      current_user.should == user
-      current_user.should == user
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
     end
   end
 
   describe '.sudo_identifier' do
     it "should return integers when input is an int" do
       set_env(admin, '123')
-      sudo_identifier.should == 123
+      expect(sudo_identifier).to eq(123)
       set_env(admin, '0001234567890')
-      sudo_identifier.should == 1234567890
+      expect(sudo_identifier).to eq(1234567890)
 
       set_param(admin, '123')
-      sudo_identifier.should == 123
+      expect(sudo_identifier).to eq(123)
       set_param(admin, '0001234567890')
-      sudo_identifier.should == 1234567890
+      expect(sudo_identifier).to eq(1234567890)
     end
 
     it "should return string when input is an is not an int" do
       set_env(admin, '12.30')
-      sudo_identifier.should == "12.30"
+      expect(sudo_identifier).to eq("12.30")
       set_env(admin, 'hello')
-      sudo_identifier.should == 'hello'
+      expect(sudo_identifier).to eq('hello')
       set_env(admin, ' 123')
-      sudo_identifier.should == ' 123'
+      expect(sudo_identifier).to eq(' 123')
 
       set_param(admin, '12.30')
-      sudo_identifier.should == "12.30"
+      expect(sudo_identifier).to eq("12.30")
       set_param(admin, 'hello')
-      sudo_identifier.should == 'hello'
+      expect(sudo_identifier).to eq('hello')
       set_param(admin, ' 123')
-      sudo_identifier.should == ' 123'
+      expect(sudo_identifier).to eq(' 123')
     end
   end
 end
diff --git a/spec/requests/api/branches_spec.rb b/spec/requests/api/branches_spec.rb
index b45572c39fd..f40d68b75a4 100644
--- a/spec/requests/api/branches_spec.rb
+++ b/spec/requests/api/branches_spec.rb
@@ -15,79 +15,79 @@ describe API::API, api: true  do
   describe "GET /projects/:id/repository/branches" do
     it "should return an array of project branches" do
       get api("/projects/#{project.id}/repository/branches", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.first['name'].should == project.repository.branch_names.first
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.first['name']).to eq(project.repository.branch_names.first)
     end
   end
 
   describe "GET /projects/:id/repository/branches/:branch" do
     it "should return the branch information for a single branch" do
       get api("/projects/#{project.id}/repository/branches/#{branch_name}", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
 
-      json_response['name'].should == branch_name
-      json_response['commit']['id'].should == branch_sha
-      json_response['protected'].should == false
+      expect(json_response['name']).to eq(branch_name)
+      expect(json_response['commit']['id']).to eq(branch_sha)
+      expect(json_response['protected']).to eq(false)
     end
 
     it "should return a 403 error if guest" do
       get api("/projects/#{project.id}/repository/branches", user2)
-      response.status.should == 403
+      expect(response.status).to eq(403)
     end
 
     it "should return a 404 error if branch is not available" do
       get api("/projects/#{project.id}/repository/branches/unknown", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
   describe "PUT /projects/:id/repository/branches/:branch/protect" do
     it "should protect a single branch" do
       put api("/projects/#{project.id}/repository/branches/#{branch_name}/protect", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
 
-      json_response['name'].should == branch_name
-      json_response['commit']['id'].should == branch_sha
-      json_response['protected'].should == true
+      expect(json_response['name']).to eq(branch_name)
+      expect(json_response['commit']['id']).to eq(branch_sha)
+      expect(json_response['protected']).to eq(true)
     end
 
     it "should return a 404 error if branch not found" do
       put api("/projects/#{project.id}/repository/branches/unknown/protect", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it "should return a 403 error if guest" do
       put api("/projects/#{project.id}/repository/branches/#{branch_name}/protect", user2)
-      response.status.should == 403
+      expect(response.status).to eq(403)
     end
 
     it "should return success when protect branch again" do
       put api("/projects/#{project.id}/repository/branches/#{branch_name}/protect", user)
       put api("/projects/#{project.id}/repository/branches/#{branch_name}/protect", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
   end
 
   describe "PUT /projects/:id/repository/branches/:branch/unprotect" do
     it "should unprotect a single branch" do
       put api("/projects/#{project.id}/repository/branches/#{branch_name}/unprotect", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
 
-      json_response['name'].should == branch_name
-      json_response['commit']['id'].should == branch_sha
-      json_response['protected'].should == false
+      expect(json_response['name']).to eq(branch_name)
+      expect(json_response['commit']['id']).to eq(branch_sha)
+      expect(json_response['protected']).to eq(false)
     end
 
     it "should return success when unprotect branch" do
       put api("/projects/#{project.id}/repository/branches/unknown/unprotect", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it "should return success when unprotect branch again" do
       put api("/projects/#{project.id}/repository/branches/#{branch_name}/unprotect", user)
       put api("/projects/#{project.id}/repository/branches/#{branch_name}/unprotect", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
   end
 
@@ -97,46 +97,46 @@ describe API::API, api: true  do
            branch_name: 'feature1',
            ref: branch_sha
 
-      response.status.should == 201
+      expect(response.status).to eq(201)
 
-      json_response['name'].should == 'feature1'
-      json_response['commit']['id'].should == branch_sha
+      expect(json_response['name']).to eq('feature1')
+      expect(json_response['commit']['id']).to eq(branch_sha)
     end
 
     it "should deny for user without push access" do
       post api("/projects/#{project.id}/repository/branches", user2),
            branch_name: branch_name,
            ref: branch_sha
-      response.status.should == 403
+      expect(response.status).to eq(403)
     end
 
     it 'should return 400 if branch name is invalid' do
       post api("/projects/#{project.id}/repository/branches", user),
            branch_name: 'new design',
            ref: branch_sha
-      response.status.should == 400
-      json_response['message'].should == 'Branch name invalid'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('Branch name invalid')
     end
 
     it 'should return 400 if branch already exists' do
       post api("/projects/#{project.id}/repository/branches", user),
            branch_name: 'new_design1',
            ref: branch_sha
-      response.status.should == 201
+      expect(response.status).to eq(201)
 
       post api("/projects/#{project.id}/repository/branches", user),
            branch_name: 'new_design1',
            ref: branch_sha
-      response.status.should == 400
-      json_response['message'].should == 'Branch already exists'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('Branch already exists')
     end
 
     it 'should return 400 if ref name is invalid' do
       post api("/projects/#{project.id}/repository/branches", user),
            branch_name: 'new_design3',
            ref: 'foo'
-      response.status.should == 400
-      json_response['message'].should == 'Invalid reference name'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('Invalid reference name')
     end
   end
 
@@ -145,26 +145,26 @@ describe API::API, api: true  do
 
     it "should remove branch" do
       delete api("/projects/#{project.id}/repository/branches/#{branch_name}", user)
-      response.status.should == 200
-      json_response['branch_name'].should == branch_name
+      expect(response.status).to eq(200)
+      expect(json_response['branch_name']).to eq(branch_name)
     end
 
     it 'should return 404 if branch not exists' do
       delete api("/projects/#{project.id}/repository/branches/foobar", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it "should remove protected branch" do
       project.protected_branches.create(name: branch_name)
       delete api("/projects/#{project.id}/repository/branches/#{branch_name}", user)
-      response.status.should == 405
-      json_response['message'].should == 'Protected branch cant be removed'
+      expect(response.status).to eq(405)
+      expect(json_response['message']).to eq('Protected branch cant be removed')
     end
 
     it "should not remove HEAD branch" do
       delete api("/projects/#{project.id}/repository/branches/master", user)
-      response.status.should == 405
-      json_response['message'].should == 'Cannot remove HEAD branch'
+      expect(response.status).to eq(405)
+      expect(json_response['message']).to eq('Cannot remove HEAD branch')
     end
   end
 end
diff --git a/spec/requests/api/commits_spec.rb b/spec/requests/api/commits_spec.rb
index a3f58f50913..9ea60e1a4ad 100644
--- a/spec/requests/api/commits_spec.rb
+++ b/spec/requests/api/commits_spec.rb
@@ -18,17 +18,17 @@ describe API::API, api: true  do
 
       it "should return project commits" do
         get api("/projects/#{project.id}/repository/commits", user)
-        response.status.should == 200
+        expect(response.status).to eq(200)
 
-        json_response.should be_an Array
-        json_response.first['id'].should == project.repository.commit.id
+        expect(json_response).to be_an Array
+        expect(json_response.first['id']).to eq(project.repository.commit.id)
       end
     end
 
     context "unauthorized user" do
       it "should not return project commits" do
         get api("/projects/#{project.id}/repository/commits")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
   end
@@ -37,21 +37,21 @@ describe API::API, api: true  do
     context "authorized user" do
       it "should return a commit by sha" do
         get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}", user)
-        response.status.should == 200
-        json_response['id'].should == project.repository.commit.id
-        json_response['title'].should == project.repository.commit.title
+        expect(response.status).to eq(200)
+        expect(json_response['id']).to eq(project.repository.commit.id)
+        expect(json_response['title']).to eq(project.repository.commit.title)
       end
 
       it "should return a 404 error if not found" do
         get api("/projects/#{project.id}/repository/commits/invalid_sha", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context "unauthorized user" do
       it "should not return the selected commit" do
         get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
   end
@@ -62,23 +62,23 @@ describe API::API, api: true  do
 
       it "should return the diff of the selected commit" do
         get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/diff", user)
-        response.status.should == 200
+        expect(response.status).to eq(200)
 
-        json_response.should be_an Array
-        json_response.length.should >= 1
-        json_response.first.keys.should include "diff"
+        expect(json_response).to be_an Array
+        expect(json_response.length).to be >= 1
+        expect(json_response.first.keys).to include "diff"
       end
 
       it "should return a 404 error if invalid commit" do
         get api("/projects/#{project.id}/repository/commits/invalid_sha/diff", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context "unauthorized user" do
       it "should not return the diff of the selected commit" do
         get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/diff")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
   end
@@ -87,23 +87,23 @@ describe API::API, api: true  do
     context 'authorized user' do
       it 'should return merge_request comments' do
         get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.first['note'].should == 'a comment on a commit'
-        json_response.first['author']['id'].should == user.id
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['note']).to eq('a comment on a commit')
+        expect(json_response.first['author']['id']).to eq(user.id)
       end
 
       it 'should return a 404 error if merge_request_id not found' do
         get api("/projects/#{project.id}/repository/commits/1234ab/comments", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context 'unauthorized user' do
       it 'should not return the diff of the selected commit' do
         get api("/projects/#{project.id}/repository/commits/1234ab/comments")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
   end
@@ -112,37 +112,37 @@ describe API::API, api: true  do
     context 'authorized user' do
       it 'should return comment' do
         post api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments", user), note: 'My comment'
-        response.status.should == 201
-        json_response['note'].should == 'My comment'
-        json_response['path'].should be_nil
-        json_response['line'].should be_nil
-        json_response['line_type'].should be_nil
+        expect(response.status).to eq(201)
+        expect(json_response['note']).to eq('My comment')
+        expect(json_response['path']).to be_nil
+        expect(json_response['line']).to be_nil
+        expect(json_response['line_type']).to be_nil
       end
 
       it 'should return the inline comment' do
         post api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments", user), note: 'My comment', path: project.repository.commit.diffs.first.new_path, line: 7, line_type: 'new'
-        response.status.should == 201
-        json_response['note'].should == 'My comment'
-        json_response['path'].should == project.repository.commit.diffs.first.new_path
-        json_response['line'].should == 7
-        json_response['line_type'].should == 'new'
+        expect(response.status).to eq(201)
+        expect(json_response['note']).to eq('My comment')
+        expect(json_response['path']).to eq(project.repository.commit.diffs.first.new_path)
+        expect(json_response['line']).to eq(7)
+        expect(json_response['line_type']).to eq('new')
       end
 
       it 'should return 400 if note is missing' do
         post api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments", user)
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it 'should return 404 if note is attached to non existent commit' do
         post api("/projects/#{project.id}/repository/commits/1234ab/comments", user), note: 'My comment'
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context 'unauthorized user' do
       it 'should not return the diff of the selected commit' do
         post api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
   end
diff --git a/spec/requests/api/doorkeeper_access_spec.rb b/spec/requests/api/doorkeeper_access_spec.rb
index ddef99d77af..39949a90422 100644
--- a/spec/requests/api/doorkeeper_access_spec.rb
+++ b/spec/requests/api/doorkeeper_access_spec.rb
@@ -11,21 +11,21 @@ describe API::API, api: true  do
   describe "when unauthenticated" do
     it "returns authentication success" do
       get api("/user"), :access_token => token.token
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
   end
 
   describe "when token invalid" do
     it "returns authentication error" do
       get api("/user"), :access_token => "123a"
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
   end
 
   describe "authorization by private token" do
     it "returns authentication success" do
       get api("/user", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
   end
 end
diff --git a/spec/requests/api/files_spec.rb b/spec/requests/api/files_spec.rb
index b43a202aec0..cfac7d289ec 100644
--- a/spec/requests/api/files_spec.rb
+++ b/spec/requests/api/files_spec.rb
@@ -16,15 +16,15 @@ describe API::API, api: true  do
       }
 
       get api("/projects/#{project.id}/repository/files", user), params
-      response.status.should == 200
-      json_response['file_path'].should == file_path
-      json_response['file_name'].should == 'popen.rb'
-      Base64.decode64(json_response['content']).lines.first.should == "require 'fileutils'\n"
+      expect(response.status).to eq(200)
+      expect(json_response['file_path']).to eq(file_path)
+      expect(json_response['file_name']).to eq('popen.rb')
+      expect(Base64.decode64(json_response['content']).lines.first).to eq("require 'fileutils'\n")
     end
 
     it "should return a 400 bad request if no params given" do
       get api("/projects/#{project.id}/repository/files", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 404 if such file does not exist" do
@@ -34,7 +34,7 @@ describe API::API, api: true  do
       }
 
       get api("/projects/#{project.id}/repository/files", user), params
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -54,13 +54,13 @@ describe API::API, api: true  do
       )
 
       post api("/projects/#{project.id}/repository/files", user), valid_params
-      response.status.should == 201
-      json_response['file_path'].should == 'newfile.rb'
+      expect(response.status).to eq(201)
+      expect(json_response['file_path']).to eq('newfile.rb')
     end
 
     it "should return a 400 bad request if no params given" do
       post api("/projects/#{project.id}/repository/files", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 400 if satellite fails to create file" do
@@ -69,7 +69,7 @@ describe API::API, api: true  do
       )
 
       post api("/projects/#{project.id}/repository/files", user), valid_params
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 
@@ -89,13 +89,13 @@ describe API::API, api: true  do
       )
 
       put api("/projects/#{project.id}/repository/files", user), valid_params
-      response.status.should == 200
-      json_response['file_path'].should == file_path
+      expect(response.status).to eq(200)
+      expect(json_response['file_path']).to eq(file_path)
     end
 
     it "should return a 400 bad request if no params given" do
       put api("/projects/#{project.id}/repository/files", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 400 if satellite fails to create file" do
@@ -104,7 +104,7 @@ describe API::API, api: true  do
       )
 
       put api("/projects/#{project.id}/repository/files", user), valid_params
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 
@@ -123,13 +123,13 @@ describe API::API, api: true  do
       )
 
       delete api("/projects/#{project.id}/repository/files", user), valid_params
-      response.status.should == 200
-      json_response['file_path'].should == file_path
+      expect(response.status).to eq(200)
+      expect(json_response['file_path']).to eq(file_path)
     end
 
     it "should return a 400 bad request if no params given" do
       delete api("/projects/#{project.id}/repository/files", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 400 if satellite fails to create file" do
@@ -138,7 +138,7 @@ describe API::API, api: true  do
       )
 
       delete api("/projects/#{project.id}/repository/files", user), valid_params
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 end
diff --git a/spec/requests/api/fork_spec.rb b/spec/requests/api/fork_spec.rb
index 5921b3e0698..fb3ff552c8d 100644
--- a/spec/requests/api/fork_spec.rb
+++ b/spec/requests/api/fork_spec.rb
@@ -23,50 +23,50 @@ describe API::API, api: true  do
     context 'when authenticated' do
       it 'should fork if user has sufficient access to project' do
         post api("/projects/fork/#{project.id}", user2)
-        response.status.should == 201
-        json_response['name'].should == project.name
-        json_response['path'].should == project.path
-        json_response['owner']['id'].should == user2.id
-        json_response['namespace']['id'].should == user2.namespace.id
-        json_response['forked_from_project']['id'].should == project.id
+        expect(response.status).to eq(201)
+        expect(json_response['name']).to eq(project.name)
+        expect(json_response['path']).to eq(project.path)
+        expect(json_response['owner']['id']).to eq(user2.id)
+        expect(json_response['namespace']['id']).to eq(user2.namespace.id)
+        expect(json_response['forked_from_project']['id']).to eq(project.id)
       end
 
       it 'should fork if user is admin' do
         post api("/projects/fork/#{project.id}", admin)
-        response.status.should == 201
-        json_response['name'].should == project.name
-        json_response['path'].should == project.path
-        json_response['owner']['id'].should == admin.id
-        json_response['namespace']['id'].should == admin.namespace.id
-        json_response['forked_from_project']['id'].should == project.id
+        expect(response.status).to eq(201)
+        expect(json_response['name']).to eq(project.name)
+        expect(json_response['path']).to eq(project.path)
+        expect(json_response['owner']['id']).to eq(admin.id)
+        expect(json_response['namespace']['id']).to eq(admin.namespace.id)
+        expect(json_response['forked_from_project']['id']).to eq(project.id)
       end
 
       it 'should fail on missing project access for the project to fork' do
         post api("/projects/fork/#{project.id}", user3)
-        response.status.should == 404
-        json_response['message'].should == '404 Project Not Found'
+        expect(response.status).to eq(404)
+        expect(json_response['message']).to eq('404 Project Not Found')
       end
 
       it 'should fail if forked project exists in the user namespace' do
         post api("/projects/fork/#{project.id}", user)
-        response.status.should == 409
-        json_response['message']['base'].should == ['Invalid fork destination']
-        json_response['message']['name'].should == ['has already been taken']
-        json_response['message']['path'].should == ['has already been taken']
+        expect(response.status).to eq(409)
+        expect(json_response['message']['base']).to eq(['Invalid fork destination'])
+        expect(json_response['message']['name']).to eq(['has already been taken'])
+        expect(json_response['message']['path']).to eq(['has already been taken'])
       end
 
       it 'should fail if project to fork from does not exist' do
         post api('/projects/fork/424242', user)
-        response.status.should == 404
-        json_response['message'].should == '404 Project Not Found'
+        expect(response.status).to eq(404)
+        expect(json_response['message']).to eq('404 Project Not Found')
       end
     end
 
     context 'when unauthenticated' do
       it 'should return authentication error' do
         post api("/projects/fork/#{project.id}")
-        response.status.should == 401
-        json_response['message'].should == '401 Unauthorized'
+        expect(response.status).to eq(401)
+        expect(json_response['message']).to eq('401 Unauthorized')
       end
     end
   end
diff --git a/spec/requests/api/group_members_spec.rb b/spec/requests/api/group_members_spec.rb
index 4957186f605..b070bf01dbb 100644
--- a/spec/requests/api/group_members_spec.rb
+++ b/spec/requests/api/group_members_spec.rb
@@ -31,20 +31,20 @@ describe API::API, api: true  do
       it "each user: should return an array of members groups of group3" do
         [owner, master, developer, reporter, guest].each do |user|
           get api("/groups/#{group_with_members.id}/members", user)
-          response.status.should == 200
-          json_response.should be_an Array
-          json_response.size.should == 5
-          json_response.find { |e| e['id']==owner.id }['access_level'].should == GroupMember::OWNER
-          json_response.find { |e| e['id']==reporter.id }['access_level'].should == GroupMember::REPORTER
-          json_response.find { |e| e['id']==developer.id }['access_level'].should == GroupMember::DEVELOPER
-          json_response.find { |e| e['id']==master.id }['access_level'].should == GroupMember::MASTER
-          json_response.find { |e| e['id']==guest.id }['access_level'].should == GroupMember::GUEST
+          expect(response.status).to eq(200)
+          expect(json_response).to be_an Array
+          expect(json_response.size).to eq(5)
+          expect(json_response.find { |e| e['id']==owner.id }['access_level']).to eq(GroupMember::OWNER)
+          expect(json_response.find { |e| e['id']==reporter.id }['access_level']).to eq(GroupMember::REPORTER)
+          expect(json_response.find { |e| e['id']==developer.id }['access_level']).to eq(GroupMember::DEVELOPER)
+          expect(json_response.find { |e| e['id']==master.id }['access_level']).to eq(GroupMember::MASTER)
+          expect(json_response.find { |e| e['id']==guest.id }['access_level']).to eq(GroupMember::GUEST)
         end
       end
 
       it "users not part of the group should get access error" do
         get api("/groups/#{group_with_members.id}/members", stranger)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
   end
@@ -53,7 +53,7 @@ describe API::API, api: true  do
     context "when not a member of the group" do
       it "should not add guest as member of group_no_members when adding being done by person outside the group" do
         post api("/groups/#{group_no_members.id}/members", reporter), user_id: guest.id, access_level: GroupMember::MASTER
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
@@ -66,9 +66,9 @@ describe API::API, api: true  do
           user_id: new_user.id, access_level: GroupMember::MASTER
         }.to change { group_no_members.members.count }.by(1)
 
-        response.status.should == 201
-        json_response['name'].should == new_user.name
-        json_response['access_level'].should == GroupMember::MASTER
+        expect(response.status).to eq(201)
+        expect(json_response['name']).to eq(new_user.name)
+        expect(json_response['access_level']).to eq(GroupMember::MASTER)
       end
 
       it "should not allow guest to modify group members" do
@@ -79,27 +79,27 @@ describe API::API, api: true  do
           user_id: new_user.id, access_level: GroupMember::MASTER
         }.not_to change { group_with_members.members.count }
 
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
 
       it "should return error if member already exists" do
         post api("/groups/#{group_with_members.id}/members", owner), user_id: master.id, access_level: GroupMember::MASTER
-        response.status.should == 409
+        expect(response.status).to eq(409)
       end
 
       it "should return a 400 error when user id is not given" do
         post api("/groups/#{group_no_members.id}/members", owner), access_level: GroupMember::MASTER
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return a 400 error when access level is not given" do
         post api("/groups/#{group_no_members.id}/members", owner), user_id: master.id
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return a 422 error when access level is not known" do
         post api("/groups/#{group_no_members.id}/members", owner), user_id: master.id, access_level: 1234
-        response.status.should == 422
+        expect(response.status).to eq(422)
       end
     end
   end
@@ -109,7 +109,7 @@ describe API::API, api: true  do
       it "should not delete guest's membership of group_with_members" do
         random_user = create(:user)
         delete api("/groups/#{group_with_members.id}/members/#{owner.id}", random_user)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
@@ -119,17 +119,17 @@ describe API::API, api: true  do
           delete api("/groups/#{group_with_members.id}/members/#{guest.id}", owner)
         }.to change { group_with_members.members.count }.by(-1)
 
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "should return a 404 error when user id is not known" do
         delete api("/groups/#{group_with_members.id}/members/1328", owner)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "should not allow guest to modify group members" do
         delete api("/groups/#{group_with_members.id}/members/#{master.id}", guest)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
   end
diff --git a/spec/requests/api/groups_spec.rb b/spec/requests/api/groups_spec.rb
index 8465d765294..d963dbac9f1 100644
--- a/spec/requests/api/groups_spec.rb
+++ b/spec/requests/api/groups_spec.rb
@@ -18,26 +18,26 @@ describe API::API, api: true  do
     context "when unauthenticated" do
       it "should return authentication error" do
         get api("/groups")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context "when authenticated as user" do
       it "normal user: should return an array of groups of user1" do
         get api("/groups", user1)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.first['name'].should == group1.name
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['name']).to eq(group1.name)
       end
     end
 
     context "when authenticated as  admin" do
       it "admin: should return an array of all groups" do
         get api("/groups", admin)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 2
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(2)
       end
     end
   end
@@ -46,49 +46,49 @@ describe API::API, api: true  do
     context "when authenticated as user" do
       it "should return one of user1's groups" do
         get api("/groups/#{group1.id}", user1)
-        response.status.should == 200
+        expect(response.status).to eq(200)
         json_response['name'] == group1.name
       end
 
       it "should not return a non existing group" do
         get api("/groups/1328", user1)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "should not return a group not attached to user1" do
         get api("/groups/#{group2.id}", user1)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
     context "when authenticated as admin" do
       it "should return any existing group" do
         get api("/groups/#{group2.id}", admin)
-        response.status.should == 200
+        expect(response.status).to eq(200)
         json_response['name'] == group2.name
       end
 
       it "should not return a non existing group" do
         get api("/groups/1328", admin)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context 'when using group path in URL' do
       it 'should return any existing group' do
         get api("/groups/#{group1.path}", admin)
-        response.status.should == 200
+        expect(response.status).to eq(200)
         json_response['name'] == group2.name
       end
 
       it 'should not return a non existing group' do
         get api('/groups/unknown', admin)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it 'should not return a group not attached to user1' do
         get api("/groups/#{group2.path}", user1)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
   end
@@ -97,30 +97,30 @@ describe API::API, api: true  do
     context "when authenticated as user" do
       it "should not create group" do
         post api("/groups", user1), attributes_for(:group)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
     context "when authenticated as admin" do
       it "should create group" do
         post api("/groups", admin), attributes_for(:group)
-        response.status.should == 201
+        expect(response.status).to eq(201)
       end
 
       it "should not create group, duplicate" do
         post api("/groups", admin), {name: "Duplicate Test", path: group2.path}
-        response.status.should == 400
-        response.message.should == "Bad Request"
+        expect(response.status).to eq(400)
+        expect(response.message).to eq("Bad Request")
       end
 
       it "should return 400 bad request error if name not given" do
         post api("/groups", admin), {path: group2.path}
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return 400 bad request error if path not given" do
         post api("/groups", admin), { name: 'test' }
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
     end
   end
@@ -129,36 +129,36 @@ describe API::API, api: true  do
     context "when authenticated as user" do
       it "should remove group" do
         delete api("/groups/#{group1.id}", user1)
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "should not remove a group if not an owner" do
         user3 = create(:user)
         group1.add_user(user3, Gitlab::Access::MASTER)
         delete api("/groups/#{group1.id}", user3)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
 
       it "should not remove a non existing group" do
         delete api("/groups/1328", user1)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it "should not remove a group not attached to user1" do
         delete api("/groups/#{group2.id}", user1)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
     context "when authenticated as admin" do
       it "should remove any existing group" do
         delete api("/groups/#{group2.id}", admin)
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it "should not remove a non existing group" do
         delete api("/groups/1328", admin)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
   end
@@ -167,20 +167,20 @@ describe API::API, api: true  do
     let(:project) { create(:project) }
     before(:each) do
       Projects::TransferService.any_instance.stub(execute: true)
-      Project.stub(:find).and_return(project)
+      allow(Project).to receive(:find).and_return(project)
     end
 
     context "when authenticated as user" do
       it "should not transfer project to group" do
         post api("/groups/#{group1.id}/projects/#{project.id}", user2)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
     context "when authenticated as admin" do
       it "should transfer project to group" do
         post api("/groups/#{group1.id}/projects/#{project.id}", admin)
-        response.status.should == 201
+        expect(response.status).to eq(201)
       end
     end
   end
diff --git a/spec/requests/api/internal_spec.rb b/spec/requests/api/internal_spec.rb
index 1e8e9eb38d6..10b467d85fd 100644
--- a/spec/requests/api/internal_spec.rb
+++ b/spec/requests/api/internal_spec.rb
@@ -11,8 +11,8 @@ describe API::API, api: true  do
     it do
       get api("/internal/check"), secret_token: secret_token
 
-      response.status.should == 200
-      json_response['api_version'].should == API::API.version
+      expect(response.status).to eq(200)
+      expect(json_response['api_version']).to eq(API::API.version)
     end
   end
 
@@ -23,8 +23,8 @@ describe API::API, api: true  do
       it do
         get api("/internal/broadcast_message"), secret_token: secret_token
 
-        response.status.should == 200
-        json_response["message"].should == broadcast_message.message
+        expect(response.status).to eq(200)
+        expect(json_response["message"]).to eq(broadcast_message.message)
       end
     end
 
@@ -32,7 +32,7 @@ describe API::API, api: true  do
       it do
         get api("/internal/broadcast_message"), secret_token: secret_token
 
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
   end
@@ -41,9 +41,9 @@ describe API::API, api: true  do
     it do
       get(api("/internal/discover"), key_id: key.id, secret_token: secret_token)
 
-      response.status.should == 200
+      expect(response.status).to eq(200)
 
-      json_response['name'].should == user.name
+      expect(json_response['name']).to eq(user.name)
     end
   end
 
@@ -57,8 +57,8 @@ describe API::API, api: true  do
         it do
           pull(key, project)
 
-          response.status.should == 200
-          json_response["status"].should be_true
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_truthy
         end
       end
 
@@ -66,8 +66,8 @@ describe API::API, api: true  do
         it do
           push(key, project)
 
-          response.status.should == 200
-          json_response["status"].should be_true
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_truthy
         end
       end
     end
@@ -81,8 +81,8 @@ describe API::API, api: true  do
         it do
           pull(key, project)
 
-          response.status.should == 200
-          json_response["status"].should be_false
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_falsey
         end
       end
 
@@ -90,8 +90,8 @@ describe API::API, api: true  do
         it do
           push(key, project)
 
-          response.status.should == 200
-          json_response["status"].should be_false
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_falsey
         end
       end
     end
@@ -107,8 +107,8 @@ describe API::API, api: true  do
         it do
           pull(key, personal_project)
 
-          response.status.should == 200
-          json_response["status"].should be_false
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_falsey
         end
       end
 
@@ -116,8 +116,8 @@ describe API::API, api: true  do
         it do
           push(key, personal_project)
 
-          response.status.should == 200
-          json_response["status"].should be_false
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_falsey
         end
       end
     end
@@ -134,8 +134,8 @@ describe API::API, api: true  do
         it do
           pull(key, project)
 
-          response.status.should == 200
-          json_response["status"].should be_true
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_truthy
         end
       end
 
@@ -143,8 +143,8 @@ describe API::API, api: true  do
         it do
           push(key, project)
 
-          response.status.should == 200
-          json_response["status"].should be_false
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_falsey
         end
       end
     end
@@ -160,8 +160,8 @@ describe API::API, api: true  do
         it do
           archive(key, project)
 
-          response.status.should == 200
-          json_response["status"].should be_true
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_truthy
         end
       end
 
@@ -169,8 +169,8 @@ describe API::API, api: true  do
         it do
           archive(key, project)
 
-          response.status.should == 200
-          json_response["status"].should be_false
+          expect(response.status).to eq(200)
+          expect(json_response["status"]).to be_falsey
         end
       end
     end
@@ -179,8 +179,8 @@ describe API::API, api: true  do
       it do
         pull(key, OpenStruct.new(path_with_namespace: 'gitlab/notexists'))
 
-        response.status.should == 200
-        json_response["status"].should be_false
+        expect(response.status).to eq(200)
+        expect(json_response["status"]).to be_falsey
       end
     end
 
@@ -188,8 +188,8 @@ describe API::API, api: true  do
       it do
         pull(OpenStruct.new(id: 0), project)
 
-        response.status.should == 200
-        json_response["status"].should be_false
+        expect(response.status).to eq(200)
+        expect(json_response["status"]).to be_falsey
       end
     end
   end
diff --git a/spec/requests/api/issues_spec.rb b/spec/requests/api/issues_spec.rb
index 775d7b4e18d..b6b0427debf 100644
--- a/spec/requests/api/issues_spec.rb
+++ b/spec/requests/api/issues_spec.rb
@@ -34,86 +34,87 @@ describe API::API, api: true  do
     context "when unauthenticated" do
       it "should return authentication error" do
         get api("/issues")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context "when authenticated" do
       it "should return an array of issues" do
         get api("/issues", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first['title'].should == issue.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first['title']).to eq(issue.title)
       end
 
       it "should add pagination headers" do
         get api("/issues?per_page=3", user)
-        response.headers['Link'].should ==
+        expect(response.headers['Link']).to eq(
           '<http://www.example.com/api/v3/issues?page=1&per_page=3>; rel="first", <http://www.example.com/api/v3/issues?page=1&per_page=3>; rel="last"'
+        )
       end
 
       it 'should return an array of closed issues' do
         get api('/issues?state=closed', user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.first['id'].should == closed_issue.id
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['id']).to eq(closed_issue.id)
       end
 
       it 'should return an array of opened issues' do
         get api('/issues?state=opened', user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.first['id'].should == issue.id
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['id']).to eq(issue.id)
       end
 
       it 'should return an array of all issues' do
         get api('/issues?state=all', user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 2
-        json_response.first['id'].should == issue.id
-        json_response.second['id'].should == closed_issue.id
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(2)
+        expect(json_response.first['id']).to eq(issue.id)
+        expect(json_response.second['id']).to eq(closed_issue.id)
       end
 
       it 'should return an array of labeled issues' do
         get api("/issues?labels=#{label.title}", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.first['labels'].should == [label.title]
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['labels']).to eq([label.title])
       end
 
       it 'should return an array of labeled issues when at least one label matches' do
         get api("/issues?labels=#{label.title},foo,bar", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.first['labels'].should == [label.title]
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['labels']).to eq([label.title])
       end
 
       it 'should return an empty array if no issue matches labels' do
         get api('/issues?labels=foo,bar', user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 0
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(0)
       end
 
       it 'should return an array of labeled issues matching given state' do
         get api("/issues?labels=#{label.title}&state=opened", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.first['labels'].should == [label.title]
-        json_response.first['state'].should == 'opened'
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['labels']).to eq([label.title])
+        expect(json_response.first['state']).to eq('opened')
       end
 
       it 'should return an empty array if no issue matches labels and state filters' do
         get api("/issues?labels=#{label.title}&state=closed", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 0
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(0)
       end
     end
   end
@@ -124,78 +125,78 @@ describe API::API, api: true  do
 
     it "should return project issues" do
       get api("#{base_url}/issues", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.first['title'].should == issue.title
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.first['title']).to eq(issue.title)
     end
 
     it 'should return an array of labeled project issues' do
       get api("#{base_url}/issues?labels=#{label.title}", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.length.should == 1
-      json_response.first['labels'].should == [label.title]
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.length).to eq(1)
+      expect(json_response.first['labels']).to eq([label.title])
     end
 
     it 'should return an array of labeled project issues when at least one label matches' do
       get api("#{base_url}/issues?labels=#{label.title},foo,bar", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.length.should == 1
-      json_response.first['labels'].should == [label.title]
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.length).to eq(1)
+      expect(json_response.first['labels']).to eq([label.title])
     end
 
     it 'should return an empty array if no project issue matches labels' do
       get api("#{base_url}/issues?labels=foo,bar", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.length.should == 0
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.length).to eq(0)
     end
 
     it 'should return an empty array if no issue matches milestone' do
       get api("#{base_url}/issues?milestone=#{empty_milestone.title}", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.length.should == 0
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.length).to eq(0)
     end
 
     it 'should return an empty array if milestone does not exist' do
       get api("#{base_url}/issues?milestone=foo", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.length.should == 0
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.length).to eq(0)
     end
 
     it 'should return an array of issues in given milestone' do
       get api("#{base_url}/issues?milestone=#{title}", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.length.should == 2
-      json_response.first['id'].should == issue.id
-      json_response.second['id'].should == closed_issue.id
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.length).to eq(2)
+      expect(json_response.first['id']).to eq(issue.id)
+      expect(json_response.second['id']).to eq(closed_issue.id)
     end
 
     it 'should return an array of issues matching state in milestone' do
       get api("#{base_url}/issues?milestone=#{milestone.title}"\
               '&state=closed', user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.length.should == 1
-      json_response.first['id'].should == closed_issue.id
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.length).to eq(1)
+      expect(json_response.first['id']).to eq(closed_issue.id)
     end
   end
 
   describe "GET /projects/:id/issues/:issue_id" do
     it "should return a project issue by id" do
       get api("/projects/#{project.id}/issues/#{issue.id}", user)
-      response.status.should == 200
-      json_response['title'].should == issue.title
-      json_response['iid'].should == issue.iid
+      expect(response.status).to eq(200)
+      expect(json_response['title']).to eq(issue.title)
+      expect(json_response['iid']).to eq(issue.iid)
     end
 
     it "should return 404 if issue id not found" do
       get api("/projects/#{project.id}/issues/54321", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -203,32 +204,32 @@ describe API::API, api: true  do
     it "should create a new project issue" do
       post api("/projects/#{project.id}/issues", user),
         title: 'new issue', labels: 'label, label2'
-      response.status.should == 201
-      json_response['title'].should == 'new issue'
-      json_response['description'].should be_nil
-      json_response['labels'].should == ['label', 'label2']
+      expect(response.status).to eq(201)
+      expect(json_response['title']).to eq('new issue')
+      expect(json_response['description']).to be_nil
+      expect(json_response['labels']).to eq(['label', 'label2'])
     end
 
     it "should return a 400 bad request if title not given" do
       post api("/projects/#{project.id}/issues", user), labels: 'label, label2'
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it 'should return 400 on invalid label names' do
       post api("/projects/#{project.id}/issues", user),
            title: 'new issue',
            labels: 'label, ?'
-      response.status.should == 400
-      json_response['message']['labels']['?']['title'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['labels']['?']['title']).to eq(['is invalid'])
     end
 
     it 'should return 400 if title is too long' do
       post api("/projects/#{project.id}/issues", user),
            title: 'g' * 256
-      response.status.should == 400
-      json_response['message']['title'].should == [
+      expect(response.status).to eq(400)
+      expect(json_response['message']['title']).to eq([
         'is too long (maximum is 255 characters)'
-      ]
+      ])
     end
   end
 
@@ -236,23 +237,23 @@ describe API::API, api: true  do
     it "should update a project issue" do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
         title: 'updated title'
-      response.status.should == 200
+      expect(response.status).to eq(200)
 
-      json_response['title'].should == 'updated title'
+      expect(json_response['title']).to eq('updated title')
     end
 
     it "should return 404 error if issue id not found" do
       put api("/projects/#{project.id}/issues/44444", user),
         title: 'updated title'
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it 'should return 400 on invalid label names' do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
           title: 'updated title',
           labels: 'label, ?'
-      response.status.should == 400
-      json_response['message']['labels']['?']['title'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['labels']['?']['title']).to eq(['is invalid'])
     end
   end
 
@@ -263,49 +264,49 @@ describe API::API, api: true  do
     it 'should not update labels if not present' do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
           title: 'updated title'
-      response.status.should == 200
-      json_response['labels'].should == [label.title]
+      expect(response.status).to eq(200)
+      expect(json_response['labels']).to eq([label.title])
     end
 
     it 'should remove all labels' do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
           labels: ''
-      response.status.should == 200
-      json_response['labels'].should == []
+      expect(response.status).to eq(200)
+      expect(json_response['labels']).to eq([])
     end
 
     it 'should update labels' do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
           labels: 'foo,bar'
-      response.status.should == 200
-      json_response['labels'].should include 'foo'
-      json_response['labels'].should include 'bar'
+      expect(response.status).to eq(200)
+      expect(json_response['labels']).to include 'foo'
+      expect(json_response['labels']).to include 'bar'
     end
 
     it 'should return 400 on invalid label names' do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
           labels: 'label, ?'
-      response.status.should == 400
-      json_response['message']['labels']['?']['title'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['labels']['?']['title']).to eq(['is invalid'])
     end
 
     it 'should allow special label names' do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
           labels: 'label:foo, label-bar,label_bar,label/bar'
-      response.status.should == 200
-      json_response['labels'].should include 'label:foo'
-      json_response['labels'].should include 'label-bar'
-      json_response['labels'].should include 'label_bar'
-      json_response['labels'].should include 'label/bar'
+      expect(response.status).to eq(200)
+      expect(json_response['labels']).to include 'label:foo'
+      expect(json_response['labels']).to include 'label-bar'
+      expect(json_response['labels']).to include 'label_bar'
+      expect(json_response['labels']).to include 'label/bar'
     end
 
     it 'should return 400 if title is too long' do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
           title: 'g' * 256
-      response.status.should == 400
-      json_response['message']['title'].should == [
+      expect(response.status).to eq(400)
+      expect(json_response['message']['title']).to eq([
         'is too long (maximum is 255 characters)'
-      ]
+      ])
     end
   end
 
@@ -313,17 +314,17 @@ describe API::API, api: true  do
     it "should update a project issue" do
       put api("/projects/#{project.id}/issues/#{issue.id}", user),
         labels: 'label2', state_event: "close"
-      response.status.should == 200
+      expect(response.status).to eq(200)
 
-      json_response['labels'].should include 'label2'
-      json_response['state'].should eq "closed"
+      expect(json_response['labels']).to include 'label2'
+      expect(json_response['state']).to eq "closed"
     end
   end
 
   describe "DELETE /projects/:id/issues/:issue_id" do
     it "should delete a project issue" do
       delete api("/projects/#{project.id}/issues/#{issue.id}", user)
-      response.status.should == 405
+      expect(response.status).to eq(405)
     end
   end
 end
diff --git a/spec/requests/api/labels_spec.rb b/spec/requests/api/labels_spec.rb
index dbddc8a7da4..aff109a9424 100644
--- a/spec/requests/api/labels_spec.rb
+++ b/spec/requests/api/labels_spec.rb
@@ -15,10 +15,10 @@ describe API::API, api: true  do
   describe 'GET /projects/:id/labels' do
     it 'should return project labels' do
       get api("/projects/#{project.id}/labels", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.size.should == 1
-      json_response.first['name'].should == label1.name
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.size).to eq(1)
+      expect(json_response.first['name']).to eq(label1.name)
     end
   end
 
@@ -27,69 +27,69 @@ describe API::API, api: true  do
       post api("/projects/#{project.id}/labels", user),
            name: 'Foo',
            color: '#FFAABB'
-      response.status.should == 201
-      json_response['name'].should == 'Foo'
-      json_response['color'].should == '#FFAABB'
+      expect(response.status).to eq(201)
+      expect(json_response['name']).to eq('Foo')
+      expect(json_response['color']).to eq('#FFAABB')
     end
 
     it 'should return a 400 bad request if name not given' do
       post api("/projects/#{project.id}/labels", user), color: '#FFAABB'
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it 'should return a 400 bad request if color not given' do
       post api("/projects/#{project.id}/labels", user), name: 'Foobar'
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it 'should return 400 for invalid color' do
       post api("/projects/#{project.id}/labels", user),
            name: 'Foo',
            color: '#FFAA'
-      response.status.should == 400
-      json_response['message']['color'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['color']).to eq(['is invalid'])
     end
 
     it 'should return 400 for too long color code' do
       post api("/projects/#{project.id}/labels", user),
            name: 'Foo',
            color: '#FFAAFFFF'
-      response.status.should == 400
-      json_response['message']['color'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['color']).to eq(['is invalid'])
     end
 
     it 'should return 400 for invalid name' do
       post api("/projects/#{project.id}/labels", user),
            name: '?',
            color: '#FFAABB'
-      response.status.should == 400
-      json_response['message']['title'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['title']).to eq(['is invalid'])
     end
 
     it 'should return 409 if label already exists' do
       post api("/projects/#{project.id}/labels", user),
            name: 'label1',
            color: '#FFAABB'
-      response.status.should == 409
-      json_response['message'].should == 'Label already exists'
+      expect(response.status).to eq(409)
+      expect(json_response['message']).to eq('Label already exists')
     end
   end
 
   describe 'DELETE /projects/:id/labels' do
     it 'should return 200 for existing label' do
       delete api("/projects/#{project.id}/labels", user), name: 'label1'
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it 'should return 404 for non existing label' do
       delete api("/projects/#{project.id}/labels", user), name: 'label2'
-      response.status.should == 404
-      json_response['message'].should == '404 Label Not Found'
+      expect(response.status).to eq(404)
+      expect(json_response['message']).to eq('404 Label Not Found')
     end
 
     it 'should return 400 for wrong parameters' do
       delete api("/projects/#{project.id}/labels", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 
@@ -99,47 +99,47 @@ describe API::API, api: true  do
           name: 'label1',
           new_name: 'New Label',
           color: '#FFFFFF'
-      response.status.should == 200
-      json_response['name'].should == 'New Label'
-      json_response['color'].should == '#FFFFFF'
+      expect(response.status).to eq(200)
+      expect(json_response['name']).to eq('New Label')
+      expect(json_response['color']).to eq('#FFFFFF')
     end
 
     it 'should return 200 if name is changed' do
       put api("/projects/#{project.id}/labels", user),
           name: 'label1',
           new_name: 'New Label'
-      response.status.should == 200
-      json_response['name'].should == 'New Label'
-      json_response['color'].should == label1.color
+      expect(response.status).to eq(200)
+      expect(json_response['name']).to eq('New Label')
+      expect(json_response['color']).to eq(label1.color)
     end
 
     it 'should return 200 if colors is changed' do
       put api("/projects/#{project.id}/labels", user),
           name: 'label1',
           color: '#FFFFFF'
-      response.status.should == 200
-      json_response['name'].should == label1.name
-      json_response['color'].should == '#FFFFFF'
+      expect(response.status).to eq(200)
+      expect(json_response['name']).to eq(label1.name)
+      expect(json_response['color']).to eq('#FFFFFF')
     end
 
     it 'should return 404 if label does not exist' do
       put api("/projects/#{project.id}/labels", user),
           name: 'label2',
           new_name: 'label3'
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it 'should return 400 if no label name given' do
       put api("/projects/#{project.id}/labels", user), new_name: 'label2'
-      response.status.should == 400
-      json_response['message'].should == '400 (Bad request) "name" not given'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('400 (Bad request) "name" not given')
     end
 
     it 'should return 400 if no new parameters given' do
       put api("/projects/#{project.id}/labels", user), name: 'label1'
-      response.status.should == 400
-      json_response['message'].should == 'Required parameters '\
-                                         '"new_name" or "color" missing'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('Required parameters '\
+                                         '"new_name" or "color" missing')
     end
 
     it 'should return 400 for invalid name' do
@@ -147,24 +147,24 @@ describe API::API, api: true  do
           name: 'label1',
           new_name: '?',
           color: '#FFFFFF'
-      response.status.should == 400
-      json_response['message']['title'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['title']).to eq(['is invalid'])
     end
 
     it 'should return 400 for invalid name' do
       put api("/projects/#{project.id}/labels", user),
           name: 'label1',
           color: '#FF'
-      response.status.should == 400
-      json_response['message']['color'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['color']).to eq(['is invalid'])
     end
 
     it 'should return 400 for too long color code' do
       post api("/projects/#{project.id}/labels", user),
            name: 'Foo',
            color: '#FFAAFFFF'
-      response.status.should == 400
-      json_response['message']['color'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['color']).to eq(['is invalid'])
     end
   end
 end
diff --git a/spec/requests/api/merge_requests_spec.rb b/spec/requests/api/merge_requests_spec.rb
index b5deb072cd1..9e252441a4f 100644
--- a/spec/requests/api/merge_requests_spec.rb
+++ b/spec/requests/api/merge_requests_spec.rb
@@ -16,50 +16,50 @@ describe API::API, api: true  do
     context "when unauthenticated" do
       it "should return authentication error" do
         get api("/projects/#{project.id}/merge_requests")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context "when authenticated" do
       it "should return an array of all merge_requests" do
         get api("/projects/#{project.id}/merge_requests", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 3
-        json_response.last['title'].should == merge_request.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(3)
+        expect(json_response.last['title']).to eq(merge_request.title)
       end
 
       it "should return an array of all merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 3
-        json_response.last['title'].should == merge_request.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(3)
+        expect(json_response.last['title']).to eq(merge_request.title)
       end
 
       it "should return an array of open merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state=opened", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.last['title'].should == merge_request.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.last['title']).to eq(merge_request.title)
       end
 
       it "should return an array of closed merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state=closed", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 2
-        json_response.second['title'].should == merge_request_closed.title
-        json_response.first['title'].should == merge_request_merged.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(2)
+        expect(json_response.second['title']).to eq(merge_request_closed.title)
+        expect(json_response.first['title']).to eq(merge_request_merged.title)
       end
 
       it "should return an array of merged merge_requests" do
         get api("/projects/#{project.id}/merge_requests?state=merged", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.length.should == 1
-        json_response.first['title'].should == merge_request_merged.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.length).to eq(1)
+        expect(json_response.first['title']).to eq(merge_request_merged.title)
       end
 
       context "with ordering" do
@@ -70,38 +70,38 @@ describe API::API, api: true  do
 
         it "should return an array of merge_requests in ascending order" do
           get api("/projects/#{project.id}/merge_requests?sort=asc", user)
-          response.status.should == 200
-          json_response.should be_an Array
-          json_response.length.should == 3
-          json_response.last['id'].should == @mr_earlier.id
-          json_response.first['id'].should == @mr_later.id
+          expect(response.status).to eq(200)
+          expect(json_response).to be_an Array
+          expect(json_response.length).to eq(3)
+          expect(json_response.last['id']).to eq(@mr_earlier.id)
+          expect(json_response.first['id']).to eq(@mr_later.id)
         end
 
         it "should return an array of merge_requests in descending order" do
           get api("/projects/#{project.id}/merge_requests?sort=desc", user)
-          response.status.should == 200
-          json_response.should be_an Array
-          json_response.length.should == 3
-          json_response.first['id'].should == @mr_later.id
-          json_response.last['id'].should == @mr_earlier.id
+          expect(response.status).to eq(200)
+          expect(json_response).to be_an Array
+          expect(json_response.length).to eq(3)
+          expect(json_response.first['id']).to eq(@mr_later.id)
+          expect(json_response.last['id']).to eq(@mr_earlier.id)
         end
 
         it "should return an array of merge_requests ordered by updated_at" do
           get api("/projects/#{project.id}/merge_requests?order_by=updated_at", user)
-          response.status.should == 200
-          json_response.should be_an Array
-          json_response.length.should == 3
-          json_response.last['id'].should == @mr_earlier.id
-          json_response.first['id'].should == @mr_later.id
+          expect(response.status).to eq(200)
+          expect(json_response).to be_an Array
+          expect(json_response.length).to eq(3)
+          expect(json_response.last['id']).to eq(@mr_earlier.id)
+          expect(json_response.first['id']).to eq(@mr_later.id)
         end
 
         it "should return an array of merge_requests ordered by created_at" do
           get api("/projects/#{project.id}/merge_requests?sort=created_at", user)
-          response.status.should == 200
-          json_response.should be_an Array
-          json_response.length.should == 3
-          json_response.last['id'].should == @mr_earlier.id
-          json_response.first['id'].should == @mr_later.id
+          expect(response.status).to eq(200)
+          expect(json_response).to be_an Array
+          expect(json_response.length).to eq(3)
+          expect(json_response.last['id']).to eq(@mr_earlier.id)
+          expect(json_response.first['id']).to eq(@mr_later.id)
         end
       end
     end
@@ -110,14 +110,14 @@ describe API::API, api: true  do
   describe "GET /projects/:id/merge_request/:merge_request_id" do
     it "should return merge_request" do
       get api("/projects/#{project.id}/merge_request/#{merge_request.id}", user)
-      response.status.should == 200
-      json_response['title'].should == merge_request.title
-      json_response['iid'].should == merge_request.iid
+      expect(response.status).to eq(200)
+      expect(json_response['title']).to eq(merge_request.title)
+      expect(json_response['iid']).to eq(merge_request.iid)
     end
 
     it "should return a 404 error if merge_request_id not found" do
       get api("/projects/#{project.id}/merge_request/999", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -143,33 +143,33 @@ describe API::API, api: true  do
              target_branch: 'master',
              author: user,
              labels: 'label, label2'
-        response.status.should == 201
-        json_response['title'].should == 'Test merge_request'
-        json_response['labels'].should == ['label', 'label2']
+        expect(response.status).to eq(201)
+        expect(json_response['title']).to eq('Test merge_request')
+        expect(json_response['labels']).to eq(['label', 'label2'])
       end
 
       it "should return 422 when source_branch equals target_branch" do
         post api("/projects/#{project.id}/merge_requests", user),
         title: "Test merge_request", source_branch: "master", target_branch: "master", author: user
-        response.status.should == 422
+        expect(response.status).to eq(422)
       end
 
       it "should return 400 when source_branch is missing" do
         post api("/projects/#{project.id}/merge_requests", user),
         title: "Test merge_request", target_branch: "master", author: user
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return 400 when target_branch is missing" do
         post api("/projects/#{project.id}/merge_requests", user),
         title: "Test merge_request", source_branch: "stable", author: user
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return 400 when title is missing" do
         post api("/projects/#{project.id}/merge_requests", user),
         target_branch: 'master', source_branch: 'stable'
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it 'should return 400 on invalid label names' do
@@ -179,9 +179,10 @@ describe API::API, api: true  do
              target_branch: 'master',
              author: user,
              labels: 'label, ?'
-        response.status.should == 400
-        json_response['message']['labels']['?']['title'].should ==
+        expect(response.status).to eq(400)
+        expect(json_response['message']['labels']['?']['title']).to eq(
           ['is invalid']
+        )
       end
 
       context 'with existing MR' do
@@ -202,7 +203,7 @@ describe API::API, api: true  do
                  target_branch: 'master',
                  author: user
           end.to change { MergeRequest.count }.by(0)
-          response.status.should == 409
+          expect(response.status).to eq(409)
         end
       end
     end
@@ -219,37 +220,37 @@ describe API::API, api: true  do
       it "should return merge_request" do
         post api("/projects/#{fork_project.id}/merge_requests", user2),
         title: 'Test merge_request', source_branch: "stable", target_branch: "master", author: user2, target_project_id: project.id, description: 'Test description for Test merge_request'
-        response.status.should == 201
-        json_response['title'].should == 'Test merge_request'
-        json_response['description'].should == 'Test description for Test merge_request'
+        expect(response.status).to eq(201)
+        expect(json_response['title']).to eq('Test merge_request')
+        expect(json_response['description']).to eq('Test description for Test merge_request')
       end
 
       it "should not return 422 when source_branch equals target_branch" do
-        project.id.should_not == fork_project.id
-        fork_project.forked?.should be_true
-        fork_project.forked_from_project.should == project
+        expect(project.id).not_to eq(fork_project.id)
+        expect(fork_project.forked?).to be_truthy
+        expect(fork_project.forked_from_project).to eq(project)
         post api("/projects/#{fork_project.id}/merge_requests", user2),
         title: 'Test merge_request', source_branch: "master", target_branch: "master", author: user2, target_project_id: project.id
-        response.status.should == 201
-        json_response['title'].should == 'Test merge_request'
+        expect(response.status).to eq(201)
+        expect(json_response['title']).to eq('Test merge_request')
       end
 
       it "should return 400 when source_branch is missing" do
         post api("/projects/#{fork_project.id}/merge_requests", user2),
         title: 'Test merge_request', target_branch: "master", author: user2, target_project_id: project.id
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return 400 when target_branch is missing" do
         post api("/projects/#{fork_project.id}/merge_requests", user2),
         title: 'Test merge_request', target_branch: "master", author: user2, target_project_id: project.id
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return 400 when title is missing" do
         post api("/projects/#{fork_project.id}/merge_requests", user2),
         target_branch: 'master', source_branch: 'stable', author: user2, target_project_id: project.id
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       context 'when target_branch is specified' do
@@ -260,7 +261,7 @@ describe API::API, api: true  do
                source_branch: 'stable',
                author: user,
                target_project_id: fork_project.id
-          response.status.should == 422
+          expect(response.status).to eq(422)
         end
 
         it 'should return 422 if targeting a different fork' do
@@ -270,14 +271,14 @@ describe API::API, api: true  do
                source_branch: 'stable',
                author: user2,
                target_project_id: unrelated_project.id
-          response.status.should == 422
+          expect(response.status).to eq(422)
         end
       end
 
       it "should return 201 when target_branch is specified and for the same project" do
         post api("/projects/#{fork_project.id}/merge_requests", user2),
         title: 'Test merge_request', target_branch: 'master', source_branch: 'stable', author: user2, target_project_id: fork_project.id
-        response.status.should == 201
+        expect(response.status).to eq(201)
       end
     end
   end
@@ -285,8 +286,8 @@ describe API::API, api: true  do
   describe "PUT /projects/:id/merge_request/:merge_request_id to close MR" do
     it "should return merge_request" do
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}", user), state_event: "close"
-      response.status.should == 200
-      json_response['state'].should == 'closed'
+      expect(response.status).to eq(200)
+      expect(json_response['state']).to eq('closed')
     end
   end
 
@@ -294,55 +295,55 @@ describe API::API, api: true  do
     it "should return merge_request in case of success" do
       MergeRequest.any_instance.stub(can_be_merged?: true, automerge!: true)
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}/merge", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return 405 if branch can't be merged" do
       MergeRequest.any_instance.stub(can_be_merged?: false)
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}/merge", user)
-      response.status.should == 405
-      json_response['message'].should == 'Branch cannot be merged'
+      expect(response.status).to eq(405)
+      expect(json_response['message']).to eq('Branch cannot be merged')
     end
 
     it "should return 405 if merge_request is not open" do
       merge_request.close
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}/merge", user)
-      response.status.should == 405
-      json_response['message'].should == '405 Method Not Allowed'
+      expect(response.status).to eq(405)
+      expect(json_response['message']).to eq('405 Method Not Allowed')
     end
 
     it "should return 401 if user has no permissions to merge" do
       user2 = create(:user)
       project.team << [user2, :reporter]
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}/merge", user2)
-      response.status.should == 401
-      json_response['message'].should == '401 Unauthorized'
+      expect(response.status).to eq(401)
+      expect(json_response['message']).to eq('401 Unauthorized')
     end
   end
 
   describe "PUT /projects/:id/merge_request/:merge_request_id" do
     it "should return merge_request" do
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}", user), title: "New title"
-      response.status.should == 200
-      json_response['title'].should == 'New title'
+      expect(response.status).to eq(200)
+      expect(json_response['title']).to eq('New title')
     end
 
     it "should return merge_request" do
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}", user), description: "New description"
-      response.status.should == 200
-      json_response['description'].should == 'New description'
+      expect(response.status).to eq(200)
+      expect(json_response['description']).to eq('New description')
     end
 
     it "should return 422 when source_branch and target_branch are renamed the same" do
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}", user),
       source_branch: "master", target_branch: "master"
-      response.status.should == 422
+      expect(response.status).to eq(422)
     end
 
     it "should return merge_request with renamed target_branch" do
       put api("/projects/#{project.id}/merge_request/#{merge_request.id}", user), target_branch: "wiki"
-      response.status.should == 200
-      json_response['target_branch'].should == 'wiki'
+      expect(response.status).to eq(200)
+      expect(json_response['target_branch']).to eq('wiki')
     end
 
     it 'should return 400 on invalid label names' do
@@ -350,43 +351,43 @@ describe API::API, api: true  do
               user),
           title: 'new issue',
           labels: 'label, ?'
-      response.status.should == 400
-      json_response['message']['labels']['?']['title'].should == ['is invalid']
+      expect(response.status).to eq(400)
+      expect(json_response['message']['labels']['?']['title']).to eq(['is invalid'])
     end
   end
 
   describe "POST /projects/:id/merge_request/:merge_request_id/comments" do
     it "should return comment" do
       post api("/projects/#{project.id}/merge_request/#{merge_request.id}/comments", user), note: "My comment"
-      response.status.should == 201
-      json_response['note'].should == 'My comment'
+      expect(response.status).to eq(201)
+      expect(json_response['note']).to eq('My comment')
     end
 
     it "should return 400 if note is missing" do
       post api("/projects/#{project.id}/merge_request/#{merge_request.id}/comments", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return 404 if note is attached to non existent merge request" do
       post api("/projects/#{project.id}/merge_request/404/comments", user),
            note: 'My comment'
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
   describe "GET :id/merge_request/:merge_request_id/comments" do
     it "should return merge_request comments" do
       get api("/projects/#{project.id}/merge_request/#{merge_request.id}/comments", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.length.should == 1
-      json_response.first['note'].should == "a comment on a MR"
-      json_response.first['author']['id'].should == user.id
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.length).to eq(1)
+      expect(json_response.first['note']).to eq("a comment on a MR")
+      expect(json_response.first['author']['id']).to eq(user.id)
     end
 
     it "should return a 404 error if merge_request_id not found" do
       get api("/projects/#{project.id}/merge_request/999/comments", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
diff --git a/spec/requests/api/milestones_spec.rb b/spec/requests/api/milestones_spec.rb
index 647033309bd..effb0723476 100644
--- a/spec/requests/api/milestones_spec.rb
+++ b/spec/requests/api/milestones_spec.rb
@@ -11,55 +11,55 @@ describe API::API, api: true  do
   describe 'GET /projects/:id/milestones' do
     it 'should return project milestones' do
       get api("/projects/#{project.id}/milestones", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.first['title'].should == milestone.title
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.first['title']).to eq(milestone.title)
     end
 
     it 'should return a 401 error if user not authenticated' do
       get api("/projects/#{project.id}/milestones")
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
   end
 
   describe 'GET /projects/:id/milestones/:milestone_id' do
     it 'should return a project milestone by id' do
       get api("/projects/#{project.id}/milestones/#{milestone.id}", user)
-      response.status.should == 200
-      json_response['title'].should == milestone.title
-      json_response['iid'].should == milestone.iid
+      expect(response.status).to eq(200)
+      expect(json_response['title']).to eq(milestone.title)
+      expect(json_response['iid']).to eq(milestone.iid)
     end
 
     it 'should return 401 error if user not authenticated' do
       get api("/projects/#{project.id}/milestones/#{milestone.id}")
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
 
     it 'should return a 404 error if milestone id not found' do
       get api("/projects/#{project.id}/milestones/1234", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
   describe 'POST /projects/:id/milestones' do
     it 'should create a new project milestone' do
       post api("/projects/#{project.id}/milestones", user), title: 'new milestone'
-      response.status.should == 201
-      json_response['title'].should == 'new milestone'
-      json_response['description'].should be_nil
+      expect(response.status).to eq(201)
+      expect(json_response['title']).to eq('new milestone')
+      expect(json_response['description']).to be_nil
     end
 
     it 'should create a new project milestone with description and due date' do
       post api("/projects/#{project.id}/milestones", user),
         title: 'new milestone', description: 'release', due_date: '2013-03-02'
-      response.status.should == 201
-      json_response['description'].should == 'release'
-      json_response['due_date'].should == '2013-03-02'
+      expect(response.status).to eq(201)
+      expect(json_response['description']).to eq('release')
+      expect(json_response['due_date']).to eq('2013-03-02')
     end
 
     it 'should return a 400 error if title is missing' do
       post api("/projects/#{project.id}/milestones", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 
@@ -67,14 +67,14 @@ describe API::API, api: true  do
     it 'should update a project milestone' do
       put api("/projects/#{project.id}/milestones/#{milestone.id}", user),
         title: 'updated title'
-      response.status.should == 200
-      json_response['title'].should == 'updated title'
+      expect(response.status).to eq(200)
+      expect(json_response['title']).to eq('updated title')
     end
 
     it 'should return a 404 error if milestone id not found' do
       put api("/projects/#{project.id}/milestones/1234", user),
         title: 'updated title'
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -82,15 +82,15 @@ describe API::API, api: true  do
     it 'should update a project milestone' do
       put api("/projects/#{project.id}/milestones/#{milestone.id}", user),
         state_event: 'close'
-      response.status.should == 200
+      expect(response.status).to eq(200)
 
-      json_response['state'].should == 'closed'
+      expect(json_response['state']).to eq('closed')
     end
   end
 
   describe 'PUT /projects/:id/milestones/:milestone_id to test observer on close' do
     it 'should create an activity event when an milestone is closed' do
-      Event.should_receive(:create)
+      expect(Event).to receive(:create)
 
       put api("/projects/#{project.id}/milestones/#{milestone.id}", user),
           state_event: 'close'
@@ -103,14 +103,14 @@ describe API::API, api: true  do
     end
     it 'should return project issues for a particular milestone' do
       get api("/projects/#{project.id}/milestones/#{milestone.id}/issues", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.first['milestone']['title'].should == milestone.title
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.first['milestone']['title']).to eq(milestone.title)
     end
 
     it 'should return a 401 error if user not authenticated' do
       get api("/projects/#{project.id}/milestones/#{milestone.id}/issues")
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
   end
 end
diff --git a/spec/requests/api/namespaces_spec.rb b/spec/requests/api/namespaces_spec.rb
index b8943ea0762..6ddaaa0a6dd 100644
--- a/spec/requests/api/namespaces_spec.rb
+++ b/spec/requests/api/namespaces_spec.rb
@@ -10,17 +10,17 @@ describe API::API, api: true  do
     context "when unauthenticated" do
       it "should return authentication error" do
         get api("/namespaces")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context "when authenticated as  admin" do
       it "admin: should return an array of all namespaces" do
         get api("/namespaces", admin)
-        response.status.should == 200
-        json_response.should be_an Array
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
 
-        json_response.length.should == Namespace.count
+        expect(json_response.length).to eq(Namespace.count)
       end
     end
   end
diff --git a/spec/requests/api/notes_spec.rb b/spec/requests/api/notes_spec.rb
index 429824e829a..8b177af4689 100644
--- a/spec/requests/api/notes_spec.rb
+++ b/spec/requests/api/notes_spec.rb
@@ -16,42 +16,42 @@ describe API::API, api: true  do
     context "when noteable is an Issue" do
       it "should return an array of issue notes" do
         get api("/projects/#{project.id}/issues/#{issue.id}/notes", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first['body'].should == issue_note.note
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first['body']).to eq(issue_note.note)
       end
 
       it "should return a 404 error when issue id not found" do
         get api("/projects/#{project.id}/issues/123/notes", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context "when noteable is a Snippet" do
       it "should return an array of snippet notes" do
         get api("/projects/#{project.id}/snippets/#{snippet.id}/notes", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first['body'].should == snippet_note.note
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first['body']).to eq(snippet_note.note)
       end
 
       it "should return a 404 error when snippet id not found" do
         get api("/projects/#{project.id}/snippets/42/notes", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context "when noteable is a Merge Request" do
       it "should return an array of merge_requests notes" do
         get api("/projects/#{project.id}/merge_requests/#{merge_request.id}/notes", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first['body'].should == merge_request_note.note
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first['body']).to eq(merge_request_note.note)
       end
 
       it "should return a 404 error if merge request id not found" do
         get api("/projects/#{project.id}/merge_requests/4444/notes", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
   end
@@ -60,26 +60,26 @@ describe API::API, api: true  do
     context "when noteable is an Issue" do
       it "should return an issue note by id" do
         get api("/projects/#{project.id}/issues/#{issue.id}/notes/#{issue_note.id}", user)
-        response.status.should == 200
-        json_response['body'].should == issue_note.note
+        expect(response.status).to eq(200)
+        expect(json_response['body']).to eq(issue_note.note)
       end
 
       it "should return a 404 error if issue note not found" do
         get api("/projects/#{project.id}/issues/#{issue.id}/notes/123", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context "when noteable is a Snippet" do
       it "should return a snippet note by id" do
         get api("/projects/#{project.id}/snippets/#{snippet.id}/notes/#{snippet_note.id}", user)
-        response.status.should == 200
-        json_response['body'].should == snippet_note.note
+        expect(response.status).to eq(200)
+        expect(json_response['body']).to eq(snippet_note.note)
       end
 
       it "should return a 404 error if snippet note not found" do
         get api("/projects/#{project.id}/snippets/#{snippet.id}/notes/123", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
   end
@@ -88,45 +88,45 @@ describe API::API, api: true  do
     context "when noteable is an Issue" do
       it "should create a new issue note" do
         post api("/projects/#{project.id}/issues/#{issue.id}/notes", user), body: 'hi!'
-        response.status.should == 201
-        json_response['body'].should == 'hi!'
-        json_response['author']['username'].should == user.username
+        expect(response.status).to eq(201)
+        expect(json_response['body']).to eq('hi!')
+        expect(json_response['author']['username']).to eq(user.username)
       end
 
       it "should return a 400 bad request error if body not given" do
         post api("/projects/#{project.id}/issues/#{issue.id}/notes", user)
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return a 401 unauthorized error if user not authenticated" do
         post api("/projects/#{project.id}/issues/#{issue.id}/notes"), body: 'hi!'
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context "when noteable is a Snippet" do
       it "should create a new snippet note" do
         post api("/projects/#{project.id}/snippets/#{snippet.id}/notes", user), body: 'hi!'
-        response.status.should == 201
-        json_response['body'].should == 'hi!'
-        json_response['author']['username'].should == user.username
+        expect(response.status).to eq(201)
+        expect(json_response['body']).to eq('hi!')
+        expect(json_response['author']['username']).to eq(user.username)
       end
 
       it "should return a 400 bad request error if body not given" do
         post api("/projects/#{project.id}/snippets/#{snippet.id}/notes", user)
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
 
       it "should return a 401 unauthorized error if user not authenticated" do
         post api("/projects/#{project.id}/snippets/#{snippet.id}/notes"), body: 'hi!'
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
   end
 
   describe "POST /projects/:id/noteable/:noteable_id/notes to test observer on create" do
     it "should create an activity event when an issue note is created" do
-      Event.should_receive(:create)
+      expect(Event).to receive(:create)
 
       post api("/projects/#{project.id}/issues/#{issue.id}/notes", user), body: 'hi!'
     end
@@ -137,20 +137,20 @@ describe API::API, api: true  do
       it 'should return modified note' do
         put api("/projects/#{project.id}/issues/#{issue.id}/"\
                   "notes/#{issue_note.id}", user), body: 'Hello!'
-        response.status.should == 200
-        json_response['body'].should == 'Hello!'
+        expect(response.status).to eq(200)
+        expect(json_response['body']).to eq('Hello!')
       end
 
       it 'should return a 404 error when note id not found' do
         put api("/projects/#{project.id}/issues/#{issue.id}/notes/123", user),
                 body: 'Hello!'
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it 'should return a 400 bad request error if body not given' do
         put api("/projects/#{project.id}/issues/#{issue.id}/"\
                   "notes/#{issue_note.id}", user)
-        response.status.should == 400
+        expect(response.status).to eq(400)
       end
     end
 
@@ -158,14 +158,14 @@ describe API::API, api: true  do
       it 'should return modified note' do
         put api("/projects/#{project.id}/snippets/#{snippet.id}/"\
                   "notes/#{snippet_note.id}", user), body: 'Hello!'
-        response.status.should == 200
-        json_response['body'].should == 'Hello!'
+        expect(response.status).to eq(200)
+        expect(json_response['body']).to eq('Hello!')
       end
 
       it 'should return a 404 error when note id not found' do
         put api("/projects/#{project.id}/snippets/#{snippet.id}/"\
                   "notes/123", user), body: "Hello!"
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
@@ -173,14 +173,14 @@ describe API::API, api: true  do
       it 'should return modified note' do
         put api("/projects/#{project.id}/merge_requests/#{merge_request.id}/"\
                   "notes/#{merge_request_note.id}", user), body: 'Hello!'
-        response.status.should == 200
-        json_response['body'].should == 'Hello!'
+        expect(response.status).to eq(200)
+        expect(json_response['body']).to eq('Hello!')
       end
 
       it 'should return a 404 error when note id not found' do
         put api("/projects/#{project.id}/merge_requests/#{merge_request.id}/"\
                   "notes/123", user), body: "Hello!"
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
   end
diff --git a/spec/requests/api/project_hooks_spec.rb b/spec/requests/api/project_hooks_spec.rb
index cdb5e3d0612..81fe68de662 100644
--- a/spec/requests/api/project_hooks_spec.rb
+++ b/spec/requests/api/project_hooks_spec.rb
@@ -16,18 +16,18 @@ describe API::API, 'ProjectHooks', api: true  do
     context "authorized user" do
       it "should return project hooks" do
         get api("/projects/#{project.id}/hooks", user)
-        response.status.should == 200
+        expect(response.status).to eq(200)
 
-        json_response.should be_an Array
-        json_response.count.should == 1
-        json_response.first['url'].should == "http://example.com"
+        expect(json_response).to be_an Array
+        expect(json_response.count).to eq(1)
+        expect(json_response.first['url']).to eq("http://example.com")
       end
     end
 
     context "unauthorized user" do
       it "should not access project hooks" do
         get api("/projects/#{project.id}/hooks", user3)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
   end
@@ -36,26 +36,26 @@ describe API::API, 'ProjectHooks', api: true  do
     context "authorized user" do
       it "should return a project hook" do
         get api("/projects/#{project.id}/hooks/#{hook.id}", user)
-        response.status.should == 200
-        json_response['url'].should == hook.url
+        expect(response.status).to eq(200)
+        expect(json_response['url']).to eq(hook.url)
       end
 
       it "should return a 404 error if hook id is not available" do
         get api("/projects/#{project.id}/hooks/1234", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context "unauthorized user" do
       it "should not access an existing hook" do
         get api("/projects/#{project.id}/hooks/#{hook.id}", user3)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
     it "should return a 404 error if hook id is not available" do
       get api("/projects/#{project.id}/hooks/1234", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -65,17 +65,17 @@ describe API::API, 'ProjectHooks', api: true  do
         post api("/projects/#{project.id}/hooks", user),
           url: "http://example.com", issues_events: true
       }.to change {project.hooks.count}.by(1)
-      response.status.should == 201
+      expect(response.status).to eq(201)
     end
 
     it "should return a 400 error if url not given" do
       post api("/projects/#{project.id}/hooks", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 422 error if url not valid" do
       post api("/projects/#{project.id}/hooks", user), "url" => "ftp://example.com"
-      response.status.should == 422
+      expect(response.status).to eq(422)
     end
   end
 
@@ -83,23 +83,23 @@ describe API::API, 'ProjectHooks', api: true  do
     it "should update an existing project hook" do
       put api("/projects/#{project.id}/hooks/#{hook.id}", user),
         url: 'http://example.org', push_events: false
-      response.status.should == 200
-      json_response['url'].should == 'http://example.org'
+      expect(response.status).to eq(200)
+      expect(json_response['url']).to eq('http://example.org')
     end
 
     it "should return 404 error if hook id not found" do
       put api("/projects/#{project.id}/hooks/1234", user), url: 'http://example.org'
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it "should return 400 error if url is not given" do
       put api("/projects/#{project.id}/hooks/#{hook.id}", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 422 error if url is not valid" do
       put api("/projects/#{project.id}/hooks/#{hook.id}", user), url: 'ftp://example.com'
-      response.status.should == 422
+      expect(response.status).to eq(422)
     end
   end
 
@@ -108,22 +108,22 @@ describe API::API, 'ProjectHooks', api: true  do
       expect {
         delete api("/projects/#{project.id}/hooks/#{hook.id}", user)
       }.to change {project.hooks.count}.by(-1)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return success when deleting hook" do
       delete api("/projects/#{project.id}/hooks/#{hook.id}", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return success when deleting non existent hook" do
       delete api("/projects/#{project.id}/hooks/42", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return a 405 error if hook id not given" do
       delete api("/projects/#{project.id}/hooks", user)
-      response.status.should == 405
+      expect(response.status).to eq(405)
     end
   end
 end
diff --git a/spec/requests/api/project_members_spec.rb b/spec/requests/api/project_members_spec.rb
index 836f21f3e0b..8419a364ed1 100644
--- a/spec/requests/api/project_members_spec.rb
+++ b/spec/requests/api/project_members_spec.rb
@@ -15,23 +15,23 @@ describe API::API, api: true  do
 
     it "should return project team members" do
       get api("/projects/#{project.id}/members", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.count.should == 2
-      json_response.map { |u| u['username'] }.should include user.username
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.count).to eq(2)
+      expect(json_response.map { |u| u['username'] }).to include user.username
     end
 
     it "finds team members with query string" do
       get api("/projects/#{project.id}/members", user), query: user.username
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.count.should == 1
-      json_response.first['username'].should == user.username
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.count).to eq(1)
+      expect(json_response.first['username']).to eq(user.username)
     end
 
     it "should return a 404 error if id not found" do
       get api("/projects/9999/members", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -40,14 +40,14 @@ describe API::API, api: true  do
 
     it "should return project team member" do
       get api("/projects/#{project.id}/members/#{user.id}", user)
-      response.status.should == 200
-      json_response['username'].should == user.username
-      json_response['access_level'].should == ProjectMember::MASTER
+      expect(response.status).to eq(200)
+      expect(json_response['username']).to eq(user.username)
+      expect(json_response['access_level']).to eq(ProjectMember::MASTER)
     end
 
     it "should return a 404 error if user id not found" do
       get api("/projects/#{project.id}/members/1234", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -58,9 +58,9 @@ describe API::API, api: true  do
           access_level: ProjectMember::DEVELOPER
       }.to change { ProjectMember.count }.by(1)
 
-      response.status.should == 201
-      json_response['username'].should == user2.username
-      json_response['access_level'].should == ProjectMember::DEVELOPER
+      expect(response.status).to eq(201)
+      expect(json_response['username']).to eq(user2.username)
+      expect(json_response['access_level']).to eq(ProjectMember::DEVELOPER)
     end
 
     it "should return a 201 status if user is already project member" do
@@ -69,26 +69,26 @@ describe API::API, api: true  do
       expect {
         post api("/projects/#{project.id}/members", user), user_id: user2.id,
           access_level: ProjectMember::DEVELOPER
-      }.not_to change { ProjectMember.count }.by(1)
+      }.not_to change { ProjectMember.count }
 
-      response.status.should == 201
-      json_response['username'].should == user2.username
-      json_response['access_level'].should == ProjectMember::DEVELOPER
+      expect(response.status).to eq(201)
+      expect(json_response['username']).to eq(user2.username)
+      expect(json_response['access_level']).to eq(ProjectMember::DEVELOPER)
     end
 
     it "should return a 400 error when user id is not given" do
       post api("/projects/#{project.id}/members", user), access_level: ProjectMember::MASTER
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 400 error when access level is not given" do
       post api("/projects/#{project.id}/members", user), user_id: user2.id
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 422 error when access level is not known" do
       post api("/projects/#{project.id}/members", user), user_id: user2.id, access_level: 1234
-      response.status.should == 422
+      expect(response.status).to eq(422)
     end
   end
 
@@ -97,24 +97,24 @@ describe API::API, api: true  do
 
     it "should update project team member" do
       put api("/projects/#{project.id}/members/#{user3.id}", user), access_level: ProjectMember::MASTER
-      response.status.should == 200
-      json_response['username'].should == user3.username
-      json_response['access_level'].should == ProjectMember::MASTER
+      expect(response.status).to eq(200)
+      expect(json_response['username']).to eq(user3.username)
+      expect(json_response['access_level']).to eq(ProjectMember::MASTER)
     end
 
     it "should return a 404 error if user_id is not found" do
       put api("/projects/#{project.id}/members/1234", user), access_level: ProjectMember::MASTER
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it "should return a 400 error when access level is not given" do
       put api("/projects/#{project.id}/members/#{user3.id}", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return a 422 error when access level is not known" do
       put api("/projects/#{project.id}/members/#{user3.id}", user), access_level: 123
-      response.status.should == 422
+      expect(response.status).to eq(422)
     end
   end
 
@@ -132,22 +132,22 @@ describe API::API, api: true  do
       delete api("/projects/#{project.id}/members/#{user3.id}", user)
       expect {
         delete api("/projects/#{project.id}/members/#{user3.id}", user)
-      }.to_not change { ProjectMember.count }.by(1)
+      }.to_not change { ProjectMember.count }
     end
 
     it "should return 200 if team member already removed" do
       delete api("/projects/#{project.id}/members/#{user3.id}", user)
       delete api("/projects/#{project.id}/members/#{user3.id}", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return 200 OK when the user was not member" do
       expect {
         delete api("/projects/#{project.id}/members/1000000", user)
       }.to change { ProjectMember.count }.by(0)
-      response.status.should == 200
-      json_response['message'].should == "Access revoked"
-      json_response['id'].should == 1000000
+      expect(response.status).to eq(200)
+      expect(json_response['message']).to eq("Access revoked")
+      expect(json_response['id']).to eq(1000000)
     end
   end
 end
diff --git a/spec/requests/api/projects_spec.rb b/spec/requests/api/projects_spec.rb
index 65c894ac0c2..170ede57310 100644
--- a/spec/requests/api/projects_spec.rb
+++ b/spec/requests/api/projects_spec.rb
@@ -44,25 +44,25 @@ describe API::API, api: true  do
     context 'when unauthenticated' do
       it 'should return authentication error' do
         get api('/projects')
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context 'when authenticated' do
       it 'should return an array of projects' do
         get api('/projects', user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first['name'].should == project.name
-        json_response.first['owner']['username'].should == user.username
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first['name']).to eq(project.name)
+        expect(json_response.first['owner']['username']).to eq(user.username)
       end
 
       context 'and using search' do
         it 'should return searched project' do
           get api('/projects', user), { search: project.name }
-          response.status.should eq(200)
-          json_response.should be_an Array
-          json_response.length.should eq(1)
+          expect(response.status).to eq(200)
+          expect(json_response).to be_an Array
+          expect(json_response.length).to eq(1)
         end
       end
 
@@ -74,9 +74,9 @@ describe API::API, api: true  do
 
         it 'should return the correct order when sorted by id' do
           get api('/projects', user), { order_by: 'id', sort: 'desc'}
-          response.status.should eq(200)
-          json_response.should be_an Array
-          json_response.first['id'].should eq(project3.id)
+          expect(response.status).to eq(200)
+          expect(json_response).to be_an Array
+          expect(json_response.first['id']).to eq(project3.id)
         end
       end
     end
@@ -88,31 +88,31 @@ describe API::API, api: true  do
     context 'when unauthenticated' do
       it 'should return authentication error' do
         get api('/projects/all')
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context 'when authenticated as regular user' do
       it 'should return authentication error' do
         get api('/projects/all', user)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
     context 'when authenticated as admin' do
       it 'should return an array of all projects' do
         get api('/projects/all', admin)
-        response.status.should == 200
-        json_response.should be_an Array
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
         project_name = project.name
 
-        json_response.detect {
+        expect(json_response.detect {
           |project| project['name'] == project_name
-        }['name'].should == project_name
+        }['name']).to eq(project_name)
 
-        json_response.detect {
+        expect(json_response.detect {
           |project| project['owner']['username'] == user.username
-        }['owner']['username'].should == user.username
+        }['owner']['username']).to eq(user.username)
       end
     end
   end
@@ -120,29 +120,29 @@ describe API::API, api: true  do
   describe 'POST /projects' do
     context 'maximum number of projects reached' do
       it 'should not create new project and respond with 403' do
-        User.any_instance.stub(:projects_limit_left).and_return(0)
+        allow_any_instance_of(User).to receive(:projects_limit_left).and_return(0)
         expect {
           post api('/projects', user2), name: 'foo'
         }.to change {Project.count}.by(0)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
     it 'should create new project without path and return 201' do
       expect { post api('/projects', user), name: 'foo' }.
         to change { Project.count }.by(1)
-      response.status.should == 201
+      expect(response.status).to eq(201)
     end
 
     it 'should create last project before reaching project limit' do
-      User.any_instance.stub(:projects_limit_left).and_return(1)
+      allow_any_instance_of(User).to receive(:projects_limit_left).and_return(1)
       post api('/projects', user2), name: 'foo'
-      response.status.should == 201
+      expect(response.status).to eq(201)
     end
 
     it 'should not create new project without name and return 400' do
       expect { post api('/projects', user) }.to_not change { Project.count }
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should assign attributes to project" do
@@ -157,50 +157,50 @@ describe API::API, api: true  do
       post api('/projects', user), project
 
       project.each_pair do |k,v|
-        json_response[k.to_s].should == v
+        expect(json_response[k.to_s]).to eq(v)
       end
     end
 
     it 'should set a project as public' do
       project = attributes_for(:project, :public)
       post api('/projects', user), project
-      json_response['public'].should be_true
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::PUBLIC
+      expect(json_response['public']).to be_truthy
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::PUBLIC)
     end
 
     it 'should set a project as public using :public' do
       project = attributes_for(:project, { public: true })
       post api('/projects', user), project
-      json_response['public'].should be_true
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::PUBLIC
+      expect(json_response['public']).to be_truthy
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::PUBLIC)
     end
 
     it 'should set a project as internal' do
       project = attributes_for(:project, :internal)
       post api('/projects', user), project
-      json_response['public'].should be_false
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::INTERNAL
+      expect(json_response['public']).to be_falsey
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::INTERNAL)
     end
 
     it 'should set a project as internal overriding :public' do
       project = attributes_for(:project, :internal, { public: true })
       post api('/projects', user), project
-      json_response['public'].should be_false
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::INTERNAL
+      expect(json_response['public']).to be_falsey
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::INTERNAL)
     end
 
     it 'should set a project as private' do
       project = attributes_for(:project, :private)
       post api('/projects', user), project
-      json_response['public'].should be_false
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::PRIVATE
+      expect(json_response['public']).to be_falsey
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::PRIVATE)
     end
 
     it 'should set a project as private using :public' do
       project = attributes_for(:project, { public: false })
       post api('/projects', user), project
-      json_response['public'].should be_false
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::PRIVATE
+      expect(json_response['public']).to be_falsey
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::PRIVATE)
     end
   end
 
@@ -210,24 +210,24 @@ describe API::API, api: true  do
 
     it 'should create new project without path and return 201' do
       expect { post api("/projects/user/#{user.id}", admin), name: 'foo' }.to change {Project.count}.by(1)
-      response.status.should == 201
+      expect(response.status).to eq(201)
     end
 
     it 'should respond with 400 on failure and not project' do
       expect { post api("/projects/user/#{user.id}", admin) }.
         to_not change { Project.count }
 
-      response.status.should == 400
-      json_response['message']['name'].should == [
+      expect(response.status).to eq(400)
+      expect(json_response['message']['name']).to eq([
         'can\'t be blank',
         'is too short (minimum is 0 characters)',
         Gitlab::Regex.project_regex_message
-      ]
-      json_response['message']['path'].should == [
+      ])
+      expect(json_response['message']['path']).to eq([
         'can\'t be blank',
         'is too short (minimum is 0 characters)',
         Gitlab::Regex.send(:default_regex_message)
-      ]
+      ])
     end
 
     it 'should assign attributes to project' do
@@ -242,50 +242,50 @@ describe API::API, api: true  do
 
       project.each_pair do |k,v|
         next if k == :path
-        json_response[k.to_s].should == v
+        expect(json_response[k.to_s]).to eq(v)
       end
     end
 
     it 'should set a project as public' do
       project = attributes_for(:project, :public)
       post api("/projects/user/#{user.id}", admin), project
-      json_response['public'].should be_true
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::PUBLIC
+      expect(json_response['public']).to be_truthy
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::PUBLIC)
     end
 
     it 'should set a project as public using :public' do
       project = attributes_for(:project, { public: true })
       post api("/projects/user/#{user.id}", admin), project
-      json_response['public'].should be_true
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::PUBLIC
+      expect(json_response['public']).to be_truthy
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::PUBLIC)
     end
 
     it 'should set a project as internal' do
       project = attributes_for(:project, :internal)
       post api("/projects/user/#{user.id}", admin), project
-      json_response['public'].should be_false
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::INTERNAL
+      expect(json_response['public']).to be_falsey
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::INTERNAL)
     end
 
     it 'should set a project as internal overriding :public' do
       project = attributes_for(:project, :internal, { public: true })
       post api("/projects/user/#{user.id}", admin), project
-      json_response['public'].should be_false
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::INTERNAL
+      expect(json_response['public']).to be_falsey
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::INTERNAL)
     end
 
     it 'should set a project as private' do
       project = attributes_for(:project, :private)
       post api("/projects/user/#{user.id}", admin), project
-      json_response['public'].should be_false
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::PRIVATE
+      expect(json_response['public']).to be_falsey
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::PRIVATE)
     end
 
     it 'should set a project as private using :public' do
       project = attributes_for(:project, { public: false })
       post api("/projects/user/#{user.id}", admin), project
-      json_response['public'].should be_false
-      json_response['visibility_level'].should == Gitlab::VisibilityLevel::PRIVATE
+      expect(json_response['public']).to be_falsey
+      expect(json_response['visibility_level']).to eq(Gitlab::VisibilityLevel::PRIVATE)
     end
   end
 
@@ -295,27 +295,27 @@ describe API::API, api: true  do
 
     it 'should return a project by id' do
       get api("/projects/#{project.id}", user)
-      response.status.should == 200
-      json_response['name'].should == project.name
-      json_response['owner']['username'].should == user.username
+      expect(response.status).to eq(200)
+      expect(json_response['name']).to eq(project.name)
+      expect(json_response['owner']['username']).to eq(user.username)
     end
 
     it 'should return a project by path name' do
       get api("/projects/#{project.id}", user)
-      response.status.should == 200
-      json_response['name'].should == project.name
+      expect(response.status).to eq(200)
+      expect(json_response['name']).to eq(project.name)
     end
 
     it 'should return a 404 error if not found' do
       get api('/projects/42', user)
-      response.status.should == 404
-      json_response['message'].should == '404 Project Not Found'
+      expect(response.status).to eq(404)
+      expect(json_response['message']).to eq('404 Project Not Found')
     end
 
     it 'should return a 404 error if user is not a member' do
       other_user = create(:user)
       get api("/projects/#{project.id}", other_user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     describe 'permissions' do
@@ -351,24 +351,24 @@ describe API::API, api: true  do
 
     it 'should return a project events' do
       get api("/projects/#{project.id}/events", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
       json_event = json_response.first
 
-      json_event['action_name'].should == 'joined'
-      json_event['project_id'].to_i.should == project.id
-      json_event['author_username'].should == user.username
+      expect(json_event['action_name']).to eq('joined')
+      expect(json_event['project_id'].to_i).to eq(project.id)
+      expect(json_event['author_username']).to eq(user.username)
     end
 
     it 'should return a 404 error if not found' do
       get api('/projects/42/events', user)
-      response.status.should == 404
-      json_response['message'].should == '404 Project Not Found'
+      expect(response.status).to eq(404)
+      expect(json_response['message']).to eq('404 Project Not Found')
     end
 
     it 'should return a 404 error if user is not a member' do
       other_user = create(:user)
       get api("/projects/#{project.id}/events", other_user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -377,22 +377,22 @@ describe API::API, api: true  do
 
     it 'should return an array of project snippets' do
       get api("/projects/#{project.id}/snippets", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.first['title'].should == snippet.title
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.first['title']).to eq(snippet.title)
     end
   end
 
   describe 'GET /projects/:id/snippets/:snippet_id' do
     it 'should return a project snippet' do
       get api("/projects/#{project.id}/snippets/#{snippet.id}", user)
-      response.status.should == 200
-      json_response['title'].should == snippet.title
+      expect(response.status).to eq(200)
+      expect(json_response['title']).to eq(snippet.title)
     end
 
     it 'should return a 404 error if snippet id not found' do
       get api("/projects/#{project.id}/snippets/1234", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -400,8 +400,8 @@ describe API::API, api: true  do
     it 'should create a new project snippet' do
       post api("/projects/#{project.id}/snippets", user),
         title: 'api test', file_name: 'sample.rb', code: 'test'
-      response.status.should == 201
-      json_response['title'].should == 'api test'
+      expect(response.status).to eq(201)
+      expect(json_response['title']).to eq('api test')
     end
 
     it 'should return a 400 error if invalid snippet is given' do
@@ -414,16 +414,16 @@ describe API::API, api: true  do
     it 'should update an existing project snippet' do
       put api("/projects/#{project.id}/snippets/#{snippet.id}", user),
         code: 'updated code'
-      response.status.should == 200
-      json_response['title'].should == 'example'
-      snippet.reload.content.should == 'updated code'
+      expect(response.status).to eq(200)
+      expect(json_response['title']).to eq('example')
+      expect(snippet.reload.content).to eq('updated code')
     end
 
     it 'should update an existing project snippet with new title' do
       put api("/projects/#{project.id}/snippets/#{snippet.id}", user),
         title: 'other api test'
-      response.status.should == 200
-      json_response['title'].should == 'other api test'
+      expect(response.status).to eq(200)
+      expect(json_response['title']).to eq('other api test')
     end
   end
 
@@ -434,24 +434,24 @@ describe API::API, api: true  do
       expect {
         delete api("/projects/#{project.id}/snippets/#{snippet.id}", user)
       }.to change { Snippet.count }.by(-1)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it 'should return 404 when deleting unknown snippet id' do
       delete api("/projects/#{project.id}/snippets/1234", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
   describe 'GET /projects/:id/snippets/:snippet_id/raw' do
     it 'should get a raw project snippet' do
       get api("/projects/#{project.id}/snippets/#{snippet.id}/raw", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it 'should return a 404 error if raw project snippet not found' do
       get api("/projects/#{project.id}/snippets/5555/raw", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -464,43 +464,43 @@ describe API::API, api: true  do
 
       it 'should return array of ssh keys' do
         get api("/projects/#{project.id}/keys", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first['title'].should == deploy_key.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first['title']).to eq(deploy_key.title)
       end
     end
 
     describe 'GET /projects/:id/keys/:key_id' do
       it 'should return a single key' do
         get api("/projects/#{project.id}/keys/#{deploy_key.id}", user)
-        response.status.should == 200
-        json_response['title'].should == deploy_key.title
+        expect(response.status).to eq(200)
+        expect(json_response['title']).to eq(deploy_key.title)
       end
 
       it 'should return 404 Not Found with invalid ID' do
         get api("/projects/#{project.id}/keys/404", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     describe 'POST /projects/:id/keys' do
       it 'should not create an invalid ssh key' do
         post api("/projects/#{project.id}/keys", user), { title: 'invalid key' }
-        response.status.should == 400
-        json_response['message']['key'].should == [
+        expect(response.status).to eq(400)
+        expect(json_response['message']['key']).to eq([
           'can\'t be blank',
           'is too short (minimum is 0 characters)',
           'is invalid'
-        ]
+        ])
       end
 
       it 'should not create a key without title' do
         post api("/projects/#{project.id}/keys", user), key: 'some key'
-        response.status.should == 400
-        json_response['message']['title'].should == [
+        expect(response.status).to eq(400)
+        expect(json_response['message']['title']).to eq([
           'can\'t be blank',
           'is too short (minimum is 0 characters)'
-        ]
+        ])
       end
 
       it 'should create new ssh key' do
@@ -522,7 +522,7 @@ describe API::API, api: true  do
 
       it 'should return 404 Not Found with invalid ID' do
         delete api("/projects/#{project.id}/keys/404", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
   end
@@ -536,33 +536,33 @@ describe API::API, api: true  do
 
       it "shouldn't available for non admin users" do
         post api("/projects/#{project_fork_target.id}/fork/#{project_fork_source.id}", user)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
 
       it 'should allow project to be forked from an existing project' do
-        project_fork_target.forked?.should_not be_true
+        expect(project_fork_target.forked?).not_to be_truthy
         post api("/projects/#{project_fork_target.id}/fork/#{project_fork_source.id}", admin)
-        response.status.should == 201
+        expect(response.status).to eq(201)
         project_fork_target.reload
-        project_fork_target.forked_from_project.id.should == project_fork_source.id
-        project_fork_target.forked_project_link.should_not be_nil
-        project_fork_target.forked?.should be_true
+        expect(project_fork_target.forked_from_project.id).to eq(project_fork_source.id)
+        expect(project_fork_target.forked_project_link).not_to be_nil
+        expect(project_fork_target.forked?).to be_truthy
       end
 
       it 'should fail if forked_from project which does not exist' do
         post api("/projects/#{project_fork_target.id}/fork/9999", admin)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it 'should fail with 409 if already forked' do
         post api("/projects/#{project_fork_target.id}/fork/#{project_fork_source.id}", admin)
         project_fork_target.reload
-        project_fork_target.forked_from_project.id.should == project_fork_source.id
+        expect(project_fork_target.forked_from_project.id).to eq(project_fork_source.id)
         post api("/projects/#{project_fork_target.id}/fork/#{new_project_fork_source.id}", admin)
-        response.status.should == 409
+        expect(response.status).to eq(409)
         project_fork_target.reload
-        project_fork_target.forked_from_project.id.should == project_fork_source.id
-        project_fork_target.forked?.should be_true
+        expect(project_fork_target.forked_from_project.id).to eq(project_fork_source.id)
+        expect(project_fork_target.forked?).to be_truthy
       end
     end
 
@@ -570,26 +570,26 @@ describe API::API, api: true  do
 
       it "shouldn't available for non admin users" do
         delete api("/projects/#{project_fork_target.id}/fork", user)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
 
       it 'should make forked project unforked' do
         post api("/projects/#{project_fork_target.id}/fork/#{project_fork_source.id}", admin)
         project_fork_target.reload
-        project_fork_target.forked_from_project.should_not be_nil
-        project_fork_target.forked?.should be_true
+        expect(project_fork_target.forked_from_project).not_to be_nil
+        expect(project_fork_target.forked?).to be_truthy
         delete api("/projects/#{project_fork_target.id}/fork", admin)
-        response.status.should == 200
+        expect(response.status).to eq(200)
         project_fork_target.reload
-        project_fork_target.forked_from_project.should be_nil
-        project_fork_target.forked?.should_not be_true
+        expect(project_fork_target.forked_from_project).to be_nil
+        expect(project_fork_target.forked?).not_to be_truthy
       end
 
       it 'should be idempotent if not forked' do
-        project_fork_target.forked_from_project.should be_nil
+        expect(project_fork_target.forked_from_project).to be_nil
         delete api("/projects/#{project_fork_target.id}/fork", admin)
-        response.status.should == 200
-        project_fork_target.reload.forked_from_project.should be_nil
+        expect(response.status).to eq(200)
+        expect(project_fork_target.reload.forked_from_project).to be_nil
       end
     end
   end
@@ -609,27 +609,27 @@ describe API::API, api: true  do
     context 'when unauthenticated' do
       it 'should return authentication error' do
         get api("/projects/search/#{query}")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context 'when authenticated' do
       it 'should return an array of projects' do
         get api("/projects/search/#{query}",user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.size.should == 6
-        json_response.each {|project| project['name'].should =~ /.*query.*/}
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.size).to eq(6)
+        json_response.each {|project| expect(project['name']).to match(/.*query.*/)}
       end
     end
 
     context 'when authenticated as a different user' do
       it 'should return matching public projects' do
         get api("/projects/search/#{query}", user2)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.size.should == 2
-        json_response.each {|project| project['name'].should =~ /(internal|public) query/}
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.size).to eq(2)
+        json_response.each {|project| expect(project['name']).to match(/(internal|public) query/)}
       end
     end
   end
@@ -648,7 +648,7 @@ describe API::API, api: true  do
       it 'should return authentication error' do
         project_param = { name: 'bar' }
         put api("/projects/#{project.id}"), project_param
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
@@ -656,34 +656,34 @@ describe API::API, api: true  do
       it 'should update name' do
         project_param = { name: 'bar' }
         put api("/projects/#{project.id}", user), project_param
-        response.status.should == 200
+        expect(response.status).to eq(200)
         project_param.each_pair do |k, v|
-          json_response[k.to_s].should == v
+          expect(json_response[k.to_s]).to eq(v)
         end
       end
 
       it 'should update visibility_level' do
         project_param = { visibility_level: 20 }
         put api("/projects/#{project3.id}", user), project_param
-        response.status.should == 200
+        expect(response.status).to eq(200)
         project_param.each_pair do |k, v|
-          json_response[k.to_s].should == v
+          expect(json_response[k.to_s]).to eq(v)
         end
       end
 
       it 'should not update name to existing name' do
         project_param = { name: project3.name }
         put api("/projects/#{project.id}", user), project_param
-        response.status.should == 400
-        json_response['message']['name'].should == ['has already been taken']
+        expect(response.status).to eq(400)
+        expect(json_response['message']['name']).to eq(['has already been taken'])
       end
 
       it 'should update path & name to existing path & name in different namespace' do
         project_param = { path: project4.path, name: project4.name }
         put api("/projects/#{project3.id}", user), project_param
-        response.status.should == 200
+        expect(response.status).to eq(200)
         project_param.each_pair do |k, v|
-          json_response[k.to_s].should == v
+          expect(json_response[k.to_s]).to eq(v)
         end
       end
     end
@@ -692,9 +692,9 @@ describe API::API, api: true  do
       it 'should update path' do
         project_param = { path: 'bar' }
         put api("/projects/#{project3.id}", user4), project_param
-        response.status.should == 200
+        expect(response.status).to eq(200)
         project_param.each_pair do |k, v|
-          json_response[k.to_s].should == v
+          expect(json_response[k.to_s]).to eq(v)
         end
       end
 
@@ -706,29 +706,29 @@ describe API::API, api: true  do
                           description: 'new description' }
 
         put api("/projects/#{project3.id}", user4), project_param
-        response.status.should == 200
+        expect(response.status).to eq(200)
         project_param.each_pair do |k, v|
-          json_response[k.to_s].should == v
+          expect(json_response[k.to_s]).to eq(v)
         end
       end
 
       it 'should not update path to existing path' do
         project_param = { path: project.path }
         put api("/projects/#{project3.id}", user4), project_param
-        response.status.should == 400
-        json_response['message']['path'].should == ['has already been taken']
+        expect(response.status).to eq(400)
+        expect(json_response['message']['path']).to eq(['has already been taken'])
       end
 
       it 'should not update name' do
         project_param = { name: 'bar' }
         put api("/projects/#{project3.id}", user4), project_param
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
 
       it 'should not update visibility_level' do
         project_param = { visibility_level: 20 }
         put api("/projects/#{project3.id}", user4), project_param
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
@@ -741,7 +741,7 @@ describe API::API, api: true  do
                           merge_requests_enabled: true,
                           description: 'new description' }
         put api("/projects/#{project.id}", user3), project_param
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
   end
@@ -755,36 +755,36 @@ describe API::API, api: true  do
         ).twice
 
         delete api("/projects/#{project.id}", user)
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it 'should not remove a project if not an owner' do
         user3 = create(:user)
         project.team << [user3, :developer]
         delete api("/projects/#{project.id}", user3)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
 
       it 'should not remove a non existing project' do
         delete api('/projects/1328', user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
 
       it 'should not remove a project not attached to user' do
         delete api("/projects/#{project.id}", user2)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
 
     context 'when authenticated as admin' do
       it 'should remove any existing project' do
         delete api("/projects/#{project.id}", admin)
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it 'should not remove a non existing project' do
         delete api('/projects/1328', admin)
-        response.status.should == 404
+        expect(response.status).to eq(404)
       end
     end
   end
diff --git a/spec/requests/api/repositories_spec.rb b/spec/requests/api/repositories_spec.rb
index 5518d2df566..729970153d1 100644
--- a/spec/requests/api/repositories_spec.rb
+++ b/spec/requests/api/repositories_spec.rb
@@ -16,9 +16,9 @@ describe API::API, api: true  do
   describe "GET /projects/:id/repository/tags" do
     it "should return an array of project tags" do
       get api("/projects/#{project.id}/repository/tags", user)
-      response.status.should == 200
-      json_response.should be_an Array
-      json_response.first['name'].should == project.repo.tags.sort_by(&:name).reverse.first.name
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
+      expect(json_response.first['name']).to eq(project.repo.tags.sort_by(&:name).reverse.first.name)
     end
   end
 
@@ -29,8 +29,8 @@ describe API::API, api: true  do
              tag_name: 'v7.0.1',
              ref: 'master'
 
-        response.status.should == 201
-        json_response['name'].should == 'v7.0.1'
+        expect(response.status).to eq(201)
+        expect(json_response['name']).to eq('v7.0.1')
       end
     end
 
@@ -46,9 +46,9 @@ describe API::API, api: true  do
              ref: 'master',
              message: 'Release 7.1.0'
 
-        response.status.should == 201
-        json_response['name'].should == 'v7.1.0'
-        json_response['message'].should == 'Release 7.1.0'
+        expect(response.status).to eq(201)
+        expect(json_response['name']).to eq('v7.1.0')
+        expect(json_response['message']).to eq('Release 7.1.0')
       end
     end
 
@@ -56,35 +56,35 @@ describe API::API, api: true  do
       post api("/projects/#{project.id}/repository/tags", user2),
            tag_name: 'v1.9.0',
            ref: '621491c677087aa243f165eab467bfdfbee00be1'
-      response.status.should == 403
+      expect(response.status).to eq(403)
     end
 
     it 'should return 400 if tag name is invalid' do
       post api("/projects/#{project.id}/repository/tags", user),
            tag_name: 'v 1.0.0',
            ref: 'master'
-      response.status.should == 400
-      json_response['message'].should == 'Tag name invalid'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('Tag name invalid')
     end
 
     it 'should return 400 if tag already exists' do
       post api("/projects/#{project.id}/repository/tags", user),
            tag_name: 'v8.0.0',
            ref: 'master'
-      response.status.should == 201
+      expect(response.status).to eq(201)
       post api("/projects/#{project.id}/repository/tags", user),
            tag_name: 'v8.0.0',
            ref: 'master'
-      response.status.should == 400
-      json_response['message'].should == 'Tag already exists'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('Tag already exists')
     end
 
     it 'should return 400 if ref name is invalid' do
       post api("/projects/#{project.id}/repository/tags", user),
            tag_name: 'mytag',
            ref: 'foo'
-      response.status.should == 400
-      json_response['message'].should == 'Invalid reference name'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('Invalid reference name')
     end
   end
 
@@ -94,19 +94,19 @@ describe API::API, api: true  do
 
       it "should return project commits" do
         get api("/projects/#{project.id}/repository/tree", user)
-        response.status.should == 200
+        expect(response.status).to eq(200)
 
-        json_response.should be_an Array
-        json_response.first['name'].should == 'encoding'
-        json_response.first['type'].should == 'tree'
-        json_response.first['mode'].should == '040000'
+        expect(json_response).to be_an Array
+        expect(json_response.first['name']).to eq('encoding')
+        expect(json_response.first['type']).to eq('tree')
+        expect(json_response.first['mode']).to eq('040000')
       end
 
       it 'should return a 404 for unknown ref' do
         get api("/projects/#{project.id}/repository/tree?ref_name=foo", user)
-        response.status.should == 404
+        expect(response.status).to eq(404)
 
-        json_response.should be_an Object
+        expect(json_response).to be_an Object
         json_response['message'] == '404 Tree Not Found'
       end
     end
@@ -114,7 +114,7 @@ describe API::API, api: true  do
     context "unauthorized user" do
       it "should not return project commits" do
         get api("/projects/#{project.id}/repository/tree")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
   end
@@ -122,43 +122,43 @@ describe API::API, api: true  do
   describe "GET /projects/:id/repository/blobs/:sha" do
     it "should get the raw file contents" do
       get api("/projects/#{project.id}/repository/blobs/master?filepath=README.md", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return 404 for invalid branch_name" do
       get api("/projects/#{project.id}/repository/blobs/invalid_branch_name?filepath=README.md", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it "should return 404 for invalid file" do
       get api("/projects/#{project.id}/repository/blobs/master?filepath=README.invalid", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
 
     it "should return a 400 error if filepath is missing" do
       get api("/projects/#{project.id}/repository/blobs/master", user)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 
   describe "GET /projects/:id/repository/commits/:sha/blob" do
     it "should get the raw file contents" do
       get api("/projects/#{project.id}/repository/commits/master/blob?filepath=README.md", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
   end
 
   describe "GET /projects/:id/repository/raw_blobs/:sha" do
     it "should get the raw file contents" do
       get api("/projects/#{project.id}/repository/raw_blobs/#{sample_blob.oid}", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it 'should return a 404 for unknown blob' do
       get api("/projects/#{project.id}/repository/raw_blobs/123456", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
 
-      json_response.should be_an Object
+      expect(json_response).to be_an Object
       json_response['message'] == '404 Blob Not Found'
     end
   end
@@ -167,83 +167,83 @@ describe API::API, api: true  do
     it "should get the archive" do
       get api("/projects/#{project.id}/repository/archive", user)
       repo_name = project.repository.name.gsub("\.git", "")
-      response.status.should == 200
-      response.headers['Content-Disposition'].should =~ /filename\=\"#{repo_name}\-[^\.]+\.tar.gz\"/
-      response.content_type.should == MIME::Types.type_for('file.tar.gz').first.content_type
+      expect(response.status).to eq(200)
+      expect(response.headers['Content-Disposition']).to match(/filename\=\"#{repo_name}\-[^\.]+\.tar.gz\"/)
+      expect(response.content_type).to eq(MIME::Types.type_for('file.tar.gz').first.content_type)
     end
 
     it "should get the archive.zip" do
       get api("/projects/#{project.id}/repository/archive.zip", user)
       repo_name = project.repository.name.gsub("\.git", "")
-      response.status.should == 200
-      response.headers['Content-Disposition'].should =~ /filename\=\"#{repo_name}\-[^\.]+\.zip\"/
-      response.content_type.should == MIME::Types.type_for('file.zip').first.content_type
+      expect(response.status).to eq(200)
+      expect(response.headers['Content-Disposition']).to match(/filename\=\"#{repo_name}\-[^\.]+\.zip\"/)
+      expect(response.content_type).to eq(MIME::Types.type_for('file.zip').first.content_type)
     end
 
     it "should get the archive.tar.bz2" do
       get api("/projects/#{project.id}/repository/archive.tar.bz2", user)
       repo_name = project.repository.name.gsub("\.git", "")
-      response.status.should == 200
-      response.headers['Content-Disposition'].should =~ /filename\=\"#{repo_name}\-[^\.]+\.tar.bz2\"/
-      response.content_type.should == MIME::Types.type_for('file.tar.bz2').first.content_type
+      expect(response.status).to eq(200)
+      expect(response.headers['Content-Disposition']).to match(/filename\=\"#{repo_name}\-[^\.]+\.tar.bz2\"/)
+      expect(response.content_type).to eq(MIME::Types.type_for('file.tar.bz2').first.content_type)
     end
 
     it "should return 404 for invalid sha" do
       get api("/projects/#{project.id}/repository/archive/?sha=xxx", user)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
   describe 'GET /projects/:id/repository/compare' do
     it "should compare branches" do
       get api("/projects/#{project.id}/repository/compare", user), from: 'master', to: 'feature'
-      response.status.should == 200
-      json_response['commits'].should be_present
-      json_response['diffs'].should be_present
+      expect(response.status).to eq(200)
+      expect(json_response['commits']).to be_present
+      expect(json_response['diffs']).to be_present
     end
 
     it "should compare tags" do
       get api("/projects/#{project.id}/repository/compare", user), from: 'v1.0.0', to: 'v1.1.0'
-      response.status.should == 200
-      json_response['commits'].should be_present
-      json_response['diffs'].should be_present
+      expect(response.status).to eq(200)
+      expect(json_response['commits']).to be_present
+      expect(json_response['diffs']).to be_present
     end
 
     it "should compare commits" do
       get api("/projects/#{project.id}/repository/compare", user), from: sample_commit.id, to: sample_commit.parent_id
-      response.status.should == 200
-      json_response['commits'].should be_empty
-      json_response['diffs'].should be_empty
-      json_response['compare_same_ref'].should be_false
+      expect(response.status).to eq(200)
+      expect(json_response['commits']).to be_empty
+      expect(json_response['diffs']).to be_empty
+      expect(json_response['compare_same_ref']).to be_falsey
     end
 
     it "should compare commits in reverse order" do
       get api("/projects/#{project.id}/repository/compare", user), from: sample_commit.parent_id, to: sample_commit.id
-      response.status.should == 200
-      json_response['commits'].should be_present
-      json_response['diffs'].should be_present
+      expect(response.status).to eq(200)
+      expect(json_response['commits']).to be_present
+      expect(json_response['diffs']).to be_present
     end
 
     it "should compare same refs" do
       get api("/projects/#{project.id}/repository/compare", user), from: 'master', to: 'master'
-      response.status.should == 200
-      json_response['commits'].should be_empty
-      json_response['diffs'].should be_empty
-      json_response['compare_same_ref'].should be_true
+      expect(response.status).to eq(200)
+      expect(json_response['commits']).to be_empty
+      expect(json_response['diffs']).to be_empty
+      expect(json_response['compare_same_ref']).to be_truthy
     end
   end
 
   describe 'GET /projects/:id/repository/contributors' do
     it 'should return valid data' do
       get api("/projects/#{project.id}/repository/contributors", user)
-      response.status.should == 200
-      json_response.should be_an Array
+      expect(response.status).to eq(200)
+      expect(json_response).to be_an Array
       contributor = json_response.first
-      contributor['email'].should == 'dmitriy.zaporozhets@gmail.com'
-      contributor['name'].should == 'Dmitriy Zaporozhets'
-      contributor['commits'].should == 13
-      contributor['additions'].should == 0
-      contributor['deletions'].should == 0
+      expect(contributor['email']).to eq('dmitriy.zaporozhets@gmail.com')
+      expect(contributor['name']).to eq('Dmitriy Zaporozhets')
+      expect(contributor['commits']).to eq(13)
+      expect(contributor['additions']).to eq(0)
+      expect(contributor['deletions']).to eq(0)
     end
   end
 end
diff --git a/spec/requests/api/services_spec.rb b/spec/requests/api/services_spec.rb
index d8282d0696b..51c543578df 100644
--- a/spec/requests/api/services_spec.rb
+++ b/spec/requests/api/services_spec.rb
@@ -9,13 +9,13 @@ describe API::API, api: true  do
     it "should update gitlab-ci settings" do
       put api("/projects/#{project.id}/services/gitlab-ci", user), token: 'secret-token', project_url: "http://ci.example.com/projects/1"
 
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return if required fields missing" do
       put api("/projects/#{project.id}/services/gitlab-ci", user), project_url: "http://ci.example.com/projects/1", active: true
 
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 
@@ -23,8 +23,8 @@ describe API::API, api: true  do
     it "should update gitlab-ci settings" do
       delete api("/projects/#{project.id}/services/gitlab-ci", user)
 
-      response.status.should == 200
-      project.gitlab_ci_service.should be_nil
+      expect(response.status).to eq(200)
+      expect(project.gitlab_ci_service).to be_nil
     end
   end
 
@@ -33,15 +33,15 @@ describe API::API, api: true  do
       put api("/projects/#{project.id}/services/hipchat", user),
           token: 'secret-token', room: 'test'
 
-      response.status.should == 200
-      project.hipchat_service.should_not be_nil
+      expect(response.status).to eq(200)
+      expect(project.hipchat_service).not_to be_nil
     end
 
     it 'should return if required fields missing' do
       put api("/projects/#{project.id}/services/gitlab-ci", user),
           token: 'secret-token', active: true
 
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 
@@ -49,8 +49,8 @@ describe API::API, api: true  do
     it 'should delete hipchat settings' do
       delete api("/projects/#{project.id}/services/hipchat", user)
 
-      response.status.should == 200
-      project.hipchat_service.should be_nil
+      expect(response.status).to eq(200)
+      expect(project.hipchat_service).to be_nil
     end
   end
 end
diff --git a/spec/requests/api/session_spec.rb b/spec/requests/api/session_spec.rb
index 57b2e6cbd6a..fbd57b34a58 100644
--- a/spec/requests/api/session_spec.rb
+++ b/spec/requests/api/session_spec.rb
@@ -9,13 +9,13 @@ describe API::API, api: true  do
     context "when valid password" do
       it "should return private token" do
         post api("/session"), email: user.email, password: '12345678'
-        response.status.should == 201
+        expect(response.status).to eq(201)
 
-        json_response['email'].should == user.email
-        json_response['private_token'].should == user.private_token
-        json_response['is_admin'].should == user.is_admin?
-        json_response['can_create_project'].should == user.can_create_project?
-        json_response['can_create_group'].should == user.can_create_group?
+        expect(json_response['email']).to eq(user.email)
+        expect(json_response['private_token']).to eq(user.private_token)
+        expect(json_response['is_admin']).to eq(user.is_admin?)
+        expect(json_response['can_create_project']).to eq(user.can_create_project?)
+        expect(json_response['can_create_group']).to eq(user.can_create_group?)
       end
     end
 
@@ -48,30 +48,30 @@ describe API::API, api: true  do
     context "when invalid password" do
       it "should return authentication error" do
         post api("/session"), email: user.email, password: '123'
-        response.status.should == 401
+        expect(response.status).to eq(401)
 
-        json_response['email'].should be_nil
-        json_response['private_token'].should be_nil
+        expect(json_response['email']).to be_nil
+        expect(json_response['private_token']).to be_nil
       end
     end
 
     context "when empty password" do
       it "should return authentication error" do
         post api("/session"), email: user.email
-        response.status.should == 401
+        expect(response.status).to eq(401)
 
-        json_response['email'].should be_nil
-        json_response['private_token'].should be_nil
+        expect(json_response['email']).to be_nil
+        expect(json_response['private_token']).to be_nil
       end
     end
 
     context "when empty name" do
       it "should return authentication error" do
         post api("/session"), password: user.password
-        response.status.should == 401
+        expect(response.status).to eq(401)
 
-        json_response['email'].should be_nil
-        json_response['private_token'].should be_nil
+        expect(json_response['email']).to be_nil
+        expect(json_response['private_token']).to be_nil
       end
     end
   end
diff --git a/spec/requests/api/system_hooks_spec.rb b/spec/requests/api/system_hooks_spec.rb
index 5784ae8c23a..a9d86bbce6c 100644
--- a/spec/requests/api/system_hooks_spec.rb
+++ b/spec/requests/api/system_hooks_spec.rb
@@ -13,23 +13,23 @@ describe API::API, api: true  do
     context "when no user" do
       it "should return authentication error" do
         get api("/hooks")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context "when not an admin" do
       it "should return forbidden error" do
         get api("/hooks", user)
-        response.status.should == 403
+        expect(response.status).to eq(403)
       end
     end
 
     context "when authenticated as admin" do
       it "should return an array of hooks" do
         get api("/hooks", admin)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first['url'].should == hook.url
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first['url']).to eq(hook.url)
       end
     end
   end
@@ -43,7 +43,7 @@ describe API::API, api: true  do
 
     it "should respond with 400 if url not given" do
       post api("/hooks", admin)
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should not create new hook without url" do
@@ -56,13 +56,13 @@ describe API::API, api: true  do
   describe "GET /hooks/:id" do
     it "should return hook by id" do
       get api("/hooks/#{hook.id}", admin)
-      response.status.should == 200
-      json_response['event_name'].should == 'project_create'
+      expect(response.status).to eq(200)
+      expect(json_response['event_name']).to eq('project_create')
     end
 
     it "should return 404 on failure" do
       get api("/hooks/404", admin)
-      response.status.should == 404
+      expect(response.status).to eq(404)
     end
   end
 
@@ -75,7 +75,7 @@ describe API::API, api: true  do
 
     it "should return success if hook id not found" do
       delete api("/hooks/12345", admin)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
   end
 end
diff --git a/spec/requests/api/users_spec.rb b/spec/requests/api/users_spec.rb
index 12dfcacec23..081400cdedd 100644
--- a/spec/requests/api/users_spec.rb
+++ b/spec/requests/api/users_spec.rb
@@ -11,30 +11,30 @@ describe API::API, api: true  do
     context "when unauthenticated" do
       it "should return authentication error" do
         get api("/users")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context "when authenticated" do
       it "should return an array of users" do
         get api("/users", user)
-        response.status.should == 200
-        json_response.should be_an Array
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
         username = user.username
-        json_response.detect {
+        expect(json_response.detect {
           |user| user['username'] == username
-          }['username'].should == username
+          }['username']).to eq(username)
       end
     end
 
     context "when admin" do
       it "should return an array of users" do
         get api("/users", admin)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first.keys.should include 'email'
-        json_response.first.keys.should include 'identities'
-        json_response.first.keys.should include 'can_create_project'
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first.keys).to include 'email'
+        expect(json_response.first.keys).to include 'identities'
+        expect(json_response.first.keys).to include 'can_create_project'
       end
     end
   end
@@ -42,19 +42,19 @@ describe API::API, api: true  do
   describe "GET /users/:id" do
     it "should return a user by id" do
       get api("/users/#{user.id}", user)
-      response.status.should == 200
-      json_response['username'].should == user.username
+      expect(response.status).to eq(200)
+      expect(json_response['username']).to eq(user.username)
     end
 
     it "should return a 401 if unauthenticated" do
       get api("/users/9998")
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
 
     it "should return a 404 error if user id not found" do
       get api("/users/9999", user)
-      response.status.should == 404
-      json_response['message'].should == '404 Not found'
+      expect(response.status).to eq(404)
+      expect(json_response['message']).to eq('404 Not found')
     end
   end
 
@@ -69,36 +69,36 @@ describe API::API, api: true  do
 
     it "should create user with correct attributes" do
       post api('/users', admin), attributes_for(:user, admin: true, can_create_group: true)
-      response.status.should == 201
+      expect(response.status).to eq(201)
       user_id = json_response['id']
       new_user = User.find(user_id)
-      new_user.should_not == nil
-      new_user.admin.should == true
-      new_user.can_create_group.should == true
+      expect(new_user).not_to eq(nil)
+      expect(new_user.admin).to eq(true)
+      expect(new_user.can_create_group).to eq(true)
     end
 
     it "should create non-admin user" do
       post api('/users', admin), attributes_for(:user, admin: false, can_create_group: false)
-      response.status.should == 201
+      expect(response.status).to eq(201)
       user_id = json_response['id']
       new_user = User.find(user_id)
-      new_user.should_not == nil
-      new_user.admin.should == false
-      new_user.can_create_group.should == false
+      expect(new_user).not_to eq(nil)
+      expect(new_user.admin).to eq(false)
+      expect(new_user.can_create_group).to eq(false)
     end
 
     it "should create non-admin users by default" do
       post api('/users', admin), attributes_for(:user)
-      response.status.should == 201
+      expect(response.status).to eq(201)
       user_id = json_response['id']
       new_user = User.find(user_id)
-      new_user.should_not == nil
-      new_user.admin.should == false
+      expect(new_user).not_to eq(nil)
+      expect(new_user.admin).to eq(false)
     end
 
     it "should return 201 Created on success" do
       post api("/users", admin), attributes_for(:user, projects_limit: 3)
-      response.status.should == 201
+      expect(response.status).to eq(201)
     end
 
     it "should not create user with invalid email" do
@@ -106,22 +106,22 @@ describe API::API, api: true  do
            email: 'invalid email',
            password: 'password',
            name: 'test'
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it 'should return 400 error if name not given' do
       post api('/users', admin), email: 'test@example.com', password: 'pass1234'
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it 'should return 400 error if password not given' do
       post api('/users', admin), email: 'test@example.com', name: 'test'
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it "should return 400 error if email not given" do
       post api('/users', admin), password: 'pass1234', name: 'test'
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
 
     it 'should return 400 error if user does not validate' do
@@ -132,20 +132,20 @@ describe API::API, api: true  do
            name: 'test',
            bio: 'g' * 256,
            projects_limit: -1
-      response.status.should == 400
-      json_response['message']['password'].
-          should == ['is too short (minimum is 8 characters)']
-      json_response['message']['bio'].
-          should == ['is too long (maximum is 255 characters)']
-      json_response['message']['projects_limit'].
-          should == ['must be greater than or equal to 0']
-      json_response['message']['username'].
-          should == [Gitlab::Regex.send(:default_regex_message)]
+      expect(response.status).to eq(400)
+      expect(json_response['message']['password']).
+          to eq(['is too short (minimum is 8 characters)'])
+      expect(json_response['message']['bio']).
+          to eq(['is too long (maximum is 255 characters)'])
+      expect(json_response['message']['projects_limit']).
+          to eq(['must be greater than or equal to 0'])
+      expect(json_response['message']['username']).
+          to eq([Gitlab::Regex.send(:default_regex_message)])
     end
 
     it "shouldn't available for non admin users" do
       post api("/users", user), attributes_for(:user)
-      response.status.should == 403
+      expect(response.status).to eq(403)
     end
 
     context 'with existing user' do
@@ -165,8 +165,8 @@ describe API::API, api: true  do
                password: 'password',
                username: 'foo'
         }.to change { User.count }.by(0)
-        response.status.should == 409
-        json_response['message'].should == 'Email has already been taken'
+        expect(response.status).to eq(409)
+        expect(json_response['message']).to eq('Email has already been taken')
       end
 
       it 'should return 409 conflict error if same username exists' do
@@ -177,8 +177,8 @@ describe API::API, api: true  do
                password: 'password',
                username: 'test'
         end.to change { User.count }.by(0)
-        response.status.should == 409
-        json_response['message'].should == 'Username has already been taken'
+        expect(response.status).to eq(409)
+        expect(json_response['message']).to eq('Username has already been taken')
       end
     end
   end
@@ -187,8 +187,8 @@ describe API::API, api: true  do
 
     it "should redirect to sign in page" do
       get "/users/sign_up"
-      response.status.should == 302
-      response.should redirect_to(new_user_session_path)
+      expect(response.status).to eq(302)
+      expect(response).to redirect_to(new_user_session_path)
     end
   end
 
@@ -199,55 +199,55 @@ describe API::API, api: true  do
 
     it "should update user with new bio" do
       put api("/users/#{user.id}", admin), {bio: 'new test bio'}
-      response.status.should == 200
-      json_response['bio'].should == 'new test bio'
-      user.reload.bio.should == 'new test bio'
+      expect(response.status).to eq(200)
+      expect(json_response['bio']).to eq('new test bio')
+      expect(user.reload.bio).to eq('new test bio')
     end
 
     it 'should update user with his own email' do
       put api("/users/#{user.id}", admin), email: user.email
-      response.status.should == 200
-      json_response['email'].should == user.email
-      user.reload.email.should == user.email
+      expect(response.status).to eq(200)
+      expect(json_response['email']).to eq(user.email)
+      expect(user.reload.email).to eq(user.email)
     end
 
     it 'should update user with his own username' do
       put api("/users/#{user.id}", admin), username: user.username
-      response.status.should == 200
-      json_response['username'].should == user.username
-      user.reload.username.should == user.username
+      expect(response.status).to eq(200)
+      expect(json_response['username']).to eq(user.username)
+      expect(user.reload.username).to eq(user.username)
     end
 
     it "should update admin status" do
       put api("/users/#{user.id}", admin), {admin: true}
-      response.status.should == 200
-      json_response['is_admin'].should == true
-      user.reload.admin.should == true
+      expect(response.status).to eq(200)
+      expect(json_response['is_admin']).to eq(true)
+      expect(user.reload.admin).to eq(true)
     end
 
     it "should not update admin status" do
       put api("/users/#{admin_user.id}", admin), {can_create_group: false}
-      response.status.should == 200
-      json_response['is_admin'].should == true
-      admin_user.reload.admin.should == true
-      admin_user.can_create_group.should == false
+      expect(response.status).to eq(200)
+      expect(json_response['is_admin']).to eq(true)
+      expect(admin_user.reload.admin).to eq(true)
+      expect(admin_user.can_create_group).to eq(false)
     end
 
     it "should not allow invalid update" do
       put api("/users/#{user.id}", admin), {email: 'invalid email'}
-      response.status.should == 400
-      user.reload.email.should_not == 'invalid email'
+      expect(response.status).to eq(400)
+      expect(user.reload.email).not_to eq('invalid email')
     end
 
     it "shouldn't available for non admin users" do
       put api("/users/#{user.id}", user), attributes_for(:user)
-      response.status.should == 403
+      expect(response.status).to eq(403)
     end
 
     it "should return 404 for non-existing user" do
       put api("/users/999999", admin), {bio: 'update should fail'}
-      response.status.should == 404
-      json_response['message'].should == '404 Not found'
+      expect(response.status).to eq(404)
+      expect(json_response['message']).to eq('404 Not found')
     end
 
     it 'should return 400 error if user does not validate' do
@@ -258,15 +258,15 @@ describe API::API, api: true  do
           name: 'test',
           bio: 'g' * 256,
           projects_limit: -1
-      response.status.should == 400
-      json_response['message']['password'].
-          should == ['is too short (minimum is 8 characters)']
-      json_response['message']['bio'].
-          should == ['is too long (maximum is 255 characters)']
-      json_response['message']['projects_limit'].
-          should == ['must be greater than or equal to 0']
-      json_response['message']['username'].
-          should == [Gitlab::Regex.send(:default_regex_message)]
+      expect(response.status).to eq(400)
+      expect(json_response['message']['password']).
+          to eq(['is too short (minimum is 8 characters)'])
+      expect(json_response['message']['bio']).
+          to eq(['is too long (maximum is 255 characters)'])
+      expect(json_response['message']['projects_limit']).
+          to eq(['must be greater than or equal to 0'])
+      expect(json_response['message']['username']).
+          to eq([Gitlab::Regex.send(:default_regex_message)])
     end
 
     context "with existing user" do
@@ -278,15 +278,15 @@ describe API::API, api: true  do
 
       it 'should return 409 conflict error if email address exists' do
         put api("/users/#{@user.id}", admin), email: 'test@example.com'
-        response.status.should == 409
-        @user.reload.email.should == @user.email
+        expect(response.status).to eq(409)
+        expect(@user.reload.email).to eq(@user.email)
       end
 
       it 'should return 409 conflict error if username taken' do
         @user_id = User.all.last.id
         put api("/users/#{@user.id}", admin), username: 'test'
-        response.status.should == 409
-        @user.reload.username.should == @user.username
+        expect(response.status).to eq(409)
+        expect(@user.reload.username).to eq(@user.username)
       end
     end
   end
@@ -296,14 +296,14 @@ describe API::API, api: true  do
 
     it "should not create invalid ssh key" do
       post api("/users/#{user.id}/keys", admin), { title: "invalid key" }
-      response.status.should == 400
-      json_response['message'].should == '400 (Bad request) "key" not given'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('400 (Bad request) "key" not given')
     end
 
     it 'should not create key without title' do
       post api("/users/#{user.id}/keys", admin), key: 'some key'
-      response.status.should == 400
-      json_response['message'].should == '400 (Bad request) "title" not given'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('400 (Bad request) "title" not given')
     end
 
     it "should create ssh key" do
@@ -320,24 +320,24 @@ describe API::API, api: true  do
     context 'when unauthenticated' do
       it 'should return authentication error' do
         get api("/users/#{user.id}/keys")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
     context 'when authenticated' do
       it 'should return 404 for non-existing user' do
         get api('/users/999999/keys', admin)
-        response.status.should == 404
-        json_response['message'].should == '404 User Not Found'
+        expect(response.status).to eq(404)
+        expect(json_response['message']).to eq('404 User Not Found')
       end
 
       it 'should return array of ssh keys' do
         user.keys << key
         user.save
         get api("/users/#{user.id}/keys", admin)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first['title'].should == key.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first['title']).to eq(key.title)
       end
     end
   end
@@ -348,7 +348,7 @@ describe API::API, api: true  do
     context 'when unauthenticated' do
       it 'should return authentication error' do
         delete api("/users/#{user.id}/keys/42")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
@@ -359,21 +359,21 @@ describe API::API, api: true  do
         expect {
           delete api("/users/#{user.id}/keys/#{key.id}", admin)
         }.to change { user.keys.count }.by(-1)
-        response.status.should == 200
+        expect(response.status).to eq(200)
       end
 
       it 'should return 404 error if user not found' do
         user.keys << key
         user.save
         delete api("/users/999999/keys/#{key.id}", admin)
-        response.status.should == 404
-        json_response['message'].should == '404 User Not Found'
+        expect(response.status).to eq(404)
+        expect(json_response['message']).to eq('404 User Not Found')
       end
 
       it 'should return 404 error if key not foud' do
         delete api("/users/#{user.id}/keys/42", admin)
-        response.status.should == 404
-        json_response['message'].should == '404 Key Not Found'
+        expect(response.status).to eq(404)
+        expect(json_response['message']).to eq('404 Key Not Found')
       end
     end
   end
@@ -383,42 +383,42 @@ describe API::API, api: true  do
 
     it "should delete user" do
       delete api("/users/#{user.id}", admin)
-      response.status.should == 200
+      expect(response.status).to eq(200)
       expect { User.find(user.id) }.to raise_error ActiveRecord::RecordNotFound
-      json_response['email'].should == user.email
+      expect(json_response['email']).to eq(user.email)
     end
 
     it "should not delete for unauthenticated user" do
       delete api("/users/#{user.id}")
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
 
     it "shouldn't available for non admin users" do
       delete api("/users/#{user.id}", user)
-      response.status.should == 403
+      expect(response.status).to eq(403)
     end
 
     it "should return 404 for non-existing user" do
       delete api("/users/999999", admin)
-      response.status.should == 404
-      json_response['message'].should == '404 User Not Found'
+      expect(response.status).to eq(404)
+      expect(json_response['message']).to eq('404 User Not Found')
     end
   end
 
   describe "GET /user" do
     it "should return current user" do
       get api("/user", user)
-      response.status.should == 200
-      json_response['email'].should == user.email
-      json_response['is_admin'].should == user.is_admin?
-      json_response['can_create_project'].should == user.can_create_project?
-      json_response['can_create_group'].should == user.can_create_group?
-      json_response['projects_limit'].should == user.projects_limit
+      expect(response.status).to eq(200)
+      expect(json_response['email']).to eq(user.email)
+      expect(json_response['is_admin']).to eq(user.is_admin?)
+      expect(json_response['can_create_project']).to eq(user.can_create_project?)
+      expect(json_response['can_create_group']).to eq(user.can_create_group?)
+      expect(json_response['projects_limit']).to eq(user.projects_limit)
     end
 
     it "should return 401 error if user is unauthenticated" do
       get api("/user")
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
   end
 
@@ -426,7 +426,7 @@ describe API::API, api: true  do
     context "when unauthenticated" do
       it "should return authentication error" do
         get api("/user/keys")
-        response.status.should == 401
+        expect(response.status).to eq(401)
       end
     end
 
@@ -435,9 +435,9 @@ describe API::API, api: true  do
         user.keys << key
         user.save
         get api("/user/keys", user)
-        response.status.should == 200
-        json_response.should be_an Array
-        json_response.first["title"].should == key.title
+        expect(response.status).to eq(200)
+        expect(json_response).to be_an Array
+        expect(json_response.first["title"]).to eq(key.title)
       end
     end
   end
@@ -447,14 +447,14 @@ describe API::API, api: true  do
       user.keys << key
       user.save
       get api("/user/keys/#{key.id}", user)
-      response.status.should == 200
-      json_response["title"].should == key.title
+      expect(response.status).to eq(200)
+      expect(json_response["title"]).to eq(key.title)
     end
 
     it "should return 404 Not Found within invalid ID" do
       get api("/user/keys/42", user)
-      response.status.should == 404
-      json_response['message'].should == '404 Not found'
+      expect(response.status).to eq(404)
+      expect(json_response['message']).to eq('404 Not found')
     end
 
     it "should return 404 error if admin accesses user's ssh key" do
@@ -462,8 +462,8 @@ describe API::API, api: true  do
       user.save
       admin
       get api("/user/keys/#{key.id}", admin)
-      response.status.should == 404
-      json_response['message'].should == '404 Not found'
+      expect(response.status).to eq(404)
+      expect(json_response['message']).to eq('404 Not found')
     end
   end
 
@@ -473,29 +473,29 @@ describe API::API, api: true  do
       expect {
         post api("/user/keys", user), key_attrs
       }.to change{ user.keys.count }.by(1)
-      response.status.should == 201
+      expect(response.status).to eq(201)
     end
 
     it "should return a 401 error if unauthorized" do
       post api("/user/keys"), title: 'some title', key: 'some key'
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
 
     it "should not create ssh key without key" do
       post api("/user/keys", user), title: 'title'
-      response.status.should == 400
-      json_response['message'].should == '400 (Bad request) "key" not given'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('400 (Bad request) "key" not given')
     end
 
     it 'should not create ssh key without title' do
       post api('/user/keys', user), key: 'some key'
-      response.status.should == 400
-      json_response['message'].should == '400 (Bad request) "title" not given'
+      expect(response.status).to eq(400)
+      expect(json_response['message']).to eq('400 (Bad request) "title" not given')
     end
 
     it "should not create ssh key without title" do
       post api("/user/keys", user), key: "somekey"
-      response.status.should == 400
+      expect(response.status).to eq(400)
     end
   end
 
@@ -506,19 +506,19 @@ describe API::API, api: true  do
       expect {
         delete api("/user/keys/#{key.id}", user)
       }.to change{user.keys.count}.by(-1)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return success if key ID not found" do
       delete api("/user/keys/42", user)
-      response.status.should == 200
+      expect(response.status).to eq(200)
     end
 
     it "should return 401 error if unauthorized" do
       user.keys << key
       user.save
       delete api("/user/keys/#{key.id}")
-      response.status.should == 401
+      expect(response.status).to eq(401)
     end
   end
 end
-- 
cgit v1.2.3