# 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.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.tuannvm.com/slack-mcp-client/docs/test.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.