@adobe/spacecat-shared-tokowaka-client 1.1.1 → 1.2.0

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

@@ -41,9 +41,9 @@ describe('BaseOpportunityMapper', () => {
         .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('suggestionsToPatches should throw error', () => {
+      expect(() => mapper.suggestionsToPatches('/path', [], 'opp-123', null))
+        .to.throw('suggestionsToPatches() must be implemented by subclass');
     });
 
     it('canDeploy should throw error if not implemented', () => {
@@ -60,14 +60,15 @@ describe('BaseOpportunityMapper', () => {
 
         requiresPrerender() { return true; }
 
-        suggestionToPatch() { return {}; }
+        suggestionsToPatches() { return []; }
 
         canDeploy() { return { eligible: true }; }
       }
 
-      const testMapper = new TestMapper();
+      const testMapper = new TestMapper(log);
       const suggestion = {
         getId: () => 'test-123',
+        getData: () => ({}),
         getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
       };
 
@@ -85,14 +86,15 @@ describe('BaseOpportunityMapper', () => {
 
         requiresPrerender() { return true; }
 
-        suggestionToPatch() { return {}; }
+        suggestionsToPatches() { return []; }
 
         canDeploy() { return { eligible: true }; }
       }
 
-      const testMapper = new TestMapper();
+      const testMapper = new TestMapper(log);
       const suggestion = {
         getId: () => 'test-no-date',
+        getData: () => ({}),
         getUpdatedAt: () => null, // Returns null
       };
 
@@ -106,5 +108,246 @@ describe('BaseOpportunityMapper', () => {
       expect(patch.lastUpdated).to.be.at.most(afterTime);
       expect(patch.prerenderRequired).to.be.true;
     });
+
+    it('should prioritize scrapedAt from getData()', () => {
+      class TestMapper extends BaseOpportunityMapper {
+        getOpportunityType() { return 'test'; }
+
+        requiresPrerender() { return true; }
+
+        suggestionsToPatches() { return []; }
+
+        canDeploy() { return { eligible: true }; }
+      }
+
+      const testMapper = new TestMapper(log);
+      const scrapedTime = '2025-01-20T15:30:00.000Z';
+      const suggestion = {
+        getId: () => 'test-scraped',
+        getData: () => ({ scrapedAt: scrapedTime }),
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+      };
+
+      const patch = testMapper.createBasePatch(suggestion, 'opp-scraped');
+
+      expect(patch.lastUpdated).to.equal(new Date(scrapedTime).getTime());
+    });
+
+    it('should use transformRules.scrapedAt when scrapedAt is not available', () => {
+      class TestMapper extends BaseOpportunityMapper {
+        getOpportunityType() { return 'test'; }
+
+        requiresPrerender() { return true; }
+
+        suggestionsToPatches() { return []; }
+
+        canDeploy() { return { eligible: true }; }
+      }
+
+      const testMapper = new TestMapper(log);
+      const transformScrapedTime = '2025-01-18T12:00:00.000Z';
+      const suggestion = {
+        getId: () => 'test-transform',
+        getData: () => ({ transformRules: { scrapedAt: transformScrapedTime } }),
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+      };
+
+      const patch = testMapper.createBasePatch(suggestion, 'opp-transform');
+
+      expect(patch.lastUpdated).to.equal(new Date(transformScrapedTime).getTime());
+    });
+
+    it('should handle invalid date strings by using Date.now()', () => {
+      class TestMapper extends BaseOpportunityMapper {
+        getOpportunityType() { return 'test'; }
+
+        requiresPrerender() { return true; }
+
+        suggestionsToPatches() { return []; }
+
+        canDeploy() { return { eligible: true }; }
+      }
+
+      const testMapper = new TestMapper(log);
+      const suggestion = {
+        getId: () => 'test-invalid',
+        getData: () => ({}),
+        getUpdatedAt: () => 'invalid-date-string',
+      };
+
+      const beforeTime = Date.now();
+      const patch = testMapper.createBasePatch(suggestion, 'opp-invalid');
+      const afterTime = Date.now();
+
+      // Should fallback to Date.now() for invalid dates
+      expect(patch.lastUpdated).to.be.at.least(beforeTime);
+      expect(patch.lastUpdated).to.be.at.most(afterTime);
+    });
+
+    it('should handle missing getData() gracefully', () => {
+      class TestMapper extends BaseOpportunityMapper {
+        getOpportunityType() { return 'test'; }
+
+        requiresPrerender() { return true; }
+
+        suggestionsToPatches() { return []; }
+
+        canDeploy() { return { eligible: true }; }
+      }
+
+      const testMapper = new TestMapper(log);
+      const suggestion = {
+        getId: () => 'test-no-data',
+        getData: () => null,
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+      };
+
+      const patch = testMapper.createBasePatch(suggestion, 'opp-no-data');
+
+      expect(patch.lastUpdated).to.equal(new Date('2025-01-15T10:00:00.000Z').getTime());
+    });
+  });
+
+  describe('rollbackPatches', () => {
+    let testMapper;
+
+    beforeEach(() => {
+      class TestMapper extends BaseOpportunityMapper {
+        getOpportunityType() { return 'test'; }
+
+        requiresPrerender() { return true; }
+
+        suggestionsToPatches() { return []; }
+
+        canDeploy() { return { eligible: true }; }
+      }
+
+      testMapper = new TestMapper(log);
+    });
+
+    it('should remove patches by suggestion IDs using default implementation', () => {
+      const config = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            opportunityId: 'opp-test',
+            suggestionId: 'sugg-1',
+            op: 'replace',
+            value: 'value-1',
+          },
+          {
+            opportunityId: 'opp-test',
+            suggestionId: 'sugg-2',
+            op: 'replace',
+            value: 'value-2',
+          },
+        ],
+      };
+
+      const result = testMapper.rollbackPatches(config, ['sugg-1'], 'opp-test');
+
+      expect(result.patches).to.have.lengthOf(1);
+      expect(result.patches[0].suggestionId).to.equal('sugg-2');
+      expect(result.removedCount).to.equal(1);
+    });
+
+    it('should handle null/undefined config gracefully', () => {
+      const result1 = testMapper.rollbackPatches(null, ['sugg-1'], 'opp-test');
+      expect(result1).to.be.null;
+
+      const result2 = testMapper.rollbackPatches(undefined, ['sugg-1'], 'opp-test');
+      expect(result2).to.be.undefined;
+    });
+
+    it('should remove patches for multiple suggestion IDs', () => {
+      const config = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            opportunityId: 'opp-test',
+            suggestionId: 'sugg-1',
+            op: 'replace',
+            value: 'value-1',
+          },
+          {
+            opportunityId: 'opp-test',
+            suggestionId: 'sugg-2',
+            op: 'replace',
+            value: 'value-2',
+          },
+          {
+            opportunityId: 'opp-test',
+            suggestionId: 'sugg-3',
+            op: 'replace',
+            value: 'value-3',
+          },
+        ],
+      };
+
+      const result = testMapper.rollbackPatches(config, ['sugg-1', 'sugg-3'], 'opp-test');
+
+      expect(result.patches).to.have.lengthOf(1);
+      expect(result.patches[0].suggestionId).to.equal('sugg-2');
+      expect(result.removedCount).to.equal(2);
+    });
+
+    it('should remove URL path when all patches are removed', () => {
+      const config = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            opportunityId: 'opp-test',
+            suggestionId: 'sugg-1',
+            op: 'replace',
+            value: 'value-1',
+          },
+        ],
+      };
+
+      const result = testMapper.rollbackPatches(config, ['sugg-1'], 'opp-test');
+
+      // All patches removed, patches array should be empty
+      expect(result.patches).to.have.lengthOf(0);
+      expect(result.removedCount).to.equal(1);
+    });
+
+    it('should preserve patches from other opportunities', () => {
+      const config = {
+        url: 'https://example.com/page1',
+        version: '1.0',
+        forceFail: false,
+        prerender: true,
+        patches: [
+          {
+            opportunityId: 'opp-test',
+            suggestionId: 'sugg-1',
+            op: 'replace',
+            value: 'test-value',
+          },
+          {
+            opportunityId: 'opp-other',
+            suggestionId: 'sugg-2',
+            op: 'replace',
+            value: 'other-value',
+          },
+        ],
+      };
+
+      // Default implementation removes by suggestionId regardless of opportunity
+      const result = testMapper.rollbackPatches(config, ['sugg-1'], 'opp-test');
+
+      expect(result.patches).to.have.lengthOf(1);
+      expect(result.patches[0].suggestionId).to.equal('sugg-2');
+      expect(result.removedCount).to.equal(1);
+    });
   });
 });

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

@@ -13,7 +13,6 @@
 /* eslint-env mocha */
 
 import { expect } from 'chai';
-import sinon from 'sinon';
 import ContentMapper from '../../src/mappers/content-summarization-mapper.js';
 
 describe('ContentMapper', () => {
@@ -142,7 +141,7 @@ describe('ContentMapper', () => {
     });
   });
 
-  describe('suggestionToPatch', () => {
+  describe('suggestionsToPatches', () => {
     it('should create patch with HAST value from markdown', () => {
       const suggestion = {
         getId: () => 'sugg-content-123',
@@ -156,7 +155,9 @@ describe('ContentMapper', () => {
         }),
       };
 
-      const patch = mapper.suggestionToPatch(suggestion, 'opp-content-123');
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-content-123');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
 
       expect(patch).to.exist;
       expect(patch.op).to.equal('insertAfter');
@@ -187,7 +188,9 @@ describe('ContentMapper', () => {
         }),
       };
 
-      const patch = mapper.suggestionToPatch(suggestion, 'opp-bold');
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-bold');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
 
       expect(patch).to.exist;
       expect(patch.value.type).to.equal('root');
@@ -216,7 +219,9 @@ describe('ContentMapper', () => {
         }),
       };
 
-      const patch = mapper.suggestionToPatch(suggestion, 'opp-heading');
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-heading');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
 
       expect(patch).to.exist;
       expect(patch.value.children).to.be.an('array');
@@ -241,7 +246,9 @@ describe('ContentMapper', () => {
         }),
       };
 
-      const patch = mapper.suggestionToPatch(suggestion, 'opp-list');
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-list');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
 
       expect(patch).to.exist;
 
@@ -250,7 +257,7 @@ describe('ContentMapper', () => {
       expect(hasList).to.be.true;
     });
 
-    it('should return null when summarizationText is missing', () => {
+    it('should return empty array when summarizationText is missing', () => {
       const suggestion = {
         getId: () => 'sugg-invalid',
         getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
@@ -262,12 +269,11 @@ describe('ContentMapper', () => {
         }),
       };
 
-      const patch = mapper.suggestionToPatch(suggestion, 'opp-invalid');
-
-      expect(patch).to.be.null;
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-invalid');
+      expect(patches.length).to.equal(0);
     });
 
-    it('should return null when transformRules are incomplete', () => {
+    it('should return empty array when transformRules are incomplete', () => {
       const suggestion = {
         getId: () => 'sugg-invalid-2',
         getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
@@ -279,9 +285,8 @@ describe('ContentMapper', () => {
         }),
       };
 
-      const patch = mapper.suggestionToPatch(suggestion, 'opp-invalid-2');
-
-      expect(patch).to.be.null;
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-invalid-2');
+      expect(patches.length).to.equal(0);
     });
 
     it('should handle complex markdown with multiple elements', () => {
@@ -305,7 +310,9 @@ describe('ContentMapper', () => {
         }),
       };
 
-      const patch = mapper.suggestionToPatch(suggestion, 'opp-complex');
+      const patches = mapper.suggestionsToPatches('/path', [suggestion], 'opp-complex');
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
 
       expect(patch).to.exist;
       expect(patch.value.children).to.be.an('array');
@@ -329,13 +336,11 @@ describe('ContentMapper', () => {
 
       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'));
-
+      // Pass an object instead of string to trigger natural error in markdown parser
       const suggestion = {
         getId: () => 'sugg-error',
         getData: () => ({
-          summarizationText: 'Some content',
+          summarizationText: { invalid: 'object' }, // This will cause markdown parser to fail
           transformRules: {
             action: 'insertAfter',
             selector: '#selector',
@@ -343,13 +348,10 @@ describe('ContentMapper', () => {
         }),
       };
 
-      const patch = errorMapper.suggestionToPatch(suggestion, 'opp-error');
+      const patches = errorMapper.suggestionsToPatches('/path', [suggestion], 'opp-error');
 
-      expect(patch).to.be.null;
+      expect(patches.length).to.equal(0);
       expect(errorMessage).to.include('Failed to convert markdown to HAST');
-      expect(errorMessage).to.include('Markdown parsing failed');
-
-      stub.restore();
     });
   });
 });