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

import should from 'should/as-function';
import MeasurementModel from '../models/measurement';
import TestHelper from "../test/helper";

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

  describe('GET /mesurement/{id}', () => {
    it('returns the right measurement', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/measurement/800000000000000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 200,
        res: {_id: '800000000000000000000001', condition_id: '700000000000000000000001', values: {dpt: [[3997.12558,98.00555],[3995.08519,98.03253],[3993.04480,98.02657]]}, measurement_template: '300000000000000000000001'}
      });
    });
    it('returns the measurement for an API key', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/measurement/800000000000000000000001',
        auth: {key: 'janedoe'},
        httpStatus: 200,
        res: {_id: '800000000000000000000001', condition_id: '700000000000000000000001', values: {dpt: [[3997.12558,98.00555],[3995.08519,98.03253],[3993.04480,98.02657]]}, measurement_template: '300000000000000000000001'}
      });
    });
    it('rejects an invalid id', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/measurement/8000000000h0000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 404
      });
    });
    it('rejects an unknown id', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/measurement/000000000000000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 404
      });
    });
    it('rejects unauthorized requests', done => {
      TestHelper.request(server, done, {
        method: 'get',
        url: '/measurement/800000000000000000000001',
        httpStatus: 401
      });
    });
  });

  describe('PUT /measurement/{id}', () => {
    it('returns the right measurement', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 200,
        req: {},
        res: {_id: '800000000000000000000001', condition_id: '700000000000000000000001', values: {dpt: [[3997.12558,98.00555],[3995.08519,98.03253],[3993.04480,98.02657]]}, measurement_template: '300000000000000000000001'}
      });
    });
    it('keeps unchanged values', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 200,
        req: {values: {dpt: [[3997.12558,98.00555],[3995.08519,98.03253],[3993.04480,98.02657]]}}
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({_id: '800000000000000000000001', condition_id: '700000000000000000000001', values: {dpt: [[3997.12558,98.00555],[3995.08519,98.03253],[3993.04480,98.02657]]}, measurement_template: '300000000000000000000001'});
        MeasurementModel.findById('800000000000000000000001').lean().exec((err, data: any) => {
          should(data).have.property('status', 10);
          done();
        });
      });
    });
    it('changes the given values', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 200,
        req: {values: {dpt: [[1,2],[3,4],[5,6]]}}
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({_id: '800000000000000000000001', condition_id: '700000000000000000000001', values: {dpt: [[1,2],[3,4],[5,6]]}, measurement_template: '300000000000000000000001'});
        MeasurementModel.findById('800000000000000000000001').lean().exec((err, data: any) => {
          should(data).have.only.keys('_id', 'condition_id', 'values', 'measurement_template', 'status', '__v');
          should(data.condition_id.toString()).be.eql('700000000000000000000001');
          should(data.measurement_template.toString()).be.eql('300000000000000000000001');
          should(data).have.property('status', 0);
          should(data).have.property('values');
          should(data.values).have.property('dpt', [[1,2],[3,4],[5,6]]);
          done();
        });
      });
    });
    it('allows changing only one value', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        auth: {basic: 'janedoe'},
        httpStatus: 200,
        req: {values: {'weight %': 0.9}},
        res: {_id: '800000000000000000000002', condition_id: '700000000000000000000002', values: {'weight %': 0.9, 'standard deviation': 0.2}, measurement_template: '300000000000000000000002'}
      });
    });
    it('rejects not specified values', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {values: {'weight %': 0.9, 'standard deviation': 0.3, xx: 44}},
        res: {status: 'Invalid body format', details: '"xx" is not allowed'}
      });
    });
    it('rejects a value not in the value range', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000003',
        auth: {basic: 'admin'},
        httpStatus: 400,
        req: {values: {val1: 4}},
        res: {status: 'Invalid body format', details: '"val1" must be one of [1, 2, 3]'}
      });
    });
    it('rejects a value below minimum range', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {values: {'weight %': -1, 'standard deviation': 0.3}},
        res: {status: 'Invalid body format', details: '"weight %" must be larger than or equal to 0'}
      });
    });
    it('rejects a value above maximum range', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {values: {'weight %': 0.9, 'standard deviation': 3}},
        res: {status: 'Invalid body format', details: '"standard deviation" must be less than or equal to 0.5'}
      });
    });
    it('rejects a new measurement template', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {values: {'weight %': 0.9, 'standard deviation': 0.3}, measurement_template: '300000000000000000000001'},
        res: {status: 'Invalid body format', details: '"measurement_template" is not allowed'}
      });
    });
    it('rejects editing a measurement for a write user who did not create this measurement', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000003',
        auth: {basic: 'janedoe'},
        httpStatus: 403,
        req: {values: {val1: 2}}
      });
    });
    it('accepts editing a measurement of another user for a maintain/admin user', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        auth: {basic: 'admin'},
        httpStatus: 200,
        req: {values: {'weight %': 0.9, 'standard deviation': 0.3}},
        res: {_id: '800000000000000000000002', condition_id: '700000000000000000000002', values: {'weight %': 0.9, 'standard deviation': 0.3}, measurement_template: '300000000000000000000002'}
      });
    });
    it('rejects an invalid id', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000h00000000000002',
        auth: {basic: 'janedoe'},
        httpStatus: 404
      });
    });
    it('rejects an unknown id', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/000000000000000000000002',
        auth: {basic: 'janedoe'},
        httpStatus: 404
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        auth: {key: 'janedoe'},
        httpStatus: 401,
        req: {values: {'weight %': 0.9, 'standard deviation': 0.3}},
      });
    });
    it('rejects requests from a read user', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        auth: {basic: 'user'},
        httpStatus: 403,
        req: {values: {'weight %': 0.9, 'standard deviation': 0.3}},
      });
    });
    it('rejects unauthorized requests', done => {
      TestHelper.request(server, done, {
        method: 'put',
        url: '/measurement/800000000000000000000002',
        httpStatus: 401,
        req: {values: {'weight %': 0.9, 'standard deviation': 0.3}},
      });
    });
  });

  describe('DELETE /measurement/{id}', () => {
    it('sets the status to deleted', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/measurement/800000000000000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 200,
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).be.eql({status: 'OK'});
        MeasurementModel.findById('800000000000000000000001').lean().exec((err, data) => {
          if (err) return done(err);
          should(data).have.property('status', -1);
          done();
        });
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/measurement/800000000000000000000001',
        auth: {key: 'janedoe'},
        httpStatus: 401,
      });
    });
    it('rejects requests from a read user', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/measurement/800000000000000000000001',
        auth: {basic: 'user'},
        httpStatus: 403,
      });
    });
    it('rejects deleting a measurement for a write user who did not create this measurement', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/measurement/800000000000000000000003',
        auth: {basic: 'janedoe'},
        httpStatus: 403,
      });
    });
    it('accepts deleting a measurement of another user for a maintain/admin user', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/measurement/800000000000000000000001',
        auth: {basic: 'admin'},
        httpStatus: 200,
        res: {status: 'OK'}
      });
    });
    it('rejects an invalid id', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/measurement/800000000h00000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 404,
      });
    });
    it('rejects an unknown id', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/measurement/000000000000000000000001',
        auth: {basic: 'janedoe'},
        httpStatus: 404,
      });
    });
    it('rejects unauthorized requests', done => {
      TestHelper.request(server, done, {
        method: 'delete',
        url: '/measurement/800000000000000000000001',
        httpStatus: 401,
      });
    });
  });

  describe('POST /measurement/new', () => {
    it('returns the right measurement', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 200,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'}
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).have.only.keys('_id', 'condition_id', 'values', 'measurement_template');
        should(res.body).have.property('_id').be.type('string');
        should(res.body).have.property('condition_id', '700000000000000000000001');
        should(res.body).have.property('measurement_template', '300000000000000000000002');
        should(res.body).have.property('values');
        should(res.body.values).have.property('weight %', 0.8);
        should(res.body.values).have.property('standard deviation', 0.1);
        done();
      });
    });
    it('stores the measurement', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 200,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'}
      }).end((err, res) => {
        if (err) return done(err);
        MeasurementModel.findById(res.body._id).lean().exec((err, data: any) => {
          if (err) return done(err);
          should(data).have.only.keys('_id', 'condition_id', 'values', 'measurement_template', 'status', '__v');
          should(data.condition_id.toString()).be.eql('700000000000000000000001');
          should(data.measurement_template.toString()).be.eql('300000000000000000000002');
          should(data).have.property('status', 0);
          should(data).have.property('values');
          should(data.values).have.property('weight %', 0.8);
          should(data.values).have.property('standard deviation', 0.1);
          done();
        });
      });
    });
    it('rejects an invalid condition id', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000h00000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'},
        res: {status: 'Invalid body format', details: '"condition_id" with value "700000000000h00000000001" fails to match the required pattern: /[0-9a-f]{24}/'}
      });
    });
    it('rejects a condition id not available', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '000000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'},
        res: {status: 'Condition id not available'}
      });
    });
    it('rejects an invalid measurement_template id', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '30000000000h000000000002'},
        res: {status: 'Invalid body format', details: '"measurement_template" with value "30000000000h000000000002" fails to match the required pattern: /[0-9a-f]{24}/'}
      });
    });
    it('rejects a measurement_template not available', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '000000000000000000000002'},
        res: {status: 'Measurement template not available'}
      });
    });
    it('rejects not specified values', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1, xx: 44}, measurement_template: '300000000000000000000002'},
        res: {status: 'Invalid body format', details: '"xx" is not allowed'}
      });
    });
    it('rejects missing values', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8}, measurement_template: '300000000000000000000002'},
        res: {status: 'Invalid body format', details: '"standard deviation" is required'}
      });
    });
    it('rejects a value not in the value range', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000000000000001', values: {val1: 4}, measurement_template: '300000000000000000000003'},
        res: {status: 'Invalid body format', details: '"val1" must be one of [1, 2, 3]'}
      });
    });
    it('rejects a value below minimum range', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000000000000001', values: {'weight %': -1, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'},
        res: {status: 'Invalid body format', details: '"weight %" must be larger than or equal to 0'}
      });
    });
    it('rejects a value above maximum range', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 2}, measurement_template: '300000000000000000000002'},
        res: {status: 'Invalid body format', details: '"standard deviation" must be less than or equal to 0.5'}
      });
    });
    it('rejects a missing condition id', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'},
        res: {status: 'Invalid body format', details: '"condition_id" is required'}
      });
    });
    it('rejects a missing measurement_template', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 400,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}},
        res: {status: 'Invalid body format', details: '"measurement_template" is required'}
      });
    });
    it('rejects adding a measurement to the sample of another user for a write user', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'janedoe'},
        httpStatus: 403,
        req: {condition_id: '700000000000000000000003', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'}
      });
    });
    it('accepts adding a measurement to the sample of another user for a maintain/admin user', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'admin'},
        httpStatus: 200,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'}
      }).end((err, res) => {
        if (err) return done(err);
        should(res.body).have.only.keys('_id', 'condition_id', 'values', 'measurement_template');
        should(res.body).have.property('_id').be.type('string');
        should(res.body).have.property('condition_id', '700000000000000000000001');
        should(res.body).have.property('measurement_template', '300000000000000000000002');
        should(res.body).have.property('values');
        should(res.body.values).have.property('weight %', 0.8);
        should(res.body.values).have.property('standard deviation', 0.1);
        done();
      });
    });
    it('rejects an API key', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {key: 'janedoe'},
        httpStatus: 401,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'}
      });
    });
    it('rejects requests from a read user', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        auth: {basic: 'user'},
        httpStatus: 403,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'}
      });
    });
    it('rejects unauthorized requests', done => {
      TestHelper.request(server, done, {
        method: 'post',
        url: '/measurement/new',
        httpStatus: 401,
        req: {condition_id: '700000000000000000000001', values: {'weight %': 0.8, 'standard deviation': 0.1}, measurement_template: '300000000000000000000002'}
      });
    });
  });
});