@squiz/component-cli-lib 1.54.1-alpha.2 → 1.54.1-alpha.4

package/lib/integration-tests/upload-and-render-page.integration.mocks.d.ts

@@ -0,0 +1,17 @@
+import { ComponentSetWebModelForCreate } from '@squiz/component-lib';
+import { ContentApi } from '@squiz/component-web-api-lib';
+export declare const COMPONENT_SET_WEB_PATH: string;
+export declare const COMPONENT_NAME = "test-page-render";
+export declare const COMPONENT_NAMESPACE = "unit-test-components";
+export declare const COMPONENT_CONTENT_ID: string;
+export declare const COMPONENT_NODE_ID: string;
+export declare const componentSet: ComponentSetWebModelForCreate;
+export declare const componentContentItem: {
+    id: string;
+    schemaName: string;
+    content: {
+        text: string;
+    };
+};
+export declare const pageContents: ContentApi.PageContentsCreate;
+export declare const pageContentsWithVariants: ContentApi.PageContentsCreate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/component-cli-lib",
-  "version": "1.54.1-alpha.2",
+  "version": "1.54.1-alpha.4",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
@@ -13,12 +13,12 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@squiz/component-lib": "1.54.1-alpha.2",
-    "@squiz/component-web-api-lib": "1.54.1-alpha.2",
-    "@squiz/dx-common-lib": "1.54.1-alpha.2",
-    "@squiz/dx-json-schema-lib": "1.54.1-alpha.2",
-    "@squiz/dx-logger-lib": "1.54.1-alpha.2",
-    "@squiz/virus-scanner-lib": "1.54.1-alpha.2",
+    "@squiz/component-lib": "1.54.1-alpha.4",
+    "@squiz/component-web-api-lib": "1.54.1-alpha.4",
+    "@squiz/dx-common-lib": "1.54.1-alpha.4",
+    "@squiz/dx-json-schema-lib": "1.54.1-alpha.4",
+    "@squiz/dx-logger-lib": "1.54.1-alpha.4",
+    "@squiz/virus-scanner-lib": "1.54.1-alpha.4",
     "@types/cli-color": "2.0.2",
     "@types/express": "4.17.17",
     "@types/jest": "28.1.8",
@@ -32,12 +32,12 @@
     "typescript": "4.9.4"
   },
   "dependencies": {
-    "@squiz/render-runtime-lib": "1.54.1-alpha.2",
+    "@squiz/render-runtime-lib": "1.54.1-alpha.4",
     "archiver": "5.3.1",
     "axios": "1.3.2",
     "cli-color": "^2.0.2",
     "open": "^8.4.0",
     "supertest": "^6.2.3"
   },
-  "gitHead": "d3535c8a51723dac528e17f579234885f77a8d25"
+  "gitHead": "6b462491372ff22c83f7d52c9410b531f4030a55"
 }

package/src/integration-tests/helper.ts

@@ -97,10 +97,6 @@ export const managementServiceRoot = axios.create({
 
 export const renderService = axios.create({
   baseURL: configObj.renderServiceUrl,
-  headers: {
-    Authorization: authToken,
-    'x-api-key': 'inter-service-api-key',
-  },
 });
 
 export const contentService = axios.create({
@@ -112,9 +108,6 @@ export const contentService = axios.create({
 
 export const pageRenderService = axios.create({
   baseURL: configObj.pageRenderServiceUrl,
-  headers: {
-    Authorization: authToken,
-  },
 });
 
 export const jobService = axios.create({

package/src/integration-tests/upload-and-render-page.integration.mocks.ts

@@ -0,0 +1,150 @@
+import { randomInt } from 'crypto';
+import { ComponentSetWebModelForCreate } from '@squiz/component-lib';
+import { ContentApi } from '@squiz/component-web-api-lib';
+
+export const COMPONENT_SET_WEB_PATH = 'local-development-only' + randomInt(10000);
+export const COMPONENT_NAME = 'test-page-render';
+export const COMPONENT_NAMESPACE = 'unit-test-components';
+export const COMPONENT_CONTENT_ID = 'component-content-id' + randomInt(10000);
+export const COMPONENT_NODE_ID = `${COMPONENT_NAMESPACE}/${COMPONENT_NAME}/1.0.0/main`;
+
+//The componentSet for the component in the content item
+export const componentSet: ComponentSetWebModelForCreate = {
+  webPath: COMPONENT_SET_WEB_PATH,
+  displayName: 'test-set',
+  description: 'test-set',
+  headers: {},
+  components: {},
+  componentVersionRules: {
+    [`${COMPONENT_NAMESPACE}/${COMPONENT_NAME}`]: {
+      renderableVersionPattern: '1.0.0',
+      editableVersions: [],
+      excludedVersions: [],
+    },
+  },
+};
+
+// The content item for the component
+export const componentContentItem = {
+  id: COMPONENT_CONTENT_ID,
+  schemaName: COMPONENT_NODE_ID,
+  content: {
+    text: 'component-input-string',
+  },
+};
+
+// The page content item which references the content item
+export const pageContents: ContentApi.PageContentsCreate = {
+  name: 'page-contents-test-1',
+  layouts: [
+    {
+      name: 'single-column',
+      content: {
+        main: [
+          {
+            type: 'tag',
+            tag: 'h1',
+            children: [
+              {
+                type: 'text',
+                value: 'Hello World!',
+              },
+            ],
+          },
+          {
+            type: 'component',
+            componentSet: COMPONENT_SET_WEB_PATH,
+            componentId: COMPONENT_NODE_ID,
+            contentItem: { id: COMPONENT_CONTENT_ID },
+          },
+          {
+            type: 'tag',
+            tag: 'p',
+            children: [
+              {
+                type: 'text',
+                value: 'Bottom text',
+              },
+            ],
+          },
+        ],
+      },
+    },
+  ],
+};
+
+export const pageContentsWithVariants: ContentApi.PageContentsCreate = {
+  name: 'page-contents-test-2',
+  layouts: [
+    {
+      name: 'single-column',
+      content: {
+        main: [
+          {
+            type: 'variation',
+            default: {
+              node: {
+                type: 'tag',
+                tag: 'h1',
+                children: [
+                  {
+                    type: 'text',
+                    value: 'Hello World!',
+                  },
+                ],
+              },
+            },
+            variants: [
+              {
+                node: {
+                  type: 'tag',
+                  tag: 'h1',
+                  children: [
+                    {
+                      type: 'text',
+                      value: 'Hello Authenticated User with experiment B!',
+                    },
+                  ],
+                },
+                conditions: {
+                  segment: { code: 'is-authenticated' },
+                  experiment: { id: 'experiment1', variantId: 'B' },
+                },
+              },
+              {
+                node: {
+                  type: 'tag',
+                  tag: 'h1',
+                  children: [
+                    {
+                      type: 'text',
+                      value: 'Hello Authenticated User!',
+                    },
+                  ],
+                },
+                conditions: {
+                  segment: { code: 'is-authenticated' },
+                },
+              },
+              {
+                node: {
+                  type: 'tag',
+                  tag: 'h1',
+                  children: [
+                    {
+                      type: 'text',
+                      value: 'Hello Unauthenticated User!',
+                    },
+                  ],
+                },
+                conditions: {
+                  segment: { code: 'is-unauthenticated' },
+                },
+              },
+            ],
+          },
+        ],
+      },
+    },
+  ],
+};

package/src/integration-tests/upload-and-render-page.integration.spec.ts

@@ -1,11 +1,10 @@
-import { PageContentsCreate } from '@squiz/component-web-api-lib/src/generated/ContentApi';
-import { ComponentSetWebModelForCreate } from '@squiz/component-lib';
 import path from 'path';
+import { ContentApi } from '@squiz/component-web-api-lib';
 import {
   addComponentSet,
   contentService,
-  deleteComponentSet,
   deleteComponents,
+  deleteComponentSet,
   deleteContentItem,
   deleteContentSchema,
   getTestComponent,
@@ -13,88 +12,40 @@ import {
   uploadTestComponent,
 } from './helper';
 import fsp from 'fs/promises';
-import { randomInt } from 'crypto';
-
-const COMPONENT_SET_WEB_PATH = 'local-development-only' + randomInt(10000);
-const COMPONENT_NAME = 'test-page-render';
-const COMPONENT_NAMESPACE = 'unit-test-components';
-const COMPONENT_CONTENT_ID = 'component-content-id' + randomInt(10000);
-const COMPONENT_NODE_ID = `${COMPONENT_NAMESPACE}/${COMPONENT_NAME}/1.0.0/main`;
-
-//The componentSet for the component in the content item
-const testComponentSet: ComponentSetWebModelForCreate = {
-  webPath: COMPONENT_SET_WEB_PATH,
-  displayName: 'test-set',
-  description: 'test-set',
-  headers: {},
-  components: {},
-  componentVersionRules: {
-    [`${COMPONENT_NAMESPACE}/${COMPONENT_NAME}`]: {
-      renderableVersionPattern: '1.0.0',
-      editableVersions: [],
-      excludedVersions: [],
-    },
-  },
-};
-
-// The content item for the component
-const componentContentItem = {
-  id: COMPONENT_CONTENT_ID,
-  schemaName: COMPONENT_NODE_ID,
-  content: {
-    text: 'component-input-string',
-  },
-};
-
-// The page content item which references the content item
-const pageContents: PageContentsCreate = {
-  name: 'page-contents-test-1',
-  layouts: [
-    {
-      name: 'single-column',
-      content: {
-        main: [
-          {
-            type: 'tag',
-            tag: 'h1',
-            children: [
-              {
-                type: 'text',
-                value: 'Hello World!',
-              },
-            ],
-          },
-          {
-            type: 'component',
-            componentSet: COMPONENT_SET_WEB_PATH,
-            componentId: COMPONENT_NODE_ID,
-            contentItem: { id: COMPONENT_CONTENT_ID },
-          },
-          {
-            type: 'tag',
-            tag: 'p',
-            children: [
-              {
-                type: 'text',
-                value: 'Bottom text',
-              },
-            ],
-          },
-        ],
-      },
-    },
-  ],
-};
+import { buildDevelopmentSession } from '@squiz/dxp-session-lib';
+import { DxpCacheAccess, DxpSession, DxpSessionVersion } from '@squiz/dxp-session-lib';
+import {
+  COMPONENT_CONTENT_ID,
+  COMPONENT_NAME,
+  COMPONENT_NODE_ID,
+  COMPONENT_SET_WEB_PATH,
+  componentContentItem,
+  componentSet,
+  pageContents,
+  pageContentsWithVariants,
+} from './upload-and-render-page.integration.mocks';
 
 describe('PageRenderController- Integration', () => {
   let PAGE_CONTENT_ID: string;
   const testFilesDir = path.resolve(__dirname, 'test-files');
+  const pageContentIds: string[] = [];
+  const createPage = async (page: ContentApi.PageContentsCreate): Promise<string> => {
+    try {
+      const response = await contentService.post('page-contents', page);
+      pageContentIds.push(response.data.id);
+      return response.data.id;
+    } catch (error) {
+      console.log('error', error, JSON.stringify((error as any).response.data));
+      throw error;
+    }
+  };
+
   beforeAll(async () => {
     await fsp.rm(testFilesDir, { force: true, recursive: true });
     await fsp.mkdir(testFilesDir);
     // Component Configuration
     await uploadTestComponent('/__components__/test-page-render', testFilesDir);
-    await addComponentSet(testComponentSet);
+    await addComponentSet(componentSet);
     // Post component items
     await contentService.post('content-item', componentContentItem);
   });
@@ -104,133 +55,127 @@ describe('PageRenderController- Integration', () => {
     await deleteContentSchema(COMPONENT_NODE_ID);
     await deleteComponentSet(COMPONENT_SET_WEB_PATH);
     await deleteComponents(await getTestComponent(COMPONENT_NAME));
+    await Promise.all(pageContentIds.map((id) => contentService.delete(`page-contents/${id}`)));
   });
 
   it('should render a page', async () => {
-    const response = await contentService.post('page-contents', pageContents, {
-      headers: { 'x-api-key': 'MOCK_KEY' },
-    });
-    PAGE_CONTENT_ID = response.data.id!;
-    expect(response.status).toBe(201);
+    PAGE_CONTENT_ID = await createPage(pageContents);
 
-    const mockJwtPayload = {
-      segments: ['is-authenticated'],
-      customerid: 'test-id-123',
-    };
-    const mockSession = Buffer.from(JSON.stringify(mockJwtPayload)).toString('base64');
+    const mockSession = buildDevelopmentSession({
+      version: DxpSessionVersion.version1,
+    });
     const page = await pageRenderService.get(`p/${PAGE_CONTENT_ID}`, {
-      headers: { 'x-dxp-customer-session': mockSession },
+      headers: { 'x-dxp-session': mockSession },
     });
     expect(page.data).toEqual(
       `<div class="container"><h1>Hello World!</h1><esi:include src="/__dxp/au/components-render/${process.env.TENANT_ID}/r/unit-test-components/test-page-render/1.0.0/main?_componentSet=${COMPONENT_SET_WEB_PATH}&_contentItemId=${COMPONENT_CONTENT_ID}"/><p>Bottom text</p></div>`,
     );
   });
 
-  describe('it should render', () => {
+  describe('should render a page with variations', () => {
     beforeAll(async () => {
-      const pageVariant: PageContentsCreate = {
-        name: 'page-contents-test-2',
-        layouts: [
-          {
-            name: 'single-column',
-            content: {
-              main: [
-                {
-                  type: 'variation',
-                  default: {
-                    node: {
-                      type: 'tag',
-                      tag: 'h1',
-                      children: [
-                        {
-                          type: 'text',
-                          value: 'Hello World!',
-                        },
-                      ],
-                    },
-                  },
-                  variants: [
-                    {
-                      node: {
-                        type: 'tag',
-                        tag: 'h1',
-                        children: [
-                          {
-                            type: 'text',
-                            value: 'Hello Authenticated User!',
-                          },
-                        ],
-                      },
-                      conditions: {
-                        segment: { code: 'is-authenticated' },
-                      },
-                    },
-                    {
-                      node: {
-                        type: 'tag',
-                        tag: 'h1',
-                        children: [
-                          {
-                            type: 'text',
-                            value: 'Hello Unauthenticated User!',
-                          },
-                        ],
-                      },
-                      conditions: {
-                        segment: { code: 'is-unauthenticated' },
-                      },
-                    },
-                  ],
-                },
-              ],
-            },
-          },
-        ],
-      };
-      const response = await contentService.post('page-contents', pageVariant, {
-        headers: { 'x-api-key': 'MOCK_KEY' },
-      });
-      PAGE_CONTENT_ID = response.data.id!;
+      PAGE_CONTENT_ID = await createPage(pageContentsWithVariants);
     });
 
-    describe('Variations', () => {
-      it('a valid page variation', async () => {
-        const mockJwtPayload = {
-          segments: ['is-authenticated'],
-          customerid: 'test-id-123',
-        };
-        const mockSession = Buffer.from(JSON.stringify(mockJwtPayload)).toString('base64');
-        try {
-          const page = await pageRenderService.get(`p/${PAGE_CONTENT_ID}`, {
-            headers: { 'x-dxp-customer-session': mockSession },
-          });
-          expect(page.data).toEqual('<div class="container"><h1>Hello Authenticated User!</h1></div>');
-        } catch (error) {
-          console.log(JSON.stringify(error, null));
-        }
-      });
-      it('another valid page variation', async () => {
-        const mockJwtPayload = {
-          segments: ['is-unauthenticated'],
-          customerid: 'test-id-123',
-        };
-        const mockSession = Buffer.from(JSON.stringify(mockJwtPayload)).toString('base64');
-        const page = await pageRenderService.get(`p/${PAGE_CONTENT_ID}`, {
-          headers: { 'x-dxp-customer-session': mockSession },
-        });
-        expect(page.data).toEqual('<div class="container"><h1>Hello Unauthenticated User!</h1></div>');
-      });
-      it('the default node if there is not a valid page variation', async () => {
-        const mockJwtPayload = {
-          segments: ['not-valid'],
-          customerid: 'test-id-123',
-        };
-        const mockSession = Buffer.from(JSON.stringify(mockJwtPayload)).toString('base64');
+    it.each([
+      [
+        'a segment variant',
+        {
+          version: DxpSessionVersion.version1,
+          cdp: {
+            anonymous: false,
+            customerid: 'test-id-123',
+            segments: ['is-authenticated'],
+          },
+        },
+        '<div class="container"><h1>Hello Authenticated User!</h1></div>',
+        {
+          version: DxpSessionVersion.version1,
+          cdp: {
+            segments: ['is-authenticated'],
+          },
+          optimize: {
+            experiments: [{ id: 'experiment1', variant: 'B' }],
+          },
+        },
+      ],
+      [
+        'another segment variant',
+        {
+          version: DxpSessionVersion.version1,
+          cdp: {
+            anonymous: false,
+            customerid: 'test-id-123',
+            segments: ['is-unauthenticated'],
+          },
+        },
+        '<div class="container"><h1>Hello Unauthenticated User!</h1></div>',
+        {
+          version: DxpSessionVersion.version1,
+          cdp: {
+            segments: ['is-authenticated', 'is-unauthenticated'],
+          },
+          optimize: {
+            experiments: [],
+          },
+        },
+      ],
+      [
+        'an experiment variant',
+        {
+          version: DxpSessionVersion.version1,
+          cdp: {
+            anonymous: false,
+            customerid: 'test-id-123',
+            segments: ['is-authenticated'],
+          },
+          optimize: {
+            experiments: [{ id: 'experiment1', variant: 'B' }],
+          },
+        },
+        '<div class="container"><h1>Hello Authenticated User with experiment B!</h1></div>',
+        {
+          version: DxpSessionVersion.version1,
+          cdp: {
+            segments: ['is-authenticated'],
+          },
+          optimize: {
+            experiments: [{ id: 'experiment1', variant: 'B' }],
+          },
+        },
+      ],
+      [
+        'the default variant',
+        {
+          version: DxpSessionVersion.version1,
+          cdp: {
+            anonymous: false,
+            customerid: 'test-id-123',
+            segments: ['not-valid'],
+          },
+        },
+        '<div class="container"><h1>Hello World!</h1></div>',
+        {
+          version: DxpSessionVersion.version1,
+          cdp: {
+            segments: ['is-authenticated', 'is-unauthenticated'],
+          },
+          optimize: {
+            experiments: [],
+          },
+        },
+      ],
+    ])(
+      'renders the matching variation for %s',
+      async (description: string, session: DxpSession, expectedBody: string, expectedCacheAccess: DxpCacheAccess) => {
         const page = await pageRenderService.get(`p/${PAGE_CONTENT_ID}`, {
-          headers: { 'x-dxp-customer-session': mockSession },
+          headers: { 'x-dxp-session': buildDevelopmentSession(session) },
         });
-        expect(page.data).toEqual('<div class="container"><h1>Hello World!</h1></div>');
-      });
-    });
+        const dxpCacheAccess = JSON.parse(Buffer.from(page.headers['x-dxp-cache-access'], 'base64').toString());
+
+        expect(page.data).toEqual(expectedBody);
+        expect(dxpCacheAccess).toEqual(expectedCacheAccess);
+      },
+    );
   });
 });