@adobe/spacecat-shared-tokowaka-client 1.6.0 → 1.7.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [@adobe/spacecat-shared-tokowaka-client-v1.7.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.6.1...@adobe/spacecat-shared-tokowaka-client-v1.7.0) (2026-02-02)
+
+
+### Features
+
+* edge optimize status api addition ([#1292](https://github.com/adobe/spacecat-shared/issues/1292)) ([f2c89be](https://github.com/adobe/spacecat-shared/commit/f2c89be3fb4fb2580a13a3a3f7517ce92cf1ce69))
+
+# [@adobe/spacecat-shared-tokowaka-client-v1.6.1](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.6.0...@adobe/spacecat-shared-tokowaka-client-v1.6.1) (2026-01-30)
+
+
+### Bug Fixes
+
+* api key now optional for edge-preview ([#1299](https://github.com/adobe/spacecat-shared/issues/1299)) ([76eb046](https://github.com/adobe/spacecat-shared/commit/76eb04640dab752a83909a51827abde1e41fc57e))
+
 # [@adobe/spacecat-shared-tokowaka-client-v1.6.0](https://github.com/adobe/spacecat-shared/compare/@adobe/spacecat-shared-tokowaka-client-v1.5.8...@adobe/spacecat-shared-tokowaka-client-v1.6.0) (2026-01-29)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/spacecat-shared-tokowaka-client",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "Tokowaka Client for SpaceCat - Edge optimization config management",
   "type": "module",
   "engines": {

package/src/index.js

@@ -913,26 +913,13 @@ class TokowakaClient {
     }
 
     // Fetch metaconfig to get API key
-    const metaconfig = await this.fetchMetaconfig(previewUrl);
+    const metaconfig = await this.fetchMetaconfig(previewUrl) || {};
 
-    if (!metaconfig) {
-      throw this.#createError(
-        'No domain-level metaconfig found. '
-        + 'A domain-level metaconfig needs to be created first before previewing suggestions.',
-        HTTP_INTERNAL_SERVER_ERROR,
-      );
+    let apiKey;
+    if (Array.isArray(metaconfig.apiKeys) && metaconfig.apiKeys.length > 0) {
+      [apiKey] = metaconfig.apiKeys;
     }
 
-    const { apiKeys } = metaconfig;
-    if (!Array.isArray(apiKeys) || apiKeys.length === 0 || !hasText(apiKeys[0])) {
-      throw this.#createError(
-        'Metaconfig does not have valid API keys configured. '
-        + 'Please ensure the metaconfig has at least one API key.',
-        HTTP_INTERNAL_SERVER_ERROR,
-      );
-    }
-
-    const apiKey = apiKeys[0];
     const forwardedHost = calculateForwardedHost(previewUrl, this.log);
 
     // Fetch existing deployed configuration for this URL from production S3
@@ -1036,6 +1023,85 @@ class TokowakaClient {
       },
     };
   }
+
+  /**
+   * Checks if Edge Optimize is enabled for a specific page path
+   * Follows one level of redirect and retries on failures
+   * @param {Object} site - Site entity
+   * @param {string} path - Path to check (e.g., '/products/chair')
+   * @returns {Promise<Object>} - Status result with edgeOptimizeEnabled flag
+   */
+  async checkEdgeOptimizeStatus(site, path) {
+    if (!isNonEmptyObject(site)) {
+      throw this.#createError('Site is required', HTTP_BAD_REQUEST);
+    }
+
+    if (!hasText(path)) {
+      throw this.#createError('Path is required', HTTP_BAD_REQUEST);
+    }
+
+    const baseURL = getEffectiveBaseURL(site);
+    const targetUrl = new URL(path, baseURL).toString();
+
+    this.log.info(`Checking edge optimize status for ${targetUrl}`);
+
+    const maxRetries = 3;
+    let attempt = 0;
+
+    while (attempt <= maxRetries) {
+      try {
+        this.log.debug(`Attempt ${attempt + 1}/${maxRetries + 1}: Checking edge optimize status for ${targetUrl}`);
+
+        // eslint-disable-next-line no-await-in-loop
+        const response = await fetch(targetUrl, {
+          method: 'GET',
+          headers: {
+            'User-Agent': 'chatgpt-user',
+            'fastly-debug': '1',
+          },
+        });
+
+        this.log.debug(`Response status: ${response.status}`);
+
+        const edgeOptimizeEnabled = response.headers.get('x-tokowaka-request-id') !== null
+          || response.headers.get('x-edgeoptimize-request-id') !== null;
+
+        this.log.debug(`Edge optimize headers found: ${edgeOptimizeEnabled}`);
+
+        return {
+          edgeOptimizeEnabled,
+        };
+      } catch (error) {
+        attempt += 1;
+
+        if (attempt > maxRetries) {
+          // All retries exhausted
+          this.log.error(`Failed after ${maxRetries + 1} attempts: ${error.message}`);
+          throw this.#createError(
+            `Failed to check edge optimize status: ${error.message}`,
+            HTTP_INTERNAL_SERVER_ERROR,
+          );
+        }
+
+        // Exponential backoff: 200ms, 400ms, 800ms
+        const delay = 100 * (2 ** attempt);
+        this.log.warn(
+          `Attempt ${attempt} to fetch failed: ${error.message}. Retrying in ${delay}ms...`,
+        );
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((res) => {
+          setTimeout(res, delay);
+        });
+      }
+    }
+    /* c8 ignore start */
+    // This should never be reached, but needed for consistent-return
+    throw this.#createError(
+      'Failed to check edge optimize status after all retries',
+      HTTP_INTERNAL_SERVER_ERROR,
+    );
+    /* c8 ignore stop */
+  }
 }
 
 // Export the client as default and base classes for custom implementations

package/src/utils/custom-html-utils.js

@@ -104,7 +104,7 @@ async function fetchWithRetry(url, options, maxRetries, retryDelayMs, log, fetch
  * Fetches HTML content from edge with warmup call and retry logic
  * Makes an initial warmup call, waits, then makes the actual call with retries
  * @param {string} url - Full URL to fetch
- * @param {string} apiKey - Edge Optimize API key
+ * @param {string} apiKey - Edge Optimize API key (optional)
  * @param {string} forwardedHost - Host to forward in x-forwarded-host header
  * @param {string} edgeUrl - Edge URL
  * @param {boolean} isOptimized - Whether to fetch optimized HTML (with preview param)
@@ -130,10 +130,6 @@ export async function fetchHtmlWithWarmup(
     throw new Error('URL is required for fetching HTML');
   }
 
-  if (!hasText(apiKey)) {
-    throw new Error('Edge Optimize API key is required for fetching HTML');
-  }
-
   if (!hasText(forwardedHost)) {
     throw new Error('Forwarded host is required for fetching HTML');
   }
@@ -158,7 +154,7 @@ export async function fetchHtmlWithWarmup(
 
   const headers = {
     'x-forwarded-host': forwardedHost,
-    'x-edgeoptimize-api-key': apiKey,
+    ...(apiKey && { 'x-edgeoptimize-api-key': apiKey }),
     'x-edgeoptimize-url': urlPath,
     'Accept-Encoding': 'identity', // Disable compression to avoid content-length: 0 issue
   };

package/test/index.test.js

@@ -2941,61 +2941,70 @@ describe('TokowakaClient', () => {
       }
     });
 
-    it('should throw error if metaconfig does not exist', async () => {
+    it('should preview suggestions successfully without metaconfig (optional)', async () => {
+      // Override the stub from beforeEach to return null
       client.fetchMetaconfig.resolves(null);
 
-      try {
-        await client.previewSuggestions(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(500);
-      }
-    });
+      const result = await client.previewSuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+        { warmupDelayMs: 0 },
+      );
 
-    it('should throw error if metaconfig does not have apiKeys', async () => {
-      client.fetchMetaconfig.resolves({
-        siteId: 'site-123',
-        // apiKeys missing
-      });
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.config).to.exist;
+      expect(result.html).to.exist;
+      expect(result.html.originalHtml).to.equal('<html><body>Test HTML</body></html>');
+      expect(result.html.optimizedHtml).to.equal('<html><body>Test HTML</body></html>');
 
-      try {
-        await client.previewSuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Metaconfig does not have valid API keys configured');
-        expect(error.status).to.equal(500);
-      }
+      // Verify fetch was called without API key (undefined)
+      expect(fetchStub.callCount).to.equal(4); // 2 warmup + 2 actual (original + optimized)
     });
 
-    it('should throw error if metaconfig has empty apiKeys array', async () => {
+    it('should preview suggestions successfully without apiKeys in metaconfig (optional)', async () => {
+      // Override the stub from beforeEach
       client.fetchMetaconfig.resolves({
         siteId: 'site-123',
-        apiKeys: [],
+        // apiKeys missing - should work without it
       });
 
-      try {
-        await client.previewSuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Metaconfig does not have valid API keys configured');
-        expect(error.status).to.equal(500);
-      }
+      const result = await client.previewSuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+        { warmupDelayMs: 0 },
+      );
+
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.config).to.exist;
+      expect(result.html).to.exist;
+      expect(result.html.originalHtml).to.equal('<html><body>Test HTML</body></html>');
+      expect(result.html.optimizedHtml).to.equal('<html><body>Test HTML</body></html>');
+      expect(fetchStub.callCount).to.equal(4);
     });
 
-    it('should throw error if metaconfig apiKeys first value is empty', async () => {
+    it('should preview suggestions successfully with empty apiKeys array (optional)', async () => {
+      // Override the stub from beforeEach
       client.fetchMetaconfig.resolves({
         siteId: 'site-123',
-        apiKeys: ['', 'test-api-key-2'],
+        apiKeys: [],
       });
 
-      try {
-        await client.previewSuggestions(mockSite, mockOpportunity, mockSuggestions);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.include('Metaconfig does not have valid API keys configured');
-        expect(error.status).to.equal(500);
-      }
+      const result = await client.previewSuggestions(
+        mockSite,
+        mockOpportunity,
+        mockSuggestions,
+        { warmupDelayMs: 0 },
+      );
+
+      expect(result.succeededSuggestions).to.have.length(2);
+      expect(result.failedSuggestions).to.have.length(0);
+      expect(result.config).to.exist;
+      expect(result.html).to.exist;
+      expect(fetchStub.callCount).to.equal(4);
     });
 
     it('should throw error for unsupported opportunity type', async () => {
@@ -3554,4 +3563,434 @@ describe('TokowakaClient', () => {
       client.env.TOKOWAKA_CDN_PROVIDER = originalProvider;
     });
   });
+
+  describe('checkEdgeOptimizeStatus', () => {
+    let fetchStub;
+
+    beforeEach(() => {
+      fetchStub = sinon.stub(global, 'fetch');
+    });
+
+    afterEach(() => {
+      fetchStub.restore();
+    });
+
+    describe('Input Validation', () => {
+      it('should throw error when site is not provided', async () => {
+        try {
+          await client.checkEdgeOptimizeStatus(null, '/');
+          expect.fail('Should have thrown error');
+        } catch (error) {
+          expect(error.message).to.include('Site is required');
+          expect(error.status).to.equal(400);
+        }
+      });
+
+      it('should throw error when site is empty object', async () => {
+        try {
+          await client.checkEdgeOptimizeStatus({}, '/');
+          expect.fail('Should have thrown error');
+        } catch (error) {
+          expect(error.message).to.include('Site is required');
+        }
+      });
+
+      it('should throw error when path is not provided', async () => {
+        const site = {
+          getId: () => 'site-id',
+          getBaseURL: () => 'https://example.com',
+          getConfig: () => ({}),
+          getDeliveryType: () => 'aem_edge',
+        };
+
+        try {
+          await client.checkEdgeOptimizeStatus(site, '');
+          expect.fail('Should have thrown error');
+        } catch (error) {
+          expect(error.message).to.include('Path is required');
+          expect(error.status).to.equal(400);
+        }
+      });
+
+      it('should throw error when path is null', async () => {
+        const site = {
+          getId: () => 'site-id',
+          getBaseURL: () => 'https://example.com',
+          getConfig: () => ({}),
+          getDeliveryType: () => 'aem_edge',
+        };
+
+        try {
+          await client.checkEdgeOptimizeStatus(site, null);
+          expect.fail('Should have thrown error');
+        } catch (error) {
+          expect(error.message).to.include('Path is required');
+        }
+      });
+    });
+
+    describe('Direct Response (No Redirect)', () => {
+      let site;
+
+      beforeEach(() => {
+        site = {
+          getId: () => 'site-id',
+          getBaseURL: () => 'https://example.com',
+          getConfig: () => ({}),
+          getDeliveryType: () => 'aem_edge',
+        };
+      });
+
+      it('should return edgeOptimizeEnabled: true when x-tokowaka-request-id header is present', async () => {
+        const headersMap = new Map([
+          ['x-tokowaka-request-id', 'abc123'],
+        ]);
+        const mockResponse = {
+          status: 200,
+          headers: {
+            get: (key) => headersMap.get(key) || null,
+          },
+        };
+
+        fetchStub.resolves(mockResponse);
+
+        const result = await client.checkEdgeOptimizeStatus(site, '/');
+
+        expect(result).to.deep.equal({
+          edgeOptimizeEnabled: true,
+        });
+        expect(fetchStub).to.have.been.calledOnce;
+        expect(fetchStub.firstCall.args[0]).to.equal('https://example.com/');
+      });
+
+      it('should return edgeOptimizeEnabled: true when x-edgeoptimize-request-id header is present', async () => {
+        const headersMap = new Map([
+          ['x-edgeoptimize-request-id', 'xyz789'],
+        ]);
+        const mockResponse = {
+          status: 200,
+          headers: {
+            get: (key) => headersMap.get(key) || null,
+          },
+        };
+
+        fetchStub.resolves(mockResponse);
+
+        const result = await client.checkEdgeOptimizeStatus(site, '/products');
+
+        expect(result).to.deep.equal({
+          edgeOptimizeEnabled: true,
+        });
+        expect(fetchStub.firstCall.args[0]).to.equal('https://example.com/products');
+      });
+
+      it('should return edgeOptimizeEnabled: false when headers are not present', async () => {
+        const mockResponse = {
+          status: 200,
+          headers: new Map(),
+        };
+        mockResponse.headers.get = () => null;
+
+        fetchStub.resolves(mockResponse);
+
+        const result = await client.checkEdgeOptimizeStatus(site, '/');
+
+        expect(result).to.deep.equal({
+          edgeOptimizeEnabled: false,
+        });
+      });
+
+      it('should work with 404 status and edge optimize enabled', async () => {
+        const headersMap = new Map([
+          ['x-tokowaka-request-id', 'abc123'],
+        ]);
+        const mockResponse = {
+          status: 404,
+          headers: {
+            get: (key) => headersMap.get(key) || null,
+          },
+        };
+
+        fetchStub.resolves(mockResponse);
+
+        const result = await client.checkEdgeOptimizeStatus(site, '/not-found');
+
+        expect(result).to.deep.equal({
+          edgeOptimizeEnabled: true,
+        });
+      });
+
+      it('should send correct User-Agent header', async () => {
+        const mockResponse = {
+          status: 200,
+          headers: new Map(),
+        };
+        mockResponse.headers.get = () => null;
+
+        fetchStub.resolves(mockResponse);
+
+        await client.checkEdgeOptimizeStatus(site, '/');
+
+        const fetchOptions = fetchStub.firstCall.args[1];
+        expect(fetchOptions.headers['User-Agent']).to.equal('chatgpt-user');
+      });
+    });
+
+    describe('Retry Logic', () => {
+      let site;
+      let clock;
+
+      beforeEach(() => {
+        site = {
+          getId: () => 'site-id',
+          getBaseURL: () => 'https://example.com',
+          getConfig: () => ({}),
+          getDeliveryType: () => 'aem_edge',
+        };
+        clock = sinon.useFakeTimers();
+      });
+
+      afterEach(() => {
+        clock.restore();
+      });
+
+      it('should retry 3 times on network error with exponential backoff', async () => {
+        const networkError = new Error('Network timeout');
+        fetchStub.rejects(networkError);
+
+        const promise = client.checkEdgeOptimizeStatus(site, '/');
+
+        // Wait for first attempt
+        await clock.tickAsync(0);
+
+        // Wait for 200ms delay after first failure
+        await clock.tickAsync(200);
+
+        // Wait for 400ms delay after second failure
+        await clock.tickAsync(400);
+
+        // Wait for 800ms delay after third failure
+        await clock.tickAsync(800);
+
+        try {
+          await promise;
+          expect.fail('Should have thrown error');
+        } catch (error) {
+          expect(error.message).to.include('Failed to check edge optimize status');
+          expect(error.message).to.include('Network timeout');
+          expect(error.status).to.equal(500);
+          expect(fetchStub.callCount).to.equal(4); // Initial + 3 retries
+        }
+      });
+
+      it('should succeed on second attempt after first failure', async () => {
+        const headersMap = new Map([
+          ['x-tokowaka-request-id', 'abc123'],
+        ]);
+        const mockResponse = {
+          status: 200,
+          headers: {
+            get: (key) => headersMap.get(key) || null,
+          },
+        };
+
+        fetchStub.onFirstCall().rejects(new Error('Temporary failure'));
+        fetchStub.onSecondCall().resolves(mockResponse);
+
+        const promise = client.checkEdgeOptimizeStatus(site, '/');
+
+        await clock.tickAsync(200);
+
+        const result = await promise;
+
+        expect(result).to.deep.equal({
+          edgeOptimizeEnabled: true,
+        });
+        expect(fetchStub).to.have.been.calledTwice;
+      });
+
+      it('should succeed on third attempt after two failures', async () => {
+        const headersMap = new Map([
+          ['x-edgeoptimize-request-id', 'xyz789'],
+        ]);
+        const mockResponse = {
+          status: 200,
+          headers: {
+            get: (key) => headersMap.get(key) || null,
+          },
+        };
+
+        fetchStub.onFirstCall().rejects(new Error('Failure 1'));
+        fetchStub.onSecondCall().rejects(new Error('Failure 2'));
+        fetchStub.onThirdCall().resolves(mockResponse);
+
+        const promise = client.checkEdgeOptimizeStatus(site, '/');
+
+        await clock.tickAsync(200); // First retry delay
+        await clock.tickAsync(400); // Second retry delay
+
+        const result = await promise;
+
+        expect(result).to.deep.equal({
+          edgeOptimizeEnabled: true,
+        });
+        expect(fetchStub.callCount).to.equal(3);
+      });
+
+      it('should log warnings on retries', async () => {
+        const networkError = new Error('Connection refused');
+        const mockResponse = {
+          status: 200,
+          headers: new Map(),
+        };
+        mockResponse.headers.get = () => null;
+
+        fetchStub.onFirstCall().rejects(networkError);
+        fetchStub.onSecondCall().resolves(mockResponse);
+
+        const promise = client.checkEdgeOptimizeStatus(site, '/');
+        await clock.tickAsync(200);
+        await promise;
+
+        expect(log.warn).to.have.been.calledWith(
+          sinon.match(/Attempt 1 to fetch failed.*Connection refused.*Retrying in 200ms/),
+        );
+      });
+    });
+
+    describe('URL Construction', () => {
+      let site;
+
+      beforeEach(() => {
+        site = {
+          getId: () => 'site-id',
+          getBaseURL: () => 'https://example.com',
+          getConfig: () => ({}),
+          getDeliveryType: () => 'aem_edge',
+        };
+      });
+
+      it('should construct URL correctly with simple path', async () => {
+        const mockResponse = {
+          status: 200,
+          headers: new Map(),
+        };
+        mockResponse.headers.get = () => null;
+
+        fetchStub.resolves(mockResponse);
+
+        await client.checkEdgeOptimizeStatus(site, '/products/chairs');
+
+        expect(fetchStub.firstCall.args[0]).to.equal('https://example.com/products/chairs');
+      });
+
+      it('should construct URL correctly with multi-level path', async () => {
+        const mockResponse = {
+          status: 200,
+          headers: new Map(),
+        };
+        mockResponse.headers.get = () => null;
+
+        fetchStub.resolves(mockResponse);
+
+        await client.checkEdgeOptimizeStatus(site, '/a/b/c/d');
+
+        expect(fetchStub.firstCall.args[0]).to.equal('https://example.com/a/b/c/d');
+      });
+
+      it('should handle baseURL with trailing slash', async () => {
+        site = {
+          getId: () => 'site-id',
+          getBaseURL: () => 'https://example.com/',
+          getConfig: () => ({}),
+          getDeliveryType: () => 'aem_edge',
+        };
+
+        const mockResponse = {
+          status: 200,
+          headers: new Map(),
+        };
+        mockResponse.headers.get = () => null;
+
+        fetchStub.resolves(mockResponse);
+
+        await client.checkEdgeOptimizeStatus(site, '/about');
+
+        expect(fetchStub.firstCall.args[0]).to.equal('https://example.com/about');
+      });
+
+      it('should handle baseURL without trailing slash', async () => {
+        site = {
+          getId: () => 'site-id',
+          getBaseURL: () => 'https://example.com',
+          getConfig: () => ({}),
+          getDeliveryType: () => 'aem_edge',
+        };
+
+        const mockResponse = {
+          status: 200,
+          headers: new Map(),
+        };
+        mockResponse.headers.get = () => null;
+
+        fetchStub.resolves(mockResponse);
+
+        await client.checkEdgeOptimizeStatus(site, '/about');
+
+        expect(fetchStub.firstCall.args[0]).to.equal('https://example.com/about');
+      });
+    });
+
+    describe('Edge Cases', () => {
+      let site;
+
+      beforeEach(() => {
+        site = {
+          getId: () => 'site-id',
+          getBaseURL: () => 'https://example.com',
+          getConfig: () => ({}),
+          getDeliveryType: () => 'aem_edge',
+        };
+      });
+
+      it('should handle both headers present', async () => {
+        const headersMap = new Map([
+          ['x-tokowaka-request-id', 'abc123'],
+          ['x-edgeoptimize-request-id', 'xyz789'],
+        ]);
+        const mockResponse = {
+          status: 200,
+          headers: {
+            get: (key) => headersMap.get(key) || null,
+          },
+        };
+
+        fetchStub.resolves(mockResponse);
+
+        const result = await client.checkEdgeOptimizeStatus(site, '/');
+
+        expect(result.edgeOptimizeEnabled).to.be.true;
+      });
+
+      it('should handle 500 error with edge optimize header', async () => {
+        const headersMap = new Map([
+          ['x-tokowaka-request-id', 'abc123'],
+        ]);
+        const mockResponse = {
+          status: 500,
+          headers: {
+            get: (key) => headersMap.get(key) || null,
+          },
+        };
+
+        fetchStub.resolves(mockResponse);
+
+        const result = await client.checkEdgeOptimizeStatus(site, '/error');
+
+        expect(result).to.deep.equal({
+          edgeOptimizeEnabled: true,
+        });
+      });
+    });
+  });
 });

package/test/utils/html-utils.test.js

@@ -82,20 +82,33 @@ describe('HTML Utils', () => {
       }
     });
 
-    it('should throw error when apiKey is missing', async () => {
-      try {
-        await fetchHtmlWithWarmup(
-          'https://example.com/page',
-          '',
-          'host',
-          'edge-url',
-          log,
-          false,
-        );
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error.message).to.equal('Edge Optimize API key is required for fetching HTML');
-      }
+    it('should successfully fetch HTML without apiKey (optional parameter)', async () => {
+      fetchStub.resolves({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        headers: {
+          get: (name) => (name === 'x-edgeoptimize-cache' ? 'HIT' : null),
+        },
+        text: async () => '<html>Test HTML without API key</html>',
+      });
+
+      const html = await fetchHtmlWithWarmup(
+        'https://example.com/page',
+        null, // apiKey is optional
+        'host',
+        'https://edge.example.com',
+        log,
+        false,
+        { warmupDelayMs: 0 },
+      );
+
+      expect(html).to.equal('<html>Test HTML without API key</html>');
+      expect(fetchStub.callCount).to.equal(2); // warmup + actual
+
+      // Verify that x-edgeoptimize-api-key header is not present
+      const fetchOptions = fetchStub.firstCall.args[1];
+      expect(fetchOptions.headers).to.not.have.property('x-edgeoptimize-api-key');
     });
 
     it('should successfully fetch HTML with all required parameters', async () => {