reis-mobile 0.3.5 → 0.4.0

package/skills/mobile-test/references/android.md

@@ -0,0 +1,83 @@
+# Testing native Android apps
+
+For setting up a test stack from scratch (dependencies, UI tests, screenshot tests, Hilt), follow [android/setup/GUIDE.md](android/setup/GUIDE.md). This file covers writing tests in an existing setup.
+
+## Detect the setup
+
+- Test dependencies in the module build files and `gradle/libs.versions.toml`: JUnit 4 or 5, `kotlinx-coroutines-test`, Turbine, MockK or Mockito-Kotlin, Truth or AssertJ, Robolectric, `androidx.compose.ui:ui-test-junit4`, Espresso, `hilt-android-testing`.
+- Source sets: **local tests** in `src/test` run on the JVM; **instrumented tests** in `src/androidTest` need a device or emulator.
+- Existing helpers: a `MainDispatcherRule`, fakes, a `:core:testing` module, custom test runners.
+
+## Local unit tests: ViewModels, coroutines and Flow
+
+```kotlin
+class MainDispatcherRule(val dispatcher: TestDispatcher = UnconfinedTestDispatcher()) : TestWatcher() {
+    override fun starting(description: Description) = Dispatchers.setMain(dispatcher)
+    override fun finished(description: Description) = Dispatchers.resetMain()
+}
+
+class LoginViewModelTest {
+    @get:Rule val mainDispatcherRule = MainDispatcherRule()
+
+    private val repository = FakeAuthRepository()
+
+    @Test
+    fun `emits success when credentials are valid`() = runTest {
+        repository.nextResult = Result.success(fakeUser)
+        val viewModel = LoginViewModel(repository)
+
+        viewModel.uiState.test {                       // Turbine
+            assertEquals(LoginUiState.Idle, awaitItem())
+            viewModel.submit("user@example.com", "secret")
+            assertEquals(LoginUiState.Loading, awaitItem())
+            assertEquals(LoginUiState.Success(fakeUser), awaitItem())
+        }
+    }
+}
+```
+
+- `runTest` skips `delay` with virtual time; `advanceUntilIdle()` and `advanceTimeBy()` control it with a `StandardTestDispatcher`.
+- Inject dispatchers into repositories and use cases instead of hardcoding `Dispatchers.IO`; tests pass the test dispatcher.
+- Code that uses `viewModelScope` needs `Dispatchers.Main` replaced (the rule above).
+- The names above are illustrative; use the project's classes.
+
+## Compose UI tests
+
+```kotlin
+class LoginScreenTest {
+    @get:Rule val composeRule = createComposeRule()
+
+    @Test
+    fun showsErrorWhenLoginFails() {
+        composeRule.setContent { LoginScreen(state = LoginUiState.Error("Invalid credentials"), onSubmit = {}) }
+
+        composeRule.onNodeWithText("Invalid credentials").assertIsDisplayed()
+        composeRule.onNodeWithText("Sign in").performClick()
+    }
+}
+```
+
+- Test stateless composables with state passed in; they need no ViewModel or DI.
+- Prefer finding nodes by text or content description; add `Modifier.testTag` only where there is no user-visible handle.
+- These tests are instrumented by default; with Robolectric configured, they can run as local tests.
+
+## Views, Espresso and Hilt
+
+- Espresso: `onView(withId(R.id.submit)).perform(click())`, `check(matches(isDisplayed()))`. Disable animations on test devices, and use idling resources for background work instead of sleeps.
+- Hilt: annotate the test with `@HiltAndroidTest`, add `HiltAndroidRule`, use a custom runner that sets `HiltTestApplication`, and replace modules with `@TestInstallIn`. Details in [android/setup/references/android/training/dependency-injection/hilt-testing.md](android/setup/references/android/training/dependency-injection/hilt-testing.md).
+
+## Other components
+
+- **Room**: test DAOs against `Room.inMemoryDatabaseBuilder`; test migrations with `MigrationTestHelper` in instrumented tests.
+- **WorkManager**: `work-testing` provides test drivers to run workers synchronously.
+- **DataStore**: create it in a temporary folder per test.
+
+## Commands
+
+```bash
+./gradlew :app:testDebugUnitTest                               # local tests of one module
+./gradlew :app:testDebugUnitTest --tests '*LoginViewModelTest'
+./gradlew :app:connectedDebugAndroidTest                       # instrumented tests, needs a device or emulator
+```
+
+For coverage, enable `enableUnitTestCoverage` / `enableAndroidTestCoverage` on the build type and run the coverage report task the Android Gradle plugin creates for it; check the task name for the project's AGP version.

package/skills/{dart-collect-coverage/SKILL.md → mobile-test/references/flutter/coverage.md}

@@ -1,14 +1,5 @@
----
-name: dart-collect-coverage
-description: Collect coverage using the coverage packge and create an LCOV report
-metadata:
-  model: models/gemini-3.1-pro-preview
-  last_modified: Fri, 24 Apr 2026 15:14:32 GMT
-intents: [test]
-stacks: [flutter]
-source: https://github.com/dart-lang/skills
-license: BSD-3-Clause
----
+> Adapted from the `dart-collect-coverage` skill in [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause). See `THIRD_PARTY_NOTICES.md`.
+
 # Implementing Dart and Flutter Test Coverage
 
 ## Contents

package/skills/{dart-generate-test-mocks/SKILL.md → mobile-test/references/flutter/generate-mocks.md}

@@ -1,14 +1,5 @@
----
-name: dart-generate-test-mocks
-description: Define and generate mock objects for external dependencies using `package:mockito` and `build_runner`. Use when unit testing classes that depend on complex external services like APIs or databases.
-metadata:
-  model: models/gemini-3.1-pro-preview
-  last_modified: Fri, 24 Apr 2026 15:13:58 GMT
-intents: [test]
-stacks: [flutter]
-source: https://github.com/dart-lang/skills
-license: BSD-3-Clause
----
+> Adapted from the `dart-generate-test-mocks` skill in [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause). See `THIRD_PARTY_NOTICES.md`.
+
 # Testing and Mocking Dart Applications
 
 ## Contents

package/skills/{flutter-add-integration-test/SKILL.md → mobile-test/references/flutter/integration-tests.md}

@@ -1,14 +1,5 @@
----
-name: flutter-add-integration-test
-description: Configures Flutter Driver for app interaction and converts MCP actions into permanent integration tests. Use when adding integration testing to a project, exploring UI components via MCP, or automating user flows with the integration_test package.
-metadata:
-  model: models/gemini-3.1-pro-preview
-  last_modified: Tue, 21 Apr 2026 18:29:20 GMT
-intents: [test]
-stacks: [flutter]
-source: https://github.com/flutter/skills
-license: BSD-3-Clause
----
+> Adapted from the `flutter-add-integration-test` skill in [flutter/skills](https://github.com/flutter/skills) (BSD-3-Clause). See `THIRD_PARTY_NOTICES.md`.
+
 # Implementing Flutter Integration Tests
 
 ## Contents

package/skills/{dart-migrate-to-checks-package/SKILL.md → mobile-test/references/flutter/migrate-to-checks.md}

@@ -1,16 +1,5 @@
----
-name: dart-migrate-to-checks-package
-description: |-
-  Replace the usage of `expect` and similar functions from `package:matcher`
-  to `package:checks` equivalents.
-metadata:
-  model: models/gemini-3.1-pro-preview
-  last_modified: Tue, 09 Jun 2026 19:30:00 GMT
-intents: [migration]
-stacks: [flutter]
-source: https://github.com/dart-lang/skills
-license: BSD-3-Clause
----
+> Adapted from the `dart-migrate-to-checks-package` skill in [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause). See `THIRD_PARTY_NOTICES.md`.
+
 # Migrating Dart Tests to Package Checks
 
 Use this skill when you need to migrate a Dart test suite from the legacy

package/skills/{mockito/SKILL.md → mobile-test/references/flutter/mockito.md}

@@ -1,11 +1,4 @@
----
-name: mockito
-description: Uses the Mockito package for mocking in Flutter/Dart tests. Use when generating mocks, stubbing methods, verifying interactions, capturing arguments, or deciding between mocks, fakes, and real objects.
-intents: [test]
-stacks: [flutter]
-source: https://github.com/evanca/flutter-ai-rules
-license: MIT
----
+> Adapted from the `mockito` skill in [evanca/flutter-ai-rules](https://github.com/evanca/flutter-ai-rules) (MIT). See `THIRD_PARTY_NOTICES.md`.
 
 # Mockito Skill
 

package/skills/{mocktail/SKILL.md → mobile-test/references/flutter/mocktail.md}

@@ -1,11 +1,4 @@
----
-name: mocktail
-description: Uses the Mocktail package for mocking in Flutter/Dart tests. Use when creating mocks, stubbing methods, verifying interactions, registering fallback values, or deciding between mocks, fakes, and real objects.
-intents: [test]
-stacks: [flutter]
-source: https://github.com/evanca/flutter-ai-rules
-license: MIT
----
+> Adapted from the `mocktail` skill in [evanca/flutter-ai-rules](https://github.com/evanca/flutter-ai-rules) (MIT). See `THIRD_PARTY_NOTICES.md`.
 
 # Mocktail Skill
 

package/skills/{patrol-e2e-testing/SKILL.md → mobile-test/references/flutter/patrol.md}

@@ -1,11 +1,4 @@
----
-name: patrol-e2e-testing
-description: Generates and maintains end-to-end tests for Flutter apps using Patrol. Use when adding E2E coverage for new features, regression tests for UI bugs, or testing native interactions (permissions, system dialogs, deep links)
-intents: [test]
-stacks: [flutter]
-source: https://github.com/evanca/flutter-ai-rules
-license: MIT
----
+> Adapted from the `patrol-e2e-testing` skill in [evanca/flutter-ai-rules](https://github.com/evanca/flutter-ai-rules) (MIT). See `THIRD_PARTY_NOTICES.md`.
 
 # Patrol E2E Testing Skill
 

package/skills/{testing/SKILL.md → mobile-test/references/flutter/testing-guidelines.md}

@@ -1,11 +1,4 @@
----
-name: testing
-description: Writes and reviews Flutter/Dart tests. Use when writing unit tests, widget tests, or reviewing existing tests for correctness, structure, and naming conventions.
-intents: [test]
-stacks: [flutter]
-source: https://github.com/evanca/flutter-ai-rules
-license: MIT
----
+> Adapted from the `testing` skill in [evanca/flutter-ai-rules](https://github.com/evanca/flutter-ai-rules) (MIT). See `THIRD_PARTY_NOTICES.md`.
 
 # Testing Skill
 

package/skills/{dart-add-unit-test/SKILL.md → mobile-test/references/flutter/unit-tests.md}

@@ -1,14 +1,5 @@
----
-name: dart-add-unit-test
-description: Write and organize unit tests for functions, methods, and classes using `package:test`. Use when creating new logic or fixing bugs to ensure code remains correct and regression-free.
-metadata:
-  model: models/gemini-3.1-pro-preview
-  last_modified: Mon, 03 Aug 2026 21:51:24 GMT
-intents: [test]
-stacks: [flutter]
-source: https://github.com/dart-lang/skills
-license: BSD-3-Clause
----
+> Adapted from the `dart-add-unit-test` skill in [dart-lang/skills](https://github.com/dart-lang/skills) (BSD-3-Clause). See `THIRD_PARTY_NOTICES.md`.
+
 # Testing Dart and Flutter Applications
 
 ## Contents

package/skills/{flutter-add-widget-test/SKILL.md → mobile-test/references/flutter/widget-tests.md}

@@ -1,14 +1,5 @@
----
-name: flutter-add-widget-test
-description: Implement a component-level test using `WidgetTester` to verify UI rendering and user interactions (tapping, scrolling, entering text). Use when validating that a specific widget displays correct data and responds to events as expected.
-metadata:
-  model: models/gemini-3.1-pro-preview
-  last_modified: Tue, 21 Apr 2026 21:15:41 GMT
-intents: [test]
-stacks: [flutter]
-source: https://github.com/flutter/skills
-license: BSD-3-Clause
----
+> Adapted from the `flutter-add-widget-test` skill in [flutter/skills](https://github.com/flutter/skills) (BSD-3-Clause). See `THIRD_PARTY_NOTICES.md`.
+
 # Writing Flutter Widget Tests
 
 ## Contents

package/skills/mobile-test/references/flutter.md

@@ -0,0 +1,44 @@
+# Testing Flutter and Dart apps
+
+Start here for Flutter projects, then open the detailed guide for the task.
+
+## Detect the setup
+
+- `dev_dependencies` in `pubspec.yaml`: `flutter_test`, `test`, `mocktail` or `mockito` (with `build_runner`), `bloc_test`, `integration_test`, `patrol`, `checks`.
+- State management (BLoC/Cubit, Riverpod, Provider) and existing helpers under `test/`.
+- The Dart SDK constraint: records, patterns and sealed classes need Dart 3.
+
+When the project has no mocking library yet, prefer `mocktail`: it needs no code generation.
+
+## Guides
+
+| Task | Guide |
+|---|---|
+| General guidelines for meaningful Flutter/Dart tests | [flutter/testing-guidelines.md](flutter/testing-guidelines.md) |
+| Unit tests for functions and classes with `package:test` | [flutter/unit-tests.md](flutter/unit-tests.md) |
+| Widget tests with `WidgetTester` | [flutter/widget-tests.md](flutter/widget-tests.md) |
+| Integration tests (`integration_test`, Flutter Driver) | [flutter/integration-tests.md](flutter/integration-tests.md) |
+| End-to-end tests with native interactions using Patrol | [flutter/patrol.md](flutter/patrol.md) |
+| Mocks with mocktail | [flutter/mocktail.md](flutter/mocktail.md) |
+| Mocks with mockito | [flutter/mockito.md](flutter/mockito.md) |
+| Generating mocks with `build_runner` | [flutter/generate-mocks.md](flutter/generate-mocks.md) |
+| Coverage and LCOV reports | [flutter/coverage.md](flutter/coverage.md) |
+| Migrating assertions from `package:matcher` to `package:checks` | [flutter/migrate-to-checks.md](flutter/migrate-to-checks.md) |
+
+## Commands
+
+```bash
+flutter test                                   # unit and widget tests
+flutter test test/features/login/login_cubit_test.dart
+flutter test --coverage                        # writes coverage/lcov.info
+flutter test integration_test                  # needs a device, emulator or simulator
+dart test                                      # pure Dart packages
+```
+
+## Flutter-specific pitfalls
+
+- `pumpAndSettle` never returns while an infinite animation (a progress indicator) runs; pump a fixed duration instead.
+- Real timers and `Future.delayed` make widget tests slow and flaky; use `tester.pump(duration)` or `fakeAsync`.
+- Widgets that need `MediaQuery`, localization, theme or providers must be wrapped in the same ancestors the app uses; build a shared `pumpApp` helper.
+- Platform channels (plugins) have no implementation in tests; mock them with `TestDefaultBinaryMessengerBinding` or inject an abstraction over the plugin.
+- Golden tests differ between operating systems and font setups; run them on the same platform in CI that generated the goldens.

package/skills/mobile-test/references/ios.md

@@ -0,0 +1,79 @@
+# Testing native iOS apps
+
+## Detect the setup
+
+- Framework: **Swift Testing** (`import Testing`, `@Test`, `#expect`) or **XCTest** (`XCTestCase`). Swift Testing needs Xcode 16 or later; both can live in the same test target, so follow what the file or target already uses.
+- Test targets, test plans and schemes in the Xcode project, or test targets in `Package.swift`.
+- Whether unit tests run inside a host app (the app target launches) or as a logic test bundle.
+- Existing doubles and fixtures; snapshot testing only if the project already has a library for it.
+
+## Unit tests with Swift Testing
+
+```swift
+import Testing
+@testable import App
+
+@MainActor
+struct LoginViewModelTests {
+    @Test func emitsSuccessWhenCredentialsAreValid() async {
+        let viewModel = LoginViewModel(authService: FakeAuthService(result: .success(.fixture)))
+
+        await viewModel.submit(email: "user@example.com", password: "secret")
+
+        #expect(viewModel.state == .success(.fixture))
+    }
+
+    @Test(arguments: ["", "no-at-sign", "a@"])
+    func rejectsInvalidEmails(_ email: String) {
+        #expect(EmailValidator.isValid(email) == false)
+    }
+}
+```
+
+- `#expect` records a failure and continues; `try #require(...)` stops the test (use it to unwrap optionals the rest of the test depends on).
+- `#expect(throws: SomeError.self) { try parser.parse(data) }` checks thrown errors.
+- Parameterized tests (`arguments:`) replace copy-pasted test methods.
+- Suites are plain types; setup goes in `init`, teardown in `deinit`.
+
+## Unit tests with XCTest
+
+```swift
+final class LoginViewModelTests: XCTestCase {
+    @MainActor
+    func testEmitsSuccessWhenCredentialsAreValid() async {
+        let viewModel = LoginViewModel(authService: FakeAuthService(result: .success(.fixture)))
+
+        await viewModel.submit(email: "user@example.com", password: "secret")
+
+        XCTAssertEqual(viewModel.state, .success(.fixture))
+    }
+}
+```
+
+- Use `async` test methods and `await` the work instead of `XCTestExpectation` with timeouts where possible.
+- Methods must start with `test`; `setUp`/`tearDown` (or their `async throws` variants) reset state.
+
+## Test doubles and determinism
+
+- Inject dependencies through protocols in initializers; fakes return canned results and record calls when the test needs them.
+- No real network: fake the API client, or register a custom `URLProtocol` on the test `URLSessionConfiguration`.
+- No shared `UserDefaults.standard` or real Keychain: inject a store, or use `UserDefaults(suiteName:)` removed after each test.
+- Inject a clock or date provider instead of reading `Date()` in code under test.
+
+## UI tests (XCUITest)
+
+- Find elements by accessibility identifier: set `.accessibilityIdentifier("loginButton")` in SwiftUI or `accessibilityIdentifier` in UIKit.
+- Launch into a known state with `app.launchArguments` / `app.launchEnvironment` read by the app (for example to use fake services or skip onboarding).
+- Wait with `waitForExistence(timeout:)` on the element, never with `sleep`.
+- Keep UI tests to critical flows; they are slow and the first to go flaky.
+
+## Commands
+
+```bash
+xcrun simctl list devices available            # pick a simulator that exists on this machine
+xcodebuild test -scheme App -destination 'platform=iOS Simulator,name=<Device>'
+xcodebuild test -scheme App -destination 'platform=iOS Simulator,name=<Device>' -only-testing:AppTests/LoginViewModelTests
+xcodebuild test -scheme App -destination '...' -enableCodeCoverage YES -resultBundlePath TestResults.xcresult
+xcrun xccov view --report TestResults.xcresult
+swift test                                      # Swift packages
+```

package/skills/mobile-test/references/react-native.md

@@ -0,0 +1,62 @@
+# Testing React Native apps
+
+## Detect the setup
+
+- `package.json` and `jest.config.*`: Jest with the `react-native` preset, or `jest-expo` in Expo projects; the `test` script.
+- Libraries: `@testing-library/react-native` (React Native Testing Library), network mocking (MSW or mocked API modules), E2E with Detox or Maestro.
+- Setup files (`jest.setup.*`) and existing mocks for native modules (`__mocks__/`, `jest.mock` calls).
+- State and data libraries under test — TanStack Query, Redux Toolkit, Zustand — and their test helpers.
+
+## Logic, hooks and stores
+
+- Pure TypeScript modules are tested with plain Jest.
+- Hooks: `renderHook` from React Native Testing Library, with the providers the hook needs as `wrapper`.
+- TanStack Query: create a new `QueryClient` per test with `retry: false`, so failures surface immediately.
+- Redux Toolkit: build a real store with the reducers under test instead of mocking `useSelector`.
+
+## Component tests
+
+```tsx
+import { render, screen, userEvent } from '@testing-library/react-native';
+
+jest.mock('../api/auth', () => ({ login: jest.fn() }));
+const { login } = jest.requireMock('../api/auth');
+
+test('shows the home greeting after a valid login', async () => {
+  login.mockResolvedValue({ name: 'Ana' });
+  const user = userEvent.setup();
+  render(<LoginScreen />, { wrapper: AppProviders });
+
+  await user.type(screen.getByLabelText('Email'), 'ana@example.com');
+  await user.type(screen.getByLabelText('Password'), 'secret');
+  await user.press(screen.getByRole('button', { name: 'Sign in' }));
+
+  expect(await screen.findByText('Hello, Ana')).toBeOnTheScreen();
+});
+```
+
+- Query by role, label or text — what users and screen readers see. `testID` is the last resort.
+- `findBy*` and `waitFor` for async results; no manual timeouts.
+- `userEvent` simulates real interactions; `fireEvent` is the lower-level fallback.
+- Avoid whole-screen snapshots as the main assertion: they break on harmless changes and get updated blindly.
+- The names above are illustrative, and the matchers depend on the installed library version.
+
+## Native modules and navigation
+
+- Native modules have no implementation under Jest. Use the mocks libraries ship (many document a `jest` mock, including React Native Firebase modules and AsyncStorage), or `jest.mock` them in the setup file.
+- Screens that use React Navigation hooks need a `NavigationContainer` in the wrapper, or test the screen's content component with props instead.
+- Transform errors (`SyntaxError: Cannot use import statement outside a module`) come from untranspiled `node_modules` packages; add them to `transformIgnorePatterns` as the preset documents.
+
+## End-to-end
+
+- **Detox**: gray-box tests that sync with the app's idle state. It needs a build configuration per platform (`.detoxrc.js`), then `detox build` and `detox test` against a simulator or emulator.
+- **Maestro**: black-box YAML flows (`appId`, `launchApp`, `tapOn`, `assertVisible`) run with `maestro test`, against a built app.
+- Give elements stable accessibility labels or `testID`s for E2E selectors, and keep E2E suites to critical journeys.
+
+## Commands
+
+```bash
+npm test                                   # or the project's package manager and script
+npx jest src/features/login                # one folder or file
+npx jest --coverage
+```