definma-api/src/routes/model.spec.ts

import should from 'should/as-function';
import ModelFileModel from '../models/model_file';
import TestHelper from "../test/helper";
import ModelModel from '../models/model';
import UserModel from '../models/user';
import mongoose from 'mongoose';


describe('/model', () => {
  let server;
  before(done => TestHelper.before(done));
  beforeEach(done => server = TestHelper.beforeEach(server, done));
  afterEach(done => TestHelper.afterEach(server, done));
  after(done => TestHelper.after(done));

  describe('GET /model/groups', () => {
    it('returns all groups for an admin user', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/groups',
        auth: {basic: 'admin'},
        httpStatus: 200,
      }).end((err, res) => {
        if (err) return done (err);
        const json = require('../test/db.json');
        should(res.body).have.lengthOf(json.collections.models.length);
        should(res.body).matchEach(group => {
          should(group).have.only.keys('group', 'models');
          should(group).have.property('group').be.type('string');
          should(group.models).matchEach(model => {
            should(model).have.only.keys('_id', 'name', 'url');
            should(model).have.property('_id').be.type('string');
            should(model).have.property('name').be.type('string');
            should(model).have.property('url').be.type('string');
          });
        });
        done();
      });
    });
    it('returns all allowed groups for a predict user', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/groups',
        auth: {basic: 'customer'},
        httpStatus: 200,
      }).end((err, res) => {
        if (err) return done (err);
        should(res.body).have.lengthOf(1);
        should(res.body).matchEach(group => {
          should(group).have.only.keys('group', 'models');
          should(group).have.property('group').be.type('string');
          should(group).have.property('models', [{_id: '120000000000000000000001', name: 'Model A', url: 'http://model-a.com'}]);
        });
        done();
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/groups',
        auth: {key: 'janedoe'},
        httpStatus: 401,
      });
    });
    it('rejects an unauthorized request', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/groups',
        httpStatus: 401,
      });
    });
  });

  describe('POST /model/{group}', () => {
    it('adds a new model', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        auth: {basic: 'admin'},
        httpStatus: 200,
        req: {name: 'Model C', url: 'http://model-c.com'}
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({status: 'OK'});
        ModelModel.findOne({group: 'VN'}).lean().exec((err, res) => {
          if (err) return done(err);
          const model = res.models.find(e => e.name === 'Model C');
          should(model).have.property('url', 'http://model-c.com');
          done();
        });
      });
    });
    it('adds a new group', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/classification',
        auth: {basic: 'admin'},
        httpStatus: 200,
        req: {name: 'Model 0.1', url: 'http://model-0-1.com'}
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({status: 'OK'});
        ModelModel.findOne({group: 'classification'}).lean().exec((err, res) => {
          if (err) return done(err);
          should(res).have.only.keys('_id', 'group', 'models', '__v');
          should(res).have.property('group', 'classification');
          should(res.models[0]).have.only.keys('_id', 'name', 'url');
          should(res.models[0]).have.property('name', 'Model 0.1');
          should(res.models[0]).have.property('url', 'http://model-0-1.com');
          done();
        });
      });
    });
    it('replaces a model', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        auth: {basic: 'admin'},
        httpStatus: 200,
        req: {name: 'Model A', url: 'http://model-a-new.com'}
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({status: 'OK'});
        ModelModel.findOne({group: 'VN'}).lean().exec((err, res) => {
          if (err) return done(err);
          const model = res.models.find(e => e.name === 'Model A');
          should(model).have.property('url', 'http://model-a-new.com');
          done();
        });
      });
    });
    it('rejects an empty name', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        auth: {basic: 'admin'},
        httpStatus: 400,
        req: {name: '', url: 'http://model-c.com'},
        res:{status: 'Invalid body format', details: '"name" is not allowed to be empty'}
      });
    });
    it('rejects a missing name', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        auth: {basic: 'admin'},
        httpStatus: 400,
        req: {url: 'http://model-c.com'},
        res:{status: 'Invalid body format', details: '"name" is required'}
      });
    });
    it('rejects an invalid URL', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        auth: {basic: 'admin'},
        httpStatus: 400,
        req: {name: 'Model C', url: 'model-c'},
        res:{status: 'Invalid body format', details: '"url" must be a valid uri'}
      });
    });
    it('rejects a missing URL', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        auth: {basic: 'admin'},
        httpStatus: 400,
        req: {name: 'Model C'},
        res:{status: 'Invalid body format', details: '"url" is required'}
      });
    });
    it('rejects a write user', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        auth: {basic: 'janedoe'},
        httpStatus: 403,
        req: {name: 'Model C', url: 'http://model-c.com'}
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        auth: {key: 'admin'},
        httpStatus: 401,
        req: {name: 'Model C', url: 'http://model-c.com'}
      });
    });
    it('rejects an unauthorized request', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/VN',
        httpStatus: 401,
        req: {name: 'Model C', url: 'http://model-c.com'}
      });
    });
  });

  describe('DELETE /model/{group}/{name}', () => {
    it('deletes the model', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/VN/Model%20A',
        auth: {basic: 'admin'},
        httpStatus: 200
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({status: 'OK'});
        ModelModel.findOne({group: 'VN'}).lean().exec((err, res) => {
          if (err) return done(err);
          should(res).have.only.keys('_id', 'group', 'models');
          should(res).have.property('group', 'VN');
          should(res.models[0]).have.only.keys('_id', 'name', 'url');
          should(res.models[0]).have.property('name', 'Model B');
          should(res.models[0]).have.property('url', 'http://model-b.com');
          done();
        });
      });
    });
    it('deletes the group, if empty afterwards', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/Moisture/Model%201',
        auth: {basic: 'admin'},
        httpStatus: 200
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({status: 'OK'});
        ModelModel.find({group: 'Moisture'}).lean().exec((err, res) => {
          if (err) return done(err);
          should(res).have.lengthOf(0);
          done();
        });
      });
    });
    it ('removes the model_id from all user.models', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/VN/Model%20A',
        auth: {basic: 'admin'},
        httpStatus: 200
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({status: 'OK'});
        UserModel.find({models: mongoose.Types.ObjectId("120000000000000000000001")}).lean().exec((err, res) => {
          if (err) return done(err);
          should(res).have.lengthOf(0);
          done();
        });
      });
    });
    it('returns 404 for an unknown group', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/xxx/Model%201',
        auth: {basic: 'admin'},
        httpStatus: 404
      });
    });
    it('returns 404 for an unknown model', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/VN/xxx',
        auth: {basic: 'admin'},
        httpStatus: 404
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/VN/Model%20A',
        auth: {key: 'admin'},
        httpStatus: 401
      });
    });
    it('rejects a write user', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/VN/Model%20A',
        auth: {basic: 'janedoe'},
        httpStatus: 403
      });
    });
    it('rejects an unauthorized request', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/VN/Model%20A',
        httpStatus: 401
      });
    });
  });

  describe('GET /model/files', () => {
    it('rejects a write user', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/files',
        auth: {basic: 'janedoe'},
        httpStatus: 403,
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/files',
        auth: {key: 'admin'},
        httpStatus: 401,
      });
    });
    it('rejects an unauthorized request', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/files',
        httpStatus: 401,
      });
    });
  });

  describe('GET /model/file/{name}', (() => {
    it('returns the binary data', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/file/modela',
        auth: {basic: 'admin'},
        httpStatus: 200,
        contentType: 'application/octet-stream; charset=utf-8',
      }).end((err, res) => {
        if (err) return done (err);
        should(res.body.toString()).be.eql('binary data');
        done();
      });
    });
    it('returns the binary data for an API key', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/file/modela',
        auth: {key: 'admin'},
        httpStatus: 200,
        contentType: 'application/octet-stream; charset=utf-8',
      }).end((err, res) => {
        if (err) return done (err);
        should(res.body.toString()).be.eql('binary data');
        done();
      });
    });
    it('returns 404 for an unknown name', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/file/modelx',
        auth: {basic: 'admin'},
        httpStatus: 404
      })
    });
    it('rejects requests from a write user', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/file/modela',
        auth: {basic: 'janedoe'},
        httpStatus: 403
      })
    });
    it('rejects unauthorized requests', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/file/modela',
        httpStatus: 401
      })
    });
  }));

  describe('POST /model/file/{name}', () => {
    it('stores the data', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/file/modelb',
        auth: {basic: 'admin'},
        httpStatus: 200,
        reqContentType: 'application/octet-stream',
        req: 'another binary data'
      }).end((err, res) => {
        if (err) return done (err);
        should(res.body).be.eql({status: 'OK'});
        ModelFileModel.find({name: 'modelb'}).lean().exec((err, data) => {
          if (err) return done (err);
          should(data).have.lengthOf(1);
          should(data[0]).have.only.keys('_id', 'name', 'data', '__v');
          should(data[0]).have.property('name', 'modelb');
          should(data[0].data.buffer.toString()).be.eql('another binary data');
          done();
        });
      });
    });
    it('stores the data with an API key', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/file/modelb',
        auth: {key: 'admin'},
        httpStatus: 200,
        reqContentType: 'application/octet-stream',
        req: 'another binary data'
      }).end((err, res) => {
        if (err) return done (err);
        should(res.body).be.eql({status: 'OK'});
        ModelFileModel.find({name: 'modelb'}).lean().exec((err, data) => {
          if (err) return done (err);
          should(data).have.lengthOf(1);
          should(data[0]).have.only.keys('_id', 'name', 'data', '__v');
          should(data[0]).have.property('name', 'modelb');
          should(data[0].data.buffer.toString()).be.eql('another binary data');
          done();
        });
      });
    });
    it('overwrites existing data', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/file/modela',
        auth: {basic: 'admin'},
        httpStatus: 200,
        reqContentType: 'application/octet-stream',
        req: 'another binary data'
      }).end((err, res) => {
        if (err) return done (err);
        should(res.body).be.eql({status: 'OK'});
        ModelFileModel.find({name: 'modela'}).lean().exec((err, data) => {
          if (err) return done (err);
          should(data).have.lengthOf(1);
          should(data[0]).have.only.keys('_id', 'name', 'data', '__v');
          should(data[0]).have.property('name', 'modela');
          should(data[0].data.buffer.toString()).be.eql('another binary data');
          done();
        });
      });
    });
    it('rejects requests from a write user', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/file/modelb',
        auth: {basic: 'janedoe'},
        httpStatus: 403,
        req: 'another binary data'
      });
    });
    it('rejects unauthorized requests', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/model/file/modelb',
        httpStatus: 401,
        req: 'another binary data'
      });
    });
  });

  describe('DELETE /model/file/{name}', () => {
    it('deletes the data', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/file/modela',
        auth: {basic: 'admin'},
        httpStatus: 200
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({status: 'OK'});
        ModelFileModel.find({name: 'modela'}).lean().exec((err, data) => {
          if (err) return done(err);
          should(data).have.lengthOf(0);
          done();
        });
      });
    });
    it('returns 404 for an unknown name', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/file/modelx',
        auth: {basic: 'admin'},
        httpStatus: 404
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/file/modela',
        auth: {key: 'admin'},
        httpStatus: 401
      });
    });
    it('rejects a write user', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/file/modela',
        auth: {basic: 'janedoe'},
        httpStatus: 403
      });
    });
    it('rejects an unauthorized request', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/model/file/modela',
        httpStatus: 401
      });
    });
  });

  describe('GET /model/authorized/{url}', () => {
    it('returns OK for every model for admins', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/authorized/xx',
        auth: {basic: 'admin'},
        httpStatus: 200,
        res: {status: 'OK'}
      });
    });
    it('returns OK for a specified model for a predict user', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/authorized/http%3A%2F%2Fmodel-a.com',
        auth: {basic: 'customer'},
        httpStatus: 200,
        res: {status: 'OK'}
      });
    });
    it('rejects a model not specified for a predict user', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/authorized/http%3A%2F%2Fmodel-b.com',
        auth: {basic: 'customer'},
        httpStatus: 403
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/authorized/xx',
        auth: {key: 'admin'},
        httpStatus: 401
      });
    });
    it('rejects an unauthorized request', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/model/authorized/http%3A%2F%2Fmodel-b.com',
        httpStatus: 401
      });
    });
  });
});