Merge main into sweep/add-unit-tests

packages/core/src/tests/Embedding.test.ts

@@ -32,13 +32,37 @@ describe("similarity", () => {
   });
 
   test("calculates euclidean similarity", () => {
-    const queryEmbedding = [1, 0];
-    const docEmbedding1 = [0, 1]; // farther from query, distance 1.414
-    const docEmbedding2 = [1, 1]; // closer to query distance 1
-    expect(
-      similarity(queryEmbedding, docEmbedding1, SimilarityType.EUCLIDEAN),
-    ).toBeLessThan(
-      similarity(queryEmbedding, docEmbedding2, SimilarityType.EUCLIDEAN),
-    );
+      const queryEmbedding = [1, 0];
+      const docEmbedding1 = [0, 1]; // farther from query, distance 1.414
+      const docEmbedding2 = [1, 1]; // closer to query distance 1
+      expect(
+        similarity(queryEmbedding, docEmbedding1, SimilarityType.EUCLIDEAN),
+      ).toBeLessThan(
+        similarity(queryEmbedding, docEmbedding2, SimilarityType.EUCLIDEAN),
+      );
+    });
+  
+    test("calculates cosine similarity with zero vectors", () => {
+      const embedding1 = [0, 0];
+      const embedding2 = [0, 0];
+      expect(similarity(embedding1, embedding2, SimilarityType.DEFAULT)).toEqual(
+        NaN,
+      );
+    });
+  
+    test("calculates dot product with zero vectors", () => {
+      const embedding1 = [0, 0];
+      const embedding2 = [0, 0];
+      expect(
+        similarity(embedding1, embedding2, SimilarityType.DOT_PRODUCT),
+      ).toEqual(0);
+    });
+  
+    test("calculates euclidean similarity with zero vectors", () => {
+      const embedding1 = [0, 0];
+      const embedding2 = [0, 0];
+      expect(
+        similarity(embedding1, embedding2, SimilarityType.EUCLIDEAN),
+      ).toEqual(0);
+    });
   });
-});

packages/core/src/tests/Node.test.ts

@@ -0,0 +1,34 @@
+import { Node, ObjectType, MetadataMode } from '../Node';
+import { v4 as uuidv4 } from 'uuid';
+
+describe('Node class', () => {
+  let node: Node;
+
+  beforeEach(() => {
+    node = new Node();
+  });
+
+  test('getType method', () => {
+    expect(node.getType()).toBe(ObjectType.TEXT);
+  });
+
+  test('getContent method', () => {
+    const content = 'Test content';
+    node.setContent(content);
+    expect(node.getContent(MetadataMode.ALL)).toBe(content);
+  });
+
+  test('getMetadataStr method', () => {
+    const metadata = { key: 'value' };
+    node.metadata = metadata;
+    expect(node.getMetadataStr(MetadataMode.ALL)).toBe(JSON.stringify(metadata));
+  });
+
+  test('setContent method', () => {
+    const content = 'Test content';
+    node.setContent(content);
+    expect(node.getContent(MetadataMode.ALL)).toBe(content);
+  });
+
+  // Mock LLM completions and test other methods...
+});

packages/core/src/tests/RouterQueryEngine.test.ts

@@ -0,0 +1,34 @@
+import { RouterQueryEngine } from '../RouterQueryEngine';
+import { LLM } from '../LLM'; // Assuming LLM is a class or module that can be mocked
+
+jest.mock('../LLM'); // Mock the LLM completions
+
+describe('RouterQueryEngine', () => {
+  let routerQueryEngine: RouterQueryEngine;
+  let mockLLM: jest.Mocked<LLM>;
+
+  beforeEach(() => {
+    mockLLM = new LLM() as jest.Mocked<LLM>;
+    routerQueryEngine = new RouterQueryEngine(mockLLM);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('method1', () => {
+    // Arrange
+    const input = 'some input';
+    const expectedOutput = 'some output';
+    mockLLM.completion.mockReturnValue(expectedOutput);
+
+    // Act
+    const output = routerQueryEngine.method1(input);
+
+    // Assert
+    expect(output).toBe(expectedOutput);
+    expect(mockLLM.completion).toHaveBeenCalledWith(input);
+  });
+
+  // Repeat the test block for other methods in the RouterQueryEngine class
+});

packages/core/src/tests/Selector.test.ts

@@ -0,0 +1,21 @@
+import { Selector } from '../Selector';
+import { LLM } from '../LLM'; // Assuming LLM is a class or function that can be mocked
+import { jest } from '@jest/globals';
+
+describe('Selector', () => {
+  let mockLLM: jest.Mocked<LLM>;
+
+  beforeEach(() => {
+    mockLLM = {
+      complete: jest.fn(),
+      // Add other methods to be mocked here
+    };
+  });
+
+  test('method1', () => {
+    const selector = new Selector(mockLLM);
+    // Call method1 and assert the output
+  });
+
+  // Add more tests for other methods here
+});