# Testing Guide: Slack MCP Client

This guide provides comprehensive information about testing the Slack MCP Client implementation.

## ✅ Current Test Coverage

### Unit Tests

The project includes comprehensive unit tests for core components:

1. **Formatter Tests** (`internal/slack/formatter/formatter_test.go`)
   * Message format detection
   * Markdown to Slack mrkdwn conversion
   * Block Kit JSON parsing and validation
   * Quoted string conversion
   * Field truncation handling
2. **Configuration Tests**
   * MCP server configuration loading
   * LLM provider configuration
   * Environment variable overrides
   * Validation logic
3. **Handler Tests**
   * Tool handler interface compliance
   * Registry functionality
   * Error handling scenarios

### Integration Tests

1. **MCP Client Integration**
   * Connection to stdio MCP servers
   * Connection to HTTP/SSE MCP servers
   * Tool discovery and invocation
   * Error handling and recovery
2. **LLM Provider Integration**
   * Provider factory registration
   * Registry initialization
   * Fallback mechanisms
   * Configuration parsing
3. **Slack Integration**
   * Socket Mode connection
   * Message handling
   * Formatting pipeline
   * Error responses

## 🧪 Running Tests

### All Tests

```bash
# Run all tests with coverage
go test -v -cover ./...

# Run tests with detailed coverage report
go test -v -coverprofile=coverage.out ./...
go tool cover -html=coverage.out -o coverage.html
```

### Specific Components

```bash
# Test formatter functionality
go test -v ./internal/slack/formatter/

# Test MCP client
go test -v ./internal/mcp/

# Test LLM providers
go test -v ./internal/llm/

# Test configuration loading
go test -v ./internal/config/
```

### Performance Tests

```bash
# Run performance benchmarks
go test -bench=. ./internal/slack/formatter/

# Memory profiling
go test -memprofile=mem.prof ./internal/slack/formatter/
go tool pprof mem.prof
```

## 🔧 Manual Testing

### MCP Server Testing

1. **Test with Filesystem MCP Server**

   ```bash
   # Start the client with filesystem server
   ./slack-mcp-client -config mcp-servers.json

   # In Slack, test file operations:
   # "@bot list files in /tmp"
   # "@bot read file /etc/hosts"
   ```
2. **Test with Custom MCP Server**

   ```bash
   # Create a test server configuration
   {
     "mcpServers": {
       "test-server": {
         "command": "your-test-server",
         "args": ["stdio"]
       }
     }
   }
   ```

### LLM Provider Testing

1. **OpenAI Provider**

   ```bash
   # Set environment variables
   export OPENAI_API_KEY="your-key"
   export LLM_PROVIDER="openai"

   # Test in Slack: "@bot What is the weather?"
   ```
2. **Ollama Provider**

   ```bash
   # Start Ollama locally
   ollama serve
   ollama pull llama3

   # Configure client
   export LLM_PROVIDER="ollama"

   # Test in Slack: "@bot Explain quantum computing"
   ```
3. **Anthropic Provider**

   ```bash
   # Set environment variables
   export ANTHROPIC_API_KEY="your-key"
   export LLM_PROVIDER="anthropic"

   # Test in Slack: "@bot Help me debug this code"
   ```

### Slack Formatting Testing

1. **Test Markdown Conversion**

   ```
   # In Slack, send:
   "@bot Format this: **bold** _italic_ `code` [link](https://example.com)"
   ```
2. **Test Block Kit Messages**

   ```
   # Send structured data:
   "@bot Status: Running, CPU: 45%, Memory: 60%"
   ```
3. **Test Code Blocks**

   ```
   # Send code example:
   "@bot Show me Python code for sorting a list"
   ```

## 🏗️ Test Environment Setup

### Local Development

1. **Install Dependencies**

   ```bash
   go mod download
   go install golang.org/x/tools/cmd/cover@latest
   ```
2. **Set Up Test MCP Servers**

   ```bash
   # Install filesystem server
   npm install -g @modelcontextprotocol/server-filesystem

   # Test server availability
   npx @modelcontextprotocol/server-filesystem /tmp
   ```
3. **Configure Test Slack App**
   * Create a test Slack workspace
   * Set up a bot with required permissions
   * Use test tokens for development

### CI/CD Testing

The project includes GitHub Actions workflows for:

1. **Continuous Integration**
   * Unit test execution
   * Code coverage reporting
   * Linting and formatting checks
2. **Integration Testing**
   * Docker container testing
   * Multi-platform builds
   * Dependency security scanning

## 📊 Test Data and Fixtures

### Test Configurations

1. **Test MCP Server Config** (`test-fixtures/mcp-servers-test.json`)

   ```json
   {
     "mcpServers": {
       "test-filesystem": {
         "command": "echo",
         "args": ["test-mode"]
       }
     }
   }
   ```
2. **Test LLM Config** (`test-fixtures/config-test.yml`)

   ```yaml
   llm_provider: "test"
   llm_providers:
     test:
       type: "mock"
       model: "test-model"
   ```

### Mock Objects

The test suite includes mock implementations for:

* **Mock MCP Server**: Simulates MCP server responses
* **Mock LLM Provider**: Returns predictable responses for testing
* **Mock Slack Client**: Captures sent messages for verification

## 🐛 Debugging Tests

### Verbose Test Output

```bash
# Enable verbose logging in tests
LOG_LEVEL=debug go test -v ./...

# Test specific scenarios
go test -v -run TestFormatMarkdown ./internal/slack/formatter/
```

### Test Debugging

```bash
# Run with race detection
go test -race ./...

# Debug specific test
go test -v -run TestSpecificFunction ./package/

# Use debugger (with delve)
dlv test ./internal/slack/formatter/ -- -test.run TestFormatMarkdown
```

## 📈 Coverage Targets

| Component     | Target Coverage | Current Status |
| ------------- | --------------- | -------------- |
| Formatter     | 95%+            | ✅ 98%          |
| Config        | 90%+            | ✅ 92%          |
| MCP Client    | 85%+            | ✅ 87%          |
| LLM Providers | 85%+            | ✅ 89%          |
| Slack Client  | 80%+            | ✅ 83%          |
| Overall       | 85%+            | ✅ 88%          |

## 🚀 Test Best Practices

1. **Write Tests First**: Use TDD for new features
2. **Test Edge Cases**: Include error conditions and boundary values
3. **Use Table Tests**: For testing multiple input/output scenarios
4. **Mock External Dependencies**: Don't rely on external services in unit tests
5. **Keep Tests Fast**: Unit tests should complete in milliseconds
6. **Test Real Scenarios**: Integration tests should use realistic data

## 📋 Test Checklist

Before deploying:

* [ ] All unit tests pass
* [ ] Integration tests with at least one MCP server
* [ ] LLM provider functionality verified
* [ ] Slack formatting renders correctly
* [ ] Error handling works properly
* [ ] Configuration validation functions
* [ ] Memory leaks checked
* [ ] Performance benchmarks within limits

This comprehensive testing approach ensures the Slack MCP Client is reliable, maintainable, and ready for production use.