New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Frontmcp Testing

by agentfront in agentfront/frontmcp

A skill your agent uses for anything about testing FrontMCP servers: writing or running unit, integration, and E2E tests and reaching the 95%+ coverage bar.

Apache-2.0Auto-check: notesTesting & QA

Install Frontmcp Testing

skills CLI
$ npx skills add agentfront/frontmcp --skill frontmcp-testing -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install agentfront/frontmcp frontmcp-testing --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/agentfront/frontmcp.git skills-src && mkdir -p .claude/skills && cp -r skills-src/libs/skills/catalog/frontmcp-testing .claude/skills/frontmcp-testing && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
frontmcp-testing
GitHub stars
146
Token cost
~10k tokens
SKILL.md length
2,086 words
Files
28 (incl. references)
Skills in repo
12
Repo updated
First seen
Licence
Apache-2.0

At a glance

A skill your agent uses for anything about testing FrontMCP servers: writing or running unit, integration, and E2E tests and reaching the 95%+ coverage bar.

  • Works in 5 steps: Pick the test layer — unit (fastest,… → Pick the component flavour — tool /… → Pick the runtime concern — auth,… → …
  • Anything about testing FrontMCP servers: writing
  • SKILL.md covers When to Use This Skill, Prerequisites, Steps and Scenario Routing Table, plus 8 more sections
  • Calls nx and jest

What it does

Frontmcp Testing is an agent skill from agentfront/frontmcp. Use for anything about testing FrontMCP servers: writing or running unit, integration, and E2E tests and reaching the 95%+ coverage bar. Covers Jest setup and coverage gating; unit-testing a ToolContext execute() with mock context, inputs, and Zod schema validation; testing resources and prompts; in-memory testing via create() and connectOpenAI / connectClaude (no HTTP); full MCP-protocol E2E over HTTP with McpTestClient and TestServer; authenticated tests with TestTokenFactory, MockOAuthServer, and role-based…

Its SKILL.md is about 10k tokens, which your agent loads only when the skill is triggered. The skill folder holds 34 other files, including reference files (for example `examples/setup-testing/fixture-based-e2e-test.md`, `examples/setup-testing/jest-config-with-coverage.md` and `examples/setup-testing/unit-test-tool-resource-prompt.md`).

It sits in Testing & QA, covering Unit testing, End-to-end testing and Authorization and RBAC. It works with Jest, Model Context Protocol, Playwright and Zod. The repository describes itself as: TypeScript-first framework for the Model Context Protocol (MCP). You write clean, typed code; FrontMCP handles the protocol, transport, DI, session/auth, and execution flow. The licence is Apache-2.0.

When your agent uses it

  • Anything about testing FrontMCP servers: writing
  • E2E tests and reaching the 95%+ coverage bar

Example prompts

  • “/frontmcp-testing”

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. Pick the test layer — unit (fastest, mock DI), integration (real DI scope), or E2E (real MCP client + server). Use the Testing Strategy…
  2. Pick the component flavour — tool / resource / prompt / agent / job — each has a distinct recipe.
  3. Pick the runtime concern — auth, browser/CLI build, direct vs streamable transport — and add the matching reference to your reading list.
  4. Open the target reference (e.g. references/test-tool-unit.md, references/test-e2e-handler.md, references/test-auth.md) and follow its…
  5. Enforce coverage — confirm the project's 95%+ thresholds are wired into Jest before merging (see references/setup-testing.md).

What it can do on your machine

Read from SKILL.md and the folder at commit 8f59ba8. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • nx
    • jest

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • docs.agentfront.dev

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Frontmcp Testing loads about 10k tokens when it runs, and up to ~24k if it reads all its reference files. Until then it costs about 194 tokens; SKILL.md has 2,086 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~194
When it runs · the whole SKILL.md, loaded when a task matches
~10k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~24k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:102
    ironment        | `frontmcp test` loads `.env` / `.env.local` into the Jest child, same precedence as `dev` (real enviro
  • NoteMentions a .env fileSKILL.md:157
    | Specs see no `.env` values                                                        | An older CLI did not load `.env` f

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from agentfront/frontmcp at commit 8f59ba8, republished under its Apache-2.0 licence (© agentfront). 2,086 words, ~10,209 tokens.

Download SKILL.mdSave it as .claude/skills/frontmcp-testing/SKILL.md (or your agent's skills folder). This skill also uses 27 other files; get the full folder from GitHub.
name
frontmcp-testing
description
Use for anything about testing FrontMCP servers: writing or running unit, integration, and E2E tests and reaching the 95%+ coverage bar. Covers Jest setup and coverage gating; unit-testing a ToolContext execute() with mock context, inputs, and Zod schema validation; testing resources and prompts; in-memory testing via create() and connectOpenAI / connectClaude (no HTTP); full MCP-protocol E2E over HTTP with McpTestClient and TestServer; authenticated tests with TestTokenFactory, MockOAuthServer, and role-based access; browser-bundle validation with Playwright; and CLI-binary / SEA startup tests. Triggers: write tests, run tests, add e2e tests, improve coverage, test a tool / resource / prompt, mock auth, jest config. The skill for ALL testing needs.
when_to_use
Trigger when writing or running tests for a FrontMCP server: editing a *.spec.ts / *.e2e.spec.ts file or a jest config, setting up Jest or coverage gating…
paths
**/*.spec.ts, **/*.e2e.spec.ts, **/jest.config.*, **/jest.e2e.config.*
tags
router, testing, jest, e2e, coverage, quality, guide
category
testing
targets
all
bundle
recommended, full
priority
10
visibility
both
license
Apache-2.0
metadata.docs
https://docs.agentfront.dev/frontmcp/testing/overview

FrontMCP Testing Router

Entry point for testing FrontMCP applications. This skill helps you navigate testing strategies across component types and find the right patterns for unit, integration, and E2E tests.

When to Use This Skill

Must Use
  • Setting up testing infrastructure for a new FrontMCP project
  • Deciding how to test a specific component type (tool, resource, prompt, agent)
  • Planning a testing strategy that covers unit, E2E, and coverage requirements
  • Looking up testing patterns for a component type you haven't tested before
  • Understanding the relationship between unit tests, E2E tests, and coverage thresholds
  • Troubleshooting test failures or coverage gaps
Skip When
  • You need detailed Jest configuration and test harness setup (go directly to setup-testing)
  • You need to build components, not test them (see frontmcp-development)
  • You need to deploy, not test (see frontmcp-deployment)

Decision: Use this skill for testing strategy and routing. Open the setup-testing reference under references/ for hands-on Jest configuration and test writing.

Prerequisites

  • A FrontMCP project with at least one component to test (see frontmcp-development).
  • Jest installed and configured — if not, start with setup-testing before opening any other testing skill.
  • The component itself implemented and exported; tests reach decorated classes through the SDK, not by importing internal builders.

Steps

This is a router skill. Follow this order to pick a testing approach, then move to the target reference under references/.

  1. Pick the test layer — unit (fastest, mock DI), integration (real DI scope), or E2E (real MCP client + server). Use the Testing Strategy table below.
  2. Pick the component flavour — tool / resource / prompt / agent / job — each has a distinct recipe.
  3. Pick the runtime concern — auth, browser/CLI build, direct vs streamable transport — and add the matching reference to your reading list.
  4. Open the target reference (e.g. references/test-tool-unit.md, references/test-e2e-handler.md, references/test-auth.md) and follow its Steps section.
  5. Enforce coverage — confirm the project's 95%+ thresholds are wired into Jest before merging (see references/setup-testing.md).

Scenario Routing Table

ScenarioReference / SectionDescription
Set up Jest, coverage, and test harnesssetup-testingFull Jest config, test utilities, and coverage thresholds
Write unit tests for a tooltest-tool-unitMock DI, validate input/output, test error paths
Write unit tests for a resourcesetup-testing (Unit Testing)Test URI resolution, template params, read results
Write unit tests for a promptsetup-testing (Unit Testing)Test argument handling, message generation
Write E2E protocol-level testssetup-testing (E2E Testing)Real MCP client/server, full protocol flow
Test authenticated endpointstest-authE2E with OAuth tokens, session validation, role-based access
Test deployment buildssetup-testing + deploy-to-*Smoke tests against built output
Test browser buildstest-browser-buildSmoke-test a frontmcp build --target browser bundle (import the bundle, optional Playwright suite)
Test CLI binary buildstest-cli-binarySpawn-and-curl smoke tests for frontmcp build --target cli artifacts
Test with the direct API clienttest-direct-clientIn-memory testing via create(), connectOpenAI(), connectClaude() (no HTTP)
Write E2E test handler patternstest-e2e-handlerManual McpTestClient + TestServer E2E patterns (alternative to fixture API)
Unit test individual toolstest-tool-unitUnit testing individual ToolContext subclasses with a mock context

Testing Strategy by Component Type

ComponentUnit Test FocusE2E Test FocusKey Assertions
ToolInput validation, execute logic, error paths, DI mockingtools/call via MCP clientOutput matches schema, errors return MCP codes
ResourceURI resolution, read content, template param handlingresources/read via MCP clientContent type correct, URI patterns resolve
PromptArgument validation, message generation, multi-turnprompts/get via MCP clientMessages match expected structure
AgentLLM config, tool selection, handoff logicAgent loop via MCP clientTools called in order, result synthesized
ProviderLifecycle hooks, factory output, singleton behaviorIndirectly via tool/resource testsInstance reuse, cleanup on scope disposal
JobProgress tracking, retry logic, attempt countingJob execution via test harnessProgress events emitted, retries respected
WorkflowStep dependencies, conditions, input mapping functionsWorkflow run via test harnessSteps execute in order, conditions evaluated, continueOnError respected
SkillInstruction loading (inline/file/url), tool validationSkill discovery via MCP/HTTPInstructions resolve, tool refs validated per toolValidation mode
PluginContext extensions, provider registration, hook firingIndirectly via tool testsExtensions available on this, hooks fire at correct stages

Cross-Cutting Testing Patterns

PatternRule
File namingAlways .spec.ts (not .test.ts); E2E uses .e2e.spec.ts
File organizationSplit E2E tests by app/feature: e2e/calc.e2e.spec.ts, e2e/ecommerce.e2e.spec.ts. Never put all tests in a single server.e2e.spec.ts
Environmentfrontmcp test loads .env / .env.local into the Jest child, same precedence as dev (real environment wins over the files, config env.shared + env.test underneath). --no-env skips it
Test runnerStandalone projects: use frontmcp test (auto-generates Jest/SWC config; discovers src/**/*.spec.ts(x), __tests__/**/*.spec.ts(x), and e2e/**/*.e2e.spec.ts(x); transforms both .ts and .tsx with the automatic JSX runtime; transpiles ESM-only deps such as jose, @noble/hashes and @noble/ciphers (CodeCall) under npm, yarn AND pnpm's node_modules/.pnpm/ store — add your own via test.esmPackages in frontmcp.config.ts; does not force NODE_OPTIONS=--experimental-vm-modules (it would bypass the ESM transforms; scaffolded projects use Jest 30); delegates to a user-provided jest.config.{ts,js,mjs,cjs,json} if present, which drops the injected config unless it starts from preset: '@frontmcp/testing', which carries the same transform, discovery, timeout and ESM transforms). Nx monorepos: use nx test <lib> (resolves the project's jest.config.ts). Never invoke jest --config ... directly
Coverage threshold95%+ across statements, branches, functions, lines
Test descriptionsPlain English, no prefixes like "PT-001"; describe behavior not implementation
MockingMock providers via DI token replacement, never mock the framework
httpMock scopehttpMock intercepts HTTP in the test process only, NOT in the MCP server subprocess. Do not use httpMock to intercept server-to-API calls — those happen in the child process. Use httpMock for verifying client-to-server request shapes or mocking external APIs called from the test itself
Error testingAssert instanceof specific error class AND MCP error code
AsyncAlways await async operations; use expect(...).rejects.toThrow() for async errors

Common Patterns

PatternCorrectIncorrectWhy
Test file locationfetch-weather.tool.spec.ts next to source__tests__/fetch-weather.test.tsCo-location with .spec.ts extension matches FrontMCP conventions
DI mockingReplace token with mock via scope.register(TOKEN, mockImpl)jest.mock('../provider') module mockDI mocking is cleaner, type-safe, and tests the real integration path
Error assertionsexpect(err).toBeInstanceOf(ResourceNotFoundError)expect(err.message).toContain('not found')Class checks are stable; message strings are fragile
E2E transportUse @frontmcp/testing MCP client with real serverHTTP requests with fetchThe test client handles protocol details (session, framing)
Coverage gapsInvestigate uncovered branches, add targeted testsAdd istanbul ignore commentsCoverage gaps often hide real bugs; ignoring them defeats the purpose

Verification Checklist

Infrastructure
  • Jest configured with @frontmcp/testing preset
  • Coverage thresholds set to 95% in jest.config
  • Test files use .spec.ts extension throughout
Unit Tests
  • Each tool has unit tests covering happy path, validation errors, and DI failures
  • Each resource has unit tests covering URI resolution and read content
  • Provider lifecycle (init, dispose) tested where applicable
E2E Tests
  • At least one E2E test exercises full MCP protocol flow (connect, list, call, disconnect)
  • Authenticated E2E tests use proper test tokens (not mocked auth)
  • E2E tests clean up state after execution
CI Integration
  • Tests run in CI pipeline on every PR
  • Coverage report published and enforced
  • Failing tests block merge
Show full SKILL.md (950 more words)Show less

Troubleshooting

ProblemCauseSolution
Jest not finding test filesWrong file extension (.test.ts instead of .spec.ts)Rename to .spec.ts; check testMatch in jest.config
SyntaxError: Unexpected token 'export'An ESM-only dependency is being ignored instead of transpiledAdd it to test.esmPackages in frontmcp.config.ts. With a hand-written jest.config.ts, start from preset: '@frontmcp/testing' or use the pnpm-safe transformIgnorePatterns in setup-testing AND make sure transform matches .js (^.+\.[tj]sx?$ + allowJs) — un-ignoring a file does nothing if no transform matches it
Coverage below 95%Untested error paths or conditional branchesRun frontmcp test --coverage and inspect uncovered lines in the report
E2E test timeoutServer startup too slow or port conflictIncrease Jest timeout; use random port allocation
DI resolution fails in testsProvider not registered in test scopeRegister mock providers before creating the test context
Istanbul shows 0% on async methodsTypeScript source-map mismatch with IstanbulKnown issue with some TS compilation settings; verify coverage with actual test output
Specs see no .env valuesAn older CLI did not load .env for frontmcp test, only for devUpgrade the CLI — frontmcp test now loads .env / .env.local with the same precedence as dev (real environment wins, so CI secrets still override). Pass --no-env for a hermetic run
Invalid first argument, true at collection timetest.skip(condition, reason) reached Jest's skip(name, fn)Upgrade the CLI — the Playwright signature is supported: test.skip(!hasCredentials, 'credentials not set') skips every test registered after it in the enclosing block
test.use() in one describe leaks into another, or two files fight over a portOlder @frontmcp/testing kept one global config and per-process portsUpgrade — test.use() is scoped per describe and ports are locked across Jest workers; use port: 0
Every spec fails with HTTP 404 after setting http.entryPathThe test client always connected to the server rootUpgrade the CLI — the client now follows the entryPaths a 404 reports, and test.use({ entryPath: '/mcp' }) sets it explicitly
test.beforeEach(async ({ mcp }) => …) times out waiting for doneOlder @frontmcp/testing handed the hook to Jest, which read the parameter as doneUpgrade — hooks that take a parameter now receive the test's fixtures (same mcp as the test); beforeAll / afterAll never get fixtures
test.use({ transport: 'sse' }) throws "SSE transport not yet implemented"Older @frontmcp/testing had no legacy SSE clientUpgrade — 'sse' is the legacy HTTP+SSE transport; the server must enable it with transport: { protocol: { legacy: true } }
Module @swc/jest in the transform option was not found from frontmcp testOlder @frontmcp/testing did not install the transformer the injected config usesUpgrade — @frontmcp/testing depends on @swc/jest / @swc/core, and frontmcp test resolves the transformer through it
ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG from a server started inside a specOlder SDKs loaded the optional vectoriadb with import() at bootUpgrade the SDK — vectoriadb is a regular dependency, imported without import(); no --experimental-vm-modules needed

Examples

Each reference has matching examples under examples/<reference>/:

setup-testing
ExampleLevelDescription
fixture-based-e2e-testAdvancedWrite E2E tests using the fixture API from @frontmcp/testing that manages server lifecycle automatically and uses MCP-specific custom matchers.
jest-config-with-coverageBasicSet up a Jest configuration file that enforces 95%+ coverage across all metrics for a FrontMCP library.
unit-test-tool-resource-promptIntermediateWrite unit tests for the three core MCP primitives, verifying that outputs match the expected MCP response shapes.
test-auth
ExampleLevelDescription
oauth-flow-testAdvancedUse MockOAuthServer to simulate an OAuth identity provider and test the authorization code flow.
role-based-access-testIntermediateVerify that tools enforce role-based access by testing admin and user tokens against protected endpoints.
token-factory-testBasicUse TestTokenFactory to create tokens and verify authenticated and unauthenticated requests.
test-browser-build
ExampleLevelDescription
browser-bundle-validationBasicVerify that the browser build produces a valid bundle without Node.js-only module references.
playwright-browser-testAdvancedUse Playwright to test a browser-based MCP client that loads and calls tools from an MCP server.
test-cli-binary
ExampleLevelDescription
binary-startup-testBasicVerify that a compiled CLI binary starts correctly and responds to health checks.
js-bundle-import-testIntermediateVerify that the compiled JS bundle can be imported and exports the expected modules after a frontmcp build step.
test-direct-client
ExampleLevelDescription
basic-create-testBasicTest tools in-memory without any HTTP overhead using the create() function from @frontmcp/sdk.
openai-claude-format-testIntermediateVerify that tools are returned in the correct format for OpenAI and Claude clients using connectOpenAI and connectClaude.
test-e2e-handler
ExampleLevelDescription
basic-e2e-testBasicSet up a basic E2E test that starts a server, connects a client, and verifies tools are listed.
manual-client-with-transportAdvancedUse McpTestClient.create() with explicit transport settings for fine-grained control over E2E tests.
tool-call-and-error-e2eIntermediateTest successful tool calls and verify that invalid inputs produce proper error responses over the full MCP protocol.
test-tool-unit
ExampleLevelDescription
basic-tool-testBasicTest a simple tool's execute() method with mock context and verify the output.
schema-validation-testIntermediateValidate that a tool's Zod input schema rejects invalid data before execute() is called.
tool-error-handling-testAdvancedTest that a tool throws the correct MCP error classes with proper error codes and JSON-RPC error shapes.

Accessing This Skill

Skills are distributed as plain SKILL.md files plus a sibling references/ and examples/ tree, so consumers can pick whichever access mode fits:

ModeHow it works
FilesystemRead libs/skills/catalog/frontmcp-testing/ directly from a clone of the catalog repo, or from a published @frontmcp/skills install. SKILL.md is the entry point.
frontmcp CLIfrontmcp skills list, frontmcp skills read frontmcp-testing, frontmcp skills read frontmcp-testing:references/<file>.md, frontmcp skills install frontmcp-testing — no server required.
MCP skill://When a developer mounts this skill into their own FrontMCP server (@FrontMcp({ skills: [...] })), the SDK exposes it via SEP-2640 resources: skill://frontmcp-testing/SKILL.md, skill://frontmcp-testing/references/{file}.md, etc. The server’s skill://index.json returns the SEP-2640 discovery document for everything mounted on it.

The catalog itself is not an MCP server. The skill:// URIs only resolve when a server has been configured to host this skill.

Reference

  • Testing Documentation
  • Related skills: setup-testing, create-tool, create-resource, create-prompt, configure-auth

© agentfront, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 27 other files (references) in libs/skills/catalog/frontmcp-testing of agentfront/frontmcp.

  • SKILL.md
  • examples/setup-testing/fixture-based-e2e-test.md
  • examples/setup-testing/jest-config-with-coverage.md
  • examples/setup-testing/unit-test-tool-resource-prompt.md
  • examples/test-auth/oauth-flow-test.md
  • examples/test-auth/role-based-access-test.md
  • examples/test-auth/token-factory-test.md
  • examples/test-browser-build/browser-bundle-validation.md
  • examples/test-browser-build/playwright-browser-test.md
  • examples/test-cli-binary/binary-startup-test.md
  • examples/test-cli-binary/js-bundle-import-test.md
  • examples/test-direct-client/basic-create-test.md
  • examples/test-direct-client/openai-claude-format-test.md
  • examples/test-e2e-handler/basic-e2e-test.md
  • … and 14 more

Open the folder on GitHubat commit 8f59ba8

Compare with similar skills

Frontmcp Testing next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Frontmcp Testing compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Frontmcp Testing this skillagentfront/frontmcp146—~10kAutomated safety check: NotesApache-2.0
Senior QAalirezarezvani/claude-skills28k1 repos~2.1kAutomated safety check: PassMIT
Playwright Testingchongdashu/vibejam-starter-pack149—~2.2kAutomated safety check: PassNone
Testing FundamentalsDanielPodolsky/ownyourcode2901 repos~1.5kAutomated safety check: PassMIT
Test CommanderEliasOulkadi/shokunin114—~3kAutomated safety check: NotesMIT
Senior QAborghei/Claude-Skills874—~1.6kAutomated safety check: PassMIT

Similar skills

  • Senior QA

    alirezarezvani/claude-skills

    Generates unit tests, integration tests, and E2E tests for React/Next.js applications.

    28k GitHub starsUsed in 1 repo~2.1k tokens
    Testing & QAAuto-check passed

  • Playwright Testing

    chongdashu/vibejam-starter-pack

    Plan, implement, and debug frontend tests: unit/integration/E2E/visual/a11y.

    149 GitHub stars~2.2k tokensUpdated 5 mo ago
    Testing & QAAuto-check passed

  • Testing Fundamentals

    DanielPodolsky/ownyourcode

    Guides test strategy for unit, integration, and E2E testing.

    290 GitHub starsUsed in 1 repo~1.5k tokens
    Testing & QAAuto-check passed

  • Test Commander

    EliasOulkadi/shokunin

    Generate unit, integration, E2E, and visual regression tests following the Testing Trophy methodology (80% integration).

    114 GitHub stars~3k tokensUpdated 2 days ago
    Testing & QAAuto-check: notes

  • Senior QA

    borghei/Claude-Skills

    Testing for React/Next.js with Jest, React Testing Library, and Playwright.

    874 GitHub stars~1.6k tokensUpdated today
    Testing & QAAuto-check passed

  • Testing Strategy Builder

    aiskillstore/marketplace

    A skill your agent uses when creating comprehensive testing strategies for applications.

    430 GitHub stars~3.6k tokensUpdated today
    Testing & QAAuto-check passed

More from agentfront/frontmcp

All 12 skills in this repo

  • Frontmcp Auth UI

    agentfront/frontmcp

    A skill your agent uses when customizing, branding, or replacing the built-in FrontMCP OAuth pages (the login, consent, federated-select, incremental-authorization, and error pages) with your own…

    146 GitHub stars~3.7k tokensUpdated today
    Auto-check passed

  • Frontmcp Channels

    agentfront/frontmcp

    A skill your agent uses when pushing real-time notifications or events into Claude Code (or another MCP client) sessions, or building two-way chat bridges.

    146 GitHub stars~3.7k tokensUpdated today
    Auto-check passed

  • Frontmcp Extensibility

    agentfront/frontmcp

    A skill your agent uses when extending FrontMCP beyond the core SDK by integrating external npm packages, libraries, or third-party services into providers and tools.

    146 GitHub stars~3.2k tokensUpdated today
    Auto-check passed

  • Frontmcp Observability

    agentfront/frontmcp

    A skill your agent uses when adding tracing, structured logging, metrics, or monitoring to a FrontMCP server.

    146 GitHub stars~4.6k tokensUpdated today
    Auto-check passed

  • Frontmcp Authorities

    agentfront/frontmcp

    A skill your agent uses when implementing authorization and access control for FrontMCP tools, resources, prompts, or skills, deciding who may invoke what.

    146 GitHub stars~7.1k tokensUpdated today
    Auto-check passed

  • Frontmcp Config

    agentfront/frontmcp

    A skill your agent uses when configuring a FrontMCP server through frontmcp.config or the @FrontMcp options.

    146 GitHub stars~7k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Frontmcp Testing

What does Frontmcp Testing do?

A skill your agent uses for anything about testing FrontMCP servers: writing or running unit, integration, and E2E tests and reaching the 95%+ coverage bar. Frontmcp Testing is an agent skill from agentfront/frontmcp. Use for anything about testing FrontMCP servers: writing or running unit, integration, and E2E tests and reaching the 95%+ coverage bar.

When should I use Frontmcp Testing?

Frontmcp Testing fits situations like: anything about testing FrontMCP servers: writing; E2E tests and reaching the 95%+ coverage bar.

How do I install Frontmcp Testing in Claude Code?

Run `npx skills add agentfront/frontmcp --skill frontmcp-testing -a claude-code`. Or copy the skill folder (libs/skills/catalog/frontmcp-testing in agentfront/frontmcp) into .claude/skills/frontmcp-testing in your project. Claude Code loads it when a task matches its description.

How do I install Frontmcp Testing in Codex?

Run `npx skills add agentfront/frontmcp --skill frontmcp-testing -a codex`. Or copy the skill folder (libs/skills/catalog/frontmcp-testing in agentfront/frontmcp) into .agents/skills/frontmcp-testing in your project. Codex loads it when a task matches its description.

Can I use Frontmcp Testing in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add agentfront/frontmcp --skill frontmcp-testing -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/frontmcp-testing, .gemini/skills/frontmcp-testing, .github/skills/frontmcp-testing and .opencode/skills/frontmcp-testing in your project.

What does Frontmcp Testing need to run?

Going by SKILL.md and its folder, Frontmcp Testing needs the command-line tools its instructions call (nx and jest).

Does Frontmcp Testing access the network?

SKILL.md names 1 domain. As links in the text: docs.agentfront.dev. This is read from the text; nothing was executed.

Is Frontmcp Testing safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Frontmcp Testing use?

Frontmcp Testing is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Frontmcp Testing use?

About 10k tokens (SKILL.md is roughly 41k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 14k tokens, read only when the agent opens those files.

What are the alternatives to Frontmcp Testing?

Skills that share tags, products or a category with Frontmcp Testing: Senior QA (alirezarezvani/claude-skills, 28k stars), Playwright Testing (chongdashu/vibejam-starter-pack, 149 stars), Testing Fundamentals (DanielPodolsky/ownyourcode, 290 stars) and Test Commander (EliasOulkadi/shokunin, 114 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Frontmcp Testing?

agentfront (a GitHub organization) maintains it in agentfront/frontmcp, which has 146 GitHub stars. The repository holds 12 skills in this directory. The repository was last updated on October 7, 2026.

Source: agentfront/frontmcp on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.