@strapi/strapi 4.10.1-experimental.0 → 4.10.2-alpha.0

package/lib/commands/actions/export/__tests__/export.test.js

@@ -1,175 +0,0 @@
-'use strict';
-
-const { expectExit } = require('../../../__tests__/commands.test.utils');
-
-describe('Export', () => {
-  const defaultFileName = 'defaultFilename';
-
-  jest.mock('fs-extra', () => ({
-    pathExists: jest.fn(() => Promise.resolve(true)),
-  }));
-
-  const mockDataTransfer = {
-    file: {
-      providers: {
-        createLocalFileDestinationProvider: jest.fn().mockReturnValue({ name: 'testDest' }),
-      },
-    },
-    strapi: {
-      providers: {
-        createLocalStrapiSourceProvider: jest.fn().mockReturnValue({ name: 'testSource' }),
-      },
-    },
-    engine: {
-      ...jest.requireActual('@strapi/data-transfer').engine,
-      errors: {},
-      createTransferEngine() {
-        return {
-          transfer: jest.fn(() => {
-            return {
-              engine: {},
-              destination: {
-                file: {
-                  path: 'path',
-                },
-              },
-            };
-          }),
-          progress: {
-            on: jest.fn(),
-            stream: {
-              on: jest.fn(),
-            },
-          },
-          sourceProvider: { name: 'testSource' },
-          destinationProvider: { name: 'testDestination' },
-          diagnostics: {
-            on: jest.fn().mockReturnThis(),
-            onDiagnostic: jest.fn().mockReturnThis(),
-          },
-        };
-      },
-    },
-  };
-
-  jest.mock('@strapi/data-transfer', () => mockDataTransfer);
-
-  // command utils
-  const mockUtils = {
-    getTransferTelemetryPayload: jest.fn().mockReturnValue({}),
-    loadersFactory: jest.fn().mockReturnValue({ updateLoader: jest.fn() }),
-    formatDiagnostic: jest.fn(),
-    createStrapiInstance() {
-      return {
-        telemetry: {
-          send: jest.fn(),
-        },
-      };
-    },
-    getDefaultExportName: jest.fn(() => defaultFileName),
-    buildTransferTable: jest.fn(() => {
-      return {
-        toString() {
-          return 'table';
-        },
-      };
-    }),
-    exitMessageText: jest.fn(),
-  };
-  jest.mock(
-    '../../../utils/data-transfer.js',
-    () => {
-      return mockUtils;
-    },
-    { virtual: true }
-  );
-
-  // console spies
-  jest.spyOn(console, 'log').mockImplementation(() => {});
-  jest.spyOn(console, 'warn').mockImplementation(() => {});
-  jest.spyOn(console, 'info').mockImplementation(() => {});
-  jest.spyOn(console, 'error').mockImplementation(() => {});
-
-  // Now that everything is mocked, load the 'export' command
-  const exportAction = require('../action');
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('uses path provided by user', async () => {
-    const filename = 'test';
-
-    await expectExit(0, async () => {
-      await exportAction({ file: filename });
-    });
-
-    expect(console.error).not.toHaveBeenCalled();
-    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
-      expect.objectContaining({
-        file: { path: filename },
-      })
-    );
-    expect(mockUtils.getDefaultExportName).not.toHaveBeenCalled();
-  });
-
-  it('uses default path if not provided by user', async () => {
-    await expectExit(0, async () => {
-      await exportAction({});
-    });
-
-    expect(mockUtils.getDefaultExportName).toHaveBeenCalledTimes(1);
-    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
-      expect.objectContaining({
-        file: { path: defaultFileName },
-      })
-    );
-  });
-
-  it('encrypts the output file if specified', async () => {
-    const encrypt = true;
-    await expectExit(0, async () => {
-      await exportAction({ encrypt });
-    });
-
-    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
-      expect.objectContaining({
-        encryption: { enabled: encrypt },
-      })
-    );
-  });
-
-  it('encrypts the output file with the given key', async () => {
-    const key = 'secret-key';
-    const encrypt = true;
-    await expectExit(0, async () => {
-      await exportAction({ encrypt, key });
-    });
-
-    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
-      expect.objectContaining({
-        encryption: { enabled: encrypt, key },
-      })
-    );
-  });
-
-  it('uses compress option', async () => {
-    await expectExit(0, async () => {
-      await exportAction({ compress: false });
-    });
-
-    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
-      expect.objectContaining({
-        compression: { enabled: false },
-      })
-    );
-    await expectExit(0, async () => {
-      await exportAction({ compress: true });
-    });
-    expect(mockDataTransfer.file.providers.createLocalFileDestinationProvider).toHaveBeenCalledWith(
-      expect.objectContaining({
-        compression: { enabled: true },
-      })
-    );
-  });
-});

package/lib/commands/actions/import/__tests__/import.test.js

@@ -1,143 +0,0 @@
-'use strict';
-
-const {
-  strapi: {
-    providers: { DEFAULT_CONFLICT_STRATEGY },
-  },
-  engine: { DEFAULT_SCHEMA_STRATEGY, DEFAULT_VERSION_STRATEGY },
-} = require('@strapi/data-transfer');
-
-const { expectExit } = require('../../../__tests__/commands.test.utils');
-
-const createTransferEngine = jest.fn(() => {
-  return {
-    transfer: jest.fn(() => {
-      return {
-        engine: {},
-      };
-    }),
-    progress: {
-      on: jest.fn(),
-      stream: {
-        on: jest.fn(),
-      },
-    },
-    sourceProvider: { name: 'testFileSource', type: 'source', getMetadata: jest.fn() },
-    destinationProvider: {
-      name: 'testStrapiDest',
-      type: 'destination',
-      getMetadata: jest.fn(),
-    },
-    diagnostics: {
-      on: jest.fn().mockReturnThis(),
-      onDiagnostic: jest.fn().mockReturnThis(),
-    },
-  };
-});
-
-describe('Import', () => {
-  const mockDataTransfer = {
-    file: {
-      providers: {
-        createLocalFileSourceProvider: jest
-          .fn()
-          .mockReturnValue({ name: 'testFileSource', type: 'source', getMetadata: jest.fn() }),
-      },
-    },
-    strapi: {
-      providers: {
-        DEFAULT_CONFLICT_STRATEGY,
-        createLocalStrapiDestinationProvider: jest
-          .fn()
-          .mockReturnValue({ name: 'testStrapiDest', type: 'destination', getMetadata: jest.fn() }),
-      },
-    },
-    engine: {
-      ...jest.requireActual('@strapi/data-transfer').engine,
-      DEFAULT_SCHEMA_STRATEGY,
-      DEFAULT_VERSION_STRATEGY,
-      createTransferEngine,
-    },
-  };
-
-  jest.mock('@strapi/data-transfer', () => mockDataTransfer);
-
-  // command utils
-  const mockUtils = {
-    getTransferTelemetryPayload: jest.fn().mockReturnValue({}),
-    loadersFactory: jest.fn().mockReturnValue({ updateLoader: jest.fn() }),
-    formatDiagnostic: jest.fn(),
-    createStrapiInstance: jest.fn().mockReturnValue({
-      telemetry: {
-        send: jest.fn(),
-      },
-      destroy: jest.fn(),
-    }),
-    buildTransferTable: jest.fn(() => {
-      return {
-        toString() {
-          return 'table';
-        },
-      };
-    }),
-    exitMessageText: jest.fn(),
-  };
-  jest.mock(
-    '../../../utils/data-transfer.js',
-    () => {
-      return mockUtils;
-    },
-    { virtual: true }
-  );
-
-  // console spies
-  jest.spyOn(console, 'log').mockImplementation(() => {});
-  jest.spyOn(console, 'warn').mockImplementation(() => {});
-  jest.spyOn(console, 'info').mockImplementation(() => {});
-  jest.spyOn(console, 'error').mockImplementation(() => {});
-
-  // Now that everything is mocked, load the 'import' command
-  const importAction = require('../action');
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('creates providers with correct options ', async () => {
-    const options = {
-      file: 'test.tar.gz.enc',
-      decrypt: true,
-      decompress: true,
-      exclude: [],
-      only: [],
-    };
-
-    await expectExit(0, async () => {
-      await importAction(options);
-    });
-
-    // strapi options
-    expect(
-      mockDataTransfer.strapi.providers.createLocalStrapiDestinationProvider
-    ).toHaveBeenCalledWith(expect.objectContaining({ strategy: DEFAULT_CONFLICT_STRATEGY }));
-
-    // file options
-    expect(mockDataTransfer.file.providers.createLocalFileSourceProvider).toHaveBeenCalledWith(
-      expect.objectContaining({
-        file: { path: 'test.tar.gz.enc' },
-        encryption: { enabled: options.decrypt },
-        compression: { enabled: options.decompress },
-      })
-    );
-
-    // engine options
-    expect(mockDataTransfer.engine.createTransferEngine).toHaveBeenCalledWith(
-      expect.objectContaining({ name: 'testFileSource' }),
-      expect.objectContaining({ name: 'testStrapiDest' }),
-      expect.objectContaining({
-        schemaStrategy: DEFAULT_SCHEMA_STRATEGY,
-        versionStrategy: DEFAULT_VERSION_STRATEGY,
-      })
-    );
-  });
-});

package/lib/commands/actions/templates/generate/__tests__/templates.generate.js

@@ -1,118 +0,0 @@
-'use strict';
-
-jest.mock('fs-extra', () => ({
-  ensureDir: jest.fn(() => Promise.resolve()),
-  copy: jest.fn(() => Promise.resolve()),
-  pathExists: jest.fn(() => Promise.resolve()),
-  writeJSON: jest.fn(() => Promise.resolve()),
-}));
-
-const { resolve, join } = require('path');
-const fse = require('fs-extra');
-const inquirer = require('inquirer');
-
-const exportTemplate = require('../action');
-
-describe('templates:generate command', () => {
-  beforeEach(() => {
-    jest.spyOn(console, 'log').mockImplementation(() => {});
-    jest.clearAllMocks();
-  });
-
-  it('creates a new template directory', async () => {
-    fse.pathExists.mockReturnValue(false);
-    const directory = '../test-dir';
-    const rootPath = resolve(directory);
-    const templatePath = join(rootPath, 'template');
-
-    await exportTemplate(directory);
-
-    expect(fse.pathExists).toHaveBeenCalledWith(templatePath);
-    expect(fse.ensureDir).toHaveBeenCalledWith(templatePath);
-  });
-
-  it.each(['src', 'data'])('copies folder %s', async (item) => {
-    // Mock the empty directory arg
-    fse.pathExists.mockReturnValueOnce(false);
-    // Mock the folder exists
-    fse.pathExists.mockReturnValue(true);
-    const directory = '../test-dir';
-    const rootPath = resolve(directory);
-    const templatePath = join(rootPath, 'template');
-
-    await exportTemplate(directory);
-
-    expect(fse.pathExists).toHaveBeenCalledWith(join(process.cwd(), item));
-    expect(fse.copy).toHaveBeenCalledWith(join(process.cwd(), item), join(templatePath, item));
-  });
-
-  it('creates a json config file', async () => {
-    fse.pathExists.mockReturnValue(false);
-    const directory = '../test-dir';
-    const rootPath = resolve(directory);
-
-    await exportTemplate(directory);
-
-    expect(fse.pathExists).toHaveBeenCalledWith(join(rootPath, 'template.json'));
-    expect(fse.writeJSON).toHaveBeenCalledWith(join(rootPath, 'template.json'), {});
-  });
-
-  describe('handles prompt input', () => {
-    it('replaces directory if confirmed', async () => {
-      fse.pathExists.mockReturnValue(true);
-      const mockInquiry = jest
-        .spyOn(inquirer, 'prompt')
-        .mockImplementationOnce(() => ({ confirm: true }));
-      const directory = '../test-dir';
-      const rootPath = resolve(directory);
-      const templatePath = join(rootPath, 'template');
-
-      await exportTemplate(directory);
-
-      expect(fse.pathExists).toHaveBeenCalledWith(templatePath);
-      expect(mockInquiry).toHaveBeenLastCalledWith(
-        expect.objectContaining({ message: expect.any(String), name: 'confirm', type: 'confirm' })
-      );
-      expect(fse.ensureDir).toHaveBeenCalled();
-      expect(fse.copy).toHaveBeenCalled();
-    });
-
-    it('does not replace existing config file', async () => {
-      fse.pathExists.mockReturnValue(true);
-      jest.spyOn(inquirer, 'prompt').mockImplementationOnce(() => ({ confirm: true }));
-      const directory = '../test-dir';
-      const rootPath = resolve(directory);
-
-      await exportTemplate(directory);
-      expect(fse.pathExists).toHaveBeenCalledWith(join(rootPath, 'template.json'));
-      expect(fse.writeJSON).not.toHaveBeenCalled();
-    });
-
-    it('exits if not confirmed', async () => {
-      fse.pathExists.mockReturnValue(true);
-      jest.spyOn(console, 'error').mockImplementation(() => {});
-      const mockInquiry = jest
-        .spyOn(inquirer, 'prompt')
-        .mockImplementationOnce(() => ({ confirm: false }));
-
-      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
-        throw new Error('exit');
-      });
-      const directory = '../test-dir';
-      const rootPath = resolve(directory);
-      const templatePath = join(rootPath, 'template');
-
-      await exportTemplate(directory).catch((err) => {
-        expect(err).toEqual(new Error('exit'));
-      });
-
-      expect(fse.pathExists).toHaveBeenCalledWith(templatePath);
-      expect(mockInquiry).toHaveBeenLastCalledWith(
-        expect.objectContaining({ message: expect.any(String), name: 'confirm', type: 'confirm' })
-      );
-      expect(mockExit).toHaveBeenCalledWith(0);
-      expect(fse.ensureDir).not.toHaveBeenCalled();
-      expect(fse.copy).not.toHaveBeenCalled();
-    });
-  });
-});

package/lib/commands/actions/transfer/__tests__/transfer.test.js

@@ -1,178 +0,0 @@
-'use strict';
-
-const { expectExit } = require('../../../__tests__/commands.test.utils');
-
-describe('Transfer', () => {
-  // command utils
-  const mockUtils = {
-    getTransferTelemetryPayload: jest.fn().mockReturnValue({}),
-    loadersFactory: jest.fn().mockReturnValue({ updateLoader: jest.fn() }),
-    formatDiagnostic: jest.fn(),
-    createStrapiInstance() {
-      return {
-        telemetry: {
-          send: jest.fn(),
-        },
-      };
-    },
-    getDefaultExportName: jest.fn(() => 'default'),
-    buildTransferTable: jest.fn(() => {
-      return {
-        toString() {
-          return 'table';
-        },
-      };
-    }),
-    exitMessageText: jest.fn(),
-  };
-  jest.mock(
-    '../../../utils/data-transfer.js',
-    () => {
-      return mockUtils;
-    },
-    { virtual: true }
-  );
-
-  const mockDataTransfer = {
-    strapi: {
-      providers: {
-        createLocalStrapiSourceProvider: jest.fn().mockReturnValue({ name: 'testLocalSource' }),
-        createLocalStrapiDestinationProvider: jest
-          .fn()
-          .mockReturnValue({ name: 'testLocalDestination' }),
-        createRemoteStrapiDestinationProvider: jest
-          .fn()
-          .mockReturnValue({ name: 'testRemoteDest' }),
-      },
-    },
-    engine: {
-      ...jest.requireActual('@strapi/data-transfer').engine,
-      createTransferEngine() {
-        return {
-          transfer: jest.fn(() => {
-            return {
-              engine: {},
-            };
-          }),
-          progress: {
-            on: jest.fn(),
-            stream: {
-              on: jest.fn(),
-            },
-          },
-          sourceProvider: { name: 'testSource' },
-          destinationProvider: { name: 'testDestination' },
-          diagnostics: {
-            on: jest.fn().mockReturnThis(),
-            onDiagnostic: jest.fn().mockReturnThis(),
-          },
-        };
-      },
-    },
-  };
-
-  jest.mock('@strapi/data-transfer', () => mockDataTransfer);
-
-  const transferAction = require('../action');
-
-  // console spies
-  jest.spyOn(console, 'log').mockImplementation(() => {});
-  jest.spyOn(console, 'warn').mockImplementation(() => {});
-  jest.spyOn(console, 'info').mockImplementation(() => {});
-  jest.spyOn(console, 'error').mockImplementation(() => {});
-
-  const destinationUrl = new URL('http://one.localhost/admin');
-  const destinationToken = 'test-token';
-
-  const sourceUrl = new URL('http://two.localhost/admin');
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('exits with error when no --to or --from is provided', async () => {
-    await expectExit(1, async () => {
-      await transferAction({ from: undefined, to: undefined });
-    });
-
-    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/one source/i));
-
-    expect(
-      mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
-    ).not.toHaveBeenCalled();
-  });
-
-  it('exits with error when both --to and --from are provided', async () => {
-    await expectExit(1, async () => {
-      await transferAction({ from: sourceUrl, to: destinationUrl });
-    });
-
-    expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/one source/i));
-
-    expect(
-      mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
-    ).not.toHaveBeenCalled();
-  });
-
-  describe('--to', () => {
-    it('exits with error when auth is not provided', async () => {
-      await expectExit(1, async () => {
-        await transferAction({ from: undefined, to: destinationUrl });
-      });
-
-      expect(console.error).toHaveBeenCalledWith(expect.stringMatching(/missing token/i));
-
-      expect(
-        mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
-      ).not.toHaveBeenCalled();
-    });
-
-    it('uses destination url and token provided by user', async () => {
-      await expectExit(0, async () => {
-        await transferAction({ from: undefined, to: destinationUrl, toToken: destinationToken });
-      });
-
-      expect(console.error).not.toHaveBeenCalled();
-      expect(
-        mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
-      ).toHaveBeenCalledWith(
-        expect.objectContaining({
-          url: destinationUrl,
-          auth: {
-            type: 'token',
-            token: destinationToken,
-          },
-        })
-      );
-    });
-
-    it('uses local Strapi source when from is not specified', async () => {
-      await expectExit(0, async () => {
-        await transferAction({ from: undefined, to: destinationUrl, toToken: destinationToken });
-      });
-
-      expect(console.error).not.toHaveBeenCalled();
-      expect(mockDataTransfer.strapi.providers.createLocalStrapiSourceProvider).toHaveBeenCalled();
-      expect(
-        mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
-      ).toHaveBeenCalled();
-    });
-  });
-
-  it.todo('uses local Strapi destination when to is not specified');
-
-  it('uses restore as the default strategy', async () => {
-    await expectExit(0, async () => {
-      await transferAction({ from: undefined, to: destinationUrl, toToken: destinationToken });
-    });
-
-    expect(console.error).not.toHaveBeenCalled();
-    expect(
-      mockDataTransfer.strapi.providers.createRemoteStrapiDestinationProvider
-    ).toHaveBeenCalledWith(
-      expect.objectContaining({
-        strategy: 'restore',
-      })
-    );
-  });
-});