@optimizely-opal/opal-tool-ocp-sdk 1.0.0-beta.1 → 1.0.0-beta.3

package/src/logging/ToolLogger.test.ts

@@ -0,0 +1,753 @@
+import { ToolLogger } from './ToolLogger';
+import { logger, LogVisibility } from '@zaiusinc/app-sdk';
+import * as App from '@zaiusinc/app-sdk';
+
+// Mock the logger
+jest.mock('@zaiusinc/app-sdk', () => ({
+  logger: {
+    info: jest.fn()
+  },
+  LogVisibility: {
+    Zaius: 'zaius'
+  },
+  Headers: jest.fn(),
+  Response: jest.fn()
+}));
+
+describe('ToolLogger', () => {
+  const mockLogger = logger as jest.Mocked<typeof logger>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // Helper function to check JSON string logs
+  const expectJsonLog = (expectedData: any) => {
+    expect(mockLogger.info).toHaveBeenCalledWith(
+      LogVisibility.Zaius,
+      JSON.stringify(expectedData)
+    );
+  };
+
+  const createMockRequest = (overrides: any = {}): App.Request => {
+    const defaultRequest = {
+      path: '/test-tool',
+      bodyJSON: {
+        parameters: {
+          name: 'test',
+          value: 'data'
+        }
+      },
+      headers: {
+        get: jest.fn().mockReturnValue('application/json')
+      }
+    };
+
+    return { ...defaultRequest, ...overrides };
+  };
+
+  const createMockResponse = (status = 200, bodyJSON: any = {}, headers: any = {}): App.Response => {
+    const mockHeaders = {
+      get: jest.fn().mockImplementation((name: string) => {
+        if (name === 'content-type') return 'application/json';
+        return headers[name] || null;
+      })
+    };
+
+    const response = {
+      status,
+      headers: mockHeaders,
+      _bodyJSON: bodyJSON
+    } as any;
+
+    // Add getter for bodyJSON that returns the stored value
+    Object.defineProperty(response, 'bodyJSON', {
+      get() {
+        return this._bodyJSON;
+      },
+      set(value) {
+        this._bodyJSON = value;
+      },
+      enumerable: true
+    });
+
+    // Add getter for bodyAsU8Array that recalculates based on current bodyJSON
+    Object.defineProperty(response, 'bodyAsU8Array', {
+      get() {
+        if (this._bodyJSON !== null && this._bodyJSON !== undefined) {
+          // This will throw for circular references, which matches real behavior
+          const jsonString = JSON.stringify(this._bodyJSON);
+          return new Uint8Array(Buffer.from(jsonString));
+        }
+        return undefined;
+      },
+      enumerable: true
+    });
+
+    return response;
+  };
+
+  describe('logRequest', () => {
+    it('should log request with parameters', () => {
+      const req = createMockRequest();
+
+      ToolLogger.logRequest(req);
+
+      const expectedLog = {
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          name: 'test',
+          value: 'data'
+        }
+      };
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        LogVisibility.Zaius,
+        JSON.stringify(expectedLog)
+      );
+    });
+
+    it('should handle request without parameters', () => {
+      const req = createMockRequest({
+        bodyJSON: null
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: null
+      });
+    });
+
+    it('should use bodyJSON as parameters when no parameters field exists', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          name: 'direct',
+          action: 'test'
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          name: 'direct',
+          action: 'test'
+        }
+      });
+    });
+
+    it('should redact all sensitive field variations', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            username: 'john',
+            password: 'secret123',
+            api_key: 'key123',
+            secret: 'mysecret',
+            token: 'abc123',
+            auth: 'authdata',
+            credentials: 'creds',
+            access_token: 'access123',
+            refresh_token: 'refresh123',
+            private_key: 'privatekey',
+            client_secret: 'clientsecret',
+            normal_field: 'visible'
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          username: 'john',
+          password: '[REDACTED]',
+          api_key: '[REDACTED]',
+          secret: '[REDACTED]',
+          token: '[REDACTED]',
+          auth: '[REDACTED]',
+          credentials: '[REDACTED]',
+          access_token: '[REDACTED]',
+          refresh_token: '[REDACTED]',
+          private_key: '[REDACTED]',
+          client_secret: '[REDACTED]',
+          normal_field: 'visible'
+        }
+      });
+    });
+
+    it('should redact sensitive fields with case variations', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            PASSWORD: 'secret1',
+            API_KEY: 'secret2',
+            clientSecret: 'secret3',
+            user_password: 'secret4',
+            oauth_token: 'secret5',
+            ssh_key: 'secret6',
+            normal_field: 'visible'
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          PASSWORD: '[REDACTED]',
+          API_KEY: '[REDACTED]',
+          clientSecret: '[REDACTED]',
+          user_password: '[REDACTED]',
+          oauth_token: '[REDACTED]',
+          ssh_key: '[REDACTED]',
+          normal_field: 'visible'
+        }
+      });
+    });
+
+    it('should truncate long string values', () => {
+      const longString = 'a'.repeat(150);
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            description: longString,
+            short_field: 'normal'
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          description: `${'a'.repeat(100)}... (truncated, 150 chars total)`,
+          short_field: 'normal'
+        }
+      });
+    });
+
+    it('should truncate large arrays', () => {
+      const largeArray = Array.from({ length: 15 }, (_, i) => `item${i}`);
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            items: largeArray,
+            small_array: ['a', 'b']
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          items: [
+            ...largeArray.slice(0, 10),
+            '... (5 more items truncated)'
+          ],
+          small_array: ['a', 'b']
+        }
+      });
+    });
+
+    it('should handle nested objects with sensitive fields', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            user: {
+              name: 'John',
+              email: 'john@example.com',
+              password: 'secret123'
+            },
+            config: {
+              database: {
+                host: 'localhost',
+                port: 5432,
+                password: 'dbpass'
+              },
+              api_key: 'apikey123'
+            }
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          user: {
+            name: 'John',
+            email: '[REDACTED]',
+            password: '[REDACTED]'
+          },
+          config: {
+            database: {
+              host: 'localhost',
+              port: 5432,
+              password: '[REDACTED]'
+            },
+            api_key: '[REDACTED]'
+          }
+        }
+      });
+    });
+
+    it('should handle null and undefined values', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            nullValue: null,
+            undefinedValue: undefined,
+            emptyString: '',
+            zero: 0,
+            false: false,
+            password: null // sensitive field with null value
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          nullValue: null,
+          emptyString: '',
+          zero: 0,
+          false: false,
+          password: '[REDACTED]'
+        }
+      });
+    });
+
+    it('should handle arrays in sensitive fields', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            credentials: ['user', 'pass', 'token'],
+            public_list: ['item1', 'item2']
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          credentials: '[REDACTED]',
+          public_list: ['item1', 'item2']
+        }
+      });
+    });
+
+    it('should handle objects in sensitive fields', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            auth: {
+              username: 'john',
+              password: 'secret'
+            },
+            public_config: {
+              timeout: 30,
+              retries: 3
+            }
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          auth: '[REDACTED]',
+          public_config: {
+            timeout: 30,
+            retries: 3
+          }
+        }
+      });
+    });
+
+    it('should respect max depth to prevent infinite recursion', () => {
+      const deepObject: any = { level: 0, data: 'test' };
+      let current = deepObject;
+
+      // Create a very deep nested object (deeper than maxDepth)
+      for (let i = 1; i <= 10; i++) {
+        current.nested = { level: i, data: `level${i}` };
+        current = current.nested;
+      }
+
+      const req = createMockRequest({
+        bodyJSON: { parameters: { deep: deepObject } }
+      });
+
+      // Should not throw error or cause infinite recursion
+      expect(() => ToolLogger.logRequest(req)).not.toThrow();
+      expect(mockLogger.info).toHaveBeenCalled();
+    });
+
+    it('should replace deeply nested objects with MAX_DEPTH_EXCEEDED placeholder', () => {
+      // Create an object with exactly 6 levels (exceeds maxDepth of 5)
+      const deepObject = {
+        level1: {
+          level2: {
+            level3: {
+              level4: {
+                level5: {
+                  level6: {
+                    password: 'should-not-be-visible',
+                    credit_card: '1234-5678-9012-3456',
+                    data: 'sensitive-info'
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+
+      const req = createMockRequest({
+        bodyJSON: { parameters: { deep: deepObject } }
+      });
+
+      ToolLogger.logRequest(req);
+
+      // Verify that the deeply nested object is replaced with placeholder
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      // Navigate to the deeply nested part that should be replaced
+      // At maxDepth=5, the 5th level (level4) gets replaced with the placeholder
+      const level4 = loggedData.parameters.deep.level1.level2.level3.level4;
+      expect(level4).toBe('[MAX_DEPTH_EXCEEDED]');
+    });
+
+    it('should handle arrays containing deeply nested objects that exceed max depth', () => {
+      // Create a structure where the array is shallow enough to be processed (depth 3),
+      // but individual objects within the array exceed the max depth
+      const arrayWithDeepObjects = {
+        level1: {
+          items: [
+            {
+              level2: {
+                level3: {
+                  level4: {
+                    level5: {
+                      password: 'secret-in-deep-array-object',
+                      credit_card: '1234-5678-9012-3456'
+                    }
+                  }
+                }
+              }
+            },
+            'simple-item',
+            {
+              shallow: 'data'
+            },
+            {
+              level2: {
+                level3: {
+                  level4: {
+                    another: 'deep-object'
+                  }
+                }
+              }
+            }
+          ]
+        }
+      };
+
+      const req = createMockRequest({
+        bodyJSON: { parameters: arrayWithDeepObjects }
+      });
+
+      ToolLogger.logRequest(req);
+
+      // Verify the array structure and depth handling
+      const logCall = mockLogger.info.mock.calls[0];
+      const loggedData = JSON.parse(logCall[1]);
+
+      const items = loggedData.parameters.level1.items;
+
+      // First item: deeply nested object with inner parts replaced by placeholder
+      expect(items[0]).toEqual({
+        level2: {
+          level3: '[MAX_DEPTH_EXCEEDED]'
+        }
+      });
+
+      // Second item: simple string should remain unchanged
+      expect(items[1]).toBe('simple-item');
+
+      // Third item: shallow object should be processed normally
+      expect(items[2]).toEqual({ shallow: 'data' });
+
+      // Fourth item: another deeply nested object with inner parts replaced by placeholder
+      expect(items[3]).toEqual({
+        level2: {
+          level3: '[MAX_DEPTH_EXCEEDED]'
+        }
+      });
+    });
+  });
+
+  describe('logResponse', () => {
+    it('should log successful response with all details', () => {
+      const req = createMockRequest();
+      const response = createMockResponse(200, { result: 'success', data: 'test' });
+
+      ToolLogger.logResponse(req, response, 150);
+
+      const expectedLog = {
+        event: 'opal_tool_response',
+        path: '/test-tool',
+        duration: '150ms',
+        status: 200,
+        contentType: 'application/json',
+        contentLength: 34, // JSON.stringify({ result: 'success', data: 'test' }).length
+        success: true
+      };
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        LogVisibility.Zaius,
+        JSON.stringify(expectedLog)
+      );
+    });
+
+    it('should log error response', () => {
+      const req = createMockRequest();
+      const response = createMockResponse(400, { error: 'Bad request' });
+
+      ToolLogger.logResponse(req, response, 75);
+
+      expectJsonLog({
+        event: 'opal_tool_response',
+        path: '/test-tool',
+        duration: '75ms',
+        status: 400,
+        contentType: 'application/json',
+        contentLength: 23,
+        success: false
+      });
+    });
+
+    it('should handle response without bodyJSON', () => {
+      const req = createMockRequest();
+      const response = createMockResponse(204);
+      response.bodyJSON = undefined;
+
+      ToolLogger.logResponse(req, response);
+
+      expectJsonLog({
+        event: 'opal_tool_response',
+        path: '/test-tool',
+        status: 204,
+        contentType: 'application/json',
+        contentLength: 'unknown',
+        success: true
+      });
+    });
+
+    it('should handle response without processing time', () => {
+      const req = createMockRequest();
+      const response = createMockResponse(200, { data: 'test' });
+
+      ToolLogger.logResponse(req, response);
+
+      expectJsonLog({
+        event: 'opal_tool_response',
+        path: '/test-tool',
+        status: 200,
+        contentType: 'application/json',
+        contentLength: 15,
+        success: true
+      });
+    });
+
+    it('should handle unknown content type', () => {
+      const req = createMockRequest();
+      const response = createMockResponse(200, { data: 'test' });
+      response.headers.get = jest.fn().mockReturnValue(null);
+
+      ToolLogger.logResponse(req, response);
+
+      expectJsonLog({
+        event: 'opal_tool_response',
+        path: '/test-tool',
+        status: 200,
+        contentType: 'unknown',
+        contentLength: 15,
+        success: true
+      });
+    });
+
+    it('should handle content length calculation error', () => {
+      const req = createMockRequest();
+      const circularObj: any = { name: 'test' };
+      circularObj.self = circularObj; // Create circular reference
+
+      const response = createMockResponse(200, circularObj);
+
+      ToolLogger.logResponse(req, response);
+
+      expectJsonLog({
+        event: 'opal_tool_response',
+        path: '/test-tool',
+        status: 200,
+        contentType: 'application/json',
+        contentLength: 'unknown',
+        success: true
+      });
+    });
+
+    it('should correctly identify success status codes', () => {
+      const req = createMockRequest();
+
+      const testCases = [
+        { status: 200, expected: true },
+        { status: 201, expected: true },
+        { status: 204, expected: true },
+        { status: 299, expected: true },
+        { status: 300, expected: false },
+        { status: 400, expected: false },
+        { status: 404, expected: false },
+        { status: 500, expected: false }
+      ];
+
+      testCases.forEach(({ status, expected }) => {
+        mockLogger.info.mockClear();
+        const response = createMockResponse(status);
+        ToolLogger.logResponse(req, response);
+
+        expectJsonLog({
+          event: 'opal_tool_response',
+          path: '/test-tool',
+          status,
+          contentType: 'application/json',
+          contentLength: 2,
+          success: expected
+        });
+      });
+    });
+
+    it('should handle different content types', () => {
+      const req = createMockRequest();
+
+      const testCases = [
+        'application/json',
+        'text/plain',
+        'application/xml',
+        'text/html'
+      ];
+
+      testCases.forEach((contentType) => {
+        mockLogger.info.mockClear();
+        const response = createMockResponse(200, { data: 'test' });
+        response.headers.get = jest.fn().mockReturnValue(contentType);
+
+        ToolLogger.logResponse(req, response);
+
+        expectJsonLog({
+          event: 'opal_tool_response',
+          path: '/test-tool',
+          status: 200,
+          contentType,
+          contentLength: 15,
+          success: true
+        });
+      });
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle empty request bodyJSON', () => {
+      const req = createMockRequest({
+        bodyJSON: {}
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {}
+      });
+    });
+
+    it('should handle request with only parameters field', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            field: 'value' // Changed from 'key' to 'field' to avoid sensitive field detection
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          field: 'value'
+        }
+      });
+    });
+
+    it('should handle mixed data types in parameters', () => {
+      const req = createMockRequest({
+        bodyJSON: {
+          parameters: {
+            string: 'text',
+            number: 42,
+            boolean: true,
+            array: [1, 2, 3],
+            object: { nested: 'value' },
+            nullValue: null,
+            password: 'secret'
+          }
+        }
+      });
+
+      ToolLogger.logRequest(req);
+
+      expectJsonLog({
+        event: 'opal_tool_request',
+        path: '/test-tool',
+        parameters: {
+          string: 'text',
+          number: 42,
+          boolean: true,
+          array: [1, 2, 3],
+          object: { nested: 'value' },
+          nullValue: null,
+          password: '[REDACTED]'
+        }
+      });
+    });
+  });
+});