@adobe/spacecat-shared-tokowaka-client 1.0.0

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

@@ -0,0 +1,428 @@
+/*
+ * 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 HeadingsMapper from '../../src/mappers/headings-mapper.js';
+
+describe('HeadingsMapper', () => {
+  let mapper;
+  let log;
+
+  beforeEach(() => {
+    log = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    };
+    mapper = new HeadingsMapper(log);
+  });
+
+  describe('getOpportunityType', () => {
+    it('should return headings', () => {
+      expect(mapper.getOpportunityType()).to.equal('headings');
+    });
+  });
+
+  describe('requiresPrerender', () => {
+    it('should return true', () => {
+      expect(mapper.requiresPrerender()).to.be.true;
+    });
+  });
+
+  describe('canDeploy', () => {
+    it('should return eligible for heading-empty checkType', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-empty',
+          recommendedAction: 'New Heading',
+          transformRules: {
+            action: 'replace',
+            selector: 'h1',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({ eligible: true });
+    });
+
+    it('should return eligible for heading-missing-h1 checkType', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-missing-h1',
+          recommendedAction: 'New H1',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#header',
+            tag: 'h1',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({ eligible: true });
+    });
+
+    it('should return eligible for heading-h1-length checkType', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-h1-length',
+          recommendedAction: 'Better H1',
+          transformRules: {
+            action: 'replace',
+            selector: 'h1',
+          },
+        }),
+      };
+
+      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' }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      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',
+      });
+    });
+
+    it('should return ineligible when checkType is missing', () => {
+      const suggestion = {
+        getData: () => ({}),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      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',
+      });
+    });
+
+    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: 'Only heading-empty, heading-missing-h1, heading-h1-length can be deployed. This suggestion has checkType: undefined',
+      });
+    });
+
+    it('should return ineligible when recommendedAction is missing', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-empty',
+          transformRules: {
+            action: 'replace',
+            selector: 'h1',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'recommendedAction is required',
+      });
+    });
+
+    it('should return ineligible when transformRules.selector is missing', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-empty',
+          recommendedAction: 'New Heading',
+          transformRules: {
+            action: 'replace',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.selector is required',
+      });
+    });
+
+    it('should return ineligible for heading-missing-h1 with invalid action', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-missing-h1',
+          recommendedAction: 'New H1',
+          transformRules: {
+            action: 'replace',
+            selector: '#header',
+            tag: 'h1',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.action must be insertBefore or insertAfter for heading-missing-h1',
+      });
+    });
+
+    it('should return ineligible for heading-missing-h1 without tag', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-missing-h1',
+          recommendedAction: 'New H1',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#header',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.tag is required for heading-missing-h1',
+      });
+    });
+
+    it('should return ineligible for heading-h1-length with invalid action', () => {
+      const suggestion = {
+        getData: () => ({
+          checkType: 'heading-h1-length',
+          recommendedAction: 'New H1',
+          transformRules: {
+            action: 'insertAfter',
+            selector: 'h1',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.action must be replace for heading-h1-length',
+      });
+    });
+  });
+
+  describe('suggestionToPatch', () => {
+    it('should create patch for heading-empty with transformRules', () => {
+      const suggestion = {
+        getId: () => 'sugg-123',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-empty',
+          recommendedAction: 'New Heading',
+          transformRules: {
+            action: 'replace',
+            selector: 'h1',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-123');
+
+      expect(patch).to.deep.include({
+        op: 'replace',
+        selector: 'h1',
+        value: 'New Heading',
+        opportunityId: 'opp-123',
+        suggestionId: 'sugg-123',
+        prerenderRequired: true,
+      });
+      expect(patch.lastUpdated).to.be.a('number');
+    });
+
+    it('should create patch with custom selector', () => {
+      const suggestion = {
+        getId: () => 'sugg-123',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-empty',
+          recommendedAction: 'New Heading',
+          transformRules: {
+            action: 'replace',
+            selector: 'body > h1',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-123');
+
+      expect(patch).to.deep.include({
+        op: 'replace',
+        selector: 'body > h1',
+        value: 'New Heading',
+        opportunityId: 'opp-123',
+        suggestionId: 'sugg-123',
+        prerenderRequired: true,
+      });
+    });
+
+    it('should create patch for heading-missing-h1 with transformRules', () => {
+      const suggestion = {
+        getId: () => 'sugg-456',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-missing-h1',
+          recommendedAction: 'Exclusive Flight Booking Deals & Partner Discounts.',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#text-85a9876220 > h2:nth-of-type(1)',
+            tag: 'h1',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-456');
+
+      expect(patch).to.deep.include({
+        op: 'insertAfter',
+        selector: '#text-85a9876220 > h2:nth-of-type(1)',
+        value: 'Exclusive Flight Booking Deals & Partner Discounts.',
+        tag: 'h1',
+        opportunityId: 'opp-456',
+        suggestionId: 'sugg-456',
+        prerenderRequired: true,
+      });
+      expect(patch.lastUpdated).to.be.a('number');
+    });
+
+    it('should create patch for heading-h1-length with transformRules', () => {
+      const suggestion = {
+        getId: () => 'sugg-789',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-h1-length',
+          recommendedAction: 'New H1 Heading',
+          transformRules: {
+            action: 'replace',
+            selector: 'body > h1',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-789');
+
+      expect(patch).to.deep.include({
+        op: 'replace',
+        selector: 'body > h1',
+        value: 'New H1 Heading',
+        opportunityId: 'opp-789',
+        suggestionId: 'sugg-789',
+        prerenderRequired: true,
+      });
+      expect(patch.lastUpdated).to.be.a('number');
+      expect(patch.tag).to.be.undefined;
+    });
+
+    it('should return null for heading-missing-h1 without transformRules', () => {
+      const suggestion = {
+        getId: () => 'sugg-999',
+        getData: () => ({
+          checkType: 'heading-missing-h1',
+          recommendedAction: 'New Heading',
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-999');
+
+      expect(patch).to.be.null;
+    });
+
+    it('should return null for heading-h1-length without selector in transformRules', () => {
+      const suggestion = {
+        getId: () => 'sugg-888',
+        getData: () => ({
+          checkType: 'heading-h1-length',
+          recommendedAction: 'New Heading',
+          transformRules: {
+            action: 'insertAt',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-888');
+
+      expect(patch).to.be.null;
+    });
+
+    it('should log warning for heading-missing-h1 with missing transformRules - validation path', () => {
+      let warnLogged = false;
+      const warnLog = {
+        debug: () => {},
+        info: () => {},
+        warn: () => { warnLogged = true; },
+        error: () => {},
+      };
+      const warnMapper = new HeadingsMapper(warnLog);
+
+      const suggestion = {
+        getId: () => 'sugg-warn',
+        getData: () => ({
+          checkType: 'heading-missing-h1',
+          recommendedAction: 'New Heading',
+        }),
+      };
+
+      const patch = warnMapper.suggestionToPatch(suggestion, 'opp-warn');
+
+      expect(patch).to.be.null;
+      expect(warnLogged).to.be.true;
+    });
+
+    it('should log warning for heading-missing-h1 with invalid transformRules', () => {
+      let warnMessage = '';
+      const warnLog = {
+        debug: () => {},
+        info: () => {},
+        warn: (msg) => { warnMessage = msg; },
+        error: () => {},
+      };
+      const warnMapper = new HeadingsMapper(warnLog);
+
+      const suggestion = {
+        getId: () => 'sugg-defensive',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          checkType: 'heading-missing-h1',
+          recommendedAction: 'New Heading',
+          // Missing transformRules
+        }),
+      };
+
+      const patch = warnMapper.suggestionToPatch(suggestion, 'opp-defensive');
+
+      expect(patch).to.be.null;
+      expect(warnMessage).to.include('cannot be deployed');
+    });
+  });
+});

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

@@ -0,0 +1,197 @@
+/*
+ * 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 */
+/* eslint-disable max-classes-per-file */
+
+import { expect, use } from 'chai';
+import sinon from 'sinon';
+import sinonChai from 'sinon-chai';
+import MapperRegistry from '../../src/mappers/mapper-registry.js';
+import HeadingsMapper from '../../src/mappers/headings-mapper.js';
+import BaseOpportunityMapper from '../../src/mappers/base-mapper.js';
+
+use(sinonChai);
+
+describe('MapperRegistry', () => {
+  let registry;
+  let log;
+
+  beforeEach(() => {
+    log = {
+      info: sinon.stub(),
+      warn: sinon.stub(),
+      error: sinon.stub(),
+      debug: sinon.stub(),
+    };
+
+    registry = new MapperRegistry(log);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  describe('constructor', () => {
+    it('should create an instance and register default mappers', () => {
+      expect(registry).to.be.instanceOf(MapperRegistry);
+      expect(registry.mappers).to.be.instanceOf(Map);
+      expect(registry.mappers.size).to.be.greaterThan(0);
+    });
+  });
+
+  describe('registerMapper', () => {
+    it('should register a custom mapper', () => {
+      class CustomMapper extends BaseOpportunityMapper {
+        // eslint-disable-next-line class-methods-use-this
+        getOpportunityType() {
+          return 'custom';
+        }
+
+        // eslint-disable-next-line class-methods-use-this
+        requiresPrerender() {
+          return false;
+        }
+
+        // eslint-disable-next-line class-methods-use-this
+        suggestionToPatch() {
+          return {};
+        }
+
+        // eslint-disable-next-line class-methods-use-this
+        validateSuggestionData() {
+          return true;
+        }
+      }
+
+      registry.registerMapper(new CustomMapper(log));
+
+      expect(registry.mappers.has('custom')).to.be.true;
+      expect(registry.getSupportedOpportunityTypes()).to.include('custom');
+    });
+
+    it('should log debug message when overriding existing mapper', () => {
+      class CustomMapper extends BaseOpportunityMapper {
+        // eslint-disable-next-line class-methods-use-this
+        getOpportunityType() {
+          return 'headings'; // Override existing headings mapper
+        }
+
+        // eslint-disable-next-line class-methods-use-this
+        requiresPrerender() {
+          return false;
+        }
+
+        // eslint-disable-next-line class-methods-use-this
+        suggestionToPatch() {
+          return {};
+        }
+      }
+
+      registry.registerMapper(new CustomMapper(log));
+
+      expect(log.debug).to.have.been.calledWith(
+        'Mapper for opportunity type "headings" is being overridden',
+      );
+      expect(log.info).to.have.been.calledWith(
+        'Registered mapper for opportunity type: headings',
+      );
+    });
+  });
+
+  describe('getMapper', () => {
+    it('should return headings mapper for headings opportunity type', () => {
+      const mapper = registry.getMapper('headings');
+
+      expect(mapper).to.be.instanceOf(HeadingsMapper);
+    });
+
+    it('should return null for unsupported opportunity type', () => {
+      const mapper = registry.getMapper('unsupported-type');
+
+      expect(mapper).to.be.null;
+      expect(log.warn).to.have.been.calledWith(
+        'No mapper found for opportunity type: unsupported-type',
+      );
+    });
+
+    it('should return null when opportunity type is empty', () => {
+      const mapper = registry.getMapper('');
+
+      expect(mapper).to.be.null;
+    });
+
+    it('should return null when opportunity type is null', () => {
+      const mapper = registry.getMapper(null);
+
+      expect(mapper).to.be.null;
+    });
+  });
+
+  describe('getSupportedOpportunityTypes', () => {
+    it('should return list of supported opportunity types', () => {
+      const types = registry.getSupportedOpportunityTypes();
+
+      expect(types).to.be.an('array');
+      expect(types).to.include('headings');
+    });
+
+    it('should include custom registered mappers', () => {
+      class CustomMapper extends BaseOpportunityMapper {
+        // eslint-disable-next-line class-methods-use-this
+        getOpportunityType() {
+          return 'custom';
+        }
+
+        // eslint-disable-next-line class-methods-use-this
+        requiresPrerender() {
+          return false;
+        }
+
+        // eslint-disable-next-line class-methods-use-this
+        suggestionToPatch() {
+          return {};
+        }
+
+        // eslint-disable-next-line class-methods-use-this
+        validateSuggestionData() {
+          return true;
+        }
+      }
+
+      registry.registerMapper(new CustomMapper(log));
+
+      const types = registry.getSupportedOpportunityTypes();
+
+      expect(types).to.include('custom');
+      expect(types).to.include('headings');
+    });
+  });
+
+  describe('hasMapper', () => {
+    it('should return true for supported opportunity type', () => {
+      expect(registry.hasMapper('headings')).to.be.true;
+    });
+
+    it('should return false for unsupported opportunity type', () => {
+      expect(registry.hasMapper('unsupported')).to.be.false;
+    });
+
+    it('should return false for null opportunity type', () => {
+      expect(registry.hasMapper(null)).to.be.false;
+    });
+
+    it('should return false for undefined opportunity type', () => {
+      expect(registry.hasMapper(undefined)).to.be.false;
+    });
+  });
+});

package/test/setup-env.js

@@ -0,0 +1,18 @@
+/*
+ * 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-disable-next-line no-console
+console.log('Forcing HTTP/1.1 for Adobe Fetch');
+process.env.HELIX_FETCH_FORCE_HTTP1 = 'true';
+// eslint-disable-next-line no-console
+console.log('Disabling AWS XRay');
+process.env.AWS_XRAY_SDK_ENABLED = 'false';
+process.env.AWS_XRAY_CONTEXT_MISSING = 'IGNORE_ERROR';