Add latest changes from gitlab-org/gitlab@master

1 files changed, 202 insertions, 202 deletions

diff --git a/spec/requests/api/users_spec.rb b/spec/requests/api/users_spec.rb
index 73bdd3b5d96..8b9d0391b79 100644
--- a/spec/requests/api/users_spec.rb
+++ b/spec/requests/api/users_spec.rb
@@ -41,7 +41,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it "returns authorization error when the `username` parameter is not passed" do
         get api("/users")
 
-        expect(response).to have_gitlab_http_status(403)
+        expect(response).to have_gitlab_http_status(:forbidden)
       end
 
       it "returns the user when a valid `username` parameter is passed" do
@@ -65,7 +65,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it "returns an empty response when an invalid `username` parameter is passed" do
         get api("/users"), params: { username: 'invalid' }
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(:ok)
         expect(json_response).to be_an Array
         expect(json_response.size).to eq(0)
       end
@@ -93,13 +93,13 @@ describe API::Users, :do_not_mock_admin_mode do
         it "returns authorization error when the `username` parameter refers to an inaccessible user" do
           get api("/users"), params: { username: user.username }
 
-          expect(response).to have_gitlab_http_status(403)
+          expect(response).to have_gitlab_http_status(:forbidden)
         end
 
         it "returns authorization error when the `username` parameter is not passed" do
           get api("/users")
 
-          expect(response).to have_gitlab_http_status(403)
+          expect(response).to have_gitlab_http_status(:forbidden)
         end
       end
     end
@@ -169,7 +169,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it "returns a 403 when non-admin user searches by external UID" do
         get api("/users?extern_uid=#{omniauth_user.identities.first.extern_uid}&provider=#{omniauth_user.identities.first.provider}", user)
 
-        expect(response).to have_gitlab_http_status(403)
+        expect(response).to have_gitlab_http_status(:forbidden)
       end
 
       it 'does not reveal the `is_admin` flag of the user' do
@@ -218,13 +218,13 @@ describe API::Users, :do_not_mock_admin_mode do
       it "returns 400 error if provider with no extern_uid" do
         get api("/users?extern_uid=#{omniauth_user.identities.first.extern_uid}", admin)
 
-        expect(response).to have_gitlab_http_status(400)
+        expect(response).to have_gitlab_http_status(:bad_request)
       end
 
       it "returns 400 error if provider with no extern_uid" do
         get api("/users?provider=#{omniauth_user.identities.first.provider}", admin)
 
-        expect(response).to have_gitlab_http_status(400)
+        expect(response).to have_gitlab_http_status(:bad_request)
       end
 
       it "returns a user created before a specific date" do
@@ -283,7 +283,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it 'returns 400 when provided incorrect sort params' do
         get api('/users', admin), params: { order_by: 'magic', sort: 'asc' }
 
-        expect(response).to have_gitlab_http_status(400)
+        expect(response).to have_gitlab_http_status(:bad_request)
       end
     end
 
@@ -293,7 +293,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
         get api("/users", user), params: { skip_ldap: "true" }
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(:ok)
         expect(json_response).to be_an Array
         expect(json_response.first["username"]).to eq user.username
       end
@@ -403,7 +403,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
         get api("/users/#{user.id}")
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
       end
 
       it "returns the `created_at` field for public users" do
@@ -424,14 +424,14 @@ describe API::Users, :do_not_mock_admin_mode do
     it "returns a 404 error if user id not found" do
       get api("/users/0", user)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
     it "returns a 404 for invalid ID" do
       get api("/users/1ASDF", user)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
   end
 
@@ -468,7 +468,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
     it "creates user with correct attributes" do
       post api('/users', admin), params: attributes_for(:user, admin: true, can_create_group: true)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
       user_id = json_response['id']
       new_user = User.find(user_id)
       expect(new_user.admin).to eq(true)
@@ -481,12 +481,12 @@ describe API::Users, :do_not_mock_admin_mode do
 
       post api('/users', admin), params: attributes
 
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
     end
 
     it "creates non-admin user" do
       post api('/users', admin), params: attributes_for(:user, admin: false, can_create_group: false)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
       user_id = json_response['id']
       new_user = User.find(user_id)
       expect(new_user.admin).to eq(false)
@@ -495,7 +495,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
     it "creates non-admin users by default" do
       post api('/users', admin), params: attributes_for(:user)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
       user_id = json_response['id']
       new_user = User.find(user_id)
       expect(new_user.admin).to eq(false)
@@ -504,12 +504,12 @@ describe API::Users, :do_not_mock_admin_mode do
     it "returns 201 Created on success" do
       post api("/users", admin), params: attributes_for(:user, projects_limit: 3)
       expect(response).to match_response_schema('public_api/v4/user/admin')
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
     end
 
     it 'creates non-external users by default' do
       post api("/users", admin), params: attributes_for(:user)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
 
       user_id = json_response['id']
       new_user = User.find(user_id)
@@ -518,7 +518,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
     it 'allows an external user to be created' do
       post api("/users", admin), params: attributes_for(:user, external: true)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
 
       user_id = json_response['id']
       new_user = User.find(user_id)
@@ -528,7 +528,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "creates user with reset password" do
       post api('/users', admin), params: attributes_for(:user, reset_password: true).except(:password)
 
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
 
       user_id = json_response['id']
       new_user = User.find(user_id)
@@ -540,7 +540,7 @@ describe API::Users, :do_not_mock_admin_mode do
       params = attributes_for(:user, force_random_password: true, reset_password: true)
       post api('/users', admin), params: params
 
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
 
       user_id = json_response['id']
       new_user = User.find(user_id)
@@ -552,7 +552,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "creates user with private profile" do
       post api('/users', admin), params: attributes_for(:user, private_profile: true)
 
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
 
       user_id = json_response['id']
       new_user = User.find(user_id)
@@ -568,27 +568,27 @@ describe API::Users, :do_not_mock_admin_mode do
              password: 'password',
              name: 'test'
            }
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     it 'returns 400 error if name not given' do
       post api('/users', admin), params: attributes_for(:user).except(:name)
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     it 'returns 400 error if password not given' do
       post api('/users', admin), params: attributes_for(:user).except(:password)
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     it 'returns 400 error if email not given' do
       post api('/users', admin), params: attributes_for(:user).except(:email)
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     it 'returns 400 error if username not given' do
       post api('/users', admin), params: attributes_for(:user).except(:username)
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     it "doesn't create user with invalid optional attributes" do
@@ -597,7 +597,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
       post api('/users', admin), params: attributes
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     it 'returns 400 error if user does not validate' do
@@ -610,7 +610,7 @@ describe API::Users, :do_not_mock_admin_mode do
              bio: 'g' * 256,
              projects_limit: -1
            }
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['message']['password'])
         .to eq(['is too short (minimum is 8 characters)'])
       expect(json_response['message']['bio'])
@@ -623,7 +623,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
     it "is not available for non admin users" do
       post api("/users", user), params: attributes_for(:user)
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
     end
 
     context 'with existing user' do
@@ -647,7 +647,7 @@ describe API::Users, :do_not_mock_admin_mode do
                  username: 'foo'
                }
         end.to change { User.count }.by(0)
-        expect(response).to have_gitlab_http_status(409)
+        expect(response).to have_gitlab_http_status(:conflict)
         expect(json_response['message']).to eq('Email has already been taken')
       end
 
@@ -661,7 +661,7 @@ describe API::Users, :do_not_mock_admin_mode do
                  username: 'test'
                }
         end.to change { User.count }.by(0)
-        expect(response).to have_gitlab_http_status(409)
+        expect(response).to have_gitlab_http_status(:conflict)
         expect(json_response['message']).to eq('Username has already been taken')
       end
 
@@ -675,14 +675,14 @@ describe API::Users, :do_not_mock_admin_mode do
                  username: 'TEST'
                }
         end.to change { User.count }.by(0)
-        expect(response).to have_gitlab_http_status(409)
+        expect(response).to have_gitlab_http_status(:conflict)
         expect(json_response['message']).to eq('Username has already been taken')
       end
 
       it 'creates user with new identity' do
         post api("/users", admin), params: attributes_for(:user, provider: 'github', extern_uid: '67890')
 
-        expect(response).to have_gitlab_http_status(201)
+        expect(response).to have_gitlab_http_status(:created)
         expect(json_response['identities'].first['extern_uid']).to eq('67890')
         expect(json_response['identities'].first['provider']).to eq('github')
       end
@@ -704,13 +704,13 @@ describe API::Users, :do_not_mock_admin_mode do
       put api("/users/#{user.id}", admin), params: { bio: 'new test bio' }
 
       expect(response).to match_response_schema('public_api/v4/user/admin')
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
     end
 
     it "updates user with new bio" do
       put api("/users/#{user.id}", admin), params: { bio: 'new test bio' }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response['bio']).to eq('new test bio')
       expect(user.reload.bio).to eq('new test bio')
     end
@@ -718,14 +718,14 @@ describe API::Users, :do_not_mock_admin_mode do
     it "updates user with new password and forces reset on next login" do
       put api("/users/#{user.id}", admin), params: { password: '12345678' }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user.reload.password_expires_at).to be <= Time.now
     end
 
     it "updates user with organization" do
       put api("/users/#{user.id}", admin), params: { organization: 'GitLab' }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response['organization']).to eq('GitLab')
       expect(user.reload.organization).to eq('GitLab')
     end
@@ -736,7 +736,7 @@ describe API::Users, :do_not_mock_admin_mode do
       user.reload
 
       expect(user.avatar).to be_present
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response['avatar_url']).to include(user.avatar_path)
     end
 
@@ -747,7 +747,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
       user.reload
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user).to be_confirmed
       expect(user.email).to eq(old_email)
       expect(user.notification_email).to eq(old_notification_email)
@@ -759,7 +759,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
       user.reload
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user).to be_confirmed
       expect(user.email).to eq('new@email.com')
     end
@@ -767,7 +767,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'updates user with their own username' do
       put api("/users/#{user.id}", admin), params: { username: user.username }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response['username']).to eq(user.username)
       expect(user.reload.username).to eq(user.username)
     end
@@ -775,14 +775,14 @@ describe API::Users, :do_not_mock_admin_mode do
     it "updates user's existing identity" do
       put api("/users/#{omniauth_user.id}", admin), params: { provider: 'ldapmain', extern_uid: '654321' }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(omniauth_user.reload.identities.first.extern_uid).to eq('654321')
     end
 
     it 'updates user with new identity' do
       put api("/users/#{user.id}", admin), params: { provider: 'github', extern_uid: 'john' }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user.reload.identities.first.extern_uid).to eq('john')
       expect(user.reload.identities.first.provider).to eq('github')
     end
@@ -790,7 +790,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "updates admin status" do
       put api("/users/#{user.id}", admin), params: { admin: true }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user.reload.admin).to eq(true)
     end
 
@@ -811,7 +811,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "updates private profile" do
       put api("/users/#{user.id}", admin), params: { private_profile: true }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user.reload.private_profile).to eq(true)
     end
 
@@ -820,7 +820,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
       put api("/users/#{user.id}", admin), params: { private_profile: nil }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user.reload.private_profile).to eq(false)
     end
 
@@ -829,14 +829,14 @@ describe API::Users, :do_not_mock_admin_mode do
 
       put api("/users/#{user.id}", admin), params: {}
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user.reload.private_profile).to eq(true)
     end
 
     it "does not update admin status" do
       put api("/users/#{admin_user.id}", admin), params: { can_create_group: false }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(admin_user.reload.admin).to eq(true)
       expect(admin_user.can_create_group).to eq(false)
     end
@@ -844,35 +844,35 @@ describe API::Users, :do_not_mock_admin_mode do
     it "does not allow invalid update" do
       put api("/users/#{user.id}", admin), params: { email: 'invalid email' }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(user.reload.email).not_to eq('invalid email')
     end
 
     it "updates theme id" do
       put api("/users/#{user.id}", admin), params: { theme_id: 5 }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user.reload.theme_id).to eq(5)
     end
 
     it "does not update invalid theme id" do
       put api("/users/#{user.id}", admin), params: { theme_id: 50 }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(user.reload.theme_id).not_to eq(50)
     end
 
     it "updates color scheme id" do
       put api("/users/#{user.id}", admin), params: { color_scheme_id: 5 }
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(user.reload.color_scheme_id).to eq(5)
     end
 
     it "does not update invalid color scheme id" do
       put api("/users/#{user.id}", admin), params: { color_scheme_id: 50 }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(user.reload.color_scheme_id).not_to eq(50)
     end
 
@@ -882,21 +882,21 @@ describe API::Users, :do_not_mock_admin_mode do
           put api("/users/#{user.id}", user), params: attributes_for(:user)
         end.not_to change { user.reload.attributes }
 
-        expect(response).to have_gitlab_http_status(403)
+        expect(response).to have_gitlab_http_status(:forbidden)
       end
     end
 
     it "returns 404 for non-existing user" do
       put api("/users/0", admin), params: { bio: 'update should fail' }
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
     it "returns a 404 if invalid ID" do
       put api("/users/ASDF", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
 
     it 'returns 400 error if user does not validate' do
@@ -909,7 +909,7 @@ describe API::Users, :do_not_mock_admin_mode do
             bio: 'g' * 256,
             projects_limit: -1
           }
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['message']['password'])
         .to eq(['is too short (minimum is 8 characters)'])
       expect(json_response['message']['bio'])
@@ -923,13 +923,13 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns 400 if provider is missing for identity update' do
       put api("/users/#{omniauth_user.id}", admin), params: { extern_uid: '654321' }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     it 'returns 400 if external UID is missing for identity update' do
       put api("/users/#{omniauth_user.id}", admin), params: { provider: 'ldap' }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     context "with existing user" do
@@ -942,7 +942,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it 'returns 409 conflict error if email address exists' do
         put api("/users/#{@user.id}", admin), params: { email: 'test@example.com' }
 
-        expect(response).to have_gitlab_http_status(409)
+        expect(response).to have_gitlab_http_status(:conflict)
         expect(@user.reload.email).to eq(@user.email)
       end
 
@@ -950,7 +950,7 @@ describe API::Users, :do_not_mock_admin_mode do
         @user_id = User.all.last.id
         put api("/users/#{@user.id}", admin), params: { username: 'test' }
 
-        expect(response).to have_gitlab_http_status(409)
+        expect(response).to have_gitlab_http_status(:conflict)
         expect(@user.reload.username).to eq(@user.username)
       end
 
@@ -958,7 +958,7 @@ describe API::Users, :do_not_mock_admin_mode do
         @user_id = User.all.last.id
         put api("/users/#{@user.id}", admin), params: { username: 'TEST' }
 
-        expect(response).to have_gitlab_http_status(409)
+        expect(response).to have_gitlab_http_status(:conflict)
         expect(@user.reload.username).to eq(@user.username)
       end
     end
@@ -1011,14 +1011,14 @@ describe API::Users, :do_not_mock_admin_mode do
     it "does not create invalid ssh key" do
       post api("/users/#{user.id}/keys", admin), params: { title: "invalid key" }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('key is missing')
     end
 
     it 'does not create key without title' do
       post api("/users/#{user.id}/keys", admin), params: { key: 'some key' }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('title is missing')
     end
 
@@ -1031,7 +1031,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
     it "returns 400 for invalid ID" do
       post api("/users/0/keys", admin)
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
   end
 
@@ -1041,7 +1041,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
       get api("/users/#{user_id}/keys")
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
@@ -1051,7 +1051,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
       get api("/users/#{user.id}/keys")
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(response).to include_pagination_headers
       expect(json_response).to be_an Array
       expect(json_response.first['title']).to eq(key.title)
@@ -1062,7 +1062,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns 404 for non-existing user' do
       get api("/users/#{not_existing_user_id}/keys")
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
@@ -1072,7 +1072,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
       get api("/users/#{user.username}/keys")
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(response).to include_pagination_headers
       expect(json_response).to be_an Array
       expect(json_response.first['title']).to eq(key.title)
@@ -1087,7 +1087,7 @@ describe API::Users, :do_not_mock_admin_mode do
     context 'when unauthenticated' do
       it 'returns authentication error' do
         delete api("/users/#{user.id}/keys/42")
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
@@ -1099,7 +1099,7 @@ describe API::Users, :do_not_mock_admin_mode do
         expect do
           delete api("/users/#{user.id}/keys/#{key.id}", admin)
 
-          expect(response).to have_gitlab_http_status(204)
+          expect(response).to have_gitlab_http_status(:no_content)
         end.to change { user.keys.count }.by(-1)
       end
 
@@ -1111,13 +1111,13 @@ describe API::Users, :do_not_mock_admin_mode do
         user.keys << key
         user.save
         delete api("/users/0/keys/#{key.id}", admin)
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 User Not Found')
       end
 
       it 'returns 404 error if key not foud' do
         delete api("/users/#{user.id}/keys/42", admin)
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 Key Not Found')
       end
     end
@@ -1131,7 +1131,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'does not create invalid GPG key' do
       post api("/users/#{user.id}/gpg_keys", admin)
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('key is missing')
     end
 
@@ -1140,14 +1140,14 @@ describe API::Users, :do_not_mock_admin_mode do
       expect do
         post api("/users/#{user.id}/gpg_keys", admin), params: key_attrs
 
-        expect(response).to have_gitlab_http_status(201)
+        expect(response).to have_gitlab_http_status(:created)
       end.to change { user.gpg_keys.count }.by(1)
     end
 
     it 'returns 400 for invalid ID' do
       post api('/users/0/gpg_keys', admin)
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
   end
 
@@ -1160,7 +1160,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it 'returns authentication error' do
         get api("/users/#{user.id}/gpg_keys")
 
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
@@ -1168,14 +1168,14 @@ describe API::Users, :do_not_mock_admin_mode do
       it 'returns 404 for non-existing user' do
         get api('/users/0/gpg_keys', admin)
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 User Not Found')
       end
 
       it 'returns 404 error if key not foud' do
         delete api("/users/#{user.id}/gpg_keys/42", admin)
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 GPG Key Not Found')
       end
 
@@ -1185,7 +1185,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
         get api("/users/#{user.id}/gpg_keys", admin)
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(:ok)
         expect(response).to include_pagination_headers
         expect(json_response).to be_an Array
         expect(json_response.first['key']).to eq(gpg_key.key)
@@ -1202,7 +1202,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it 'returns authentication error' do
         delete api("/users/#{user.id}/keys/42")
 
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
@@ -1214,7 +1214,7 @@ describe API::Users, :do_not_mock_admin_mode do
         expect do
           delete api("/users/#{user.id}/gpg_keys/#{gpg_key.id}", admin)
 
-          expect(response).to have_gitlab_http_status(204)
+          expect(response).to have_gitlab_http_status(:no_content)
         end.to change { user.gpg_keys.count }.by(-1)
       end
 
@@ -1224,14 +1224,14 @@ describe API::Users, :do_not_mock_admin_mode do
 
         delete api("/users/0/gpg_keys/#{gpg_key.id}", admin)
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 User Not Found')
       end
 
       it 'returns 404 error if key not foud' do
         delete api("/users/#{user.id}/gpg_keys/42", admin)
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 GPG Key Not Found')
       end
     end
@@ -1246,7 +1246,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it 'returns authentication error' do
         post api("/users/#{user.id}/gpg_keys/42/revoke")
 
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
@@ -1268,14 +1268,14 @@ describe API::Users, :do_not_mock_admin_mode do
 
         post api("/users/0/gpg_keys/#{gpg_key.id}/revoke", admin)
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 User Not Found')
       end
 
       it 'returns 404 error if key not foud' do
         post api("/users/#{user.id}/gpg_keys/42/revoke", admin)
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 GPG Key Not Found')
       end
     end
@@ -1289,7 +1289,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "does not create invalid email" do
       post api("/users/#{user.id}/emails", admin), params: {}
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('email is missing')
     end
 
@@ -1306,7 +1306,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "returns a 400 for invalid ID" do
       post api("/users/0/emails", admin)
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
 
     it "creates verified email" do
@@ -1315,7 +1315,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
       post api("/users/#{user.id}/emails", admin), params: email_attrs
 
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
 
       email = Email.find_by(user_id: user.id, email: email_attrs[:email])
       expect(email).to be_confirmed
@@ -1330,14 +1330,14 @@ describe API::Users, :do_not_mock_admin_mode do
     context 'when unauthenticated' do
       it 'returns authentication error' do
         get api("/users/#{user.id}/emails")
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
     context 'when authenticated' do
       it 'returns 404 for non-existing user' do
         get api('/users/0/emails', admin)
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 User Not Found')
       end
 
@@ -1347,7 +1347,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
         get api("/users/#{user.id}/emails", admin)
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(:ok)
         expect(response).to include_pagination_headers
         expect(json_response).to be_an Array
         expect(json_response.first['email']).to eq(email.email)
@@ -1356,7 +1356,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it "returns a 404 for invalid ID" do
         get api("/users/ASDF/emails", admin)
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
       end
     end
   end
@@ -1369,7 +1369,7 @@ describe API::Users, :do_not_mock_admin_mode do
     context 'when unauthenticated' do
       it 'returns authentication error' do
         delete api("/users/#{user.id}/emails/42")
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
@@ -1381,7 +1381,7 @@ describe API::Users, :do_not_mock_admin_mode do
         expect do
           delete api("/users/#{user.id}/emails/#{email.id}", admin)
 
-          expect(response).to have_gitlab_http_status(204)
+          expect(response).to have_gitlab_http_status(:no_content)
         end.to change { user.emails.count }.by(-1)
       end
 
@@ -1393,20 +1393,20 @@ describe API::Users, :do_not_mock_admin_mode do
         user.emails << email
         user.save
         delete api("/users/0/emails/#{email.id}", admin)
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 User Not Found')
       end
 
       it 'returns 404 error if email not foud' do
         delete api("/users/#{user.id}/emails/42", admin)
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 Email Not Found')
       end
 
       it "returns a 404 for invalid ID" do
         delete api("/users/ASDF/emails/bar", admin)
 
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
       end
     end
   end
@@ -1422,7 +1422,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "deletes user", :sidekiq_might_not_need_inline do
       perform_enqueued_jobs { delete api("/users/#{user.id}", admin) }
 
-      expect(response).to have_gitlab_http_status(204)
+      expect(response).to have_gitlab_http_status(:no_content)
       expect { User.find(user.id) }.to raise_error ActiveRecord::RecordNotFound
       expect { Namespace.find(namespace.id) }.to raise_error ActiveRecord::RecordNotFound
     end
@@ -1433,14 +1433,14 @@ describe API::Users, :do_not_mock_admin_mode do
       context "hard delete disabled" do
         it "does not delete user" do
           perform_enqueued_jobs { delete api("/users/#{user.id}", admin)}
-          expect(response).to have_gitlab_http_status(409)
+          expect(response).to have_gitlab_http_status(:conflict)
         end
       end
 
       context "hard delete enabled" do
         it "delete user and group", :sidekiq_might_not_need_inline do
           perform_enqueued_jobs { delete api("/users/#{user.id}?hard_delete=true", admin)}
-          expect(response).to have_gitlab_http_status(204)
+          expect(response).to have_gitlab_http_status(:no_content)
           expect(Group.exists?(group.id)).to be_falsy
         end
       end
@@ -1452,31 +1452,31 @@ describe API::Users, :do_not_mock_admin_mode do
 
     it "does not delete for unauthenticated user" do
       perform_enqueued_jobs { delete api("/users/#{user.id}") }
-      expect(response).to have_gitlab_http_status(401)
+      expect(response).to have_gitlab_http_status(:unauthorized)
     end
 
     it "is not available for non admin users" do
       perform_enqueued_jobs { delete api("/users/#{user.id}", user) }
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
     end
 
     it "returns 404 for non-existing user" do
       perform_enqueued_jobs { delete api("/users/0", admin) }
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
     it "returns a 404 for invalid ID" do
       perform_enqueued_jobs { delete api("/users/ASDF", admin) }
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
 
     context "hard delete disabled" do
       it "moves contributions to the ghost user", :sidekiq_might_not_need_inline do
         perform_enqueued_jobs { delete api("/users/#{user.id}", admin) }
 
-        expect(response).to have_gitlab_http_status(204)
+        expect(response).to have_gitlab_http_status(:no_content)
         expect(issue.reload).to be_persisted
         expect(issue.author.ghost?).to be_truthy
       end
@@ -1486,7 +1486,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it "removes contributions", :sidekiq_might_not_need_inline do
         perform_enqueued_jobs { delete api("/users/#{user.id}?hard_delete=true", admin) }
 
-        expect(response).to have_gitlab_http_status(204)
+        expect(response).to have_gitlab_http_status(:no_content)
         expect(Issue.exists?(issue.id)).to be_falsy
       end
     end
@@ -1501,14 +1501,14 @@ describe API::Users, :do_not_mock_admin_mode do
           it 'returns 403 without private token when sudo is defined' do
             get api("/user?private_token=#{personal_access_token}&sudo=123", version: version)
 
-            expect(response).to have_gitlab_http_status(403)
+            expect(response).to have_gitlab_http_status(:forbidden)
           end
         end
 
         it 'returns current user without private token when sudo not defined' do
           get api("/user", user, version: version)
 
-          expect(response).to have_gitlab_http_status(200)
+          expect(response).to have_gitlab_http_status(:ok)
           expect(response).to match_response_schema('public_api/v4/user/public')
           expect(json_response['id']).to eq(user.id)
         end
@@ -1528,13 +1528,13 @@ describe API::Users, :do_not_mock_admin_mode do
           it 'returns 403 without private token when sudo defined' do
             get api("/user?private_token=#{admin_personal_access_token}&sudo=#{user.id}", version: version)
 
-            expect(response).to have_gitlab_http_status(403)
+            expect(response).to have_gitlab_http_status(:forbidden)
           end
 
           it 'returns initial current user without private token but with is_admin when sudo not defined' do
             get api("/user?private_token=#{admin_personal_access_token}", version: version)
 
-            expect(response).to have_gitlab_http_status(200)
+            expect(response).to have_gitlab_http_status(:ok)
             expect(response).to match_response_schema('public_api/v4/user/admin')
             expect(json_response['id']).to eq(admin.id)
           end
@@ -1545,7 +1545,7 @@ describe API::Users, :do_not_mock_admin_mode do
         it "returns 401 error if user is unauthenticated" do
           get api("/user", version: version)
 
-          expect(response).to have_gitlab_http_status(401)
+          expect(response).to have_gitlab_http_status(:unauthorized)
         end
       end
     end
@@ -1558,7 +1558,7 @@ describe API::Users, :do_not_mock_admin_mode do
     context "when unauthenticated" do
       it "returns authentication error" do
         get api("/user/keys")
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
@@ -1569,7 +1569,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
         get api("/user/keys", user)
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(:ok)
         expect(response).to include_pagination_headers
         expect(json_response).to be_an Array
         expect(json_response.first["title"]).to eq(key.title)
@@ -1589,14 +1589,14 @@ describe API::Users, :do_not_mock_admin_mode do
       user.keys << key
       user.save
       get api("/user/keys/#{key.id}", user)
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response["title"]).to eq(key.title)
     end
 
     it "returns 404 Not Found within invalid ID" do
       get api("/user/keys/42", user)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Key Not Found')
     end
 
@@ -1605,14 +1605,14 @@ describe API::Users, :do_not_mock_admin_mode do
       user.save
       admin
       get api("/user/keys/#{key.id}", admin)
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Key Not Found')
     end
 
     it "returns 404 for invalid ID" do
       get api("/users/keys/ASDF", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
 
     context "scopes" do
@@ -1629,31 +1629,31 @@ describe API::Users, :do_not_mock_admin_mode do
       expect do
         post api("/user/keys", user), params: key_attrs
       end.to change { user.keys.count }.by(1)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
     end
 
     it "returns a 401 error if unauthorized" do
       post api("/user/keys"), params: { title: 'some title', key: 'some key' }
-      expect(response).to have_gitlab_http_status(401)
+      expect(response).to have_gitlab_http_status(:unauthorized)
     end
 
     it "does not create ssh key without key" do
       post api("/user/keys", user), params: { title: 'title' }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('key is missing')
     end
 
     it 'does not create ssh key without title' do
       post api('/user/keys', user), params: { key: 'some key' }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('title is missing')
     end
 
     it "does not create ssh key without title" do
       post api("/user/keys", user), params: { key: "somekey" }
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
   end
 
@@ -1665,7 +1665,7 @@ describe API::Users, :do_not_mock_admin_mode do
       expect do
         delete api("/user/keys/#{key.id}", user)
 
-        expect(response).to have_gitlab_http_status(204)
+        expect(response).to have_gitlab_http_status(:no_content)
       end.to change { user.keys.count}.by(-1)
     end
 
@@ -1676,7 +1676,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "returns 404 if key ID not found" do
       delete api("/user/keys/42", user)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Key Not Found')
     end
 
@@ -1684,13 +1684,13 @@ describe API::Users, :do_not_mock_admin_mode do
       user.keys << key
       user.save
       delete api("/user/keys/#{key.id}")
-      expect(response).to have_gitlab_http_status(401)
+      expect(response).to have_gitlab_http_status(:unauthorized)
     end
 
     it "returns a 404 for invalid ID" do
       delete api("/users/keys/ASDF", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
   end
 
@@ -1699,7 +1699,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it 'returns authentication error' do
         get api('/user/gpg_keys')
 
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
@@ -1710,7 +1710,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
         get api('/user/gpg_keys', user)
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(:ok)
         expect(response).to include_pagination_headers
         expect(json_response).to be_an Array
         expect(json_response.first['key']).to eq(gpg_key.key)
@@ -1732,14 +1732,14 @@ describe API::Users, :do_not_mock_admin_mode do
 
       get api("/user/gpg_keys/#{gpg_key.id}", user)
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response['key']).to eq(gpg_key.key)
     end
 
     it 'returns 404 Not Found within invalid ID' do
       get api('/user/gpg_keys/42', user)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 GPG Key Not Found')
     end
 
@@ -1749,14 +1749,14 @@ describe API::Users, :do_not_mock_admin_mode do
 
       get api("/user/gpg_keys/#{gpg_key.id}", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 GPG Key Not Found')
     end
 
     it 'returns 404 for invalid ID' do
       get api('/users/gpg_keys/ASDF', admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
 
     context 'scopes' do
@@ -1773,20 +1773,20 @@ describe API::Users, :do_not_mock_admin_mode do
       expect do
         post api('/user/gpg_keys', user), params: key_attrs
 
-        expect(response).to have_gitlab_http_status(201)
+        expect(response).to have_gitlab_http_status(:created)
       end.to change { user.gpg_keys.count }.by(1)
     end
 
     it 'returns a 401 error if unauthorized' do
       post api('/user/gpg_keys'), params: { key: 'some key' }
 
-      expect(response).to have_gitlab_http_status(401)
+      expect(response).to have_gitlab_http_status(:unauthorized)
     end
 
     it 'does not create GPG key without key' do
       post api('/user/gpg_keys', user)
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('key is missing')
     end
   end
@@ -1806,7 +1806,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns 404 if key ID not found' do
       post api('/user/gpg_keys/42/revoke', user)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 GPG Key Not Found')
     end
 
@@ -1816,13 +1816,13 @@ describe API::Users, :do_not_mock_admin_mode do
 
       post api("/user/gpg_keys/#{gpg_key.id}/revoke")
 
-      expect(response).to have_gitlab_http_status(401)
+      expect(response).to have_gitlab_http_status(:unauthorized)
     end
 
     it 'returns a 404 for invalid ID' do
       post api('/users/gpg_keys/ASDF/revoke', admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
   end
 
@@ -1834,14 +1834,14 @@ describe API::Users, :do_not_mock_admin_mode do
       expect do
         delete api("/user/gpg_keys/#{gpg_key.id}", user)
 
-        expect(response).to have_gitlab_http_status(204)
+        expect(response).to have_gitlab_http_status(:no_content)
       end.to change { user.gpg_keys.count}.by(-1)
     end
 
     it 'returns 404 if key ID not found' do
       delete api('/user/gpg_keys/42', user)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 GPG Key Not Found')
     end
 
@@ -1851,13 +1851,13 @@ describe API::Users, :do_not_mock_admin_mode do
 
       delete api("/user/gpg_keys/#{gpg_key.id}")
 
-      expect(response).to have_gitlab_http_status(401)
+      expect(response).to have_gitlab_http_status(:unauthorized)
     end
 
     it 'returns a 404 for invalid ID' do
       delete api('/users/gpg_keys/ASDF', admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
   end
 
@@ -1865,7 +1865,7 @@ describe API::Users, :do_not_mock_admin_mode do
     context "when unauthenticated" do
       it "returns authentication error" do
         get api("/user/emails")
-        expect(response).to have_gitlab_http_status(401)
+        expect(response).to have_gitlab_http_status(:unauthorized)
       end
     end
 
@@ -1876,7 +1876,7 @@ describe API::Users, :do_not_mock_admin_mode do
 
         get api("/user/emails", user)
 
-        expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(:ok)
         expect(response).to include_pagination_headers
         expect(json_response).to be_an Array
         expect(json_response.first["email"]).to eq(email.email)
@@ -1896,13 +1896,13 @@ describe API::Users, :do_not_mock_admin_mode do
       user.emails << email
       user.save
       get api("/user/emails/#{email.id}", user)
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response["email"]).to eq(email.email)
     end
 
     it "returns 404 Not Found within invalid ID" do
       get api("/user/emails/42", user)
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Email Not Found')
     end
 
@@ -1911,14 +1911,14 @@ describe API::Users, :do_not_mock_admin_mode do
       user.save
       admin
       get api("/user/emails/#{email.id}", admin)
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Email Not Found')
     end
 
     it "returns 404 for invalid ID" do
       get api("/users/emails/ASDF", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
 
     context "scopes" do
@@ -1935,18 +1935,18 @@ describe API::Users, :do_not_mock_admin_mode do
       expect do
         post api("/user/emails", user), params: email_attrs
       end.to change { user.emails.count }.by(1)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
     end
 
     it "returns a 401 error if unauthorized" do
       post api("/user/emails"), params: { email: 'some email' }
-      expect(response).to have_gitlab_http_status(401)
+      expect(response).to have_gitlab_http_status(:unauthorized)
     end
 
     it "does not create email with invalid email" do
       post api("/user/emails", user), params: {}
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('email is missing')
     end
   end
@@ -1959,7 +1959,7 @@ describe API::Users, :do_not_mock_admin_mode do
       expect do
         delete api("/user/emails/#{email.id}", user)
 
-        expect(response).to have_gitlab_http_status(204)
+        expect(response).to have_gitlab_http_status(:no_content)
       end.to change { user.emails.count}.by(-1)
     end
 
@@ -1970,7 +1970,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it "returns 404 if email ID not found" do
       delete api("/user/emails/42", user)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Email Not Found')
     end
 
@@ -1978,20 +1978,20 @@ describe API::Users, :do_not_mock_admin_mode do
       user.emails << email
       user.save
       delete api("/user/emails/#{email.id}")
-      expect(response).to have_gitlab_http_status(401)
+      expect(response).to have_gitlab_http_status(:unauthorized)
     end
 
     it "returns 400 for invalid ID" do
       delete api("/user/emails/ASDF", admin)
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
     end
   end
 
   context 'activate and deactivate' do
     shared_examples '404' do
       it 'returns 404' do
-        expect(response).to have_gitlab_http_status(404)
+        expect(response).to have_gitlab_http_status(:not_found)
         expect(json_response['message']).to eq('404 User Not Found')
       end
     end
@@ -2001,7 +2001,7 @@ describe API::Users, :do_not_mock_admin_mode do
         it 'is not authorized to perform the action' do
           post api("/users/#{user.id}/activate", user)
 
-          expect(response).to have_gitlab_http_status(403)
+          expect(response).to have_gitlab_http_status(:forbidden)
         end
       end
 
@@ -2014,7 +2014,7 @@ describe API::Users, :do_not_mock_admin_mode do
           end
 
           it 'activates a deactivated user' do
-            expect(response).to have_gitlab_http_status(201)
+            expect(response).to have_gitlab_http_status(:created)
             expect(user.reload.state).to eq('active')
           end
         end
@@ -2027,7 +2027,7 @@ describe API::Users, :do_not_mock_admin_mode do
           end
 
           it 'returns 201' do
-            expect(response).to have_gitlab_http_status(201)
+            expect(response).to have_gitlab_http_status(:created)
             expect(user.reload.state).to eq('active')
           end
         end
@@ -2040,7 +2040,7 @@ describe API::Users, :do_not_mock_admin_mode do
           end
 
           it 'returns 403' do
-            expect(response).to have_gitlab_http_status(403)
+            expect(response).to have_gitlab_http_status(:forbidden)
             expect(json_response['message']).to eq('403 Forbidden  - A blocked user must be unblocked to be activated')
             expect(user.reload.state).to eq('blocked')
           end
@@ -2054,7 +2054,7 @@ describe API::Users, :do_not_mock_admin_mode do
           end
 
           it 'returns 403' do
-            expect(response).to have_gitlab_http_status(403)
+            expect(response).to have_gitlab_http_status(:forbidden)
             expect(json_response['message']).to eq('403 Forbidden  - A blocked user must be unblocked to be activated')
             expect(user.reload.state).to eq('ldap_blocked')
           end
@@ -2075,7 +2075,7 @@ describe API::Users, :do_not_mock_admin_mode do
         it 'is not authorized to perform the action' do
           post api("/users/#{user.id}/deactivate", user)
 
-          expect(response).to have_gitlab_http_status(403)
+          expect(response).to have_gitlab_http_status(:forbidden)
         end
       end
 
@@ -2092,7 +2092,7 @@ describe API::Users, :do_not_mock_admin_mode do
             end
 
             it 'deactivates an active user' do
-              expect(response).to have_gitlab_http_status(201)
+              expect(response).to have_gitlab_http_status(:created)
               expect(user.reload.state).to eq('deactivated')
             end
           end
@@ -2105,7 +2105,7 @@ describe API::Users, :do_not_mock_admin_mode do
             end
 
             it 'does not deactivate an active user' do
-              expect(response).to have_gitlab_http_status(403)
+              expect(response).to have_gitlab_http_status(:forbidden)
               expect(json_response['message']).to eq("403 Forbidden  - The user you are trying to deactivate has been active in the past #{::User::MINIMUM_INACTIVE_DAYS} days and cannot be deactivated")
               expect(user.reload.state).to eq('active')
             end
@@ -2120,7 +2120,7 @@ describe API::Users, :do_not_mock_admin_mode do
           end
 
           it 'returns 201' do
-            expect(response).to have_gitlab_http_status(201)
+            expect(response).to have_gitlab_http_status(:created)
             expect(user.reload.state).to eq('deactivated')
           end
         end
@@ -2133,7 +2133,7 @@ describe API::Users, :do_not_mock_admin_mode do
           end
 
           it 'returns 403' do
-            expect(response).to have_gitlab_http_status(403)
+            expect(response).to have_gitlab_http_status(:forbidden)
             expect(json_response['message']).to eq('403 Forbidden  - A blocked user cannot be deactivated by the API')
             expect(user.reload.state).to eq('blocked')
           end
@@ -2147,7 +2147,7 @@ describe API::Users, :do_not_mock_admin_mode do
           end
 
           it 'returns 403' do
-            expect(response).to have_gitlab_http_status(403)
+            expect(response).to have_gitlab_http_status(:forbidden)
             expect(json_response['message']).to eq('403 Forbidden  - A blocked user cannot be deactivated by the API')
             expect(user.reload.state).to eq('ldap_blocked')
           end
@@ -2171,25 +2171,25 @@ describe API::Users, :do_not_mock_admin_mode do
 
     it 'blocks existing user' do
       post api("/users/#{user.id}/block", admin)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
       expect(user.reload.state).to eq('blocked')
     end
 
     it 'does not re-block ldap blocked users' do
       post api("/users/#{ldap_blocked_user.id}/block", admin)
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(ldap_blocked_user.reload.state).to eq('ldap_blocked')
     end
 
     it 'does not be available for non admin users' do
       post api("/users/#{user.id}/block", user)
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(user.reload.state).to eq('active')
     end
 
     it 'returns a 404 error if user id not found' do
       post api('/users/0/block', admin)
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
   end
@@ -2204,44 +2204,44 @@ describe API::Users, :do_not_mock_admin_mode do
 
     it 'unblocks existing user' do
       post api("/users/#{user.id}/unblock", admin)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
       expect(user.reload.state).to eq('active')
     end
 
     it 'unblocks a blocked user' do
       post api("/users/#{blocked_user.id}/unblock", admin)
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
       expect(blocked_user.reload.state).to eq('active')
     end
 
     it 'does not unblock ldap blocked users' do
       post api("/users/#{ldap_blocked_user.id}/unblock", admin)
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(ldap_blocked_user.reload.state).to eq('ldap_blocked')
     end
 
     it 'does not unblock deactivated users' do
       post api("/users/#{deactivated_user.id}/unblock", admin)
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(deactivated_user.reload.state).to eq('deactivated')
     end
 
     it 'is not available for non admin users' do
       post api("/users/#{user.id}/unblock", user)
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(user.reload.state).to eq('active')
     end
 
     it 'returns a 404 error if user id not found' do
       post api('/users/0/block', admin)
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
     it "returns a 404 for invalid ID" do
       post api("/users/ASDF/block", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
     end
   end
 
@@ -2330,7 +2330,7 @@ describe API::Users, :do_not_mock_admin_mode do
       it 'has no permission' do
         get api("/user/activities", user)
 
-        expect(response).to have_gitlab_http_status(403)
+        expect(response).to have_gitlab_http_status(:forbidden)
       end
     end
 
@@ -2382,7 +2382,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'renders errors when the status was invalid' do
       put api('/user/status', user), params: { emoji: 'does not exist', message: 'hello world' }
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['message']['emoji']).to be_present
     end
 
@@ -2404,21 +2404,21 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns a 404 error if user not found' do
       get api("/users/#{not_existing_user_id}/impersonation_tokens", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
     it 'returns a 403 error when authenticated as normal user' do
       get api("/users/#{not_existing_user_id}/impersonation_tokens", user)
 
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(json_response['message']).to eq('403 Forbidden')
     end
 
     it 'returns an array of all impersonated tokens' do
       get api("/users/#{user.id}/impersonation_tokens", admin)
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(response).to include_pagination_headers
       expect(json_response).to be_an Array
       expect(json_response.size).to eq(2)
@@ -2427,7 +2427,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns an array of active impersonation tokens if state active' do
       get api("/users/#{user.id}/impersonation_tokens?state=active", admin)
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(response).to include_pagination_headers
       expect(json_response).to be_an Array
       expect(json_response.size).to eq(1)
@@ -2437,7 +2437,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns an array of inactive personal access tokens if active is set to false' do
       get api("/users/#{user.id}/impersonation_tokens?state=inactive", admin)
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response).to be_an Array
       expect(json_response.size).to eq(1)
       expect(json_response).to all(include('active' => false))
@@ -2453,7 +2453,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns validation error if impersonation token misses some attributes' do
       post api("/users/#{user.id}/impersonation_tokens", admin)
 
-      expect(response).to have_gitlab_http_status(400)
+      expect(response).to have_gitlab_http_status(:bad_request)
       expect(json_response['error']).to eq('name is missing')
     end
 
@@ -2464,7 +2464,7 @@ describe API::Users, :do_not_mock_admin_mode do
           expires_at: expires_at
         }
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
@@ -2475,7 +2475,7 @@ describe API::Users, :do_not_mock_admin_mode do
           expires_at: expires_at
         }
 
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(json_response['message']).to eq('403 Forbidden')
     end
 
@@ -2488,7 +2488,7 @@ describe API::Users, :do_not_mock_admin_mode do
           impersonation: impersonation
         }
 
-      expect(response).to have_gitlab_http_status(201)
+      expect(response).to have_gitlab_http_status(:created)
       expect(json_response['name']).to eq(name)
       expect(json_response['scopes']).to eq(scopes)
       expect(json_response['expires_at']).to eq(expires_at)
@@ -2508,35 +2508,35 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns 404 error if user not found' do
       get api("/users/#{not_existing_user_id}/impersonation_tokens/1", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
     it 'returns a 404 error if impersonation token not found' do
       get api("/users/#{user.id}/impersonation_tokens/#{not_existing_pat_id}", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Impersonation Token Not Found')
     end
 
     it 'returns a 404 error if token is not impersonation token' do
       get api("/users/#{user.id}/impersonation_tokens/#{personal_access_token.id}", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Impersonation Token Not Found')
     end
 
     it 'returns a 403 error when authenticated as normal user' do
       get api("/users/#{user.id}/impersonation_tokens/#{impersonation_token.id}", user)
 
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(json_response['message']).to eq('403 Forbidden')
     end
 
     it 'returns an impersonation token' do
       get api("/users/#{user.id}/impersonation_tokens/#{impersonation_token.id}", admin)
 
-      expect(response).to have_gitlab_http_status(200)
+      expect(response).to have_gitlab_http_status(:ok)
       expect(json_response['token']).not_to be_present
       expect(json_response['impersonation']).to be_truthy
     end
@@ -2549,28 +2549,28 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'returns a 404 error if user not found' do
       delete api("/users/#{not_existing_user_id}/impersonation_tokens/1", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 User Not Found')
     end
 
     it 'returns a 404 error if impersonation token not found' do
       delete api("/users/#{user.id}/impersonation_tokens/#{not_existing_pat_id}", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Impersonation Token Not Found')
     end
 
     it 'returns a 404 error if token is not impersonation token' do
       delete api("/users/#{user.id}/impersonation_tokens/#{personal_access_token.id}", admin)
 
-      expect(response).to have_gitlab_http_status(404)
+      expect(response).to have_gitlab_http_status(:not_found)
       expect(json_response['message']).to eq('404 Impersonation Token Not Found')
     end
 
     it 'returns a 403 error when authenticated as normal user' do
       delete api("/users/#{user.id}/impersonation_tokens/#{impersonation_token.id}", user)
 
-      expect(response).to have_gitlab_http_status(403)
+      expect(response).to have_gitlab_http_status(:forbidden)
       expect(json_response['message']).to eq('403 Forbidden')
     end
 
@@ -2581,7 +2581,7 @@ describe API::Users, :do_not_mock_admin_mode do
     it 'revokes a impersonation token' do
       delete api("/users/#{user.id}/impersonation_tokens/#{impersonation_token.id}", admin)
 
-      expect(response).to have_gitlab_http_status(204)
+      expect(response).to have_gitlab_http_status(:no_content)
       expect(impersonation_token.revoked).to be_falsey
       expect(impersonation_token.reload.revoked).to be_truthy
     end