@adobe/spacecat-shared-tokowaka-client 1.4.0 → 1.4.1

package/test/index.test.js

@@ -368,25 +368,6 @@ describe('TokowakaClient', () => {
       expect(command.input.Key).to.equal('opportunities/example.com/config');
     });
 
-    it('should fetch metaconfig from preview bucket', async () => {
-      const metaconfig = {
-        siteId: 'site-123',
-        prerender: true,
-      };
-
-      s3Client.send.resolves({
-        Body: {
-          transformToString: async () => JSON.stringify(metaconfig),
-        },
-      });
-
-      await client.fetchMetaconfig('https://example.com/page1', true);
-
-      const command = s3Client.send.firstCall.args[0];
-      expect(command.input.Bucket).to.equal('test-preview-bucket');
-      expect(command.input.Key).to.equal('preview/opportunities/example.com/config');
-    });
-
     it('should return null if metaconfig does not exist', async () => {
       const noSuchKeyError = new Error('NoSuchKey');
       noSuchKeyError.name = 'NoSuchKey';
@@ -441,20 +422,6 @@ describe('TokowakaClient', () => {
       expect(JSON.parse(command.input.Body)).to.deep.equal(metaconfig);
     });
 
-    it('should upload metaconfig to preview bucket', async () => {
-      const metaconfig = {
-        siteId: 'site-123',
-        prerender: true,
-      };
-
-      const s3Path = await client.uploadMetaconfig('https://example.com/page1', metaconfig, true);
-
-      expect(s3Path).to.equal('preview/opportunities/example.com/config');
-
-      const command = s3Client.send.firstCall.args[0];
-      expect(command.input.Bucket).to.equal('test-preview-bucket');
-    });
-
     it('should throw error if URL is missing', async () => {
       try {
         await client.uploadMetaconfig('', { siteId: 'site-123', prerender: true });
@@ -810,16 +777,19 @@ describe('TokowakaClient', () => {
 
   describe('deploySuggestions', () => {
     beforeEach(() => {
-      // Stub CDN invalidation for deploy tests
-      sinon.stub(client, 'invalidateCdnCache').resolves({
+      // Stub CDN invalidation for deploy tests (now handles both single and batch)
+      sinon.stub(client, 'invalidateCdnCache').resolves([{
         status: 'success',
         provider: 'cloudfront',
         invalidationId: 'I123',
-      });
+      }]);
       // Stub fetchConfig to return null by default (no existing config)
       sinon.stub(client, 'fetchConfig').resolves(null);
-      // Stub fetchMetaconfig to return null by default (will create new)
-      sinon.stub(client, 'fetchMetaconfig').resolves(null);
+      // Stub fetchMetaconfig to return existing metaconfig (required for deployment)
+      sinon.stub(client, 'fetchMetaconfig').resolves({
+        siteId: 'site-123',
+        prerender: true,
+      });
       // Stub uploadMetaconfig
       sinon.stub(client, 'uploadMetaconfig').resolves('opportunities/example.com/config');
     });
@@ -835,43 +805,28 @@ describe('TokowakaClient', () => {
       expect(result.s3Paths).to.be.an('array').with.length(1);
       expect(result.s3Paths[0]).to.equal('opportunities/example.com/L3BhZ2Ux');
       expect(result).to.have.property('cdnInvalidations');
+      // Only 1 invalidation result returned (for batch URLs)
+      // Metaconfig invalidation happens inside uploadMetaconfig() automatically
       expect(result.cdnInvalidations).to.be.an('array').with.length(1);
       expect(result.succeededSuggestions).to.have.length(2);
       expect(result.failedSuggestions).to.have.length(0);
       expect(s3Client.send).to.have.been.called;
     });
 
-    it('should create metaconfig on first deployment', async () => {
-      await client.deploySuggestions(
-        mockSite,
-        mockOpportunity,
-        mockSuggestions,
-      );
-
-      expect(client.fetchMetaconfig).to.have.been.calledOnce;
-      expect(client.uploadMetaconfig).to.have.been.calledOnce;
+    it('should throw error if metaconfig does not exist', async () => {
+      client.fetchMetaconfig.resolves(null);
 
-      const metaconfigArg = client.uploadMetaconfig.firstCall.args[1];
-      expect(metaconfigArg).to.deep.include({
-        siteId: 'site-123',
-        prerender: true,
-      });
-    });
-
-    it('should reuse existing metaconfig', async () => {
-      client.fetchMetaconfig.resolves({
-        siteId: 'site-123',
-        prerender: true,
-      });
-
-      await client.deploySuggestions(
-        mockSite,
-        mockOpportunity,
-        mockSuggestions,
-      );
-
-      expect(client.fetchMetaconfig).to.have.been.calledOnce;
-      expect(client.uploadMetaconfig).to.not.have.been.called;
+      try {
+        await client.deploySuggestions(
+          mockSite,
+          mockOpportunity,
+          mockSuggestions,
+        );
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('No domain-level metaconfig found');
+        expect(error.status).to.equal(400);
+      }
     });
 
     it('should handle suggestions for multiple URLs', async () => {
@@ -911,7 +866,9 @@ describe('TokowakaClient', () => {
       );
 
       expect(result.s3Paths).to.have.length(2);
-      expect(result.cdnInvalidations).to.have.length(2);
+      // Only 1 invalidation result returned (for batch URLs)
+      // Metaconfig invalidation happens inside uploadMetaconfig() automatically
+      expect(result.cdnInvalidations).to.have.length(1);
       expect(result.succeededSuggestions).to.have.length(2);
     });
 
@@ -1147,6 +1104,8 @@ describe('TokowakaClient', () => {
       expect(result.succeededSuggestions).to.have.length(1);
       expect(result.failedSuggestions).to.have.length(0);
       expect(result.s3Paths).to.have.length(1);
+      // Only 1 invalidation result returned (for batch URLs)
+      // Metaconfig invalidation happens inside uploadMetaconfig() automatically
       expect(result.cdnInvalidations).to.have.length(1);
 
       // Verify uploaded config has no patches but prerender is enabled
@@ -1155,12 +1114,12 @@ describe('TokowakaClient', () => {
       expect(uploadedConfig.prerender).to.equal(true);
       expect(uploadedConfig.url).to.equal('https://example.com/page1');
 
-      // Verify CDN was invalidated
+      // Verify CDN was invalidated using batch method with new options signature
       expect(client.invalidateCdnCache).to.have.been.calledOnce;
-      expect(client.invalidateCdnCache).to.have.been.calledWith(
-        'https://example.com/page1',
-        'cloudfront',
-      );
+      const invalidateCall = client.invalidateCdnCache.firstCall.args[0];
+      expect(invalidateCall).to.deep.include({
+        urls: ['https://example.com/page1'],
+      });
     });
 
     it('should throw error for unsupported opportunity type', async () => {
@@ -1254,12 +1213,12 @@ describe('TokowakaClient', () => {
 
   describe('rollbackSuggestions', () => {
     beforeEach(() => {
-      // Stub CDN invalidation for rollback tests
-      sinon.stub(client, 'invalidateCdnCache').resolves({
+      // Stub CDN invalidation for rollback tests (now handles both single and batch)
+      sinon.stub(client, 'invalidateCdnCache').resolves([{
         status: 'success',
         provider: 'cloudfront',
         invalidationId: 'I123',
-      });
+      }]);
     });
 
     it('should rollback suggestions successfully', async () => {
@@ -1375,12 +1334,12 @@ describe('TokowakaClient', () => {
       expect(uploadedConfig.patches).to.have.length(1);
       expect(uploadedConfig.patches[0].suggestionId).to.equal('other-sugg-1');
 
-      // Verify CDN was invalidated
+      // Verify CDN was invalidated using batch method with new options signature
       expect(client.invalidateCdnCache).to.have.been.calledOnce;
-      expect(client.invalidateCdnCache).to.have.been.calledWith(
-        'https://example.com/page1',
-        'cloudfront',
-      );
+      const invalidateCall = client.invalidateCdnCache.firstCall.args[0];
+      expect(invalidateCall).to.deep.include({
+        urls: ['https://example.com/page1'],
+      });
     });
 
     it('should handle no existing config gracefully', async () => {
@@ -1629,7 +1588,8 @@ describe('TokowakaClient', () => {
       );
 
       expect(result.s3Paths).to.have.length(2);
-      expect(result.cdnInvalidations).to.have.length(2);
+      // Batch invalidation returns 1 result per CDN provider, not per URL
+      expect(result.cdnInvalidations).to.have.length(1);
       expect(result.succeededSuggestions).to.have.length(2);
     });
 
@@ -2048,10 +2008,11 @@ describe('TokowakaClient', () => {
       );
 
       expect(client.invalidateCdnCache).to.have.been.calledOnce;
-      const { firstCall } = client.invalidateCdnCache;
-      expect(firstCall.args[0]).to.equal('https://example.com/page1');
-      expect(firstCall.args[1]).to.equal('cloudfront');
-      expect(firstCall.args[2]).to.be.true; // isPreview
+      const invalidateCall = client.invalidateCdnCache.firstCall.args[0];
+      expect(invalidateCall).to.deep.include({
+        urls: ['https://example.com/page1'],
+        isPreview: true,
+      });
     });
 
     it('should throw error if suggestions span multiple URLs', async () => {
@@ -2118,9 +2079,12 @@ describe('TokowakaClient', () => {
     });
 
     it('should invalidate CDN cache successfully', async () => {
-      const result = await client.invalidateCdnCache('https://example.com/page1', 'cloudfront');
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: 'cloudfront' });
 
-      expect(result).to.deep.equal({
+      // Now returns array with one result per provider
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.deep.equal({
         status: 'success',
         provider: 'cloudfront',
         invalidationId: 'I123',
@@ -2129,63 +2093,299 @@ describe('TokowakaClient', () => {
       expect(mockCdnClient.invalidateCache).to.have.been.calledWith([
         '/opportunities/example.com/L3BhZ2Ux',
       ]);
-      expect(log.debug).to.have.been.calledWith(sinon.match(/Invalidating CDN cache/));
+      expect(log.info).to.have.been.calledWith(sinon.match(/Invalidating CDN cache/));
       expect(log.info).to.have.been.calledWith(sinon.match(/CDN cache invalidation completed/));
     });
 
     it('should invalidate CDN cache for preview path', async () => {
-      await client.invalidateCdnCache('https://example.com/page1', 'cloudfront', true);
+      await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: 'cloudfront', isPreview: true });
 
       expect(mockCdnClient.invalidateCache).to.have.been.calledWith([
         '/preview/opportunities/example.com/L3BhZ2Ux',
       ]);
     });
 
-    it('should throw error if URL is missing', async () => {
-      try {
-        await client.invalidateCdnCache('', 'cloudfront');
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.equal('URL and provider are required');
-        expect(error.status).to.equal(400);
-      }
+    it('should return empty array if URL array is empty', async () => {
+      const result = await client.invalidateCdnCache({ urls: [], providers: 'cloudfront' });
+      expect(result).to.deep.equal([]);
     });
 
-    it('should throw error if provider is missing', async () => {
-      try {
-        await client.invalidateCdnCache('https://example.com/page1', '');
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.equal('URL and provider are required');
-        expect(error.status).to.equal(400);
-      }
+    it('should return empty array if provider is missing', async () => {
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: '' });
+      expect(result).to.deep.equal([]);
+      expect(log.warn).to.have.been.calledWith('No CDN providers specified for cache invalidation');
     });
 
     it('should return error object if no CDN client available', async () => {
       client.cdnClientRegistry.getClient.returns(null);
 
-      const result = await client.invalidateCdnCache('https://example.com/page1', 'cloudfront');
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: 'cloudfront' });
 
-      expect(result).to.deep.equal({
+      // Now returns array with one result per provider
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.deep.equal({
         status: 'error',
         provider: 'cloudfront',
         message: 'No CDN client available for provider: cloudfront',
       });
-      expect(log.error).to.have.been.calledWith(sinon.match(/Failed to invalidate Tokowaka CDN cache/));
     });
 
     it('should return error object if CDN invalidation fails', async () => {
       mockCdnClient.invalidateCache.rejects(new Error('CDN API error'));
 
-      const result = await client.invalidateCdnCache('https://example.com/page1', 'cloudfront');
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: 'cloudfront' });
 
-      expect(result).to.deep.equal({
+      // Now returns array with one result per provider
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.deep.equal({
         status: 'error',
         provider: 'cloudfront',
         message: 'CDN API error',
       });
 
-      expect(log.error).to.have.been.calledWith(sinon.match(/Failed to invalidate Tokowaka CDN cache/));
+      expect(log.warn).to.have.been.calledWith(sinon.match(/Failed to invalidate cloudfront CDN cache/));
+    });
+  });
+
+  describe('invalidateCdnCache (batch/multiple URLs)', () => {
+    let mockCdnClient;
+
+    beforeEach(() => {
+      mockCdnClient = {
+        invalidateCache: sinon.stub().resolves({
+          status: 'success',
+          provider: 'cloudfront',
+          invalidationId: 'I123',
+        }),
+      };
+
+      sinon.stub(client.cdnClientRegistry, 'getClient').returns(mockCdnClient);
+    });
+
+    it('should invalidate CDN cache for multiple URLs (batch)', async () => {
+      const urls = [
+        'https://example.com/page1',
+        'https://example.com/page2',
+        'https://example.com/page3',
+      ];
+
+      // Pass array of URLs for batch invalidation
+      const result = await client.invalidateCdnCache({ urls, providers: 'cloudfront' });
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.deep.equal({
+        status: 'success',
+        provider: 'cloudfront',
+        invalidationId: 'I123',
+      });
+
+      expect(mockCdnClient.invalidateCache).to.have.been.calledWith([
+        '/opportunities/example.com/L3BhZ2Ux',
+        '/opportunities/example.com/L3BhZ2Uy',
+        '/opportunities/example.com/L3BhZ2Uz',
+      ]);
+      expect(log.info).to.have.been.calledWith(sinon.match(/Invalidating CDN cache for 3 path\(s\)/));
+    });
+
+    it('should return empty array for empty URLs array', async () => {
+      const result = await client.invalidateCdnCache({ urls: [], providers: 'cloudfront' });
+      expect(result).to.deep.equal([]);
+    });
+
+    it('should return empty array if providers is empty', async () => {
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: '' });
+      expect(result).to.deep.equal([]);
+      expect(log.warn).to.have.been.calledWith('No CDN providers specified for cache invalidation');
+    });
+
+    it('should return error object if no CDN client available', async () => {
+      client.cdnClientRegistry.getClient.returns(null);
+
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: 'cloudfront' });
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.deep.equal({
+        status: 'error',
+        provider: 'cloudfront',
+        message: 'No CDN client available for provider: cloudfront',
+      });
+    });
+
+    it('should return error object if CDN invalidation fails', async () => {
+      mockCdnClient.invalidateCache.rejects(new Error('CDN API error'));
+
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: 'cloudfront' });
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.deep.equal({
+        status: 'error',
+        provider: 'cloudfront',
+        message: 'CDN API error',
+      });
+    });
+
+    it('should handle multiple providers in parallel', async () => {
+      const mockFastlyClient = {
+        invalidateCache: sinon.stub().resolves({
+          status: 'success',
+          provider: 'fastly',
+          purgeId: 'F456',
+        }),
+      };
+
+      client.cdnClientRegistry.getClient.withArgs('cloudfront').returns(mockCdnClient);
+      client.cdnClientRegistry.getClient.withArgs('fastly').returns(mockFastlyClient);
+
+      const result = await client.invalidateCdnCache({
+        urls: ['https://example.com/page1'],
+        providers: ['cloudfront', 'fastly'],
+      });
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(2);
+      expect(result[0].provider).to.equal('cloudfront');
+      expect(result[1].provider).to.equal('fastly');
+
+      expect(mockCdnClient.invalidateCache).to.have.been.calledOnce;
+      expect(mockFastlyClient.invalidateCache).to.have.been.calledOnce;
+    });
+
+    it('should handle errors from getClient', async () => {
+      // Simulate an error when getting the CDN client
+      client.cdnClientRegistry.getClient.restore();
+      sinon.stub(client.cdnClientRegistry, 'getClient').throws(new Error('Unexpected error'));
+
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: 'cloudfront' });
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+      expect(result[0]).to.deep.equal({
+        status: 'error',
+        provider: 'cloudfront',
+        message: 'Unexpected error',
+      });
+
+      // Error is caught in provider-specific error handler
+      expect(log.warn).to.have.been.calledWith(sinon.match(/Failed to invalidate cloudfront CDN cache/));
+    });
+
+    it('should handle empty CDN provider config', async () => {
+      // Test with existing client but passing no providers
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: [] });
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(0);
+      expect(log.warn).to.have.been.calledWith('No CDN providers specified for cache invalidation');
+    });
+
+    it('should handle multiple providers passed as array', async () => {
+      const mockFastlyClient = {
+        invalidateCache: sinon.stub().resolves({
+          status: 'success',
+          provider: 'fastly',
+        }),
+      };
+
+      client.cdnClientRegistry.getClient.restore();
+      sinon.stub(client.cdnClientRegistry, 'getClient')
+        .withArgs('cloudfront')
+        .returns(mockCdnClient)
+        .withArgs('fastly')
+        .returns(mockFastlyClient);
+
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: ['cloudfront', 'fastly'] });
+
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(2);
+      expect(mockCdnClient.invalidateCache).to.have.been.calledOnce;
+      expect(mockFastlyClient.invalidateCache).to.have.been.calledOnce;
+    });
+
+    it('should handle empty paths after filtering', async () => {
+      // Call the method with URLs to test path generation
+      const result = await client.invalidateCdnCache({ urls: ['https://example.com/page1'], providers: 'cloudfront' });
+
+      // Should successfully invalidate (paths are generated from URL)
+      expect(result).to.be.an('array');
+      expect(result).to.have.lengthOf(1);
+    });
+  });
+
+  describe('#getCdnProviders (edge cases)', () => {
+    it('should handle missing CDN provider config (lines 105-106)', async () => {
+      // Temporarily remove TOKOWAKA_CDN_PROVIDER to test early return
+      const originalProvider = client.env.TOKOWAKA_CDN_PROVIDER;
+      delete client.env.TOKOWAKA_CDN_PROVIDER;
+
+      // Call uploadMetaconfig which uses #getCdnProviders internally
+      await client.uploadMetaconfig('https://example.com/page1', { siteId: 'test', prerender: true });
+
+      // No CDN invalidation should happen (no providers configured)
+      expect(log.warn).to.have.been.calledWith('No CDN providers specified for cache invalidation');
+
+      // Restore
+      client.env.TOKOWAKA_CDN_PROVIDER = originalProvider;
+    });
+
+    it('should handle array provider config with falsy values (line 111)', async () => {
+      // Temporarily modify env to test array filtering
+      const originalProvider = client.env.TOKOWAKA_CDN_PROVIDER;
+      client.env.TOKOWAKA_CDN_PROVIDER = ['cloudfront', '', null, undefined]; // Array with falsy values
+
+      const mockCloudFrontClient = {
+        invalidateCache: sinon.stub().resolves({
+          status: 'success',
+          provider: 'cloudfront',
+        }),
+      };
+
+      sinon.stub(client.cdnClientRegistry, 'getClient')
+        .withArgs('cloudfront')
+        .returns(mockCloudFrontClient);
+
+      // Call uploadMetaconfig which uses #getCdnProviders internally
+      await client.uploadMetaconfig('https://example.com/page1', { siteId: 'test', prerender: true });
+
+      // Should only use 'cloudfront' (falsy values filtered out)
+      expect(mockCloudFrontClient.invalidateCache).to.have.been.calledOnce;
+
+      // Restore
+      client.env.TOKOWAKA_CDN_PROVIDER = originalProvider;
+    });
+
+    it('should handle invalid CDN provider type - number (lines 120-121)', async () => {
+      // Temporarily modify env to test invalid type
+      const originalProvider = client.env.TOKOWAKA_CDN_PROVIDER;
+      client.env.TOKOWAKA_CDN_PROVIDER = 12345; // Invalid type (number)
+
+      // Call uploadMetaconfig which uses #getCdnProviders internally
+      await client.uploadMetaconfig('https://example.com/page1', { siteId: 'test', prerender: true });
+
+      // No CDN invalidation should happen (no providers)
+      expect(log.warn).to.have.been.calledWith('No CDN providers specified for cache invalidation');
+
+      // Restore
+      client.env.TOKOWAKA_CDN_PROVIDER = originalProvider;
+    });
+
+    it('should handle invalid CDN provider type - object (lines 120-121)', async () => {
+      // Temporarily modify env to test invalid type
+      const originalProvider = client.env.TOKOWAKA_CDN_PROVIDER;
+      client.env.TOKOWAKA_CDN_PROVIDER = { key: 'value' }; // Invalid type (object)
+
+      // Call uploadMetaconfig which uses #getCdnProviders internally
+      await client.uploadMetaconfig('https://example.com/page1', { siteId: 'test', prerender: true });
+
+      // No CDN invalidation should happen (no providers)
+      expect(log.warn).to.have.been.calledWith('No CDN providers specified for cache invalidation');
+
+      // Restore
+      client.env.TOKOWAKA_CDN_PROVIDER = originalProvider;
     });
   });
 });

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

@@ -663,6 +663,36 @@ describe('GenericMapper', () => {
       expect(patch.valueFormat).to.equal('hast');
     });
 
+    it('should parse JSON patchValue when format is json', () => {
+      const jsonValue = {
+        title: 'Test Title',
+        description: 'Test description',
+        metadata: { key: 'value' },
+      };
+
+      const suggestion = {
+        getId: () => 'sugg-json-format',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          transformRules: {
+            action: 'replace',
+            selector: '.content',
+          },
+          patchValue: JSON.stringify(jsonValue),
+          format: 'json',
+          url: 'https://example.com/page',
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/page', [suggestion], 'opp-json');
+
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      expect(patch.value).to.deep.equal(jsonValue);
+      expect(patch.valueFormat).to.equal('json');
+    });
+
     it('should use raw patchValue when format is not hast', () => {
       const suggestion = {
         getId: () => 'sugg-text',
@@ -686,6 +716,58 @@ describe('GenericMapper', () => {
       expect(patch.valueFormat).to.equal('text');
     });
 
+    it('should parse and include attrs when provided', () => {
+      const attrs = {
+        id: 'custom-id',
+        class: 'custom-class',
+        'data-test': 'test-value',
+      };
+
+      const suggestion = {
+        getId: () => 'sugg-with-attrs',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#selector',
+          },
+          patchValue: 'Content with attributes',
+          attrs: JSON.stringify(attrs),
+          url: 'https://example.com/page',
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/page', [suggestion], 'opp-attrs');
+
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      expect(patch.attrs).to.deep.equal(attrs);
+      expect(patch.value).to.equal('Content with attributes');
+    });
+
+    it('should not include attrs when not provided', () => {
+      const suggestion = {
+        getId: () => 'sugg-no-attrs',
+        getUpdatedAt: () => '2025-01-15T10:00:00.000Z',
+        getData: () => ({
+          transformRules: {
+            action: 'insertAfter',
+            selector: '#selector',
+          },
+          patchValue: 'Content without attributes',
+          url: 'https://example.com/page',
+        }),
+      };
+
+      const patches = mapper.suggestionsToPatches('/page', [suggestion], 'opp-no-attrs');
+
+      expect(patches.length).to.equal(1);
+      const patch = patches[0];
+
+      expect(patch.attrs).to.be.undefined;
+    });
+
     it('should not include UI-only fields in patch', () => {
       const suggestion = {
         getId: () => 'sugg-ui',