ios-testing — Claude Code skill: what it does, how to install
ios-testing is a Claude Code skill for testing modular apps on iOS 26 and Swift 6.2. It guides unit, UI, and snapshot tests with protocol mocks and actor isolation.
MIT 288 installs ★ 227 updated 2026-08-15
npx skills add pproenca/dot-skills --skill ios-testing -a claude-codeWhat ios-testing does
The skill lays down 44 testing rules organized across 8 prioritized categories. It is built around a clinic modular MVVM-C architecture for iOS 26 and Swift 6.2. In this setup, feature modules import only Domain and DesignSystem. All network calls, background tasks, and SwiftData operations live strictly inside Data, while ViewModels interact directly with repository protocols.
Guidance prioritizes the Swift Testing framework over XCTest, pushing for #expect and #require macros. It supplies patterns for @Observable SwiftUI models, MainActor verification, swift-snapshot-testing, and Page Object UI suites. Task cancellations run explicitly. Because the guidance assumes this strict clinic boundary, projects with monolithic targets will need to adapt the dependency injection rules manually.
What it helps with
- migrate legacy test suites from XCTest to Swift Testing
- build protocol-based test doubles and spies for repositories
- verify async code paths under
MainActorisolation - structure UI tests using Page Objects and accessibility identifiers
- test SwiftUI
@Observablemodels as plain objects
Example prompts for the agent
- Review my ViewModel tests against the ios-testing architectural guidelines
- Refactor these repository unit tests to use Swift Testing #expect and #require
- Create a protocol-based mock for an async Domain repository on MainActor
How to install ios-testing
1Skills CLI (Vercel)
npx skills add pproenca/dot-skills --skill ios-testing -a claude-code2Manually: put the files in place
~/.claude/skills/ios-testing/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/ios-testing/
1Skills CLI (Vercel)
npx skills add pproenca/dot-skills --skill ios-testing -a codex2Manually: put the files in place
.agents/skills/ios-testing/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add pproenca/dot-skills --skill ios-testing -a cursor2Manually: put the files in place
.cursor/skills/ios-testing/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install pproenca/dot-skills skills/.experimental/ios-testing2Manually: put the files in place
.github/skills/ios-testing/SKILL.md1Skills CLI (Vercel)
npx skills add pproenca/dot-skills --skill ios-testing -a gemini-cli2Platform CLI
gemini skills install https://github.com/pproenca/dot-skills --path skills/.experimental/ios-testingManually: put the files in place
.devin/skills/ios-testing/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add pproenca/dot-skills --skill ios-testing -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about ios-testing
How to install ios-testing in Claude Code?
Run npx skills add pproenca/dot-skills --skill ios-testing -a claude-code in your terminal. It sets up the skill at ~/.claude/skills/ios-testing/SKILL.md.
What does the ios-testing skill do?
It provides 44 prioritized testing guidelines for Swift 6.2 and iOS 26 modular projects. The rules cover Swift Testing fundamentals, mock isolation, SwiftUI state, and UI test stability.
What architectural contract does ios-testing require?
It expects a modular MVVM-C structure where feature modules import only Domain and DesignSystem. The Data layer manages SwiftData and network I/O, while the App target handles dependency injection.
Source text
SKILL.md · MIT
--- name: ios-testing description: Testing practices for iOS 26 / Swift 6.2 clinic modular MVVM-C applications. Covers unit/UI/snapshot testing, protocol-based mocks, async actor isolation, and dependency-injected test architecture aligned with Domain protocols, App-target composition, and Data-owned I/O boundaries. Use when writing, reviewing, or refactoring tests for ios-* and swift-* clinic modules. --- # iOS Testing Best Practices Comprehensive testing guide for iOS and Swift applications, written at principal engineer level. Contains 44 rules across 8 categories, prioritized by impact to guide test architecture decisions, test authoring patterns, and CI infrastructure. ## Clinic Architecture Contract (iOS 26 / Swift 6.2) All guidance in this skill assumes the clinic modular MVVM-C architecture: - Feature modules import `Domain` + `DesignSystem` only (never `Data`, never sibling features) - App target is the convergence point and owns `DependencyContainer`, concrete coordinators, and Route Shell wiring - `Domain` stays pure Swift and defines models plus repository, `*Coordinating`, `ErrorRouting`, and `AppError` contracts - `Data` owns SwiftData/network/sync/retry/background I/O and implements Domain protocols - Read/write flow defaults to stale-while-revalidate reads and optimistic queued writes - ViewModels call repository protocols directly (no default use-case/interactor layer) ## When to Apply Reference these guidelines when: - Writing new unit tests or UI tests for iOS apps - Designing testable architecture with dependency injection - Testing async/await, actors, and Combine publishers - Setting up snapshot testing or visual regression suites - Configuring CI pipelines, test plans, and parallel execution ## Rule Categories by Priority | Priority | Category | Impact | Prefix | |----------|----------|--------|--------| | 1 | Test Architecture & Testability | CRITICAL | `arch-` | | 2 | Unit Testing Fundamentals | CRITICAL | `unit-` | | 3 | Test Doubles & Isolation | HIGH | `mock-` | | 4 | Async & Concurrency Testing | HIGH | `async-` | | 5 | SwiftUI Testing | MEDIUM-HIGH | `swiftui-` | | 6 | UI & Acceptance Testing | MEDIUM | `ui-` | | 7 | Snapshot & Visual Testing | MEDIUM | `snap-` | | 8 | Test Reliability & CI | LOW-MEDIUM | `ci-` | ## Quick Reference ### 1. Test Architecture & Testability (CRITICAL) - [`arch-protocol-dependencies`](references/arch-protocol-dependencies.md) - Depend on protocols, not concrete types - [`arch-constructor-injection`](references/arch-constructor-injection.md) - Use constructor injection over service locators - [`arch-test-target-separation`](references/arch-test-target-separation.md) - Separate unit and UI test targets - [`arch-testable-import`](references/arch-testable-import.md) - Use @testable import sparingly - [`arch-single-responsibility-tests`](references/arch-single-responsibility-tests.md) - One assertion concept per test - [`arch-arrange-act-assert`](references/arch-arrange-act-assert.md) - Structure tests as Arrange-Act-Assert ### 2. Unit Testing Fundamentals (CRITICAL) - [`unit-swift-testing-framework`](references/unit-swift-testing-framework.md) - Use Swift Testing over XCTest for new tests - [`unit-parameterized-tests`](references/unit-parameterized-tests.md) - Use parameterized tests for input variations - [`unit-descriptive-test-names`](references/unit-descriptive-test-names.md) - Name tests after the behavior they verify - [`unit-expect-over-assert`](references/unit-expect-over-assert.md) - Use #expect and #require over XCTAssert - [`unit-require-preconditions`](references/unit-require-preconditions.md) - Use #require for test preconditions - [`unit-test-suites`](references/unit-test-suites.md) - Organize related tests into suites - [`unit-test-tags`](references/unit-test-tags.md) - Use tags to categorize cross-cutting tests ### 3. Test Doubles & Isolation (HIGH) - [`mock-protocol-based-mocks`](references/mock-protocol-based-mocks.md) - Create mocks from protocols, not subclasses - [`mock-spy-for-verification`](references/mock-spy-for-verification.md) - Use spies to verify interactions - [`mock-stub-return-values`](references/mock-stub-return-values.md) - Use stubs for deterministic return values - [`mock-avoid-over-mocking`](references/mock-avoid-over-mocking.md) - Avoid mocking value types and simple logic - [`mock-fake-for-integration`](references/mock-fake-for-integration.md) - Use in-memory fakes for integration tests - [`mock-dependency-container`](references/mock-dependency-container.md) - Use a dependency container for test configuration ### 4. Async & Concurrency Testing (HIGH) - [`async-await-directly`](references/async-await-directly.md) - Await async functions directly in tests - [`async-confirmation`](references/async-confirmation.md) - Use confirmation() for callback-based APIs - [`async-mainactor-isolation`](references/async-mainactor-isolation.md) - Test MainActor-isolated code on MainActor - [`async-actor-testing`](references/async-actor-testing.md) - Test actor state through async interface - [`async-task-cancellation`](references/async-task-cancellation.md) - Test task cancellation paths explicitly ### 5. SwiftUI Testing (MEDIUM-HIGH) - [`swiftui-test-observable-models`](references/swiftui-test-observable-models.md) - Test @Observable models as plain objects - [`swiftui-environment-injection`](references/swiftui-environment-injection.md) - Inject environment dependencies for tests - [`swiftui-preview-as-test`](references/swiftui-preview-as-test.md) - Use previews as visual smoke tests - [`swiftui-view-model-extraction`](references/swiftui-view-model-extraction.md) - Extract logic from views into testable models - [`swiftui-binding-testing`](references/swiftui-binding-testing.md) - Test binding behavior with @Bindable ### 6. UI & Acceptance Testing (MEDIUM) - [`ui-accessibility-identifiers`](references/ui-accessibility-identifiers.md) - Use accessibility identifiers for element queries - [`ui-page-object-pattern`](references/ui-page-object-pattern.md) - Encapsulate screens in page objects - [`ui-launch-arguments`](references/ui-launch-arguments.md) - Configure test state via launch arguments - [`ui-wait-for-elements`](references/ui-wait-for-elements.md) - Wait for elements instead of using sleep() - [`ui-test-user-journeys`](references/ui-test-user-journeys.md) - Test complete user journeys, not individual screens - [`ui-reset-state-between-tests`](references/ui-reset-state-between-tests.md) - Reset app state between UI tests ### 7. Snapshot & Visual Testing (MEDIUM) - [`snap-swift-snapshot-testing`](references/snap-swift-snapshot-testing.md) - Use swift-snapshot-testing for visual regression - [`snap-device-matrix`](references/snap-device-matrix.md) - Snapshot across device sizes and traits - [`snap-named-references`](references/snap-named-references.md) - Use named snapshot references for clarity - [`snap-inline-snapshots`](references/snap-inline-snapshots.md) - Use inline snapshots for non-image assertions ### 8. Test Reliability & CI (LOW-MEDIUM) - [`ci-test-plans`](references/ci-test-plans.md) - Use Xcode Test Plans for environment configurations - [`ci-parallel-execution`](references/ci-parallel-execution.md) - Enable parallel test execution - [`ci-flaky-test-quarantine`](references/ci-flaky-test-quarantine.md) - Quarantine flaky tests instead of disabling them - [`ci-deterministic-test-data`](references/ci-deterministic-test-data.md) - Use deterministic test data over random generation - [`ci-coverage-thresholds`](references/ci-coverage-thresholds.md) - Set coverage thresholds for critical paths ## How to Use Read individual reference files for detailed explanations and code examples: - [Section definitions](references/_sections.md) - Category structure and impact levels - [Rule template](assets/templates/_template.md) - Template for adding new rules ## Reference Files | File | Description | |------|-------------| | [references/_sections.md](references/_sections.md) | Category definitions and ordering | | [assets/templates/_template.md](assets/templates/_template.md) | Template for new rules | | [metadata.json](metadata.json) | Version and reference information |
© pproenca · MIT · pproenca/dot-skills