@agentic-qe/v3 3.0.0-alpha.10

package/assets/skills/localization-testing/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: localization-testing
+description: "Internationalization (i18n) and localization (l10n) testing for global products including translations, locale formats, RTL languages, and cultural appropriateness. Use when launching in new markets or building multi-language products."
+category: specialized-testing
+priority: medium
+tokenEstimate: 800
+agents: [qe-test-generator, qe-test-executor, qe-visual-tester]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [localization, i18n, l10n, translation, rtl, unicode, locale]
+---
+
+# Localization & Internationalization Testing
+
+<default_to_action>
+When testing multi-language/region support:
+1. VERIFY translation coverage (all strings translated)
+2. TEST locale-specific formats (date, time, currency, numbers)
+3. VALIDATE RTL layout (Arabic, Hebrew)
+4. CHECK character encoding (UTF-8, unicode)
+5. CONFIRM cultural appropriateness (icons, colors, content)
+
+**Quick i18n Checklist:**
+- All user-facing strings externalized
+- No hardcoded text in code
+- Date/time/currency formatted per locale
+- RTL languages flip layout correctly
+- Unicode characters display properly
+
+**Critical Success Factors:**
+- Don't hardcode strings - externalize everything
+- Test with real speakers, not just translation files
+- RTL requires mirrored UI layout
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Launching in new markets
+- Adding language support
+- Before international releases
+- After UI changes
+
+### i18n vs l10n
+| Term | Full Name | Focus |
+|------|-----------|-------|
+| **i18n** | Internationalization | Building for localization |
+| **l10n** | Localization | Adapting for specific locale |
+
+### Common Locale Formats
+| Type | US (en-US) | UK (en-GB) | Japan (ja-JP) |
+|------|------------|------------|---------------|
+| **Date** | 10/24/2025 | 24/10/2025 | 2025/10/24 |
+| **Currency** | $1,234.56 | £1,234.56 | ¥1,235 |
+| **Number** | 1,234.56 | 1,234.56 | 1,234.56 |
+
+---
+
+## Translation Coverage Testing
+
+```javascript
+test('all strings are translated', () => {
+  const enKeys = Object.keys(translations.en);
+  const frKeys = Object.keys(translations.fr);
+  const esKeys = Object.keys(translations.es);
+
+  // All locales have same keys
+  expect(frKeys).toEqual(enKeys);
+  expect(esKeys).toEqual(enKeys);
+});
+
+test('no missing translation placeholders', async ({ page }) => {
+  await page.goto('/?lang=fr');
+  const text = await page.textContent('body');
+
+  // Should not see placeholder keys
+  expect(text).not.toContain('translation.missing');
+  expect(text).not.toMatch(/\{\{.*\}\}/); // {{key}} format
+});
+```
+
+---
+
+## Date/Time/Currency Formats
+
+```javascript
+test('date formats by locale', () => {
+  const date = new Date('2025-10-24');
+
+  expect(formatDate(date, 'en-US')).toBe('10/24/2025');
+  expect(formatDate(date, 'en-GB')).toBe('24/10/2025');
+  expect(formatDate(date, 'ja-JP')).toBe('2025/10/24');
+});
+
+test('currency formats by locale', () => {
+  const amount = 1234.56;
+
+  expect(formatCurrency(amount, 'en-US', 'USD')).toBe('$1,234.56');
+  expect(formatCurrency(amount, 'de-DE', 'EUR')).toBe('1.234,56 €');
+  expect(formatCurrency(amount, 'ja-JP', 'JPY')).toBe('¥1,235');
+});
+```
+
+---
+
+## RTL (Right-to-Left) Testing
+
+```javascript
+test('layout flips for RTL languages', async ({ page }) => {
+  await page.goto('/?lang=ar'); // Arabic
+
+  const dir = await page.locator('html').getAttribute('dir');
+  expect(dir).toBe('rtl');
+
+  // Navigation should be on right
+  const nav = await page.locator('nav');
+  const styles = await nav.evaluate(el =>
+    window.getComputedStyle(el)
+  );
+  expect(styles.direction).toBe('rtl');
+});
+
+test('icons/images appropriate for RTL', async ({ page }) => {
+  await page.goto('/?lang=he'); // Hebrew
+
+  // Back arrow should point right in RTL
+  const backIcon = await page.locator('.back-icon');
+  expect(await backIcon.getAttribute('class')).toContain('rtl-flipped');
+});
+```
+
+---
+
+## Unicode Character Support
+
+```javascript
+test('supports unicode characters', async ({ page }) => {
+  // Japanese
+  await page.fill('#name', '山田太郎');
+  await page.click('#submit');
+
+  const saved = await db.users.findOne({ /* ... */ });
+  expect(saved.name).toBe('山田太郎');
+
+  // Arabic
+  await page.fill('#name', 'محمد');
+  // Emoji
+  await page.fill('#bio', '👋🌍');
+
+  expect(saved.bio).toBe('👋🌍');
+});
+```
+
+---
+
+## Agent-Driven Localization Testing
+
+```typescript
+// Comprehensive localization validation
+await Task("Localization Testing", {
+  url: 'https://example.com',
+  locales: ['en-US', 'fr-FR', 'de-DE', 'ja-JP', 'ar-SA'],
+  checks: ['translations', 'formats', 'rtl', 'unicode'],
+  detectHardcodedStrings: true
+}, "qe-test-generator");
+
+// Returns:
+// {
+//   locales: 5,
+//   missingTranslations: 3,
+//   formatIssues: 1,
+//   rtlIssues: 0,
+//   hardcodedStrings: ['button.submit', 'header.title']
+// }
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/localization-testing/
+├── translations/*       - Translation coverage
+├── formats/*            - Locale-specific formats
+├── rtl-validation/*     - RTL layout checks
+└── unicode/*            - Character encoding tests
+```
+
+### Fleet Coordination
+```typescript
+const l10nFleet = await FleetManager.coordinate({
+  strategy: 'localization-testing',
+  agents: [
+    'qe-test-generator',   // Generate l10n tests
+    'qe-test-executor',    // Execute across locales
+    'qe-visual-tester'     // RTL visual validation
+  ],
+  topology: 'parallel'
+});
+```
+
+---
+
+## Related Skills
+- [accessibility-testing](../accessibility-testing/) - Language accessibility
+- [compatibility-testing](../compatibility-testing/) - Cross-platform i18n
+- [visual-testing-advanced](../visual-testing-advanced/) - RTL visual regression
+
+---
+
+## Remember
+
+**Don't hardcode. Externalize all user-facing strings.** Every string visible to users must come from translation files, not code.
+
+**Test with native speakers, not just translation files.** Machine translations and translation files can have context issues that only native speakers catch.
+
+**With Agents:** Agents validate translation coverage, detect hardcoded strings, test locale-specific formatting, and verify RTL layouts automatically across all supported languages.

package/assets/skills/mobile-testing/SKILL.md

@@ -0,0 +1,219 @@
+---
+name: mobile-testing
+description: "Comprehensive mobile testing for iOS and Android platforms including gestures, sensors, permissions, device fragmentation, and performance. Use when testing native apps, hybrid apps, or mobile web, ensuring quality across 1000+ device variants."
+category: specialized-testing
+priority: high
+tokenEstimate: 1000
+agents: [qe-test-executor, qe-performance-tester, qe-visual-tester]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [mobile, ios, android, appium, gestures, device-fragmentation, sensors]
+---
+
+# Mobile Testing
+
+<default_to_action>
+When testing mobile applications:
+1. DEFINE device coverage matrix (Tier 1: 60%, Tier 2: 30%, Tier 3: 10%)
+2. TEST platform differences (iOS ≠ Android: back button, permissions, UI)
+3. VALIDATE touch gestures (tap, swipe, pinch, long-press)
+4. TEST mobile-specific scenarios (offline, low battery, interruptions)
+5. USE real devices for critical paths, emulators for fast feedback
+
+**Quick Mobile Checklist:**
+- Test on latest iOS + Android flagship devices
+- Test offline mode and network transitions
+- Verify push notifications work
+- Test gesture interactions (swipe, pinch)
+- Check permissions flow (camera, location, notifications)
+
+**Critical Success Factors:**
+- Emulators for 80% of testing, real devices for 20% critical paths
+- Test on devices your users actually use (analytics)
+- Device fragmentation is Android's biggest challenge
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Native app development (iOS/Android)
+- Hybrid apps (React Native, Flutter)
+- Mobile web / PWAs
+- App store submission preparation
+
+### iOS vs Android Differences
+| Aspect | iOS | Android |
+|--------|-----|---------|
+| OS Versions | 2-3 supported | 10+ in use |
+| Devices | ~40 models | 1000+ variants |
+| Back Button | Gesture/nav | Hardware/software |
+| Permissions | Single prompt | Runtime granular |
+| App Store | Strict review | Google Play + sideload |
+
+### Device Coverage Tiers
+| Tier | Coverage | Devices |
+|------|----------|---------|
+| **Tier 1** | 60% users | iPhone 15, Galaxy S24, iPad |
+| **Tier 2** | 30% users | iPhone 14/13, Pixel 8 |
+| **Tier 3** | 10% users | Older devices, other manufacturers |
+
+### Mobile Performance Goals
+| Metric | Target |
+|--------|--------|
+| App launch | < 2 seconds |
+| Screen transition | < 300ms |
+| Frame rate | 60 FPS |
+| Battery drain | < 5%/hour background |
+
+---
+
+## Touch Gesture Testing
+
+```javascript
+// Appium gesture examples
+// Tap
+await driver.touchAction({ action: 'tap', x: 100, y: 200 });
+
+// Swipe (scroll down)
+await driver.touchAction([
+  { action: 'press', x: 200, y: 400 },
+  { action: 'moveTo', x: 200, y: 100 },
+  { action: 'release' }
+]);
+
+// Pinch to zoom
+const finger1 = [
+  { action: 'press', x: 100, y: 200 },
+  { action: 'moveTo', x: 50, y: 150 },
+  { action: 'release' }
+];
+const finger2 = [
+  { action: 'press', x: 200, y: 200 },
+  { action: 'moveTo', x: 250, y: 250 },
+  { action: 'release' }
+];
+await driver.multiTouchAction([finger1, finger2]);
+
+// Long press
+await driver.touchAction({
+  action: 'longPress',
+  x: 100, y: 200,
+  duration: 2000
+});
+```
+
+---
+
+## Mobile-Specific Scenarios
+
+```javascript
+// Offline mode testing
+test('app works offline', async () => {
+  await driver.toggleAirplaneMode();
+
+  await driver.findElement('view-saved-items').click();
+  const items = await driver.findElements('saved-item');
+  expect(items.length).toBeGreaterThan(0);
+
+  const banner = await driver.findElement('offline-banner');
+  expect(banner.getText()).toContain('No internet');
+
+  await driver.toggleAirplaneMode(); // Restore
+});
+
+// Location testing
+test('location-based features', async () => {
+  await driver.setGeoLocation({
+    latitude: 37.7749,
+    longitude: -122.4194,
+    altitude: 0
+  });
+
+  const stores = await driver.findElement('stores-list');
+  expect(stores.getText()).toContain('San Francisco');
+});
+
+// Permission testing (Android)
+test('camera permission flow', async () => {
+  await driver.findElement('take-photo').click();
+
+  // Handle permission dialog
+  await driver.findElement(
+    'com.android.packageinstaller:id/permission_allow_button'
+  ).click();
+
+  expect(await driver.findElement('camera-view')).toBeDefined();
+});
+```
+
+---
+
+## Agent-Driven Mobile Testing
+
+```typescript
+// Cross-platform mobile testing
+await Task("Mobile Test Suite", {
+  platforms: ['iOS', 'Android'],
+  deviceTiers: [1, 2],
+  tests: 'regression-suite',
+  parallelDevices: 5,
+  deviceFarm: 'browserstack'
+}, "qe-test-executor");
+
+// Device farm integration
+await Task("Device Farm Execution", {
+  service: 'browserstack',
+  devices: [
+    'iPhone 15 - iOS 17',
+    'Samsung Galaxy S24 - Android 14'
+  ],
+  recordVideo: true,
+  captureNetworkLogs: true
+}, "qe-test-executor");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/mobile-testing/
+├── device-matrix/*      - Device coverage strategy
+├── platform-tests/*     - iOS/Android specific tests
+├── gesture-library/*    - Reusable gesture patterns
+└── performance/*        - Mobile performance metrics
+```
+
+### Fleet Coordination
+```typescript
+const mobileFleet = await FleetManager.coordinate({
+  strategy: 'mobile-testing',
+  agents: [
+    'qe-test-executor',       // Cross-platform execution
+    'qe-performance-tester',  // Mobile performance
+    'qe-visual-tester'        // Screen size validation
+  ],
+  topology: 'parallel'
+});
+```
+
+---
+
+## Related Skills
+- [accessibility-testing](../accessibility-testing/) - VoiceOver, TalkBack
+- [performance-testing](../performance-testing/) - Mobile performance
+- [compatibility-testing](../compatibility-testing/) - Device compatibility
+
+---
+
+## Remember
+
+**Mobile is not a smaller desktop - it's a different platform.** 60%+ of web traffic is mobile. Device fragmentation (1000+ Android devices), touch gestures, sensors, permissions, offline scenarios - all require specific testing.
+
+**Test on real devices for critical flows.** Emulators catch 80% of bugs but real devices needed for actual performance, sensor behavior, and platform quirks.
+
+**With Agents:** `qe-test-executor` orchestrates testing across device farms, manages platform differences, and tests 10+ devices in parallel. Reduces mobile testing from days to hours.

package/assets/skills/mutation-testing/SKILL.md

@@ -0,0 +1,229 @@
+---
+name: mutation-testing
+description: "Test quality validation through mutation testing, assessing test suite effectiveness by introducing code mutations and measuring kill rate. Use when evaluating test quality, identifying weak tests, or proving tests actually catch bugs."
+category: specialized-testing
+priority: high
+tokenEstimate: 900
+agents: [qe-test-generator, qe-coverage-analyzer, qe-quality-analyzer]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [mutation, stryker, test-quality, kill-rate, assertions, effectiveness]
+---
+
+# Mutation Testing
+
+<default_to_action>
+When validating test quality or improving test effectiveness:
+1. MUTATE code (change + to -, >= to >, remove statements)
+2. RUN tests against each mutant
+3. VERIFY tests catch mutations (kill mutants)
+4. IDENTIFY surviving mutants (tests need improvement)
+5. STRENGTHEN tests to kill surviving mutants
+
+**Quick Mutation Metrics:**
+- Mutation Score = Killed / (Killed + Survived)
+- Target: > 80% mutation score
+- Surviving mutants = weak tests
+
+**Critical Success Factors:**
+- High coverage ≠ good tests (100% coverage, 0% assertions)
+- Mutation testing proves tests actually catch bugs
+- Focus on critical code paths first
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Evaluating test suite quality
+- Finding gaps in test assertions
+- Proving tests catch bugs
+- Before critical releases
+
+### Mutation Score Interpretation
+| Score | Interpretation |
+|-------|----------------|
+| **90%+** | Excellent test quality |
+| **80-90%** | Good, minor improvements |
+| **60-80%** | Needs attention |
+| **< 60%** | Significant gaps |
+
+### Common Mutation Operators
+| Category | Original | Mutant |
+|----------|----------|--------|
+| **Arithmetic** | `a + b` | `a - b` |
+| **Relational** | `x >= 18` | `x > 18` |
+| **Logical** | `a && b` | `a \|\| b` |
+| **Conditional** | `if (x)` | `if (true)` |
+| **Statement** | `return x` | *(removed)* |
+
+---
+
+## How Mutation Testing Works
+
+```javascript
+// Original code
+function isAdult(age) {
+  return age >= 18; // ← Mutant: change >= to >
+}
+
+// Strong test (catches mutation)
+test('18 is adult', () => {
+  expect(isAdult(18)).toBe(true); // Kills mutant!
+});
+
+// Weak test (mutation survives)
+test('19 is adult', () => {
+  expect(isAdult(19)).toBe(true); // Doesn't catch >= vs >
+});
+// Surviving mutant → Test needs boundary value
+```
+
+---
+
+## Using Stryker
+
+```bash
+# Install
+npm install --save-dev @stryker-mutator/core @stryker-mutator/jest-runner
+
+# Initialize
+npx stryker init
+```
+
+**Configuration:**
+```json
+{
+  "packageManager": "npm",
+  "reporters": ["html", "clear-text", "progress"],
+  "testRunner": "jest",
+  "coverageAnalysis": "perTest",
+  "mutate": [
+    "src/**/*.ts",
+    "!src/**/*.spec.ts"
+  ],
+  "thresholds": {
+    "high": 90,
+    "low": 70,
+    "break": 60
+  }
+}
+```
+
+**Run:**
+```bash
+npx stryker run
+```
+
+**Output:**
+```
+Mutation Score: 87.3%
+Killed: 124
+Survived: 18
+No Coverage: 3
+Timeout: 1
+```
+
+---
+
+## Fixing Surviving Mutants
+
+```javascript
+// Surviving mutant: >= changed to >
+function calculateDiscount(quantity) {
+  if (quantity >= 10) { // Mutant survives!
+    return 0.1;
+  }
+  return 0;
+}
+
+// Original weak test
+test('large order gets discount', () => {
+  expect(calculateDiscount(15)).toBe(0.1); // Doesn't test boundary
+});
+
+// Fixed: Add boundary test
+test('exactly 10 gets discount', () => {
+  expect(calculateDiscount(10)).toBe(0.1); // Kills mutant!
+});
+
+test('9 does not get discount', () => {
+  expect(calculateDiscount(9)).toBe(0); // Tests below boundary
+});
+```
+
+---
+
+## Agent-Driven Mutation Testing
+
+```typescript
+// Analyze mutation score and generate fixes
+await Task("Mutation Analysis", {
+  targetFile: 'src/payment.ts',
+  generateMissingTests: true,
+  minScore: 80
+}, "qe-test-generator");
+
+// Returns:
+// {
+//   mutationScore: 0.65,
+//   survivedMutations: [
+//     { line: 45, operator: '>=', mutant: '>', killedBy: null }
+//   ],
+//   generatedTests: [
+//     'test for boundary at line 45'
+//   ]
+// }
+
+// Coverage + mutation correlation
+await Task("Coverage Quality Analysis", {
+  coverageData: coverageReport,
+  mutationData: mutationReport,
+  identifyWeakCoverage: true
+}, "qe-coverage-analyzer");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/mutation-testing/
+├── mutation-results/*   - Stryker reports
+├── surviving/*          - Surviving mutants
+├── generated-tests/*    - Tests to kill mutants
+└── trends/*             - Mutation score over time
+```
+
+### Fleet Coordination
+```typescript
+const mutationFleet = await FleetManager.coordinate({
+  strategy: 'mutation-testing',
+  agents: [
+    'qe-test-generator',     // Generate tests for survivors
+    'qe-coverage-analyzer',  // Coverage correlation
+    'qe-quality-analyzer'    // Quality assessment
+  ],
+  topology: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [tdd-london-chicago](../tdd-london-chicago/) - Write effective tests first
+- [test-design-techniques](../test-design-techniques/) - Boundary value analysis
+- [quality-metrics](../quality-metrics/) - Measure test effectiveness
+
+---
+
+## Remember
+
+**High code coverage ≠ good tests.** 100% coverage but weak assertions = useless. Mutation testing proves tests actually catch bugs.
+
+**Focus on critical paths first.** Don't mutation test everything - prioritize payment, authentication, data integrity code.
+
+**With Agents:** Agents run mutation analysis, identify surviving mutants, and generate missing test cases to kill them. Automated improvement of test quality.