test/e2e/api.spec.js

import path from 'path';
import assert from 'assert';
import sinon from 'sinon';
import fs from 'fs-extra';
 
import { simpleSite } from '../utils';
 
import Reptar from '../../lib/index';
import { ApiService } from '../../lib/server/api';
import cache from '../../lib/cache';
import Config from '../../lib/config/index';
import log from '../../lib/log';
 
log.setSilent(true);
 
describe('api', function test() {
  this.timeout(5000);
 
  const generatedOutputDir = path.join(simpleSite.src, '_site');
 
  let sandbox;
  let instance;
  let apiService;
  let request;
  let reply;
 
  before(async () => {
    sandbox = sinon.sandbox.create();
 
    // Don't actually save cache to file system.
    sandbox.stub(cache, 'save');
 
    fs.removeSync(generatedOutputDir);
 
    sandbox.spy(Reptar.prototype, 'update');
    sandbox.spy(Config.prototype, 'update');
 
    instance = new Reptar({
      rootPath: simpleSite.src,
      showSpinner: false,
    });
    await instance.update();
 
    apiService = ApiService(instance);
  });
 
  beforeEach(() => {
    request = {
      query: {},
      payload: {},
      params: {},
    };
    reply = sandbox.spy();
  });
 
  afterEach(() => {
    reply.reset();
  });
 
  after(() => {
    sandbox.restore();
  });
 
  describe('config handlers', () => {
    beforeEach(() => apiService.config.get(request, reply));
 
    it('returns the config object', () => {
      assert(reply.firstCall.calledWith(instance.config.get()));
    });
  });
 
  describe('files.get handler', () => {
    let response;
 
    function commonAssertions({ expectedLength }) {
      it('returns an array', () => {
        assert.equal(typeof response.length, 'number');
      });
 
      it(`returns ${expectedLength} items`, () => {
        assert.equal(response.length, expectedLength);
      });
    }
 
    afterEach(() => {
      response = undefined;
    });
 
    describe('without any query params', () => {
      beforeEach(async () => {
        await apiService.files.get(request, reply);
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 15,
      });
    });
 
    describe('when filtered=true', () => {
      beforeEach(async () => {
        request.query = {
          filtered: 'true',
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 1,
      });
 
      it('every item is filtered', () => {
        response.forEach(file => assert.equal(file.filtered, true));
      });
    });
 
    describe('when filtered=false', () => {
      beforeEach(async () => {
        request.query = {
          filtered: 'false',
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 14,
      });
 
      it('every item is not filtered', () => {
        response.forEach(file => assert.equal(file.filtered, false));
      });
    });
 
    describe('when skipProcessing=true', () => {
      beforeEach(async () => {
        request.query = {
          skipProcessing: 'true',
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 7,
      });
 
      it('every item is skipProcessing', () => {
        response.forEach(file => assert.equal(file.skipProcessing, true));
      });
    });
 
    describe('when skipProcessing=false', () => {
      beforeEach(async () => {
        request.query = {
          skipProcessing: 'false',
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 8,
      });
 
      it('every item is skipProcessing', () => {
        response.forEach(file => assert.equal(file.skipProcessing, false));
      });
    });
 
    describe('when assetProcessor=true', () => {
      beforeEach(async () => {
        request.query = {
          assetProcessor: 'true',
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 5,
      });
 
      it('every item is assetProcessor', () => {
        response.forEach(file => assert(file.assetProcessor));
      });
    });
 
    describe('when assetProcessor=false', () => {
      beforeEach(async () => {
        request.query = {
          assetProcessor: 'false',
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 10,
      });
 
      it('every item is assetProcessor', () => {
        response.forEach(file => assert.equal(file.assetProcessor, null));
      });
    });
 
    describe('when path does not match a file', () => {
      beforeEach(async () => {
        request.query = {
          path: 'badabada',
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 0,
      });
    });
 
    describe('when path does match a file', () => {
      let filePath;
 
      beforeEach(async () => {
        filePath = path.join(instance.config.get('path.source'), 'about.md');
 
        request.query = {
          path: filePath,
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 1,
      });
 
      it('the file returned is the one we requested', () => {
        assert.equal(response[0].path, filePath);
      });
    });
 
    describe('when the path is relative and matches', () => {
      const filePath = 'about.md';
      let fullPath;
 
      beforeEach(async () => {
        fullPath = path.join(instance.config.get('path.source'), filePath);
 
        request.query = {
          path: filePath,
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 1,
      });
 
      it('the file returned is the one we requested', () => {
        assert.equal(response[0].path, fullPath);
      });
    });
 
    //
    //
    describe('when destination does not match a file', () => {
      beforeEach(async () => {
        request.query = {
          destination: 'badabada',
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 0,
      });
    });
 
    describe('when destination does match a file', () => {
      const filePath = '/about.html';
 
      beforeEach(async () => {
        request.query = {
          destination: filePath,
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 1,
      });
 
      it('the file returned is the one we requested', () => {
        assert.equal(response[0].destination, filePath);
      });
    });
 
    describe('when the destination is relative and matches', () => {
      const filePath = 'about.html';
 
      beforeEach(async () => {
        request.query = {
          destination: filePath,
        };
 
        await apiService.files.get(request, reply);
 
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 1,
      });
 
      it('the file returned is the one we requested', () => {
        assert.equal(response[0].destination, `/${filePath}`);
      });
    });
  });
 
  describe('collections.get handler', () => {
    let response;
 
    function commonAssertions({ expectedLength }) {
      it('returns an array', () => {
        assert.equal(typeof response.length, 'number');
      });
 
      it(`returns ${expectedLength} items`, () => {
        assert.equal(response.length, expectedLength);
      });
    }
 
    afterEach(() => {
      response = undefined;
    });
 
    describe('without any query params', () => {
      beforeEach(async () => {
        await apiService.collections.get(request, reply);
        response = reply.firstCall.args[0];
      });
 
      commonAssertions({
        expectedLength: 2,
      });
 
      it('returns an array of just collection names', () => {
        assert.deepEqual(response, ['post', 'tag']);
      });
    });
 
    function commonOneCollection({ id }) {
      it('returns an object', () => {
        assert.equal(typeof response, 'object');
      });
 
      it('the object matches the request id', () => {
        assert.equal(response.id, id);
      });
    }
 
    describe('when requesting one collection', () => {
      const id = 'post';
 
      beforeEach(async () => {
        request.params.id = id;
        await apiService.collections.get(request, reply);
        response = reply.firstCall.args[0];
      });
 
      commonOneCollection({ id });
 
      it('the object does not have properties that excluded by default', () => {
        ['pages', 'files', 'data'].forEach(prop =>
          assert.equal(typeof response[prop], 'undefined')
        );
      });
    });
 
    describe('when requesting one collection with include param', () => {
      const id = 'post';
 
      beforeEach(async () => {
        request.params.id = id;
        request.query.include = 'pages';
        await apiService.collections.get(request, reply);
        response = reply.firstCall.args[0];
      });
 
      commonOneCollection({ id });
 
      it('the object has a pages property which is an array', () => {
        assert.equal(typeof response.pages.length, 'number');
      });
 
      it('pages has expected length', () => {
        assert.equal(response.pages.length, 1);
      });
 
      it('the object does not have properties that excluded by default', () => {
        ['files', 'data'].forEach(prop =>
          assert.equal(typeof response[prop], 'undefined')
        );
      });
    });
 
    // eslint-disable-next-line max-len
    describe('when requesting one collection with multiple include values', () => {
      const id = 'post';
 
      beforeEach(async () => {
        request.params.id = id;
        request.query.include = 'pages,files';
        await apiService.collections.get(request, reply);
        response = reply.firstCall.args[0];
      });
 
      commonOneCollection({ id });
 
      it('the object has a pages property which is an array', () => {
        assert.equal(typeof response.pages.length, 'number');
      });
 
      it('pages has expected length', () => {
        assert.equal(response.pages.length, 1);
      });
 
      it('files is an object', () => {
        assert.equal(typeof response.files, 'object');
      });
 
      it('files is not an array object', () => {
        assert.equal(typeof response.files.length, 'undefined');
      });
 
      it('the object does not have properties that excluded by default', () => {
        ['data'].forEach(prop =>
          assert.equal(typeof response[prop], 'undefined')
        );
      });
    });
  });
});