@adobe/spacecat-shared-tokowaka-client 1.0.0

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

@@ -0,0 +1,110 @@
+/*
+ * 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, class-methods-use-this */
+
+import { expect } from 'chai';
+import BaseOpportunityMapper from '../../src/mappers/base-mapper.js';
+
+describe('BaseOpportunityMapper', () => {
+  let mapper;
+  let log;
+
+  beforeEach(() => {
+    log = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    };
+    mapper = new BaseOpportunityMapper(log);
+  });
+
+  describe('abstract methods', () => {
+    it('getOpportunityType should throw error', () => {
+      expect(() => mapper.getOpportunityType())
+        .to.throw('getOpportunityType() must be implemented by subclass');
+    });
+
+    it('requiresPrerender should throw error', () => {
+      expect(() => mapper.requiresPrerender())
+        .to.throw('requiresPrerender() must be implemented by subclass');
+    });
+
+    it('suggestionToPatch should throw error', () => {
+      expect(() => mapper.suggestionToPatch({}, 'opp-123'))
+        .to.throw('suggestionToPatch() must be implemented by subclass');
+    });
+
+    it('canDeploy should throw error if not implemented', () => {
+      expect(() => mapper.canDeploy({}))
+        .to.throw('canDeploy() must be implemented by subclass');
+    });
+  });
+
+  describe('createBasePatch', () => {
+    it('should use getUpdatedAt method when available', () => {
+      // Create a concrete subclass for testing
+      class TestMapper extends BaseOpportunityMapper {
+        getOpportunityType() { return 'test'; }
+
+        requiresPrerender() { return true; }
+
+        suggestionToPatch() { return {}; }
+
+        canDeploy() { return { eligible: true }; }
+      }
+
+      const testMapper = new TestMapper();
+      const suggestion = {
+        getId: () => 'test-123',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+      };
+
+      const patch = testMapper.createBasePatch(suggestion, 'opp-456');
+
+      expect(patch.suggestionId).to.equal('test-123');
+      expect(patch.opportunityId).to.equal('opp-456');
+      expect(patch.lastUpdated).to.equal(new Date('2025-01-15T10:00:00.000Z').getTime());
+      expect(patch.prerenderRequired).to.be.true;
+    });
+
+    it('should use Date.now() when getUpdatedAt returns null', () => {
+      class TestMapper extends BaseOpportunityMapper {
+        getOpportunityType() { return 'test'; }
+
+        requiresPrerender() { return true; }
+
+        suggestionToPatch() { return {}; }
+
+        canDeploy() { return { eligible: true }; }
+      }
+
+      const testMapper = new TestMapper();
+      const suggestion = {
+        getId: () => 'test-no-date',
+        getUpdatedAt: () => null, // Returns null
+      };
+
+      const beforeTime = Date.now();
+      const patch = testMapper.createBasePatch(suggestion, 'opp-fallback');
+      const afterTime = Date.now();
+
+      expect(patch.suggestionId).to.equal('test-no-date');
+      expect(patch.opportunityId).to.equal('opp-fallback');
+      expect(patch.lastUpdated).to.be.at.least(beforeTime);
+      expect(patch.lastUpdated).to.be.at.most(afterTime);
+      expect(patch.prerenderRequired).to.be.true;
+    });
+  });
+});

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

@@ -0,0 +1,355 @@
+/*
+ * 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 sinon from 'sinon';
+import ContentMapper from '../../src/mappers/content-summarization-mapper.js';
+
+describe('ContentMapper', () => {
+  let mapper;
+  let log;
+
+  beforeEach(() => {
+    log = {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    };
+    mapper = new ContentMapper(log);
+  });
+
+  describe('getOpportunityType', () => {
+    it('should return summarization', () => {
+      expect(mapper.getOpportunityType()).to.equal('summarization');
+    });
+  });
+
+  describe('requiresPrerender', () => {
+    it('should return true', () => {
+      expect(mapper.requiresPrerender()).to.be.true;
+    });
+  });
+
+  describe('canDeploy', () => {
+    it('should return eligible for valid content suggestion', () => {
+      const suggestion = {
+        getData: () => ({
+          summarizationText: 'Some content',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#text-85a9876220 > h1:nth-of-type(1)',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({ eligible: true });
+    });
+
+    it('should return ineligible when summarizationText is missing', () => {
+      const suggestion = {
+        getData: () => ({
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#selector',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'summarizationText is required',
+      });
+    });
+
+    it('should return ineligible when transformRules are missing', () => {
+      const suggestion = {
+        getData: () => ({
+          summarizationText: 'Some content',
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules is required',
+      });
+    });
+
+    it('should return ineligible when transformRules action is missing', () => {
+      const suggestion = {
+        getData: () => ({
+          summarizationText: 'Some content',
+          transformRules: {
+            selector: '#selector',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.action must be insertAfter, insertBefore, or appendChild',
+      });
+    });
+
+    it('should return ineligible when transformRules selector is missing', () => {
+      const suggestion = {
+        getData: () => ({
+          summarizationText: 'Some content',
+          transformRules: {
+            action: 'insertAfter',
+          },
+        }),
+      };
+
+      const result = mapper.canDeploy(suggestion);
+
+      expect(result).to.deep.equal({
+        eligible: false,
+        reason: 'transformRules.selector 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: 'summarizationText is required',
+      });
+    });
+  });
+
+  describe('suggestionToPatch', () => {
+    it('should create patch with HAST value from markdown', () => {
+      const suggestion = {
+        getId: () => 'sugg-content-123',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          summarizationText: 'Enter your name exactly as it appears on your **government ID**.',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#text-85a9876220 > h1:nth-of-type(1)',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-content-123');
+
+      expect(patch).to.exist;
+      expect(patch.op).to.equal('insertAfter');
+      expect(patch.selector).to.equal('#text-85a9876220 > h1:nth-of-type(1)');
+      expect(patch.valueFormat).to.equal('hast');
+      expect(patch.opportunityId).to.equal('opp-content-123');
+      expect(patch.suggestionId).to.equal('sugg-content-123');
+      expect(patch.prerenderRequired).to.be.true;
+      expect(patch.lastUpdated).to.be.a('number');
+
+      // Verify HAST structure
+      expect(patch.value).to.be.an('object');
+      expect(patch.value.type).to.equal('root');
+      expect(patch.value.children).to.be.an('array');
+      expect(patch.value.children.length).to.be.greaterThan(0);
+    });
+
+    it('should convert markdown with bold text to HAST', () => {
+      const suggestion = {
+        getId: () => 'sugg-bold',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          summarizationText: 'This is **bold** text.',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '.content',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-bold');
+
+      expect(patch).to.exist;
+      expect(patch.value.type).to.equal('root');
+      expect(patch.value.children).to.be.an('array');
+
+      // Find the paragraph
+      const paragraph = patch.value.children.find((child) => child.type === 'element' && child.tagName === 'p');
+      expect(paragraph).to.exist;
+      expect(paragraph.children).to.be.an('array');
+
+      // Should contain text and strong elements
+      const hasStrong = paragraph.children.some((child) => child.type === 'element' && child.tagName === 'strong');
+      expect(hasStrong).to.be.true;
+    });
+
+    it('should convert markdown with headings to HAST', () => {
+      const suggestion = {
+        getId: () => 'sugg-heading',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          summarizationText: '## Key Points\n\nImportant information.',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#intro',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-heading');
+
+      expect(patch).to.exist;
+      expect(patch.value.children).to.be.an('array');
+
+      // Should have h2 and paragraph
+      const hasH2 = patch.value.children.some((child) => child.type === 'element' && child.tagName === 'h2');
+      const hasP = patch.value.children.some((child) => child.type === 'element' && child.tagName === 'p');
+      expect(hasH2).to.be.true;
+      expect(hasP).to.be.true;
+    });
+
+    it('should convert markdown with lists to HAST', () => {
+      const suggestion = {
+        getId: () => 'sugg-list',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          summarizationText: '- Item 1\n- Item 2\n- Item 3',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#list-section',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-list');
+
+      expect(patch).to.exist;
+
+      // Should have ul element
+      const hasList = patch.value.children.some((child) => child.type === 'element' && child.tagName === 'ul');
+      expect(hasList).to.be.true;
+    });
+
+    it('should return null when summarizationText is missing', () => {
+      const suggestion = {
+        getId: () => 'sugg-invalid',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#selector',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-invalid');
+
+      expect(patch).to.be.null;
+    });
+
+    it('should return null when transformRules are incomplete', () => {
+      const suggestion = {
+        getId: () => 'sugg-invalid-2',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          summarizationText: 'Some content',
+          transformRules: {
+            selector: '#selector',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-invalid-2');
+
+      expect(patch).to.be.null;
+    });
+
+    it('should handle complex markdown with multiple elements', () => {
+      const markdownText = `Enter your name exactly as it appears on your **government ID** when booking flights. The same name must be on your **ticket and travel documents**. Rules for names may be different for some countries, such as **Canada, UAE, Australia, and New Zealand**. If your name is spelled wrong, contact support before you travel. There may be a fee to make changes.
+
+**Key Points**
+
+- Name on booking must match your government-issued ID or passport.
+- Exact spelling is required for both ticket and travel documents.
+- Special requirements may apply for Canada, UAE, Australia, and New Zealand.`;
+
+      const suggestion = {
+        getId: () => 'sugg-complex',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          summarizationText: markdownText,
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#content-section',
+          },
+        }),
+      };
+
+      const patch = mapper.suggestionToPatch(suggestion, 'opp-complex');
+
+      expect(patch).to.exist;
+      expect(patch.value.children).to.be.an('array');
+      expect(patch.value.children.length).to.be.greaterThan(2);
+
+      // Should have paragraphs and list
+      const hasP = patch.value.children.some((child) => child.type === 'element' && child.tagName === 'p');
+      const hasList = patch.value.children.some((child) => child.type === 'element' && child.tagName === 'ul');
+      expect(hasP).to.be.true;
+      expect(hasList).to.be.true;
+    });
+
+    it('should handle markdown parsing errors gracefully', () => {
+      let errorMessage = '';
+      const errorLog = {
+        debug: () => {},
+        info: () => {},
+        warn: () => {},
+        error: (msg) => { errorMessage = msg; },
+      };
+
+      const errorMapper = new ContentMapper(errorLog);
+
+      // Stub the markdownToHast method to throw an error
+      const stub = sinon.stub(errorMapper, 'markdownToHast').throws(new Error('Markdown parsing failed'));
+
+      const suggestion = {
+        getId: () => 'sugg-error',
+        getData: () => ({
+          summarizationText: 'Some content',
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#selector',
+          },
+        }),
+      };
+
+      const patch = errorMapper.suggestionToPatch(suggestion, 'opp-error');
+
+      expect(patch).to.be.null;
+      expect(errorMessage).to.include('Failed to convert markdown to HAST');
+      expect(errorMessage).to.include('Markdown parsing failed');
+
+      stub.restore();
+    });
+  });
+});