galileo-generated 0.2.7 → 0.2.9

package/src/tests/hooks/sdk-identifier.test.ts

@@ -0,0 +1,176 @@
+import { describe, test, expect, vi } from "vitest";
+import { SDKIdentifierHook } from "../../hooks/sdk-identifier.js";
+import type { BeforeRequestContext } from "../../hooks/types.js";
+
+describe("SDKIdentifierHook", () => {
+  const mockContext: BeforeRequestContext = {
+    baseURL: new URL("http://localhost:8088"),
+    operationID: "testOperation",
+    oAuth2Scopes: null,
+    retryConfig: { strategy: "none" },
+    resolvedSecurity: null,
+    options: {},
+  };
+
+  describe("beforeRequest", () => {
+    test("adds X-Galileo-SDK header to request", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+
+      expect(modifiedRequest.headers.has("X-Galileo-SDK")).toBe(true);
+    });
+
+    test("header contains galileo-generated prefix", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+      const headerValue = modifiedRequest.headers.get("X-Galileo-SDK");
+
+      expect(headerValue).toMatch(/^galileo-generated\//);
+    });
+
+    test("header contains valid version format", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+      const headerValue = modifiedRequest.headers.get("X-Galileo-SDK");
+
+      expect(headerValue).toMatch(/^galileo-generated\/\d+\.\d+\.\d+/);
+    });
+
+    test("preserves existing headers", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test", {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Bearer token",
+        },
+      });
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+
+      expect(modifiedRequest.headers.get("Content-Type")).toBe("application/json");
+      expect(modifiedRequest.headers.get("Authorization")).toBe("Bearer token");
+      expect(modifiedRequest.headers.has("X-Galileo-SDK")).toBe(true);
+    });
+
+    test("returns a Request object", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const result = await hook.beforeRequest(mockContext, request);
+
+      expect(result instanceof Request).toBe(true);
+    });
+
+    test("does not modify request method or body", async () => {
+      const hook = new SDKIdentifierHook();
+      const body = JSON.stringify({ test: "data" });
+      const request = new Request("http://localhost:8088/api/test", {
+        method: "POST",
+        body,
+      });
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+
+      expect(modifiedRequest.method).toBe("POST");
+    });
+
+    test("works with different HTTP methods", async () => {
+      const hook = new SDKIdentifierHook();
+
+      for (const method of ["GET", "POST", "PUT", "DELETE", "PATCH"]) {
+        const request = new Request("http://localhost:8088/api/test", {
+          method,
+        });
+
+        const modifiedRequest = await hook.beforeRequest(mockContext, request);
+
+        expect(modifiedRequest.headers.has("X-Galileo-SDK")).toBe(true);
+        expect(modifiedRequest.method).toBe(method);
+      }
+    });
+
+    test("header value is consistent across multiple calls", async () => {
+      const hook = new SDKIdentifierHook();
+      const request1 = new Request("http://localhost:8088/api/test");
+      const request2 = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest1 = await hook.beforeRequest(mockContext, request1);
+      const modifiedRequest2 = await hook.beforeRequest(mockContext, request2);
+
+      const header1 = modifiedRequest1.headers.get("X-Galileo-SDK");
+      const header2 = modifiedRequest2.headers.get("X-Galileo-SDK");
+
+      expect(header1).toBe(header2);
+    });
+
+    test("overwrites existing X-Galileo-SDK header", async () => {
+      const hook = new SDKIdentifierHook();
+      const request = new Request("http://localhost:8088/api/test", {
+        headers: {
+          "X-Galileo-SDK": "old-value",
+        },
+      });
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+      const headerValue = modifiedRequest.headers.get("X-Galileo-SDK");
+
+      expect(headerValue).toMatch(/^galileo-generated\//);
+      expect(headerValue).not.toBe("old-value");
+    });
+
+    test("handles loadVersion() failure gracefully with fallback to unknown", async () => {
+      vi.resetModules();
+
+      vi.doMock("../../hooks/sdk-identifier.js", async () => {
+        return {
+          SDKIdentifierHook: class {
+            async beforeRequest(
+              _hookCtx: BeforeRequestContext,
+              request: Request,
+            ): Promise<Request> {
+              const newRequest = request.clone();
+
+              const loadVersionWithFailure = (): string => {
+                try {
+                  throw new Error("Failed to load package.json (ESM runtime issue)");
+                } catch {
+                  return "unknown";
+                }
+              };
+
+              const version = loadVersionWithFailure();
+              const sdkIdentifier = `galileo-generated/${version}`;
+              newRequest.headers.set("X-Galileo-SDK", sdkIdentifier);
+              return newRequest;
+            }
+          },
+        };
+      });
+
+      const { SDKIdentifierHook: MockedHook } = await import("../../hooks/sdk-identifier.js");
+      const hook = new MockedHook();
+      const request = new Request("http://localhost:8088/api/test");
+
+      const modifiedRequest = await hook.beforeRequest(mockContext, request);
+      const headerValue = modifiedRequest.headers.get("X-Galileo-SDK");
+
+      expect(headerValue).toBe("galileo-generated/unknown");
+
+      vi.doUnmock("../../hooks/sdk-identifier.js");
+    });
+  });
+
+  describe("hook integration", () => {
+    test("hook implements BeforeRequestHook interface", () => {
+      const hook = new SDKIdentifierHook();
+
+      expect(typeof hook.beforeRequest).toBe("function");
+    });
+  });
+});

package/src/tests/lib/galileo-config.test.ts

@@ -13,6 +13,11 @@ const ENV_KEYS = [
   'GALILEO_PROJECT_NAME',
   'GALILEO_LOG_STREAM',
   'GALILEO_LOG_STREAM_NAME',
+  'GALILEO_CA_CERT_PATH',
+  'GALILEO_CA_CERT_CONTENT',
+  'GALILEO_CLIENT_CERT_PATH',
+  'GALILEO_CLIENT_KEY_PATH',
+  'GALILEO_REJECT_UNAUTHORIZED',
 ] as const;
 
 function clearGalileoEnv(): void {
@@ -233,4 +238,109 @@ describe('GalileoConfig', () => {
     expect(() => config.logConfig()).not.toThrow();
     spy.mockRestore();
   });
+
+  test('test getCertConfig returns cert fields from overrides', () => {
+    GalileoConfig.reset();
+    const config = GalileoConfig.get({
+      apiKey: 'key',
+      apiUrl: 'https://api.example.com',
+      caCertPath: '/path/to/ca.pem',
+      caCertContent: '-----BEGIN CERTIFICATE-----',
+      clientCertPath: '/path/to/client.pem',
+      clientKeyPath: '/path/to/key.pem',
+      rejectUnauthorized: false,
+    });
+    const cert = config.getCertConfig();
+    expect(cert).not.toBeNull();
+    if (!cert) throw new Error("unreachable");
+    expect(cert.caCertPath).toBe('/path/to/ca.pem');
+    expect(cert.caCertContent).toBe('-----BEGIN CERTIFICATE-----');
+    expect(cert.clientCertPath).toBe('/path/to/client.pem');
+    expect(cert.clientKeyPath).toBe('/path/to/key.pem');
+    expect(cert.rejectUnauthorized).toBe(false);
+  });
+
+  test('test getCertConfig empty when no cert set', () => {
+    GalileoConfig.reset();
+    const config = GalileoConfig.get({
+      apiKey: 'key',
+      apiUrl: 'https://api.example.com',
+    });
+    const cert = config.getCertConfig();
+    expect(cert).toBeNull();
+  });
+
+  test('test snapshot includes cert when set', () => {
+    GalileoConfig.reset();
+    const config = GalileoConfig.get({
+      apiKey: 'key',
+      apiUrl: 'https://api.example.com',
+      caCertPath: '/ca.pem',
+      rejectUnauthorized: true,
+    });
+    expect(config.snapshot.cert).toEqual({
+      caCertPath: '/ca.pem',
+      rejectUnauthorized: true,
+    });
+  });
+
+  test('test cert from env', () => {
+    GalileoConfig.reset();
+    process.env['GALILEO_API_KEY'] = 'env-key';
+    process.env['GALILEO_CA_CERT_PATH'] = '/env/ca.pem';
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = 'false';
+    const config = GalileoConfig.get({});
+    const cert = config.getCertConfig();
+    expect(cert).not.toBeNull();
+    if (!cert) throw new Error("unreachable");
+    expect(cert.caCertPath).toBe('/env/ca.pem');
+    expect(cert.rejectUnauthorized).toBe(false);
+  });
+
+  test('test empty GALILEO_REJECT_UNAUTHORIZED treated as undefined', () => {
+    GalileoConfig.reset();
+    process.env['GALILEO_API_KEY'] = 'env-key';
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = '';
+    const config = GalileoConfig.get({});
+    const cert = config.getCertConfig();
+    expect(cert).toBeNull();
+  });
+
+  test('test empty NODE_TLS_REJECT_UNAUTHORIZED treated as undefined', () => {
+    GalileoConfig.reset();
+    process.env['GALILEO_API_KEY'] = 'env-key';
+    process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '';
+    const config = GalileoConfig.get({});
+    const cert = config.getCertConfig();
+    expect(cert).toBeNull();
+  });
+
+  test('test explicit rejectUnauthorized values', () => {
+    GalileoConfig.reset();
+    process.env['GALILEO_API_KEY'] = 'env-key';
+    
+    // Test "true" string
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = 'true';
+    let config = GalileoConfig.get({});
+    let cert = config.getCertConfig();
+    expect(cert?.rejectUnauthorized).toBe(true);
+    
+    GalileoConfig.reset();
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = '1';
+    config = GalileoConfig.get({});
+    cert = config.getCertConfig();
+    expect(cert?.rejectUnauthorized).toBe(true);
+    
+    GalileoConfig.reset();
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = 'false';
+    config = GalileoConfig.get({});
+    cert = config.getCertConfig();
+    expect(cert?.rejectUnauthorized).toBe(false);
+    
+    GalileoConfig.reset();
+    process.env['GALILEO_REJECT_UNAUTHORIZED'] = '0';
+    config = GalileoConfig.get({});
+    cert = config.getCertConfig();
+    expect(cert?.rejectUnauthorized).toBe(false);
+  });
 });