text: import Vue from 'vue';
  import VueResource from 'vue-resource';
  import Poll from '~/lib/utils/poll';
  
  Vue.use(VueResource);
  
  class ServiceMock {
    constructor(endpoint) {
      this.service = Vue.resource(endpoint);
    }
  
    fetch() {
      return this.service.get();
    }
  }
  
  describe('Poll', () => {
    let callbacks;
  
    beforeEach(() => {
      callbacks = {
        success: () => {},
        error: () => {},
      };
  
      spyOn(callbacks, 'success');
      spyOn(callbacks, 'error');
    });
  
    it('calls the success callback when no header for interval is provided', (done) => {
      const successInterceptor = (request, next) => {
        next(request.respondWith(JSON.stringify([]), { status: 200 }));
      };
  
      Vue.http.interceptors.push(successInterceptor);
  
      new Poll({
        resource: new ServiceMock('endpoint'),
        method: 'fetch',
        successCallback: callbacks.success,
        errorCallback: callbacks.error,
      }).makeRequest();
  
      setTimeout(() => {
        expect(callbacks.success).toHaveBeenCalled();
        expect(callbacks.error).not.toHaveBeenCalled();
        done();
      }, 0);
  
      Vue.http.interceptors = _.without(Vue.http.interceptors, successInterceptor);
    });
  
    it('calls the error callback whe the http request returns an error', (done) => {
      const errorInterceptor = (request, next) => {
        next(request.respondWith(JSON.stringify([]), { status: 500 }));
      };
  
      Vue.http.interceptors.push(errorInterceptor);
  
      new Poll({
        resource: new ServiceMock('endpoint'),
        method: 'fetch',
        successCallback: callbacks.success,
        errorCallback: callbacks.error,
      }).makeRequest();
  
      setTimeout(() => {
        expect(callbacks.success).not.toHaveBeenCalled();
        expect(callbacks.error).toHaveBeenCalled();
        done();
      }, 0);
  
      Vue.http.interceptors = _.without(Vue.http.interceptors, errorInterceptor);
    });
  
    it('should call the success callback when the interval header is -1', (done) => {
      const intervalInterceptor = (request, next) => {
        next(request.respondWith(JSON.stringify([]), { status: 200, headers: { 'poll-interval': -1 } }));
      };
  
      Vue.http.interceptors.push(intervalInterceptor);
  
      new Poll({
        resource: new ServiceMock('endpoint'),
        method: 'fetch',
        successCallback: callbacks.success,
        errorCallback: callbacks.error,
      }).makeRequest();
  
      setTimeout(() => {
        expect(callbacks.success).toHaveBeenCalled();
        expect(callbacks.error).not.toHaveBeenCalled();
        done();
      }, 0);
  
      Vue.http.interceptors = _.without(Vue.http.interceptors, intervalInterceptor);
    });
  
    it('starts polling when http status is 200 and interval header is provided', (done) => {
      const pollInterceptor = (request, next) => {
        next(request.respondWith(JSON.stringify([]), { status: 200, headers: { 'poll-interval': 2 } }));
      };
  
      Vue.http.interceptors.push(pollInterceptor);
  
      const service = new ServiceMock('endpoint');
      spyOn(service, 'fetch').and.callThrough();
  
      new Poll({
        resource: service,
        method: 'fetch',
        data: { page: 1 },
        successCallback: callbacks.success,
        errorCallback: callbacks.error,
      }).makeRequest();
  
      setTimeout(() => {
        expect(service.fetch.calls.count()).toEqual(2);
        expect(service.fetch).toHaveBeenCalledWith({ page: 1 });
        expect(callbacks.success).toHaveBeenCalled();
        expect(callbacks.error).not.toHaveBeenCalled();
        done();
      }, 5);
  
      Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
    });
  
    describe('stop', () => {
      it('stops polling when method is called', (done) => {
        const pollInterceptor = (request, next) => {
          next(request.respondWith(JSON.stringify([]), { status: 200, headers: { 'poll-interval': 2 } }));
        };
  
        Vue.http.interceptors.push(pollInterceptor);
  
        const service = new ServiceMock('endpoint');
        spyOn(service, 'fetch').and.callThrough();
  
        const Polling = new Poll({
          resource: service,
          method: 'fetch',
          data: { page: 1 },
          successCallback: () => {
            Polling.stop();
          },
          errorCallback: callbacks.error,
        });
  
        spyOn(Polling, 'stop').and.callThrough();
  
        Polling.makeRequest();
  
        setTimeout(() => {
          expect(service.fetch.calls.count()).toEqual(1);
          expect(service.fetch).toHaveBeenCalledWith({ page: 1 });
          expect(Polling.stop).toHaveBeenCalled();
          done();
        }, 100);
  
        Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
      });
    });
  
    describe('restart', () => {
      it('should restart polling when its called', (done) => {
        const pollInterceptor = (request, next) => {
          next(request.respondWith(JSON.stringify([]), { status: 200, headers: { 'poll-interval': 2 } }));
        };
  
        Vue.http.interceptors.push(pollInterceptor);
  
        const service = new ServiceMock('endpoint');
  
        spyOn(service, 'fetch').and.callThrough();
  
        const Polling = new Poll({
          resource: service,
          method: 'fetch',
          data: { page: 1 },
          successCallback: () => {
            Polling.stop();
            setTimeout(() => {
              Polling.restart();
            }, 0);
          },
          errorCallback: callbacks.error,
        });
  
        spyOn(Polling, 'stop').and.callThrough();
  
        Polling.makeRequest();
  
        setTimeout(() => {
          expect(service.fetch.calls.count()).toEqual(2);
          expect(service.fetch).toHaveBeenCalledWith({ page: 1 });
          expect(Polling.stop).toHaveBeenCalled();
          done();
        }, 10);
  
        Vue.http.interceptors = _.without(Vue.http.interceptors, pollInterceptor);
      });
    });
  });
  