From e8314ccca5ff1cd9cf2b1d1aeccd699598b384a5 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Fri, 15 Apr 2016 19:37:21 +0530
Subject: Refactor `API::Helpers` into `API::Helpers::Core` and
 `API::Helpers::Authentication`

---
 spec/requests/api/users_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/requests/api/users_spec.rb b/spec/requests/api/users_spec.rb
index 40b24c125b5..628569d3e00 100644
--- a/spec/requests/api/users_spec.rb
+++ b/spec/requests/api/users_spec.rb
@@ -24,7 +24,7 @@ describe API::API, api: true  do
       context "when public level is restricted" do
         before do
           stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
-          allow_any_instance_of(API::Helpers).to receive(:authenticate!).and_return(true)
+          allow_any_instance_of(API::Helpers::Authentication).to receive(:authenticate!).and_return(true)
         end
 
         it "renders 403" do
-- 
cgit v1.2.1


From 1541d1de18c3e7707ce1289f882b4c1262ec8c71 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Mon, 18 Apr 2016 14:47:38 +0530
Subject: Rename `api_helpers_spec` to `api_authentication_spec`

- And fix all tests.
---
 spec/requests/api/api_authentication_spec.rb | 175 +++++++++++++++++++++++++++
 spec/requests/api/api_helpers_spec.rb        | 173 --------------------------
 2 files changed, 175 insertions(+), 173 deletions(-)
 create mode 100644 spec/requests/api/api_authentication_spec.rb
 delete mode 100644 spec/requests/api/api_helpers_spec.rb

(limited to 'spec')

diff --git a/spec/requests/api/api_authentication_spec.rb b/spec/requests/api/api_authentication_spec.rb
new file mode 100644
index 00000000000..8bed3bb119b
--- /dev/null
+++ b/spec/requests/api/api_authentication_spec.rb
@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+describe API::Helpers::Authentication, api: true do
+
+  include API::Helpers::Authentication
+  include ApiHelpers
+
+  let(:user) { create(:user) }
+  let(:admin) { create(:admin) }
+  let(:key) { create(:key, user: user) }
+
+  let(:params) { {} }
+  let(:env) { {} }
+
+  def set_env(token_usr, identifier)
+    clear_env
+    clear_param
+    env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = token_usr.private_token
+    env[API::Helpers::Authentication::SUDO_HEADER] = identifier
+  end
+
+  def set_param(token_usr, identifier)
+    clear_env
+    clear_param
+    params[API::Helpers::Authentication::PRIVATE_TOKEN_PARAM] = token_usr.private_token
+    params[API::Helpers::Authentication::SUDO_PARAM] = identifier
+  end
+
+  def clear_env
+    env.delete(API::Helpers::Authentication::PRIVATE_TOKEN_HEADER)
+    env.delete(API::Helpers::Authentication::SUDO_HEADER)
+  end
+
+  def clear_param
+    params.delete(API::Helpers::Authentication::PRIVATE_TOKEN_PARAM)
+    params.delete(API::Helpers::Authentication::SUDO_PARAM)
+  end
+
+  def error!(message, status)
+    raise Exception
+  end
+
+  describe ".current_user" do
+    it "should return nil for an invalid token" do
+      env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = 'invalid token'
+      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::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = user.private_token
+      allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
+      expect(current_user).to be_nil
+    end
+
+    it "should leave user as is when sudo not specified" do
+      env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = user.private_token
+      expect(current_user).to eq(user)
+      clear_env
+      params[API::Helpers::Authentication::PRIVATE_TOKEN_PARAM] = user.private_token
+      expect(current_user).to eq(user)
+    end
+
+    it "should change current user to sudo when admin" do
+      set_env(admin, user.id)
+      expect(current_user).to eq(user)
+      set_param(admin, user.id)
+      expect(current_user).to eq(user)
+      set_env(admin, user.username)
+      expect(current_user).to eq(user)
+      set_param(admin, user.username)
+      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
+      set_env(user, admin.id)
+      expect { current_user }.to raise_error(Exception)
+      set_param(user, admin.id)
+      expect { current_user }.to raise_error(Exception)
+      set_env(user, admin.username)
+      expect { current_user }.to raise_error(Exception)
+      set_param(user, admin.username)
+      expect { current_user }.to raise_error(Exception)
+    end
+
+    it "should throw an error when the user cannot be found for a given id" do
+      id = user.id + admin.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(Exception)
+
+      set_param(admin, id)
+      expect { current_user }.to raise_error(Exception)
+    end
+
+    it "should throw an error when the user cannot be found for a given username" do
+      username = "#{user.username}#{admin.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(Exception)
+
+      set_param(admin, username)
+      expect { current_user }.to raise_error(Exception)
+    end
+
+    it "should handle sudo's to oneself" do
+      set_env(admin, admin.id)
+      expect(current_user).to eq(admin)
+      set_param(admin, admin.id)
+      expect(current_user).to eq(admin)
+      set_env(admin, admin.username)
+      expect(current_user).to eq(admin)
+      set_param(admin, admin.username)
+      expect(current_user).to eq(admin)
+    end
+
+    it "should handle multiple sudo's to oneself" do
+      set_env(admin, user.id)
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
+      set_env(admin, user.username)
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
+
+      set_param(admin, user.id)
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
+      set_param(admin, user.username)
+      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)
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
+
+      set_param(admin, user.id.to_s)
+      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')
+      expect(sudo_identifier).to eq(123)
+      set_env(admin, '0001234567890')
+      expect(sudo_identifier).to eq(1234567890)
+
+      set_param(admin, '123')
+      expect(sudo_identifier).to eq(123)
+      set_param(admin, '0001234567890')
+      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')
+      expect(sudo_identifier).to eq("12.30")
+      set_env(admin, 'hello')
+      expect(sudo_identifier).to eq('hello')
+      set_env(admin, ' 123')
+      expect(sudo_identifier).to eq(' 123')
+
+      set_param(admin, '12.30')
+      expect(sudo_identifier).to eq("12.30")
+      set_param(admin, 'hello')
+      expect(sudo_identifier).to eq('hello')
+      set_param(admin, ' 123')
+      expect(sudo_identifier).to eq(' 123')
+    end
+  end
+end
diff --git a/spec/requests/api/api_helpers_spec.rb b/spec/requests/api/api_helpers_spec.rb
deleted file mode 100644
index 0c19094ec54..00000000000
--- a/spec/requests/api/api_helpers_spec.rb
+++ /dev/null
@@ -1,173 +0,0 @@
-require 'spec_helper'
-
-describe API, api: true do
-  include API::Helpers
-  include ApiHelpers
-  let(:user) { create(:user) }
-  let(:admin) { create(:admin) }
-  let(:key) { create(:key, user: user) }
-
-  let(:params) { {} }
-  let(:env) { {} }
-
-  def set_env(token_usr, identifier)
-    clear_env
-    clear_param
-    env[API::Helpers::PRIVATE_TOKEN_HEADER] = token_usr.private_token
-    env[API::Helpers::SUDO_HEADER] = identifier
-  end
-
-  def set_param(token_usr, identifier)
-    clear_env
-    clear_param
-    params[API::Helpers::PRIVATE_TOKEN_PARAM] = token_usr.private_token
-    params[API::Helpers::SUDO_PARAM] = identifier
-  end
-
-  def clear_env
-    env.delete(API::Helpers::PRIVATE_TOKEN_HEADER)
-    env.delete(API::Helpers::SUDO_HEADER)
-  end
-
-  def clear_param
-    params.delete(API::Helpers::PRIVATE_TOKEN_PARAM)
-    params.delete(API::Helpers::SUDO_PARAM)
-  end
-
-  def error!(message, status)
-    raise Exception
-  end
-
-  describe ".current_user" do
-    it "should return nil for an invalid token" do
-      env[API::Helpers::PRIVATE_TOKEN_HEADER] = 'invalid token'
-      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::Helpers::PRIVATE_TOKEN_HEADER] = user.private_token
-      allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
-      expect(current_user).to be_nil
-    end
-
-    it "should leave user as is when sudo not specified" do
-      env[API::Helpers::PRIVATE_TOKEN_HEADER] = user.private_token
-      expect(current_user).to eq(user)
-      clear_env
-      params[API::Helpers::PRIVATE_TOKEN_PARAM] = user.private_token
-      expect(current_user).to eq(user)
-    end
-
-    it "should change current user to sudo when admin" do
-      set_env(admin, user.id)
-      expect(current_user).to eq(user)
-      set_param(admin, user.id)
-      expect(current_user).to eq(user)
-      set_env(admin, user.username)
-      expect(current_user).to eq(user)
-      set_param(admin, user.username)
-      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
-      set_env(user, admin.id)
-      expect { current_user }.to raise_error(Exception)
-      set_param(user, admin.id)
-      expect { current_user }.to raise_error(Exception)
-      set_env(user, admin.username)
-      expect { current_user }.to raise_error(Exception)
-      set_param(user, admin.username)
-      expect { current_user }.to raise_error(Exception)
-    end
-
-    it "should throw an error when the user cannot be found for a given id" do
-      id = user.id + admin.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(Exception)
-
-      set_param(admin, id)
-      expect { current_user }.to raise_error(Exception)
-    end
-
-    it "should throw an error when the user cannot be found for a given username" do
-      username = "#{user.username}#{admin.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(Exception)
-
-      set_param(admin, username)
-      expect { current_user }.to raise_error(Exception)
-    end
-
-    it "should handle sudo's to oneself" do
-      set_env(admin, admin.id)
-      expect(current_user).to eq(admin)
-      set_param(admin, admin.id)
-      expect(current_user).to eq(admin)
-      set_env(admin, admin.username)
-      expect(current_user).to eq(admin)
-      set_param(admin, admin.username)
-      expect(current_user).to eq(admin)
-    end
-
-    it "should handle multiple sudo's to oneself" do
-      set_env(admin, user.id)
-      expect(current_user).to eq(user)
-      expect(current_user).to eq(user)
-      set_env(admin, user.username)
-      expect(current_user).to eq(user)
-      expect(current_user).to eq(user)
-
-      set_param(admin, user.id)
-      expect(current_user).to eq(user)
-      expect(current_user).to eq(user)
-      set_param(admin, user.username)
-      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)
-      expect(current_user).to eq(user)
-      expect(current_user).to eq(user)
-
-      set_param(admin, user.id.to_s)
-      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')
-      expect(sudo_identifier).to eq(123)
-      set_env(admin, '0001234567890')
-      expect(sudo_identifier).to eq(1234567890)
-
-      set_param(admin, '123')
-      expect(sudo_identifier).to eq(123)
-      set_param(admin, '0001234567890')
-      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')
-      expect(sudo_identifier).to eq("12.30")
-      set_env(admin, 'hello')
-      expect(sudo_identifier).to eq('hello')
-      set_env(admin, ' 123')
-      expect(sudo_identifier).to eq(' 123')
-
-      set_param(admin, '12.30')
-      expect(sudo_identifier).to eq("12.30")
-      set_param(admin, 'hello')
-      expect(sudo_identifier).to eq('hello')
-      set_param(admin, ' 123')
-      expect(sudo_identifier).to eq(' 123')
-    end
-  end
-end
-- 
cgit v1.2.1


From e5cf527f279964a8952de544526e8def226b98d7 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Mon, 18 Apr 2016 15:48:54 +0530
Subject: Allow expiration of personal access tokens.

---
 spec/factories/personal_access_tokens.rb     |  9 ++++
 spec/requests/api/api_authentication_spec.rb | 72 +++++++++++++++++++++-------
 2 files changed, 65 insertions(+), 16 deletions(-)
 create mode 100644 spec/factories/personal_access_tokens.rb

(limited to 'spec')

diff --git a/spec/factories/personal_access_tokens.rb b/spec/factories/personal_access_tokens.rb
new file mode 100644
index 00000000000..da4c72bcb5b
--- /dev/null
+++ b/spec/factories/personal_access_tokens.rb
@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  factory :personal_access_token do
+    user
+    token { SecureRandom.hex(50) }
+    name { FFaker::Product.brand }
+    revoked false
+    expires_at { 5.days.from_now }
+  end
+end
diff --git a/spec/requests/api/api_authentication_spec.rb b/spec/requests/api/api_authentication_spec.rb
index 8bed3bb119b..0416e57c68b 100644
--- a/spec/requests/api/api_authentication_spec.rb
+++ b/spec/requests/api/api_authentication_spec.rb
@@ -41,24 +41,64 @@ describe API::Helpers::Authentication, api: true do
   end
 
   describe ".current_user" do
-    it "should return nil for an invalid token" do
-      env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = 'invalid token'
-      allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
-      expect(current_user).to be_nil
+    describe "when authenticating using a user's private token" do
+      it "should return nil for an invalid token" do
+        env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = 'invalid token'
+        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::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = user.private_token
+        allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
+        expect(current_user).to be_nil
+      end
+
+      it "should leave user as is when sudo not specified" do
+        env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = user.private_token
+        expect(current_user).to eq(user)
+        clear_env
+        params[API::Helpers::Authentication::PRIVATE_TOKEN_PARAM] = user.private_token
+        expect(current_user).to eq(user)
+      end
     end
 
-    it "should return nil for a user without access" do
-      env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = user.private_token
-      allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
-      expect(current_user).to be_nil
-    end
-
-    it "should leave user as is when sudo not specified" do
-      env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = user.private_token
-      expect(current_user).to eq(user)
-      clear_env
-      params[API::Helpers::Authentication::PRIVATE_TOKEN_PARAM] = user.private_token
-      expect(current_user).to eq(user)
+    describe "when authenticating using a user's personal access tokens" do
+      let(:personal_access_token) { create(:personal_access_token, user: user) }
+
+      it "should return nil for an invalid token" do
+        env[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = 'invalid token'
+        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::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
+        expect(current_user).to be_nil
+      end
+
+      it "should leave user as is when sudo not specified" do
+        env[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        expect(current_user).to eq(user)
+        clear_env
+        params[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_PARAM] = personal_access_token.token
+        expect(current_user).to eq(user)
+      end
+
+      it 'does not allow revoked tokens' do
+        personal_access_token.revoke!
+        env[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
+        expect(current_user).to be_nil
+      end
+
+      it 'does not allow expired tokens' do
+        personal_access_token.update_attributes!(expires_at: 1.day.ago)
+        env[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
+        expect(current_user).to be_nil
+      end
     end
 
     it "should change current user to sudo when admin" do
-- 
cgit v1.2.1


From ade40fdcd2a4ee879bd2aba939cffaff39c65228 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Tue, 19 Apr 2016 16:22:15 +0530
Subject: Authenticate non-API requests with personal access tokens.

- Rename the `authenticate_user_from_token!` filter to
  `authenticate_user_from_private_token!`
- Add a new `authenticate_user_from_personal_access_token!` filter
- Add tests for both.
---
 spec/controllers/application_controller_spec.rb | 66 +++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

(limited to 'spec')

diff --git a/spec/controllers/application_controller_spec.rb b/spec/controllers/application_controller_spec.rb
index 186239d3096..1ec51465cd3 100644
--- a/spec/controllers/application_controller_spec.rb
+++ b/spec/controllers/application_controller_spec.rb
@@ -30,4 +30,70 @@ describe ApplicationController do
       controller.send(:check_password_expiration)
     end
   end
+
+  describe "#authenticate_user_from_private_token!" do
+    controller(ApplicationController) do
+      def index
+        render text: "authenticated"
+      end
+    end
+
+    let(:user) { create(:user) }
+
+    it "logs the user in when the 'authenticity_token' param is populated with the private token" do
+      get :index, authenticity_token: user.private_token
+      expect(response.status).to eq(200)
+      expect(response.body).to eq("authenticated")
+    end
+
+    it "logs the user in when the 'private_token' param is populated with the private token" do
+      get :index, private_token: user.private_token
+      expect(response.status).to eq(200)
+      expect(response.body).to eq("authenticated")
+    end
+
+    it "logs the user in when the 'PRIVATE-TOKEN' header is populated with the private token" do
+      @request.headers['PRIVATE-TOKEN'] = user.private_token
+      get :index
+      expect(response.status).to eq(200)
+      expect(response.body).to eq("authenticated")
+    end
+
+    it "doesn't log the user in otherwise" do
+      @request.headers['PRIVATE-TOKEN'] = "token"
+      get :index, private_token: "token", authenticity_token: "token"
+      expect(response.status).to_not eq(200)
+      expect(response.body).to_not eq("authenticated")
+    end
+  end
+
+  describe "#authenticate_user_from_personal_access_token!" do
+    controller(ApplicationController) do
+      def index
+        render text: 'authenticated'
+      end
+    end
+
+    let(:user) { create(:user) }
+    let(:personal_access_token) { create(:personal_access_token, user: user) }
+
+    it "logs the user in when the 'personal_access_token' param is populated with the personal access token" do
+      get :index, personal_access_token: personal_access_token.token
+      expect(response.status).to eq(200)
+      expect(response.body).to eq('authenticated')
+    end
+
+    it "logs the user in when the 'PERSONAL_ACCESS_TOKEN' header is populated with the personal access token" do
+      @request.headers["PERSONAL_ACCESS_TOKEN"] = personal_access_token.token
+      get :index
+      expect(response.status).to eq(200)
+      expect(response.body).to eq('authenticated')
+    end
+
+    it "doesn't log the user in otherwise" do
+      get :index, personal_access_token: "token"
+      expect(response.status).to_not eq(200)
+      expect(response.body).to_not eq('authenticated')
+    end
+  end
 end
-- 
cgit v1.2.1


From 25aefde62b0ac57d93ff3a6ddeef3277e40cc7bd Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Wed, 20 Apr 2016 11:58:48 +0530
Subject: Add feature specs for personal access token management.

---
 .../profiles/personal_access_tokens_spec.rb        | 52 ++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 spec/features/profiles/personal_access_tokens_spec.rb

(limited to 'spec')

diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
new file mode 100644
index 00000000000..ce972776ffe
--- /dev/null
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe 'Profile > Personal Access Tokens', feature: true do
+  let(:user) { create(:user) }
+
+  before do
+    login_as(user)
+  end
+
+  describe "token creation" do
+    it "allows creation of a token with an optional expiry date" do
+      visit profile_personal_access_tokens_path
+      fill_in "Name", with: FFaker::Product.brand
+      expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
+
+      active_personal_access_tokens = find(".table.active-personal-access-tokens").native.inner_html
+      expect(active_personal_access_tokens).to match(PersonalAccessToken.last.name)
+      expect(active_personal_access_tokens).to match("Never")
+      expect(active_personal_access_tokens).to match(PersonalAccessToken.last.token)
+
+      fill_in "Name", with: FFaker::Product.brand
+      fill_in "Expires at", with: 5.days.from_now
+      expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
+
+      active_personal_access_tokens = find(".table.active-personal-access-tokens").native.inner_html
+      expect(active_personal_access_tokens).to match(PersonalAccessToken.last.name)
+      expect(active_personal_access_tokens).to match(5.days.from_now.to_date.to_s)
+      expect(active_personal_access_tokens).to match(PersonalAccessToken.last.token)
+    end
+  end
+
+  describe "inactive tokens" do
+    it "allows revocation of an active token" do
+      personal_access_token = create(:personal_access_token, user: user)
+      visit profile_personal_access_tokens_path
+      click_on "Revoke"
+
+      inactive_personal_access_tokens = find(".table.inactive-personal-access-tokens").native.inner_html
+      expect(inactive_personal_access_tokens).to match(personal_access_token.name)
+      expect(inactive_personal_access_tokens).to match(personal_access_token.token)
+    end
+
+    it "moves expired tokens to the 'inactive' section" do
+      personal_access_token = create(:personal_access_token, expires_at: 5.days.ago, user: user)
+      visit profile_personal_access_tokens_path
+
+      inactive_personal_access_tokens = find(".table.inactive-personal-access-tokens").native.inner_html
+      expect(inactive_personal_access_tokens).to match(personal_access_token.name)
+      expect(inactive_personal_access_tokens).to match(personal_access_token.token)
+    end
+  end
+end
-- 
cgit v1.2.1


From b22a47c62e076acddd254e2d659f38261085bf01 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Mon, 25 Apr 2016 09:00:20 +0530
Subject: Combine `API::Helpers::Core` and `API::Helpers::Authentication` back
 into `API::Helpers`

- Makes the MR easier to read; this can go in a separate MR
- This is a (sort of) revert of 99bea01
---
 spec/requests/api/api_authentication_spec.rb | 215 ---------------------------
 spec/requests/api/api_helpers_spec.rb        | 215 +++++++++++++++++++++++++++
 spec/requests/api/users_spec.rb              |   2 +-
 3 files changed, 216 insertions(+), 216 deletions(-)
 delete mode 100644 spec/requests/api/api_authentication_spec.rb
 create mode 100644 spec/requests/api/api_helpers_spec.rb

(limited to 'spec')

diff --git a/spec/requests/api/api_authentication_spec.rb b/spec/requests/api/api_authentication_spec.rb
deleted file mode 100644
index 0416e57c68b..00000000000
--- a/spec/requests/api/api_authentication_spec.rb
+++ /dev/null
@@ -1,215 +0,0 @@
-require 'spec_helper'
-
-describe API::Helpers::Authentication, api: true do
-
-  include API::Helpers::Authentication
-  include ApiHelpers
-
-  let(:user) { create(:user) }
-  let(:admin) { create(:admin) }
-  let(:key) { create(:key, user: user) }
-
-  let(:params) { {} }
-  let(:env) { {} }
-
-  def set_env(token_usr, identifier)
-    clear_env
-    clear_param
-    env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = token_usr.private_token
-    env[API::Helpers::Authentication::SUDO_HEADER] = identifier
-  end
-
-  def set_param(token_usr, identifier)
-    clear_env
-    clear_param
-    params[API::Helpers::Authentication::PRIVATE_TOKEN_PARAM] = token_usr.private_token
-    params[API::Helpers::Authentication::SUDO_PARAM] = identifier
-  end
-
-  def clear_env
-    env.delete(API::Helpers::Authentication::PRIVATE_TOKEN_HEADER)
-    env.delete(API::Helpers::Authentication::SUDO_HEADER)
-  end
-
-  def clear_param
-    params.delete(API::Helpers::Authentication::PRIVATE_TOKEN_PARAM)
-    params.delete(API::Helpers::Authentication::SUDO_PARAM)
-  end
-
-  def error!(message, status)
-    raise Exception
-  end
-
-  describe ".current_user" do
-    describe "when authenticating using a user's private token" do
-      it "should return nil for an invalid token" do
-        env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = 'invalid token'
-        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::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = user.private_token
-        allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
-        expect(current_user).to be_nil
-      end
-
-      it "should leave user as is when sudo not specified" do
-        env[API::Helpers::Authentication::PRIVATE_TOKEN_HEADER] = user.private_token
-        expect(current_user).to eq(user)
-        clear_env
-        params[API::Helpers::Authentication::PRIVATE_TOKEN_PARAM] = user.private_token
-        expect(current_user).to eq(user)
-      end
-    end
-
-    describe "when authenticating using a user's personal access tokens" do
-      let(:personal_access_token) { create(:personal_access_token, user: user) }
-
-      it "should return nil for an invalid token" do
-        env[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = 'invalid token'
-        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::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
-        allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
-        expect(current_user).to be_nil
-      end
-
-      it "should leave user as is when sudo not specified" do
-        env[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
-        expect(current_user).to eq(user)
-        clear_env
-        params[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_PARAM] = personal_access_token.token
-        expect(current_user).to eq(user)
-      end
-
-      it 'does not allow revoked tokens' do
-        personal_access_token.revoke!
-        env[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
-        allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
-        expect(current_user).to be_nil
-      end
-
-      it 'does not allow expired tokens' do
-        personal_access_token.update_attributes!(expires_at: 1.day.ago)
-        env[API::Helpers::Authentication::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
-        allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
-        expect(current_user).to be_nil
-      end
-    end
-
-    it "should change current user to sudo when admin" do
-      set_env(admin, user.id)
-      expect(current_user).to eq(user)
-      set_param(admin, user.id)
-      expect(current_user).to eq(user)
-      set_env(admin, user.username)
-      expect(current_user).to eq(user)
-      set_param(admin, user.username)
-      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
-      set_env(user, admin.id)
-      expect { current_user }.to raise_error(Exception)
-      set_param(user, admin.id)
-      expect { current_user }.to raise_error(Exception)
-      set_env(user, admin.username)
-      expect { current_user }.to raise_error(Exception)
-      set_param(user, admin.username)
-      expect { current_user }.to raise_error(Exception)
-    end
-
-    it "should throw an error when the user cannot be found for a given id" do
-      id = user.id + admin.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(Exception)
-
-      set_param(admin, id)
-      expect { current_user }.to raise_error(Exception)
-    end
-
-    it "should throw an error when the user cannot be found for a given username" do
-      username = "#{user.username}#{admin.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(Exception)
-
-      set_param(admin, username)
-      expect { current_user }.to raise_error(Exception)
-    end
-
-    it "should handle sudo's to oneself" do
-      set_env(admin, admin.id)
-      expect(current_user).to eq(admin)
-      set_param(admin, admin.id)
-      expect(current_user).to eq(admin)
-      set_env(admin, admin.username)
-      expect(current_user).to eq(admin)
-      set_param(admin, admin.username)
-      expect(current_user).to eq(admin)
-    end
-
-    it "should handle multiple sudo's to oneself" do
-      set_env(admin, user.id)
-      expect(current_user).to eq(user)
-      expect(current_user).to eq(user)
-      set_env(admin, user.username)
-      expect(current_user).to eq(user)
-      expect(current_user).to eq(user)
-
-      set_param(admin, user.id)
-      expect(current_user).to eq(user)
-      expect(current_user).to eq(user)
-      set_param(admin, user.username)
-      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)
-      expect(current_user).to eq(user)
-      expect(current_user).to eq(user)
-
-      set_param(admin, user.id.to_s)
-      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')
-      expect(sudo_identifier).to eq(123)
-      set_env(admin, '0001234567890')
-      expect(sudo_identifier).to eq(1234567890)
-
-      set_param(admin, '123')
-      expect(sudo_identifier).to eq(123)
-      set_param(admin, '0001234567890')
-      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')
-      expect(sudo_identifier).to eq("12.30")
-      set_env(admin, 'hello')
-      expect(sudo_identifier).to eq('hello')
-      set_env(admin, ' 123')
-      expect(sudo_identifier).to eq(' 123')
-
-      set_param(admin, '12.30')
-      expect(sudo_identifier).to eq("12.30")
-      set_param(admin, 'hello')
-      expect(sudo_identifier).to eq('hello')
-      set_param(admin, ' 123')
-      expect(sudo_identifier).to eq(' 123')
-    end
-  end
-end
diff --git a/spec/requests/api/api_helpers_spec.rb b/spec/requests/api/api_helpers_spec.rb
new file mode 100644
index 00000000000..06997147b09
--- /dev/null
+++ b/spec/requests/api/api_helpers_spec.rb
@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe API::Helpers, api: true do
+
+  include API::Helpers
+  include ApiHelpers
+
+  let(:user) { create(:user) }
+  let(:admin) { create(:admin) }
+  let(:key) { create(:key, user: user) }
+
+  let(:params) { {} }
+  let(:env) { {} }
+
+  def set_env(token_usr, identifier)
+    clear_env
+    clear_param
+    env[API::Helpers::PRIVATE_TOKEN_HEADER] = token_usr.private_token
+    env[API::Helpers::SUDO_HEADER] = identifier
+  end
+
+  def set_param(token_usr, identifier)
+    clear_env
+    clear_param
+    params[API::Helpers::PRIVATE_TOKEN_PARAM] = token_usr.private_token
+    params[API::Helpers::SUDO_PARAM] = identifier
+  end
+
+  def clear_env
+    env.delete(API::Helpers::PRIVATE_TOKEN_HEADER)
+    env.delete(API::Helpers::SUDO_HEADER)
+  end
+
+  def clear_param
+    params.delete(API::Helpers::PRIVATE_TOKEN_PARAM)
+    params.delete(API::Helpers::SUDO_PARAM)
+  end
+
+  def error!(message, status)
+    raise Exception
+  end
+
+  describe ".current_user" do
+    describe "when authenticating using a user's private token" do
+      it "should return nil for an invalid token" do
+        env[API::Helpers::PRIVATE_TOKEN_HEADER] = 'invalid token'
+        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::Helpers::PRIVATE_TOKEN_HEADER] = user.private_token
+        allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
+        expect(current_user).to be_nil
+      end
+
+      it "should leave user as is when sudo not specified" do
+        env[API::Helpers::PRIVATE_TOKEN_HEADER] = user.private_token
+        expect(current_user).to eq(user)
+        clear_env
+        params[API::Helpers::PRIVATE_TOKEN_PARAM] = user.private_token
+        expect(current_user).to eq(user)
+      end
+    end
+
+    describe "when authenticating using a user's personal access tokens" do
+      let(:personal_access_token) { create(:personal_access_token, user: user) }
+
+      it "should return nil for an invalid token" do
+        env[API::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = 'invalid token'
+        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::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
+        expect(current_user).to be_nil
+      end
+
+      it "should leave user as is when sudo not specified" do
+        env[API::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        expect(current_user).to eq(user)
+        clear_env
+        params[API::Helpers::PERSONAL_ACCESS_TOKEN_PARAM] = personal_access_token.token
+        expect(current_user).to eq(user)
+      end
+
+      it 'does not allow revoked tokens' do
+        personal_access_token.revoke!
+        env[API::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
+        expect(current_user).to be_nil
+      end
+
+      it 'does not allow expired tokens' do
+        personal_access_token.update_attributes!(expires_at: 1.day.ago)
+        env[API::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
+        expect(current_user).to be_nil
+      end
+    end
+
+    it "should change current user to sudo when admin" do
+      set_env(admin, user.id)
+      expect(current_user).to eq(user)
+      set_param(admin, user.id)
+      expect(current_user).to eq(user)
+      set_env(admin, user.username)
+      expect(current_user).to eq(user)
+      set_param(admin, user.username)
+      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
+      set_env(user, admin.id)
+      expect { current_user }.to raise_error(Exception)
+      set_param(user, admin.id)
+      expect { current_user }.to raise_error(Exception)
+      set_env(user, admin.username)
+      expect { current_user }.to raise_error(Exception)
+      set_param(user, admin.username)
+      expect { current_user }.to raise_error(Exception)
+    end
+
+    it "should throw an error when the user cannot be found for a given id" do
+      id = user.id + admin.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(Exception)
+
+      set_param(admin, id)
+      expect { current_user }.to raise_error(Exception)
+    end
+
+    it "should throw an error when the user cannot be found for a given username" do
+      username = "#{user.username}#{admin.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(Exception)
+
+      set_param(admin, username)
+      expect { current_user }.to raise_error(Exception)
+    end
+
+    it "should handle sudo's to oneself" do
+      set_env(admin, admin.id)
+      expect(current_user).to eq(admin)
+      set_param(admin, admin.id)
+      expect(current_user).to eq(admin)
+      set_env(admin, admin.username)
+      expect(current_user).to eq(admin)
+      set_param(admin, admin.username)
+      expect(current_user).to eq(admin)
+    end
+
+    it "should handle multiple sudo's to oneself" do
+      set_env(admin, user.id)
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
+      set_env(admin, user.username)
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
+
+      set_param(admin, user.id)
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
+      set_param(admin, user.username)
+      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)
+      expect(current_user).to eq(user)
+      expect(current_user).to eq(user)
+
+      set_param(admin, user.id.to_s)
+      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')
+      expect(sudo_identifier).to eq(123)
+      set_env(admin, '0001234567890')
+      expect(sudo_identifier).to eq(1234567890)
+
+      set_param(admin, '123')
+      expect(sudo_identifier).to eq(123)
+      set_param(admin, '0001234567890')
+      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')
+      expect(sudo_identifier).to eq("12.30")
+      set_env(admin, 'hello')
+      expect(sudo_identifier).to eq('hello')
+      set_env(admin, ' 123')
+      expect(sudo_identifier).to eq(' 123')
+
+      set_param(admin, '12.30')
+      expect(sudo_identifier).to eq("12.30")
+      set_param(admin, 'hello')
+      expect(sudo_identifier).to eq('hello')
+      set_param(admin, ' 123')
+      expect(sudo_identifier).to eq(' 123')
+    end
+  end
+end
diff --git a/spec/requests/api/users_spec.rb b/spec/requests/api/users_spec.rb
index 628569d3e00..40b24c125b5 100644
--- a/spec/requests/api/users_spec.rb
+++ b/spec/requests/api/users_spec.rb
@@ -24,7 +24,7 @@ describe API::API, api: true  do
       context "when public level is restricted" do
         before do
           stub_application_setting(restricted_visibility_levels: [Gitlab::VisibilityLevel::PUBLIC])
-          allow_any_instance_of(API::Helpers::Authentication).to receive(:authenticate!).and_return(true)
+          allow_any_instance_of(API::Helpers).to receive(:authenticate!).and_return(true)
         end
 
         it "renders 403" do
-- 
cgit v1.2.1


From bafbf22c6ab613d25287d7119d7e30770c531fdb Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Mon, 25 Apr 2016 14:30:59 +0530
Subject: Address @DouweM's feedback on !3749.

- Use `TokenAuthenticatable` to generate the personal access token
- Remove a check for `authenticity_token` in application controller;
  this should've been `authentication_token`, maybe, and doesn't make
  any sense now.
- Have the datepicker appear inline
---
 spec/controllers/application_controller_spec.rb       |  6 ------
 spec/features/profiles/personal_access_tokens_spec.rb | 18 +++++++++++-------
 spec/models/personal_access_token_spec.rb             | 15 +++++++++++++++
 3 files changed, 26 insertions(+), 13 deletions(-)
 create mode 100644 spec/models/personal_access_token_spec.rb

(limited to 'spec')

diff --git a/spec/controllers/application_controller_spec.rb b/spec/controllers/application_controller_spec.rb
index 1ec51465cd3..e8bdbf1afb7 100644
--- a/spec/controllers/application_controller_spec.rb
+++ b/spec/controllers/application_controller_spec.rb
@@ -40,12 +40,6 @@ describe ApplicationController do
 
     let(:user) { create(:user) }
 
-    it "logs the user in when the 'authenticity_token' param is populated with the private token" do
-      get :index, authenticity_token: user.private_token
-      expect(response.status).to eq(200)
-      expect(response.body).to eq("authenticated")
-    end
-
     it "logs the user in when the 'private_token' param is populated with the private token" do
       get :index, private_token: user.private_token
       expect(response.status).to eq(200)
diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index ce972776ffe..e9fbeefae75 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe 'Profile > Personal Access Tokens', feature: true do
+describe 'Profile > Personal Access Tokens', feature: true, js: true do
   let(:user) { create(:user) }
 
   before do
@@ -13,18 +13,22 @@ describe 'Profile > Personal Access Tokens', feature: true do
       fill_in "Name", with: FFaker::Product.brand
       expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
 
-      active_personal_access_tokens = find(".table.active-personal-access-tokens").native.inner_html
+      active_personal_access_tokens = find(".table.active-personal-access-tokens").native['innerHTML']
       expect(active_personal_access_tokens).to match(PersonalAccessToken.last.name)
       expect(active_personal_access_tokens).to match("Never")
       expect(active_personal_access_tokens).to match(PersonalAccessToken.last.token)
 
       fill_in "Name", with: FFaker::Product.brand
-      fill_in "Expires at", with: 5.days.from_now
+
+      # Set date to 1st of next month
+      find("a[title='Next']").click
+      click_on "1"
+
       expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
 
-      active_personal_access_tokens = find(".table.active-personal-access-tokens").native.inner_html
+      active_personal_access_tokens = find(".table.active-personal-access-tokens").native['innerHTML']
       expect(active_personal_access_tokens).to match(PersonalAccessToken.last.name)
-      expect(active_personal_access_tokens).to match(5.days.from_now.to_date.to_s)
+      expect(active_personal_access_tokens).to match(Date.today.next_month.at_beginning_of_month.to_s)
       expect(active_personal_access_tokens).to match(PersonalAccessToken.last.token)
     end
   end
@@ -35,7 +39,7 @@ describe 'Profile > Personal Access Tokens', feature: true do
       visit profile_personal_access_tokens_path
       click_on "Revoke"
 
-      inactive_personal_access_tokens = find(".table.inactive-personal-access-tokens").native.inner_html
+      inactive_personal_access_tokens = find(".table.inactive-personal-access-tokens").native['innerHTML']
       expect(inactive_personal_access_tokens).to match(personal_access_token.name)
       expect(inactive_personal_access_tokens).to match(personal_access_token.token)
     end
@@ -44,7 +48,7 @@ describe 'Profile > Personal Access Tokens', feature: true do
       personal_access_token = create(:personal_access_token, expires_at: 5.days.ago, user: user)
       visit profile_personal_access_tokens_path
 
-      inactive_personal_access_tokens = find(".table.inactive-personal-access-tokens").native.inner_html
+      inactive_personal_access_tokens = find(".table.inactive-personal-access-tokens").native['innerHTML']
       expect(inactive_personal_access_tokens).to match(personal_access_token.name)
       expect(inactive_personal_access_tokens).to match(personal_access_token.token)
     end
diff --git a/spec/models/personal_access_token_spec.rb b/spec/models/personal_access_token_spec.rb
new file mode 100644
index 00000000000..3e80a48175a
--- /dev/null
+++ b/spec/models/personal_access_token_spec.rb
@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe PersonalAccessToken, models: true do
+  describe ".generate" do
+    it "generates a random token" do
+      personal_access_token = PersonalAccessToken.generate({})
+      expect(personal_access_token.token).to be_present
+    end
+
+    it "doesn't save the record" do
+      personal_access_token = PersonalAccessToken.generate({})
+      expect(personal_access_token).to_not be_persisted
+    end
+  end
+end
-- 
cgit v1.2.1


From d915e7d5cad99b8971e65d30accc8bc7a05fecbc Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Wed, 11 May 2016 10:16:23 +0530
Subject: Reuse the private token param and header for personal access tokens.

- https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/3749#note_11626427
- Personal access tokens are still a separate entity as far as the
  codebase is concerned - they just happen to use the same entry point
  as private tokens.
- Update tests and documentation to reflect this change
---
 spec/controllers/application_controller_spec.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'spec')

diff --git a/spec/controllers/application_controller_spec.rb b/spec/controllers/application_controller_spec.rb
index e8bdbf1afb7..d7835dc6e2b 100644
--- a/spec/controllers/application_controller_spec.rb
+++ b/spec/controllers/application_controller_spec.rb
@@ -72,20 +72,20 @@ describe ApplicationController do
     let(:personal_access_token) { create(:personal_access_token, user: user) }
 
     it "logs the user in when the 'personal_access_token' param is populated with the personal access token" do
-      get :index, personal_access_token: personal_access_token.token
+      get :index, private_token: personal_access_token.token
       expect(response.status).to eq(200)
       expect(response.body).to eq('authenticated')
     end
 
     it "logs the user in when the 'PERSONAL_ACCESS_TOKEN' header is populated with the personal access token" do
-      @request.headers["PERSONAL_ACCESS_TOKEN"] = personal_access_token.token
+      @request.headers["PRIVATE-TOKEN"] = personal_access_token.token
       get :index
       expect(response.status).to eq(200)
       expect(response.body).to eq('authenticated')
     end
 
     it "doesn't log the user in otherwise" do
-      get :index, personal_access_token: "token"
+      get :index, private_token: "token"
       expect(response.status).to_not eq(200)
       expect(response.body).to_not eq('authenticated')
     end
-- 
cgit v1.2.1


From 05b319b0b45288cbbe0bce15bf7bed7f58f6cf76 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Wed, 1 Jun 2016 14:04:38 +0530
Subject: Perform private token and personal access token authentication in the
 same `before_action`.

- So that the check for valid personal access tokens happens only if
  private token auth fails.
---
 spec/controllers/application_controller_spec.rb | 92 +++++++++++++------------
 1 file changed, 47 insertions(+), 45 deletions(-)

(limited to 'spec')

diff --git a/spec/controllers/application_controller_spec.rb b/spec/controllers/application_controller_spec.rb
index d7835dc6e2b..90dbd1183eb 100644
--- a/spec/controllers/application_controller_spec.rb
+++ b/spec/controllers/application_controller_spec.rb
@@ -31,63 +31,65 @@ describe ApplicationController do
     end
   end
 
-  describe "#authenticate_user_from_private_token!" do
-    controller(ApplicationController) do
-      def index
-        render text: "authenticated"
+  describe "#authenticate_user_from_token!" do
+    describe "authenticating a user from a private token" do
+      controller(ApplicationController) do
+        def index
+          render text: "authenticated"
+        end
       end
-    end
 
-    let(:user) { create(:user) }
+      let(:user) { create(:user) }
 
-    it "logs the user in when the 'private_token' param is populated with the private token" do
-      get :index, private_token: user.private_token
-      expect(response.status).to eq(200)
-      expect(response.body).to eq("authenticated")
-    end
+      it "logs the user in when the 'private_token' param is populated with the private token" do
+        get :index, private_token: user.private_token
+        expect(response.status).to eq(200)
+        expect(response.body).to eq("authenticated")
+      end
 
-    it "logs the user in when the 'PRIVATE-TOKEN' header is populated with the private token" do
-      @request.headers['PRIVATE-TOKEN'] = user.private_token
-      get :index
-      expect(response.status).to eq(200)
-      expect(response.body).to eq("authenticated")
-    end
+      it "logs the user in when the 'PRIVATE-TOKEN' header is populated with the private token" do
+        @request.headers['PRIVATE-TOKEN'] = user.private_token
+        get :index
+        expect(response.status).to eq(200)
+        expect(response.body).to eq("authenticated")
+      end
 
-    it "doesn't log the user in otherwise" do
-      @request.headers['PRIVATE-TOKEN'] = "token"
-      get :index, private_token: "token", authenticity_token: "token"
-      expect(response.status).to_not eq(200)
-      expect(response.body).to_not eq("authenticated")
+      it "doesn't log the user in otherwise" do
+        @request.headers['PRIVATE-TOKEN'] = "token"
+        get :index, private_token: "token", authenticity_token: "token"
+        expect(response.status).to_not eq(200)
+        expect(response.body).to_not eq("authenticated")
+      end
     end
-  end
 
-  describe "#authenticate_user_from_personal_access_token!" do
-    controller(ApplicationController) do
-      def index
-        render text: 'authenticated'
+    describe "authenticating a user from a personal access token" do
+      controller(ApplicationController) do
+        def index
+          render text: 'authenticated'
+        end
       end
-    end
 
-    let(:user) { create(:user) }
-    let(:personal_access_token) { create(:personal_access_token, user: user) }
+      let(:user) { create(:user) }
+      let(:personal_access_token) { create(:personal_access_token, user: user) }
 
-    it "logs the user in when the 'personal_access_token' param is populated with the personal access token" do
-      get :index, private_token: personal_access_token.token
-      expect(response.status).to eq(200)
-      expect(response.body).to eq('authenticated')
-    end
+      it "logs the user in when the 'personal_access_token' param is populated with the personal access token" do
+        get :index, private_token: personal_access_token.token
+        expect(response.status).to eq(200)
+        expect(response.body).to eq('authenticated')
+      end
 
-    it "logs the user in when the 'PERSONAL_ACCESS_TOKEN' header is populated with the personal access token" do
-      @request.headers["PRIVATE-TOKEN"] = personal_access_token.token
-      get :index
-      expect(response.status).to eq(200)
-      expect(response.body).to eq('authenticated')
-    end
+      it "logs the user in when the 'PERSONAL_ACCESS_TOKEN' header is populated with the personal access token" do
+        @request.headers["PRIVATE-TOKEN"] = personal_access_token.token
+        get :index
+        expect(response.status).to eq(200)
+        expect(response.body).to eq('authenticated')
+      end
 
-    it "doesn't log the user in otherwise" do
-      get :index, private_token: "token"
-      expect(response.status).to_not eq(200)
-      expect(response.body).to_not eq('authenticated')
+      it "doesn't log the user in otherwise" do
+        get :index, private_token: "token"
+        expect(response.status).to_not eq(200)
+        expect(response.body).to_not eq('authenticated')
+      end
     end
   end
 end
-- 
cgit v1.2.1


From 4d50d8a6e3b8ae1521617df32af4cad18385fb9f Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Thu, 2 Jun 2016 08:27:47 +0530
Subject: Only show a personal access token right after its creation.

---
 .../profiles/personal_access_tokens_spec.rb        | 32 ++++++++++++++--------
 1 file changed, 20 insertions(+), 12 deletions(-)

(limited to 'spec')

diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index e9fbeefae75..095c7d60e29 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -3,21 +3,35 @@ require 'spec_helper'
 describe 'Profile > Personal Access Tokens', feature: true, js: true do
   let(:user) { create(:user) }
 
+  def active_personal_access_tokens
+    find(".table.active-personal-access-tokens").native['innerHTML']
+  end
+
+  def inactive_personal_access_tokens
+    find(".table.inactive-personal-access-tokens").native['innerHTML']
+  end
+
+  def created_personal_access_token
+    find(".created-personal-access-token pre").native['innerHTML']
+  end
+
   before do
     login_as(user)
   end
 
   describe "token creation" do
-    it "allows creation of a token with an optional expiry date" do
+    it "allows creation of a token" do
       visit profile_personal_access_tokens_path
       fill_in "Name", with: FFaker::Product.brand
-      expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
 
-      active_personal_access_tokens = find(".table.active-personal-access-tokens").native['innerHTML']
+      expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
+      expect(created_personal_access_token).to eq(PersonalAccessToken.last.token)
       expect(active_personal_access_tokens).to match(PersonalAccessToken.last.name)
       expect(active_personal_access_tokens).to match("Never")
-      expect(active_personal_access_tokens).to match(PersonalAccessToken.last.token)
+    end
 
+    it "allows creation of a token with an expiry date" do
+      visit profile_personal_access_tokens_path
       fill_in "Name", with: FFaker::Product.brand
 
       # Set date to 1st of next month
@@ -25,11 +39,9 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       click_on "1"
 
       expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
-
-      active_personal_access_tokens = find(".table.active-personal-access-tokens").native['innerHTML']
+      expect(created_personal_access_token).to eq(PersonalAccessToken.last.token)
       expect(active_personal_access_tokens).to match(PersonalAccessToken.last.name)
-      expect(active_personal_access_tokens).to match(Date.today.next_month.at_beginning_of_month.to_s)
-      expect(active_personal_access_tokens).to match(PersonalAccessToken.last.token)
+      expect(active_personal_access_tokens).to match(Date.today.next_month.at_beginning_of_month.to_s(:medium))
     end
   end
 
@@ -39,18 +51,14 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       visit profile_personal_access_tokens_path
       click_on "Revoke"
 
-      inactive_personal_access_tokens = find(".table.inactive-personal-access-tokens").native['innerHTML']
       expect(inactive_personal_access_tokens).to match(personal_access_token.name)
-      expect(inactive_personal_access_tokens).to match(personal_access_token.token)
     end
 
     it "moves expired tokens to the 'inactive' section" do
       personal_access_token = create(:personal_access_token, expires_at: 5.days.ago, user: user)
       visit profile_personal_access_tokens_path
 
-      inactive_personal_access_tokens = find(".table.inactive-personal-access-tokens").native['innerHTML']
       expect(inactive_personal_access_tokens).to match(personal_access_token.name)
-      expect(inactive_personal_access_tokens).to match(personal_access_token.token)
     end
   end
 end
-- 
cgit v1.2.1


From a1295d8ebef223eb0a87bc9e1660efcb9147599c Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Fri, 3 Jun 2016 08:58:15 +0530
Subject: Don't use `natve['innerHTML']` in the feature spec.

- The `have_text` matcher works fine.
---
 .../profiles/personal_access_tokens_spec.rb        | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

(limited to 'spec')

diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index 095c7d60e29..14f2a7c9a25 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -4,15 +4,15 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
   let(:user) { create(:user) }
 
   def active_personal_access_tokens
-    find(".table.active-personal-access-tokens").native['innerHTML']
+    find(".table.active-personal-access-tokens")
   end
 
   def inactive_personal_access_tokens
-    find(".table.inactive-personal-access-tokens").native['innerHTML']
+    find(".table.inactive-personal-access-tokens")
   end
 
   def created_personal_access_token
-    find(".created-personal-access-token pre").native['innerHTML']
+    find(".created-personal-access-token pre")
   end
 
   before do
@@ -25,9 +25,9 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       fill_in "Name", with: FFaker::Product.brand
 
       expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
-      expect(created_personal_access_token).to eq(PersonalAccessToken.last.token)
-      expect(active_personal_access_tokens).to match(PersonalAccessToken.last.name)
-      expect(active_personal_access_tokens).to match("Never")
+      expect(created_personal_access_token).to have_text(PersonalAccessToken.last.token)
+      expect(active_personal_access_tokens).to have_text(PersonalAccessToken.last.name)
+      expect(active_personal_access_tokens).to have_text("Never")
     end
 
     it "allows creation of a token with an expiry date" do
@@ -39,9 +39,9 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       click_on "1"
 
       expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
-      expect(created_personal_access_token).to eq(PersonalAccessToken.last.token)
-      expect(active_personal_access_tokens).to match(PersonalAccessToken.last.name)
-      expect(active_personal_access_tokens).to match(Date.today.next_month.at_beginning_of_month.to_s(:medium))
+      expect(created_personal_access_token).to have_text(PersonalAccessToken.last.token)
+      expect(active_personal_access_tokens).to have_text(PersonalAccessToken.last.name)
+      expect(active_personal_access_tokens).to have_text(Date.today.next_month.at_beginning_of_month.to_s(:medium))
     end
   end
 
@@ -51,14 +51,14 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       visit profile_personal_access_tokens_path
       click_on "Revoke"
 
-      expect(inactive_personal_access_tokens).to match(personal_access_token.name)
+      expect(inactive_personal_access_tokens).to have_text(personal_access_token.name)
     end
 
     it "moves expired tokens to the 'inactive' section" do
       personal_access_token = create(:personal_access_token, expires_at: 5.days.ago, user: user)
       visit profile_personal_access_tokens_path
 
-      expect(inactive_personal_access_tokens).to match(personal_access_token.name)
+      expect(inactive_personal_access_tokens).to have_text(personal_access_token.name)
     end
   end
 end
-- 
cgit v1.2.1


From b4b024857783e1fc39424fdf631b722ee1dfd195 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Fri, 3 Jun 2016 09:00:39 +0530
Subject: Parts of spec names with "when" should be contexts.

---
 spec/controllers/application_controller_spec.rb | 45 +++++++++++++++----------
 1 file changed, 27 insertions(+), 18 deletions(-)

(limited to 'spec')

diff --git a/spec/controllers/application_controller_spec.rb b/spec/controllers/application_controller_spec.rb
index 90dbd1183eb..ff596e7c2ad 100644
--- a/spec/controllers/application_controller_spec.rb
+++ b/spec/controllers/application_controller_spec.rb
@@ -41,17 +41,22 @@ describe ApplicationController do
 
       let(:user) { create(:user) }
 
-      it "logs the user in when the 'private_token' param is populated with the private token" do
-        get :index, private_token: user.private_token
-        expect(response.status).to eq(200)
-        expect(response.body).to eq("authenticated")
+      context "when the 'private_token' param is populated with the private token" do
+        it "logs the user in" do
+          get :index, private_token: user.private_token
+          expect(response.status).to eq(200)
+          expect(response.body).to eq("authenticated")
+        end
       end
 
-      it "logs the user in when the 'PRIVATE-TOKEN' header is populated with the private token" do
-        @request.headers['PRIVATE-TOKEN'] = user.private_token
-        get :index
-        expect(response.status).to eq(200)
-        expect(response.body).to eq("authenticated")
+
+      context "when the 'PRIVATE-TOKEN' header is populated with the private token" do
+        it "logs the user in" do
+          @request.headers['PRIVATE-TOKEN'] = user.private_token
+          get :index
+          expect(response.status).to eq(200)
+          expect(response.body).to eq("authenticated")
+        end
       end
 
       it "doesn't log the user in otherwise" do
@@ -72,17 +77,21 @@ describe ApplicationController do
       let(:user) { create(:user) }
       let(:personal_access_token) { create(:personal_access_token, user: user) }
 
-      it "logs the user in when the 'personal_access_token' param is populated with the personal access token" do
-        get :index, private_token: personal_access_token.token
-        expect(response.status).to eq(200)
-        expect(response.body).to eq('authenticated')
+      context "when the 'personal_access_token' param is populated with the personal access token" do
+        it "logs the user in" do
+          get :index, private_token: personal_access_token.token
+          expect(response.status).to eq(200)
+          expect(response.body).to eq('authenticated')
+        end
       end
 
-      it "logs the user in when the 'PERSONAL_ACCESS_TOKEN' header is populated with the personal access token" do
-        @request.headers["PRIVATE-TOKEN"] = personal_access_token.token
-        get :index
-        expect(response.status).to eq(200)
-        expect(response.body).to eq('authenticated')
+      context "when the 'PERSONAL_ACCESS_TOKEN' header is populated with the personal access token" do
+        it "logs the user in" do
+          @request.headers["PRIVATE-TOKEN"] = personal_access_token.token
+          get :index
+          expect(response.status).to eq(200)
+          expect(response.body).to eq('authenticated')
+        end
       end
 
       it "doesn't log the user in otherwise" do
-- 
cgit v1.2.1


From 3adf125a155fd04fbba4f0882c739eae1cc73e15 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Fri, 3 Jun 2016 09:53:49 +0530
Subject: Add tests for errors while creating/revoking personal access tokens.

---
 .../profiles/personal_access_tokens_spec.rb        | 33 ++++++++++++++++++++--
 1 file changed, 31 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index 14f2a7c9a25..5bba08d005c 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -15,6 +15,12 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
     find(".created-personal-access-token pre")
   end
 
+  def disallow_personal_access_token_saves!
+    allow_any_instance_of(PersonalAccessToken).to receive(:save).and_return(false)
+    errors = ActiveModel::Errors.new(PersonalAccessToken.new).tap { |e| e.add(:name, "cannot be nil") }
+    allow_any_instance_of(PersonalAccessToken).to receive(:errors).and_return(errors)
+  end
+
   before do
     login_as(user)
   end
@@ -43,11 +49,23 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       expect(active_personal_access_tokens).to have_text(PersonalAccessToken.last.name)
       expect(active_personal_access_tokens).to have_text(Date.today.next_month.at_beginning_of_month.to_s(:medium))
     end
+
+    context "when creation fails" do
+      it "displays an error message" do
+        disallow_personal_access_token_saves!
+        visit profile_personal_access_tokens_path
+        fill_in "Name", with: FFaker::Product.brand
+
+        expect { click_on "Add Personal Access Token" }.not_to change { PersonalAccessToken.count }
+        expect(page).to have_content("Name cannot be nil")
+      end
+    end
   end
 
   describe "inactive tokens" do
+    let!(:personal_access_token) { create(:personal_access_token, user: user) }
+
     it "allows revocation of an active token" do
-      personal_access_token = create(:personal_access_token, user: user)
       visit profile_personal_access_tokens_path
       click_on "Revoke"
 
@@ -55,10 +73,21 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
     end
 
     it "moves expired tokens to the 'inactive' section" do
-      personal_access_token = create(:personal_access_token, expires_at: 5.days.ago, user: user)
+      personal_access_token.update(expires_at: 5.days.ago)
       visit profile_personal_access_tokens_path
 
       expect(inactive_personal_access_tokens).to have_text(personal_access_token.name)
     end
+
+    context "when revocation fails" do
+      it "displays an error message" do
+        disallow_personal_access_token_saves!
+        visit profile_personal_access_tokens_path
+
+        expect { click_on "Revoke" }.not_to change { PersonalAccessToken.inactive.count }
+        expect(active_personal_access_tokens).to have_text(personal_access_token.name)
+        expect(page).to have_content("Could not revoke")
+      end
+    end
   end
 end
-- 
cgit v1.2.1


From 0dff6fd7148957fa94d2626e3912cd929ba150d3 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Fri, 3 Jun 2016 10:10:58 +0530
Subject: Fix rubocop spec.

---
 spec/controllers/application_controller_spec.rb | 8 ++++----
 spec/models/personal_access_token_spec.rb       | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'spec')

diff --git a/spec/controllers/application_controller_spec.rb b/spec/controllers/application_controller_spec.rb
index ff596e7c2ad..ff5b3916273 100644
--- a/spec/controllers/application_controller_spec.rb
+++ b/spec/controllers/application_controller_spec.rb
@@ -62,8 +62,8 @@ describe ApplicationController do
       it "doesn't log the user in otherwise" do
         @request.headers['PRIVATE-TOKEN'] = "token"
         get :index, private_token: "token", authenticity_token: "token"
-        expect(response.status).to_not eq(200)
-        expect(response.body).to_not eq("authenticated")
+        expect(response.status).not_to eq(200)
+        expect(response.body).not_to eq("authenticated")
       end
     end
 
@@ -96,8 +96,8 @@ describe ApplicationController do
 
       it "doesn't log the user in otherwise" do
         get :index, private_token: "token"
-        expect(response.status).to_not eq(200)
-        expect(response.body).to_not eq('authenticated')
+        expect(response.status).not_to eq(200)
+        expect(response.body).not_to eq('authenticated')
       end
     end
   end
diff --git a/spec/models/personal_access_token_spec.rb b/spec/models/personal_access_token_spec.rb
index 3e80a48175a..46eb71cef14 100644
--- a/spec/models/personal_access_token_spec.rb
+++ b/spec/models/personal_access_token_spec.rb
@@ -9,7 +9,7 @@ describe PersonalAccessToken, models: true do
 
     it "doesn't save the record" do
       personal_access_token = PersonalAccessToken.generate({})
-      expect(personal_access_token).to_not be_persisted
+      expect(personal_access_token).not_to be_persisted
     end
   end
 end
-- 
cgit v1.2.1


From af2f56f8f742e00ddb298fadea763fd0fe7054f0 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Thu, 2 Jun 2016 12:39:15 +0200
Subject: Refactor ci commit pipeline to prevent implicit saves

---
 spec/services/create_commit_builds_service_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/services/create_commit_builds_service_spec.rb b/spec/services/create_commit_builds_service_spec.rb
index 9ae8f31b372..e643991e0b9 100644
--- a/spec/services/create_commit_builds_service_spec.rb
+++ b/spec/services/create_commit_builds_service_spec.rb
@@ -81,7 +81,7 @@ describe CreateCommitBuildsService, services: true do
       expect(commit.yaml_errors).not_to be_nil
     end
 
-    describe :ci_skip? do
+    context 'when commit contains a [ci skip] directive' do
       let(:message) { "some message[ci skip]" }
 
       before do
-- 
cgit v1.2.1


From 1bcb61dd2076995b5fed786133f94def1fd637a5 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Thu, 2 Jun 2016 13:38:30 +0200
Subject: Add specs covering case when there are no builds

---
 spec/services/create_commit_builds_service_spec.rb | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'spec')

diff --git a/spec/services/create_commit_builds_service_spec.rb b/spec/services/create_commit_builds_service_spec.rb
index e643991e0b9..8c6b602ac83 100644
--- a/spec/services/create_commit_builds_service_spec.rb
+++ b/spec/services/create_commit_builds_service_spec.rb
@@ -171,5 +171,23 @@ describe CreateCommitBuildsService, services: true do
       expect(commit.status).to eq("failed")
       expect(commit.builds.any?).to be false
     end
+
+    context 'when there are no jobs for this pipeline' do
+      before do
+        config = YAML.dump({ test: { deploy: 'ls', only: ['feature'] } })
+        stub_ci_commit_yaml_file(config)
+      end
+
+      it 'does not create a new pipeline' do
+        result = service.execute(project, user,
+                                 ref: 'refs/heads/master',
+                                 before: '00000000',
+                                 after: '31das312',
+                                 commits: [{ message: 'some msg'}])
+
+        expect(result).to be false
+        expect(Ci::Build.all).to be_empty
+      end
+    end
   end
 end
-- 
cgit v1.2.1


From 0d19abf450d26fa76a23aaae38d392ecdef4e1e0 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Thu, 2 Jun 2016 13:52:19 +0200
Subject: Add minor improvements in create builds service

---
 spec/services/create_commit_builds_service_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/services/create_commit_builds_service_spec.rb b/spec/services/create_commit_builds_service_spec.rb
index 8c6b602ac83..dc915e9dd77 100644
--- a/spec/services/create_commit_builds_service_spec.rb
+++ b/spec/services/create_commit_builds_service_spec.rb
@@ -183,7 +183,7 @@ describe CreateCommitBuildsService, services: true do
                                  ref: 'refs/heads/master',
                                  before: '00000000',
                                  after: '31das312',
-                                 commits: [{ message: 'some msg'}])
+                                 commits: [{ message: 'some msg'} ])
 
         expect(result).to be false
         expect(Ci::Build.all).to be_empty
-- 
cgit v1.2.1


From 53fe06efde46acd2df62f818c421ecf3a0b971c9 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Thu, 2 Jun 2016 14:41:48 +0200
Subject: Update ci commit pipeline specs according to changes

---
 spec/models/ci/commit_spec.rb                      | 16 ++++++++--------
 spec/services/create_commit_builds_service_spec.rb |  2 +-
 2 files changed, 9 insertions(+), 9 deletions(-)

(limited to 'spec')

diff --git a/spec/models/ci/commit_spec.rb b/spec/models/ci/commit_spec.rb
index 22f8639e5ab..0939eb946ac 100644
--- a/spec/models/ci/commit_spec.rb
+++ b/spec/models/ci/commit_spec.rb
@@ -346,9 +346,9 @@ describe Ci::Commit, models: true do
     end
   end
 
-  describe '#update_state' do
-    it 'execute update_state after touching object' do
-      expect(commit).to receive(:update_state).and_return(true)
+  describe '#update_state!' do
+    it 'execute update_state! after touching object' do
+      expect(commit).to receive(:update_state!).and_return(true)
       commit.touch
     end
 
@@ -356,17 +356,17 @@ describe Ci::Commit, models: true do
       let(:commit_status) { build :commit_status, commit: commit }
 
       it 'execute update_state after saving dependent object' do
-        expect(commit).to receive(:update_state).and_return(true)
+        expect(commit).to receive(:update_state!).and_return(true)
         commit_status.save
       end
     end
 
     context 'update state' do
       let(:current) { Time.now.change(usec: 0) }
-      let(:build) { FactoryGirl.create :ci_build, :success, commit: commit, started_at: current - 120, finished_at: current - 60 }
-
-      before do
-        build
+      let!(:build) do
+        create :ci_build, :success, commit: commit,
+                                    started_at: current - 120,
+                                    finished_at: current - 60
       end
 
       [:status, :started_at, :finished_at, :duration].each do |param|
diff --git a/spec/services/create_commit_builds_service_spec.rb b/spec/services/create_commit_builds_service_spec.rb
index dc915e9dd77..b116e3e8fb4 100644
--- a/spec/services/create_commit_builds_service_spec.rb
+++ b/spec/services/create_commit_builds_service_spec.rb
@@ -183,7 +183,7 @@ describe CreateCommitBuildsService, services: true do
                                  ref: 'refs/heads/master',
                                  before: '00000000',
                                  after: '31das312',
-                                 commits: [{ message: 'some msg'} ])
+                                 commits: [{ message: 'some msg' }])
 
         expect(result).to be false
         expect(Ci::Build.all).to be_empty
-- 
cgit v1.2.1


From 07af37a243ea0d6b5741754ea116044ee46614b3 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Thu, 2 Jun 2016 15:55:38 +0200
Subject: Do not create pipeline objects when no builds

---
 spec/services/ci/create_builds_service_spec.rb | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/services/ci/create_builds_service_spec.rb b/spec/services/ci/create_builds_service_spec.rb
index ecc3a88a262..8e737fd44f9 100644
--- a/spec/services/ci/create_builds_service_spec.rb
+++ b/spec/services/ci/create_builds_service_spec.rb
@@ -9,7 +9,7 @@ describe Ci::CreateBuildsService, services: true do
     #
 
     subject do
-      described_class.new(commit).execute(commit, nil, user, status)
+      described_class.new(commit).execute('test', user, status, nil)
     end
 
     context 'next builds available' do
@@ -17,6 +17,10 @@ describe Ci::CreateBuildsService, services: true do
 
       it { is_expected.to be_an_instance_of Array }
       it { is_expected.to all(be_an_instance_of Ci::Build) }
+
+      it 'does not persist created builds' do
+        expect(subject.first).not_to be_persisted
+      end
     end
 
     context 'builds skipped' do
-- 
cgit v1.2.1


From c6bce7e63c305d07dbc91d032df9c783e0cf0c9f Mon Sep 17 00:00:00 2001
From: Kamil Trzcinski <ayufan@ayufan.eu>
Date: Thu, 2 Jun 2016 17:17:23 +0200
Subject: Save Ci::Commit object to persist all created builds

---
 spec/models/ci/commit_spec.rb       | 8 ++++++--
 spec/requests/ci/api/builds_spec.rb | 5 +++++
 2 files changed, 11 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/models/ci/commit_spec.rb b/spec/models/ci/commit_spec.rb
index 0939eb946ac..07b875e4f88 100644
--- a/spec/models/ci/commit_spec.rb
+++ b/spec/models/ci/commit_spec.rb
@@ -55,11 +55,15 @@ describe Ci::Commit, models: true do
     let!(:commit) { FactoryGirl.create :ci_commit, project: project, ref: 'master', tag: false }
 
     def create_builds(trigger_request = nil)
-      commit.create_builds(nil, trigger_request)
+      if commit.create_builds(nil, trigger_request)
+        commit.save
+      end
     end
 
     def create_next_builds
-      commit.create_next_builds(commit.builds.order(:id).last)
+      if commit.create_next_builds(commit.builds.order(:id).last)
+        commit.save
+      end
     end
 
     it 'creates builds' do
diff --git a/spec/requests/ci/api/builds_spec.rb b/spec/requests/ci/api/builds_spec.rb
index e5124ea5ea7..7eff8048667 100644
--- a/spec/requests/ci/api/builds_spec.rb
+++ b/spec/requests/ci/api/builds_spec.rb
@@ -22,6 +22,7 @@ describe Ci::API::API do
       it "should start a build" do
         commit = FactoryGirl.create(:ci_commit, project: project, ref: 'master')
         commit.create_builds(nil)
+        commit.save
         build = commit.builds.first
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
@@ -58,6 +59,7 @@ describe Ci::API::API do
       it "returns options" do
         commit = FactoryGirl.create(:ci_commit, project: project, ref: 'master')
         commit.create_builds(nil)
+        commit.save
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
 
@@ -68,6 +70,7 @@ describe Ci::API::API do
       it "returns variables" do
         commit = FactoryGirl.create(:ci_commit, project: project, ref: 'master')
         commit.create_builds(nil)
+        commit.save
         project.variables << Ci::Variable.new(key: "SECRET_KEY", value: "secret_value")
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
@@ -87,6 +90,7 @@ describe Ci::API::API do
 
         trigger_request = FactoryGirl.create(:ci_trigger_request_with_variables, commit: commit, trigger: trigger)
         commit.create_builds(nil, trigger_request)
+        commit.save
         project.variables << Ci::Variable.new(key: "SECRET_KEY", value: "secret_value")
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
@@ -105,6 +109,7 @@ describe Ci::API::API do
       it "returns dependent builds" do
         commit = FactoryGirl.create(:ci_commit, project: project, ref: 'master')
         commit.create_builds(nil, nil)
+        commit.save
         commit.builds.where(stage: 'test').each(&:success)
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
-- 
cgit v1.2.1


From 8e811f2c6c4c74a30789ff5213de5ebc28897753 Mon Sep 17 00:00:00 2001
From: Kamil Trzcinski <ayufan@ayufan.eu>
Date: Thu, 2 Jun 2016 21:02:52 +0200
Subject: Update CreateCommitBuildsService to pass tests

---
 spec/models/ci/commit_spec.rb                      | 6 +++---
 spec/services/create_commit_builds_service_spec.rb | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

(limited to 'spec')

diff --git a/spec/models/ci/commit_spec.rb b/spec/models/ci/commit_spec.rb
index 07b875e4f88..d36aca113a1 100644
--- a/spec/models/ci/commit_spec.rb
+++ b/spec/models/ci/commit_spec.rb
@@ -351,8 +351,8 @@ describe Ci::Commit, models: true do
   end
 
   describe '#update_state!' do
-    it 'execute update_state! after touching object' do
-      expect(commit).to receive(:update_state!).and_return(true)
+    it 'execute update_state after touching object' do
+      expect(commit).to receive(:update_state).and_return(true)
       commit.touch
     end
 
@@ -360,7 +360,7 @@ describe Ci::Commit, models: true do
       let(:commit_status) { build :commit_status, commit: commit }
 
       it 'execute update_state after saving dependent object' do
-        expect(commit).to receive(:update_state!).and_return(true)
+        expect(commit).to receive(:update_state).and_return(true)
         commit_status.save
       end
     end
diff --git a/spec/services/create_commit_builds_service_spec.rb b/spec/services/create_commit_builds_service_spec.rb
index b116e3e8fb4..e3202c959d9 100644
--- a/spec/services/create_commit_builds_service_spec.rb
+++ b/spec/services/create_commit_builds_service_spec.rb
@@ -60,7 +60,7 @@ describe CreateCommitBuildsService, services: true do
                                after: '31das312',
                                commits: [{ message: 'Message' }]
                               )
-      expect(result).to be_falsey
+      expect(result).not_to be_persisted
       expect(Ci::Commit.count).to eq(0)
     end
 
@@ -174,7 +174,7 @@ describe CreateCommitBuildsService, services: true do
 
     context 'when there are no jobs for this pipeline' do
       before do
-        config = YAML.dump({ test: { deploy: 'ls', only: ['feature'] } })
+        config = YAML.dump({ test: { script: 'ls', only: ['feature'] } })
         stub_ci_commit_yaml_file(config)
       end
 
@@ -184,9 +184,9 @@ describe CreateCommitBuildsService, services: true do
                                  before: '00000000',
                                  after: '31das312',
                                  commits: [{ message: 'some msg' }])
-
-        expect(result).to be false
+        expect(result).not_to be_persisted
         expect(Ci::Build.all).to be_empty
+        expect(Ci::Commit.count).to eq(0)
       end
     end
   end
-- 
cgit v1.2.1


From 681b472c36d5079b620b93957d62dbacc473bf6f Mon Sep 17 00:00:00 2001
From: Kamil Trzcinski <ayufan@ayufan.eu>
Date: Thu, 2 Jun 2016 21:04:45 +0200
Subject: Update specs describe

---
 spec/models/ci/commit_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/models/ci/commit_spec.rb b/spec/models/ci/commit_spec.rb
index d36aca113a1..a4549d40461 100644
--- a/spec/models/ci/commit_spec.rb
+++ b/spec/models/ci/commit_spec.rb
@@ -350,7 +350,7 @@ describe Ci::Commit, models: true do
     end
   end
 
-  describe '#update_state!' do
+  describe '#update_state' do
     it 'execute update_state after touching object' do
       expect(commit).to receive(:update_state).and_return(true)
       commit.touch
-- 
cgit v1.2.1


From a21d084ded6cdf5b83163d4d72bb5c636218d091 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Fri, 3 Jun 2016 10:01:00 +0200
Subject: Fix specs for pipeline create for merge requests

---
 spec/features/merge_requests/created_from_fork_spec.rb | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/features/merge_requests/created_from_fork_spec.rb b/spec/features/merge_requests/created_from_fork_spec.rb
index edc0bdec3db..16c572b3197 100644
--- a/spec/features/merge_requests/created_from_fork_spec.rb
+++ b/spec/features/merge_requests/created_from_fork_spec.rb
@@ -34,7 +34,10 @@ feature 'Merge request created from fork' do
                                        ref: merge_request.source_branch)
     end
 
-    background { pipeline.create_builds(user) }
+    background do
+      pipeline.create_builds(user)
+      pipeline.save
+    end
 
     scenario 'user visits a pipelines page', js: true do
       visit_merge_request(merge_request)
-- 
cgit v1.2.1


From d8c4556d3c8623bf48e689f3734c9c35cda34c2f Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Fri, 3 Jun 2016 11:58:08 +0200
Subject: Refactor code reponsible for creating builds

This removes duplications and extracts method that builds build-jobs
without persisting those objects, to a separate method.
---
 spec/features/merge_requests/created_from_fork_spec.rb | 5 +----
 spec/models/ci/commit_spec.rb                          | 8 ++------
 spec/requests/ci/api/builds_spec.rb                    | 5 -----
 3 files changed, 3 insertions(+), 15 deletions(-)

(limited to 'spec')

diff --git a/spec/features/merge_requests/created_from_fork_spec.rb b/spec/features/merge_requests/created_from_fork_spec.rb
index 16c572b3197..edc0bdec3db 100644
--- a/spec/features/merge_requests/created_from_fork_spec.rb
+++ b/spec/features/merge_requests/created_from_fork_spec.rb
@@ -34,10 +34,7 @@ feature 'Merge request created from fork' do
                                        ref: merge_request.source_branch)
     end
 
-    background do
-      pipeline.create_builds(user)
-      pipeline.save
-    end
+    background { pipeline.create_builds(user) }
 
     scenario 'user visits a pipelines page', js: true do
       visit_merge_request(merge_request)
diff --git a/spec/models/ci/commit_spec.rb b/spec/models/ci/commit_spec.rb
index a4549d40461..01d931b087e 100644
--- a/spec/models/ci/commit_spec.rb
+++ b/spec/models/ci/commit_spec.rb
@@ -55,15 +55,11 @@ describe Ci::Commit, models: true do
     let!(:commit) { FactoryGirl.create :ci_commit, project: project, ref: 'master', tag: false }
 
     def create_builds(trigger_request = nil)
-      if commit.create_builds(nil, trigger_request)
-        commit.save
-      end
+      commit.create_builds(nil, trigger_request)
     end
 
     def create_next_builds
-      if commit.create_next_builds(commit.builds.order(:id).last)
-        commit.save
-      end
+      commit.create_next_builds(commit.builds.order(:id).last)
     end
 
     it 'creates builds' do
diff --git a/spec/requests/ci/api/builds_spec.rb b/spec/requests/ci/api/builds_spec.rb
index 7eff8048667..e5124ea5ea7 100644
--- a/spec/requests/ci/api/builds_spec.rb
+++ b/spec/requests/ci/api/builds_spec.rb
@@ -22,7 +22,6 @@ describe Ci::API::API do
       it "should start a build" do
         commit = FactoryGirl.create(:ci_commit, project: project, ref: 'master')
         commit.create_builds(nil)
-        commit.save
         build = commit.builds.first
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
@@ -59,7 +58,6 @@ describe Ci::API::API do
       it "returns options" do
         commit = FactoryGirl.create(:ci_commit, project: project, ref: 'master')
         commit.create_builds(nil)
-        commit.save
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
 
@@ -70,7 +68,6 @@ describe Ci::API::API do
       it "returns variables" do
         commit = FactoryGirl.create(:ci_commit, project: project, ref: 'master')
         commit.create_builds(nil)
-        commit.save
         project.variables << Ci::Variable.new(key: "SECRET_KEY", value: "secret_value")
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
@@ -90,7 +87,6 @@ describe Ci::API::API do
 
         trigger_request = FactoryGirl.create(:ci_trigger_request_with_variables, commit: commit, trigger: trigger)
         commit.create_builds(nil, trigger_request)
-        commit.save
         project.variables << Ci::Variable.new(key: "SECRET_KEY", value: "secret_value")
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
@@ -109,7 +105,6 @@ describe Ci::API::API do
       it "returns dependent builds" do
         commit = FactoryGirl.create(:ci_commit, project: project, ref: 'master')
         commit.create_builds(nil, nil)
-        commit.save
         commit.builds.where(stage: 'test').each(&:success)
 
         post ci_api("/builds/register"), token: runner.token, info: { platform: :darwin }
-- 
cgit v1.2.1


From 50b3b8ce80b3573f53c22ac5ff34391b5bc469d8 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Tue, 7 Jun 2016 17:54:29 +0300
Subject: Added tests for categorised search autocomplete.

---
 spec/features/search_spec.rb                       |  79 +++++++++++++
 .../fixtures/search_autocomplete.html.haml         |  10 ++
 spec/javascripts/notes_spec.js.coffee              |   2 +-
 spec/javascripts/project_title_spec.js.coffee      |   2 +-
 .../javascripts/search_autocomplete_spec.js.coffee | 129 +++++++++++++++++++++
 5 files changed, 220 insertions(+), 2 deletions(-)
 create mode 100644 spec/javascripts/fixtures/search_autocomplete.html.haml
 create mode 100644 spec/javascripts/search_autocomplete_spec.js.coffee

(limited to 'spec')

diff --git a/spec/features/search_spec.rb b/spec/features/search_spec.rb
index 029a11ea43c..4f4d4b1e3e9 100644
--- a/spec/features/search_spec.rb
+++ b/spec/features/search_spec.rb
@@ -47,4 +47,83 @@ describe "Search", feature: true  do
       expect(page).to have_link(snippet.title)
     end
   end
+
+
+  describe 'Right header search field', feature: true do
+
+    describe 'Search in project page' do
+      before do
+        visit namespace_project_path(project.namespace, project)
+      end
+
+      it 'top right search form is present' do
+        expect(page).to have_selector('#search')
+      end
+
+      it 'top right search form contains location badge' do
+        expect(page).to have_selector('.has-location-badge')
+      end
+
+      context 'clicking the search field', js: true do
+        it 'should show category search dropdown' do
+          page.find('#search').click
+
+          expect(page).to have_selector('.dropdown-header', text: /go to in #{project.name}/i)
+        end
+      end
+
+      context 'click the links in the category search dropdown', js: true do
+
+        before do
+          page.find('#search').click
+        end
+
+        it 'should take user to her issues page when issues assigned is clicked' do
+          find('.dropdown-menu').click_link 'Issues assigned to me'
+          sleep 2
+
+          expect(page).to have_selector('.issues-holder')
+          expect(find('.js-assignee-search .dropdown-toggle-text')).to have_content(user.name)
+        end
+
+        it 'should take user to her issues page when issues authored is clicked' do
+          find('.dropdown-menu').click_link "Issues I've created"
+          sleep 2
+
+          expect(page).to have_selector('.issues-holder')
+          expect(find('.js-author-search .dropdown-toggle-text')).to have_content(user.name)
+        end
+
+        it 'should take user to her MR page when MR assigned is clicked' do
+          find('.dropdown-menu').click_link 'Merge requests assigned to me'
+          sleep 2
+
+          expect(page).to have_selector('.merge-requests-holder')
+          expect(find('.js-assignee-search .dropdown-toggle-text')).to have_content(user.name)
+        end
+
+        it 'should take user to her MR page when MR authored is clicked' do
+          find('.dropdown-menu').click_link "Merge requests I've created"
+          sleep 2
+
+          expect(page).to have_selector('.merge-requests-holder')
+          expect(find('.js-author-search .dropdown-toggle-text')).to have_content(user.name)
+        end
+      end
+
+      context 'entering text into the search field', js: true do
+        before do
+          page.within '.search-input-wrap' do
+            fill_in "search", with: project.name[0..3]
+          end
+        end
+
+        it 'should not display the category search dropdown' do
+          expect(page).not_to have_selector('.dropdown-header', text: /go to in #{project.name}/i)
+        end
+      end
+    end
+  end
+
+
 end
diff --git a/spec/javascripts/fixtures/search_autocomplete.html.haml b/spec/javascripts/fixtures/search_autocomplete.html.haml
new file mode 100644
index 00000000000..7785120da5b
--- /dev/null
+++ b/spec/javascripts/fixtures/search_autocomplete.html.haml
@@ -0,0 +1,10 @@
+.search.search-form.has-location-badge
+  %form.navbar-form
+    .search-input-container
+      %div.location-badge
+        This project
+      .search-input-wrap
+        .dropdown
+          %input#search.search-input.dropdown-menu-toggle
+          .dropdown-menu.dropdown-select
+            .dropdown-content
diff --git a/spec/javascripts/notes_spec.js.coffee b/spec/javascripts/notes_spec.js.coffee
index dd160e821b3..3a3c8d63e82 100644
--- a/spec/javascripts/notes_spec.js.coffee
+++ b/spec/javascripts/notes_spec.js.coffee
@@ -1,7 +1,7 @@
 #= require notes
 #= require gl_form
 
-window.gon = {}
+window.gon or= {}
 window.disableButtonIfEmptyField = -> null
 
 describe 'Notes', ->
diff --git a/spec/javascripts/project_title_spec.js.coffee b/spec/javascripts/project_title_spec.js.coffee
index 1cf34d4d2d3..9be29097f4c 100644
--- a/spec/javascripts/project_title_spec.js.coffee
+++ b/spec/javascripts/project_title_spec.js.coffee
@@ -6,7 +6,7 @@
 #= require project_select
 #= require project
 
-window.gon = {}
+window.gon or= {}
 window.gon.api_version = 'v3'
 
 describe 'Project Title', ->
diff --git a/spec/javascripts/search_autocomplete_spec.js.coffee b/spec/javascripts/search_autocomplete_spec.js.coffee
new file mode 100644
index 00000000000..5212f5d223a
--- /dev/null
+++ b/spec/javascripts/search_autocomplete_spec.js.coffee
@@ -0,0 +1,129 @@
+#= require gl_dropdown
+#= require search_autocomplete
+#= require jquery
+#= require lib/common_utils
+#= require lib/type_utility
+#= require fuzzaldrin-plus
+
+
+widget       = null
+userId       = 1
+window.gon or= {}
+window.gon.current_user_id = userId
+
+dashboardIssuesPath = '/dashboard/issues'
+dashboardMRsPath    = '/dashboard/merge_requests'
+projectIssuesPath   = "/gitlab-org/gitlab-ce/issues"
+projectMRsPath      = "/gitlab-org/gitlab-ce/merge_requests"
+projectName         = 'GitLab Community Edition'
+
+# Add required attributes to body before starting the test.
+addBodyAttributes = (page = 'groups') ->
+
+  $('body').removeAttr 'data-page'
+  $('body').removeAttr 'data-project'
+
+  $('body').data 'page', "#{page}:show"
+  $('body').data 'project', 'gitlab-ce'
+
+
+# Mock `gl` object in window for dashboard specific page. App code will need it.
+mockDashboardOptions = ->
+
+  window.gl or= {}
+  window.gl.dashboardOptions =
+    issuesPath: dashboardIssuesPath
+    mrPath    : dashboardMRsPath
+
+
+# Mock `gl` object in window for project specific page. App code will need it.
+mockProjectOptions = ->
+
+  window.gl or= {}
+  window.gl.projectOptions =
+    'gitlab-ce'   :
+      issuesPath  : projectIssuesPath
+      mrPath      : projectMRsPath
+      projectName : projectName
+
+
+assertLinks = (list, a1, a2, a3, a4) ->
+
+  expect(list.find(a1).length).toBe 1
+  expect(list.find(a1).text()).toBe ' Issues assigned to me '
+
+  expect(list.find(a2).length).toBe 1
+  expect(list.find(a2).text()).toBe " Issues I've created "
+
+  expect(list.find(a3).length).toBe 1
+  expect(list.find(a3).text()).toBe ' Merge requests assigned to me '
+
+  expect(list.find(a4).length).toBe 1
+  expect(list.find(a4).text()).toBe " Merge requests I've created "
+
+
+
+describe 'Search autocomplete dropdown', ->
+
+  fixture.preload 'search_autocomplete.html'
+
+  beforeEach ->
+
+    fixture.load 'search_autocomplete.html'
+    widget = new SearchAutocomplete
+
+
+  it 'should show Dashboard specific dropdown menu', ->
+
+    addBodyAttributes()
+    mockDashboardOptions()
+
+    # Focus input to show dropdown list.
+    widget.searchInput.focus()
+
+    w = widget.wrap.find '.dropdown-menu'
+    l = w.find 'ul'
+
+    # # Expect dropdown and dropdown header
+    expect(w.find('.dropdown-header').text()).toBe 'Go to in Dashboard'
+
+    # Create links then assert link urls and inner texts
+    issuesAssignedToMeLink = "#{dashboardIssuesPath}/?assignee_id=#{userId}"
+    issuesIHaveCreatedLink = "#{dashboardIssuesPath}/?author_id=#{userId}"
+    mrsAssignedToMeLink    = "#{dashboardMRsPath}/?assignee_id=#{userId}"
+    mrsIHaveCreatedLink    = "#{dashboardMRsPath}/?author_id=#{userId}"
+
+    a1 = "a[href='#{issuesAssignedToMeLink}']"
+    a2 = "a[href='#{issuesIHaveCreatedLink}']"
+    a3 = "a[href='#{mrsAssignedToMeLink}']"
+    a4 = "a[href='#{mrsIHaveCreatedLink}']"
+
+    assertLinks l, a1, a2, a3, a4
+
+
+  it 'should show Project specific dropdown menu', ->
+
+    addBodyAttributes 'projects'
+    mockProjectOptions()
+
+    # Focus input to show dropdown list.
+    widget.searchInput.focus()
+
+    w = widget.wrap.find '.dropdown-menu'
+    l = w.find 'ul'
+
+    # Expect dropdown and dropdown header
+    expect(w.find('.dropdown-header').text()).toBe "Go to in #{projectName}"
+
+    # Create links then verify link urls and inner texts
+    issuesAssignedToMeLink = "#{projectIssuesPath}/?assignee_id=#{userId}"
+    issuesIHaveCreatedLink = "#{projectIssuesPath}/?author_id=#{userId}"
+    mrsAssignedToMeLink    = "#{projectMRsPath}/?assignee_id=#{userId}"
+    mrsIHaveCreatedLink    = "#{projectMRsPath}/?author_id=#{userId}"
+
+    a1 = "a[href='#{issuesAssignedToMeLink}']"
+    a2 = "a[href='#{issuesIHaveCreatedLink}']"
+    a3 = "a[href='#{mrsAssignedToMeLink}']"
+    a4 = "a[href='#{mrsIHaveCreatedLink}']"
+
+    assertLinks l, a1, a2, a3, a4
-- 
cgit v1.2.1


From 1f5ecf916ee7b1d34fbf8775890b2aada2055384 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Thu, 9 Jun 2016 14:08:49 +0530
Subject: Implement @jschatz1's comments.

- No hardcoded colors in any SCSS file except `variables.scss`
- Don't allow choosing a date in the past
- Use the same table as in the "Applications" tab
- The button should say "Create Personal Access Token"
- Float the revoke button to the right of the table cell
- Change the revocation message to be more explicit.
- Date shouldn't look selected on page load
- Don't use a panel for the created token
    - Use a normal flash for "Your new personal access token has been created"
    - Show the input (with the token) below it full width.
    - Put the "Make sure you save it - you won't be able to access it again." message near the input
- Have the created token's input highlight all on single click
---
 spec/features/profiles/personal_access_tokens_spec.rb | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'spec')

diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index 5bba08d005c..105c5dae34e 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -12,7 +12,7 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
   end
 
   def created_personal_access_token
-    find(".created-personal-access-token pre")
+    find(".created-personal-access-token input").value
   end
 
   def disallow_personal_access_token_saves!
@@ -30,8 +30,8 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       visit profile_personal_access_tokens_path
       fill_in "Name", with: FFaker::Product.brand
 
-      expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
-      expect(created_personal_access_token).to have_text(PersonalAccessToken.last.token)
+      expect {click_on "Create Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
+      expect(created_personal_access_token).to eq(PersonalAccessToken.last.token)
       expect(active_personal_access_tokens).to have_text(PersonalAccessToken.last.name)
       expect(active_personal_access_tokens).to have_text("Never")
     end
@@ -44,8 +44,8 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       find("a[title='Next']").click
       click_on "1"
 
-      expect {click_on "Add Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
-      expect(created_personal_access_token).to have_text(PersonalAccessToken.last.token)
+      expect {click_on "Create Personal Access Token"}.to change { PersonalAccessToken.count }.by(1)
+      expect(created_personal_access_token).to eq(PersonalAccessToken.last.token)
       expect(active_personal_access_tokens).to have_text(PersonalAccessToken.last.name)
       expect(active_personal_access_tokens).to have_text(Date.today.next_month.at_beginning_of_month.to_s(:medium))
     end
@@ -56,7 +56,7 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
         visit profile_personal_access_tokens_path
         fill_in "Name", with: FFaker::Product.brand
 
-        expect { click_on "Add Personal Access Token" }.not_to change { PersonalAccessToken.count }
+        expect { click_on "Create Personal Access Token" }.not_to change { PersonalAccessToken.count }
         expect(page).to have_content("Name cannot be nil")
       end
     end
-- 
cgit v1.2.1


From e864bdf25b0082be8d0847fed6a2d16fe348ae59 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Fri, 10 Jun 2016 01:05:09 +0300
Subject: Fix specs and add new tests.

---
 spec/features/search_spec.rb                       |   4 +-
 .../javascripts/search_autocomplete_spec.js.coffee | 104 ++++++++++++---------
 2 files changed, 64 insertions(+), 44 deletions(-)

(limited to 'spec')

diff --git a/spec/features/search_spec.rb b/spec/features/search_spec.rb
index 4f4d4b1e3e9..b9e63a7152c 100644
--- a/spec/features/search_spec.rb
+++ b/spec/features/search_spec.rb
@@ -68,7 +68,7 @@ describe "Search", feature: true  do
         it 'should show category search dropdown' do
           page.find('#search').click
 
-          expect(page).to have_selector('.dropdown-header', text: /go to in #{project.name}/i)
+          expect(page).to have_selector('.dropdown-header', text: /#{project.name}/i)
         end
       end
 
@@ -119,7 +119,7 @@ describe "Search", feature: true  do
         end
 
         it 'should not display the category search dropdown' do
-          expect(page).not_to have_selector('.dropdown-header', text: /go to in #{project.name}/i)
+          expect(page).not_to have_selector('.dropdown-header', text: /#{project.name}/i)
         end
       end
     end
diff --git a/spec/javascripts/search_autocomplete_spec.js.coffee b/spec/javascripts/search_autocomplete_spec.js.coffee
index 5212f5d223a..e77177783a7 100644
--- a/spec/javascripts/search_autocomplete_spec.js.coffee
+++ b/spec/javascripts/search_autocomplete_spec.js.coffee
@@ -13,18 +13,33 @@ window.gon.current_user_id = userId
 
 dashboardIssuesPath = '/dashboard/issues'
 dashboardMRsPath    = '/dashboard/merge_requests'
-projectIssuesPath   = "/gitlab-org/gitlab-ce/issues"
-projectMRsPath      = "/gitlab-org/gitlab-ce/merge_requests"
+projectIssuesPath   = '/gitlab-org/gitlab-ce/issues'
+projectMRsPath      = '/gitlab-org/gitlab-ce/merge_requests'
+groupIssuesPath     = '/groups/gitlab-org/issues'
+groupMRsPath        = '/groups/gitlab-org/merge_requests'
 projectName         = 'GitLab Community Edition'
+groupName           = 'Gitlab Org'
+
 
 # Add required attributes to body before starting the test.
-addBodyAttributes = (page = 'groups') ->
+# section would be dashboard|group|project
+addBodyAttributes = (section = 'dashboard') ->
+
+  $body = $ 'body'
 
-  $('body').removeAttr 'data-page'
-  $('body').removeAttr 'data-project'
+  $body.removeAttr 'data-page'
+  $body.removeAttr 'data-project'
+  $body.removeAttr 'data-group'
 
-  $('body').data 'page', "#{page}:show"
-  $('body').data 'project', 'gitlab-ce'
+  switch section
+    when 'dashboard'
+      $body.data 'page', 'root:index'
+    when 'group'
+      $body.data 'page', 'groups:show'
+      $body.data 'group', 'gitlab-org'
+    when 'project'
+      $body.data 'page', 'projects:show'
+      $body.data 'project', 'gitlab-ce'
 
 
 # Mock `gl` object in window for dashboard specific page. App code will need it.
@@ -47,7 +62,27 @@ mockProjectOptions = ->
       projectName : projectName
 
 
-assertLinks = (list, a1, a2, a3, a4) ->
+mockGroupOptions = ->
+
+  window.gl or= {}
+  window.gl.groupOptions =
+    'gitlab-org'  :
+      issuesPath  : groupIssuesPath
+      mrPath      : groupMRsPath
+      projectName : groupName
+
+
+assertLinks = (list, issuesPath, mrsPath) ->
+
+  issuesAssignedToMeLink = "#{issuesPath}/?assignee_id=#{userId}"
+  issuesIHaveCreatedLink = "#{issuesPath}/?author_id=#{userId}"
+  mrsAssignedToMeLink    = "#{mrsPath}/?assignee_id=#{userId}"
+  mrsIHaveCreatedLink    = "#{mrsPath}/?author_id=#{userId}"
+
+  a1 = "a[href='#{issuesAssignedToMeLink}']"
+  a2 = "a[href='#{issuesIHaveCreatedLink}']"
+  a3 = "a[href='#{mrsAssignedToMeLink}']"
+  a4 = "a[href='#{mrsIHaveCreatedLink}']"
 
   expect(list.find(a1).length).toBe 1
   expect(list.find(a1).text()).toBe ' Issues assigned to me '
@@ -62,7 +97,6 @@ assertLinks = (list, a1, a2, a3, a4) ->
   expect(list.find(a4).text()).toBe " Merge requests I've created "
 
 
-
 describe 'Search autocomplete dropdown', ->
 
   fixture.preload 'search_autocomplete.html'
@@ -77,53 +111,39 @@ describe 'Search autocomplete dropdown', ->
 
     addBodyAttributes()
     mockDashboardOptions()
-
-    # Focus input to show dropdown list.
     widget.searchInput.focus()
 
-    w = widget.wrap.find '.dropdown-menu'
-    l = w.find 'ul'
+    list = widget.wrap.find('.dropdown-menu').find 'ul'
+    assertLinks list, dashboardIssuesPath, dashboardMRsPath
 
-    # # Expect dropdown and dropdown header
-    expect(w.find('.dropdown-header').text()).toBe 'Go to in Dashboard'
 
-    # Create links then assert link urls and inner texts
-    issuesAssignedToMeLink = "#{dashboardIssuesPath}/?assignee_id=#{userId}"
-    issuesIHaveCreatedLink = "#{dashboardIssuesPath}/?author_id=#{userId}"
-    mrsAssignedToMeLink    = "#{dashboardMRsPath}/?assignee_id=#{userId}"
-    mrsIHaveCreatedLink    = "#{dashboardMRsPath}/?author_id=#{userId}"
+  it 'should show Group specific dropdown menu', ->
 
-    a1 = "a[href='#{issuesAssignedToMeLink}']"
-    a2 = "a[href='#{issuesIHaveCreatedLink}']"
-    a3 = "a[href='#{mrsAssignedToMeLink}']"
-    a4 = "a[href='#{mrsIHaveCreatedLink}']"
+    addBodyAttributes 'group'
+    mockGroupOptions()
+    widget.searchInput.focus()
 
-    assertLinks l, a1, a2, a3, a4
+    list = widget.wrap.find('.dropdown-menu').find 'ul'
+    assertLinks list, groupIssuesPath, groupMRsPath
 
 
   it 'should show Project specific dropdown menu', ->
 
-    addBodyAttributes 'projects'
+    addBodyAttributes 'project'
     mockProjectOptions()
-
-    # Focus input to show dropdown list.
     widget.searchInput.focus()
 
-    w = widget.wrap.find '.dropdown-menu'
-    l = w.find 'ul'
+    list = widget.wrap.find('.dropdown-menu').find 'ul'
+    assertLinks list, projectIssuesPath, projectMRsPath
 
-    # Expect dropdown and dropdown header
-    expect(w.find('.dropdown-header').text()).toBe "Go to in #{projectName}"
 
-    # Create links then verify link urls and inner texts
-    issuesAssignedToMeLink = "#{projectIssuesPath}/?assignee_id=#{userId}"
-    issuesIHaveCreatedLink = "#{projectIssuesPath}/?author_id=#{userId}"
-    mrsAssignedToMeLink    = "#{projectMRsPath}/?assignee_id=#{userId}"
-    mrsIHaveCreatedLink    = "#{projectMRsPath}/?author_id=#{userId}"
+  it 'should not show category related menu if there is text in the input', ->
 
-    a1 = "a[href='#{issuesAssignedToMeLink}']"
-    a2 = "a[href='#{issuesIHaveCreatedLink}']"
-    a3 = "a[href='#{mrsAssignedToMeLink}']"
-    a4 = "a[href='#{mrsIHaveCreatedLink}']"
+    addBodyAttributes 'project'
+    mockProjectOptions()
+    widget.searchInput.val 'help'
+    widget.searchInput.focus()
 
-    assertLinks l, a1, a2, a3, a4
+    list = widget.wrap.find('.dropdown-menu').find 'ul'
+    link = "a[href='#{projectIssuesPath}/?assignee_id=#{userId}']"
+    expect(list.find(link).length).toBe 0
-- 
cgit v1.2.1


From e18a08fd89f59088db22208069370a85f6a33001 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Fri, 10 Jun 2016 08:49:05 +0530
Subject: Implement second round of comments from @jschatz1.

- Just use a link for the clipboard button. Having a non-clickable
  container (that looks like a button) is confusing.
- Use `text-danger` for the "you won't be able to access it again" message.
- Highlight the created token so people know to look there.
---
 spec/features/profiles/personal_access_tokens_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index 105c5dae34e..d824e1d288d 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -12,7 +12,7 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
   end
 
   def created_personal_access_token
-    find(".created-personal-access-token input").value
+    find("#created-personal-access-token").value
   end
 
   def disallow_personal_access_token_saves!
-- 
cgit v1.2.1


From b0cf82105bbb3d61e559e8bb36abfa308cbee6ae Mon Sep 17 00:00:00 2001
From: Phil Hughes <me@iamphill.com>
Date: Thu, 2 Jun 2016 12:24:31 +0100
Subject: Fixed tests

---
 spec/features/issues_spec.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/features/issues_spec.rb b/spec/features/issues_spec.rb
index f6fb6a72d22..32d1e631408 100644
--- a/spec/features/issues_spec.rb
+++ b/spec/features/issues_spec.rb
@@ -515,10 +515,10 @@ describe 'Issues', feature: true do
             first('.ui-state-default').click
           end
 
-          expect(page).to have_no_content 'None'
+          expect(page).to have_no_content 'No due date'
 
           click_link 'remove due date'
-          expect(page).to have_content 'None'
+          expect(page).to have_content 'No due date'
         end
       end
     end
-- 
cgit v1.2.1


From ee2e583500360385c9b3f8d9231233223ab72b42 Mon Sep 17 00:00:00 2001
From: Kamil Trzcinski <ayufan@ayufan.eu>
Date: Mon, 13 Jun 2016 21:52:41 +0200
Subject: Fair usage of Shared Runners

---
 spec/services/ci/register_build_service_spec.rb | 40 +++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

(limited to 'spec')

diff --git a/spec/services/ci/register_build_service_spec.rb b/spec/services/ci/register_build_service_spec.rb
index d91fc574299..fa4c2fddeb8 100644
--- a/spec/services/ci/register_build_service_spec.rb
+++ b/spec/services/ci/register_build_service_spec.rb
@@ -50,6 +50,46 @@ module Ci
           project.update(shared_runners_enabled: true)
         end
 
+        context 'for multiple builds' do
+          let!(:project2) { create :empty_project, shared_runners_enabled: true }
+          let!(:pipeline2) { create :ci_pipeline, project: project2 }
+          let!(:project3) { create :empty_project, shared_runners_enabled: true }
+          let!(:pipeline3) { create :ci_pipeline, project: project3 }
+          let!(:build1_project1) { pending_build }
+          let!(:build2_project1) { FactoryGirl.create :ci_build, pipeline: pipeline }
+          let!(:build3_project1) { FactoryGirl.create :ci_build, pipeline: pipeline }
+          let!(:build1_project2) { FactoryGirl.create :ci_build, pipeline: pipeline2 }
+          let!(:build2_project2) { FactoryGirl.create :ci_build, pipeline: pipeline2 }
+          let!(:build1_project3) { FactoryGirl.create :ci_build, pipeline: pipeline3 }
+
+          it 'prefers projects without builds first' do
+            # it gets for one build from each of the projects
+            expect(service.execute(shared_runner)).to eq(build1_project1)
+            expect(service.execute(shared_runner)).to eq(build1_project2)
+            expect(service.execute(shared_runner)).to eq(build1_project3)
+
+            # then it gets a second build from each of the projects
+            expect(service.execute(shared_runner)).to eq(build2_project1)
+            expect(service.execute(shared_runner)).to eq(build2_project2)
+
+            # in the end the third build
+            expect(service.execute(shared_runner)).to eq(build3_project1)
+          end
+
+          it 'equalises number of running builds' do
+            # after finishing the first build for project 1, get a second build from the same project
+            expect(service.execute(shared_runner)).to eq(build1_project1)
+            build1_project1.success
+            expect(service.execute(shared_runner)).to eq(build2_project1)
+
+            expect(service.execute(shared_runner)).to eq(build1_project2)
+            build1_project2.success
+            expect(service.execute(shared_runner)).to eq(build2_project2)
+            expect(service.execute(shared_runner)).to eq(build1_project3)
+            expect(service.execute(shared_runner)).to eq(build3_project1)
+          end
+        end
+
         context 'shared runner' do
           let(:build) { service.execute(shared_runner) }
 
-- 
cgit v1.2.1


From e45fd5a1e4efb805d3f7f5ed9cb708105c4e9d60 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Tue, 14 Jun 2016 14:21:24 +0200
Subject: Remove ci commit specs that remain after bad merge

---
 spec/models/ci/commit_spec.rb | 403 ------------------------------------------
 1 file changed, 403 deletions(-)
 delete mode 100644 spec/models/ci/commit_spec.rb

(limited to 'spec')

diff --git a/spec/models/ci/commit_spec.rb b/spec/models/ci/commit_spec.rb
deleted file mode 100644
index 01d931b087e..00000000000
--- a/spec/models/ci/commit_spec.rb
+++ /dev/null
@@ -1,403 +0,0 @@
-require 'spec_helper'
-
-describe Ci::Commit, models: true do
-  let(:project) { FactoryGirl.create :empty_project }
-  let(:commit) { FactoryGirl.create :ci_commit, project: project }
-
-  it { is_expected.to belong_to(:project) }
-  it { is_expected.to have_many(:statuses) }
-  it { is_expected.to have_many(:trigger_requests) }
-  it { is_expected.to have_many(:builds) }
-  it { is_expected.to validate_presence_of :sha }
-  it { is_expected.to validate_presence_of :status }
-
-  it { is_expected.to respond_to :git_author_name }
-  it { is_expected.to respond_to :git_author_email }
-  it { is_expected.to respond_to :short_sha }
-
-  describe :valid_commit_sha do
-    context 'commit.sha can not start with 00000000' do
-      before do
-        commit.sha = '0' * 40
-        commit.valid_commit_sha
-      end
-
-      it('commit errors should not be empty') { expect(commit.errors).not_to be_empty }
-    end
-  end
-
-  describe :short_sha do
-    subject { commit.short_sha }
-
-    it 'has 8 items' do
-      expect(subject.size).to eq(8)
-    end
-    it { expect(commit.sha).to start_with(subject) }
-  end
-
-  describe :create_next_builds do
-  end
-
-  describe :retried do
-    subject { commit.retried }
-
-    before do
-      @commit1 = FactoryGirl.create :ci_build, commit: commit, name: 'deploy'
-      @commit2 = FactoryGirl.create :ci_build, commit: commit, name: 'deploy'
-    end
-
-    it 'returns old builds' do
-      is_expected.to contain_exactly(@commit1)
-    end
-  end
-
-  describe :create_builds do
-    let!(:commit) { FactoryGirl.create :ci_commit, project: project, ref: 'master', tag: false }
-
-    def create_builds(trigger_request = nil)
-      commit.create_builds(nil, trigger_request)
-    end
-
-    def create_next_builds
-      commit.create_next_builds(commit.builds.order(:id).last)
-    end
-
-    it 'creates builds' do
-      expect(create_builds).to be_truthy
-      commit.builds.update_all(status: "success")
-      expect(commit.builds.count(:all)).to eq(2)
-
-      expect(create_next_builds).to be_truthy
-      commit.builds.update_all(status: "success")
-      expect(commit.builds.count(:all)).to eq(4)
-
-      expect(create_next_builds).to be_truthy
-      commit.builds.update_all(status: "success")
-      expect(commit.builds.count(:all)).to eq(5)
-
-      expect(create_next_builds).to be_falsey
-    end
-
-    context 'custom stage with first job allowed to fail' do
-      let(:yaml) do
-        {
-          stages: ['clean', 'test'],
-          clean_job: {
-            stage: 'clean',
-            allow_failure: true,
-            script: 'BUILD',
-          },
-          test_job: {
-            stage: 'test',
-            script: 'TEST',
-          },
-        }
-      end
-
-      before do
-        stub_ci_commit_yaml_file(YAML.dump(yaml))
-        create_builds
-      end
-
-      it 'properly schedules builds' do
-        expect(commit.builds.pluck(:status)).to contain_exactly('pending')
-        commit.builds.running_or_pending.each(&:drop)
-        expect(commit.builds.pluck(:status)).to contain_exactly('pending', 'failed')
-      end
-    end
-
-    context 'properly creates builds when "when" is defined' do
-      let(:yaml) do
-        {
-          stages: ["build", "test", "test_failure", "deploy", "cleanup"],
-          build: {
-            stage: "build",
-            script: "BUILD",
-          },
-          test: {
-            stage: "test",
-            script: "TEST",
-          },
-          test_failure: {
-            stage: "test_failure",
-            script: "ON test failure",
-            when: "on_failure",
-          },
-          deploy: {
-            stage: "deploy",
-            script: "PUBLISH",
-          },
-          cleanup: {
-            stage: "cleanup",
-            script: "TIDY UP",
-            when: "always",
-          }
-        }
-      end
-
-      before do
-        stub_ci_commit_yaml_file(YAML.dump(yaml))
-      end
-
-      context 'when builds are successful' do
-        it 'properly creates builds' do
-          expect(create_builds).to be_truthy
-          expect(commit.builds.pluck(:name)).to contain_exactly('build')
-          expect(commit.builds.pluck(:status)).to contain_exactly('pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'deploy')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'success', 'pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'deploy', 'cleanup')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'success', 'success', 'pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'success', 'success', 'success')
-          commit.reload
-          expect(commit.status).to eq('success')
-        end
-      end
-
-      context 'when test job fails' do
-        it 'properly creates builds' do
-          expect(create_builds).to be_truthy
-          expect(commit.builds.pluck(:name)).to contain_exactly('build')
-          expect(commit.builds.pluck(:status)).to contain_exactly('pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'pending')
-          commit.builds.running_or_pending.each(&:drop)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'test_failure')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'failed', 'pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'test_failure', 'cleanup')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'failed', 'success', 'pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'failed', 'success', 'success')
-          commit.reload
-          expect(commit.status).to eq('failed')
-        end
-      end
-
-      context 'when test and test_failure jobs fail' do
-        it 'properly creates builds' do
-          expect(create_builds).to be_truthy
-          expect(commit.builds.pluck(:name)).to contain_exactly('build')
-          expect(commit.builds.pluck(:status)).to contain_exactly('pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'pending')
-          commit.builds.running_or_pending.each(&:drop)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'test_failure')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'failed', 'pending')
-          commit.builds.running_or_pending.each(&:drop)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'test_failure', 'cleanup')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'failed', 'failed', 'pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'test_failure', 'cleanup')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'failed', 'failed', 'success')
-          commit.reload
-          expect(commit.status).to eq('failed')
-        end
-      end
-
-      context 'when deploy job fails' do
-        it 'properly creates builds' do
-          expect(create_builds).to be_truthy
-          expect(commit.builds.pluck(:name)).to contain_exactly('build')
-          expect(commit.builds.pluck(:status)).to contain_exactly('pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'deploy')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'success', 'pending')
-          commit.builds.running_or_pending.each(&:drop)
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test', 'deploy', 'cleanup')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'success', 'failed', 'pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'success', 'failed', 'success')
-          commit.reload
-          expect(commit.status).to eq('failed')
-        end
-      end
-
-      context 'when build is canceled in the second stage' do
-        it 'does not schedule builds after build has been canceled' do
-          expect(create_builds).to be_truthy
-          expect(commit.builds.pluck(:name)).to contain_exactly('build')
-          expect(commit.builds.pluck(:status)).to contain_exactly('pending')
-          commit.builds.running_or_pending.each(&:success)
-
-          expect(commit.builds.running_or_pending).not_to be_empty
-
-          expect(commit.builds.pluck(:name)).to contain_exactly('build', 'test')
-          expect(commit.builds.pluck(:status)).to contain_exactly('success', 'pending')
-          commit.builds.running_or_pending.each(&:cancel)
-
-          expect(commit.builds.running_or_pending).to be_empty
-          expect(commit.reload.status).to eq('canceled')
-        end
-      end
-    end
-  end
-
-  describe "#finished_at" do
-    let(:commit) { FactoryGirl.create :ci_commit }
-
-    it "returns finished_at of latest build" do
-      build = FactoryGirl.create :ci_build, commit: commit, finished_at: Time.now - 60
-      FactoryGirl.create :ci_build, commit: commit, finished_at: Time.now - 120
-
-      expect(commit.finished_at.to_i).to eq(build.finished_at.to_i)
-    end
-
-    it "returns nil if there is no finished build" do
-      FactoryGirl.create :ci_not_started_build, commit: commit
-
-      expect(commit.finished_at).to be_nil
-    end
-  end
-
-  describe "coverage" do
-    let(:project) { FactoryGirl.create :empty_project, build_coverage_regex: "/.*/" }
-    let(:commit) { FactoryGirl.create :ci_commit, project: project }
-
-    it "calculates average when there are two builds with coverage" do
-      FactoryGirl.create :ci_build, name: "rspec", coverage: 30, commit: commit
-      FactoryGirl.create :ci_build, name: "rubocop", coverage: 40, commit: commit
-      expect(commit.coverage).to eq("35.00")
-    end
-
-    it "calculates average when there are two builds with coverage and one with nil" do
-      FactoryGirl.create :ci_build, name: "rspec", coverage: 30, commit: commit
-      FactoryGirl.create :ci_build, name: "rubocop", coverage: 40, commit: commit
-      FactoryGirl.create :ci_build, commit: commit
-      expect(commit.coverage).to eq("35.00")
-    end
-
-    it "calculates average when there are two builds with coverage and one is retried" do
-      FactoryGirl.create :ci_build, name: "rspec", coverage: 30, commit: commit
-      FactoryGirl.create :ci_build, name: "rubocop", coverage: 30, commit: commit
-      FactoryGirl.create :ci_build, name: "rubocop", coverage: 40, commit: commit
-      expect(commit.coverage).to eq("35.00")
-    end
-
-    it "calculates average when there is one build without coverage" do
-      FactoryGirl.create :ci_build, commit: commit
-      expect(commit.coverage).to be_nil
-    end
-  end
-
-  describe '#retryable?' do
-    subject { commit.retryable? }
-
-    context 'no failed builds' do
-      before do
-        FactoryGirl.create :ci_build, name: "rspec", commit: commit, status: 'success'
-      end
-
-      it 'be not retryable' do
-        is_expected.to be_falsey
-      end
-    end
-
-    context 'with failed builds' do
-      before do
-        FactoryGirl.create :ci_build, name: "rspec", commit: commit, status: 'running'
-        FactoryGirl.create :ci_build, name: "rubocop", commit: commit, status: 'failed'
-      end
-
-      it 'be retryable' do
-        is_expected.to be_truthy
-      end
-    end
-  end
-
-  describe '#stages' do
-    let(:commit2) { FactoryGirl.create :ci_commit, project: project }
-    subject { CommitStatus.where(commit: [commit, commit2]).stages }
-
-    before do
-      FactoryGirl.create :ci_build, commit: commit2, stage: 'test', stage_idx: 1
-      FactoryGirl.create :ci_build, commit: commit, stage: 'build', stage_idx: 0
-    end
-
-    it 'return all stages' do
-      is_expected.to eq(%w(build test))
-    end
-  end
-
-  describe '#update_state' do
-    it 'execute update_state after touching object' do
-      expect(commit).to receive(:update_state).and_return(true)
-      commit.touch
-    end
-
-    context 'dependent objects' do
-      let(:commit_status) { build :commit_status, commit: commit }
-
-      it 'execute update_state after saving dependent object' do
-        expect(commit).to receive(:update_state).and_return(true)
-        commit_status.save
-      end
-    end
-
-    context 'update state' do
-      let(:current) { Time.now.change(usec: 0) }
-      let!(:build) do
-        create :ci_build, :success, commit: commit,
-                                    started_at: current - 120,
-                                    finished_at: current - 60
-      end
-
-      [:status, :started_at, :finished_at, :duration].each do |param|
-        it "update #{param}" do
-          expect(commit.send(param)).to eq(build.send(param))
-        end
-      end
-    end
-  end
-
-  describe '#branch?' do
-    subject { commit.branch? }
-
-    context 'is not a tag' do
-      before do
-        commit.tag = false
-      end
-
-      it 'return true when tag is set to false' do
-        is_expected.to be_truthy
-      end
-    end
-
-    context 'is not a tag' do
-      before do
-        commit.tag = true
-      end
-
-      it 'return false when tag is set to true' do
-        is_expected.to be_falsey
-      end
-    end
-  end
-end
-- 
cgit v1.2.1


From cf292a3f1d3cc17d55131a15d91a53ff31017f5d Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Tue, 14 Jun 2016 14:09:07 +0200
Subject: Improve code clarity in pipeline create service

---
 spec/services/create_commit_builds_service_spec.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/services/create_commit_builds_service_spec.rb b/spec/services/create_commit_builds_service_spec.rb
index 08cbc9beb5c..50ce9659c10 100644
--- a/spec/services/create_commit_builds_service_spec.rb
+++ b/spec/services/create_commit_builds_service_spec.rb
@@ -60,7 +60,7 @@ describe CreateCommitBuildsService, services: true do
                                after: '31das312',
                                commits: [{ message: 'Message' }]
                               )
-      expect(result).not_to be_persisted
+      expect(result).to be_falsey
       expect(Ci::Pipeline.count).to eq(0)
     end
 
@@ -184,7 +184,7 @@ describe CreateCommitBuildsService, services: true do
                                  before: '00000000',
                                  after: '31das312',
                                  commits: [{ message: 'some msg' }])
-        expect(result).not_to be_persisted
+        expect(result).to be_falsey
         expect(Ci::Build.all).to be_empty
         expect(Ci::Pipeline.count).to eq(0)
       end
-- 
cgit v1.2.1


From 7b4e0739e6834cfe192012059163af523dcae798 Mon Sep 17 00:00:00 2001
From: Douglas Barbosa Alexandre <dbalexandre@gmail.com>
Date: Tue, 14 Jun 2016 22:13:58 -0300
Subject: Project members with guest role can't access notes on confidential
 issues

---
 spec/finders/notes_finder_spec.rb | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'spec')

diff --git a/spec/finders/notes_finder_spec.rb b/spec/finders/notes_finder_spec.rb
index 639b28d49ee..1bd354815e4 100644
--- a/spec/finders/notes_finder_spec.rb
+++ b/spec/finders/notes_finder_spec.rb
@@ -49,6 +49,13 @@ describe NotesFinder do
         user = create(:user)
         expect { NotesFinder.new.execute(project, user, params) }.to raise_error(ActiveRecord::RecordNotFound)
       end
+
+      it 'raises an error for project members with guest role' do
+        user = create(:user)
+        project.team << [user, :guest]
+
+        expect { NotesFinder.new.execute(project, user, params) }.to raise_error(ActiveRecord::RecordNotFound)
+      end
     end
   end
 end
-- 
cgit v1.2.1


From bf990fcda4c5b728272d3775cdefadce6f80cf01 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Wed, 15 Jun 2016 09:35:11 +0200
Subject: Return false in create_builds if not builds created

This fixes compatibility with trigger request create service.
---
 spec/models/ci/pipeline_spec.rb | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'spec')

diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index 0d769ed7324..458013ad9f2 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -258,6 +258,16 @@ describe Ci::Pipeline, models: true do
         end
       end
     end
+
+    context 'when no builds created' do
+      before do
+        stub_ci_pipeline_yaml_file(YAML.dump(before_script: ['ls']))
+      end
+
+      it 'returns false' do
+        expect(pipeline.create_builds(nil)).to be_falsey
+      end
+    end
   end
 
   describe "#finished_at" do
-- 
cgit v1.2.1


From 8aed815b6e646df52043867edfdfcf4f618c6a87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Coutable?= <remy@rymai.me>
Date: Wed, 15 Jun 2016 10:32:57 +0200
Subject: Avoid a TypeError when initializing MergeRequest JS class with no arg
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Without this sane default you would get the following error when you
tried to instantiate a new MergeRequest object with no argument (i.e.
`new MergeRequest();`):

TypeError: undefined is not an object (evaluating 'this.opts.action')

Signed-off-by: Rémy Coutable <remy@rymai.me>
---
 spec/javascripts/merge_request_spec.js.coffee | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/javascripts/merge_request_spec.js.coffee b/spec/javascripts/merge_request_spec.js.coffee
index 22ebc7039d1..3cb67d51c85 100644
--- a/spec/javascripts/merge_request_spec.js.coffee
+++ b/spec/javascripts/merge_request_spec.js.coffee
@@ -6,7 +6,7 @@ describe 'MergeRequest', ->
 
     beforeEach ->
       fixture.load('merge_requests_show.html')
-      @merge = new MergeRequest({})
+      @merge = new MergeRequest()
 
     it 'modifies the Markdown field', ->
       spyOn(jQuery, 'ajax').and.stub()
-- 
cgit v1.2.1


From f30d1fdf94a373649b2b570bbd6d77cbe817ebe0 Mon Sep 17 00:00:00 2001
From: Kamil Trzcinski <ayufan@ayufan.eu>
Date: Wed, 15 Jun 2016 12:53:10 +0200
Subject: Add support for Docker Registry manifest v1

---
 .../container_registry/tag_manifest_1.json         | 32 ++++++++
 spec/lib/container_registry/tag_spec.rb            | 89 ++++++++++++++++------
 2 files changed, 96 insertions(+), 25 deletions(-)
 create mode 100644 spec/fixtures/container_registry/tag_manifest_1.json

(limited to 'spec')

diff --git a/spec/fixtures/container_registry/tag_manifest_1.json b/spec/fixtures/container_registry/tag_manifest_1.json
new file mode 100644
index 00000000000..d09ede5bea7
--- /dev/null
+++ b/spec/fixtures/container_registry/tag_manifest_1.json
@@ -0,0 +1,32 @@
+{
+  "schemaVersion": 1,
+  "name": "library/alpine",
+  "tag": "2.6",
+  "architecture": "amd64",
+  "fsLayers": [
+    {
+      "blobSum": "sha256:2a3ebcb7fbcc29bf40c4f62863008bb573acdea963454834d9483b3e5300c45d"
+    }
+  ],
+  "history": [
+    {
+      "v1Compatibility": "{\"id\":\"dd807873c9a21bcc82e30317c283e6601d7e19f5cf7867eec34cdd1aeb3f099e\",\"created\":\"2016-01-18T18:32:39.162138276Z\",\"container\":\"556a728876db7b0e621adc029c87c649d32520804f8f15defd67bb070dc1a88d\",\"container_config\":{\"Hostname\":\"556a728876db\",\"Domainname\":\"\",\"User\":\"\",\"AttachStdin\":false,\"AttachStdout\":false,\"AttachStderr\":false,\"Tty\":false,\"OpenStdin\":false,\"StdinOnce\":false,\"Env\":null,\"Cmd\":[\"/bin/sh\",\"-c\",\"#(nop) ADD file:7dee8a455bcc39013aa168d27ece9227aad155adbaacbd153d94ca60113f59fc in /\"],\"Image\":\"\",\"Volumes\":null,\"WorkingDir\":\"\",\"Entrypoint\":null,\"OnBuild\":null,\"Labels\":null},\"docker_version\":\"1.8.3\",\"config\":{\"Hostname\":\"556a728876db\",\"Domainname\":\"\",\"User\":\"\",\"AttachStdin\":false,\"AttachStdout\":false,\"AttachStderr\":false,\"Tty\":false,\"OpenStdin\":false,\"StdinOnce\":false,\"Env\":null,\"Cmd\":null,\"Image\":\"\",\"Volumes\":null,\"WorkingDir\":\"\",\"Entrypoint\":null,\"OnBuild\":null,\"Labels\":null},\"architecture\":\"amd64\",\"os\":\"linux\",\"Size\":4501436}"
+    }
+  ],
+  "signatures": [
+    {
+      "header": {
+        "jwk": {
+          "crv": "P-256",
+          "kid": "4MZL:Z5ZP:2RPA:Q3TD:QOHA:743L:EM2G:QY6Q:ZJCX:BSD7:CRYC:LQ6T",
+          "kty": "EC",
+          "x": "qmWOaxPUk7QsE5iTPdeG1e9yNE-wranvQEnWzz9FhWM",
+          "y": "WeeBpjTOYnTNrfCIxtFY5qMrJNNk9C1vc5ryxbbMD_M"
+        },
+        "alg": "ES256"
+      },
+      "signature": "0zmjTJ4m21yVwAeteLc3SsQ0miScViCDktFPR67W-ozGjjI3iBjlDjwOl6o2sds5ZI9U6bSIKOeLDinGOhHoOQ",
+      "protected": "eyJmb3JtYXRMZW5ndGgiOjEzNzIsImZvcm1hdFRhaWwiOiJDbjAiLCJ0aW1lIjoiMjAxNi0wNi0xNVQxMDo0NDoxNFoifQ"
+    }
+  ]
+}
diff --git a/spec/lib/container_registry/tag_spec.rb b/spec/lib/container_registry/tag_spec.rb
index 858cb0bb134..c7324c2bf77 100644
--- a/spec/lib/container_registry/tag_spec.rb
+++ b/spec/lib/container_registry/tag_spec.rb
@@ -17,46 +17,85 @@ describe ContainerRegistry::Tag do
   end
 
   context 'manifest processing' do
-    before do
-      stub_request(:get, 'http://example.com/v2/group/test/manifests/tag').
-        with(headers: headers).
-        to_return(
-          status: 200,
-          body: File.read(Rails.root + 'spec/fixtures/container_registry/tag_manifest.json'),
-          headers: { 'Content-Type' => 'application/vnd.docker.distribution.manifest.v2+json' })
-    end
+    context 'schema v1' do
+      before do
+        stub_request(:get, 'http://example.com/v2/group/test/manifests/tag').
+          with(headers: headers).
+          to_return(
+            status: 200,
+            body: File.read(Rails.root + 'spec/fixtures/container_registry/tag_manifest_1.json'),
+            headers: { 'Content-Type' => 'application/vnd.docker.distribution.manifest.v1+prettyjws' })
+      end
 
-    context '#layers' do
-      subject { tag.layers }
+      context '#layers' do
+        subject { tag.layers }
 
-      it { expect(subject.length).to eq(1) }
-    end
+        it { expect(subject.length).to eq(1) }
+      end
+
+      context '#total_size' do
+        subject { tag.total_size }
 
-    context '#total_size' do
-      subject { tag.total_size }
+        it { is_expected.to be_nil }
+      end
 
-      it { is_expected.to eq(2319870) }
+      context 'config processing' do
+        context '#config' do
+          subject { tag.config }
+
+          it { is_expected.to be_nil }
+        end
+
+        context '#created_at' do
+          subject { tag.created_at }
+
+          it { is_expected.to be_nil }
+        end
+      end
     end
 
-    context 'config processing' do
+    context 'schema v2' do
       before do
-        stub_request(:get, 'http://example.com/v2/group/test/blobs/sha256:d7a513a663c1a6dcdba9ed832ca53c02ac2af0c333322cd6ca92936d1d9917ac').
-          with(headers: { 'Accept' => 'application/octet-stream' }).
+        stub_request(:get, 'http://example.com/v2/group/test/manifests/tag').
+          with(headers: headers).
           to_return(
             status: 200,
-            body: File.read(Rails.root + 'spec/fixtures/container_registry/config_blob.json'))
+            body: File.read(Rails.root + 'spec/fixtures/container_registry/tag_manifest.json'),
+            headers: { 'Content-Type' => 'application/vnd.docker.distribution.manifest.v2+json' })
       end
 
-      context '#config' do
-        subject { tag.config }
+      context '#layers' do
+        subject { tag.layers }
 
-        it { is_expected.not_to be_nil }
+        it { expect(subject.length).to eq(1) }
       end
 
-      context '#created_at' do
-        subject { tag.created_at }
+      context '#total_size' do
+        subject { tag.total_size }
+
+        it { is_expected.to eq(2319870) }
+      end
+
+      context 'config processing' do
+        before do
+          stub_request(:get, 'http://example.com/v2/group/test/blobs/sha256:d7a513a663c1a6dcdba9ed832ca53c02ac2af0c333322cd6ca92936d1d9917ac').
+            with(headers: { 'Accept' => 'application/octet-stream' }).
+            to_return(
+              status: 200,
+              body: File.read(Rails.root + 'spec/fixtures/container_registry/config_blob.json'))
+        end
+
+        context '#config' do
+          subject { tag.config }
+
+          it { is_expected.not_to be_nil }
+        end
+
+        context '#created_at' do
+          subject { tag.created_at }
 
-        it { is_expected.not_to be_nil }
+          it { is_expected.not_to be_nil }
+        end
       end
     end
   end
-- 
cgit v1.2.1


From 342434c886a680bea5a4e37dbfbd8d96882ae780 Mon Sep 17 00:00:00 2001
From: Phil Hughes <me@iamphill.com>
Date: Wed, 15 Jun 2016 12:40:22 +0100
Subject: Fixed issue with de-selecting dropdown option in issue sidebar

Closes #18641
---
 spec/features/issues_spec.rb | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

(limited to 'spec')

diff --git a/spec/features/issues_spec.rb b/spec/features/issues_spec.rb
index f6fb6a72d22..65fe918e2e8 100644
--- a/spec/features/issues_spec.rb
+++ b/spec/features/issues_spec.rb
@@ -396,6 +396,27 @@ describe 'Issues', feature: true do
           expect(page).to have_content @user.name
         end
       end
+
+      it 'allows user to unselect themselves', js: true do
+        issue2 = create(:issue, project: project, author: @user)
+        visit namespace_project_issue_path(project.namespace, project, issue2)
+
+        page.within '.assignee' do
+          click_link 'Edit'
+          click_link @user.name
+
+          page.within '.value' do
+            expect(page).to have_content @user.name
+          end
+
+          click_link 'Edit'
+          click_link @user.name
+
+          page.within '.value' do
+            expect(page).to have_content "No assignee"
+          end
+        end
+      end
     end
 
     context 'by unauthorized user' do
@@ -440,6 +461,26 @@ describe 'Issues', feature: true do
 
         expect(issue.reload.milestone).to be_nil
       end
+
+      it 'allows user to de-select milestone', js: true do
+        visit namespace_project_issue_path(project.namespace, project, issue)
+
+        page.within('.milestone') do
+          click_link 'Edit'
+          click_link milestone.title
+
+          page.within '.value' do
+            expect(page).to have_content milestone.title
+          end
+
+          click_link 'Edit'
+          click_link milestone.title
+
+          page.within '.value' do
+            expect(page).to have_content 'None'
+          end
+        end
+      end
     end
 
     context 'by unauthorized user' do
-- 
cgit v1.2.1


From 2d495fce529cc3ac15f7096ddf9962db0fbd1e23 Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Wed, 15 Jun 2016 14:03:43 +0200
Subject: Remove reduntant method for building pipeline builds

---
 spec/models/ci/pipeline_spec.rb                    | 3 +++
 spec/services/create_commit_builds_service_spec.rb | 1 +
 2 files changed, 4 insertions(+)

(limited to 'spec')

diff --git a/spec/models/ci/pipeline_spec.rb b/spec/models/ci/pipeline_spec.rb
index 458013ad9f2..34507cf5083 100644
--- a/spec/models/ci/pipeline_spec.rb
+++ b/spec/models/ci/pipeline_spec.rb
@@ -260,12 +260,15 @@ describe Ci::Pipeline, models: true do
     end
 
     context 'when no builds created' do
+      let(:pipeline) { build(:ci_pipeline) }
+
       before do
         stub_ci_pipeline_yaml_file(YAML.dump(before_script: ['ls']))
       end
 
       it 'returns false' do
         expect(pipeline.create_builds(nil)).to be_falsey
+        expect(pipeline).not_to be_persisted
       end
     end
   end
diff --git a/spec/services/create_commit_builds_service_spec.rb b/spec/services/create_commit_builds_service_spec.rb
index 50ce9659c10..deab242f45a 100644
--- a/spec/services/create_commit_builds_service_spec.rb
+++ b/spec/services/create_commit_builds_service_spec.rb
@@ -184,6 +184,7 @@ describe CreateCommitBuildsService, services: true do
                                  before: '00000000',
                                  after: '31das312',
                                  commits: [{ message: 'some msg' }])
+
         expect(result).to be_falsey
         expect(Ci::Build.all).to be_empty
         expect(Ci::Pipeline.count).to eq(0)
-- 
cgit v1.2.1


From fefc3e9e4f476078e0402dd2585c664beda4b98f Mon Sep 17 00:00:00 2001
From: Kamil Trzcinski <ayufan@ayufan.eu>
Date: Wed, 15 Jun 2016 16:48:42 +0200
Subject: Make sure that we test RegisterBuildService behavior for deleted
 projects

---
 spec/services/ci/register_build_service_spec.rb | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

(limited to 'spec')

diff --git a/spec/services/ci/register_build_service_spec.rb b/spec/services/ci/register_build_service_spec.rb
index fa4c2fddeb8..f28f2f1438d 100644
--- a/spec/services/ci/register_build_service_spec.rb
+++ b/spec/services/ci/register_build_service_spec.rb
@@ -45,6 +45,28 @@ module Ci
         end
       end
 
+      context 'deleted projects' do
+        before do
+          project.update(pending_delete: true)
+        end
+
+        context 'for shared runners' do
+          before do
+            project.update(shared_runners_enabled: true)
+          end
+
+          it 'does not pick a build' do
+            expect(service.execute(shared_runner)).to be_nil
+          end
+        end
+
+        context 'for specific runner' do
+          it 'does not pick a build' do
+            expect(service.execute(specific_runner)).to be_nil
+          end
+        end
+      end
+
       context 'allow shared runners' do
         before do
           project.update(shared_runners_enabled: true)
-- 
cgit v1.2.1


From 415b032ba1d003bb407581ce3069c95ac178bfd4 Mon Sep 17 00:00:00 2001
From: Fatih Acet <acetfatih@gmail.com>
Date: Wed, 15 Jun 2016 00:15:46 +0300
Subject: Prevent default disabled buttons and links.

---
 spec/javascripts/application_spec.js.coffee     | 30 +++++++++++++++++++++++++
 spec/javascripts/fixtures/application.html.haml |  2 ++
 2 files changed, 32 insertions(+)
 create mode 100644 spec/javascripts/application_spec.js.coffee
 create mode 100644 spec/javascripts/fixtures/application.html.haml

(limited to 'spec')

diff --git a/spec/javascripts/application_spec.js.coffee b/spec/javascripts/application_spec.js.coffee
new file mode 100644
index 00000000000..8af39c41f2f
--- /dev/null
+++ b/spec/javascripts/application_spec.js.coffee
@@ -0,0 +1,30 @@
+#= require lib/common_utils
+
+describe 'Application', ->
+  describe 'disable buttons', ->
+    fixture.preload('application.html')
+
+    beforeEach ->
+      fixture.load('application.html')
+
+    it 'should prevent default action for disabled buttons', ->
+
+      gl.utils.preventDisabledButtons()
+
+      isClicked = false
+      $button   = $ '#test-button'
+
+      $button.click -> isClicked = true
+      $button.trigger 'click'
+
+      expect(isClicked).toBe false
+
+
+    it 'should be on the same page if a disabled link clicked', ->
+
+      locationBeforeLinkClick = window.location.href
+      gl.utils.preventDisabledButtons()
+
+      $('#test-link').click()
+
+      expect(window.location.href).toBe locationBeforeLinkClick
diff --git a/spec/javascripts/fixtures/application.html.haml b/spec/javascripts/fixtures/application.html.haml
new file mode 100644
index 00000000000..3fc6114407d
--- /dev/null
+++ b/spec/javascripts/fixtures/application.html.haml
@@ -0,0 +1,2 @@
+%a#test-link.btn.disabled{:href => "/foo"} Test link
+%button#test-button.btn.disabled Test Button
-- 
cgit v1.2.1


From bcbe9b4de8776dbbaee6e374200de395cae3c61a Mon Sep 17 00:00:00 2001
From: Dmitriy Zaporozhets <dmitriy.zaporozhets@gmail.com>
Date: Wed, 15 Jun 2016 18:47:43 +0300
Subject: Fix admin hooks spec

Signed-off-by: Dmitriy Zaporozhets <dmitriy.zaporozhets@gmail.com>
---
 spec/features/admin/admin_hooks_spec.rb | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/features/admin/admin_hooks_spec.rb b/spec/features/admin/admin_hooks_spec.rb
index 7265cdac7a7..31633817d53 100644
--- a/spec/features/admin/admin_hooks_spec.rb
+++ b/spec/features/admin/admin_hooks_spec.rb
@@ -12,9 +12,11 @@ describe "Admin::Hooks", feature: true do
   describe "GET /admin/hooks" do
     it "should be ok" do
       visit admin_root_path
-      page.within ".sidebar-wrapper" do
+
+      page.within ".layout-nav" do
         click_on "Hooks"
       end
+
       expect(current_path).to eq(admin_hooks_path)
     end
 
-- 
cgit v1.2.1


From b21980bff48de425a3994cb3914650d06d48e486 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9my=20Coutable?= <remy@rymai.me>
Date: Wed, 15 Jun 2016 17:25:48 +0200
Subject: Fix permission checks in member row
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Rémy Coutable <remy@rymai.me>
---
 spec/helpers/members_helper_spec.rb | 16 ----------------
 1 file changed, 16 deletions(-)

(limited to 'spec')

diff --git a/spec/helpers/members_helper_spec.rb b/spec/helpers/members_helper_spec.rb
index 0b1a76156e0..7998209b7b0 100644
--- a/spec/helpers/members_helper_spec.rb
+++ b/spec/helpers/members_helper_spec.rb
@@ -9,22 +9,6 @@ describe MembersHelper do
     it { expect(action_member_permission(:admin, group_member)).to eq :admin_group_member }
   end
 
-  describe '#can_see_member_roles?' do
-    let(:project) { create(:empty_project) }
-    let(:group) { create(:group) }
-    let(:user) { build(:user) }
-    let(:admin) { build(:user, :admin) }
-    let(:project_member) { create(:project_member, project: project) }
-    let(:group_member) { create(:group_member, group: group) }
-
-    it { expect(can_see_member_roles?(source: project, user: nil)).to be_falsy }
-    it { expect(can_see_member_roles?(source: group, user: nil)).to be_falsy }
-    it { expect(can_see_member_roles?(source: project, user: admin)).to be_truthy }
-    it { expect(can_see_member_roles?(source: group, user: admin)).to be_truthy }
-    it { expect(can_see_member_roles?(source: project, user: project_member.user)).to be_truthy }
-    it { expect(can_see_member_roles?(source: group, user: group_member.user)).to be_truthy }
-  end
-
   describe '#remove_member_message' do
     let(:requester) { build(:user) }
     let(:project) { create(:project) }
-- 
cgit v1.2.1


From 94135e6275a0c538ab0a5782c3f71152894efc2d Mon Sep 17 00:00:00 2001
From: Ilan Shamir <ilanshamir1@gmail.com>
Date: Tue, 14 Jun 2016 23:43:31 +0300
Subject: Remove JiraIssue model and replace references with ExternalIssue

---
 spec/helpers/merge_requests_helper_spec.rb        |  6 ++---
 spec/lib/gitlab/reference_extractor_spec.rb       |  3 ++-
 spec/models/jira_issue_spec.rb                    | 30 -----------------------
 spec/models/project_services/jira_service_spec.rb |  6 +++--
 spec/services/system_note_service_spec.rb         |  2 +-
 5 files changed, 10 insertions(+), 37 deletions(-)
 delete mode 100644 spec/models/jira_issue_spec.rb

(limited to 'spec')

diff --git a/spec/helpers/merge_requests_helper_spec.rb b/spec/helpers/merge_requests_helper_spec.rb
index a3336c87173..903224589dd 100644
--- a/spec/helpers/merge_requests_helper_spec.rb
+++ b/spec/helpers/merge_requests_helper_spec.rb
@@ -33,9 +33,9 @@ describe MergeRequestsHelper do
       let(:project) { create(:project) }
       let(:issues) do
         [
-          JiraIssue.new('JIRA-123', project),
-          JiraIssue.new('JIRA-456', project),
-          JiraIssue.new('FOOBAR-7890', project)
+          ExternalIssue.new('JIRA-123', project),
+          ExternalIssue.new('JIRA-456', project),
+          ExternalIssue.new('FOOBAR-7890', project)
         ]
       end
 
diff --git a/spec/lib/gitlab/reference_extractor_spec.rb b/spec/lib/gitlab/reference_extractor_spec.rb
index 7c617723e6d..7b4ccc83915 100644
--- a/spec/lib/gitlab/reference_extractor_spec.rb
+++ b/spec/lib/gitlab/reference_extractor_spec.rb
@@ -105,7 +105,8 @@ describe Gitlab::ReferenceExtractor, lib: true do
 
     it 'returns JIRA issues for a JIRA-integrated project' do
       subject.analyze('JIRA-123 and FOOBAR-4567')
-      expect(subject.issues).to eq [JiraIssue.new('JIRA-123', project), JiraIssue.new('FOOBAR-4567', project)]
+      expect(subject.issues).to eq [ExternalIssue.new('JIRA-123', project),
+                                    ExternalIssue.new('FOOBAR-4567', project)]
     end
   end
 
diff --git a/spec/models/jira_issue_spec.rb b/spec/models/jira_issue_spec.rb
deleted file mode 100644
index 1634265b439..00000000000
--- a/spec/models/jira_issue_spec.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe JiraIssue do
-  let(:project) { create(:project) }
-  subject { JiraIssue.new('JIRA-123', project) }
-
-  describe 'id' do
-    subject { super().id }
-    it { is_expected.to eq('JIRA-123') }
-  end
-
-  describe 'iid' do
-    subject { super().iid }
-    it { is_expected.to eq('JIRA-123') }
-  end
-
-  describe 'to_s' do
-    subject { super().to_s }
-    it { is_expected.to eq('JIRA-123') }
-  end
-
-  describe :== do
-    specify { expect(subject).to eq(JiraIssue.new('JIRA-123', project)) }
-    specify { expect(subject).not_to eq(JiraIssue.new('JIRA-124', project)) }
-
-    it 'only compares with JiraIssues' do
-      expect(subject).not_to eq('JIRA-123')
-    end
-  end
-end
diff --git a/spec/models/project_services/jira_service_spec.rb b/spec/models/project_services/jira_service_spec.rb
index 5309cfb99ff..c9517324541 100644
--- a/spec/models/project_services/jira_service_spec.rb
+++ b/spec/models/project_services/jira_service_spec.rb
@@ -76,7 +76,8 @@ describe JiraService, models: true do
     end
 
     it "should call JIRA API" do
-      @jira_service.execute(merge_request, JiraIssue.new("JIRA-123", project))
+      @jira_service.execute(merge_request,
+                            ExternalIssue.new("JIRA-123", project))
       expect(WebMock).to have_requested(:post, @comment_url).with(
         body: /Issue solved with/
       ).once
@@ -84,7 +85,8 @@ describe JiraService, models: true do
 
     it "calls the api with jira_issue_transition_id" do
       @jira_service.jira_issue_transition_id = 'this-is-a-custom-id'
-      @jira_service.execute(merge_request, JiraIssue.new("JIRA-123", project))
+      @jira_service.execute(merge_request,
+                            ExternalIssue.new("JIRA-123", project))
       expect(WebMock).to have_requested(:post, @api_url).with(
         body: /this-is-a-custom-id/
       ).once
diff --git a/spec/services/system_note_service_spec.rb b/spec/services/system_note_service_spec.rb
index 09f0ee3871d..85dd30bf48c 100644
--- a/spec/services/system_note_service_spec.rb
+++ b/spec/services/system_note_service_spec.rb
@@ -529,7 +529,7 @@ describe SystemNoteService, services: true do
     let(:author)     { create(:user) }
     let(:issue)      { create(:issue, project: project) }
     let(:mergereq)   { create(:merge_request, :simple, target_project: project, source_project: project) }
-    let(:jira_issue) { JiraIssue.new("JIRA-1", project)}
+    let(:jira_issue) { ExternalIssue.new("JIRA-1", project)}
     let(:jira_tracker) { project.create_jira_service if project.jira_service.nil? }
     let(:commit)     { project.commit }
 
-- 
cgit v1.2.1


From 7ee0898a9ec4a03c9a55841b1cbea67add460c50 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Thu, 16 Jun 2016 08:24:13 +0530
Subject: Implement @DouweM's feedback.

- Extract a duplicated `redirect_to`
- Fix a typo: "token", not "certificate"
- Have the "Expires at" datepicker be attached to a text field, not inline
- Have both private tokens and personal access tokens verified in a
  single "authenticate_from_private_token" method, both in the
  application and API. Move relevant logic to
  `User#find_by_personal_access_token`
- Remove unnecessary constants relating to API auth. We don't need a
  separate constant for personal access tokens since the param is the
  same as for private tokens.
---
 spec/features/profiles/personal_access_tokens_spec.rb | 1 +
 1 file changed, 1 insertion(+)

(limited to 'spec')

diff --git a/spec/features/profiles/personal_access_tokens_spec.rb b/spec/features/profiles/personal_access_tokens_spec.rb
index d824e1d288d..a85930c7543 100644
--- a/spec/features/profiles/personal_access_tokens_spec.rb
+++ b/spec/features/profiles/personal_access_tokens_spec.rb
@@ -41,6 +41,7 @@ describe 'Profile > Personal Access Tokens', feature: true, js: true do
       fill_in "Name", with: FFaker::Product.brand
 
       # Set date to 1st of next month
+      find_field("Expires at").trigger('focus')
       find("a[title='Next']").click
       click_on "1"
 
-- 
cgit v1.2.1


From e8a467e0943cfc5aea1c2c42680bfa61e1733cc7 Mon Sep 17 00:00:00 2001
From: Alfredo Sumaran <alfredo@gitlab.com>
Date: Wed, 15 Jun 2016 02:12:42 -0500
Subject: Implements TemplateDropdown class to create custom template dropdowns

Also License dropdown has been ported to use our GL dropdown instead of Select2.
Fixes tests to make it work with current implementation
---
 .../files/project_owner_creates_license_file_spec.rb       | 14 +++++++++++---
 ...es_link_to_create_license_file_in_empty_project_spec.rb | 12 ++++++++++--
 .../features/projects/labels/update_prioritization_spec.rb |  1 +
 3 files changed, 22 insertions(+), 5 deletions(-)

(limited to 'spec')

diff --git a/spec/features/projects/files/project_owner_creates_license_file_spec.rb b/spec/features/projects/files/project_owner_creates_license_file_spec.rb
index ecc818eb1e1..e1e105e6bbe 100644
--- a/spec/features/projects/files/project_owner_creates_license_file_spec.rb
+++ b/spec/features/projects/files/project_owner_creates_license_file_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 feature 'project owner creates a license file', feature: true, js: true do
-  include Select2Helper
+  include WaitForAjax
 
   let(:project_master) { create(:user) }
   let(:project) { create(:project) }
@@ -21,7 +21,7 @@ feature 'project owner creates a license file', feature: true, js: true do
 
     expect(page).to have_selector('.license-selector')
 
-    select2('mit', from: '#license_type')
+    select_template('MIT License')
 
     file_content = find('.file-content')
     expect(file_content).to have_content('The MIT License (MIT)')
@@ -44,7 +44,7 @@ feature 'project owner creates a license file', feature: true, js: true do
     expect(find('#file_name').value).to eq('LICENSE')
     expect(page).to have_selector('.license-selector')
 
-    select2('mit', from: '#license_type')
+    select_template('MIT License')
 
     file_content = find('.file-content')
     expect(file_content).to have_content('The MIT License (MIT)')
@@ -58,4 +58,12 @@ feature 'project owner creates a license file', feature: true, js: true do
     expect(page).to have_content('The MIT License (MIT)')
     expect(page).to have_content("Copyright (c) #{Time.now.year} #{project.namespace.human_name}")
   end
+
+  def select_template(template)
+    page.within('.js-license-selector-wrap') do
+      click_button 'Choose a License template'
+      click_link template
+      wait_for_ajax
+    end
+  end
 end
diff --git a/spec/features/projects/files/project_owner_sees_link_to_create_license_file_in_empty_project_spec.rb b/spec/features/projects/files/project_owner_sees_link_to_create_license_file_in_empty_project_spec.rb
index 34eda29c285..67aac25e427 100644
--- a/spec/features/projects/files/project_owner_sees_link_to_create_license_file_in_empty_project_spec.rb
+++ b/spec/features/projects/files/project_owner_sees_link_to_create_license_file_in_empty_project_spec.rb
@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 feature 'project owner sees a link to create a license file in empty project', feature: true, js: true do
-  include Select2Helper
+  include WaitForAjax
 
   let(:project_master) { create(:user) }
   let(:project) { create(:empty_project) }
@@ -20,7 +20,7 @@ feature 'project owner sees a link to create a license file in empty project', f
     expect(find('#file_name').value).to eq('LICENSE')
     expect(page).to have_selector('.license-selector')
 
-    select2('mit', from: '#license_type')
+    select_template('MIT License')
 
     file_content = find('.file-content')
     expect(file_content).to have_content('The MIT License (MIT)')
@@ -36,4 +36,12 @@ feature 'project owner sees a link to create a license file in empty project', f
     expect(page).to have_content('The MIT License (MIT)')
     expect(page).to have_content("Copyright (c) #{Time.now.year} #{project.namespace.human_name}")
   end
+
+  def select_template(template)
+    page.within('.js-license-selector-wrap') do
+      click_button 'Choose a License template'
+      click_link template
+      wait_for_ajax
+    end
+  end
 end
diff --git a/spec/features/projects/labels/update_prioritization_spec.rb b/spec/features/projects/labels/update_prioritization_spec.rb
index 8550d279d09..6a39c302f55 100644
--- a/spec/features/projects/labels/update_prioritization_spec.rb
+++ b/spec/features/projects/labels/update_prioritization_spec.rb
@@ -77,6 +77,7 @@ feature 'Prioritize labels', feature: true do
       end
 
       visit current_url
+      wait_for_ajax
 
       page.within('.prioritized-labels') do
         expect(first('li')).to have_content('wontfix')
-- 
cgit v1.2.1


From 9d7cda3ddce52baad9618466a5d00319b333be57 Mon Sep 17 00:00:00 2001
From: Timothy Andrew <mail@timothyandrew.net>
Date: Thu, 16 Jun 2016 12:28:31 +0530
Subject: Fix `api_helpers_spec`

---
 spec/requests/api/api_helpers_spec.rb | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'spec')

diff --git a/spec/requests/api/api_helpers_spec.rb b/spec/requests/api/api_helpers_spec.rb
index 06997147b09..f22db61e744 100644
--- a/spec/requests/api/api_helpers_spec.rb
+++ b/spec/requests/api/api_helpers_spec.rb
@@ -67,35 +67,35 @@ describe API::Helpers, api: true do
       let(:personal_access_token) { create(:personal_access_token, user: user) }
 
       it "should return nil for an invalid token" do
-        env[API::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = 'invalid token'
+        env[API::Helpers::PRIVATE_TOKEN_HEADER] = 'invalid token'
         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::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        env[API::Helpers::PRIVATE_TOKEN_HEADER] = personal_access_token.token
         allow(Gitlab::UserAccess).to receive(:allowed?).and_return(false)
         expect(current_user).to be_nil
       end
 
       it "should leave user as is when sudo not specified" do
-        env[API::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        env[API::Helpers::PRIVATE_TOKEN_HEADER] = personal_access_token.token
         expect(current_user).to eq(user)
         clear_env
-        params[API::Helpers::PERSONAL_ACCESS_TOKEN_PARAM] = personal_access_token.token
+        params[API::Helpers::PRIVATE_TOKEN_PARAM] = personal_access_token.token
         expect(current_user).to eq(user)
       end
 
       it 'does not allow revoked tokens' do
         personal_access_token.revoke!
-        env[API::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        env[API::Helpers::PRIVATE_TOKEN_HEADER] = personal_access_token.token
         allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
         expect(current_user).to be_nil
       end
 
       it 'does not allow expired tokens' do
         personal_access_token.update_attributes!(expires_at: 1.day.ago)
-        env[API::Helpers::PERSONAL_ACCESS_TOKEN_HEADER] = personal_access_token.token
+        env[API::Helpers::PRIVATE_TOKEN_HEADER] = personal_access_token.token
         allow_any_instance_of(self.class).to receive(:doorkeeper_guard){ false }
         expect(current_user).to be_nil
       end
-- 
cgit v1.2.1


From 84e2be5a5f3f020f1c57b013e82143ff90e48e58 Mon Sep 17 00:00:00 2001
From: Yorick Peterse <yorickpeterse@gmail.com>
Date: Wed, 15 Jun 2016 15:22:05 +0200
Subject: Turn Group#owners into a has_many association

This allows the owners to be eager loaded where needed.
---
 spec/models/group_spec.rb | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'spec')

diff --git a/spec/models/group_spec.rb b/spec/models/group_spec.rb
index ccdcb29f773..2c19aa3f67f 100644
--- a/spec/models/group_spec.rb
+++ b/spec/models/group_spec.rb
@@ -158,6 +158,18 @@ describe Group, models: true do
     it { expect(group.has_master?(@members[:requester])).to be_falsey }
   end
 
+  describe '#owners' do
+    let(:owner) { create(:user) }
+    let(:developer) { create(:user) }
+
+    it 'returns the owners of a Group' do
+      group.add_owner(owner)
+      group.add_developer(developer)
+
+      expect(group.owners).to eq([owner])
+    end
+  end
+
   def setup_group_members(group)
     members = {
       owner: create(:user),
-- 
cgit v1.2.1


From 46696bde83736a83ec6f54f05795b003793b5865 Mon Sep 17 00:00:00 2001
From: Paco Guzman <pacoguzmanp@gmail.com>
Date: Wed, 15 Jun 2016 19:00:50 +0200
Subject: Banzai::Filter::UploadLinkFilter use XPath

---
 spec/lib/banzai/filter/upload_link_filter_spec.rb | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/lib/banzai/filter/upload_link_filter_spec.rb b/spec/lib/banzai/filter/upload_link_filter_spec.rb
index b83be54746c..273d2ed709a 100644
--- a/spec/lib/banzai/filter/upload_link_filter_spec.rb
+++ b/spec/lib/banzai/filter/upload_link_filter_spec.rb
@@ -23,6 +23,14 @@ describe Banzai::Filter::UploadLinkFilter, lib: true do
     %(<a href="#{path}">#{path}</a>)
   end
 
+  def nested_image(path)
+    %(<div><img src="#{path}" /></div>)
+  end
+
+  def nested_link(path)
+    %(<div><a href="#{path}">#{path}</a></div>)
+  end
+
   let(:project) { create(:project) }
 
   shared_examples :preserve_unchanged do
@@ -47,11 +55,19 @@ describe Banzai::Filter::UploadLinkFilter, lib: true do
       doc = filter(link('/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg'))
       expect(doc.at_css('a')['href']).
         to eq "#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg"
+
+      doc = filter(nested_link('/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg'))
+      expect(doc.at_css('a')['href']).
+        to eq "#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg"
     end
 
     it 'rebuilds relative URL for an image' do
-      doc = filter(link('/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg'))
-      expect(doc.at_css('a')['href']).
+      doc = filter(image('/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg'))
+      expect(doc.at_css('img')['src']).
+        to eq "#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg"
+
+      doc = filter(nested_image('/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg'))
+      expect(doc.at_css('img')['src']).
         to eq "#{Gitlab.config.gitlab.url}/#{project.path_with_namespace}/uploads/e90decf88d8f96fe9e1389afc2e4a91f/test.jpg"
     end
 
-- 
cgit v1.2.1


From 425987861530c9c0fb7fe618d7f4bab017a80253 Mon Sep 17 00:00:00 2001
From: Yorick Peterse <yorickpeterse@gmail.com>
Date: Wed, 15 Jun 2016 18:07:04 +0200
Subject: Fixed ordering in Project.find_with_namespace

This ensures that Project.find_with_namespace returns a row matching
literally as the first value, instead of returning a random value.

The ordering here is _only_ applied to Project.find_with_namespace and
_not_ Project.where_paths_in as currently there's no code that requires
Project.where_paths_in to return rows in a certain order. Since this
method also returns all rows that match there's no real harm in not
setting a specific order either. Another reason is that generating all
the "WHEN" arms for multiple values in Project.where_paths_in becomes
really messy.

On MySQL we have to use the "BINARY" operator to turn a "WHERE" into a
case-sensitive WHERE as otherwise MySQL may still end up returning rows
in an unpredictable order.

Fixes gitlab-org/gitlab-ce#18603
---
 spec/models/project_spec.rb | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index fedab1f913b..53c8408633c 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -220,7 +220,7 @@ describe Project, models: true do
     end
   end
 
-  describe :find_with_namespace do
+  describe '.find_with_namespace' do
     context 'with namespace' do
       before do
         @group = create :group, name: 'gitlab'
@@ -231,6 +231,22 @@ describe Project, models: true do
       it { expect(Project.find_with_namespace('GitLab/GitlabHQ')).to eq(@project) }
       it { expect(Project.find_with_namespace('gitlab-ci')).to be_nil }
     end
+
+    context 'when multiple projects using a similar name exist' do
+      let(:group) { create(:group, name: 'gitlab') }
+
+      let!(:project1) do
+        create(:empty_project, name: 'gitlab1', path: 'gitlab', namespace: group)
+      end
+
+      let!(:project2) do
+        create(:empty_project, name: 'gitlab2', path: 'GITLAB', namespace: group)
+      end
+
+      it 'returns the row where the path matches literally' do
+        expect(Project.find_with_namespace('gitlab/GITLAB')).to eq(project2)
+      end
+    end
   end
 
   describe :to_param do
-- 
cgit v1.2.1


From 19a290e7bfcb5e74a0e9975fd3f7396ca0e2e990 Mon Sep 17 00:00:00 2001
From: Yorick Peterse <yorickpeterse@gmail.com>
Date: Wed, 1 Jun 2016 17:39:12 +0200
Subject: Reduce queries in IssueReferenceFilter

This reduces the number of queries executed in IssueReferenceFilter by
retrieving the various projects/issues that may be referenced in batches
_before_ iterating over all the HTML nodes.

A chunk of the logic resides in AbstractReferenceFilter so it can be
re-used by other filters in the future.
---
 .../lib/banzai/filter/abstract_link_filter_spec.rb | 52 ++++++++++++++++++++++
 .../banzai/filter/issue_reference_filter_spec.rb   |  9 ++--
 spec/services/git_push_service_spec.rb             |  3 +-
 3 files changed, 60 insertions(+), 4 deletions(-)
 create mode 100644 spec/lib/banzai/filter/abstract_link_filter_spec.rb

(limited to 'spec')

diff --git a/spec/lib/banzai/filter/abstract_link_filter_spec.rb b/spec/lib/banzai/filter/abstract_link_filter_spec.rb
new file mode 100644
index 00000000000..0c55d8e19da
--- /dev/null
+++ b/spec/lib/banzai/filter/abstract_link_filter_spec.rb
@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Banzai::Filter::AbstractReferenceFilter do
+  let(:project) { create(:empty_project) }
+
+  describe '#references_per_project' do
+    it 'returns a Hash containing references grouped per project paths' do
+      doc = Nokogiri::HTML.fragment("#1 #{project.to_reference}#2")
+      filter = described_class.new(doc, project: project)
+
+      expect(filter).to receive(:object_class).twice.and_return(Issue)
+      expect(filter).to receive(:object_sym).twice.and_return(:issue)
+
+      refs = filter.references_per_project
+
+      expect(refs).to be_an_instance_of(Hash)
+      expect(refs[project.to_reference]).to eq(Set.new(%w[1 2]))
+    end
+  end
+
+  describe '#projects_per_reference' do
+    it 'returns a Hash containing projects grouped per project paths' do
+      doc = Nokogiri::HTML.fragment('')
+      filter = described_class.new(doc, project: project)
+
+      expect(filter).to receive(:references_per_project).
+        and_return({ project.path_with_namespace => Set.new(%w[1]) })
+
+      expect(filter.projects_per_reference).
+        to eq({ project.path_with_namespace => project })
+    end
+  end
+
+  describe '#find_projects_for_paths' do
+    it 'returns a list of Projects for a list of paths' do
+      doc = Nokogiri::HTML.fragment('')
+      filter = described_class.new(doc, project: project)
+
+      expect(filter.find_projects_for_paths([project.path_with_namespace])).
+        to eq([project])
+    end
+  end
+
+  describe '#current_project_path' do
+    it 'returns the path of the current project' do
+      doc = Nokogiri::HTML.fragment('')
+      filter = described_class.new(doc, project: project)
+
+      expect(filter.current_project_path).to eq(project.path_with_namespace)
+    end
+  end
+end
diff --git a/spec/lib/banzai/filter/issue_reference_filter_spec.rb b/spec/lib/banzai/filter/issue_reference_filter_spec.rb
index 8e6a264970d..25f0bc2092f 100644
--- a/spec/lib/banzai/filter/issue_reference_filter_spec.rb
+++ b/spec/lib/banzai/filter/issue_reference_filter_spec.rb
@@ -25,7 +25,9 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
     let(:reference) { issue.to_reference }
 
     it 'ignores valid references when using non-default tracker' do
-      expect(project).to receive(:get_issue).with(issue.iid).and_return(nil)
+      expect_any_instance_of(described_class).to receive(:find_object).
+        with(project, issue.iid).
+        and_return(nil)
 
       exp = act = "Issue #{reference}"
       expect(reference_filter(act).to_html).to eq exp
@@ -107,8 +109,9 @@ describe Banzai::Filter::IssueReferenceFilter, lib: true do
     let(:reference) { issue.to_reference(project) }
 
     it 'ignores valid references when cross-reference project uses external tracker' do
-      expect_any_instance_of(Project).to receive(:get_issue).
-        with(issue.iid).and_return(nil)
+      expect_any_instance_of(described_class).to receive(:find_object).
+        with(project2, issue.iid).
+        and_return(nil)
 
       exp = act = "Issue #{reference}"
       expect(reference_filter(act).to_html).to eq exp
diff --git a/spec/services/git_push_service_spec.rb b/spec/services/git_push_service_spec.rb
index 18692f1279a..f99ad046f0d 100644
--- a/spec/services/git_push_service_spec.rb
+++ b/spec/services/git_push_service_spec.rb
@@ -312,7 +312,8 @@ describe GitPushService, services: true do
       end
 
       it "doesn't close issues when external issue tracker is in use" do
-        allow(project).to receive(:default_issues_tracker?).and_return(false)
+        allow_any_instance_of(Project).to receive(:default_issues_tracker?).
+          and_return(false)
 
         # The push still shouldn't create cross-reference notes.
         expect do
-- 
cgit v1.2.1


From ae6a54f73caaa0d9023d09f0820f3bee1e0cd0d4 Mon Sep 17 00:00:00 2001
From: Paco Guzman <pacoguzmanp@gmail.com>
Date: Thu, 16 Jun 2016 09:56:58 +0200
Subject: Banzai::Filter::ExternalLinkFilter use XPath

---
 .../lib/banzai/filter/external_link_filter_spec.rb | 34 +++++++++++++++-------
 1 file changed, 23 insertions(+), 11 deletions(-)

(limited to 'spec')

diff --git a/spec/lib/banzai/filter/external_link_filter_spec.rb b/spec/lib/banzai/filter/external_link_filter_spec.rb
index f4c5c621bd0..695a5bc6fd4 100644
--- a/spec/lib/banzai/filter/external_link_filter_spec.rb
+++ b/spec/lib/banzai/filter/external_link_filter_spec.rb
@@ -19,19 +19,31 @@ describe Banzai::Filter::ExternalLinkFilter, lib: true do
     expect(filter(act).to_html).to eq exp
   end
 
-  it 'adds rel="nofollow" to external links' do
-    act = %q(<a href="https://google.com/">Google</a>)
-    doc = filter(act)
-
-    expect(doc.at_css('a')).to have_attribute('rel')
-    expect(doc.at_css('a')['rel']).to include 'nofollow'
+  context 'for root links on document' do
+    let(:doc) { filter %q(<a href="https://google.com/">Google</a>) }
+
+    it 'adds rel="nofollow" to external links' do
+      expect(doc.at_css('a')).to have_attribute('rel')
+      expect(doc.at_css('a')['rel']).to include 'nofollow'
+    end
+
+    it 'adds rel="noreferrer" to external links' do
+      expect(doc.at_css('a')).to have_attribute('rel')
+      expect(doc.at_css('a')['rel']).to include 'noreferrer'
+    end
   end
 
-  it 'adds rel="noreferrer" to external links' do
-    act = %q(<a href="https://google.com/">Google</a>)
-    doc = filter(act)
+  context 'for nested links on document' do
+    let(:doc) { filter %q(<p><a href="https://google.com/">Google</a></p>) }
+
+    it 'adds rel="nofollow" to external links' do
+      expect(doc.at_css('a')).to have_attribute('rel')
+      expect(doc.at_css('a')['rel']).to include 'nofollow'
+    end
 
-    expect(doc.at_css('a')).to have_attribute('rel')
-    expect(doc.at_css('a')['rel']).to include 'noreferrer'
+    it 'adds rel="noreferrer" to external links' do
+      expect(doc.at_css('a')).to have_attribute('rel')
+      expect(doc.at_css('a')['rel']).to include 'noreferrer'
+    end
   end
 end
-- 
cgit v1.2.1


From 7b66dcf65e240723ae6c8772492bbb79cf4a348e Mon Sep 17 00:00:00 2001
From: Robert Speicher <rspeicher@gmail.com>
Date: Wed, 25 May 2016 17:53:26 -0400
Subject: Add previews for all customized Devise emails

---
 spec/mailers/previews/devise_mailer_preview.rb | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/mailers/previews/devise_mailer_preview.rb b/spec/mailers/previews/devise_mailer_preview.rb
index dc3062a4332..d6588efc486 100644
--- a/spec/mailers/previews/devise_mailer_preview.rb
+++ b/spec/mailers/previews/devise_mailer_preview.rb
@@ -1,11 +1,30 @@
 class DeviseMailerPreview < ActionMailer::Preview
   def confirmation_instructions_for_signup
-    user = User.new(name: 'Jane Doe', email: 'signup@example.com')
-    DeviseMailer.confirmation_instructions(user, 'faketoken', {})
+    DeviseMailer.confirmation_instructions(unsaved_user, 'faketoken', {})
   end
 
   def confirmation_instructions_for_new_email
     user = User.last
+    user.unconfirmed_email = 'unconfirmed@example.com'
+
     DeviseMailer.confirmation_instructions(user, 'faketoken', {})
   end
+
+  def reset_password_instructions
+    DeviseMailer.reset_password_instructions(unsaved_user, 'faketoken', {})
+  end
+
+  def unlock_instructions
+    DeviseMailer.unlock_instructions(unsaved_user, 'faketoken', {})
+  end
+
+  def password_change
+    DeviseMailer.password_change(unsaved_user, {})
+  end
+
+  private
+
+  def unsaved_user
+    User.new(name: 'Jane Doe', email: 'jdoe@example.com')
+  end
 end
-- 
cgit v1.2.1


From aef6214c42c6b6abc7f84f9c92f5f9b836157c9a Mon Sep 17 00:00:00 2001
From: Kamil Trzcinski <ayufan@ayufan.eu>
Date: Fri, 17 Jun 2016 11:43:08 +0200
Subject: Validate only and except regexp

Currently the RegexpError can be raised when processing next stage which leads to 500 in different places of code base.
This adds early check that regexps used in only and except are valid.
---
 spec/lib/ci/gitlab_ci_yaml_processor_spec.rb | 59 +++++++++++++++++++++++++++-
 1 file changed, 58 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb b/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
index 143e2e6d238..b0b03146d0c 100644
--- a/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
+++ b/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
@@ -157,6 +157,35 @@ module Ci
           expect(config_processor.builds_for_stage_and_ref("test", "deploy").size).to eq(1)
           expect(config_processor.builds_for_stage_and_ref("deploy", "master").size).to eq(1)
         end
+
+        context 'for invalid value' do
+          let(:config) { { rspec: { script: "rspec", type: "test", only: only } } }
+          let(:processor) { GitlabCiYamlProcessor.new(YAML.dump(config)) }
+
+          shared_examples 'raises an error' do
+            it do
+              expect { processor }.to raise_error(GitlabCiYamlProcessor::ValidationError, 'rspec job: only parameter should be an array of strings or regexps')
+            end
+          end
+
+          context 'when it is integer' do
+            let(:only) { 1 }
+
+            it_behaves_like 'raises an error'
+          end
+
+          context 'when it is an array of integers' do
+            let(:only) { [1, 1] }
+
+            it_behaves_like 'raises an error'
+          end
+
+          context 'when it is invalid regex' do
+            let(:only) { ["/*invalid/"] }
+
+            it_behaves_like 'raises an error'
+          end
+        end
       end
 
       describe :except do
@@ -284,8 +313,36 @@ module Ci
           expect(config_processor.builds_for_stage_and_ref("test", "test").size).to eq(0)
           expect(config_processor.builds_for_stage_and_ref("deploy", "master").size).to eq(0)
         end
-      end
 
+        context 'for invalid value' do
+          let(:config) { { rspec: { script: "rspec", except: except } } }
+          let(:processor) { GitlabCiYamlProcessor.new(YAML.dump(config)) }
+
+          shared_examples 'raises an error' do
+            it do
+              expect { processor }.to raise_error(GitlabCiYamlProcessor::ValidationError, 'rspec job: except parameter should be an array of strings or regexps')
+            end
+          end
+
+          context 'when it is integer' do
+            let(:except) { 1 }
+
+            it_behaves_like 'raises an error'
+          end
+
+          context 'when it is an array of integers' do
+            let(:except) { [1, 1] }
+
+            it_behaves_like 'raises an error'
+          end
+
+          context 'when it is invalid regex' do
+            let(:except) { ["/*invalid/"] }
+
+            it_behaves_like 'raises an error'
+          end
+        end
+      end
     end
     
     describe "Scripts handling" do
-- 
cgit v1.2.1


From d63673d6df703664aa95909c723df08449c573b5 Mon Sep 17 00:00:00 2001
From: Kamil Trzcinski <ayufan@ayufan.eu>
Date: Fri, 17 Jun 2016 12:58:26 +0200
Subject: Make sure that artifacts_file is nullified after removing artifacts

---
 spec/workers/expire_build_artifacts_worker_spec.rb | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'spec')

diff --git a/spec/workers/expire_build_artifacts_worker_spec.rb b/spec/workers/expire_build_artifacts_worker_spec.rb
index e3827cae9a6..7d6668920c0 100644
--- a/spec/workers/expire_build_artifacts_worker_spec.rb
+++ b/spec/workers/expire_build_artifacts_worker_spec.rb
@@ -20,6 +20,10 @@ describe ExpireBuildArtifactsWorker do
       it 'does remove files' do
         expect(build.reload.artifacts_file.exists?).to be_falsey
       end
+
+      it 'does nullify artifacts_file column' do
+        expect(build.reload.artifacts_file_identifier).to be_nil
+      end
     end
 
     context 'with not yet expired artifacts' do
@@ -32,6 +36,10 @@ describe ExpireBuildArtifactsWorker do
       it 'does not remove files' do
         expect(build.reload.artifacts_file.exists?).to be_truthy
       end
+
+      it 'does not nullify artifacts_file column' do
+        expect(build.reload.artifacts_file_identifier).not_to be_nil
+      end
     end
 
     context 'without expire date' do
@@ -44,6 +52,10 @@ describe ExpireBuildArtifactsWorker do
       it 'does not remove files' do
         expect(build.reload.artifacts_file.exists?).to be_truthy
       end
+
+      it 'does not nullify artifacts_file column' do
+        expect(build.reload.artifacts_file_identifier).not_to be_nil
+      end
     end
 
     context 'for expired artifacts' do
-- 
cgit v1.2.1


From eaa91cbe12a6919c865615f64c6e61e779c5f1ad Mon Sep 17 00:00:00 2001
From: Grzegorz Bizon <grzesiek.bizon@gmail.com>
Date: Fri, 17 Jun 2016 14:14:55 +0200
Subject: Fix error when CI job variables not specified

---
 spec/lib/ci/gitlab_ci_yaml_processor_spec.rb | 56 +++++++++++++++++++---------
 1 file changed, 39 insertions(+), 17 deletions(-)

(limited to 'spec')

diff --git a/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb b/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
index 143e2e6d238..1c775c182f1 100644
--- a/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
+++ b/spec/lib/ci/gitlab_ci_yaml_processor_spec.rb
@@ -287,13 +287,13 @@ module Ci
       end
 
     end
-    
+
     describe "Scripts handling" do
       let(:config_data) { YAML.dump(config) }
       let(:config_processor) { GitlabCiYamlProcessor.new(config_data, path) }
-      
+
       subject { config_processor.builds_for_stage_and_ref("test", "master").first }
-      
+
       describe "before_script" do
         context "in global context" do
           let(:config) do
@@ -302,12 +302,12 @@ module Ci
               test: { script: ["script"] }
             }
           end
-          
+
           it "return commands with scripts concencaced" do
             expect(subject[:commands]).to eq("global script\nscript")
           end
         end
- 
+
         context "overwritten in local context" do
           let(:config) do
             {
@@ -465,19 +465,41 @@ module Ci
         end
 
         context 'when syntax is incorrect' do
-          it 'raises error' do
-            variables = [:KEY1, 'value1', :KEY2, 'value2']
-
-            config =  YAML.dump(
-              { before_script: ['pwd'],
-                rspec: {
-                  variables: variables,
-                  script: 'rspec' }
-              })
+          context 'when variables defined but invalid' do
+            it 'raises error' do
+              variables = [:KEY1, 'value1', :KEY2, 'value2']
+
+              config =  YAML.dump(
+                { before_script: ['pwd'],
+                  rspec: {
+                    variables: variables,
+                    script: 'rspec' }
+                })
+
+              expect { GitlabCiYamlProcessor.new(config, path) }
+                .to raise_error(GitlabCiYamlProcessor::ValidationError,
+                                 /job: variables should be a map/)
+            end
+          end
 
-            expect { GitlabCiYamlProcessor.new(config, path) }
-              .to raise_error(GitlabCiYamlProcessor::ValidationError,
-                               /job: variables should be a map/)
+          context 'when variables key defined but value not specified' do
+            it 'returns empty array' do
+              config =  YAML.dump(
+                { before_script: ['pwd'],
+                  rspec: {
+                    variables: nil,
+                    script: 'rspec' }
+                })
+
+              config_processor = GitlabCiYamlProcessor.new(config, path)
+
+              ##
+              #  TODO, in next version of CI configuration processor this
+              # should be invalid configuration, see #18775 and #15060
+              #
+              expect(config_processor.job_variables(:rspec))
+                .to be_an_instance_of(Array).and be_empty
+            end
           end
         end
       end
-- 
cgit v1.2.1