# TestMonitor MCP

> TestMonitor MCP Server reads your entire QA project history directly into your chat window. It lists projects, fetches test runs and milestones, audits defects via `list_issues`, or maps requirements against features—all without you leaving your AI client. Get the full picture of your codebase's quality status instantly.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Tags:** qa-testing, test-runs, requirements-management, milestone-tracking, test-coverage, issue-tracking

## Description

You're tired of clicking through a dozen dashboards just to figure out if your code actually works. The **TestMonitor MCP Server** connects your entire QA project history directly into your chat window. You don't have to navigate web UIs; you just ask your AI client, and it handles the digging for you. It pulls everything—project status, test results, reported bugs, requirements mapping—all from one place.

When you connect this server, you get instant access to every piece of data defining your product's quality. You can look at what's done, what's broken, and who signed off on it, all without leaving your chat interface. It’s the full picture of your codebase's health, right now.

**Project Scope & Metadata**

To start, you use `list_projects` to pull a list of every project ID sitting on your TestMonitor instance. Need more info? Use `get_project_details` with a specific ID to grab full metadata, including the current status and overall scope for that particular effort. You can also run `list_requirements`, which pulls a comprehensive list of all business requirements tied to the target project's scope so you know exactly what the product's supposed to do.

**Testing & Execution Auditing**

When it comes to testing, this server gives you deep visibility. You can run `list_test_runs` to get a list of all test cycles—both completed and pending—for the project. If you want details on one specific attempt, use `get_test_run_details`. That tells you exactly how many tests passed versus failed, and what the overall status was for that particular run instance.

If you need to check out the individual components of your test suite, first call `list_test_cases` to get a list of every available test case in scope. Then, use `get_test_case_details` to retrieve the full setup and expected steps for any single test case. You can also track project progress by calling `list_milestones`, which pulls all defined milestones, helping you see if the team hit its targets.

**Defect Tracking & Team Audit**

When things go wrong, this server makes it easy to find out why. Use `list_issues` to pull a definitive list of defects and reported issues from any specified project scope. You'll get details on what broke and where the fix needs to happen.

To confirm who owns what or who signed off on changes, you can call `list_account_users`. This tool pulls every user account provisioned in your TestMonitor workspace so you've got your role verification ready. Together, these tools let you look at project scope, list requirements, check all the runs and milestones, find every bug reported via `list_issues`, or get the setup details for a single test case—you can map it out completely from your chat window.

## Tools

### get_test_case_details
Retrieves the full setup and expected steps for a single test case.

### get_project_details
Fetches specific metadata for one TestMonitor project ID.

### get_test_run_details
Gets detailed results, passed/failed counts, and status for one specific test run instance.

### list_test_cases
Lists every test case available within a specific TestMonitor project.

### list_issues
Pulls a list of defects and reported issues from a specified project scope.

### list_milestones
Retrieves all defined milestones for the current project.

### list_projects
Lists every available project ID on your TestMonitor instance.

### list_requirements
Pulls a list of all business requirements defined for the target project.

### list_test_runs
Retrieves a list of all completed and pending test runs for the target project.

### list_account_users
Lists all user accounts tied to the TestMonitor workspace.

## Prompt Examples

**Prompt:** 
```
List all TestMonitor projects.
```

**Response:** 
```
Found 1 project:
`ID: 8840` | Name: "Vinkius CRM Engine V2" | Status: **Active**
I can retrieve the related milestones, test cases, or registered issues matching ID 8840.
```

**Prompt:** 
```
Get me the details for Test Case ID 5521 from project 8840.
```

**Response:** 
```
Detailing Case `5521` (API Logout Auth Rejection):
- **Status:** Approved
- **Requirement ID Linked:** REQ-10
- **Step 1:** Force invalid Bearer string to the `/auth/logout` endpoint. Expected: Returns raw 401 HTTP unauthorized block immediately.
- **Step 2:** Ensure cache header remains un-poisoned. Expected: True.
Anything I can rewrite from this?
```

**Prompt:** 
```
List all issues for Project 8840.
```

**Response:** 
```
Gathering active issues for Project 8840:
1. **Issue ID:** `ISS-91` | Title: 'Registration Webhook drops payload' | State: In Progress
2. **Issue ID:** `ISS-99` | Title: 'Avatar uploads broken on edge' | State: Open
The project seems to currently host 2 vital reported defects. Should I inspect linked tests for `ISS-91`?
```

## Capabilities

### List and filter all projects
The server retrieves a list of every project ID available on your TestMonitor instance.

### Get details for one specific project
It fetches full metadata, including status and scope, for any given project ID.

### Audit all reported defects/issues
The tool pulls a list of issues (defects) from a specified project ID.

### Track test runs and milestones
You can retrieve lists of all available milestones, or details for any specific test execution run.

### List and read requirements
The server pulls a comprehensive list of business requirements tied to the project scope.

### Lookup user assignments
It lists every user account provisioned in your TestMonitor workspace for role verification.

## Use Cases

### The Pre-Standup Status Check
A QA Director needs to report on the status of three projects before a standup. Instead of opening three dashboards, they prompt: 'Give me milestones and test runs for Project A, B, and C.' The agent uses `list_milestones` and `list_test_runs` multiple times and compiles a single, actionable summary in the chat.

### Triage a Critical Bug
A bug triager finds an issue ID. They ask the agent to pull all details for that defect using `list_issues`, then cross-reference it with requirements using `list_requirements` to ensure the bug isn't related to old, unrecorded features.

### Onboarding a New Team Member
A new engineer needs to understand the project scope. They ask: 'What are all the active projects and who works on them?' The agent uses `list_projects` and then runs `list_account_users` to build an immediate, comprehensive resource document.

### Validating Feature Scope
A Product Owner wants to confirm that a new feature (REQ-10) has adequate testing coverage. They ask the agent to list requirements using `list_requirements` and then check linked test cases via `list_test_cases`, verifying nothing was missed.

## Benefits

- **Immediate Defect Visibility:** Instead of navigating to the Issues tab, just ask for defects. `list_issues` pulls all reported bugs for a project instantly, letting you see if an issue is 'Open' or 'In Progress'.
- **Full Requirement Mapping:** Stop manually checking boxes. Use `list_requirements` and map them against active test cases—it tells you which feature specs are fully covered by tests.
- **Test Run Deep Dive:** You get more than just a pass/fail count. `get_test_run_details` shows the full history and specific results for any single execution run, making debugging faster.
- **Scope Management:** Need to know what's running? `list_projects` gives you an inventory of every project ID available in your environment right away.
- **Team Accountability:** Quickly confirm who owns a feature or bug. The `list_account_users` tool shows all provisioned users, eliminating guesswork about team roles.

## How It Works

The bottom line is you use natural conversation to run complex QA queries that used to require logging into multiple web dashboards.

1. First, subscribe to the server and provide your Subdomain and Personal Access Token.
2. Next, tell your AI client exactly what you need—for example: 'What are the issues for project 8840?'
3. The agent calls the right tool (e.g., `list_issues`), processes the data, and returns a clean summary directly to your chat.

## Frequently Asked Questions

**How do I list all projects using TestMonitor MCP Server?**
You call `list_projects`. This tool returns a complete inventory of every project ID on the instance, which you then need to feed into other tools like `list_issues`.

**What is the difference between `get_test_cases_details` and `get_project_details`?**
`get_test_case_details` gives you a step-by-step breakdown of one specific test. `get_project_details` provides high-level metadata about the entire project, like its overall status or coverage score.

**Can I check for defects using `list_issues`?**
Yes, that's exactly what it does. You provide a Project ID, and `list_issues` returns all currently reported defects attached to that project scope.

**How do I find out who is assigned to the account?**
Use the `list_account_users` tool. This fetches a simple list of every user provisioned in your workspace, which helps you confirm ownership or roles.

**What does calling `list_milestones` show about a project's timeline?**
It retrieves all defined milestones for a given project. This lets you track the scheduled progress and due dates, giving you a clear view of overall delivery status.

**How do I use `list_requirements` to map feature specifications?**
You provide the Project ID to pull all core requirements for that project. This allows your agent to cross-reference specific features against existing test cases or reported issues.

**What details does `get_test_run_details` return for a specific run?**
This tool gives you a complete report card for one test execution. You get granular data on which steps passed, failed, and the overall metrics of that particular test cycle.

**If I use `list_test_runs`, what information can I gather about history?**
You must specify a Project ID to index all historical runs. This tool gathers records for every completed or in-progress test run, letting you track performance over time.

**Does this tool automate actual user interface tests on websites?**
No. TestMonitor is essentially a Test Management Hub. You document your cases, requirements, runs, and defect reports structurally. The MCP server reads this deep structural data allowing the AI to help correlate bugs to requirements and plan sprints—it does not inherently control a web-browser headless tester to run things.

**Which ID should I pass to fetch Test Runs or Cases?**
Almost all context actions downstream require a `project_id`. Start by telling your prompt: 'List all my TestMonitor projects'. Take the numeric ID corresponding to your target platform, then use it as the anchor for subsequent 'list test cases', 'list runs', or 'list issues' queries.

**Where do I track the Personal Access Token setting?**
It is tied to your individual profile. Log in via web, go to the top right avatar, pick 'My Account', open the 'API' sub-tab, and hit 'Create Token'. Copy it precisely because it is obscured upon closing.