@adobe/spacecat-shared-tokowaka-client 1.3.0 → 1.3.2

package/test/index.test.js

@@ -1040,6 +1040,59 @@ describe('TokowakaClient', () => {
       // Both suggestions are in result but sugg-1 skipped deployment due to no patches
       expect(result.succeededSuggestions).to.have.length(2);
       expect(result.s3Paths).to.have.length(1); // Only one URL actually deployed
+      expect(log.warn).to.have.been.calledWith('No config generated for URL: https://example.com/page1');
+    });
+
+    it('should skip URL when config has no patches after generation', async () => {
+      // Stub generateConfig to return a config with no patches (defensive check)
+      const originalGenerateConfig = client.generateConfig.bind(client);
+      sinon.stub(client, 'generateConfig').callsFake((url, ...args) => {
+        const config = originalGenerateConfig(url, ...args);
+        if (config && url === 'https://example.com/page1') {
+          // Return config but with empty patches array (simulating edge case)
+          return { ...config, patches: [] };
+        }
+        return config;
+      });
+
+      mockSuggestions = [
+        {
+          getId: () => 'sugg-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page1',
+            recommendedAction: 'New Heading',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h1',
+            },
+          }),
+        },
+        {
+          getId: () => 'sugg-2',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page2',
+            recommendedAction: 'New Subtitle',
+            checkType: 'heading-empty',
+            transformRules: {
+              action: 'replace',
+              selector: 'h2',
+            },
+          }),
+        },
+      ];
+
+      const result = await client.deploySuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+      );
+
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.s3Paths).to.have.length(1); // Only page2 deployed
+      expect(log.warn).to.have.been.calledWith('No eligible suggestions to deploy for URL: https://example.com/page1');
     });
 
     it('should return early when no eligible suggestions', async () => {
@@ -1066,6 +1119,50 @@ describe('TokowakaClient', () => {
       expect(s3Client.send).to.not.have.been.called;
     });
 
+    it('should deploy prerender-only suggestions with no patches', async () => {
+      // Create prerender opportunity
+      const prerenderOpportunity = {
+        getId: () => 'opp-prerender-123',
+        getType: () => 'prerender',
+      };
+
+      // Create prerender suggestions with no transform rules (prerender-only)
+      const prerenderSuggestions = [
+        {
+          getId: () => 'prerender-sugg-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page1',
+            // No transform rules - prerender only
+          }),
+        },
+      ];
+
+      const result = await client.deploySuggestions(
+        mockSite,
+        prerenderOpportunity,
+        prerenderSuggestions,
+      );
+
+      expect(result.succeededSuggestions).to.have.length(1);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.s3Paths).to.have.length(1);
+      expect(result.cdnInvalidations).to.have.length(1);
+
+      // Verify uploaded config has no patches but prerender is enabled
+      const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
+      expect(uploadedConfig.patches).to.have.length(0);
+      expect(uploadedConfig.prerender).to.equal(true);
+      expect(uploadedConfig.url).to.equal('https://example.com/page1');
+
+      // Verify CDN was invalidated
+      expect(client.invalidateCdnCache).to.have.been.calledOnce;
+      expect(client.invalidateCdnCache).to.have.been.calledWith(
+        'https://example.com/page1',
+        'cloudfront',
+      );
+    });
+
     it('should throw error for unsupported opportunity type', async () => {
       mockOpportunity.getType = () => 'unsupported-type';
 
@@ -1222,6 +1319,70 @@ describe('TokowakaClient', () => {
       expect(uploadedConfig.patches[0].suggestionId).to.equal('sugg-3');
     });
 
+    it('should rollback prerender suggestions by disabling prerender flag', async () => {
+      // Create prerender opportunity
+      const prerenderOpportunity = {
+        getId: () => 'opp-prerender-123',
+        getType: () => 'prerender',
+      };
+
+      // Create prerender suggestions
+      const prerenderSuggestions = [
+        {
+          getId: () => 'prerender-sugg-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page1',
+          }),
+        },
+      ];
+
+      const existingConfig = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Heading 1',
+            opportunityId: 'opp-other-123',
+            suggestionId: 'other-sugg-1',
+            prerenderRequired: false,
+            lastUpdated: 1234567890,
+          },
+        ],
+      };
+
+      sinon.stub(client, 'fetchConfig').resolves(existingConfig);
+
+      const result = await client.rollbackSuggestions(
+        mockSite,
+        prerenderOpportunity,
+        prerenderSuggestions,
+      );
+
+      expect(result.s3Paths).to.have.length(1);
+      expect(result.s3Paths[0]).to.equal('opportunities/example.com/L3BhZ2Ux');
+      expect(result.succeededSuggestions).to.have.length(1);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.removedPatchesCount).to.equal(1);
+
+      // Verify uploaded config has prerender disabled but patches intact
+      const uploadedConfig = JSON.parse(s3Client.send.firstCall.args[0].input.Body);
+      expect(uploadedConfig.prerender).to.equal(false);
+      expect(uploadedConfig.patches).to.have.length(1);
+      expect(uploadedConfig.patches[0].suggestionId).to.equal('other-sugg-1');
+
+      // Verify CDN was invalidated
+      expect(client.invalidateCdnCache).to.have.been.calledOnce;
+      expect(client.invalidateCdnCache).to.have.been.calledWith(
+        'https://example.com/page1',
+        'cloudfront',
+      );
+    });
+
     it('should handle no existing config gracefully', async () => {
       sinon.stub(client, 'fetchConfig').resolves(null);
 
@@ -1262,6 +1423,30 @@ describe('TokowakaClient', () => {
       expect(s3Client.send).to.not.have.been.called;
     });
 
+    it('should handle missing patches property in config', async () => {
+      const existingConfig = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        // patches property is missing
+      };
+
+      sinon.stub(client, 'fetchConfig').resolves(existingConfig);
+
+      const result = await client.rollbackSuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+      );
+
+      // Code marks eligible suggestions as succeeded even if patches property missing
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.s3Paths).to.have.length(0);
+      expect(s3Client.send).to.not.have.been.called;
+    });
+
     it('should handle suggestions not found in config', async () => {
       const existingConfig = {
         url: 'https://example.com/page1',
@@ -1589,6 +1774,64 @@ describe('TokowakaClient', () => {
       expect(s3Client.send).to.have.been.calledOnce;
     });
 
+    it('should preview prerender-only suggestions with no patches', async () => {
+      // Update fetchConfig to return existing config with deployed patches
+      client.fetchConfig.resolves({
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: false,
+        patches: [
+          {
+            op: 'replace',
+            selector: 'h1',
+            value: 'Existing Heading',
+            opportunityId: 'opp-other-123',
+            suggestionId: 'sugg-other',
+            prerenderRequired: false,
+            lastUpdated: 1234567890,
+          },
+        ],
+      });
+
+      // Create prerender opportunity
+      const prerenderOpportunity = {
+        getId: () => 'opp-prerender-123',
+        getType: () => 'prerender',
+      };
+
+      // Create prerender suggestions with no transform rules (prerender-only)
+      const prerenderSuggestions = [
+        {
+          getId: () => 'prerender-sugg-1',
+          getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+          getData: () => ({
+            url: 'https://example.com/page1',
+            // No transform rules - prerender only
+          }),
+        },
+      ];
+
+      const result = await client.previewSuggestions(
+        mockSite,
+        prerenderOpportunity,
+        prerenderSuggestions,
+        { warmupDelayMs: 0 },
+      );
+
+      expect(result).to.have.property('s3Path');
+      expect(result.config).to.not.be.null;
+      expect(result.config.patches).to.have.length(1); // Merged with existing deployed patch
+      expect(result.config.prerender).to.equal(true); // Prerender enabled
+      expect(result.succeededSuggestions).to.have.length(1);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result).to.have.property('html');
+
+      // Verify fetch was called for HTML fetching
+      expect(fetchStub.callCount).to.equal(4);
+      expect(s3Client.send).to.have.been.calledOnce;
+    });
+
     it('should throw error if TOKOWAKA_EDGE_URL is not configured', async () => {
       delete client.env.TOKOWAKA_EDGE_URL;
 

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

@@ -41,6 +41,12 @@ describe('GenericMapper', () => {
     });
   });
 
+  describe('allowConfigsWithoutPatch', () => {
+    it('should return false for generic mapper', () => {
+      expect(mapper.allowConfigsWithoutPatch()).to.be.false;
+    });
+  });
+
   describe('canDeploy', () => {
     it('should return eligible for valid suggestion with all required fields', () => {
       const suggestion = {

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 });
+      });
+    });
+  });
+});