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

package/test/utils/s3-utils.test.js

@@ -0,0 +1,140 @@
+/*
+ * 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 {
+  normalizePath,
+  getHostName,
+  base64UrlEncode,
+  getTokowakaConfigS3Path,
+  getTokowakaMetaconfigS3Path,
+} from '../../src/utils/s3-utils.js';
+
+describe('S3 Utils', () => {
+  describe('normalizePath', () => {
+    it('should add leading slash if missing', () => {
+      const result = normalizePath('page1');
+      expect(result).to.equal('/page1');
+    });
+
+    it('should keep single slash', () => {
+      const result = normalizePath('/');
+      expect(result).to.equal('/');
+    });
+
+    it('should remove trailing slash except for root', () => {
+      const result = normalizePath('/page1/');
+      expect(result).to.equal('/page1');
+    });
+
+    it('should handle path with leading slash', () => {
+      const result = normalizePath('/page1');
+      expect(result).to.equal('/page1');
+    });
+  });
+
+  describe('getHostName', () => {
+    it('should extract hostname and remove www', () => {
+      const url = new URL('https://www.example.com/page');
+      const logger = { error: () => {} };
+      const result = getHostName(url, logger);
+      expect(result).to.equal('example.com');
+    });
+
+    it('should handle hostname without www', () => {
+      const url = new URL('https://example.com/page');
+      const logger = { error: () => {} };
+      const result = getHostName(url, logger);
+      expect(result).to.equal('example.com');
+    });
+
+    it('should throw error on invalid URL', () => {
+      const logger = { error: () => {} };
+      const invalidUrl = { hostname: null };
+
+      try {
+        getHostName(invalidUrl, logger);
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Error extracting host name');
+      }
+    });
+  });
+
+  describe('getTokowakaConfigS3Path', () => {
+    const logger = { error: () => {} };
+
+    it('should generate correct S3 path for deploy', () => {
+      const url = 'https://example.com/page1';
+      const result = getTokowakaConfigS3Path(url, logger, false);
+      expect(result).to.equal('opportunities/example.com/L3BhZ2Ux');
+    });
+
+    it('should generate correct S3 path for preview', () => {
+      const url = 'https://example.com/page1';
+      const result = getTokowakaConfigS3Path(url, logger, true);
+      expect(result).to.equal('preview/opportunities/example.com/L3BhZ2Ux');
+    });
+
+    it('should throw error on invalid URL', () => {
+      try {
+        getTokowakaConfigS3Path('not-a-valid-url', logger, false);
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Failed to generate S3 path');
+      }
+    });
+  });
+
+  describe('getTokowakaMetaconfigS3Path', () => {
+    it('should generate correct metaconfig S3 path for deploy', () => {
+      const url = 'https://example.com/page1';
+      const logger = { error: () => {} };
+      const result = getTokowakaMetaconfigS3Path(url, logger, false);
+      expect(result).to.equal('opportunities/example.com/config');
+    });
+
+    it('should generate correct metaconfig S3 path for preview', () => {
+      const url = 'https://example.com/page1';
+      const logger = { error: () => {} };
+      const result = getTokowakaMetaconfigS3Path(url, logger, true);
+      expect(result).to.equal('preview/opportunities/example.com/config');
+    });
+
+    it('should throw error on invalid URL', () => {
+      const logger = { error: () => {} };
+
+      try {
+        getTokowakaMetaconfigS3Path('not-a-valid-url', logger, false);
+        expect.fail('Should have thrown error');
+      } catch (error) {
+        expect(error.message).to.include('Failed to generate metaconfig S3 path');
+      }
+    });
+  });
+
+  describe('base64UrlEncode', () => {
+    it('should encode string to base64url', () => {
+      const result = base64UrlEncode('/page1');
+      expect(result).to.equal('L3BhZ2Ux');
+    });
+
+    it('should handle special characters', () => {
+      const result = base64UrlEncode('/page?query=1');
+      // Should replace + with - and / with _
+      expect(result).to.not.include('+');
+      expect(result).to.not.include('=');
+    });
+  });
+});

package/test/utils/site-utils.test.js

@@ -0,0 +1,80 @@
+/*
+ * 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 { getEffectiveBaseURL } from '../../src/utils/site-utils.js';
+
+describe('Site Utils', () => {
+  describe('getEffectiveBaseURL', () => {
+    it('should return site baseURL when no override', () => {
+      const site = {
+        getBaseURL: () => 'https://example.com',
+        getConfig: () => ({
+          getFetchConfig: () => ({}),
+        }),
+      };
+
+      const result = getEffectiveBaseURL(site);
+      expect(result).to.equal('https://example.com');
+    });
+
+    it('should return override baseURL when valid', () => {
+      const site = {
+        getBaseURL: () => 'https://example.com',
+        getConfig: () => ({
+          getFetchConfig: () => ({
+            overrideBaseURL: 'https://override.com',
+          }),
+        }),
+      };
+
+      const result = getEffectiveBaseURL(site);
+      expect(result).to.equal('https://override.com');
+    });
+
+    it('should return site baseURL when override is invalid', () => {
+      const site = {
+        getBaseURL: () => 'https://example.com',
+        getConfig: () => ({
+          getFetchConfig: () => ({
+            overrideBaseURL: 'not-a-valid-url',
+          }),
+        }),
+      };
+
+      const result = getEffectiveBaseURL(site);
+      expect(result).to.equal('https://example.com');
+    });
+
+    it('should handle missing getFetchConfig', () => {
+      const site = {
+        getBaseURL: () => 'https://example.com',
+        getConfig: () => ({}),
+      };
+
+      const result = getEffectiveBaseURL(site);
+      expect(result).to.equal('https://example.com');
+    });
+
+    it('should handle missing config', () => {
+      const site = {
+        getBaseURL: () => 'https://example.com',
+        getConfig: () => null,
+      };
+
+      const result = getEffectiveBaseURL(site);
+      expect(result).to.equal('https://example.com');
+    });
+  });
+});

package/test/utils/suggestion-utils.test.js

@@ -0,0 +1,187 @@
+/*
+ * 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 { groupSuggestionsByUrlPath, filterEligibleSuggestions } from '../../src/utils/suggestion-utils.js';
+
+describe('Suggestion Utils', () => {
+  describe('groupSuggestionsByUrlPath', () => {
+    const log = {
+      warn: () => {},
+      debug: () => {},
+    };
+
+    it('should group suggestions by URL path', () => {
+      const suggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({ url: 'https://example.com/page1' }),
+        },
+        {
+          getId: () => 'sugg-2',
+          getData: () => ({ url: 'https://example.com/page1' }),
+        },
+        {
+          getId: () => 'sugg-3',
+          getData: () => ({ url: 'https://example.com/page2' }),
+        },
+      ];
+
+      const result = groupSuggestionsByUrlPath(suggestions, 'https://example.com', log);
+
+      expect(result).to.have.property('/page1');
+      expect(result).to.have.property('/page2');
+      expect(result['/page1']).to.have.lengthOf(2);
+      expect(result['/page2']).to.have.lengthOf(1);
+    });
+
+    it('should skip suggestions without URL', () => {
+      const suggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({}), // No URL
+        },
+        {
+          getId: () => 'sugg-2',
+          getData: () => ({ url: 'https://example.com/page1' }),
+        },
+      ];
+
+      const result = groupSuggestionsByUrlPath(suggestions, 'https://example.com', log);
+
+      expect(result).to.not.have.property('undefined');
+      expect(result).to.have.property('/page1');
+      expect(result['/page1']).to.have.lengthOf(1);
+    });
+
+    it('should skip suggestions with invalid URL', () => {
+      const suggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({ url: 'not-a-valid-url' }),
+        },
+        {
+          getId: () => 'sugg-2',
+          getData: () => ({ url: 'https://example.com/page1' }),
+        },
+      ];
+
+      const result = groupSuggestionsByUrlPath(suggestions, 'https://example.com', log);
+
+      expect(result).to.have.property('/page1');
+      expect(result['/page1']).to.have.lengthOf(1);
+    });
+
+    it('should skip suggestions with malformed URL that throws', () => {
+      const suggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({ url: 'http://[invalid' }), // Malformed URL that will throw
+        },
+        {
+          getId: () => 'sugg-2',
+          getData: () => ({ url: 'https://example.com/page1' }),
+        },
+      ];
+
+      const result = groupSuggestionsByUrlPath(suggestions, 'invalid-base', log);
+
+      // Should skip sugg-1 due to URL parsing error
+      expect(Object.keys(result)).to.have.lengthOf(0); // Both fail due to invalid base
+    });
+  });
+
+  describe('filterEligibleSuggestions', () => {
+    const mapper = {
+      canDeploy: (suggestion) => {
+        const data = suggestion.getData();
+        if (data.shouldDeploy) {
+          return { eligible: true };
+        }
+        return { eligible: false, reason: 'Not eligible' };
+      },
+    };
+
+    it('should filter eligible and ineligible suggestions', () => {
+      const suggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({ shouldDeploy: true }),
+        },
+        {
+          getId: () => 'sugg-2',
+          getData: () => ({ shouldDeploy: false }),
+        },
+      ];
+
+      const result = filterEligibleSuggestions(suggestions, mapper);
+
+      expect(result.eligible).to.have.lengthOf(1);
+      expect(result.ineligible).to.have.lengthOf(1);
+      expect(result.eligible[0].getId()).to.equal('sugg-1');
+      expect(result.ineligible[0].suggestion.getId()).to.equal('sugg-2');
+      expect(result.ineligible[0].reason).to.equal('Not eligible');
+    });
+
+    it('should handle all eligible suggestions', () => {
+      const suggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({ shouldDeploy: true }),
+        },
+        {
+          getId: () => 'sugg-2',
+          getData: () => ({ shouldDeploy: true }),
+        },
+      ];
+
+      const result = filterEligibleSuggestions(suggestions, mapper);
+
+      expect(result.eligible).to.have.lengthOf(2);
+      expect(result.ineligible).to.have.lengthOf(0);
+    });
+
+    it('should handle all ineligible suggestions', () => {
+      const suggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({ shouldDeploy: false }),
+        },
+      ];
+
+      const result = filterEligibleSuggestions(suggestions, mapper);
+
+      expect(result.eligible).to.have.lengthOf(0);
+      expect(result.ineligible).to.have.lengthOf(1);
+    });
+
+    it('should use default reason when eligibility.reason is empty', () => {
+      const mapperWithoutReason = {
+        canDeploy: () => ({ eligible: false }), // No reason provided
+      };
+
+      const suggestions = [
+        {
+          getId: () => 'sugg-1',
+          getData: () => ({}),
+        },
+      ];
+
+      const result = filterEligibleSuggestions(suggestions, mapperWithoutReason);
+
+      expect(result.ineligible).to.have.lengthOf(1);
+      expect(result.ineligible[0].reason).to.equal('Suggestion cannot be deployed');
+    });
+  });
+});