@strapi/admin 4.16.2 → 4.18.0

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

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

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

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

@@ -1,275 +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 { 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 },
-        });
-      });
-    });
-  });
-});