@strapi/admin 4.15.0-alpha.0 → 4.15.1

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

@@ -0,0 +1,117 @@
+'use strict';
+
+jest.mock('@strapi/strapi/dist/utils/ee', () => ({
+  features: {
+    isEnabled() {
+      return true;
+    },
+    list() {
+      return [{ name: 'sso' }];
+    },
+  },
+}));
+
+const {
+  syncProviderRegistryWithConfig,
+  getStrategyCallbackURL,
+  providerRegistry,
+} = require('../passport/sso');
+const createProviderRegistry = require('../passport/provider-registry');
+
+describe('SSO', () => {
+  afterEach(() => {
+    providerRegistry.clear();
+  });
+
+  const register = jest.spyOn(providerRegistry, 'register');
+
+  describe('Sync Provider Registry with Config', () => {
+    test('The provider registry should match the auth config', async () => {
+      global.strapi = {
+        config: {
+          get: () => ({ providers: [{ uid: 'foo' }, { uid: 'bar' }] }),
+        },
+      };
+
+      syncProviderRegistryWithConfig();
+
+      expect(register).toHaveBeenCalledTimes(2);
+      expect(providerRegistry.size).toBe(2);
+    });
+  });
+
+  describe('Get Strategy Callback URL', () => {
+    const BASE_URL = '/admin/connect/{{ provider }}';
+
+    test.each(['foo', 'bar', 'foobar'])('Get a correct callback url for %s', (providerName) => {
+      expect(getStrategyCallbackURL(providerName)).toBe(
+        BASE_URL.replace('{{ provider }}', providerName)
+      );
+    });
+  });
+
+  describe('Provider Registry', () => {
+    const registry = createProviderRegistry();
+    const setSpy = jest.spyOn(registry, 'set');
+    const fooProvider = { uid: 'foo', createStrategy: jest.fn() };
+    const barProvider = { uid: 'bar', createStrategy: jest.fn() };
+
+    beforeEach(() => {
+      global.strapi = { isLoaded: false };
+    });
+
+    afterEach(() => {
+      registry.clear();
+      jest.clearAllMocks();
+    });
+
+    test('Cannot register after bootstrap', () => {
+      global.strapi = { isLoaded: true };
+
+      const fn = () => registry.register(fooProvider);
+
+      expect(fn).toThrowError(`You can't register new provider after the bootstrap`);
+      expect(registry.size).toBe(0);
+    });
+
+    test('Can register a provider', () => {
+      registry.register(fooProvider);
+
+      expect(setSpy).toHaveBeenCalledWith(fooProvider.uid, fooProvider);
+      expect(registry.size).toBe(1);
+    });
+
+    test('Can register several providers at once', () => {
+      const providers = [fooProvider, barProvider];
+
+      registry.registerMany(providers);
+
+      expect(setSpy).toHaveBeenCalledTimes(providers.length);
+      expect(registry.size).toBe(providers.length);
+    });
+
+    test('Do not register twice providers with the same uid', () => {
+      const providers = [fooProvider, fooProvider];
+
+      registry.registerMany(providers);
+
+      expect(setSpy).toHaveBeenCalledWith(fooProvider.uid, fooProvider);
+      expect(setSpy).toHaveBeenCalledTimes(2);
+      expect(registry.size).toBe(1);
+    });
+
+    test('Can update the value of a provider', () => {
+      const newFooProvider = {
+        ...fooProvider,
+        newProperty: 'foobar',
+      };
+
+      registry.register(fooProvider);
+      registry.register(newFooProvider);
+
+      expect(setSpy).toHaveBeenCalledTimes(2);
+      expect(registry.size).toBe(1);
+      expect(registry.get(fooProvider.uid)).toEqual(newFooProvider);
+    });
+  });
+});

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

@@ -0,0 +1,275 @@
+'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 { cloneDeep } = require('lodash/fp');
+
+const stageFactory = require('../review-workflows/stages');
+const { STAGE_MODEL_UID } = require('../../constants/workflows');
+
+const stageMock = {
+  id: 1,
+  name: 'test',
+  workflow: 1,
+};
+
+const relatedUID = 'uid';
+const workflowMock = {
+  id: 1,
+  stages: [
+    stageMock,
+    { id: 2, name: 'in progress', workflow: 1 },
+    {
+      id: 3,
+      name: 'ready to review',
+      related: [{ id: 3, __type: relatedUID }],
+      workflow: 1,
+    },
+    {
+      id: 4,
+      name: 'done',
+      related: [
+        { id: 1, __type: relatedUID },
+        { id: 2, __type: relatedUID },
+      ],
+      workflow: 1,
+    },
+  ],
+};
+
+const entityServiceMock = {
+  findOne: jest.fn((uid, id) => workflowMock.stages.find((stage) => stage.id === id) || { id }),
+  findMany: jest.fn(() => [stageMock]),
+  create: jest.fn((uid, { data }) => ({
+    ...data,
+    id: data?.id || Math.floor(Math.random() * 1000),
+  })),
+  update: jest.fn((uid, id, { data }) => data),
+  delete: jest.fn(() => true),
+};
+const servicesMock = {
+  'admin::workflows': {
+    findById: jest.fn(() => workflowMock),
+    update: jest.fn((id, data) => data),
+  },
+  'admin::review-workflows-metrics': {
+    sendDidCreateStage: jest.fn(),
+    sendDidEditStage: jest.fn(),
+    sendDidDeleteStage: jest.fn(),
+    sendDidChangeEntryStage: jest.fn(),
+  },
+  'admin::review-workflows-validation': {
+    register: jest.fn(),
+    validateWorkflowCount: jest.fn().mockResolvedValue(true),
+    validateWorkflowStages: jest.fn(),
+  },
+  'admin::stage-permissions': {
+    register: jest.fn(),
+    registerMany: jest.fn(),
+    unregister: jest.fn(),
+    can: jest.fn(() => true),
+  },
+};
+
+const queryUpdateMock = jest.fn(() => Promise.resolve());
+
+const strapiMock = {
+  query: jest.fn(() => ({
+    findOne: jest.fn(() => workflowMock),
+  })),
+  entityService: entityServiceMock,
+  service: jest.fn((serviceName) => {
+    return servicesMock[serviceName];
+  }),
+  db: {
+    transaction: jest.fn((func) => func({})),
+    query: jest.fn(() => ({
+      updateMany: queryUpdateMock,
+    })),
+    metadata: {
+      get: () => ({
+        tableName: 'test',
+        attributes: {
+          strapi_stage: {
+            joinColumn: {
+              name: 'strapi_stage_id',
+            },
+          },
+        },
+      }),
+    },
+  },
+  contentTypes: {
+    'api::shop.shop': {
+      kind: 'collectionType',
+      collectionName: 'shop',
+      options: {
+        reviewWorkflows: true,
+      },
+    },
+  },
+};
+
+const stagesService = stageFactory({ strapi: strapiMock });
+
+describe('Review workflows - Stages service', () => {
+  let mockUpdateEntitiesStage;
+  beforeEach(() => {
+    mockUpdateEntitiesStage = jest
+      .spyOn(stagesService, 'updateEntitiesStage')
+      .mockImplementation(() => {
+        return Promise.resolve();
+      });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+    mockUpdateEntitiesStage.mockRestore();
+  });
+
+  describe('find', () => {
+    test('Should call entityService with the right model UID and ID', async () => {
+      stagesService.find({ workflowId: 1 });
+
+      expect(entityServiceMock.findOne).not.toBeCalled();
+      expect(entityServiceMock.findMany).toBeCalled();
+      expect(entityServiceMock.findMany).toBeCalledWith(STAGE_MODEL_UID, {
+        filters: { workflow: 1 },
+      });
+    });
+  });
+  describe('findById', () => {
+    test('Should call entityService with the right model UID', async () => {
+      stagesService.findById(1, { workflowId: 1 });
+
+      expect(entityServiceMock.findMany).not.toBeCalled();
+      expect(entityServiceMock.findOne).toBeCalled();
+      expect(entityServiceMock.findOne).toBeCalledWith(STAGE_MODEL_UID, 1, {});
+    });
+  });
+  describe('replaceStages', () => {
+    test('Should create a new stage and assign it to workflow', async () => {
+      await stagesService.replaceStages(
+        [...workflowMock.stages],
+        [...workflowMock.stages, { name: 'to publish' }]
+      );
+
+      expect(entityServiceMock.create).toBeCalled();
+      expect(entityServiceMock.update).not.toBeCalled();
+      expect(entityServiceMock.delete).not.toBeCalled();
+    });
+    test('Should update a stage contained in the workflow', async () => {
+      const updateStages = cloneDeep(workflowMock.stages);
+      updateStages[0].name = `${updateStages[0].name}(new value)`;
+
+      await stagesService.replaceStages(workflowMock.stages, updateStages);
+
+      expect(entityServiceMock.create).not.toBeCalled();
+      expect(entityServiceMock.update).toBeCalled();
+      expect(entityServiceMock.delete).not.toBeCalled();
+    });
+    test('Should delete a stage contained in the workflow', async () => {
+      const selectedIndexes = [0, 2, 3];
+      await stagesService.replaceStages(
+        workflowMock.stages,
+        selectedIndexes.map((index) => workflowMock.stages[index])
+      );
+
+      expect(entityServiceMock.create).not.toBeCalled();
+      expect(entityServiceMock.update).not.toBeCalled();
+      expect(entityServiceMock.delete).toBeCalled();
+    });
+
+    // TODO: Fix when the updateEntitiesStage method is implemented
+    test.skip('Should move entities in a deleted stage to the previous stage', async () => {
+      await stagesService.replaceStages(workflowMock.stages, workflowMock.stages.slice(0, 3));
+
+      expect(entityServiceMock.create).not.toBeCalled();
+      expect(entityServiceMock.delete).toBeCalled();
+
+      // Here we are only deleting the stage containing related IDs 1 & 2
+      expect(stagesService.updateEntitiesStage).toHaveBeenCalledWith('api::shop.shop', {
+        fromStageId: workflowMock.stages[3].id,
+        toStageId: workflowMock.stages[2].id,
+      });
+    });
+
+    test.skip('When deleting all stages, all entities should be moved to the new stage', async () => {
+      const newStageID = 10;
+      await stagesService.replaceStages(workflowMock.stages, [
+        { id: newStageID, name: 'newStage', workflow: 1 },
+      ]);
+
+      expect(servicesMock['admin::workflows'].findById).toBeCalled();
+      expect(entityServiceMock.create).toBeCalled();
+      expect(entityServiceMock.delete).toBeCalled();
+
+      // Here we are deleting all stages and expecting all entities to be moved to the new stage
+      for (const stage of workflowMock.stages) {
+        expect(stagesService.updateEntitiesStage).toHaveBeenCalledWith('api::shop.shop', {
+          fromStageId: stage.id,
+          toStageId: newStageID,
+        });
+      }
+
+      expect(servicesMock['admin::workflows'].update).toBeCalled();
+      expect(servicesMock['admin::workflows'].update).toBeCalledWith(workflowMock.id, {
+        stages: [newStageID],
+      });
+
+      mockUpdateEntitiesStage.mockRestore();
+    });
+
+    test('New stage + updated + deleted', async () => {
+      await stagesService.replaceStages(workflowMock.stages, [
+        workflowMock.stages[0],
+        { id: workflowMock.stages[1].id, name: 'new_name' },
+        { name: 'new stage' },
+        { name: 'new stage2' },
+      ]);
+
+      expect(entityServiceMock.create).toBeCalled();
+      expect(entityServiceMock.update).toBeCalled();
+      expect(entityServiceMock.delete).toBeCalled();
+    });
+
+    test('Undefined destination stage permissions should apply a partial permission update', async () => {
+      const srcStages = workflowMock.stages.map((stage) => ({
+        ...stage,
+        permissions: [{ id: 1, role: 'role', action: 'action' }],
+      }));
+
+      const destStages = workflowMock.stages.map((stage, index) => ({
+        ...stage,
+        name: `Updated Name ${index}`,
+      }));
+
+      await stagesService.replaceStages(srcStages, destStages);
+
+      expect(entityServiceMock.create).not.toBeCalled();
+      expect(entityServiceMock.delete).not.toBeCalled();
+      expect(entityServiceMock.update).toBeCalledTimes(4);
+
+      destStages.forEach((stage, index) => {
+        expect(entityServiceMock.update).toBeCalledWith('admin::workflow-stage', stage.id, {
+          data: { ...stage, permissions: srcStages[index].permissions },
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,203 @@
+'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 workflowsServiceFactory = require('../review-workflows/workflows');
+const { WORKFLOW_MODEL_UID, WORKFLOW_POPULATE } = require('../../constants/workflows');
+
+const workflowMock = {
+  id: 1,
+};
+
+const entityServiceMock = {
+  findOne: jest.fn(() => workflowMock),
+  findMany: jest.fn(() => [workflowMock]),
+  update: jest.fn(() => [workflowMock]),
+  create: jest.fn(() => [workflowMock]),
+};
+
+const contentManagerServicesMock = {
+  'content-types': {
+    updateConfiguration: jest.fn(() => Promise.resolve()),
+  },
+};
+
+const pluginsMock = {
+  'content-manager': {
+    service: jest.fn((name) => contentManagerServicesMock[name]),
+  },
+};
+
+const reviewWorkflowsValidationMock = {
+  validateWorkflowCount: jest.fn().mockResolvedValue(true),
+  validateWorkflowStages: jest.fn(),
+};
+
+const stagesMock = [
+  {
+    id: 1,
+  },
+  { id: 2 },
+];
+
+const servicesMock = {
+  'admin::review-workflows-validation': reviewWorkflowsValidationMock,
+  'admin::review-workflows-metrics': {
+    sendDidCreateWorkflow: jest.fn(),
+    sendDidEditWorkflow: jest.fn(),
+  },
+  'admin::stages': {
+    replaceStages: jest.fn(async () => stagesMock),
+    createMany: jest.fn(async () => stagesMock),
+  },
+  'admin::stage-permissions': {
+    register: jest.fn(),
+    registerMany: jest.fn(),
+    unregister: jest.fn(),
+    can: jest.fn(() => true),
+  },
+};
+
+const strapiMock = {
+  entityService: entityServiceMock,
+  plugin: jest.fn((name) => pluginsMock[name]),
+  service: jest.fn((serviceName) => servicesMock[serviceName]),
+  db: {
+    transaction: jest.fn((func) => func()),
+  },
+};
+
+const workflowsService = workflowsServiceFactory({ strapi: strapiMock });
+
+describe('Review workflows - Workflows service', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('find', () => {
+    test('Should call entityService with the right model UID and ID', async () => {
+      workflowsService.find({ opt1: 1 });
+
+      expect(entityServiceMock.findOne).not.toBeCalled();
+      expect(entityServiceMock.findMany).toBeCalled();
+      expect(entityServiceMock.findMany).toBeCalledWith(WORKFLOW_MODEL_UID, {
+        opt1: 1,
+        filters: {},
+      });
+    });
+  });
+
+  describe('findById', () => {
+    test('Should call entityService with the right model UID', async () => {
+      workflowsService.findById(1, {});
+
+      expect(entityServiceMock.findMany).not.toBeCalled();
+      expect(entityServiceMock.findOne).toBeCalled();
+      expect(entityServiceMock.findOne).toBeCalledWith(WORKFLOW_MODEL_UID, 1, {});
+    });
+  });
+
+  describe('update', () => {
+    const uid = 'uid';
+    const workflow = {
+      id: 1,
+      name: 'Default',
+      contentTypes: [uid],
+      stages: [
+        {
+          id: 1,
+          name: 'To do',
+          color: '#4945FF',
+        },
+        {
+          id: 2,
+          name: 'Ready to review',
+          color: '#4945FF',
+        },
+      ],
+    };
+
+    const opts = {
+      data: {
+        ...workflow,
+        stages: workflow.stages.map((stage) => {
+          if (stage.id === 1) {
+            return {
+              ...stage,
+              name: 'Update',
+            };
+          }
+          return stage;
+        }),
+      },
+      populate: WORKFLOW_POPULATE,
+    };
+
+    test('Should call entityService with the right model UID', async () => {
+      await workflowsService.update(workflow, opts);
+
+      expect(entityServiceMock.update).toBeCalledWith(WORKFLOW_MODEL_UID, workflow.id, {
+        data: {
+          contentTypes: [uid],
+          id: workflow.id,
+          name: 'Default',
+          stages: workflow.stages.map((stage) => stage.id),
+        },
+        populate: WORKFLOW_POPULATE,
+      });
+      expect(servicesMock['admin::review-workflows-metrics'].sendDidEditWorkflow).toBeCalled();
+    });
+  });
+
+  describe('create', () => {
+    const uid = 'uid';
+    const opts = {
+      data: {
+        name: 'Workflow',
+        contentTypes: [uid],
+        stages: [
+          {
+            color: '#4945ff',
+            name: 'Stage 1',
+          },
+        ],
+      },
+      populate: WORKFLOW_POPULATE,
+    };
+
+    test('Should call entityService with the right model UID', async () => {
+      await workflowsService.create(opts);
+
+      expect(entityServiceMock.create).toBeCalledWith(WORKFLOW_MODEL_UID, {
+        data: {
+          contentTypes: [uid],
+          name: 'Workflow',
+          stages: stagesMock.map((stage) => stage.id),
+        },
+        populate: WORKFLOW_POPULATE,
+      });
+      expect(servicesMock['admin::review-workflows-metrics'].sendDidCreateWorkflow).toBeCalled();
+    });
+  });
+});

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

@@ -2,7 +2,7 @@
 
 const localProvider = require('@strapi/provider-audit-logs-local');
 const { scheduleJob } = require('node-schedule');
-const { features } = require('@strapi/strapi/dist/utils/ee').default;
+const { features } = require('@strapi/strapi/dist/utils/ee');
 
 const DEFAULT_RETENTION_DAYS = 90;
 

package/ee/server/services/passport/sso.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const ee = require('@strapi/strapi/dist/utils/ee').default;
+const ee = require('@strapi/strapi/dist/utils/ee');
 const { authEventsMapper } = require('../../../../server/services/passport');
 const createProviderRegistry = require('./provider-registry');
 

package/ee/server/services/passport.js

@@ -1,7 +1,7 @@
 'use strict';
 
 // eslint-disable-next-line node/no-extraneous-require
-const { features } = require('@strapi/strapi/dist/utils/ee').default;
+const { features } = require('@strapi/strapi/dist/utils/ee');
 
 const { UnauthorizedError } = require('@strapi/utils').errors;
 const createLocalStrategy = require('../../../server/services/passport/local-strategy');