chore(add-tests): plugin anyone: test config and test coverage (elizaOS#2854)

* plugin-anyone: vitest config

* plugin-anyone: vitest config

* plugin-anyone: vitest config - fixing coverage

* plugin-anyone: start anyone tests

* plugin-anyone: stop anyone tests

---------

Co-authored-by: Sayo <hi@sayo.wtf>

Author: ai16z-demirix

packages/plugin-anyone/__tests__/actions/startAnyone.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { startAnyone } from '../../src/actions/startAnyone';
+import { AnyoneClientService } from '../../src/services/AnyoneClientService';
+import { AnyoneProxyService } from '../../src/services/AnyoneProxyService';
+
+vi.mock('../../src/services/AnyoneClientService', () => ({
+    AnyoneClientService: {
+        initialize: vi.fn(),
+        getInstance: vi.fn(),
+        stop: vi.fn(),
+    }
+}));
+
+vi.mock('../../src/services/AnyoneProxyService', () => ({
+    AnyoneProxyService: {
+        getInstance: vi.fn(() => ({
+            initialize: vi.fn(),
+            cleanup: vi.fn()
+        }))
+    }
+}));
+
+describe('startAnyone Action', () => {
+    const mockRuntime = {
+        getSetting: vi.fn(),
+        getState: vi.fn(),
+        setState: vi.fn(),
+    };
+
+    const mockMessage = {
+        content: {
+            text: 'Start Anyone',
+            type: 'START_ANYONE'
+        }
+    };
+
+    const mockState = {};
+    const mockCallback = vi.fn();
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('validate', () => {
+        it('should validate successfully', async () => {
+            const result = await startAnyone.validate(mockRuntime, mockMessage);
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('handler', () => {
+        it('should initialize AnyoneClientService and AnyoneProxyService', async () => {
+            const mockProxyInstance = {
+                initialize: vi.fn(),
+                cleanup: vi.fn()
+            };
+            vi.mocked(AnyoneProxyService.getInstance).mockReturnValue(mockProxyInstance);
+
+            const result = await startAnyone.handler(
+                mockRuntime,
+                mockMessage,
+                mockState,
+                {},
+                mockCallback
+            );
+
+            expect(AnyoneClientService.initialize).toHaveBeenCalled();
+            expect(AnyoneProxyService.getInstance).toHaveBeenCalled();
+            expect(mockProxyInstance.initialize).toHaveBeenCalled();
+            expect(mockCallback).toHaveBeenCalledWith({
+                text: 'Started Anyone'
+            });
+            expect(result).toBe(true);
+        });
+
+        it('should handle initialization errors gracefully', async () => {
+            const error = new Error('Initialization failed');
+            vi.mocked(AnyoneClientService.initialize).mockRejectedValue(error);
+
+            await expect(
+                startAnyone.handler(mockRuntime, mockMessage, mockState, {}, mockCallback)
+            ).rejects.toThrow('Initialization failed');
+        });
+    });
+
+    describe('metadata', () => {
+        it('should have correct name and similes', () => {
+            expect(startAnyone.name).toBe('START_ANYONE');
+            expect(startAnyone.similes).toEqual(['ANYONE']);
+        });
+
+        it('should have valid examples', () => {
+            expect(Array.isArray(startAnyone.examples)).toBe(true);
+            expect(startAnyone.examples.length).toBeGreaterThan(0);
+            
+            startAnyone.examples.forEach(example => {
+                expect(Array.isArray(example)).toBe(true);
+                expect(example.length).toBe(2);
+                expect(example[1].content.action).toBe('START_ANYONE');
+            });
+        });
+    });
+});

packages/plugin-anyone/__tests__/actions/stopAnyone.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { stopAnyone } from '../../src/actions/stopAnyone';
+import { AnyoneClientService } from '../../src/services/AnyoneClientService';
+import { AnyoneProxyService } from '../../src/services/AnyoneProxyService';
+
+vi.mock('../../src/services/AnyoneClientService', () => ({
+    AnyoneClientService: {
+        initialize: vi.fn(),
+        getInstance: vi.fn(),
+        stop: vi.fn(),
+    }
+}));
+
+vi.mock('../../src/services/AnyoneProxyService', () => ({
+    AnyoneProxyService: {
+        getInstance: vi.fn(() => ({
+            initialize: vi.fn(),
+            cleanup: vi.fn()
+        }))
+    }
+}));
+
+describe('stopAnyone Action', () => {
+    const mockRuntime = {
+        getSetting: vi.fn(),
+        getState: vi.fn(),
+        setState: vi.fn(),
+    };
+
+    const mockMessage = {
+        content: {
+            text: 'Stop Anyone',
+            type: 'STOP_ANYONE'
+        }
+    };
+
+    const mockState = {};
+    const mockCallback = vi.fn();
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    describe('validate', () => {
+        it('should validate successfully', async () => {
+            const result = await stopAnyone.validate(mockRuntime, mockMessage);
+            expect(result).toBe(true);
+        });
+    });
+
+    describe('handler', () => {
+        it('should stop AnyoneClientService and cleanup AnyoneProxyService', async () => {
+            const mockProxyInstance = {
+                initialize: vi.fn(),
+                cleanup: vi.fn()
+            };
+            vi.mocked(AnyoneProxyService.getInstance).mockReturnValue(mockProxyInstance);
+
+            const result = await stopAnyone.handler(
+                mockRuntime,
+                mockMessage,
+                mockState,
+                {},
+                mockCallback
+            );
+
+            expect(mockProxyInstance.cleanup).toHaveBeenCalled();
+            expect(AnyoneClientService.stop).toHaveBeenCalled();
+            expect(mockCallback).toHaveBeenCalledWith({
+                text: 'Stopped Anyone and cleaned up proxy'
+            });
+            expect(result).toBe(true);
+        });
+
+        it('should handle cleanup errors gracefully', async () => {
+            const error = new Error('Cleanup failed');
+            vi.mocked(AnyoneClientService.stop).mockRejectedValue(error);
+
+            await expect(
+                stopAnyone.handler(mockRuntime, mockMessage, mockState, {}, mockCallback)
+            ).rejects.toThrow('Cleanup failed');
+        });
+    });
+
+    describe('metadata', () => {
+        it('should have correct name and similes', () => {
+            expect(stopAnyone.name).toBe('STOP_ANYONE');
+            expect(stopAnyone.similes).toEqual(['STOP_PROXY']);
+        });
+
+        it('should have valid examples', () => {
+            expect(Array.isArray(stopAnyone.examples)).toBe(true);
+            expect(stopAnyone.examples.length).toBeGreaterThan(0);
+            
+            stopAnyone.examples.forEach(example => {
+                expect(Array.isArray(example)).toBe(true);
+                expect(example.length).toBe(2);
+                expect(example[1].content.action).toBe('STOP_ANYONE');
+            });
+        });
+    });
+});

packages/plugin-anyone/package.json

@@ -10,9 +10,16 @@
         "axios": "^1.7.9",
         "tsup": "8.3.5"
     },
+    "devDependencies": {
+        "vitest": "^1.2.1",
+        "@vitest/coverage-v8": "^1.2.1"
+    },
     "scripts": {
         "build": "tsup --format esm --dts",
-        "dev": "tsup --format esm --dts --watch"
+        "dev": "tsup --format esm --dts --watch",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:coverage": "vitest run --coverage"
     },
     "peerDependencies": {
         "whatwg-url": "7.1.0"

packages/plugin-anyone/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['__tests__/**/*.test.ts'],
+        mockReset: true,
+        clearMocks: true,
+        restoreMocks: true,
+    },
+});