@strapi/strapi 4.10.0-beta.1 → 4.10.1-experimental.0

package/lib/services/__tests__/core-store.test.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const { createCoreStore } = require('../core-store');
+
+const data = {
+  key: 'testKey',
+  value: 'testValue',
+};
+
+const queryRes = {
+  id: 1,
+  key: 'testKey',
+  value: 'testValue',
+  type: 'string',
+  environment: null,
+  tag: null,
+};
+
+const where = {
+  key: 'plugin_testName_testKey',
+  environment: 'test',
+  tag: null,
+};
+
+describe('Core Store', () => {
+  test('Set key in empty store', async () => {
+    const fakeEmptyDBQuery = {
+      findOne: jest.fn(() => Promise.resolve()),
+      update: jest.fn(() => Promise.resolve(queryRes)),
+      create: jest.fn(() => Promise.resolve(queryRes)),
+      delete: jest.fn(() => Promise.resolve()),
+    };
+
+    const fakeEmptyDB = {
+      query: jest.fn(() => fakeEmptyDBQuery),
+    };
+
+    const emptyTestStore = createCoreStore({
+      db: fakeEmptyDB,
+    });
+
+    const store = emptyTestStore({
+      environment: 'test',
+      type: 'plugin',
+      name: 'testName',
+    });
+
+    await store.set(data);
+
+    expect(fakeEmptyDB.query).toHaveBeenCalledTimes(2);
+    expect(fakeEmptyDBQuery.findOne).toHaveBeenCalledWith({ where });
+    expect(fakeEmptyDBQuery.create).toHaveBeenCalledWith({
+      data: { ...where, value: JSON.stringify('testValue'), type: 'string' },
+    });
+  });
+
+  test('Set key in not empty store', async () => {
+    const fakeNotEmptyDBQuery = {
+      findOne: jest.fn(() => Promise.resolve(queryRes)),
+      update: jest.fn(() => Promise.resolve(queryRes)),
+      create: jest.fn(() => Promise.resolve(queryRes)),
+      delete: jest.fn(() => Promise.resolve()),
+    };
+
+    const fakeNotEmptyDB = {
+      query: jest.fn(() => fakeNotEmptyDBQuery),
+    };
+
+    const notEmptyTestStore = createCoreStore({
+      db: fakeNotEmptyDB,
+    });
+
+    const store = notEmptyTestStore({
+      environment: 'test',
+      type: 'plugin',
+      name: 'testName',
+    });
+
+    await store.set(data);
+
+    expect(fakeNotEmptyDB.query).toHaveBeenCalledTimes(2);
+    expect(fakeNotEmptyDBQuery.findOne).toHaveBeenCalledWith({ where });
+    expect(fakeNotEmptyDBQuery.update).toHaveBeenCalledWith({
+      where: { id: queryRes.id },
+      data: {
+        type: 'string',
+        value: JSON.stringify('testValue'),
+      },
+    });
+  });
+
+  test('Delete key from empty store', async () => {
+    const fakeEmptyDBQuery = {
+      findOne: jest.fn(() => Promise.resolve()),
+      update: jest.fn(() => Promise.resolve(queryRes)),
+      create: jest.fn(() => Promise.resolve(queryRes)),
+      delete: jest.fn(() => Promise.resolve()),
+    };
+
+    const fakeEmptyDB = {
+      query: jest.fn(() => fakeEmptyDBQuery),
+    };
+
+    const emptyTestStore = createCoreStore({
+      db: fakeEmptyDB,
+    });
+
+    const store = emptyTestStore({
+      environment: 'test',
+      type: 'plugin',
+      name: 'testName',
+    });
+
+    await store.delete(data);
+
+    expect(fakeEmptyDB.query).toHaveBeenCalledTimes(1);
+    expect(fakeEmptyDBQuery.delete).toHaveBeenCalledWith({ where });
+  });
+
+  test('Delete key from not empty store', async () => {
+    const fakeNotEmptyDBQuery = {
+      findOne: jest.fn(() => Promise.resolve(queryRes)),
+      update: jest.fn(() => Promise.resolve(queryRes)),
+      create: jest.fn(() => Promise.resolve(queryRes)),
+      delete: jest.fn(() => Promise.resolve()),
+    };
+
+    const fakeNotEmptyDB = {
+      query: jest.fn(() => fakeNotEmptyDBQuery),
+    };
+
+    const notEmptyTestStore = createCoreStore({
+      db: fakeNotEmptyDB,
+    });
+
+    const store = notEmptyTestStore({
+      environment: 'test',
+      type: 'plugin',
+      name: 'testName',
+    });
+
+    const rest = await store.delete(data);
+
+    expect(fakeNotEmptyDB.query).toHaveBeenCalledTimes(1);
+    expect(fakeNotEmptyDBQuery.delete).toHaveBeenCalledWith({ where });
+    expect(rest).toEqual(undefined);
+  });
+});

package/lib/services/__tests__/event-hub.test.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const createEventHub = require('../event-hub');
+
+describe('Event Hub', () => {
+  it('only triggers the callback once with once()', async () => {
+    const { once, emit } = createEventHub();
+
+    const fn = jest.fn();
+
+    const args = [1, 2, 3];
+    once('my-event', fn);
+
+    await emit('my-event', ...args);
+    await emit('my-event');
+    await emit('my-event');
+
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn).toHaveBeenCalledWith(...args);
+  });
+
+  it('subscribes and unsubscribes to all events', async () => {
+    const { subscribe, unsubscribe, emit } = createEventHub();
+
+    const fn = jest.fn();
+    subscribe(fn);
+
+    const args1 = [1, 2, 3];
+    const args2 = [4, 5, 6];
+
+    await emit('my-event', ...args1);
+    await emit('my-event', ...args2);
+    await emit('my-other-event');
+
+    expect(fn).toHaveBeenCalled();
+    expect(fn).toHaveBeenNthCalledWith(1, 'my-event', ...args1);
+    expect(fn).toHaveBeenNthCalledWith(2, 'my-event', ...args2);
+    expect(fn).toHaveBeenNthCalledWith(3, 'my-other-event');
+
+    // Unsubscribes with unsubscribe()
+    unsubscribe(fn);
+    await emit('my-event');
+    expect(fn).toHaveBeenCalledTimes(3);
+
+    // Unsubscribes with the returned function
+    const unsubscribe2 = subscribe(fn);
+    await emit('my-event');
+    expect(fn).toHaveBeenCalledTimes(4);
+    unsubscribe2();
+    await emit('my-event');
+    expect(fn).toHaveBeenCalledTimes(4);
+
+    // Avoid removing the wrong subscriber when unsubscribe is given a non-existing subscriber
+    const unsubscribe3 = subscribe(fn);
+    const unrelatedFunction = jest.fn();
+    unsubscribe(unrelatedFunction);
+    await emit('my-event');
+    expect(fn).toHaveBeenCalledTimes(5);
+    unsubscribe3();
+  });
+
+  it('adds and removes simple listeners', async () => {
+    const { on, off, emit } = createEventHub();
+
+    const fn = jest.fn();
+    const args = [1, 2, 3];
+
+    // Listens to event with on()
+    on('my-event', fn);
+    await emit('my-event', ...args);
+    expect(fn).toHaveBeenCalledWith(...args);
+
+    // Removes listener with off()
+    off('my-event', fn);
+    await emit('my-event');
+    expect(fn).toHaveBeenCalledTimes(1);
+
+    // Removes listener with the returned function
+    const off2 = on('my-event', fn);
+    await emit('my-event', ...args);
+    expect(fn).toHaveBeenCalledTimes(2);
+    off2();
+    await emit('my-event');
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it('removes all subscribers on destroy()', async () => {
+    const { subscribe, on, emit, destroy } = createEventHub();
+
+    const fn = jest.fn();
+    const fn2 = jest.fn();
+    subscribe(fn);
+    on('my-event', fn2);
+
+    await emit('my-event');
+    expect(fn).toHaveBeenCalled();
+    expect(fn2).toHaveBeenCalled();
+
+    destroy();
+
+    // Subscribers are removed
+    await emit('my-event');
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn2).toHaveBeenCalledTimes(1);
+  });
+
+  it('removes all subscribers on removeAllListeners()', async () => {
+    const { subscribe, on, emit, removeAllListeners } = createEventHub();
+
+    const fn = jest.fn();
+    const fn2 = jest.fn();
+    subscribe(fn);
+    on('my-event', fn2);
+
+    await emit('my-event');
+    expect(fn).toHaveBeenCalled();
+    expect(fn2).toHaveBeenCalled();
+
+    removeAllListeners();
+
+    // Subscribers are removed
+    await emit('my-event');
+    expect(fn).toHaveBeenCalledTimes(1);
+    expect(fn2).toHaveBeenCalledTimes(1);
+  });
+});

package/lib/services/__tests__/fs.test.js

@@ -0,0 +1,78 @@
+'use strict';
+
+jest.mock('fs-extra', () => ({
+  ensureFile: jest.fn(() => Promise.resolve()),
+  writeFile: jest.fn(() => Promise.resolve()),
+}));
+
+const path = require('path');
+const fse = require('fs-extra');
+const fs = require('../fs');
+
+describe('Strapi fs utils', () => {
+  const strapi = {
+    dirs: { dist: { root: '/tmp' }, app: { root: '/tmp' } },
+  };
+
+  test('Provides new functions', () => {
+    const strapiFS = fs(strapi);
+
+    expect(strapiFS.writeAppFile).toBeInstanceOf(Function);
+    expect(strapiFS.writePluginFile).toBeInstanceOf(Function);
+  });
+
+  describe('Write App File', () => {
+    test('Makes sure the path exists and writes', async () => {
+      const strapiFS = fs(strapi);
+
+      const content = '';
+
+      await strapiFS.writeAppFile('test', content);
+
+      expect(fse.ensureFile).toHaveBeenCalledWith(path.join('/', 'tmp', 'test'));
+      expect(fse.writeFile).toHaveBeenCalledWith(path.join('/', 'tmp', 'test'), content);
+    });
+
+    test('Normalize the path to avoid relative access to folders in parent directories', async () => {
+      const strapiFS = fs(strapi);
+
+      const content = '';
+
+      await strapiFS.writeAppFile('../../test', content);
+
+      expect(fse.ensureFile).toHaveBeenCalledWith(path.join('/', 'tmp', 'test'));
+      expect(fse.writeFile).toHaveBeenCalledWith(path.join('/', 'tmp', 'test'), content);
+    });
+
+    test('Works with array path', async () => {
+      const strapiFS = fs(strapi);
+
+      const content = '';
+
+      await strapiFS.writeAppFile(['test', 'sub', 'path'], content);
+
+      expect(fse.ensureFile).toHaveBeenCalledWith(path.join('/', 'tmp', 'test', 'sub', 'path'));
+      expect(fse.writeFile).toHaveBeenCalledWith(
+        path.join('/', 'tmp', 'test', 'sub', 'path'),
+        content
+      );
+    });
+  });
+
+  describe('Write Plugin File', () => {
+    test('Scopes the writes in the extensions folder', async () => {
+      const strapiFS = fs(strapi);
+
+      const content = '';
+
+      strapiFS.writeAppFile = jest.fn(() => Promise.resolve());
+
+      await strapiFS.writePluginFile('users-permissions', ['test', 'sub', 'path'], content);
+
+      expect(strapiFS.writeAppFile).toHaveBeenCalledWith(
+        'extensions/users-permissions/test/sub/path',
+        content
+      );
+    });
+  });
+});

package/lib/services/__tests__/worker-queue.test.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const WorkerQueue = require('../worker-queue');
+
+describe('WorkerQueue', () => {
+  test('Executes worker', async () => {
+    const fn = jest.fn();
+    const input = 1;
+
+    const q = new WorkerQueue({
+      logger: console.log.bind(console),
+      concurrency: 1,
+    });
+    q.subscribe(fn);
+
+    q.enqueue(input);
+
+    await new Promise((resolve) => {
+      setTimeout(resolve);
+    });
+
+    expect(fn).toHaveBeenCalledWith(input);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  test('Executes worker', async () => {
+    const fn = jest.fn();
+    const input = 1;
+
+    const q = new WorkerQueue({
+      logger: console.log.bind(console),
+      concurrency: 1,
+    });
+    q.subscribe(fn);
+
+    q.enqueue(input);
+    q.enqueue(input);
+    q.enqueue(input);
+
+    await new Promise((resolve) => {
+      setTimeout(resolve);
+    });
+
+    expect(fn).toHaveBeenCalledWith(input);
+    expect(fn).toHaveBeenCalledTimes(3);
+  });
+});

package/lib/services/entity-service/__tests__/entity-service-events.test.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const createEntityService = require('..');
+const entityValidator = require('../../entity-validator');
+
+describe('Entity service triggers webhooks', () => {
+  let instance;
+  const eventHub = { emit: jest.fn() };
+  let entity = { attr: 'value' };
+
+  beforeAll(() => {
+    const model = {
+      uid: 'api::test.test',
+      kind: 'singleType',
+      modelName: 'test-model',
+      privateAttributes: [],
+      attributes: {
+        attr: { type: 'string' },
+      },
+    };
+    instance = createEntityService({
+      strapi: {
+        getModel: () => model,
+      },
+      db: {
+        transaction: (cb) => cb(),
+        query: () => ({
+          count: () => 0,
+          create: ({ data }) => data,
+          update: ({ data }) => data,
+          findOne: () => entity,
+          findMany: () => [entity, entity],
+          delete: () => ({}),
+          deleteMany: () => ({}),
+        }),
+      },
+      eventHub,
+      entityValidator,
+    });
+
+    global.strapi = {
+      getModel: () => model,
+      config: {
+        get: () => [],
+      },
+    };
+  });
+
+  test('Emit event: Create', async () => {
+    // Create entity
+    await instance.create('test-model', { data: entity });
+
+    // Expect entry.create event to be emitted
+    expect(eventHub.emit).toHaveBeenCalledWith('entry.create', {
+      entry: entity,
+      model: 'test-model',
+      uid: 'api::test.test',
+    });
+
+    eventHub.emit.mockClear();
+  });
+
+  test('Emit event: Update', async () => {
+    // Update entity
+    await instance.update('test-model', 'entity-id', { data: entity });
+
+    // Expect entry.update event to be emitted
+    expect(eventHub.emit).toHaveBeenCalledWith('entry.update', {
+      entry: entity,
+      model: 'test-model',
+      uid: 'api::test.test',
+    });
+
+    eventHub.emit.mockClear();
+  });
+
+  test('Emit event: Delete', async () => {
+    // Delete entity
+    await instance.delete('test-model', 'entity-id', {});
+
+    // Expect entry.create event to be emitted
+    expect(eventHub.emit).toHaveBeenCalledWith('entry.delete', {
+      entry: entity,
+      model: 'test-model',
+      uid: 'api::test.test',
+    });
+
+    eventHub.emit.mockClear();
+  });
+
+  test('Emit event: Delete Many', async () => {
+    // Delete entity
+    await instance.deleteMany('test-model', {});
+
+    // Expect entry.create event to be emitted
+    expect(eventHub.emit).toHaveBeenCalledWith('entry.delete', {
+      entry: entity,
+      model: 'test-model',
+      uid: 'api::test.test',
+    });
+    // One event per each entity deleted
+    expect(eventHub.emit).toHaveBeenCalledTimes(2);
+
+    eventHub.emit.mockClear();
+  });
+
+  test('Do not emit event when no deleted entity', async () => {
+    entity = null;
+    // Delete non existent entity
+    await instance.delete('test-model', 'entity-id', {});
+
+    // Expect entry.create event to be emitted
+    expect(eventHub.emit).toHaveBeenCalledTimes(0);
+
+    eventHub.emit.mockClear();
+  });
+});