kami-parse-server/spec/ParseGlobalConfig.spec.js

'use strict';

const request = require('request');
const Config = require('../lib/Config');

describe('a GlobalConfig', () => {
  beforeEach(done => {
    const config = Config.get('test');
    const query = on_db(
      'mongo',
      () => {
        // Legacy is with an int...
        return { objectId: 1 };
      },
      () => {
        return { objectId: '1' };
      }
    );
    config.database.adapter
      .upsertOneObject(
        '_GlobalConfig',
        {
          fields: { objectId: { type: 'Number' }, params: { type: 'Object' } },
        },
        query,
        { params: { companies: ['US', 'DK'] } }
      )
      .then(done, err => {
        jfail(err);
        done();
      });
  });

  it('can be retrieved', done => {
    request.get(
      {
        url: 'http://localhost:8378/1/config',
        json: true,
        headers: {
          'X-Parse-Application-Id': 'test',
          'X-Parse-Master-Key': 'test',
        },
      },
      (error, response, body) => {
        try {
          expect(response.statusCode).toEqual(200);
          expect(body.params.companies).toEqual(['US', 'DK']);
        } catch (e) {
          jfail(e);
        }
        done();
      }
    );
  });

  it('can be updated when a master key exists', done => {
    request.put(
      {
        url: 'http://localhost:8378/1/config',
        json: true,
        body: { params: { companies: ['US', 'DK', 'SE'] } },
        headers: {
          'X-Parse-Application-Id': 'test',
          'X-Parse-Master-Key': 'test',
        },
      },
      (error, response, body) => {
        expect(response.statusCode).toEqual(200);
        expect(body.result).toEqual(true);
        done();
      }
    );
  });

  it('can add and retrive files', done => {
    request.put(
      {
        url: 'http://localhost:8378/1/config',
        json: true,
        body: {
          params: { file: { __type: 'File', name: 'name', url: 'http://url' } },
        },
        headers: {
          'X-Parse-Application-Id': 'test',
          'X-Parse-Master-Key': 'test',
        },
      },
      (error, response, body) => {
        expect(response.statusCode).toEqual(200);
        expect(body.result).toEqual(true);
        Parse.Config.get().then(res => {
          const file = res.get('file');
          expect(file.name()).toBe('name');
          expect(file.url()).toBe('http://url');
          done();
        });
      }
    );
  });

  it('can add and retrive Geopoints', done => {
    const geopoint = new Parse.GeoPoint(10, -20);
    request.put(
      {
        url: 'http://localhost:8378/1/config',
        json: true,
        body: { params: { point: geopoint.toJSON() } },
        headers: {
          'X-Parse-Application-Id': 'test',
          'X-Parse-Master-Key': 'test',
        },
      },
      (error, response, body) => {
        expect(response.statusCode).toEqual(200);
        expect(body.result).toEqual(true);
        Parse.Config.get().then(res => {
          const point = res.get('point');
          expect(point.latitude).toBe(10);
          expect(point.longitude).toBe(-20);
          done();
        });
      }
    );
  });

  it('properly handles delete op', done => {
    request.put(
      {
        url: 'http://localhost:8378/1/config',
        json: true,
        body: { params: { companies: { __op: 'Delete' }, foo: 'bar' } },
        headers: {
          'X-Parse-Application-Id': 'test',
          'X-Parse-Master-Key': 'test',
        },
      },
      (error, response, body) => {
        expect(response.statusCode).toEqual(200);
        expect(body.result).toEqual(true);
        request.get(
          {
            url: 'http://localhost:8378/1/config',
            json: true,
            headers: {
              'X-Parse-Application-Id': 'test',
              'X-Parse-Master-Key': 'test',
            },
          },
          (error, response, body) => {
            try {
              expect(response.statusCode).toEqual(200);
              expect(body.params.companies).toBeUndefined();
              expect(body.params.foo).toBe('bar');
              expect(Object.keys(body.params).length).toBe(1);
            } catch (e) {
              jfail(e);
            }
            done();
          }
        );
      }
    );
  });

  it('fail to update if master key is missing', done => {
    request.put(
      {
        url: 'http://localhost:8378/1/config',
        json: true,
        body: { params: { companies: [] } },
        headers: {
          'X-Parse-Application-Id': 'test',
          'X-Parse-REST-API-Key': 'rest',
        },
      },
      (error, response, body) => {
        expect(response.statusCode).toEqual(403);
        expect(body.error).toEqual('unauthorized: master key is required');
        done();
      }
    );
  });

  it('failed getting config when it is missing', done => {
    const config = Config.get('test');
    config.database.adapter
      .deleteObjectsByQuery(
        '_GlobalConfig',
        { fields: { params: { __type: 'String' } } },
        { objectId: '1' }
      )
      .then(() => {
        request.get(
          {
            url: 'http://localhost:8378/1/config',
            json: true,
            headers: {
              'X-Parse-Application-Id': 'test',
              'X-Parse-Master-Key': 'test',
            },
          },
          (error, response, body) => {
            expect(response.statusCode).toEqual(200);
            expect(body.params).toEqual({});
            done();
          }
        );
      })
      .catch(e => {
        jfail(e);
        done();
      });
  });
});