cd apps/agent

# Run all tests with coverage
uv run pytest

# Run only unit tests
uv run pytest tests/unit/

# Run specific test file
uv run pytest tests/unit/test_shell_security.py -v

# Run tests matching pattern
uv run pytest -k "test_blocks"

# Run with verbose output
uv run pytest -v --tb=long

# Generate HTML coverage report
uv run pytest --cov-report=html
# Open htmlcov/index.html in browser

cd apps/gateway

# Run all tests
npm test

# Run with coverage
npm run test:coverage

# Run in watch mode
npm run test:watch

# Run specific test file
npx vitest run src/skills/SkillManager.test.ts

import pytest
from ag3nt_agent.shell_security import ShellSecurityValidator, SecurityLevel

class TestShellSecurityValidator:
    """Tests for ShellSecurityValidator."""

    @pytest.fixture
    def validator(self):
        """Create a validator instance for testing."""
        return ShellSecurityValidator()

    def test_blocks_rm_rf_root(self, validator):
        """Should block recursive deletion of root."""
        level, reason = validator.validate("rm -rf /")
        assert level == SecurityLevel.BLOCK
        assert "root" in reason.lower()

    def test_allows_safe_commands(self, validator):
        """Should allow common safe commands."""
        safe_commands = ["ls -la", "cat file.txt", "echo hello"]
        for cmd in safe_commands:
            level, _ = validator.validate(cmd)
            assert level == SecurityLevel.ALLOW

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { SessionManager } from '@/session/SessionManager';

describe('SessionManager', () => {
  let manager: SessionManager;

  beforeEach(() => {
    manager = new SessionManager();
  });

  it('creates new session for unknown user', async () => {
    const session = await manager.getOrCreate({
      channelType: 'cli',
      channelId: 'test',
      userId: 'user1',
    });
    expect(session.id).toBeDefined();
    expect(session.userId).toBe('user1');
  });

  it('returns existing session for known user', async () => {
    const first = await manager.getOrCreate({ ... });
    const second = await manager.getOrCreate({ ... });
    expect(first.id).toBe(second.id);
  });
});

from unittest.mock import AsyncMock, patch, MagicMock

# Mock a function
with patch('ag3nt_agent.tools.web_search.TavilyClient') as mock:
    mock.return_value.search.return_value = {'results': []}
    # test code

# Mock async function
mock_client = AsyncMock()
mock_client.generate.return_value = "response"

# Use pytest-mock fixture
def test_something(mocker):
    mocker.patch('module.function', return_value='mocked')

import { vi } from 'vitest';

// Mock a module
vi.mock('@/services/llm', () => ({
  LLMService: vi.fn().mockImplementation(() => ({
    generate: vi.fn().mockResolvedValue('response'),
  })),
}));

// Spy on a method
const spy = vi.spyOn(service, 'method');
expect(spy).toHaveBeenCalledWith('arg');