Merge branch 'develop' into logger-improvement

Author: JoeyKhd

.env.example

@@ -550,6 +550,10 @@ AWS_SECRET_ACCESS_KEY=
 AWS_REGION=
 AWS_S3_BUCKET=
 AWS_S3_UPLOAD_PATH=
+AWS_S3_ENDPOINT=
+AWS_S3_SSL_ENABLED=
+AWS_S3_FORCE_PATH_STYLE=
+
 
 # Deepgram
 DEEPGRAM_API_KEY=

packages/client-github/__tests__/environment.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi } from 'vitest';
+import { validateGithubConfig, githubEnvSchema } from '../src/environment';
+import { IAgentRuntime } from '@elizaos/core';
+
+describe('GitHub Environment Configuration', () => {
+  const mockRuntime: IAgentRuntime = {
+    getSetting: vi.fn(),
+  } as unknown as IAgentRuntime;
+
+  it('validates correct GitHub configuration', async () => {
+    const validConfig = {
+      GITHUB_OWNER: 'testowner',
+      GITHUB_REPO: 'testrepo',
+      GITHUB_BRANCH: 'main',
+      GITHUB_PATH: 'src',
+      GITHUB_API_TOKEN: 'ghp_test123',
+    };
+
+    vi.mocked(mockRuntime.getSetting).mockImplementation((key: string) => validConfig[key as keyof typeof validConfig]);
+
+    const config = await validateGithubConfig(mockRuntime);
+    expect(config).toEqual(validConfig);
+  });
+
+  it('throws error for missing configuration', async () => {
+    const invalidConfig = {
+      GITHUB_OWNER: '',
+      GITHUB_REPO: '',
+      GITHUB_BRANCH: '',
+      GITHUB_PATH: '',
+      GITHUB_API_TOKEN: '',
+    };
+
+    vi.mocked(mockRuntime.getSetting).mockImplementation((key: string) => invalidConfig[key as keyof typeof invalidConfig]);
+
+    await expect(validateGithubConfig(mockRuntime)).rejects.toThrow();
+  });
+
+  it('throws error for partial configuration', async () => {
+    const partialConfig = {
+      GITHUB_OWNER: 'testowner',
+      GITHUB_REPO: 'testrepo',
+      // Missing other required fields
+    };
+
+    vi.mocked(mockRuntime.getSetting).mockImplementation((key: string) => partialConfig[key as keyof typeof partialConfig]);
+
+    await expect(validateGithubConfig(mockRuntime)).rejects.toThrow();
+  });
+});

packages/client-github/__tests__/index.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GitHubClient, GitHubClientInterface } from '../src';
+import { AgentRuntime, IAgentRuntime } from '@elizaos/core';
+import { Octokit } from '@octokit/rest';
+import simpleGit from 'simple-git';
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+
+// Mock external dependencies
+vi.mock('@octokit/rest', () => ({
+  Octokit: vi.fn(),
+}));
+
+vi.mock('simple-git', () => ({
+  default: vi.fn(() => ({
+    clone: vi.fn(),
+    pull: vi.fn(),
+    checkout: vi.fn(),
+  })),
+}));
+
+vi.mock('fs/promises', async (importOriginal) => {
+  const actual = await importOriginal() as typeof fsPromises;
+  return {
+    ...actual,
+    mkdir: vi.fn(),
+    lstat: vi.fn(),
+    readdir: vi.fn(),
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+  };
+});
+
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal() as typeof fs;
+  return {
+    ...actual,
+    existsSync: vi.fn(),
+    realpathSync: vi.fn(),
+    lstatSync: vi.fn(),
+    readdirSync: vi.fn(),
+  };
+});
+
+describe('GitHubClient', () => {
+  let mockRuntime: AgentRuntime;
+  const mockConfig = {
+    GITHUB_OWNER: 'testowner',
+    GITHUB_REPO: 'testrepo',
+    GITHUB_BRANCH: 'main',
+    GITHUB_PATH: 'src',
+    GITHUB_API_TOKEN: 'ghp_test123',
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockRuntime = {
+      getSetting: vi.fn((key: string) => mockConfig[key as keyof typeof mockConfig]),
+    } as unknown as AgentRuntime;
+  });
+
+  it('initializes with correct configuration', () => {
+    const client = new GitHubClient(mockRuntime);
+    expect(Octokit).toHaveBeenCalledWith({ auth: mockConfig.GITHUB_API_TOKEN });
+  });
+
+  describe('GitHubClientInterface', () => {
+    it('has start and stop methods', () => {
+      expect(GitHubClientInterface.start).toBeDefined();
+      expect(GitHubClientInterface.stop).toBeDefined();
+    });
+
+    it('start method initializes client', async () => {
+      const runtime = {
+        getSetting: vi.fn((key: string) => mockConfig[key as keyof typeof mockConfig]),
+      } as unknown as IAgentRuntime;
+
+      await GitHubClientInterface.start(runtime);
+      // Add more specific assertions based on what start should do
+    });
+
+    it('stop method cleans up resources', () => {
+      const runtime = {} as IAgentRuntime;
+      GitHubClientInterface.stop(runtime);
+      // Add assertions for cleanup if needed
+    });
+  });
+});

packages/client-github/package.json

@@ -27,11 +27,14 @@
     },
     "devDependencies": {
         "@types/glob": "8.1.0",
-        "tsup": "8.3.5"
+        "tsup": "8.3.5",
+        "vitest": "^1.2.1"
     },
     "scripts": {
         "build": "tsup --format esm --dts",
         "dev": "tsup --format esm --dts --watch",
-        "lint": "eslint --fix  --cache ."
+        "lint": "eslint --fix  --cache .",
+        "test": "vitest run",
+        "test:watch": "vitest"
     }
 }

packages/client-slack/__tests__/message-manager.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MessageManager } from '../src/messages';
+import { WebClient } from '@slack/web-api';
+import { IAgentRuntime } from '@elizaos/core';
+
+// Mock dependencies
+vi.mock('@slack/web-api');
+vi.mock('@elizaos/core');
+
+describe('MessageManager', () => {
+  let mockWebClient: WebClient;
+  let mockRuntime: IAgentRuntime;
+  let messageManager: MessageManager;
+  const mockBotUserId = 'U123456';
+
+  beforeEach(() => {
+    // Setup mock WebClient
+    mockWebClient = {
+      chat: {
+        postMessage: vi.fn()
+      }
+    } as unknown as WebClient;
+
+    // Setup mock runtime
+    mockRuntime = {
+      getSetting: vi.fn(),
+      character: {
+        name: 'TestBot'
+      }
+    } as unknown as IAgentRuntime;
+
+    messageManager = new MessageManager(mockWebClient, mockRuntime, mockBotUserId);
+  });
+
+  it('should initialize with correct parameters', () => {
+    expect(messageManager).toBeDefined();
+  });
+
+  it('should not process duplicate events', () => {
+    const eventId = 'evt_123';
+    const result1 = messageManager['processedEvents'].has(eventId);
+    expect(result1).toBe(false);
+
+    // Add event to processed set
+    messageManager['processedEvents'].add(eventId);
+    const result2 = messageManager['processedEvents'].has(eventId);
+    expect(result2).toBe(true);
+  });
+
+  it('should handle message processing lock correctly', () => {
+    const messageId = 'msg_123';
+    const isLocked1 = messageManager['messageProcessingLock'].has(messageId);
+    expect(isLocked1).toBe(false);
+
+    // Lock message
+    messageManager['messageProcessingLock'].add(messageId);
+    const isLocked2 = messageManager['messageProcessingLock'].has(messageId);
+    expect(isLocked2).toBe(true);
+  });
+
+  it('should clean up old processed messages', () => {
+    vi.useFakeTimers();
+    const oldMessageId = 'old_msg';
+    const newMessageId = 'new_msg';
+    
+    // Add messages with different timestamps
+    messageManager['processedMessages'].set(oldMessageId, Date.now() - 3700000); // older than 1 hour
+    messageManager['processedMessages'].set(newMessageId, Date.now()); // current
+
+    // Trigger cleanup by advancing time and running interval callback
+    const cleanupInterval = setInterval(() => {
+      const oneHourAgo = Date.now() - 3600000;
+      for (const [key, timestamp] of messageManager['processedMessages'].entries()) {
+        if (timestamp < oneHourAgo) {
+          messageManager['processedMessages'].delete(key);
+        }
+      }
+    }, 3600000);
+
+    vi.advanceTimersByTime(3600000);
+
+    // Check if old message was cleaned up
+    expect(messageManager['processedMessages'].has(oldMessageId)).toBe(false);
+    expect(messageManager['processedMessages'].has(newMessageId)).toBe(true);
+
+    clearInterval(cleanupInterval);
+    vi.useRealTimers();
+  });
+});