ParseRelation-test.js

jest.dontMock('../encode');
jest.dontMock('../CoreManager');
jest.dontMock('../ParseRelation');
jest.dontMock('../ParseOp');
jest.dontMock('../unique');

const mockStore = {};
const mockObject = function (className) {
  this.className = className;
  this.ops = {};
};
mockObject.registerSubclass = function () {};
mockObject.prototype = {
  _getId() {
    return this.id;
  },
  set(key, value) {
    if (!mockStore[this.id]) {
      mockStore[this.id] = {};
    }
    if (!mockStore[this.id][key]) {
      mockStore[this.id][key] = [];
    }
    mockStore[this.id][key].push(value);
  },
  relation(key) {
    if (mockStore[this.id][key]) {
      return this.get(key);
    }
    return new ParseRelation(this, key);
  },
  get(key) {
    return this.op(key).applyTo(null, { className: this.className, id: this.id }, key);
  },
  op(key) {
    let finalOp = undefined;
    for (let i = 0; i < mockStore[this.id][key].length; i++) {
      finalOp = mockStore[this.id][key][i].mergeWith(finalOp);
    }
    return finalOp;
  },
};
jest.setMock('../ParseObject', mockObject);

const mockQuery = function (className) {
  this.className = className;
  this.where = {};
  this._extraOptions = {};
};
mockQuery.prototype = {
  _addCondition(key, comparison, value) {
    this.where[key] = this.where[key] || {};
    this.where[key][comparison] = value;
  },
};
jest.setMock('../ParseQuery', mockQuery);

const ParseObject = require('../ParseObject');
const ParseRelation = require('../ParseRelation').default;
const CoreManager = require('../CoreManager');
CoreManager.setParseObject(mockObject);
CoreManager.setParseQuery(mockQuery);
CoreManager.setParseOp(require('../ParseOp'));

describe('ParseRelation', () => {
  it('can be constructed with a reference parent and key', () => {
    const parent = new ParseObject('Item');
    parent.id = 'I1';
    const r = new ParseRelation(parent, 'shipments');
    expect(r.parent).toBe(parent);
    expect(r.key).toBe('shipments');
    expect(r.targetClassName).toBe(null);
  });

  it('can add objects to a relation', () => {
    const parent = new ParseObject('Item');
    parent.id = 'I1';
    const r = new ParseRelation(parent, 'shipments');
    const o = new ParseObject('Delivery');
    o.id = 'D1';
    const p = r.add(o);
    expect(p).toBeTruthy();
    expect(r.toJSON()).toEqual({
      __type: 'Relation',
      className: 'Delivery',
    });
    expect(parent.op('shipments').toJSON()).toEqual({
      __op: 'AddRelation',
      objects: [{ __type: 'Pointer', objectId: 'D1', className: 'Delivery' }],
    });

    const o2 = new ParseObject('Delivery');
    o2.id = 'D2';
    const o3 = new ParseObject('Delivery');
    o3.id = 'D3';
    r.add([o2, o3]);
    expect(r.toJSON()).toEqual({
      __type: 'Relation',
      className: 'Delivery',
    });
    expect(parent.op('shipments').toJSON()).toEqual({
      __op: 'AddRelation',
      objects: [
        { __type: 'Pointer', objectId: 'D1', className: 'Delivery' },
        { __type: 'Pointer', objectId: 'D2', className: 'Delivery' },
        { __type: 'Pointer', objectId: 'D3', className: 'Delivery' },
      ],
    });
  });

  it('can add empty array to a relation', () => {
    const parent = new ParseObject('Item');
    parent.id = 'I1234';
    const r = new ParseRelation(parent, 'shipments');
    const o = new ParseObject('Delivery');
    o.id = 'D1234';
    const p = r.add(o);
    expect(p).toBeTruthy();
    expect(r.toJSON()).toEqual({
      __type: 'Relation',
      className: 'Delivery',
    });
    expect(parent.op('shipments').toJSON()).toEqual({
      __op: 'AddRelation',
      objects: [{ __type: 'Pointer', objectId: 'D1234', className: 'Delivery' }],
    });
    // Adding empty array shouldn't change the relation
    r.add([]);
    expect(r.toJSON()).toEqual({
      __type: 'Relation',
      className: 'Delivery',
    });
    expect(parent.op('shipments').toJSON()).toEqual({
      __op: 'AddRelation',
      objects: [{ __type: 'Pointer', objectId: 'D1234', className: 'Delivery' }],
    });
  });

  it('cannot add to relation without parent', () => {
    const relation = new ParseRelation();
    expect(() => {
      relation.add([]);
    }).toThrow('Cannot add to a Relation without a parent');
  });

  it('cannot remove from relation without parent', () => {
    const relation = new ParseRelation();
    expect(() => {
      relation.remove([]);
    }).toThrow('Cannot remove from a Relation without a parent');
  });

  it('cannot construct query from relation without parent', () => {
    const relation = new ParseRelation();
    expect(() => {
      relation.query();
    }).toThrow('Cannot construct a query for a Relation without a parent');
  });

  it('can remove objects from a relation', () => {
    const parent = new ParseObject('Item');
    parent.id = 'I2';
    const r = new ParseRelation(parent, 'shipments');
    const o = new ParseObject('Delivery');
    o.id = 'D1';
    r.remove(o);
    expect(r.toJSON()).toEqual({
      __type: 'Relation',
      className: 'Delivery',
    });
    expect(parent.op('shipments').toJSON()).toEqual({
      __op: 'RemoveRelation',
      objects: [{ __type: 'Pointer', objectId: 'D1', className: 'Delivery' }],
    });

    const o2 = new ParseObject('Delivery');
    o2.id = 'D2';
    const o3 = new ParseObject('Delivery');
    o3.id = 'D3';
    r.remove([o2, o3]);
    expect(r.toJSON()).toEqual({
      __type: 'Relation',
      className: 'Delivery',
    });
    expect(parent.op('shipments').toJSON()).toEqual({
      __op: 'RemoveRelation',
      objects: [
        { __type: 'Pointer', objectId: 'D1', className: 'Delivery' },
        { __type: 'Pointer', objectId: 'D2', className: 'Delivery' },
        { __type: 'Pointer', objectId: 'D3', className: 'Delivery' },
      ],
    });
  });

  it('can remove empty array from a relation', () => {
    const parent = new ParseObject('Item');
    parent.id = 'I5678';
    const r = new ParseRelation(parent, 'shipments');
    const o = new ParseObject('Delivery');
    o.id = 'D5678';
    r.remove(o);
    expect(r.toJSON()).toEqual({
      __type: 'Relation',
      className: 'Delivery',
    });
    expect(parent.op('shipments').toJSON()).toEqual({
      __op: 'RemoveRelation',
      objects: [{ __type: 'Pointer', objectId: 'D5678', className: 'Delivery' }],
    });
    // Removing empty array shouldn't change the relation
    r.remove([]);
    expect(r.toJSON()).toEqual({
      __type: 'Relation',
      className: 'Delivery',
    });
    expect(parent.op('shipments').toJSON()).toEqual({
      __op: 'RemoveRelation',
      objects: [{ __type: 'Pointer', objectId: 'D5678', className: 'Delivery' }],
    });
  });

  it('can generate a query for relation objects', () => {
    const parent = new ParseObject('Item');
    parent.id = 'I1';
    let r = new ParseRelation(parent, 'shipments');
    let q = r.query();
    expect(q.className).toBe('Item');
    expect(q._extraOptions).toEqual({
      redirectClassNameForKey: 'shipments',
    });
    expect(q.where).toEqual({
      $relatedTo: {
        object: {
          __type: 'Pointer',
          objectId: 'I1',
          className: 'Item',
        },
        key: 'shipments',
      },
    });

    r = new ParseRelation(parent, 'shipments');
    const o = new ParseObject('Delivery');
    o.id = 'D1';
    r.add(o);
    q = r.query();
    expect(q.className).toBe('Delivery');
    expect(q.where).toEqual({
      $relatedTo: {
        object: {
          __type: 'Pointer',
          className: 'Item',
          objectId: 'I1',
        },
        key: 'shipments',
      },
    });
  });

  it('can ensure it relates to the correct parent and key', () => {
    const parent = new ParseObject('Item');
    parent.id = 'I3';
    const r = new ParseRelation(parent, 'shipments');
    expect(r._ensureParentAndKey.bind(r, new ParseObject('Item'), 'shipments')).toThrow(
      'Internal Error. Relation retrieved from two different Objects.'
    );
    expect(() => {
      r._ensureParentAndKey(new ParseObject('TestObject'), 'shipments');
    }).toThrow('Internal Error. Relation retrieved from two different Objects.');
    expect(r._ensureParentAndKey.bind(r, parent, 'partners')).toThrow(
      'Internal Error. Relation retrieved from two different keys.'
    );
    expect(r._ensureParentAndKey.bind(r, parent, 'shipments')).not.toThrow();

    const noParent = new ParseRelation(null, null);
    noParent._ensureParentAndKey(parent);
    expect(noParent.parent).toEqual(parent);

    const noIdParent = new ParseObject('Item');
    const newParent = new ParseObject('Item');
    newParent.id = 'newId';

    const hasParent = new ParseRelation(noIdParent);
    hasParent._ensureParentAndKey(newParent);
    expect(hasParent.parent).toEqual(newParent);
  });
});