@strapi/admin 4.15.0 → 4.15.1

package/ee/server/services/__tests__/audit-logs.test.js

@@ -0,0 +1,300 @@
+'use strict';
+
+const { features } = require('@strapi/strapi/dist/utils/ee');
+const { register } = require('@strapi/provider-audit-logs-local');
+const { scheduleJob } = require('node-schedule');
+const createAuditLogsService = require('../audit-logs');
+const createEventHub = require('../../../../../strapi/dist/services/event-hub');
+
+jest.mock('../../../../server/register');
+
+jest.mock('../../utils', () => ({
+  getService: jest.fn().mockReturnValue({}),
+}));
+
+jest.mock('@strapi/strapi/dist/utils/ee', () => ({
+  features: {
+    isEnabled: jest.fn(),
+    get: jest.fn(),
+  },
+}));
+
+jest.mock('@strapi/provider-audit-logs-local', () => ({
+  register: jest.fn(),
+}));
+
+jest.mock('node-schedule', () => ({
+  scheduleJob: jest.fn(),
+}));
+
+describe('Audit logs service', () => {
+  afterEach(() => {
+    jest.resetModules();
+  });
+
+  afterAll(() => {
+    jest.useRealTimers();
+  });
+
+  describe('Init with audit logs disabled', () => {
+    beforeAll(() => {
+      features.isEnabled.mockReturnValue(false);
+    });
+
+    it('should not register the audit logs service when is disabled by the user', async () => {
+      const eeAdminRegister = require('../../register');
+      const mockRegister = jest.fn();
+
+      const strapi = {
+        container: {
+          register: mockRegister,
+        },
+        config: {
+          get: () => false,
+        },
+      };
+
+      await eeAdminRegister({ strapi });
+
+      expect(mockRegister).not.toHaveBeenCalledWith('audit-logs', expect.anything());
+    });
+
+    it('should not subscribe to events when the license does not allow it', async () => {
+      const mockSubscribe = jest.fn();
+
+      const strapi = {
+        container: {
+          register: jest.fn(),
+        },
+        config: {
+          get(key) {
+            switch (key) {
+              case 'admin.auditLogs.enabled':
+                return true;
+              case 'admin.auditLogs.retentionDays':
+                return undefined;
+              default:
+                return null;
+            }
+          },
+        },
+        eventHub: {
+          ...createEventHub(),
+          subscribe: mockSubscribe,
+        },
+        hook: () => ({
+          register: jest.fn(),
+        }),
+      };
+
+      // Should not subscribe to events at first
+      const auditLogsService = createAuditLogsService(strapi);
+      await auditLogsService.register();
+      expect(mockSubscribe).not.toHaveBeenCalled();
+
+      // Should subscribe to events when license gets enabled
+      features.isEnabled.mockImplementationOnce(() => true);
+      await strapi.eventHub.emit('ee.enable');
+      expect(mockSubscribe).toHaveBeenCalled();
+
+      // Should unsubscribe to events when license gets disabled
+      mockSubscribe.mockClear();
+      features.isEnabled.mockImplementationOnce(() => false);
+      await strapi.eventHub.emit('ee.disable');
+      expect(mockSubscribe).not.toHaveBeenCalled();
+
+      // Should recreate the service when license updates
+      const destroySpy = jest.spyOn(auditLogsService, 'destroy');
+      const registerSpy = jest.spyOn(auditLogsService, 'register');
+      await strapi.eventHub.emit('ee.update');
+      expect(destroySpy).toHaveBeenCalled();
+      expect(registerSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('Init with audit logs enabled', () => {
+    const mockRegister = jest.fn();
+    const mockScheduleJob = jest.fn((rule, callback) => callback());
+
+    // Audit logs Local Provider mocks
+    const mockSaveEvent = jest.fn();
+    const mockFindOne = jest.fn();
+    const mockFindMany = jest.fn();
+    const mockDeleteExpiredEvents = jest.fn();
+
+    let strapi = {};
+
+    beforeAll(() => {
+      features.isEnabled.mockReturnValue(true);
+      register.mockReturnValue({
+        saveEvent: mockSaveEvent,
+        findOne: mockFindOne,
+        findMany: mockFindMany,
+        deleteExpiredEvents: mockDeleteExpiredEvents,
+      });
+      scheduleJob.mockImplementation(mockScheduleJob);
+
+      strapi = {
+        admin: {
+          services: {
+            permission: {
+              actionProvider: { registerMany: jest.fn() },
+            },
+          },
+        },
+        container: {
+          register: mockRegister,
+        },
+        eventHub: createEventHub(),
+        hook: () => ({ register: jest.fn() }),
+        config: {
+          get: () => 90,
+        },
+        db: {
+          transaction(cb) {
+            const opt = {
+              onCommit(func) {
+                return func();
+              },
+            };
+            return cb(opt);
+          },
+        },
+      };
+    });
+
+    afterEach(() => {
+      mockSaveEvent.mockClear();
+      mockFindMany.mockClear();
+      mockScheduleJob.mockClear();
+    });
+
+    beforeEach(() => {
+      strapi.requestContext = {
+        get() {
+          return {
+            state: {
+              user: {
+                id: 1,
+              },
+              auth: {
+                strategy: {
+                  name: 'admin',
+                },
+              },
+            },
+          };
+        },
+      };
+    });
+
+    it('should register and init the audit logs service when registered', async () => {
+      const eeAdminRegister = require('../../register');
+
+      await eeAdminRegister({ strapi });
+
+      expect(mockRegister).toHaveBeenCalledWith('audit-logs', expect.anything());
+    });
+
+    it('should emit an event and capture it in the audit logs', async () => {
+      const auditLogsService = createAuditLogsService(strapi);
+      await auditLogsService.register();
+
+      jest.useFakeTimers().setSystemTime(new Date('1970-01-01T00:00:00.000Z'));
+
+      await strapi.eventHub.emit('entry.create', { meta: 'test' });
+
+      // Sends the processed event to a provider
+      expect(mockSaveEvent).toHaveBeenCalledTimes(1);
+      expect(mockSaveEvent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          action: 'entry.create',
+          date: '1970-01-01T00:00:00.000Z',
+          payload: { meta: 'test' },
+          userId: 1,
+        })
+      );
+    });
+
+    it('ignores events that are not in the event map', async () => {
+      const auditLogsService = createAuditLogsService(strapi);
+      auditLogsService.register();
+
+      const eventName = 'unknown';
+      const eventPayload = { meta: 'test' };
+      await strapi.eventHub.emit(eventName, eventPayload);
+
+      expect(mockSaveEvent).not.toHaveBeenCalled();
+    });
+
+    it('ignores entry events from the upload plugin', async () => {
+      const auditLogsService = createAuditLogsService(strapi);
+      auditLogsService.register();
+
+      await strapi.eventHub.emit('entry.create', { uid: 'plugin::upload.file' });
+      await strapi.eventHub.emit('entry.update', { uid: 'plugin::upload.folder' });
+
+      expect(mockSaveEvent).not.toHaveBeenCalled();
+    });
+
+    it('should find many audit logs with the right params', async () => {
+      const auditLogsService = createAuditLogsService(strapi);
+      await auditLogsService.register();
+      mockFindMany.mockResolvedValueOnce({ results: [], pagination: {} });
+
+      await strapi.eventHub.emit('entry.create', { meta: 'test' });
+
+      const params = { page: 1, pageSize: 10, order: 'createdAt:DESC' };
+      const result = await auditLogsService.findMany(params);
+
+      expect(mockFindMany).toHaveBeenCalledTimes(1);
+      expect(mockFindMany).toHaveBeenCalledWith(params);
+      expect(result).toEqual({ results: [], pagination: {} });
+    });
+
+    it('should find one audit log with the right params', async () => {
+      const auditLogsService = createAuditLogsService(strapi);
+      await auditLogsService.register();
+      mockFindOne.mockResolvedValueOnce({ id: 1, user: null });
+
+      await strapi.eventHub.emit('entry.create', { meta: 'test' });
+
+      const result = await auditLogsService.findOne(1);
+
+      expect(mockFindOne).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({ id: 1, user: null });
+    });
+
+    it('should create a cron job that executed one time a day', async () => {
+      const auditLogsService = createAuditLogsService(strapi);
+      await auditLogsService.register();
+
+      expect(mockScheduleJob).toHaveBeenCalledTimes(1);
+      expect(mockScheduleJob).toHaveBeenCalledWith('0 0 * * *', expect.any(Function));
+      expect(mockDeleteExpiredEvents).toHaveBeenCalledWith(expect.any(Date));
+    });
+
+    it('should not log event if strategy is not admin', async () => {
+      strapi.requestContext = {
+        get() {
+          return {
+            state: {
+              auth: {
+                strategy: {
+                  name: 'content-api',
+                },
+              },
+            },
+          };
+        },
+      };
+
+      const auditLogsService = createAuditLogsService(strapi);
+      await auditLogsService.register();
+
+      await strapi.eventHub.emit('entry.create', { meta: 'test' });
+
+      expect(mockSaveEvent).not.toHaveBeenCalled();
+    });
+  });
+});

package/ee/server/services/__tests__/passport.test.js

@@ -0,0 +1,95 @@
+'use strict';
+
+jest.mock('koa-passport', () => ({
+  use: jest.fn(),
+  initialize: jest.fn(),
+}));
+
+const passport = require('koa-passport');
+
+const { init } = require('../../../../server/services/passport');
+
+describe('Passport', () => {
+  afterEach(() => {
+    // Reset the mock on passport.use.toHaveBeenCalledTimes
+    jest.clearAllMocks();
+    // Reset the mock on strapi/ee so we can change its behavior
+    jest.resetModules();
+  });
+
+  describe('Init (SSO disabled)', () => {
+    beforeAll(() => {
+      jest.mock('@strapi/strapi/dist/utils/ee', () => ({
+        features: {
+          // Disable the SSO feature
+          isEnabled: (feature) => feature !== 'sso',
+        },
+      }));
+    });
+
+    test('It should register the local provider in passport and init it', () => {
+      const createStrategy = jest.fn(() => ({ foo: 'bar' }));
+      const { getPassportStrategies } = require('../passport');
+
+      global.strapi = {
+        admin: {
+          services: {
+            passport: { getPassportStrategies },
+          },
+        },
+        config: {
+          get: () => ({
+            providers: [
+              // Since SSO is disabled here, those strategies should be ignored
+              { uid: 'foo', createStrategy },
+              { uid: 'bar', createStrategy },
+            ],
+          }),
+        },
+      };
+
+      init();
+
+      expect(passport.use).toHaveBeenCalledTimes(1);
+      expect(passport.initialize).toHaveBeenCalled();
+    });
+  });
+
+  describe('Init (SSO enabled)', () => {
+    beforeAll(() => {
+      jest.mock('@strapi/strapi/dist/utils/ee', () => ({
+        features: {
+          // Enable all the features (including SSO)
+          isEnabled: () => true,
+        },
+      }));
+    });
+
+    test('It should register all providers in passport and init them', () => {
+      const createStrategy = jest.fn(() => ({ foo: 'bar' }));
+      const { getPassportStrategies } = require('../passport');
+
+      global.strapi = {
+        admin: {
+          services: {
+            passport: { getPassportStrategies },
+          },
+        },
+        config: {
+          get: () => ({
+            providers: [
+              // Since SSO is enabled, those strategies should be registered
+              { uid: 'foo', createStrategy },
+              { uid: 'bar', createStrategy },
+            ],
+          }),
+        },
+      };
+
+      init();
+
+      expect(passport.use).toHaveBeenCalledTimes(3);
+      expect(passport.initialize).toHaveBeenCalled();
+    });
+  });
+});

package/ee/server/services/__tests__/review-workflows-validation.test.js

@@ -0,0 +1,100 @@
+'use strict';
+
+jest.mock('@strapi/strapi/dist/utils/ee', () => {
+  const eeModule = () => true;
+
+  Object.assign(eeModule, {
+    features: {
+      isEnabled() {
+        return true;
+      },
+      getEnabled() {
+        return ['review-workflows'];
+      },
+    },
+  });
+
+  return eeModule;
+});
+
+jest.mock('../review-workflows/workflows/content-types', () => {
+  return jest.fn(() => ({
+    migrate: jest.fn(),
+  }));
+});
+
+const validationServiceFactory = require('../review-workflows/validation');
+const { MAX_WORKFLOWS, MAX_STAGES_PER_WORKFLOW } = require('../../constants/workflows');
+
+const workflowsServiceMock = {
+  count: jest.fn(() => 1),
+};
+
+const servicesMock = {
+  'admin::workflows': workflowsServiceMock,
+};
+
+const strapiMock = {
+  service: jest.fn((serviceName) => servicesMock[serviceName]),
+};
+let validationService;
+
+describe('Review workflows - Validation service', () => {
+  beforeEach(() => {
+    validationService = validationServiceFactory({ strapi: strapiMock });
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  describe('register', () => {
+    test('Limits object should be frozen after register', () => {
+      validationService.register({ numberOfWorkflows: 2, stagesPerWorkflow: 10 });
+      expect(validationService.limits.numberOfWorkflows).toEqual(2);
+      expect(validationService.limits.stagesPerWorkflow).toEqual(10);
+      expect(Object.isFrozen(validationService.limits)).toBe(true);
+    });
+    test(`Limits object shouldn't be frozen before register`, () => {
+      expect(validationService.limits.numberOfWorkflows).toEqual(MAX_WORKFLOWS);
+      expect(validationService.limits.stagesPerWorkflow).toEqual(MAX_STAGES_PER_WORKFLOW);
+      expect(Object.isFrozen(validationService.limits)).toBe(false);
+    });
+    test('Limits object should not be modified after first register', () => {
+      validationService.register({ numberOfWorkflows: 2, stagesPerWorkflow: 10 });
+      expect(validationService.limits.numberOfWorkflows).toEqual(2);
+      expect(validationService.limits.stagesPerWorkflow).toEqual(10);
+      validationService.register({ workflows: 99, stagesPerWorkflow: 99 });
+      expect(validationService.limits.numberOfWorkflows).toEqual(2);
+      expect(validationService.limits.stagesPerWorkflow).toEqual(10);
+    });
+  });
+  describe('validateWorkflowCount', () => {
+    test('Should not throw because limit is not reached', async () => {
+      validationService.register({ numberOfWorkflows: 2 });
+      workflowsServiceMock.count.mockReturnValue(1);
+      await expect(validationService.validateWorkflowCount()).resolves.not.toThrowError();
+    });
+    test('Should throw because limit is reached', async () => {
+      validationService.register({ numberOfWorkflows: 2 });
+      workflowsServiceMock.count.mockReturnValue(2);
+      await expect(validationService.validateWorkflowCount(1)).rejects.toThrowError();
+    });
+  });
+  describe('validateWorkflowStages', () => {
+    test('Should not throw because limit is not reached and at least 1 stage', async () => {
+      validationService.register({ stagesPerWorkflow: 2 });
+      expect(() =>
+        validationService.validateWorkflowStages([{ name: 'a' }, { name: 'b' }])
+      ).not.toThrowError();
+    });
+    test('Should throw because limit is reached', async () => {
+      validationService.register({ stagesPerWorkflow: 2 });
+      expect(() => validationService.validateWorkflowStages([{}, {}, {}])).toThrowError();
+    });
+    test('Should throw because stage name is duplicated', async () => {
+      validationService.register({ stagesPerWorkflow: 200 });
+      expect(() =>
+        validationService.validateWorkflowStages([{ name: 'a' }, { name: 'a' }])
+      ).toThrowError();
+    });
+  });
+});

package/ee/server/services/__tests__/review-workflows.test.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const reviewWorkflowsServiceFactory = require('../review-workflows/review-workflows');
+const { ENTITY_STAGE_ATTRIBUTE, ENTITY_ASSIGNEE_ATTRIBUTE } = require('../../constants/workflows');
+
+const workflowMock = {
+  id: 1,
+};
+const stagesMock = [
+  {
+    id: 1,
+    name: 'stage 1',
+  },
+  {
+    id: 2,
+    name: 'stage 2',
+  },
+  {
+    id: 3,
+    name: 'stage 3',
+  },
+];
+
+const workflowsServiceMock = {
+  count: jest.fn(() => 0),
+  create: jest.fn(() => workflowMock),
+};
+const stagesServiceMock = {
+  count: jest.fn(() => 0),
+  createMany: jest.fn(() => stagesMock),
+};
+
+const queryMock = {
+  findOne: jest.fn(),
+};
+
+const contentTypesMock = {
+  test1: {
+    options: {},
+    attributes: {},
+    pluginOptions: {
+      'content-manager': {
+        visible: false,
+      },
+    },
+    collectionName: 'test1',
+  },
+  test2: {
+    attributes: {},
+    collectionName: 'test2',
+  },
+};
+
+const contentTypesContainer = {
+  get: jest.fn((uid) => contentTypesMock[uid]),
+  extend: jest.fn((uid, callback) => callback(contentTypesMock[uid])),
+};
+
+const containerMock = {
+  get: jest.fn((container) => {
+    switch (container) {
+      case 'content-types':
+        return contentTypesContainer;
+      default:
+        return null;
+    }
+  }),
+};
+
+const reviewWorkflowsValidationMock = {
+  register: jest.fn(),
+  validateWorkflowCount: jest.fn().mockResolvedValue(true),
+  validateWorkflowStages: jest.fn(),
+};
+
+const hookMock = jest.fn().mockReturnValue({ register: jest.fn() });
+
+const strapiMock = {
+  contentTypes: contentTypesMock,
+  container: containerMock,
+  hook: hookMock,
+  query: jest.fn(() => queryMock),
+  service(serviceName) {
+    switch (serviceName) {
+      case 'admin::stages':
+        return stagesServiceMock;
+      case 'admin::workflows':
+        return workflowsServiceMock;
+      case 'admin::review-workflows-validation':
+        return reviewWorkflowsValidationMock;
+      default:
+        return null;
+    }
+  },
+  webhookStore: {
+    addAllowedEvent: jest.fn(),
+  },
+};
+
+const reviewWorkflowsService = reviewWorkflowsServiceFactory({ strapi: strapiMock });
+
+describe('Review workflows service', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('bootstrap', () => {
+    test('Without stages or workflows in DB', async () => {
+      await reviewWorkflowsService.bootstrap();
+
+      expect(workflowsServiceMock.count).toBeCalled();
+      expect(stagesServiceMock.count).toBeCalled();
+
+      expect(workflowsServiceMock.create).toBeCalled();
+    });
+    test('With a workflow in DB', async () => {
+      workflowsServiceMock.count.mockResolvedValue(1);
+      await reviewWorkflowsService.bootstrap();
+
+      expect(workflowsServiceMock.count).toBeCalled();
+      expect(stagesServiceMock.count).toBeCalled();
+
+      expect(stagesServiceMock.createMany).not.toBeCalled();
+      expect(workflowsServiceMock.create).not.toBeCalled();
+    });
+    test('With stages in DB', async () => {
+      stagesServiceMock.count.mockResolvedValue(5);
+      await reviewWorkflowsService.bootstrap();
+
+      expect(workflowsServiceMock.count).toBeCalled();
+      expect(stagesServiceMock.count).toBeCalled();
+
+      expect(stagesServiceMock.createMany).not.toBeCalled();
+      expect(workflowsServiceMock.create).not.toBeCalled();
+    });
+  });
+  describe('register', () => {
+    test('Content types with review workflows options should have new attributes for assignee and stage relations', async () => {
+      await reviewWorkflowsService.register();
+      expect(contentTypesContainer.extend).toHaveBeenCalledTimes(1);
+      expect(contentTypesContainer.extend).not.toHaveBeenCalledWith('test1', expect.any(Function));
+      expect(contentTypesContainer.extend).toHaveBeenCalledWith('test2', expect.any(Function));
+
+      const extendFunc = contentTypesContainer.extend.mock.calls[0][1];
+
+      expect(extendFunc({ collectionName: 'toto' })).toEqual({
+        collectionName: 'toto',
+        attributes: {
+          [ENTITY_STAGE_ATTRIBUTE]: expect.objectContaining({
+            relation: 'oneToOne',
+            target: 'admin::workflow-stage',
+            type: 'relation',
+          }),
+          [ENTITY_ASSIGNEE_ATTRIBUTE]: expect.objectContaining({
+            relation: 'oneToOne',
+            target: 'admin::user',
+            type: 'relation',
+          }),
+        },
+      });
+    });
+  });
+});