@strapi/strapi 4.10.1 → 4.10.2

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

@@ -1,148 +0,0 @@
-'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

@@ -1,126 +0,0 @@
-'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

@@ -1,78 +0,0 @@
-'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

@@ -1,47 +0,0 @@
-'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

@@ -1,117 +0,0 @@
-'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();
-  });
-});