charlotte-graphql/test/lib/unit.js

Generates GraphQL type definitions and resolvers off of a concise spec.

'use strict';

const { strictEqual } = require('assert');
const { expandTypes } = require('../../lib/helpers');
const { TestPerson, TestCompany, TestFriendship, TestEmployment } = expandTypes(require('./types'));

const Person = TestPerson;
const Company = TestCompany;
const Friendship = TestFriendship;
const Employment = TestEmployment;

module.exports = (adapter, _afterEach = _.noop) => {
  afterEach(_afterEach);

  describe('#create/#get', () => {
    it('returns a hyperedge reference with added properties', async () => {
      const created = await adapter.create(Person, { name: 'Gizmo' })
      const loaded = await adapter.get(Person, created);
      strictEqual(loaded.uuid, created.uuid);
      strictEqual(loaded.name, created.name);
    });

    it('creates relationships to any referenced hyperedges', async () => {
      const person1 = await adapter.create(Person);
      const person2 = await adapter.create(Person);
      const friendship = await adapter.create(Friendship, { person1, person2 });
      strictEqual(friendship.person1.uuid, person1.uuid);
      strictEqual(friendship.person2.uuid, person2.uuid);
    });
  });

  describe('#remove', () => {
    it('removes hyperedge from database and any references to it', async () => {
      const person1 = await adapter.create(Person);
      const person2 = await adapter.create(Person);
      const friendship = await adapter.create(Friendship, { person1, person2 });

      await adapter.remove(Person, person1);

      const loadedPerson = await adapter.get(Person, person1);
      const loadedFriendship = await adapter.get(Friendship, friendship);

      strictEqual(loadedPerson, null);
      strictEqual(!!loadedFriendship.person1, false);
    });
  });

  describe('#find', () => {
    it('matches based on properties', async () => {
      const person1 = await adapter.create(Person, { name: 'Joe' });
      const person2 = await adapter.create(Person, { name: 'John' });
      const matches = await adapter.find(Person, {
        conditions: [{ name: ['John'] }]
      });
      strictEqual(matches.length, 1);
      strictEqual(matches[0].uuid, person2.uuid);
    });

    it('matches based on connected properties', async () => {
      const person1 = await adapter.create(Person, { name: 'Gizmo' });
      const person2 = await adapter.create(Person, { name: 'Gremlin' });
      const company1 = await adapter.create(Company, { name: 'Prolific' });
      const company2 = await adapter.create(Company, { name: 'Microsoft' });
      const employment1 = await adapter.create(Employment, { person: person1, company: company1 });
      const employment2 = await adapter.create(Employment, { person: person2, company: company2 });
      const matches = await adapter.find(Employment, {
        conditions: [{
          person: [{
            name: ['Gizmo']
          }]
        }]
      });

      strictEqual(matches.length, 1);
      strictEqual(matches[0].uuid, employment1.uuid);
      strictEqual(matches[0].person.uuid, person1.uuid);
      strictEqual(matches[0].company.uuid, company1.uuid);
    });

    it('accepts OR arguments', async () => {
      const person1 = await adapter.create(Person, { name: 'Gizmo' });
      const person2 = await adapter.create(Person, { name: 'Smart Gremlin' });
      const person3 = await adapter.create(Person, { name: 'Bat Gremlin' });
      const company1 = await adapter.create(Company, { name: 'Prolific' });
      const company2 = await adapter.create(Company, { name: 'Microsoft' });
      const employment1 = await adapter.create(Employment, { person: person1, company: company1 });
      const employment2 = await adapter.create(Employment, { person: person2, company: company2 });
      const employment3 = await adapter.create(Employment, { person: person3, company: company2 });

      const matches = await adapter.find(Employment, {
        conditions: [{
          person: [{
            name: ['Smart Gremlin']
          }]
        }, {
          company: [{
            name: ['Prolific']
          }]
        }]
      });

      strictEqual(matches.length, 2);
      strictEqual(matches.filter(match => match.uuid === employment1.uuid).length, 1);
      strictEqual(matches.filter(match => match.uuid === employment2.uuid).length, 1);
    });

    it('accepts AND arguments', async () => {
      const person1 = await adapter.create(Person, { name: 'Gizmo', x: 1 });
      const person2 = await adapter.create(Person, { name: 'Smart Gremlin', x: 1 });
      const person3 = await adapter.create(Person, { name: 'Bat Gremlin', x: 2 });
      const company1 = await adapter.create(Company, { name: 'Prolific' });
      const company2 = await adapter.create(Company, { name: 'Microsoft' });
      const employment1 = await adapter.create(Employment, { person: person1, company: company1 });
      const employment2 = await adapter.create(Employment, { person: person2, company: company2 });
      const employment3 = await adapter.create(Employment, { person: person3, company: company2 });

      const matches = await adapter.find(Employment, {
        conditions: [{
          person: [{
            x: [1]
          }],
          company: [{
            name: ['Microsoft']
          }]
        }]
      });

      strictEqual(matches.length, 1);
      strictEqual(matches[0].uuid, employment2.uuid);
    });

    it('queries reciprocal fields', async () => {
      const person1 = await adapter.create(Person, { name: 'Gizmo', x: 1 });
      const person2 = await adapter.create(Person, { name: 'Smart Gremlin', x: 1 });
      const person3 = await adapter.create(Person, { name: 'Bat Gremlin', x: 2 });
      const company1 = await adapter.create(Company, { name: 'Prolific' });
      const company2 = await adapter.create(Company, { name: 'Microsoft' });
      const employment1 = await adapter.create(Employment, { person: person1, company: company1 });
      const employment2 = await adapter.create(Employment, { person: person2, company: company2 });
      const employment3 = await adapter.create(Employment, { person: person3, company: company2 });

      const matches = await adapter.find(Person, {
        conditions: [{
          testEmployments: [{
            company: [{ name: ['Prolific'] }]
          }]
        }]
      });

      strictEqual(matches.length, 1);
      strictEqual(matches[0].uuid, person1.uuid);
    });

    it('applies limit and offset', async () => {
      const limit = 5;
      const offset = 35;

      for (let x = 0; x < 50; x += 1) {
        await adapter.create(Person, { x });
      }

      const results = await adapter.find(Person, {
        pagination: {
          limit,
          offset
        }
      });

      strictEqual(results.length, limit);

      results.forEach((result, x) => {
        strictEqual(result.x, x + offset);
      });
    });

    it('applies gt_ operator', async () => {
      for (let x = 100; x <= 110; x += 1) {
        await adapter.create(Person, { x });
      }

      const results = await adapter.find(Person, {
        conditions: [{
          gt_: { x: 109 }
        }]
      });

      strictEqual(results.length, 1);
      strictEqual(results[0].x, 110);
    });

    it('applies gte_ operator', async () => {
      for (let x = 100; x <= 110; x += 1) {
        await adapter.create(Person, { x });
      }

      const results = await adapter.find(Person, {
        conditions: [{
          gte_: { x: 109 }
        }]
      });

      strictEqual(results.length, 2);
      strictEqual(results.map(o => o.x).sort().join(' '), '109 110');
    });

    it('applies lt_ operator', async () => {
      for (let x = 0; x < 5; x += 1) {
        await adapter.create(Person, { x });
      }

      const results = await adapter.find(Person, {
        conditions: [{
          lt_: { x: 1 }
        }]
      });

      strictEqual(results.length, 1);
      strictEqual(results[0].x, 0);
    });

    it('applies lte_ operator', async () => {
      for (let x = 0; x < 5; x += 1) {
        await adapter.create(Person, { x });
      }

      const results = await adapter.find(Person, {
        conditions: [{
          lte_: { x: 1 }
        }]
      });

      strictEqual(results.length, 2);
      strictEqual(results.map(o => o.x).sort().join(' '), '0 1');
    });

    it('applies not_ operator', async () => {
      for (let x = 0; x < 5; x += 1) {
        await adapter.create(Person, { x });
      }

      const results = await adapter.find(Person, {
        conditions: [{
          not_: { x: 1 }
        }]
      });

      strictEqual(results.length, 4);
      strictEqual(results.map(o => o.x).sort().join(' '), '0 2 3 4');
    });

    it('applies search_ operator', async () => {
      const names = [
        'Joe',
        'James',
        'Joseph'
      ];

      for (let name of names) {
        await adapter.create(Person, { name });
      }

      const results = await adapter.find(Person, {
        conditions: [{
          search_: { name: 'jo' }
        }]
      });

      strictEqual(results.length, 2);
      strictEqual(results.map(o => o.name).sort().join(' '), 'Joe Joseph');
    });
  });

  describe('#update', () => {
    it('updates any passed properties', async () => {
      const created = await adapter.create(Person, { name: 'Gizmo' });
      const updated = await adapter.update(Person, {
        conditions: [{ uuid: [created.uuid] }],
        updates: { name: 'Gremlin' }
      });
      const loaded = await adapter.get(Person, created);
      strictEqual(loaded.name, 'Gremlin');
    });

    it('updates any relationships', async () => {
      const person1 = await adapter.create(Person, { name: 'P1' });
      const person2a = await adapter.create(Person, { name: 'P2a' });
      const person2b = await adapter.create(Person, { name: 'P3b' });
      const friendship = await adapter.create(Friendship, { person1, person2: person2a });

      await adapter.update(Friendship, {
        conditions: [{ uuid: [friendship.uuid] }],
        updates: {
          person2: person2b
        }
      });

      const loaded = await adapter.get(Friendship, friendship);

      strictEqual(loaded.person1.uuid, person1.uuid);
      strictEqual(loaded.person2.uuid, person2b.uuid);
    });
  });
};