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

'use strict';

const Parse = require("parse/node");
const Config = require('../lib/Config');

describe('Uniqueness', function() {
  it('fail when create duplicate value in unique field', done => {
    const obj = new Parse.Object('UniqueField');
    obj.set('unique', 'value');
    obj.save().then(() => {
      expect(obj.id).not.toBeUndefined();
      const config = Config.get('test');
      return config.database.adapter.ensureUniqueness('UniqueField', { fields: { unique: { __type: 'String' } } }, ['unique'])
    })
      .then(() => {
        const obj = new Parse.Object('UniqueField');
        obj.set('unique', 'value');
        return obj.save()
      }).then(() => {
        fail('Saving duplicate field should have failed');
        done();
      }, error => {
        expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
        done();
      });
  });

  it('unique indexing works on pointer fields', done => {
    const obj = new Parse.Object('UniquePointer');
    obj.save({ string: 'who cares' })
      .then(() => obj.save({ ptr: obj }))
      .then(() => {
        const config = Config.get('test');
        return config.database.adapter.ensureUniqueness('UniquePointer', { fields: {
          string: { __type: 'String' },
          ptr: { __type: 'Pointer', targetClass: 'UniquePointer' }
        } }, ['ptr']);
      })
      .then(() => {
        const newObj = new Parse.Object('UniquePointer')
        newObj.set('ptr', obj)
        return newObj.save()
      })
      .then(() => {
        fail('save should have failed due to duplicate value');
        done();
      })
      .catch(error => {
        expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
        done();
      });
  });

  it('fails when attempting to ensure uniqueness of fields that are not currently unique', done => {
    const o1 = new Parse.Object('UniqueFail');
    o1.set('key', 'val');
    const o2 = new Parse.Object('UniqueFail');
    o2.set('key', 'val');
    Parse.Object.saveAll([o1, o2])
      .then(() => {
        const config = Config.get('test');
        return config.database.adapter.ensureUniqueness('UniqueFail', { fields: { key: { __type: 'String' } } }, ['key']);
      })
      .catch(error => {
        expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
        done();
      });
  });

  it_exclude_dbs(['postgres'])('can do compound uniqueness', done => {
    const config = Config.get('test');
    config.database.adapter.ensureUniqueness('CompoundUnique', { fields: { k1: { __type: 'String' }, k2: { __type: 'String' } } }, ['k1', 'k2'])
      .then(() => {
        const o1 = new Parse.Object('CompoundUnique');
        o1.set('k1', 'v1');
        o1.set('k2', 'v2');
        return o1.save();
      })
      .then(() => {
        const o2 = new Parse.Object('CompoundUnique');
        o2.set('k1', 'v1');
        o2.set('k2', 'not a dupe');
        return o2.save();
      })
      .then(() => {
        const o3 = new Parse.Object('CompoundUnique');
        o3.set('k1', 'not a dupe');
        o3.set('k2', 'v2');
        return o3.save();
      })
      .then(() => {
        const o4 = new Parse.Object('CompoundUnique');
        o4.set('k1', 'v1');
        o4.set('k2', 'v2');
        return o4.save();
      })
      .catch(error => {
        expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
        done();
      });
  });
});