Merge branch 'ce-to-ee-2018-04-10' into 'master'

CE upstream - 2018-04-10 12:26 UTC

See merge request gitlab-org/gitlab-ee!5310

GITALY_SERVER_VERSION

-0.94.0
+0.95.0

app/assets/javascripts/commit/pipelines/pipelines_table.vue

@@ -55,14 +55,13 @@
     },
     methods: {
       successCallback(resp) {
-        return resp.json().then((response) => {
         // depending of the endpoint the response can either bring a `pipelines` key or not.
-          const pipelines = response.pipelines || response;
+        const pipelines = resp.data.pipelines || resp.data;
         this.setCommonData(pipelines);
 
         const updatePipelinesEvent = new CustomEvent('update-pipelines-count', {
           detail: {
-              pipelines: response,
+            pipelines: resp.data,
           },
         });
 
@@ -70,7 +69,6 @@
         if (this.$el.parentElement) {
           this.$el.parentElement.dispatchEvent(updatePipelinesEvent);
         }
-        });
       },
     },
   };

app/assets/javascripts/pipelines/components/pipelines.vue

@@ -7,10 +7,7 @@
   import TablePagination from '../../vue_shared/components/table_pagination.vue';
   import NavigationTabs from '../../vue_shared/components/navigation_tabs.vue';
   import NavigationControls from './nav_controls.vue';
-  import {
-    getParameterByName,
-    parseQueryStringIntoObject,
-  } from '../../lib/utils/common_utils';
+  import { getParameterByName } from '../../lib/utils/common_utils';
   import CIPaginationMixin from '../../vue_shared/mixins/ci_pagination_api_mixin';
 
   export default {
@@ -19,10 +16,7 @@
       NavigationTabs,
       NavigationControls,
     },
-    mixins: [
-      pipelinesMixin,
-      CIPaginationMixin,
-    ],
+    mixins: [pipelinesMixin, CIPaginationMixin],
     props: {
       store: {
         type: Object,
@@ -147,25 +141,26 @@
        */
       shouldRenderTabs() {
         const { stateMap } = this.$options;
-        return this.hasMadeRequest &&
-          [
-            stateMap.loading,
-            stateMap.tableList,
-            stateMap.error,
-            stateMap.emptyTab,
-          ].includes(this.stateToRender);
+        return (
+          this.hasMadeRequest &&
+          [stateMap.loading, stateMap.tableList, stateMap.error, stateMap.emptyTab].includes(
+            this.stateToRender,
+          )
+        );
       },
 
       shouldRenderButtons() {
-        return (this.newPipelinePath ||
-          this.resetCachePath ||
-          this.ciLintPath) && this.shouldRenderTabs;
+        return (
+          (this.newPipelinePath || this.resetCachePath || this.ciLintPath) && this.shouldRenderTabs
+        );
       },
 
       shouldRenderPagination() {
-        return !this.isLoading &&
+        return (
+          !this.isLoading &&
           this.state.pipelines.length &&
-          this.state.pageInfo.total > this.state.pageInfo.perPage;
+          this.state.pageInfo.total > this.state.pageInfo.perPage
+        );
       },
 
       emptyTabMessage() {
@@ -229,15 +224,13 @@
     },
     methods: {
       successCallback(resp) {
-        return resp.json().then((response) => {
         // Because we are polling & the user is interacting verify if the response received
         // matches the last request made
-          if (_.isEqual(parseQueryStringIntoObject(resp.url.split('?')[1]), this.requestData)) {
-            this.store.storeCount(response.count);
+        if (_.isEqual(resp.config.params, this.requestData)) {
+          this.store.storeCount(resp.data.count);
           this.store.storePagination(resp.headers);
-            this.setCommonData(response.pipelines);
+          this.setCommonData(resp.data.pipelines);
         }
-        });
       },
       /**
        * Handles URL and query parameter changes.
@@ -251,8 +244,9 @@
         this.updateInternalState(parameters);
 
         // fetch new data
-        return this.service.getPipelines(this.requestData)
-          .then((response) => {
+        return this.service
+          .getPipelines(this.requestData)
+          .then(response => {
             this.isLoading = false;
             this.successCallback(response);
 
@@ -271,13 +265,11 @@
       handleResetRunnersCache(endpoint) {
         this.isResetCacheButtonLoading = true;
 
-        this.service.postAction(endpoint)
+        this.service
+          .postAction(endpoint)
           .then(() => {
             this.isResetCacheButtonLoading = false;
-            createFlash(
-              s__('Pipelines|Project cache successfully reset.'),
-              'notice',
-            );
+            createFlash(s__('Pipelines|Project cache successfully reset.'), 'notice');
           })
           .catch(() => {
             this.isResetCacheButtonLoading = false;

app/assets/javascripts/pipelines/services/pipelines_service.js

-/* eslint-disable class-methods-use-this */
-import Vue from 'vue';
-import VueResource from 'vue-resource';
-import '../../vue_shared/vue_resource_interceptor';
-
-Vue.use(VueResource);
+import axios from '../../lib/utils/axios_utils';
 
 export default class PipelinesService {
-
   /**
    * Commits and merge request endpoints need to be requested with `.json`.
    *
@@ -16,20 +10,18 @@ export default class PipelinesService {
    * @param  {String} root
    */
   constructor(root) {
-    let endpoint;
-
     if (root.indexOf('.json') === -1) {
-      endpoint = `${root}.json`;
+      this.endpoint = `${root}.json`;
     } else {
-      endpoint = root;
+      this.endpoint = root;
     }
-
-    this.pipelines = Vue.resource(endpoint);
   }
 
   getPipelines(data = {}) {
     const { scope, page } = data;
-    return this.pipelines.get({ scope, page });
+    return axios.get(this.endpoint, {
+      params: { scope, page },
+    });
   }
 
   /**
@@ -38,7 +30,8 @@ export default class PipelinesService {
    * @param  {String} endpoint
    * @return {Promise}
    */
+  // eslint-disable-next-line class-methods-use-this
   postAction(endpoint) {
-    return Vue.http.post(`${endpoint}.json`);
+    return axios.post(`${endpoint}.json`);
   }
 }

app/models/deploy_token.rb

@@ -34,7 +34,7 @@ class DeployToken < ActiveRecord::Base
   end
 
   def has_access_to?(requested_project)
-    project == requested_project
+    active? && project == requested_project
   end
 
   # This is temporal. Currently we limit DeployToken

app/services/auth/container_registry_authentication_service.rb

@@ -149,7 +149,8 @@ module Auth
     def deploy_token_can_pull?(requested_project)
       has_authentication_ability?(:read_container_image) &&
         current_user.is_a?(DeployToken) &&
-        current_user.has_access_to?(requested_project)
+        current_user.has_access_to?(requested_project) &&
+        current_user.read_registry?
     end
 
     ##

app/services/ci/register_job_service.rb

@@ -6,9 +6,6 @@ module Ci
 
     attr_reader :runner
 
-    JOB_QUEUE_DURATION_SECONDS_BUCKETS = [1, 3, 10, 30].freeze
-    JOBS_RUNNING_FOR_PROJECT_MAX_BUCKET = 5.freeze
-
     Result = Struct.new(:build, :valid?)
 
     def initialize(runner)
@@ -109,22 +106,10 @@ module Ci
     end
 
     def register_success(job)
-      labels = { shared_runner: runner.shared?,
-                 jobs_running_for_project: jobs_running_for_project(job) }
-
-      job_queue_duration_seconds.observe(labels, Time.now - job.queued_at)
+      job_queue_duration_seconds.observe({ shared_runner: @runner.shared? }, Time.now - job.created_at)
       attempt_counter.increment
     end
 
-    def jobs_running_for_project(job)
-      return '+Inf' unless runner.shared?
-
-      # excluding currently started job
-      running_jobs_count = job.project.builds.running.where(runner: Ci::Runner.shared)
-                              .limit(JOBS_RUNNING_FOR_PROJECT_MAX_BUCKET + 1).count - 1
-      running_jobs_count < JOBS_RUNNING_FOR_PROJECT_MAX_BUCKET ? running_jobs_count : "#{JOBS_RUNNING_FOR_PROJECT_MAX_BUCKET}+"
-    end
-
     def failed_attempt_counter
       @failed_attempt_counter ||= Gitlab::Metrics.counter(:job_register_attempts_failed_total, "Counts the times a runner tries to register a job")
     end
@@ -134,7 +119,7 @@ module Ci
     end
 
     def job_queue_duration_seconds
-      @job_queue_duration_seconds ||= Gitlab::Metrics.histogram(:job_queue_duration_seconds, 'Request handling execution time', {}, JOB_QUEUE_DURATION_SECONDS_BUCKETS)
+      @job_queue_duration_seconds ||= Gitlab::Metrics.histogram(:job_queue_duration_seconds, 'Request handling execution time')
     end
   end
 end

changelogs/unreleased/40487-axios-pipelines.yml

+title: Replace vue resource with axios in pipelines table
+merge_request:
+author:
+type: other
\ No newline at end of file

changelogs/unreleased/deploy-tokens-container-registry-specs.yml

+---
+title: Verify that deploy token has valid access when pulling container registry image
+merge_request: 18260
+author:
+type: fixed

changelogs/unreleased/improve-jobs-queuing-time-metric.yml

----
-title: Partition job_queue_duration_seconds with jobs_running_for_project
-merge_request: 17730
-author:
-type: changed

doc/development/gitaly.md

@@ -7,6 +7,67 @@ be replaced by Gitaly API calls.
 Visit the [Gitaly Migration Board](https://gitlab.com/gitlab-org/gitaly/boards/331341) for current
 status of the migration.
 
+## Developing new Git features
+
+Starting with Gitlab 10.8, all new Git features should be developed in
+Gitaly.
+
+> This is a new process that is not clearly defined yet. If you want
+to contribute a Git feature and you're getting stuck, reach out to the
+Gitaly team or `@jacobvosmaer-gitlab`.
+
+By 'new feature' we mean any method or class in `lib/gitlab/git` that is
+called from outside `lib/gitlab/git`. For new methods that are called
+from inside `lib/gitlab/git`, see 'Modifying existing Git features'
+below.
+
+There should be no new code that touches Git repositories via
+disk access (e.g. Rugged, `git`, `rm -rf`) anywhere outside
+`lib/gitlab/git`.
+
+The process for adding new Gitaly features is:
+
+- exploration / prototyping
+- design and create a new Gitaly RPC [in gitaly-proto](https://gitlab.com/gitlab-org/gitaly-proto)
+- release a new version of gitaly-proto
+- write implementation and tests for the RPC [in Gitaly](https://gitlab.com/gitlab-org/gitaly), in Go or Ruby
+- release a new version of Gitaly
+- write client code in gitlab-ce/ee, gitlab-workhorse or gitlab-shell that calls the new Gitaly RPC
+
+These steps often overlap. It is possible to use an unreleased version
+of Gitaly and gitaly-proto during testing and development.
+
+- See the [Gitaly repo](https://gitlab.com/gitlab-org/gitaly/blob/master/CONTRIBUTING.md#development-and-testing-with-a-custom-gitaly-proto) for instructions on writing server side code with an unreleased protocol.
+- See [below](#running-tests-with-a-locally-modified-version-of-gitaly) for instructions on running gitlab-ce tests with a modified version of Gitaly.
+- In GDK run `gdk install` and restart `gdk run` (or `gdk run app`) to use a locally modified Gitaly version for development
+
+### Gitaly-ruby
+
+It is possible to implement and test RPC's in Gitaly using Ruby code,
+in
+[gitaly-ruby](https://gitlab.com/gitlab-org/gitaly/tree/master/ruby).
+This should make it easier to contribute for developers who are less
+comfortable writing Go code.
+
+There is documentation for this approach in [the Gitaly
+repo](https://gitlab.com/gitlab-org/gitaly/blob/master/doc/ruby_endpoint.md).
+
+## Modifying existing Git features
+
+If you modify existing Git features in `lib/gitlab/git` you need to make
+sure the changes also work in Gitaly. Because we are still in the
+migration process there are a number of subtle pitfalls. Features that
+have been migrated have dual implementations (Gitaly and local). The
+Gitaly implementation may or may not use a vendored (and therefore
+possibly outdated) copy of the local implementation in `lib/gitlab/git`.
+
+To avoid unexpected problems and conflicts, all changes to
+`lib/gitlab/git` need to be approved by a member of the Gitaly team.
+
+For the time being, while the Gitaly migration is still in progress,
+there should be no Enterprise Edition-only Git code in
+`lib/gitlab/git`. Also no mixins.
+
 ## Feature Flags
 
 Gitaly makes heavy use of [feature flags](feature_flags.md).
@@ -99,10 +160,14 @@ end
 
 ## Running tests with a locally modified version of Gitaly
 
-Normally, gitlab-ce/ee tests use a local clone of Gitaly in `tmp/tests/gitaly`
-pinned at the version specified in GITALY_SERVER_VERSION. If you want
-to run tests locally against a modified version of Gitaly you can
-replace `tmp/tests/gitaly` with a symlink.
+Normally, gitlab-ce/ee tests use a local clone of Gitaly in
+`tmp/tests/gitaly` pinned at the version specified in
+`GITALY_SERVER_VERSION`. The `GITALY_SERVER_VERSION` file supports
+`=my-branch` syntax to use a custom branch in gitlab-org/gitaly. If
+you want to run tests locally against a modified version of Gitaly you
+can replace `tmp/tests/gitaly` with a symlink. This is much faster
+because the `=my-branch` syntax forces a Gitaly re-install each time
+you run `rspec`.
 
 ```shell
 rm -rf tmp/tests/gitaly

spec/factories/ci/builds.rb

@@ -62,7 +62,6 @@ FactoryBot.define do
     end
 
     trait :pending do
-      queued_at 'Di 29. Okt 09:50:59 CET 2013'
       status 'pending'
     end
 

spec/javascripts/commit/pipelines/pipelines_spec.js

-import _ from 'underscore';
 import Vue from 'vue';
+import MockAdapter from 'axios-mock-adapter';
+import axios from '~/lib/utils/axios_utils';
 import pipelinesTable from '~/commit/pipelines/pipelines_table.vue';
+import mountComponent from 'spec/helpers/vue_mount_component_helper';
 
 describe('Pipelines table in Commits and Merge requests', () => {
   const jsonFixtureName = 'pipelines/pipelines.json';
   let pipeline;
   let PipelinesTable;
+  let mock;
+  let vm;
 
   preloadFixtures(jsonFixtureName);
 
   beforeEach(() => {
+    mock = new MockAdapter(axios);
+
     const pipelines = getJSONFixture(jsonFixtureName).pipelines;
 
     PipelinesTable = Vue.extend(pipelinesTable);
     pipeline = pipelines.find(p => p.user !== null && p.commit !== null);
   });
 
+  afterEach(() => {
+    vm.$destroy();
+    mock.restore();
+  });
+
   describe('successful request', () => {
     describe('without pipelines', () => {
-      const pipelinesEmptyResponse = (request, next) => {
-        next(request.respondWith(JSON.stringify([]), {
-          status: 200,
-        }));
-      };
-
       beforeEach(function () {
-        Vue.http.interceptors.push(pipelinesEmptyResponse);
+        mock.onGet('endpoint.json').reply(200, []);
 
-        this.component = new PipelinesTable({
-          propsData: {
-            endpoint: 'endpoint',
+        vm = mountComponent(PipelinesTable, {
+          endpoint: 'endpoint.json',
           helpPagePath: 'foo',
           emptyStateSvgPath: 'foo',
           errorStateSvgPath: 'foo',
           autoDevopsHelpPath: 'foo',
-          },
-        }).$mount();
         });
-
-      afterEach(function () {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, pipelinesEmptyResponse,
-        );
-        this.component.$destroy();
       });
 
       it('should render the empty state', function (done) {
         setTimeout(() => {
-          expect(this.component.$el.querySelector('.empty-state')).toBeDefined();
-          expect(this.component.$el.querySelector('.realtime-loading')).toBe(null);
-          expect(this.component.$el.querySelector('.js-pipelines-error-state')).toBe(null);
+          expect(vm.$el.querySelector('.empty-state')).toBeDefined();
+          expect(vm.$el.querySelector('.realtime-loading')).toBe(null);
+          expect(vm.$el.querySelector('.js-pipelines-error-state')).toBe(null);
           done();
-        }, 1);
+        }, 0);
       });
     });
 
     describe('with pipelines', () => {
-      const pipelinesResponse = (request, next) => {
-        next(request.respondWith(JSON.stringify([pipeline]), {
-          status: 200,
-        }));
-      };
-
       beforeEach(() => {
-        Vue.http.interceptors.push(pipelinesResponse);
-
-        this.component = new PipelinesTable({
-          propsData: {
-            endpoint: 'endpoint',
+        mock.onGet('endpoint.json').reply(200, [pipeline]);
+        vm = mountComponent(PipelinesTable, {
+          endpoint: 'endpoint.json',
           helpPagePath: 'foo',
           emptyStateSvgPath: 'foo',
           errorStateSvgPath: 'foo',
           autoDevopsHelpPath: 'foo',
-          },
-        }).$mount();
         });
-
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, pipelinesResponse,
-        );
-        this.component.$destroy();
       });
 
       it('should render a table with the received pipelines', (done) => {
         setTimeout(() => {
-          expect(this.component.$el.querySelectorAll('.ci-table .commit').length).toEqual(1);
-          expect(this.component.$el.querySelector('.realtime-loading')).toBe(null);
-          expect(this.component.$el.querySelector('.empty-state')).toBe(null);
-          expect(this.component.$el.querySelector('.js-pipelines-error-state')).toBe(null);
+          expect(vm.$el.querySelectorAll('.ci-table .commit').length).toEqual(1);
+          expect(vm.$el.querySelector('.realtime-loading')).toBe(null);
+          expect(vm.$el.querySelector('.empty-state')).toBe(null);
+          expect(vm.$el.querySelector('.js-pipelines-error-state')).toBe(null);
           done();
         }, 0);
       });
     });
 
     describe('pipeline badge counts', () => {
-      const pipelinesResponse = (request, next) => {
-        next(request.respondWith(JSON.stringify([pipeline]), {
-          status: 200,
-        }));
-      };
-
       beforeEach(() => {
-        Vue.http.interceptors.push(pipelinesResponse);
-      });
-
-      afterEach(() => {
-        Vue.http.interceptors = _.without(Vue.http.interceptors, pipelinesResponse);
-        this.component.$destroy();
+        mock.onGet('endpoint.json').reply(200, [pipeline]);
       });
 
       it('should receive update-pipelines-count event', (done) => {
@@ -119,54 +88,38 @@ describe('Pipelines table in Commits and Merge requests', () => {
           done();
         });
 
-        this.component = new PipelinesTable({
-          propsData: {
-            endpoint: 'endpoint',
+        vm = mountComponent(PipelinesTable, {
+          endpoint: 'endpoint.json',
           helpPagePath: 'foo',
           emptyStateSvgPath: 'foo',
           errorStateSvgPath: 'foo',
           autoDevopsHelpPath: 'foo',
-          },
-        }).$mount();
-        element.appendChild(this.component.$el);
+        });
+
+        element.appendChild(vm.$el);
       });
     });
   });
 
   describe('unsuccessfull request', () => {
-    const pipelinesErrorResponse = (request, next) => {
-      next(request.respondWith(JSON.stringify([]), {
-        status: 500,
-      }));
-    };
-
-    beforeEach(function () {
-      Vue.http.interceptors.push(pipelinesErrorResponse);
+    beforeEach(() => {
+      mock.onGet('endpoint.json').reply(500, []);
 
-      this.component = new PipelinesTable({
-        propsData: {
-          endpoint: 'endpoint',
+      vm = mountComponent(PipelinesTable, {
+        endpoint: 'endpoint.json',
         helpPagePath: 'foo',
         emptyStateSvgPath: 'foo',
         errorStateSvgPath: 'foo',
         autoDevopsHelpPath: 'foo',
-        },
-      }).$mount();
       });
-
-    afterEach(function () {
-      Vue.http.interceptors = _.without(
-        Vue.http.interceptors, pipelinesErrorResponse,
-      );
-      this.component.$destroy();
     });
 
     it('should render error state', function (done) {
       setTimeout(() => {
-        expect(this.component.$el.querySelector('.js-pipelines-error-state')).toBeDefined();
-        expect(this.component.$el.querySelector('.realtime-loading')).toBe(null);
-        expect(this.component.$el.querySelector('.js-empty-state')).toBe(null);
-        expect(this.component.$el.querySelector('.ci-table')).toBe(null);
+        expect(vm.$el.querySelector('.js-pipelines-error-state')).toBeDefined();
+        expect(vm.$el.querySelector('.realtime-loading')).toBe(null);
+        expect(vm.$el.querySelector('.js-empty-state')).toBe(null);
+        expect(vm.$el.querySelector('.ci-table')).toBe(null);
         done();
       }, 0);
     });

spec/javascripts/pipelines/pipelines_spec.js

-import _ from 'underscore';
 import Vue from 'vue';
+import MockAdapter from 'axios-mock-adapter';
+import axios from '~/lib/utils/axios_utils';
 import pipelinesComp from '~/pipelines/components/pipelines.vue';
 import Store from '~/pipelines/stores/pipelines_store';
 import mountComponent from 'spec/helpers/vue_mount_component_helper';
@@ -12,6 +13,8 @@ describe('Pipelines', () => {
   let PipelinesComponent;
   let pipelines;
   let vm;
+  let mock;
+
   const paths = {
     endpoint: 'twitter/flight/pipelines.json',
     autoDevopsPath: '/help/topics/autodevops/index.md',
@@ -34,6 +37,8 @@ describe('Pipelines', () => {
   };
 
   beforeEach(() => {
+    mock = new MockAdapter(axios);
+
     pipelines = getJSONFixture(jsonFixtureName);
 
     PipelinesComponent = Vue.extend(pipelinesComp);
@@ -41,38 +46,14 @@ describe('Pipelines', () => {
 
   afterEach(() => {
     vm.$destroy();
+    mock.restore();
   });
 
-  const pipelinesInterceptor = (request, next) => {
-    next(request.respondWith(JSON.stringify(pipelines), {
-      status: 200,
-    }));
-  };
-
-  const emptyStateInterceptor = (request, next) => {
-    next(request.respondWith(JSON.stringify({
-      pipelines: [],
-      count: {
-        all: 0,
-        pending: 0,
-        running: 0,
-        finished: 0,
-      },
-    }), {
-      status: 200,
-    }));
-  };
-
-  const errorInterceptor = (request, next) => {
-    next(request.respondWith(JSON.stringify({}), {
-      status: 500,
-    }));
-  };
-
   describe('With permission', () => {
     describe('With pipelines in main tab', () => {
       beforeEach((done) => {
-        Vue.http.interceptors.push(pipelinesInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(200, pipelines);
+
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: true,
@@ -85,12 +66,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, pipelinesInterceptor,
-        );
-      });
-
       it('renders tabs', () => {
         expect(vm.$el.querySelector('.js-pipelines-tab-all').textContent.trim()).toContain('All');
       });
@@ -116,7 +91,15 @@ describe('Pipelines', () => {
 
     describe('Without pipelines on main tab with CI', () => {
       beforeEach((done) => {
-        Vue.http.interceptors.push(emptyStateInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(200, {
+          pipelines: [],
+          count: {
+            all: 0,
+            pending: 0,
+            running: 0,
+            finished: 0,
+          },
+        });
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: true,
@@ -129,12 +112,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, emptyStateInterceptor,
-        );
-      });
-
       it('renders tabs', () => {
         expect(vm.$el.querySelector('.js-pipelines-tab-all').textContent.trim()).toContain('All');
       });
@@ -158,7 +135,15 @@ describe('Pipelines', () => {
 
     describe('Without pipelines nor CI', () => {
       beforeEach((done) => {
-        Vue.http.interceptors.push(emptyStateInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(200, {
+          pipelines: [],
+          count: {
+            all: 0,
+            pending: 0,
+            running: 0,
+            finished: 0,
+          },
+        });
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: false,
@@ -171,12 +156,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, emptyStateInterceptor,
-        );
-      });
-
       it('renders empty state', () => {
         expect(vm.$el.querySelector('.js-empty-state h4').textContent.trim()).toEqual('Build with confidence');
         expect(vm.$el.querySelector('.js-get-started-pipelines').getAttribute('href')).toEqual(paths.helpPagePath);
@@ -192,7 +171,7 @@ describe('Pipelines', () => {
 
     describe('When API returns error', () => {
       beforeEach((done) => {
-        Vue.http.interceptors.push(errorInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(500, {});
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: false,
@@ -205,12 +184,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, errorInterceptor,
-        );
-      });
-
       it('renders tabs', () => {
         expect(vm.$el.querySelector('.js-pipelines-tab-all').textContent.trim()).toContain('All');
       });
@@ -230,7 +203,8 @@ describe('Pipelines', () => {
   describe('Without permission', () => {
     describe('With pipelines in main tab', () => {
       beforeEach((done) => {
-        Vue.http.interceptors.push(pipelinesInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(200, pipelines);
+
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: false,
@@ -243,12 +217,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, pipelinesInterceptor,
-        );
-      });
-
       it('renders tabs', () => {
         expect(vm.$el.querySelector('.js-pipelines-tab-all').textContent.trim()).toContain('All');
       });
@@ -268,7 +236,16 @@ describe('Pipelines', () => {
 
     describe('Without pipelines on main tab with CI', () => {
       beforeEach((done) => {
-        Vue.http.interceptors.push(emptyStateInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(200, {
+          pipelines: [],
+          count: {
+            all: 0,
+            pending: 0,
+            running: 0,
+            finished: 0,
+          },
+        });
+
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: true,
@@ -281,11 +258,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, emptyStateInterceptor,
-        );
-      });
       it('renders tabs', () => {
         expect(vm.$el.querySelector('.js-pipelines-tab-all').textContent.trim()).toContain('All');
       });
@@ -303,7 +275,16 @@ describe('Pipelines', () => {
 
     describe('Without pipelines nor CI', () => {
       beforeEach((done) => {
-        Vue.http.interceptors.push(emptyStateInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(200, {
+          pipelines: [],
+          count: {
+            all: 0,
+            pending: 0,
+            running: 0,
+            finished: 0,
+          },
+        });
+
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: false,
@@ -316,12 +297,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, emptyStateInterceptor,
-        );
-      });
-
       it('renders empty state without button to set CI', () => {
         expect(vm.$el.querySelector('.js-empty-state').textContent.trim()).toEqual('This project is not currently set up to run pipelines.');
         expect(vm.$el.querySelector('.js-get-started-pipelines')).toBeNull();
@@ -337,7 +312,8 @@ describe('Pipelines', () => {
 
     describe('When API returns error', () => {
       beforeEach((done) => {
-        Vue.http.interceptors.push(errorInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(500, {});
+
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: false,
@@ -350,12 +326,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, errorInterceptor,
-        );
-      });
-
       it('renders tabs', () => {
         expect(vm.$el.querySelector('.js-pipelines-tab-all').textContent.trim()).toContain('All');
       });
@@ -375,7 +345,8 @@ describe('Pipelines', () => {
   describe('successfull request', () => {
     describe('with pipelines', () => {
       beforeEach(() => {
-        Vue.http.interceptors.push(pipelinesInterceptor);
+        mock.onGet('twitter/flight/pipelines.json').reply(200, pipelines);
+
         vm = mountComponent(PipelinesComponent, {
           store: new Store(),
           hasGitlabCi: true,
@@ -384,12 +355,6 @@ describe('Pipelines', () => {
         });
       });
 
-      afterEach(() => {
-        Vue.http.interceptors = _.without(
-          Vue.http.interceptors, pipelinesInterceptor,
-        );
-      });
-
       it('should render table', (done) => {
         setTimeout(() => {
           expect(vm.$el.querySelector('.table-holder')).toBeDefined();

spec/models/deploy_token_spec.rb

@@ -78,19 +78,30 @@ describe DeployToken do
   describe '#has_access_to?' do
     let(:project) { create(:project) }
 
-    subject(:deploy_token) { create(:deploy_token, projects: [project]) }
+    subject { deploy_token.has_access_to?(project) }
 
-    context 'when the deploy token has access to the project' do
-      it 'should return true' do
-        expect(deploy_token.has_access_to?(project)).to be_truthy
+    context 'when deploy token is active and related to project' do
+      let(:deploy_token) { create(:deploy_token, projects: [project]) }
+
+      it { is_expected.to be_truthy }
     end
+
+    context 'when deploy token is active but not related to project' do
+      let(:deploy_token) { create(:deploy_token) }
+
+      it { is_expected.to be_falsy }
     end
 
-    context 'when the deploy token does not have access to the project' do
-      it 'should return false' do
-        another_project = create(:project)
-        expect(deploy_token.has_access_to?(another_project)).to be_falsy
+    context 'when deploy token is revoked and related to project' do
+      let(:deploy_token) { create(:deploy_token, :revoked, projects: [project]) }
+
+      it { is_expected.to be_falsy }
     end
+
+    context 'when deploy token is revoked and not related to the project' do
+      let(:deploy_token) { create(:deploy_token, :revoked) }
+
+      it { is_expected.to be_falsy }
     end
   end
 

spec/services/auth/container_registry_authentication_service_spec.rb

@@ -598,4 +598,140 @@ describe Auth::ContainerRegistryAuthenticationService do
       it_behaves_like 'not a container repository factory'
     end
   end
+
+  context 'for deploy tokens' do
+    let(:current_params) do
+      { scope: "repository:#{project.full_path}:pull" }
+    end
+
+    context 'when deploy token has read_registry as a scope' do
+      let(:current_user) { create(:deploy_token, projects: [project]) }
+
+      context 'for public project' do
+        let(:project) { create(:project, :public) }
+
+        context 'when pulling' do
+          it_behaves_like 'a pullable'
+        end
+
+        context 'when pushing' do
+          let(:current_params) do
+            { scope: "repository:#{project.full_path}:push" }
+          end
+
+          it_behaves_like 'an inaccessible'
+        end
+      end
+
+      context 'for internal project' do
+        let(:project) { create(:project, :internal) }
+
+        context 'when pulling' do
+          it_behaves_like 'a pullable'
+        end
+
+        context 'when pushing' do
+          let(:current_params) do
+            { scope: "repository:#{project.full_path}:push" }
+          end
+
+          it_behaves_like 'an inaccessible'
+        end
+      end
+
+      context 'for private project' do
+        let(:project) { create(:project, :private) }
+
+        context 'when pulling' do
+          it_behaves_like 'a pullable'
+        end
+
+        context 'when pushing' do
+          let(:current_params) do
+            { scope: "repository:#{project.full_path}:push" }
+          end
+
+          it_behaves_like 'an inaccessible'
+        end
+      end
+    end
+
+    context 'when deploy token does not have read_registry scope' do
+      let(:current_user) { create(:deploy_token, projects: [project], read_registry: false) }
+
+      context 'for public project' do
+        let(:project) { create(:project, :public) }
+
+        context 'when pulling' do
+          it_behaves_like 'a pullable'
+        end
+      end
+
+      context 'for internal project' do
+        let(:project) { create(:project, :internal) }
+
+        context 'when pulling' do
+          it_behaves_like 'an inaccessible'
+        end
+      end
+
+      context 'for private project' do
+        let(:project) { create(:project, :internal) }
+
+        context 'when pulling' do
+          it_behaves_like 'an inaccessible'
+        end
+      end
+    end
+
+    context 'when deploy token is not related to the project' do
+      let(:current_user) { create(:deploy_token, read_registry: false) }
+
+      context 'for public project' do
+        let(:project) { create(:project, :public) }
+
+        context 'when pulling' do
+          it_behaves_like 'a pullable'
+        end
+      end
+
+      context 'for internal project' do
+        let(:project) { create(:project, :internal) }
+
+        context 'when pulling' do
+          it_behaves_like 'an inaccessible'
+        end
+      end
+
+      context 'for private project' do
+        let(:project) { create(:project, :internal) }
+
+        context 'when pulling' do
+          it_behaves_like 'an inaccessible'
+        end
+      end
+    end
+
+    context 'when deploy token has been revoked' do
+      let(:current_user) { create(:deploy_token, :revoked, projects: [project]) }
+
+      context 'for public project' do
+        let(:project) { create(:project, :public) }
+
+        it_behaves_like 'a pullable'
+      end
+
+      context 'for internal project' do
+        let(:project) { create(:project, :internal) }
+
+        it_behaves_like 'an inaccessible'
+      end
+
+      context 'for private project' do
+        let(:project) { create(:project, :internal) }
+
+        it_behaves_like 'an inaccessible'
+      end
+    end
+  end
 end

spec/services/ci/register_job_service_spec.rb

@@ -370,89 +370,10 @@ module Ci
           it_behaves_like 'validation is not active'
         end
       end
-    end
-
-    describe '#register_success' do
-      let!(:current_time) { Time.new(2018, 4, 5, 14, 0, 0) }
-      let!(:attempt_counter) { double('Gitlab::Metrics::NullMetric') }
-      let!(:job_queue_duration_seconds) { double('Gitlab::Metrics::NullMetric') }
-
-      before do
-        allow(Time).to receive(:now).and_return(current_time)
-
-        # Stub defaults for any metrics other than the ones we're testing
-        allow(Gitlab::Metrics).to receive(:counter)
-                                    .with(any_args)
-                                    .and_return(Gitlab::Metrics::NullMetric.instance)
-        allow(Gitlab::Metrics).to receive(:histogram)
-                                    .with(any_args)
-                                    .and_return(Gitlab::Metrics::NullMetric.instance)
-
-        # Stub tested metrics
-        allow(Gitlab::Metrics).to receive(:counter)
-                                    .with(:job_register_attempts_total, anything)
-                                    .and_return(attempt_counter)
-        allow(Gitlab::Metrics).to receive(:histogram)
-                                    .with(:job_queue_duration_seconds, anything, anything, anything)
-                                    .and_return(job_queue_duration_seconds)
-
-        project.update(shared_runners_enabled: true)
-        pending_job.update(created_at: current_time - 3600, queued_at: current_time - 1800)
-      end
-
-      shared_examples 'metrics collector' do
-        it 'increments attempt counter' do
-          allow(job_queue_duration_seconds).to receive(:observe)
-          expect(attempt_counter).to receive(:increment)
-
-          execute(runner)
-        end
-
-        it 'counts job queuing time histogram with expected labels' do
-          allow(attempt_counter).to receive(:increment)
-          expect(job_queue_duration_seconds).to receive(:observe)
-            .with({ shared_runner: expected_shared_runner,
-                    jobs_running_for_project: expected_jobs_running_for_project_first_job }, 1800)
-
-          execute(runner)
-        end
-
-        context 'when project already has running jobs' do
-          let!(:build2) { create( :ci_build, :running, pipeline: pipeline, runner: shared_runner) }
-          let!(:build3) { create( :ci_build, :running, pipeline: pipeline, runner: shared_runner) }
-
-          it 'counts job queuing time histogram with expected labels' do
-            allow(attempt_counter).to receive(:increment)
-            expect(job_queue_duration_seconds).to receive(:observe)
-              .with({ shared_runner: expected_shared_runner,
-                      jobs_running_for_project: expected_jobs_running_for_project_third_job }, 1800)
-
-            execute(runner)
-          end
-        end
-      end
-
-      context 'when shared runner is used' do
-        let(:runner) { shared_runner }
-        let(:expected_shared_runner) { true }
-        let(:expected_jobs_running_for_project_first_job) { 0 }
-        let(:expected_jobs_running_for_project_third_job) { 2 }
-
-        it_behaves_like 'metrics collector'
-      end
-
-      context 'when specific runner is used' do
-        let(:runner) { specific_runner }
-        let(:expected_shared_runner) { false }
-        let(:expected_jobs_running_for_project_first_job) { '+Inf' }
-        let(:expected_jobs_running_for_project_third_job) { '+Inf' }
-
-        it_behaves_like 'metrics collector'
-      end
-    end
 
       def execute(runner)
         described_class.new(runner).execute.build
       end
     end
+  end
 end