@adobe/spacecat-shared-tokowaka-client 1.2.4 → 1.3.1

package/test/mappers/headings-mapper.test.js

@@ -94,6 +94,24 @@ describe('HeadingsMapper', () => {
       expect(result).to.deep.equal({ eligible: true });
     });
 
+    it('should return eligible for heading-order-invalid checkType', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          transformRules: {
+            action: 'replaceWith',
+            selector: '.invalid-section',
+            valueFormat: 'hast',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({ eligible: true });
+    });
+
     it('should return ineligible for unknown checkType', () => {
       const suggestion = {
         getData: () => ({ checkType: 'unknown-type' }),
@@ -103,7 +121,7 @@ describe('HeadingsMapper', () => {
 
       expect(result).to.deep.equal({
         eligible: false,
-        reason: 'Only heading-empty, heading-missing-h1, heading-h1-length can be deployed. This suggestion has checkType: unknown-type',
+        reason: 'Only heading-empty, heading-missing-h1, heading-h1-length, heading-order-invalid can be deployed. This suggestion has checkType: unknown-type',
       });
     });
 
@@ -116,7 +134,7 @@ describe('HeadingsMapper', () => {
 
       expect(result).to.deep.equal({
         eligible: false,
-        reason: 'Only heading-empty, heading-missing-h1, heading-h1-length can be deployed. This suggestion has checkType: undefined',
+        reason: 'Only heading-empty, heading-missing-h1, heading-h1-length, heading-order-invalid can be deployed. This suggestion has checkType: undefined',
       });
     });
 
@@ -129,7 +147,7 @@ describe('HeadingsMapper', () => {
 
       expect(result).to.deep.equal({
         eligible: false,
-        reason: 'Only heading-empty, heading-missing-h1, heading-h1-length can be deployed. This suggestion has checkType: undefined',
+        reason: 'Only heading-empty, heading-missing-h1, heading-h1-length, heading-order-invalid can be deployed. This suggestion has checkType: undefined',
       });
     });
 
@@ -231,6 +249,68 @@ describe('HeadingsMapper', () => {
         reason: 'transformRules.action must be replace for heading-h1-length',
       });
     });
+
+    it('should return ineligible for heading-order-invalid with invalid action', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          transformRules: {
+            action: 'replace',
+            selector: '.invalid-section',
+            valueFormat: 'hast',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.action must be replaceWith for heading-order-invalid',
+      });
+    });
+
+    it('should return ineligible for heading-order-invalid with missing valueFormat', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          transformRules: {
+            action: 'replaceWith',
+            selector: '.invalid-section',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.valueFormat must be hast for heading-order-invalid',
+      });
+    });
+
+    it('should return ineligible for heading-order-invalid with invalid valueFormat', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          transformRules: {
+            action: 'replaceWith',
+            selector: '.invalid-section',
+            valueFormat: 'text',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.valueFormat must be hast for heading-order-invalid',
+      });
+    });
   });
 
   describe('suggestionsToPatches', () => {
@@ -352,6 +432,77 @@ describe('HeadingsMapper', () => {
       expect(patch.tag).to.be.undefined;
     });
 
+    it('should create patch for heading-order-invalid with transformRules', () => {
+      const hastValue = {
+        type: 'element',
+        tagName: 'div',
+        children: [
+          { type: 'element', tagName: 'h2', children: [{ type: 'text', value: 'Section Title' }] },
+          { type: 'element', tagName: 'h3', children: [{ type: 'text', value: 'Subsection' }] },
+        ],
+      };
+
+      const suggestion = {
+        getId: () => 'sugg-101',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: hastValue,
+          transformRules: {
+            action: 'replaceWith',
+            selector: '.content-section',
+            valueFormat: 'hast',
+          },
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-101');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      expect(patch).to.deep.include({
+        op: 'replaceWith',
+        selector: '.content-section',
+        value: hastValue,
+        opportunityId: 'opp-101',
+        suggestionId: 'sugg-101',
+        prerenderRequired: true,
+      });
+      expect(patch.lastUpdated).to.be.a('number');
+      expect(patch.tag).to.be.undefined;
+    });
+
+    it('should return empty array for heading-order-invalid without transformRules', () => {
+      const suggestion = {
+        getId: () => 'sugg-102',
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-102');
+      expect(patches.length).to.equal(0);
+    });
+
+    it('should return empty array for heading-order-invalid with invalid action', () => {
+      const suggestion = {
+        getId: () => 'sugg-103',
+        getData: () => ({
+          checkType: 'heading-order-invalid',
+          recommendedAction: { type: 'element', tagName: 'h2', children: [] },
+          transformRules: {
+            action: 'replace',
+            selector: '.content-section',
+            valueFormat: 'hast',
+          },
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-103');
+      expect(patches.length).to.equal(0);
+    });
+
     it('should return empty array for heading-missing-h1 without transformRules', () => {
       const suggestion = {
         getId: () => 'sugg-999',

package/test/mappers/prerender-mapper.test.js

@@ -0,0 +1,216 @@
+/*
+ * Copyright 2025 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+/* eslint-env mocha */
+
+import { expect } from 'chai';
+import PrerenderMapper from '../../src/mappers/prerender-mapper.js';
+
+describe('PrerenderMapper', () => {
+  let mapper;
+  let log;
+
+  beforeEach(() => {
+    log = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    };
+    mapper = new PrerenderMapper(log);
+  });
+
+  describe('getOpportunityType', () => {
+    it('should return prerender', () => {
+      expect(mapper.getOpportunityType()).to.equal('prerender');
+    });
+  });
+
+  describe('requiresPrerender', () => {
+    it('should return true', () => {
+      expect(mapper.requiresPrerender()).to.be.true;
+    });
+  });
+
+  describe('allowConfigsWithoutPatch', () => {
+    it('should return true for prerender mapper', () => {
+      expect(mapper.allowConfigsWithoutPatch()).to.be.true;
+    });
+  });
+
+  describe('suggestionsToPatches', () => {
+    it('should return empty array for prerender suggestions', () => {
+      const suggestion = {
+        getId: () => 'test-suggestion-id',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          url: 'https://example.com/page',
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches(
+        '/page',
+        [suggestion],
+        'test-opportunity-id',
+      );
+
+      expect(patches).to.be.an('array');
+      expect(patches).to.be.empty;
+    });
+
+    it('should return empty array even with multiple suggestions', () => {
+      const suggestions = [
+        {
+          getId: () => 'suggestion-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page1',
+          }),
+        },
+        {
+          getId: () => 'suggestion-2',
+          getUpdatedAt: () => '2025-01-15T11:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page2',
+          }),
+        },
+      ];
+
+      const patches = mapper.suggestionsToPatches(
+        '/page',
+        suggestions,
+        'test-opportunity-id',
+      );
+
+      expect(patches).to.be.an('array');
+      expect(patches).to.be.empty;
+    });
+  });
+
+  describe('canDeploy', () => {
+    it('should return eligible for valid suggestion with URL', () => {
+      const suggestion = {
+        getData: () => ({
+          url: 'https://example.com/page',
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({ eligible: true });
+    });
+
+    it('should return ineligible when URL is missing', () => {
+      const suggestion = {
+        getData: () => ({}),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'url is required',
+      });
+    });
+
+    it('should return ineligible when URL is empty string', () => {
+      const suggestion = {
+        getData: () => ({
+          url: '',
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'url is required',
+      });
+    });
+
+    it('should return ineligible when URL is null', () => {
+      const suggestion = {
+        getData: () => ({
+          url: null,
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'url is required',
+      });
+    });
+
+    it('should return ineligible when URL is undefined', () => {
+      const suggestion = {
+        getData: () => ({
+          url: undefined,
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'url is required',
+      });
+    });
+
+    it('should return ineligible when data is null', () => {
+      const suggestion = {
+        getData: () => null,
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'url is required',
+      });
+    });
+
+    it('should return ineligible when data is undefined', () => {
+      const suggestion = {
+        getData: () => undefined,
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'url is required',
+      });
+    });
+
+    it('should return eligible for various valid URL formats', () => {
+      const urls = [
+        'https://example.com',
+        'https://example.com/path',
+        'https://subdomain.example.com/path/to/page',
+        'https://example.com/path?query=value',
+        'https://example.com/path#hash',
+      ];
+
+      urls.forEach((url) => {
+        const suggestion = {
+          getData: () => ({ url }),
+        };
+
+        const result = mapper.canDeploy(suggestion);
+
+        expect(result).to.deep.equal({ eligible: true });
+      });
+    });
+  });
+});