Skip to main content
skill CX Codex

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

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pproenca/dot-skills --skill ios-testing -a claude-code
Open on GitHub

What 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 MainActor isolation
  • structure UI tests using Page Objects and accessibility identifiers
  • test SwiftUI @Observable models 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-code

2Manually: put the files in place

~/.claude/skills/ios-testing/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/ios-testing/

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

Similar skills

All skills for Testing and QA →

From the same set139

The whole set →
rails-dev Set of guidelines for Ruby on Rails development. Helps build clean controllers, optimize ActiveRecord queries, and configure caching. CX Codex +1 299installs swift-optimise The swift-optimise skill reviews Swift and SwiftUI performance across concurrency, rendering, and animation. Use it while profiling clinic modules. CX Codex +1 293installs ruby-optimise The ruby-optimise skill guides Ruby code reviews and refactors around performance. Use it when working with allocations, collections, ActiveRecord queries, or runtime settings. CX Codex +1 292installs swift-refactor swift-refactor is a Claude Code skill for reshaping existing SwiftUI code around a modular MVVM-C architecture. It applies to work on navigation, state, and app layer boundaries. CX Codex +1 289installs dev-rfc dev-rfc guides coding agents through writing technical proposals, system design docs, and architecture overviews with structured templates. CX Codex +1 286installs swift-ui-architect swift-ui-architect enforces modular MVVM-C architecture for SwiftUI and Swift 6.2 across local SPM packages. Keeps Domain, Data, and Feature boundaries strict during code generation. CX Codex +1 283installs ios-taste ios-taste designs iOS 18+ SwiftUI views guided by user context and emotional intent instead of defaulting to generic lists. CX Codex +1 280installs ios-storyboard ios-storyboard — a 45-rule guide for maintaining legacy Xcode Storyboard scenes and resolving merge conflicts in Swift 6.2 codebases. Useful when preparing UIKit migrations to SwiftUI. CX Codex +1 277installs

Project sponsors

Companies that keep this analytics open