redoc/tests/unit/SchemaManager.spec.js

'use strict';

import SchemaManager from 'lib/utils/SchemaManager';
describe('Schema manager', () => {
  let schemaMgr;

  beforeEach(() => {
    schemaMgr = new SchemaManager();
  });

  it('Should initialize with empty schema', ()=> {
    schemaMgr.schema.should.be.empty;
  });

  it('Should be a singleton', ()=> {
    (new SchemaManager()).should.be.equal(schemaMgr);
    SchemaManager.instance().should.be.equal(schemaMgr);
  });

  it('load should return a promise', ()=> {
    schemaMgr.load('/tests/schemas/extended-petstore.json').should.be.instanceof(Promise);
  });

  it('load should reject promise for invalid url', (done)=> {
    schemaMgr.load('/nonexisting/schema.json').then(() => {
      throw new Error('Succees handler should not be called');
    }, () => {
      done();
    });
  });

  it('load should resolve promise for valid url', (done)=> {
    schemaMgr.load('/tests/schemas/extended-petstore.json').then(() => {
      done();
    }, () => {
      throw new Error('Error handler should not be called');
    });
  });

  describe('Schema manager basic functionality', ()=> {
    before(function (done) {
      schemaMgr.load('/tests/schemas/extended-petstore.json').then(() => {
        done();
      }, () => {
        throw new Error('Error handler should not be called');
      });
    });


    it('should contain non-empty schema', ()=> {
      schemaMgr.schema.should.be.an('object');
      schemaMgr.schema.should.be.not.empty;
    });

    it('should correctly init api url', ()=> {
      schemaMgr.apiUrl.should.be.equal('http://petstore.swagger.io/v2');
    });

    describe('byPointer method', () => {
      it('should return correct schema part', ()=> {
        let part = schemaMgr.byPointer('/tags/3');
        part.should.be.deep.equal(schemaMgr.schema.tags[3]);
        part.should.be.equal(schemaMgr.schema.tags[3]);
      });

      it('should return null for incorrect pointer', ()=> {
        let part = schemaMgr.byPointer('/incorrect/pointer');
        should.not.exist(part);
      });
    });
  });

  describe('getTagsMap method', () => {
    before(function () {
      schemaMgr._schema = {
        tags: [
          {name: 'tag1', description: 'info1'},
          {name: 'tag2', description: 'info2', 'x-traitTag': true}
        ]
      };
    });

    it('should return correct tags map', () => {
      let tagsMap = schemaMgr.getTagsMap();
      let expectedResult = {
        tag1: {description: 'info1', 'x-traitTag': false},
        tag2: {description: 'info2', 'x-traitTag': true}
      };
      tagsMap.should.be.deep.equal(expectedResult);
    });

    it('should return empty array for non-specified tags', () => {
      delete schemaMgr._schema.tags;
      let tagsMap = schemaMgr.getTagsMap();
      tagsMap.should.be.empty;
    });
  });

  describe('buildMenuTree method', () => {
    let suitSchema = {
      tags: [
        {name: 'tag1', description: 'info1', 'x-traitTag': true},
        {name: 'tag2', description: 'info2'}
      ],
      paths: {
        test: {
          put: {
            tags: ['tag1', 'tag3'],
            summary: 'test put'
          },
          get: {
            tags: ['tag1', 'tag2'],
            summary: 'test get'
          },
          // no tags
          post: {
            summary: 'test post'
          }
        }
      }
    };

    let menuTree;
    let entries;

    before(() => {
      schemaMgr._schema = suitSchema;
      menuTree = schemaMgr.buildMenuTree();
      entries = Array.from(menuTree.entries());
    });

    it('should return instance of Map', () => {
      menuTree.should.be.instanceof(Map);
    });

    it('should return Map with correct number of entries', () => {
      //2 - defined tags, 1 - tag3 and 1 [other] tag for no-tags method
      entries.length.should.be.equal(2 + 1 + 1);
    });

    it('should append not defined tags to the end of list', () => {
      let [tag, info] = entries[2];
      tag.should.be.equal('tag3');
      info.methods.length.should.be.equal(1);
      info.methods[0].summary.should.be.equal('test put');
    });

    it('should append methods without tags to [other] tag', () => {
      let [tag, info] = entries[3];
      tag.should.be.equal('[Other]');
      info.methods.length.should.be.equal(1);
      info.methods[0].summary.should.be.equal('test post');
    });

    it('should map x-traitTag to empty methods list', () => {
      let [, info] = entries[0];
      info['x-traitTag'].should.be.true;
      info.methods.should.be.empty;
    });

    it('methods for tag should contain valid pointer and summary', () => {
      for (let entr of entries) {
        let [, info] = entr;
        info.should.be.an('object');
        info.methods.should.be.an('array');
        for (let methodInfo of info.methods) {
          methodInfo.should.include.keys('pointer', 'summary');
          let methSchema = schemaMgr.byPointer(methodInfo.pointer);
          should.exist(methSchema);
          if (methSchema.summary) {
            methSchema.summary.should.be.equal(methodInfo.summary);
          }
        }
      }
    });
  });

  describe('getMethodParams method', () => {
    before((done) => {
      schemaMgr.load('/tests/schemas/schema-mgr-methodparams.json').then(() => {
        done();
      }, () => {
        done(new Error('Error handler should not be called'));
      });
    });

    it('should propagate path parameters', () => {
      let params = schemaMgr.getMethodParams('/paths/test1/get');
      params.length.should.be.equal(2);
      params[0].name.should.be.equal('methodParam');
      params[1].name.should.be.equal('pathParam');
    });

    it('should inject correct pointers', () => {
      let params = schemaMgr.getMethodParams('/paths/test1/get');
      params[0]._pointer.should.be.equal('/paths/test1/get/parameters/0');
      params[1]._pointer.should.be.equal('/paths/test1/parameters/0');
    });

    it('should accept pointer directly to parameters', () => {
      let params = schemaMgr.getMethodParams('/paths/test1/get/parameters', true);
      expect(params).to.exist;
      params.length.should.be.equal(2);
    });

    it('should resolve path params from Parameters Definitions Object', () => {
      let params = schemaMgr.getMethodParams('/paths/test2/get', true);
      params.length.should.be.equal(2);
      params[0].name.should.be.equal('methodParam');
      params[1].name.should.be.equal('extParam');
      params[1]._pointer.should.be.equal('#/parameters/extparam');
    });

    it('should resolve method params from Parameters Definitions Object', () => {
      let params = schemaMgr.getMethodParams('/paths/test3/get', true);
      params.length.should.be.equal(1);
      params[0].name.should.be.equal('extParam');
      params[0]._pointer.should.be.equal('#/parameters/extparam');
    });

    it('should throw for parameters other than array', () => {
      let func = () => schemaMgr.getMethodParams('/paths/test4/get', true);
      func.should.throw();
    });
  });

});