@contentstack/cli-variants 0.0.1-alpha

package/src/utils/variant-api-adapter.ts

@@ -0,0 +1,326 @@
+import omit from 'lodash/omit';
+import { existsSync } from 'fs';
+import {
+  HttpClient,
+  HttpResponse,
+  HttpClientOptions,
+  ContentstackClient,
+  ContentstackConfig,
+  managementSDKClient,
+} from '@contentstack/cli-utilities';
+
+import {
+  APIConfig,
+  AdapterType,
+  AnyProperty,
+  ExportConfig,
+  ImportConfig,
+  VariantOptions,
+  VariantsOption,
+  VariantInterface,
+  VariantEntryStruct,
+  CreateVariantEntryDto,
+  CreateVariantEntryOptions,
+  APIResponse,
+  PublishVariantEntryDto,
+  PublishVariantEntryOptions,
+} from '../types';
+import messages from '../messages';
+import { AdapterHelper } from './adapter-helper';
+import { formatErrors } from './error-helper';
+
+export class VariantHttpClient<C> extends AdapterHelper<C, HttpClient> implements VariantInterface<C, HttpClient> {
+  public baseURL: string;
+  constructor(config: APIConfig, options?: HttpClientOptions) {
+    super(config, options);
+    this.baseURL = config.baseURL?.includes('http') ? `${config.baseURL}/v3` : `https://${config.baseURL}/v3`;
+    this.apiClient.baseUrl(this.baseURL);
+  }
+
+  async variantEntry(options: VariantOptions) {
+    // TODO single entry variant
+    return { entry: {} };
+  }
+
+  /**
+   * The function `variantEntries` retrieves variant entries based on specified options and stores them
+   * in an array.
+   * @param {VariantsOption} options - The `options` parameter in the `variantEntries` function is an
+   * object that contains the following properties:
+   * @param {Record<string, any>[]} entries - The `entries` parameter in the `variantEntries` function
+   * is an array of objects where each object represents a record with key-value pairs. This parameter
+   * is used to store the entries retrieved from the API response or passed down recursively when
+   * fetching all data.
+   * @returns The function `variantEntries` returns a Promise that resolves to an object with an
+   * `entries` property containing an array of record objects or an unknown array. The function can
+   * also return void if certain conditions are not met.
+   */
+  async variantEntries(
+    options: VariantsOption,
+    entries: Record<string, any>[] = [],
+  ): Promise<{ entries?: Record<string, any>[] | unknown[] } | void> {
+    const variantConfig = (this.config as ExportConfig).modules.variantEntry;
+    const {
+      callback,
+      entry_uid,
+      getAllData,
+      returnResult,
+      content_type_uid,
+      locale,
+      skip = variantConfig.query.skip || 0,
+      limit = variantConfig.query.limit || 100,
+      include_variant = variantConfig.query.include_variant || true,
+      include_count = variantConfig.query.include_count || true,
+      include_publish_details = variantConfig.query.include_publish_details || true,
+    } = options;
+
+    if (variantConfig.serveMockData && callback) {
+      let data = [] as Record<string, any>[];
+
+      if (existsSync(variantConfig.mockDataPath)) {
+        data = require(variantConfig.mockDataPath) as Record<string, any>[];
+      }
+      callback(data);
+      return;
+    }
+    if (!locale) return;
+
+    const start = Date.now();
+    let endpoint = `/content_types/${content_type_uid}/entries/${entry_uid}/variants?locale=${locale}`;
+
+    if (skip) {
+      endpoint = endpoint.concat(`&skip=${skip}`);
+    }
+
+    if (limit) {
+      endpoint = endpoint.concat(`&limit=${limit}`);
+    }
+
+    if (include_variant) {
+      endpoint = endpoint.concat(`&include_variant=${include_variant}`);
+    }
+
+    if (include_count) {
+      endpoint = endpoint.concat(`&include_count=${include_count}`);
+    }
+
+    if (include_publish_details) {
+      endpoint = endpoint.concat(`&include_publish_details=${include_publish_details}`);
+    }
+
+    const query = this.constructQuery(
+      omit(variantConfig.query, [
+        'skip',
+        'limit',
+        'locale',
+        'include_variant',
+        'include_count',
+        'include_publish_details',
+      ]),
+    );
+
+    if (query) {
+      endpoint = endpoint.concat(query);
+    }
+
+    const data = await this.apiClient.get(endpoint);
+    const response = this.handleVariantAPIRes(data) as { entries: VariantEntryStruct[]; count: number };
+
+    if (callback) {
+      callback(response.entries);
+    } else {
+      entries = entries.concat(response.entries);
+    }
+
+    if (getAllData && skip + limit < response.count) {
+      const end = Date.now();
+      const exeTime = end - start;
+
+      if (exeTime < 1000) {
+        // 1 API call per second
+        await this.delay(1000 - exeTime);
+      }
+      if (!options.skip) {
+        options['skip'] = 0;
+      }
+
+      options.skip += limit;
+      return await this.variantEntries(options, entries);
+    }
+
+    if (returnResult) return { entries };
+  }
+
+  /**
+   * Creates a variant entry.
+   *
+   * @param input - The input data for the variant entry.
+   * @param options - The options for creating the variant entry.
+   * @param apiParams - Additional parameters for the API.
+   * @returns A Promise that resolves to a VariantEntryStruct, a string, or void.
+   */
+  async createVariantEntry(
+    input: CreateVariantEntryDto,
+    options: CreateVariantEntryOptions,
+    apiParams: Record<string, any>,
+  ): Promise<VariantEntryStruct | string | void> {
+    const { reject, resolve, variantUid, log } = apiParams;
+    const variantConfig = (this.config as ImportConfig).modules.variantEntry;
+    const { locale = variantConfig.query.locale || 'en-us', variant_id, entry_uid, content_type_uid } = options;
+    let endpoint = `content_types/${content_type_uid}/entries/${entry_uid}/variants/${variant_id}?locale=${locale}`;
+
+    const query = this.constructQuery(omit(variantConfig.query, ['locale']));
+
+    if (query) {
+      endpoint = endpoint.concat(query);
+    }
+
+    const onSuccess = (response: any) => resolve({ response, apiData: { variantUid, entryUid: entry_uid }, log });
+    const onReject = (error: any) =>
+      reject({
+        error,
+        apiData: { variantUid, entryUid: entry_uid },
+        log,
+      });
+
+    try {
+      const res = await this.apiClient.put<VariantEntryStruct>(endpoint, { entry: input });
+      const data = this.handleVariantAPIRes(res);
+
+      if (res.status >= 200 && res.status < 300) {
+        onSuccess(data);
+      } else {
+        onReject(data);
+      }
+    } catch (error: any) {
+      onReject(error);
+    }
+  }
+
+  /**
+   * Publishes a variant entry.
+   *
+   * @param input - The input data for publishing the variant entry.
+   * @param options - The options for publishing the variant entry.
+   * @param apiParams - Additional API parameters.
+   * @returns A Promise that resolves to the published variant entry response.
+   */
+  async publishVariantEntry(
+    input: PublishVariantEntryDto,
+    options: PublishVariantEntryOptions,
+    apiParams: Record<string, any>,
+  ) {
+    const { reject, resolve, log, variantUid } = apiParams;
+    const { entry_uid, content_type_uid } = options;
+    let endpoint = `content_types/${content_type_uid}/entries/${entry_uid}/publish`;
+
+    const onSuccess = (response: any) =>
+      resolve({ response, apiData: { entryUid: entry_uid, variantUid }, log });
+    const onReject = (error: any) =>
+      reject({
+        error,
+        apiData: { entryUid: entry_uid, variantUid },
+        log,
+      });
+
+    try {
+      this.apiClient.headers({ api_version: 3.2 });
+      const res = await this.apiClient.post<any>(endpoint, input);
+      const data = this.handleVariantAPIRes(res);
+
+      if (res.status >= 200 && res.status < 300) {
+        onSuccess(data);
+      } else {
+        onReject(data);
+      }
+    } catch (error: any) {
+      onReject(error);
+    }
+  }
+
+  /**
+   * Handles the API response for variant requests.
+   * @param res - The API response object.
+   * @returns The variant API response data.
+   * @throws If the API response status is not within the success range, an error message is thrown.
+   */
+  handleVariantAPIRes(
+    res: APIResponse,
+  ): VariantEntryStruct | { entries: VariantEntryStruct[]; count: number } | string | any {
+    const { status, data } = res;
+
+    if (status >= 200 && status < 300) {
+      return data;
+    }
+
+    const errorMsg = data?.errors
+      ? formatErrors(data.errors)
+      : data?.error_message || data?.message || 'Something went wrong while processing entry variant request!';
+
+    throw errorMsg;
+  }
+}
+
+export class VariantManagementSDK<T>
+  extends AdapterHelper<T, ContentstackClient>
+  implements VariantInterface<T, ContentstackClient>
+{
+  public override apiClient!: ContentstackClient;
+
+  async init(): Promise<void> {
+    this.apiClient = await managementSDKClient(this.config);
+  }
+
+  async variantEntry(options: VariantOptions) {
+    // TODO SDK implementation
+    return { entry: {} };
+  }
+
+  async variantEntries(options: VariantsOption) {
+    // TODO SDK implementation
+    return { entries: [{}] };
+  }
+
+  createVariantEntry(
+    input: CreateVariantEntryDto,
+    options: CreateVariantEntryOptions,
+    apiParams: Record<string, any>,
+  ): Promise<VariantEntryStruct | string | void> {
+    // FIXME placeholder
+    return Promise.resolve({} as VariantEntryStruct);
+  }
+
+  handleVariantAPIRes(
+    res: APIResponse,
+  ): VariantEntryStruct | { entries: VariantEntryStruct[]; count: number } | string {
+    return res.data;
+  }
+
+  constructQuery(query: Record<string, any>): string | void {}
+
+  async delay(ms: number): Promise<void> {}
+}
+
+export class VariantAdapter<T> {
+  protected variantInstance;
+  public readonly messages: typeof messages;
+
+  constructor(config: ContentstackConfig & AnyProperty & AdapterType<T, ContentstackConfig>);
+  constructor(config: APIConfig & AdapterType<T, APIConfig & AnyProperty>, options?: HttpClientOptions);
+  constructor(
+    config: APIConfig & AdapterType<T, (APIConfig & AnyProperty) | ContentstackConfig>,
+    options?: HttpClientOptions,
+  ) {
+    if (config.httpClient) {
+      const { httpClient, Adapter, ...restConfig } = config;
+      this.variantInstance = new Adapter(restConfig, options);
+    } else {
+      const { Adapter, ...restConfig } = config;
+      this.variantInstance = new Adapter(restConfig);
+    }
+
+    this.messages = messages;
+  }
+}
+
+export default VariantAdapter;

package/test/unit/export/variant-entries.test.ts

@@ -0,0 +1,80 @@
+import { expect } from '@oclif/test';
+import { FsUtility } from '@contentstack/cli-utilities';
+import { fancy } from '@contentstack/cli-dev-dependencies';
+
+import exportConf from '../mock/export-config.json';
+import { Export, ExportConfig, VariantHttpClient, VariantsOption } from '../../../src';
+
+describe('Variant Entries Export', () => {
+  let config: ExportConfig;
+
+  const exportEntryData = {
+    locale: 'en-us',
+    contentTypeUid: 'CT-ID',
+    entries: [{ uid: 'E-UID-1', title: 'Entry 1' }],
+  };
+
+  const test = fancy
+    .stdout({ print: process.env.PRINT === 'true' || false })
+    .stub(FsUtility.prototype, 'completeFile', () => {})
+    .stub(FsUtility.prototype, 'writeIntoFile', () => {})
+    .stub(FsUtility.prototype, 'createFolderIfNotExist', () => {});
+
+  beforeEach(() => {
+    config = exportConf as unknown as ExportConfig;
+  });
+
+  describe('exportVariantEntry method', () => {
+    test
+      .stub(VariantHttpClient.prototype, 'variantEntries', async () => {})
+      .spy(VariantHttpClient.prototype, 'variantEntries')
+      .spy(FsUtility.prototype, 'completeFile')
+      .spy(FsUtility.prototype, 'createFolderIfNotExist')
+      .it('should call export variant entry method (API call)', async ({ spy }) => {
+        let entryVariantInstace = new Export.VariantEntries(config);
+        await entryVariantInstace.exportVariantEntry(exportEntryData);
+
+        expect(spy.variantEntries.callCount).to.be.equals(1);
+        expect(spy.completeFile.callCount).to.be.equals(1);
+        expect(spy.createFolderIfNotExist.callCount).to.be.equals(1);
+        expect(spy.completeFile.alwaysCalledWith(true)).to.be.true;
+      });
+
+    test
+      .stub(VariantHttpClient.prototype, 'variantEntries', async (...args: any) => {
+        const { callback } = args[0] as VariantsOption;
+        if (callback) {
+          callback([{ uid: 'E-UID-1', title: 'Entry 1' }]);
+        }
+      })
+      .spy(FsUtility.prototype, 'writeIntoFile')
+      .it('should write data in files (As chunk)', async ({ spy }) => {
+        let entryVariantInstace = new Export.VariantEntries(config);
+        await entryVariantInstace.exportVariantEntry(exportEntryData);
+
+        expect(spy.writeIntoFile.callCount).to.be.equals(1);
+        expect(spy.writeIntoFile.alwaysCalledWith([{ uid: 'E-UID-1', title: 'Entry 1' }])).to.be.true;
+      });
+
+    test
+      .stub(VariantHttpClient.prototype, 'variantEntries', async (...args: any) => {
+        const { callback } = args[0] as VariantsOption;
+        if (callback) {
+          callback([]); // NOTE API callback with empty response
+        }
+      })
+      .spy(FsUtility.prototype, 'writeIntoFile')
+      .spy(VariantHttpClient.prototype, 'variantEntries')
+      .it(
+        'should skip write data in files (Empty data check validation), should set default file chunk 1MB if chunk size is not passed in config',
+        async ({ spy }) => {
+          config.modules.variantEntry.chunkFileSize = null as any;
+          let entryVariantInstace = new Export.VariantEntries(config, () => {});
+          await entryVariantInstace.exportVariantEntry(exportEntryData);
+
+          expect(spy.writeIntoFile.callCount).to.be.equals(0);
+          expect(spy.variantEntries.callCount).to.be.equals(1);
+        },
+      );
+  });
+});

package/test/unit/import/variant-entries.test.ts

@@ -0,0 +1,200 @@
+import { join } from 'path';
+import { expect } from '@oclif/test';
+import cloneDeep from 'lodash/cloneDeep';
+import { fancy } from '@contentstack/cli-dev-dependencies';
+
+import importConf from '../mock/import-config.json';
+import ContentType from '../mock/contents/content_types/CT-1.json';
+import { Import, ImportConfig, VariantHttpClient } from '../../../src';
+import variantEntryData from '../mock/contents/mapper/entries/data-for-variant-entry.json';
+import variantEntries from '../mock/contents/entries/CT-1/en-us/variants/E-1/9b0da6xd7et72y-6gv7he23.json';
+
+describe('Variant Entries Import', () => {
+  let config: ImportConfig;
+
+  const test = fancy.stdout({ print: process.env.PRINT === 'true' || false });
+
+  beforeEach(() => {
+    config = cloneDeep(importConf) as unknown as ImportConfig;
+  });
+
+  describe('import method', () => {
+    test
+      .stub(Import.VariantEntries.prototype, 'importVariantEntries', async () => {})
+      .spy(Import.VariantEntries.prototype, 'importVariantEntries')
+      .it('should call import variant entry method (API call)', async ({ spy }) => {
+        let entryVariantInstace = new Import.VariantEntries(config);
+        await entryVariantInstace.import();
+
+        expect(spy.importVariantEntries.called).to.be.true;
+        expect(spy.importVariantEntries.calledWith(variantEntryData[0])).to.be.true;
+      });
+
+    test
+      .stub(Import.VariantEntries.prototype, 'importVariantEntries', async () => {})
+      .spy(Import.VariantEntries.prototype, 'importVariantEntries')
+      .it('should return with entry not found message', async (ctx) => {
+        config.backupDir = './';
+        let entryVariantInstace = new Import.VariantEntries(config);
+        await entryVariantInstace.import();
+
+        expect(ctx.stdout).to.be.includes(entryVariantInstace.messages.IMPORT_ENTRY_NOT_FOUND);
+      });
+
+    test
+      .stub(Import.VariantEntries.prototype, 'importVariantEntries', async () => {})
+      .spy(Import.VariantEntries.prototype, 'importVariantEntries')
+      .it('should return with variant UID mapper file not found message', async (ctx) => {
+        config.modules.personalization.dirName = 'wrong-dir';
+        let entryVariantInstace = new Import.VariantEntries(config);
+        await entryVariantInstace.import();
+
+        expect(ctx.stdout).to.be.includes(entryVariantInstace.messages.EMPTY_VARIANT_UID_DATA);
+      });
+
+    test
+      .stub(Import.VariantEntries.prototype, 'importVariantEntries', async () => {})
+      .spy(Import.VariantEntries.prototype, 'importVariantEntries')
+      .it('should return with entry not found message if empty content found on file', async (ctx) => {
+        let entryVariantInstace = new Import.VariantEntries(config);
+        entryVariantInstace.entriesMapperPath = join(entryVariantInstace.entriesMapperPath, 'empty-data');
+        await entryVariantInstace.import();
+
+        expect(ctx.stdout).to.be.includes(entryVariantInstace.messages.IMPORT_ENTRY_NOT_FOUND);
+      });
+
+    test
+      .stub(Import.VariantEntries.prototype, 'importVariantEntries', async () => {})
+      .spy(Import.VariantEntries.prototype, 'importVariantEntries')
+      .it('should check taxonomies folder existence', async (ctx) => {
+        config.modules.taxonomies.dirName = 'wrong-dir';
+        let entryVariantInstace = new Import.VariantEntries(config);
+        await entryVariantInstace.import();
+
+        expect(entryVariantInstace.taxonomies).to.contain({});
+      });
+  });
+
+  describe('importVariantEntries method', () => {
+    test
+      .stub(Import.VariantEntries.prototype, 'handleCuncurrency', async () => {})
+      .spy(Import.VariantEntries.prototype, 'handleCuncurrency')
+      .it('should call handle Cuncurrency method to manage import batch', async ({ spy }) => {
+        let entryVariantInstace = new Import.VariantEntries(config);
+        await entryVariantInstace.importVariantEntries(variantEntryData[0]);
+
+        expect(spy.handleCuncurrency.called).to.be.true;
+        expect(spy.handleCuncurrency.calledWith(ContentType, variantEntries, variantEntryData[0])).to.be.true;
+      });
+
+    test
+      .stub(Import.VariantEntries.prototype, 'handleCuncurrency', async () => {
+        throw new Error('Dummy error');
+      })
+      .spy(Import.VariantEntries.prototype, 'handleCuncurrency')
+      .it('should catch and log errors on catch block', async (ctx) => {
+        let entryVariantInstace = new Import.VariantEntries(config);
+        await entryVariantInstace.importVariantEntries(variantEntryData[0]);
+
+        expect(ctx.stdout).to.be.includes('Dummy error');
+      });
+  });
+
+  describe('handleCuncurrency method', () => {
+    test
+      .stub(VariantHttpClient.prototype, 'createVariantEntry', async () => {})
+      .stub(Import.VariantEntries.prototype, 'handleVariantEntryRelationalData', () => variantEntries[0])
+      .spy(VariantHttpClient.prototype, 'createVariantEntry')
+      .spy(Import.VariantEntries.prototype, 'handleVariantEntryRelationalData')
+      .it('should call handle Cuncurrency method to manage import batch', async ({ spy }) => {
+        const variantEntry = variantEntries[0];
+        const { content_type, entry_uid, locale } = variantEntryData[0];
+        let entryVariantInstace = new Import.VariantEntries(config);
+        entryVariantInstace.variantIdList = { 'VARIANT-ID-1': 'VARIANT-ID-2' };
+        await entryVariantInstace.handleCuncurrency(ContentType, variantEntries, variantEntryData[0]);
+
+        expect(spy.createVariantEntry.called).to.be.true;
+        expect(spy.handleVariantEntryRelationalData.called).to.be.true;
+        expect(spy.handleVariantEntryRelationalData.calledWith(ContentType, variantEntry)).to.be.true;
+        expect(
+          spy.createVariantEntry.calledWith(variantEntry, {
+            locale,
+            entry_uid,
+            variant_id: 'VARIANT-ID-2',
+            content_type_uid: content_type,
+          }),
+        ).to.be.true;
+      });
+
+    test
+      .stub(VariantHttpClient.prototype, 'createVariantEntry', async () => {})
+      .stub(Import.VariantEntries.prototype, 'handleVariantEntryRelationalData', () => variantEntries[0])
+      .spy(VariantHttpClient.prototype, 'createVariantEntry')
+      .spy(Import.VariantEntries.prototype, 'handleVariantEntryRelationalData')
+      .it('should return without any execution if empty batch found', async (ctx) => {
+        let entryVariantInstace = new Import.VariantEntries(config);
+        const result = await entryVariantInstace.handleCuncurrency(ContentType, [], variantEntryData[0]);
+
+        expect(result).to.be.undefined;
+      });
+
+    test
+      .stub(VariantHttpClient.prototype, 'createVariantEntry', async () => {})
+      .stub(Import.VariantEntries.prototype, 'handleVariantEntryRelationalData', () => variantEntries[0])
+      .spy(VariantHttpClient.prototype, 'createVariantEntry')
+      .spy(Import.VariantEntries.prototype, 'handleVariantEntryRelationalData')
+      .it('should log error message if variant UID not found on the mapper file', async (ctx) => {
+        let entryVariantInstace = new Import.VariantEntries(config);
+        entryVariantInstace.config.modules.variantEntry.apiConcurrency = null as any; // NOTE Missing apiConcurrency value in config
+        entryVariantInstace.variantIdList = { 'VARIANT-ID-2': 'VARIANT-ID-NEW-2' };
+        await entryVariantInstace.handleCuncurrency(ContentType, variantEntries, variantEntryData[0]);
+
+        expect(ctx.stdout).to.be.includes(entryVariantInstace.messages.VARIANT_ID_NOT_FOUND);
+      });
+  });
+
+  describe('handleVariantEntryRelationalData method', () => {
+    test.it('should call handle Cuncurrency method to manage import batch', async () => {
+      // NOTE passing helper methods along with config
+      let conf = Object.assign(config, {
+        helpers: {
+          lookUpTerms: () => {},
+          lookupExtension: () => {},
+          lookupAssets: (entry: any) => entry,
+          lookupEntries: (entry: any) => entry,
+          restoreJsonRteEntryRefs: (entry: any) => entry,
+        },
+      });
+      const variantEntry = variantEntries[0];
+      let entryVariantInstace = new Import.VariantEntries(conf);
+      const entry = await entryVariantInstace.handleVariantEntryRelationalData(ContentType, variantEntry);
+
+      expect(entry).to.contain(variantEntry);
+    });
+
+    test.it('should skip calling lookupExtension if not available in helper', async () => {
+      // NOTE passing helper methods along with config
+      let conf = Object.assign(config, {
+        helpers: {
+          lookUpTerms: () => {},
+          lookupAssets: (entry: any) => entry,
+          lookupEntries: (entry: any) => entry,
+          restoreJsonRteEntryRefs: (entry: any) => entry,
+        },
+      });
+      const variantEntry = variantEntries[0];
+      let entryVariantInstace = new Import.VariantEntries(conf);
+      const entry = await entryVariantInstace.handleVariantEntryRelationalData(ContentType, variantEntry);
+
+      expect(entry).to.contain(variantEntry);
+    });
+
+    test.it('will skip calling lookup function if helper is not present in config', async () => {
+      const variantEntry = variantEntries[0];
+      let entryVariantInstace = new Import.VariantEntries(config);
+      const entry = await entryVariantInstace.handleVariantEntryRelationalData(ContentType, variantEntry);
+
+      expect(entry).to.contain(variantEntry);
+    });
+  });
+});

package/test/unit/mock/contents/content_types/CT-1.json

@@ -0,0 +1,7 @@
+{
+  "uid": "CT-1",
+  "title": "CT-1",
+  "description": "test CT",
+  "schema": [],
+  "options": {}
+}

package/test/unit/mock/contents/entries/CT-1/en-us/variants/E-1/9b0da6xd7et72y-6gv7he23.json

@@ -0,0 +1,12 @@
+[{
+  "uid": "E-1",
+  "locale": "en-us",
+  "title": "Variant 1",
+  "variant_id": "VARIANT-ID-1",
+  "_version": 1,
+  "_variant": {
+    "uid": "UID-1",
+    "_change_set": [],
+    "_base_entry_version": 1
+  }
+}]

package/test/unit/mock/contents/entries/CT-1/en-us/variants/E-1/index.json

@@ -0,0 +1,3 @@
+{
+  "1": "9b0da6xd7et72y-6gv7he23.json"
+}

package/test/unit/mock/contents/entries/CT-1/en-us/variants/E-2/9b0da6xd7et72y-6gv7he23.json

@@ -0,0 +1,12 @@
+[{
+  "uid": "E-1",
+  "locale": "en-us",
+  "title": "Variant 1",
+  "variant_id": "VARIANT-ID-1",
+  "_version": 1,
+  "_variant": {
+    "uid": "UID-1",
+    "_change_set": [],
+    "_base_entry_version": 1
+  }
+}]

package/test/unit/mock/contents/entries/CT-1/en-us/variants/E-2/index.json

@@ -0,0 +1,3 @@
+{
+  "1": "9b0da6xd7et72y-6gv7he23.json"
+}

package/test/unit/mock/contents/mapper/assets/uid-mapping.json

@@ -0,0 +1,6 @@
+{
+  "O-A-UID-1": "N-A-UID-1",
+  "O-A-UID-2": "N-A-UID-2",
+  "O-A-UID-3": "N-A-UID-3",
+  "O-A-UID-4": "N-A-UID-4"
+}

package/test/unit/mock/contents/mapper/assets/url-mapping.json

@@ -0,0 +1,6 @@
+{
+  "o-ass-url-1.com": "n-ass-url-1.com",
+  "o-ass-url-2.com": "n-ass-url-2.com",
+  "o-ass-url-3.com": "n-ass-url-3.com",
+  "o-ass-url-4.com": "n-ass-url-4.com"
+}

package/test/unit/mock/contents/mapper/entries/data-for-variant-entry.json

@@ -0,0 +1,6 @@
+[
+  { "content_type": "CT-1", "locale": "en-us", "entry_uid": "E-1" },
+  { "content_type": "CT-2", "locale": "en-us", "entry_uid": "E-2" },
+  { "content_type": "CT-3", "locale": "en-us", "entry_uid": "E-3" },
+  { "content_type": "CT-4", "locale": "en-us", "entry_uid": "E-4" }
+]

package/test/unit/mock/contents/mapper/entries/empty-data/data-for-variant-entry.json

@@ -0,0 +1 @@
+[]

package/test/unit/mock/contents/mapper/entries/uid-mapping.json

@@ -0,0 +1,6 @@
+{
+  "E-UID-1": "E-UID-1",
+  "E-UID-2": "E-UID-2",
+  "E-UID-3": "E-UID-3",
+  "E-UID-4": "E-UID-4"
+}