agentic-qe 1.2.0 → 1.3.1

package/.claude/skills/database-testing/SKILL.md

@@ -0,0 +1,243 @@
+---
+name: database-testing
+description: Database schema validation, data integrity testing, migration testing, transaction isolation, and query performance. Use when testing data persistence, ensuring referential integrity, or validating database migrations.
+version: 1.0.0
+category: specialized-testing
+tags: [database-testing, sql, schema-migration, data-integrity, transaction-testing, query-performance]
+difficulty: intermediate
+estimated_time: 75 minutes
+author: agentic-qe
+---
+
+# Database Testing
+
+## Core Principle
+
+**Data is your most valuable asset. Database bugs cause data loss/corruption.**
+
+Database testing ensures schema correctness, data integrity, transaction safety, and query performance. Critical for preventing catastrophic data issues.
+
+## Schema Testing
+
+**Validate database structure:**
+```sql
+-- Test schema exists
+SELECT table_name FROM information_schema.tables 
+WHERE table_schema = 'public' AND table_name = 'users';
+
+-- Test column types
+SELECT column_name, data_type 
+FROM information_schema.columns 
+WHERE table_name = 'users';
+
+-- Test constraints
+SELECT constraint_name, constraint_type
+FROM information_schema.table_constraints
+WHERE table_name = 'users';
+```
+
+**Test with code:**
+```javascript
+test('users table has correct schema', async () => {
+  const schema = await db.raw(`
+    SELECT column_name, data_type, is_nullable
+    FROM information_schema.columns
+    WHERE table_name = 'users'
+  `);
+
+  expect(schema).toContainEqual({
+    column_name: 'id',
+    data_type: 'integer',
+    is_nullable: 'NO'
+  });
+
+  expect(schema).toContainEqual({
+    column_name: 'email',
+    data_type: 'character varying',
+    is_nullable: 'NO'
+  });
+});
+```
+
+## Data Integrity Testing
+
+**Test constraints:**
+```javascript
+test('email must be unique', async () => {
+  await db.users.create({ email: 'test@example.com' });
+
+  // Duplicate should fail
+  await expect(
+    db.users.create({ email: 'test@example.com' })
+  ).rejects.toThrow('unique constraint violation');
+});
+
+test('foreign key prevents orphaned records', async () => {
+  const user = await db.users.create({ email: 'test@example.com' });
+  await db.orders.create({ userId: user.id, total: 100 });
+
+  // Cannot delete user with orders
+  await expect(
+    db.users.delete({ id: user.id })
+  ).rejects.toThrow('foreign key constraint');
+});
+
+test('check constraint validates data', async () => {
+  // Age must be ≥ 18
+  await expect(
+    db.users.create({ email: 'minor@example.com', age: 17 })
+  ).rejects.toThrow('check constraint violation');
+});
+```
+
+## Migration Testing
+
+**Test database migrations:**
+```javascript
+import { migrate, rollback } from './migrations';
+
+test('migration adds users table', async () => {
+  // Start fresh
+  await rollback();
+
+  // Run migration
+  await migrate();
+
+  // Verify table exists
+  const tables = await db.raw(`
+    SELECT table_name FROM information_schema.tables
+    WHERE table_schema = 'public'
+  `);
+
+  expect(tables.map(t => t.table_name)).toContain('users');
+});
+
+test('migration is reversible', async () => {
+  await migrate();
+  await rollback();
+
+  // Table should be gone
+  const tables = await db.raw(`
+    SELECT table_name FROM information_schema.tables
+    WHERE table_schema = 'public'
+  `);
+
+  expect(tables.map(t => t.table_name)).not.toContain('users');
+});
+
+test('migration preserves existing data', async () => {
+  // Create data before migration
+  await db.users.create({ email: 'test@example.com' });
+
+  // Run migration that adds 'age' column
+  await migrate('add-age-column');
+
+  // Data should still exist
+  const user = await db.users.findOne({ email: 'test@example.com' });
+  expect(user).toBeDefined();
+  expect(user.age).toBeNull(); // New column, null default
+});
+```
+
+## Transaction Isolation Testing
+
+**Test ACID properties:**
+```javascript
+test('transaction rolls back on error', async () => {
+  const initialCount = await db.users.count();
+
+  try {
+    await db.transaction(async (trx) => {
+      await trx('users').insert({ email: 'user1@example.com' });
+      await trx('users').insert({ email: 'user2@example.com' });
+
+      // Force error
+      throw new Error('Rollback test');
+    });
+  } catch (error) {
+    // Expected
+  }
+
+  // No users should be inserted
+  const finalCount = await db.users.count();
+  expect(finalCount).toBe(initialCount);
+});
+
+test('concurrent transactions are isolated', async () => {
+  const user = await db.users.create({ email: 'test@example.com', balance: 100 });
+
+  // Two concurrent withdrawals
+  const withdraw1 = db.transaction(async (trx) => {
+    const current = await trx('users').where({ id: user.id }).first();
+    await sleep(100); // Simulate delay
+    await trx('users').where({ id: user.id }).update({ 
+      balance: current.balance - 50 
+    });
+  });
+
+  const withdraw2 = db.transaction(async (trx) => {
+    const current = await trx('users').where({ id: user.id }).first();
+    await sleep(100);
+    await trx('users').where({ id: user.id }).update({ 
+      balance: current.balance - 50 
+    });
+  });
+
+  await Promise.all([withdraw1, withdraw2]);
+
+  // With proper isolation, balance should be 0, not 50
+  const final = await db.users.findOne({ id: user.id });
+  expect(final.balance).toBe(0); // Not 50!
+});
+```
+
+## Query Performance Testing
+
+**Test slow queries:**
+```javascript
+test('user lookup by email is fast', async () => {
+  // Seed 10,000 users
+  await seedUsers(10000);
+
+  const start = Date.now();
+  await db.users.findOne({ email: 'user5000@example.com' });
+  const duration = Date.now() - start;
+
+  // Should use index on email
+  expect(duration).toBeLessThan(10); // < 10ms
+});
+
+test('EXPLAIN shows index usage', async () => {
+  const explain = await db.raw(`
+    EXPLAIN SELECT * FROM users WHERE email = 'test@example.com'
+  `);
+
+  // Should show index scan, not sequential scan
+  const plan = explain.rows[0]['QUERY PLAN'];
+  expect(plan).toContain('Index Scan');
+  expect(plan).not.toContain('Seq Scan');
+});
+```
+
+## Related Skills
+
+- [test-data-management](../test-data-management/) - Generate test data for DB
+- [performance-testing](../performance-testing/) - DB performance testing
+- [test-automation-strategy](../test-automation-strategy/) - Automate DB tests
+
+## Remember
+
+**Database bugs are catastrophic.**
+
+- Data loss is unrecoverable
+- Corruption spreads silently
+- Performance issues compound
+- Migrations must be reversible
+
+**Test migrations before production:**
+- Forward migration works
+- Backward rollback works
+- Data preserved/migrated correctly
+- Performance acceptable
+
+**With Agents:** `qe-test-data-architect` generates realistic test data with referential integrity. `qe-test-executor` runs DB migration tests automatically in CI/CD.

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

@@ -0,0 +1,115 @@
+---
+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.
+version: 1.0.0
+category: specialized-testing
+tags: [i18n, l10n, localization, internationalization, translations, rtl, locale]
+difficulty: intermediate
+estimated_time: 60 minutes
+author: agentic-qe
+---
+
+# Localization & Internationalization Testing
+
+## Core Principle
+
+**Global products must work globally.**
+
+i18n testing ensures software supports multiple languages, regions, and cultures without code changes.
+
+## i18n vs l10n
+
+**Internationalization (i18n):** Building software to support localization
+**Localization (l10n):** Adapting software for specific locale
+
+## Testing Translation Coverage
+
+```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', () => {
+  const text = await page.locator('button').textContent();
+
+  // 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, 'USD')).toBe('$1,234.56');
+  expect(formatCurrency(amount, 'EUR')).toBe('€1.234,56');
+  expect(formatCurrency(amount, 'JPY')).toBe('¥1,235'); // No decimals
+});
+```
+
+## RTL (Right-to-Left) Testing
+
+```javascript
+test('layout flips for RTL languages', async () => {
+  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');
+});
+```
+
+## Character Encoding
+
+```javascript
+test('supports unicode characters', async () => {
+  // Japanese
+  await page.fill('#name', '山田太郎');
+
+  // Arabic
+  await page.fill('#name', 'محمد');
+
+  // Emoji
+  await page.fill('#name', '👋🌍');
+
+  // Verify saved correctly
+  const saved = await db.users.findOne({ id: userId });
+  expect(saved.name).toBe('👋🌍');
+});
+```
+
+## Remember
+
+**Don't hardcode. Externalize all user-facing strings.**
+
+Test:
+- Translation completeness
+- Locale-specific formats (date, time, currency)
+- RTL layout (Arabic, Hebrew)
+- Character encoding (UTF-8)
+- Cultural appropriateness
+
+**With Agents:** Agents validate translation coverage, detect hardcoded strings, and test locale-specific formatting automatically across all supported languages.