@strapi/strapi 4.10.0 → 4.10.1-experimental.0

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

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

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

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

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