testing

Guide test-first engineering with integration tests and minimal mocking in Go projects.

1|Updated Dec 3, 2025
One-click install
npx skills add https://github.com/yurifrl/cly --skill testing-yurifrl
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: testing
Source: https://github.com/yurifrl/cly/tree/main/.opencode/skill/testing
Command: npx skills add https://github.com/yurifrl/cly --skill testing-yurifrl

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill enables test-first engineering with a default to integration tests. It helps teams balance rapid development with reliable verification by prioritizing end-to-end scenarios and real dependencies over mocks.

Core Features & Use Cases

  • Test-First Development: Write tests before code to clarify requirements and guide design.
  • Integration by Default: Favor integration or end-to-end tests over isolated unit tests, using real databases, filesystems, and services when possible.
  • Pragmatic Mocks Strategy: Use fakes or minimal mocks only when necessary; avoid over-mocking to preserve observable behavior.

Quick Start

Ask the AI to design an integration-test plan for a new feature, then implement the tests in your Go project and run them against real dependencies.

Frequently Asked Questions about testing

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I start test-driven development in Go with integration tests?

Test-driven development in Go starts by writing integration tests before code, using real databases and services rather than mocks. This Skill guides you to design end-to-end test plans first, then implement features against real dependencies.

When should I use mocking instead of real dependencies in Go testing?

Mocking should be used minimally in Go testing, reserved only when real dependencies are impractical. This Skill promotes a pragmatic mocks strategy, favoring fakes over complex mocks to preserve observable behavior during integration testing.

What is integration-first testing and why prefer it over isolated unit tests?

Integration-first testing prioritizes end-to-end scenarios using real filesystems and services over isolated unit tests. It balances rapid development with reliable verification by ensuring the system works cohesively with actual dependencies.

Can I write tests before code to clarify requirements in Go projects?

Writing tests before code in Go projects clarifies requirements and guides software design. This Skill enables test-first engineering by helping you define expected behaviors upfront through comprehensive integration test plans.

Does over-mocking affect test reliability in Go integration testing?

Over-mocking reduces test reliability by hiding integration failures and obscuring real behavior. This Skill advises against over-mocking in Go projects, recommending real dependencies to ensure tests reflect actual production scenarios.

What's the best way to structure end-to-end test plans for new Go features?

The best way to structure end-to-end test plans for Go features is to define integration scenarios against real services first. This Skill helps design comprehensive test plans that validate actual dependencies before implementation.