rest-methods/test/server/manifest.test.js

Declaratively publish functions for remote invocation.

import { expect } from 'chai';
import Server from '../../src/server/server';
import manifest from '../../src/server/manifest';
import { getMethods } from '../../src/server/manifest';

const fakeConnect = { use: () => {} };



describe('Server:manifest', () => {
  describe('getMethods(server)', () => {
    let server;
    beforeEach(() => { server = Server(); });

    it('returns an empty object (no methods registered)', () => {
      expect(getMethods(server)).to.eql({});
    });


    it('does not add method definitions that are empty', () => {
      server.methods({
        'foo': {}
      });
      expect(getMethods(server)).to.eql({});
    });


    it('retrieves a single method with a GET verb', () => {
      server.methods({
        'foo': { get: (id) => {} } // NB: The parameter is stripped off and ignored.
      });
      expect(getMethods(server)).to.eql({
        'foo': {
          name: 'foo',
          url: '/foo',
          get: {}
        }
      });
    });

    it('retrieves a single method with a GET verb with a URL parameter', () => {
      server.methods({
        'foo': {
          url: 'foo/:id',
          get: (id, ignored) => {}
        }
      });
      expect(getMethods(server)).to.eql({
        'foo': {
          name: 'foo',
          url: '/foo/:id',
          get: {
            params: [{ name:'id' }]
          }
        }
      });
    });


    it('retrieves a single method with a PUT verb that has parameters', () => {
      server.methods({
        'foo': { put: (text, number) => {} }
      });
      expect(getMethods(server)).to.eql({
        'foo': {
          name: 'foo',
          url: '/foo',
          put: {
            params: [{ name:'text' }, { name:'number' }]
          }
        }
      });
    });


    it('retrieves a single method with a GET verb', () => {
      server.methods({
        'foo': { get: () => {} }
      });
      expect(getMethods(server)).to.eql({
        'foo': {
          name: 'foo',
          url: '/foo',
          get: {}
        }
      });
    });


    it('stores the full code-path in the method name', () => {
      server.methods({
        'foo/bar/user': { get: () => {} }
      });
      expect(getMethods(server)['foo/bar/user'].name).to.equal('foo.bar.user');
    });


    it('retrieves methods for each HTTP verb from a single method registration', () => {
      server.methods({ 'foo': (text) => {} });
      let methods = getMethods(server);
      expect(methods.foo.url).to.equal('/foo');
      expect(methods.foo.get).to.eql({}); // No params.
      expect(methods.foo.put).to.eql({ params:[{ name: 'text' }] });
      expect(methods.foo.post).to.eql({ params:[{ name: 'text' }] });
      expect(methods.foo.delete).to.eql({}); // No params.
    });


    it('prefixes the base-url to the methods route', () => {
      server = Server({ basePath:'//v1///' })
      server.methods({ 'foo': (text) => {} });
      expect(getMethods(server).foo.url).to.equal('/v1/foo');
    });


    it('has a custom url', () => {
      server.methods({
        'foo': { url: '/thing/:id', get:(id) => {} }
      });
      expect(getMethods(server).foo.url).to.equal('/thing/:id');
    });
  });


  describe('manifest (default)', () => {
    it('has the service name', () => {
      let server = Server();
      expect(manifest(server).name).to.eql(server.name);
      server = Server({ name:'Foo' });
      expect(manifest(server).name).to.eql('Foo');
    });


    it('has default version', () => {
      let server = Server();
      expect(manifest(server).version).to.eql('0.0.0');
    });


    it('has specified version', () => {
      let server = Server({ version: '1.2.3' });
      expect(manifest(server).version).to.eql('1.2.3');
    });


    it('has basePath', () => {
      let server = Server({ basePath: '//api///' });
      expect(manifest(server).basePath).to.eql('/api');
    });


    it('has no methods', () => {
      let server = Server();
      expect(manifest(server).methods).to.eql({});
    });


    it('has methods', () => {
      let server = Server();
      server.methods({ 'foo': (text) => {} });
      expect(manifest(server).methods).not.to.equal(undefined);
      expect(manifest(server).methods).to.eql(getMethods(server));
    });
  });
});