@strapi/admin 4.16.2 → 4.18.0

package/ee/server/routes/sso.js

@@ -1,69 +0,0 @@
-'use strict';
-
-const { enableFeatureMiddleware } = require('./utils');
-
-module.exports = {
-  type: 'admin',
-  routes: [
-    {
-      method: 'GET',
-      path: '/providers',
-      handler: 'authentication.getProviders',
-      config: {
-        middlewares: [enableFeatureMiddleware('sso')],
-        auth: false,
-      },
-    },
-    {
-      method: 'GET',
-      path: '/connect/:provider',
-      handler: 'authentication.providerLogin',
-      config: {
-        middlewares: [enableFeatureMiddleware('sso')],
-        auth: false,
-      },
-    },
-    {
-      method: 'POST',
-      path: '/connect/:provider',
-      handler: 'authentication.providerLogin',
-      config: {
-        middlewares: [enableFeatureMiddleware('sso')],
-        auth: false,
-      },
-    },
-    {
-      method: 'GET',
-      path: '/providers/options',
-      handler: 'authentication.getProviderLoginOptions',
-      config: {
-        middlewares: [enableFeatureMiddleware('sso')],
-        policies: [
-          'admin::isAuthenticatedAdmin',
-          { name: 'admin::hasPermissions', config: { actions: ['admin::provider-login.read'] } },
-        ],
-      },
-    },
-    {
-      method: 'PUT',
-      path: '/providers/options',
-      handler: 'authentication.updateProviderLoginOptions',
-      config: {
-        middlewares: [enableFeatureMiddleware('sso')],
-        policies: [
-          'admin::isAuthenticatedAdmin',
-          { name: 'admin::hasPermissions', config: { actions: ['admin::provider-login.update'] } },
-        ],
-      },
-    },
-    {
-      method: 'GET',
-      path: '/providers/isSSOLocked',
-      handler: 'user.isSSOLocked',
-      config: {
-        middlewares: [enableFeatureMiddleware('sso')],
-        policies: ['admin::isAuthenticatedAdmin'],
-      },
-    },
-  ],
-};

package/ee/server/routes/utils.js

@@ -1,15 +0,0 @@
-'use strict';
-
-const { features } = require('@strapi/strapi/dist/utils/ee');
-
-const enableFeatureMiddleware = (featureName) => (ctx, next) => {
-  if (features.isEnabled(featureName)) {
-    return next();
-  }
-
-  ctx.status = 404;
-};
-
-module.exports = {
-  enableFeatureMiddleware,
-};

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

@@ -1,76 +0,0 @@
-'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;
-});
-
-const { ENTITY_ASSIGNEE_ATTRIBUTE } = require('../../constants/workflows');
-const assigneeFactory = require('../review-workflows/assignees');
-
-const uid = 'uid';
-const fromAssigneeId = 1;
-const entityServiceMock = {
-  findOne: jest.fn(() => {
-    return {
-      [ENTITY_ASSIGNEE_ATTRIBUTE]: {
-        id: fromAssigneeId,
-      },
-    };
-  }),
-  update: jest.fn((uid, id, { data }) => data),
-};
-const servicesMock = {
-  'admin::user': {
-    exists: jest.fn(() => true),
-  },
-  'admin::review-workflows-metrics': {
-    sendDidEditAssignee: jest.fn(),
-  },
-};
-
-const strapiMock = {
-  entityService: entityServiceMock,
-  service: jest.fn((serviceName) => {
-    return servicesMock[serviceName];
-  }),
-};
-
-const assigneeService = assigneeFactory({ strapi: strapiMock });
-
-describe('Review workflows - Stages service', () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('updateEntityAssignee', () => {
-    it('should update the assignee of an entity', async () => {
-      const id = 10;
-      const toId = 2;
-      await assigneeService.updateEntityAssignee(id, uid, toId);
-
-      expect(servicesMock['admin::user'].exists).toBeCalled();
-      expect(servicesMock['admin::review-workflows-metrics'].sendDidEditAssignee).toBeCalledWith(
-        fromAssigneeId,
-        toId
-      );
-      expect(entityServiceMock.update).toBeCalledWith(uid, id, {
-        data: { [ENTITY_ASSIGNEE_ATTRIBUTE]: toId },
-        fields: [],
-        populate: [ENTITY_ASSIGNEE_ATTRIBUTE],
-      });
-    });
-  });
-});

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

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

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

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