qa-skills 3.0.0

package/skills/qa-manual-test-designer/templates/exploratory-charter-template.md

@@ -0,0 +1,47 @@
+# Exploratory Testing Session Charter
+
+**Charter:** {mission statement}
+**Date:** {YYYY-MM-DD}
+**Tester:** {name}
+**Time-box:** {e.g., 90 minutes}
+
+---
+
+## Mission
+
+{What are we trying to learn or validate?}
+
+---
+
+## Areas to Explore
+
+1. {area 1}
+2. {area 2}
+3. {area 3}
+
+---
+
+## Setup
+
+- **Build/URL:** {version or URL}
+- **Test data:** {credentials, test accounts}
+- **Tools:** {browser, proxy, recorder}
+
+---
+
+## Session Notes
+
+| Time | Action | Observation | Issue? |
+|------|--------|-------------|--------|
+| {HH:MM} | {what you did} | {what you saw} | ☐ Yes ☐ No |
+| {HH:MM} | | | |
+| {HH:MM} | | | |
+
+---
+
+## Debrief
+
+- **Bugs found:** {count and brief list}
+- **Coverage:** {areas covered vs. missed}
+- **Questions / follow-ups:** {open items}
+- **Next charter:** {suggested focus}

package/skills/qa-manual-test-designer/templates/test-case-template.md

@@ -0,0 +1,31 @@
+# Test Case
+
+## [TC-{ID}] {Title}
+
+**Module:** {module name}
+**Priority:** {P1 | P2 | P3 | P4}
+**Type:** {Functional | Regression | Smoke | Integration | E2E | Other}
+
+## Preconditions
+{Prerequisites, data state, environment setup}
+
+## Test Steps
+
+| # | Action | Expected Result |
+|---|--------|-----------------|
+| 1 | {action} | {expected} |
+| 2 | {action} | {expected} |
+| 3 | {action} | {expected} |
+
+## Postconditions
+{Cleanup, state after test}
+
+## Test Data
+{Input values, test accounts, sample data}
+
+## Traceability
+- **Requirement ID:** [REQ-{ID}]
+- **Spec Reference:** {section or link}
+
+## Automation Status
+{Manual | Automated | Planned | N/A}

package/skills/qa-mobile-test-writer/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: qa-mobile-test-writer
+description: Generate mobile tests using Appium, WebdriverIO Mobile, and Flutter Driver for iOS and Android native, hybrid, Flutter, and mobile web applications.
+output_dir: tests/mobile
+---
+
+# QA Mobile Test Writer
+
+## Purpose
+
+Write mobile tests for iOS, Android, hybrid, Flutter, and mobile web applications. Transform structured test cases into executable mobile test scripts using Appium (cross-platform native + hybrid), WebdriverIO Mobile (@wdio/appium-service), and Flutter Driver / integration_test for Flutter apps.
+
+## Trigger Phrases
+
+- "Write mobile tests for [iOS/Android/Flutter]"
+- "Generate Appium tests from test cases"
+- "Create mobile E2E tests for [app]"
+- "Add Flutter integration tests"
+- "Appium tests for native/hybrid app"
+- "Mobile web tests on device"
+- "WebdriverIO mobile tests with Appium"
+- "Touch actions, gestures, app lifecycle tests"
+- "Configure device farm (BrowserStack, Sauce Labs)"
+- "Mobile test capabilities and emulator setup"
+
+## Workflow
+
+1. **Read test cases** — From qa-testcase-from-docs, qa-manual-test-designer, qa-testcase-from-ui
+2. **Determine platform/framework** — iOS vs Android, native vs hybrid vs Flutter vs mobile web
+3. **Generate test files** — Create test scripts with appropriate framework (Appium, WDIO, Flutter)
+4. **Configure capabilities** — platformName, automationName, app path, device/emulator
+5. **Set up device/emulator** — Local emulator, simulator, or device farm config
+
+## Frameworks
+
+| Framework | Use Case | Drivers |
+|-----------|----------|---------|
+| **Appium** | Native, hybrid, mobile web | XCUITest (iOS), UiAutomator2 (Android), Espresso (Android) |
+| **WebdriverIO Mobile** | WDIO + Appium; TypeScript | @wdio/appium-service, same drivers |
+| **Flutter Driver** | Flutter apps only | Flutter driver, integration_test |
+
+## Platform Coverage
+
+| Platform | Driver | Automation |
+|----------|--------|------------|
+| **iOS** | XCUITest | Native, hybrid, Safari (mobile web) |
+| **Android** | UiAutomator2 | Native, hybrid, Chrome (mobile web) |
+| **Flutter** | Flutter Driver | Flutter widgets, integration_test |
+| **Mobile Web** | Browser on device | Chrome (Android), Safari (iOS) |
+
+## Key Patterns
+
+- **Desired capabilities:** platformName, automationName, app (path or URL), deviceName, udid, noReset, fullReset
+- **Touch actions:** tap, swipe, scroll, long press, multi-touch
+- **Element location:** accessibility id, xpath, class name, resource-id (Android), name (iOS)
+- **Gestures:** W3C Actions API, TouchAction, MultiTouchAction
+- **App lifecycle:** install, launch, close, reset, background/foreground
+
+See `references/patterns.md` for native apps, hybrid apps, gestures, app lifecycle, deep links.
+
+## Flutter Integration
+
+- **flutter_test** — Unit and widget tests
+- **integration_test** — E2E on device/emulator
+- **Finders:** find.byKey, find.text, find.byType, find.bySemanticsLabel
+- **Pumping:** pumpWidget, pumpAndSettle
+- **Golden tests** — Screenshot comparison for visual regression
+
+## WebdriverIO Mobile
+
+- **@wdio/appium-service** — Appium server management
+- **Mobile-specific selectors** — accessibility id, -android uiautomator, -ios predicate string
+- **Touch actions** — element.touchAction(), browser.touchAction()
+- **Mobile commands** — getContext, switchContext (for hybrid)
+
+## Device Farms
+
+| Service | Use Case |
+|---------|----------|
+| **BrowserStack** | Real devices, parallel execution |
+| **Sauce Labs** | Real devices, emulators, Appium cloud |
+| **AWS Device Farm** | AWS-integrated device testing |
+| **Local** | Emulators, simulators, USB devices |
+
+See `references/config.md` for Appium setup, capabilities, device farms, emulators.
+
+## Output
+
+- Mobile test scripts (Appium, WDIO, Flutter)
+- Capability configuration files
+- CI integration snippets (GitHub Actions, Jenkins, etc.)
+- Device/emulator setup instructions
+
+## Scope
+
+**Can do (autonomous):**
+- Generate Appium, WebdriverIO Mobile, Flutter Driver tests from test cases
+- Configure desired capabilities for iOS/Android
+- Use touch actions, gestures, app lifecycle patterns
+- Set up capability configs for BrowserStack, Sauce Labs, AWS Device Farm
+- Generate Flutter integration_test with finders and pumping
+- Apply accessibility id, resource-id, xpath for element location
+- Delegate to qa-test-healer when tests fail (selector/assertion fixes)
+
+**Cannot do (requires confirmation):**
+- Change production app code or add test IDs
+- Add dependencies not in package.json / pubspec.yaml
+- Override project Appium/WDIO config without approval
+- Install or configure emulators/simulators on user machine
+
+**Will not do (out of scope):**
+- Execute tests (user runs `npx wdio`, `appium`, `flutter test integration_test`)
+- Write unit/widget tests (use qa-jest-writer, qa-pytest-writer)
+- Modify CI/CD pipelines
+- Provision or manage device farm accounts
+
+## References
+
+- `references/patterns.md` — Native apps, hybrid apps, gestures, app lifecycle, deep links
+- `references/config.md` — Appium setup, capabilities, device farms, emulators
+- `references/best-practices.md` — Test stability, device matrix, accessibility IDs, CI with emulators
+
+## Quality Checklist
+
+- [ ] Accessibility id / resource-id preferred over xpath where possible
+- [ ] Touch actions used for mobile (tap, swipe, scroll) vs generic click
+- [ ] App lifecycle handled (install, launch, reset) per test needs
+- [ ] Capabilities match target platform (iOS XCUITest, Android UiAutomator2)
+- [ ] Tests independent (no shared state, order-independent)
+- [ ] No hardcoded secrets (use env vars for device farm credentials)
+- [ ] Traceability to test case IDs where applicable
+- [ ] Flutter: find.byKey used for stable element location when available
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| Element not found | Wrong locator strategy, timing | Use accessibility id; add explicit wait; check context (native vs webview) |
+| Session not created | Capability mismatch, wrong driver | Verify platformName, automationName, app path; check Appium server version |
+| Hybrid app: element in webview | Wrong context | Use getContext/switchContext to webview; use CSS/XPath in webview |
+| Flaky on emulator | Timing, animations | Use pumpAndSettle (Flutter); add explicit waits; disable animations |
+| Device farm timeout | Slow device, network | Increase timeout; use faster device; check app size |
+| Gesture fails | Unsupported action | Use W3C Actions API; fallback to TouchAction |
+| App not installing | Invalid path, signing | Verify app path; check .ipa/.apk signing for real devices |

package/skills/qa-mobile-test-writer/references/best-practices.md

@@ -0,0 +1,214 @@
+# Mobile Testing Best Practices
+
+## Test Stability
+
+### Prefer Accessibility IDs
+
+```javascript
+// Good — stable, semantic
+await $('~login-button').click();
+await $('~email-input').setValue('user@test.com');
+
+// Avoid — brittle
+await $('//android.widget.Button[@index="2"]').click();
+await $('.android.widget.EditText').setValue('user@test.com');
+```
+
+**Recommendation:** Add `accessibilityIdentifier` (iOS) and `contentDescription` / `testID` (Android/React Native) to key UI elements. Use these for automation.
+
+### Explicit Waits
+
+```javascript
+// Good — wait for condition
+await $('~welcome-message').waitForDisplayed({ timeout: 10000 });
+await $('~submit-btn').waitForClickable();
+
+// Bad — arbitrary delay
+await driver.pause(3000);
+```
+
+### Handle Animations
+
+- **Flutter:** Use `pumpAndSettle()` to wait for animations to finish
+- **Appium:** Add short waits after navigation; use `waitForDisplayed` before interaction
+- **Tip:** Disable animations on emulators for faster, more stable runs:
+  - Android: Settings → Developer options → Window/Transition/Animator scale → Off
+  - iOS: Settings → Accessibility → Motion → Reduce Motion
+
+### Avoid Order Dependencies
+
+- Each test should run in isolation
+- Use `beforeEach` to reset app state or use `fullReset` when needed
+- Prefer API/data setup over UI-based setup when possible
+
+---
+
+## Device Matrix
+
+### Prioritize Key Combinations
+
+| Priority | Android | iOS |
+|----------|---------|-----|
+| High | Latest (API 34) | Latest (17) |
+| Medium | L-1 (API 33) | N-1 (16) |
+| Low | Older (API 30) | Older (15) |
+
+### Screen Sizes
+
+- **Phone:** Small (320pt), Medium (375pt), Large (414pt)
+- **Tablet:** 768pt, 1024pt (if app supports)
+- **Orientation:** Portrait and landscape for critical flows
+
+### Strategy
+
+- **Smoke:** 1–2 devices (latest Android + iOS)
+- **Regression:** 4–6 devices covering OS versions and screen sizes
+- **Full matrix:** Device farm with parallel execution
+
+---
+
+## Accessibility IDs
+
+### iOS (Swift/SwiftUI)
+
+```swift
+Button("Login") { ... }
+  .accessibilityIdentifier("login-button")
+
+TextField("Email", text: $email)
+  .accessibilityIdentifier("email-input")
+```
+
+### Android (Kotlin/XML)
+
+```xml
+<Button
+  android:id="@+id/login_button"
+  android:contentDescription="Login" />
+```
+
+```kotlin
+// Or programmatically
+view.accessibilityDelegate = object : AccessibilityDelegate() {
+  // Use contentDescription for screen readers and automation
+}
+```
+
+### React Native
+
+```jsx
+<Button testID="login-button" title="Login" />
+<TextInput testID="email-input" />
+```
+
+### Flutter
+
+```dart
+ElevatedButton(
+  key: Key('login-button'),
+  onPressed: () {},
+  child: Text('Login'),
+)
+```
+
+---
+
+## CI with Emulators
+
+### Caching
+
+- Cache Android SDK and emulator images
+- Cache iOS simulators (Xcode)
+- Cache npm/pip dependencies
+
+### Parallelization
+
+```yaml
+# Run Android and iOS in parallel
+jobs:
+  android:
+    runs-on: ubuntu-latest
+    steps:
+      - run: npx wdio run wdio.android.conf.ts
+  ios:
+    runs-on: macos-latest
+    steps:
+      - run: npx wdio run wdio.ios.conf.ts
+```
+
+### Sharding
+
+```bash
+# Split specs across workers
+npx wdio run wdio.conf.ts --shard=1/4
+npx wdio run wdio.conf.ts --shard=2/4
+# ...
+```
+
+### Artifacts on Failure
+
+- Screenshots on failure
+- Appium logs
+- Video recording (device farms often provide this)
+
+```javascript
+afterTest: async function (test, context, result) {
+  if (result.error) {
+    const screenshot = await browser.takeScreenshot();
+    // Write to file, upload to artifact storage
+  }
+},
+```
+
+---
+
+## Hybrid App Considerations
+
+- **Context switching:** Always verify current context before interacting
+- **Webview load:** Wait for webview context to appear and page to load
+- **Selectors in webview:** Use web selectors (CSS, XPath) after switching to webview
+- **Performance:** Webview interactions can be slower; increase timeouts if needed
+
+---
+
+## Flutter-Specific
+
+### Use Keys for Stability
+
+```dart
+// In app
+ElevatedButton(key: Key('submit'), ...)
+
+// In test
+await tester.tap(find.byKey(Key('submit')));
+```
+
+### pumpAndSettle for Animations
+
+```dart
+await tester.pumpAndSettle();  // Waits for all animations
+```
+
+### Golden Tests
+
+- Store golden images in version control
+- Review visual diffs in PRs
+- Use `flutter test --update-goldens` to update when UI intentionally changes
+
+---
+
+## Security
+
+- Never hardcode device farm credentials
+- Use `process.env` or CI secrets
+- Store app paths in config; avoid committing .apk/.ipa to repo
+- Use signed builds for real device testing
+
+---
+
+## Performance
+
+- Use `noReset: true` when possible to avoid reinstall between tests
+- Run tests in parallel on device farms
+- Minimize unnecessary app restarts
+- Consider splitting long flows into smaller, focused tests