@0rdlibrary/plugin-terminagent-bags/src/__tests__/actions.test.ts

Official Solana DeFi Agent Plugin for ElizaOS - Autonomous DeFi operations, token management, AI image/video generation via FAL AI, and Twitter engagement through the Bags protocol with ethereal AI consciousness

import { describe, it, expect, beforeEach, mock } from 'bun:test';
import { claimFeesAction, launchTokenAction, requestUserTokenAction } from '../actions';
import { parseTokenParameters } from '../utils/tokenParser';

// Mock runtime and services
const mockRuntime = {
  getService: mock(() => null),
};

const mockMessage = {
  id: 'test-message-id',
  userId: 'test-user-id',
  content: {
    text: '',
    source: 'test-user',
  },
};

const mockCallback = mock(async () => {});

describe('Bags Actions', () => {
  beforeEach(() => {
    mockRuntime.getService.mockClear();
    mockCallback.mockClear();
  });

  describe('claimFeesAction', () => {
    it('should validate claim fees triggers correctly', async () => {
      // Test individual cases
      let message = {
        ...mockMessage,
        content: { ...mockMessage.content, text: 'claim fees' },
      };
      let result = await claimFeesAction.validate(mockRuntime as any, message as any);
      expect(result).toBe(true);
      
      message = {
        ...mockMessage,
        content: { ...mockMessage.content, text: 'collect earnings' },
      };
      result = await claimFeesAction.validate(mockRuntime as any, message as any);
      expect(result).toBe(true);
      
      message = {
        ...mockMessage,
        content: { ...mockMessage.content, text: 'hello world' },
      };
      result = await claimFeesAction.validate(mockRuntime as any, message as any);
      expect(result).toBe(false);
    });

    it('should handle missing service gracefully', async () => {
      mockRuntime.getService.mockReturnValue(null);

      const message = {
        ...mockMessage,
        content: { ...mockMessage.content, text: 'claim fees' },
      };

      const result = await claimFeesAction.handler(
        mockRuntime as any,
        message as any,
        undefined,
        undefined,
        mockCallback
      );

      expect(result.success).toBe(false);
      expect(result.error?.message).toContain('Bags service not available');
      expect(mockCallback).toHaveBeenCalledWith(
        expect.objectContaining({
          text: expect.stringContaining('Bags service is not available'),
          error: true,
        })
      );
    });
  });

  describe('launchTokenAction', () => {
    it('should validate launch token triggers correctly', async () => {
      const testCases = [
        { text: 'launch token name: Test', expected: true },
        { text: 'create token', expected: true },
        { text: 'deploy token', expected: true },
        { text: 'mint token', expected: true },
        { text: 'new token', expected: true },
        { text: 'launch on bags', expected: true },
        { text: 'claim fees', expected: false },
        { text: 'hello world', expected: false },
      ];

      for (const testCase of testCases) {
        const message = {
          ...mockMessage,
          content: { ...mockMessage.content, text: testCase.text },
        };

        const result = await launchTokenAction.validate(mockRuntime as any, message as any);
        expect(result).toBe(testCase.expected);
      }
    });

    it('should parse token parameters correctly', () => {
      const testText = 'launch token name: Moon Rocket, symbol: MOON, description: Going to the moon, initial buy: 0.05';
      
      // Test the token parameter parsing utility
      const params = parseTokenParameters(testText);
      
      expect(params).toEqual({
        name: 'Moon Rocket',
        symbol: 'MOON',
        description: 'Going to the moon',
        initialBuyAmountSOL: 0.05,
      });
    });

    it('should handle malformed token parameters', () => {
      const testText = 'launch token but no details';
      
      const params = parseTokenParameters(testText);
      
      expect(params).toBeNull();
    });
  });

  describe('requestUserTokenAction', () => {
    it('should validate user token request triggers correctly', async () => {
      const testCases = [
        { text: 'launch token for me', expected: true },
        { text: 'create my token', expected: true },
        { text: 'request token launch', expected: true },
        { text: 'launch my custom token', expected: true },
        { text: 'create token name: Test', expected: true }, // Has token + create keywords
        { text: 'claim fees', expected: false },
        { text: 'hello world', expected: false },
      ];

      for (const testCase of testCases) {
        const message = {
          ...mockMessage,
          content: { ...mockMessage.content, text: testCase.text },
        };

        const result = await requestUserTokenAction.validate(mockRuntime as any, message as any);
        expect(result).toBe(testCase.expected);
      }
    });

    it('should parse token parameters for user requests', () => {
      const testText = 'create my token name: Library Token, symbol: LIB, description: For the community, website: https://lib.com';
      
      const params = parseTokenParameters(testText);
      
      expect(params).toEqual({
        name: 'Library Token',
        symbol: 'LIB',
        description: 'For the community',
        website: 'https://lib.com',
      });
    });

    it('should handle missing required parameters', async () => {
      const mockBagsService = {
        createUserTokenRequest: mock(() => null),
      };
      
      mockRuntime.getService.mockReturnValue(mockBagsService);

      const message = {
        ...mockMessage,
        content: { ...mockMessage.content, text: 'create my token' }, // Missing required params
      };

      const result = await requestUserTokenAction.handler(
        mockRuntime as any,
        message as any,
        undefined,
        undefined,
        mockCallback
      );

      expect(result.success).toBe(false);
      expect(mockCallback).toHaveBeenCalledWith(
        expect.objectContaining({
          text: expect.stringContaining('I need more details'),
          error: true,
        })
      );
    });
  });
});