@nockdev/awf 6.2.0 → 6.2.2

package/.agent/skills/cross-cutting/tdd-workflow/data/test-doubles.yaml

@@ -0,0 +1,93 @@
+# Test Doubles Patterns
+# Mock, Stub, Spy, Fake, Dummy patterns across languages
+
+patterns:
+  - name: dummy-object
+    type: dummy
+    description: "Object passed to fill required parameters but never used"
+    when: "Method signature requires parameter you don't care about"
+    example:
+      language: typescript
+      code: |
+        const dummyLogger = {} as Logger;
+        const service = new UserService(dummyLogger);
+
+  - name: stub-canned-response
+    type: stub
+    description: "Returns pre-configured answers to calls"
+    when: "Isolate SUT from external dependency"
+    examples:
+      typescript: |
+        const stubRepo = { findById: jest.fn().mockResolvedValue({ id: 1, name: 'John' }) };
+      python: |
+        stub_repo = Mock()
+        stub_repo.find_by_id.return_value = User(id=1, name="John")
+      go: |
+        type stubRepo struct{}
+        func (s *stubRepo) FindByID(id int) (*User, error) {
+            return &User{ID: 1, Name: "John"}, nil
+        }
+
+  - name: spy-record-calls
+    type: spy
+    description: "Records interactions for later verification"
+    when: "Verify side-effects (was method called? with what args?)"
+    examples:
+      typescript: |
+        const sendEmail = jest.fn();
+        service.register(user);
+        expect(sendEmail).toHaveBeenCalledWith(user.email, expect.any(String));
+      python: |
+        mock_email = Mock()
+        service.register(user)
+        mock_email.send.assert_called_once_with(user.email, ANY)
+
+  - name: mock-expectations
+    type: mock
+    description: "Pre-programmed with expectations, fail if unexpected calls"
+    when: "Strict behavior verification"
+    examples:
+      typescript: |
+        // Vitest strict mock
+        const mockPayment = vi.fn()
+          .mockResolvedValueOnce({ success: true })
+          .mockRejectedValueOnce(new Error('declined'));
+      java: |
+        // Mockito
+        when(paymentGateway.charge(any())).thenReturn(Result.success());
+        verify(paymentGateway, times(1)).charge(argThat(a -> a.amount() > 0));
+
+  - name: fake-implementation
+    type: fake
+    description: "Working implementation with shortcuts (in-memory DB, fake API)"
+    when: "Need real behavior without infrastructure"
+    examples:
+      typescript: |
+        class FakeUserRepository implements UserRepository {
+          private users: Map<string, User> = new Map();
+          async save(user: User) { this.users.set(user.id, user); }
+          async findById(id: string) { return this.users.get(id) ?? null; }
+        }
+      go: |
+        type FakeStore struct {
+            data map[string][]byte
+        }
+        func (f *FakeStore) Get(key string) ([]byte, error) {
+            v, ok := f.data[key]
+            if !ok { return nil, ErrNotFound }
+            return v, nil
+        }
+
+  - name: test-double-selection
+    type: guide
+    description: "Decision tree for choosing the right test double"
+    decision:
+      - question: "Do you need to verify interactions?"
+        yes: "Use Mock or Spy"
+        no: "Use Stub or Fake"
+      - question: "Do you need real behavior?"
+        yes: "Use Fake"
+        no: "Use Stub"
+      - question: "Do you need strict call verification?"
+        yes: "Use Mock"
+        no: "Use Spy"

package/.agent/skills/cross-cutting/testing/META.yaml

@@ -1,5 +1,5 @@
 name: testing
-version: "6.2.0"
+version: "6.2.2"
 display: Testing
 category: support
 tier: 1
@@ -37,10 +37,6 @@ caps:
   - Mocking strategies
   - Test-driven development
 
-hsa:
-  enabled: true
-  adapter: testing_adapter.py
-  functions:
     - search_testing_patterns
     - get_framework_patterns
 

package/.agent/skills/cross-cutting/testing/SKILL.md

@@ -8,7 +8,7 @@ detect:
     "vitest.config.*",
     "playwright.config.*",
   ]
-version: "6.1.2"
+version: "6.2.2"
 ---
 
 # Testing Patterns (2026)
@@ -17,10 +17,10 @@ version: "6.1.2"
 
 ## 📦 Data Files
 
-| File             | Content                                         | Records |
-| ---------------- | ----------------------------------------------- | ------- |
-| `frameworks.csv` | Testing frameworks across 12 languages          | 20      |
-| `patterns.csv`   | Testing patterns, best practices, anti-patterns | 15      |
+| File              | Content                                         | Records |
+| ----------------- | ----------------------------------------------- | ------- |
+| `frameworks.yaml` | Testing frameworks across 12 languages          | 20      |
+| `patterns.yaml`   | Testing patterns, best practices, anti-patterns | 15      |
 
 ## 📦 Testing Frameworks
 
@@ -234,29 +234,16 @@ test.describe("Full stack test", () => {
 
 ## 🔌 HSA Integration
 
-This skill is powered by HSA adapter for semantic search:
+Data powered by HSA BM25 search engine:
 
-```python
-from .agent.scripts.hsa.adapters import (
-    search_testing_patterns,
-    get_framework_for,
-    get_testing_pyramid,
-    get_mocking_patterns,
-)
+| Domain    | Query Examples                     |
+| --------- | ---------------------------------- |
+| Framework | "vitest typescript mocking"        |
+| E2E       | "playwright cross-browser testing" |
+| Pattern   | "AAA arrange act assert"           |
+| Coverage  | "v8 coverage threshold"            |
 
-# Search testing patterns
-results = search_testing_patterns("mocking", language="python")
-
-# Get recommended framework
-framework = get_framework_for("typescript", test_type="e2e")
-# → {"name": "Playwright", "type": "e2e", ...}
-
-# Test pyramid strategy
-pyramid = get_testing_pyramid()
-# → Unit 70%, Integration 20%, E2E 10%
-```
-
-**Available Functions**: `search_testing_patterns`, `get_framework_for`, `get_testing_pattern`, `get_testing_pyramid`, `get_mocking_patterns`, `get_coverage_command`
+**Data domains**: `frameworks`, `patterns`, `pyramid`, `mocking`, `coverage`
 
 ---
 

package/.agent/skills/cross-cutting/testing/data/e2e-patterns.yaml

@@ -0,0 +1,136 @@
+# =============================================================================
+# e2e-patterns.yaml — End-to-End Testing Patterns
+# =============================================================================
+
+version: "1.0.0"
+
+playwright:
+  config: |
+    // playwright.config.ts
+    import { defineConfig, devices } from '@playwright/test';
+    export default defineConfig({
+      testDir: './tests/e2e',
+      fullyParallel: true,
+      forbidOnly: !!process.env.CI,
+      retries: process.env.CI ? 2 : 0,
+      workers: process.env.CI ? 1 : undefined,
+      reporter: 'html',
+      use: {
+        baseURL: 'http://localhost:3000',
+        trace: 'on-first-retry',
+        screenshot: 'only-on-failure',
+      },
+      projects: [
+        { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
+        { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
+        { name: 'mobile', use: { ...devices['iPhone 14'] } },
+      ],
+      webServer: {
+        command: 'npm run dev',
+        url: 'http://localhost:3000',
+        reuseExistingServer: !process.env.CI,
+      },
+    });
+
+  page_objects: |
+    // tests/pages/LoginPage.ts
+    import { Page, Locator, expect } from '@playwright/test';
+
+    export class LoginPage {
+      readonly page: Page;
+      readonly emailInput: Locator;
+      readonly passwordInput: Locator;
+      readonly submitButton: Locator;
+
+      constructor(page: Page) {
+        this.page = page;
+        this.emailInput = page.getByLabel('Email');
+        this.passwordInput = page.getByLabel('Password');
+        this.submitButton = page.getByRole('button', { name: 'Sign in' });
+      }
+
+      async login(email: string, password: string) {
+        await this.emailInput.fill(email);
+        await this.passwordInput.fill(password);
+        await this.submitButton.click();
+      }
+    }
+
+  fixtures: |
+    // tests/fixtures.ts
+    import { test as base } from '@playwright/test';
+    import { LoginPage } from './pages/LoginPage';
+
+    type Fixtures = {
+      loginPage: LoginPage;
+      authenticatedPage: Page;
+    };
+
+    export const test = base.extend<Fixtures>({
+      loginPage: async ({ page }, use) => {
+        const loginPage = new LoginPage(page);
+        await page.goto('/login');
+        await use(loginPage);
+      },
+      authenticatedPage: async ({ page }, use) => {
+        await page.goto('/login');
+        // Login with test credentials
+        await page.getByLabel('Email').fill('test@example.com');
+        await page.getByLabel('Password').fill('password');
+        await page.getByRole('button', { name: 'Sign in' }).click();
+        await page.waitForURL('/dashboard');
+        await use(page);
+      },
+    });
+
+  visual_regression: |
+    test('homepage visual', async ({ page }) => {
+      await page.goto('/');
+      await expect(page).toHaveScreenshot('homepage.png', {
+        maxDiffPixelRatio: 0.01,
+      });
+    });
+
+cypress:
+  custom_commands: |
+    // cypress/support/commands.ts
+    Cypress.Commands.add('login', (email: string, password: string) => {
+      cy.session([email, password], () => {
+        cy.visit('/login');
+        cy.get('[data-testid=email]').type(email);
+        cy.get('[data-testid=password]').type(password);
+        cy.get('[data-testid=submit]').click();
+        cy.url().should('include', '/dashboard');
+      });
+    });
+
+  intercept: |
+    it('loads user data', () => {
+      cy.intercept('GET', '/api/users/*', { fixture: 'user.json' }).as('getUser');
+      cy.visit('/profile');
+      cy.wait('@getUser');
+      cy.get('[data-testid=username]').should('contain', 'John');
+    });
+
+best_practices:
+  selectors:
+    preferred: "data-testid, role, label, text"
+    avoid: "CSS classes, IDs, XPath"
+    example: |
+      ✅ page.getByRole('button', { name: 'Submit' })
+      ✅ page.getByTestId('submit-button')
+      ❌ page.locator('.btn-primary.submit')
+
+  test_isolation:
+    - "Each test should be independent"
+    - "Use database seeds/fixtures for test data"
+    - "Clean up after tests"
+    - "Don't depend on test execution order"
+
+  ci_setup:
+    - "Run in headless mode"
+    - "Use retries for flaky tests (max 2)"
+    - "Upload traces/screenshots on failure"
+    - "Parallelize across workers"
+
+# _DOMYH Awesome Code • E2E Testing Patterns_

package/.agent/skills/cross-cutting/testing/data/frameworks.yaml

@@ -1,9 +1,9 @@
 metadata:
   skill: testing
   domain: frameworks
-  version: 6.2.0
+  version: 6.2.2
   updated: "2026-02-05"
-  migrated_from: frameworks.csv
+  migrated_from: frameworks.yaml
   patterns_count: 20
   columns:
     - name
@@ -55,7 +55,7 @@ patterns:
     mocking: vi.fn(), vi.mock()
     coverage: --coverage
     docs_url: https://vitest.dev
-    # v6.2.0: Version-specific info
+    # v6.2.2: Version-specific info
     version_info:
       current: "4.0.0"
       min_supported: "2.0.0"

package/.agent/skills/cross-cutting/testing/data/patterns.yaml

@@ -1,168 +1,170 @@
 metadata:
   skill: testing
   domain: patterns
-  version: 6.2.0
-  updated: '2026-02-05'
-  migrated_from: patterns.csv
+  version: 6.2.2
+  updated: "2026-02-05"
+  migrated_from: patterns.yaml
   patterns_count: 15
   columns:
-  - pattern
-  - category
-  - description
-  - when_to_use
-  - example_structure
-  - anti_pattern
-  - languages
+    - pattern
+    - category
+    - description
+    - when_to_use
+    - example_structure
+    - anti_pattern
+    - languages
 patterns:
-- id: item_001
-  pattern: AAA Pattern
-  category: Structure
-  description: 'Arrange-Act-Assert: setup, execute, verify'
-  when_to_use: All unit tests
-  example_structure: '// Arrange
+  - id: item_001
+    pattern: AAA Pattern
+    category: Structure
+    description: "Arrange-Act-Assert: setup, execute, verify"
+    when_to_use: All unit tests
+    example_structure: "// Arrange
 
-    const calculator = new Calculator();
+      const calculator = new Calculator();
 
-    // Act
+      // Act
 
-    const result = calculator.add(2, 3);
+      const result = calculator.add(2, 3);
 
-    // Assert
+      // Assert
 
-    expect(result).toBe(5);'
-  anti_pattern: Mixing arrange/act/assert throughout test
-  languages: all
-- id: item_002
-  pattern: Given-When-Then
-  category: BDD
-  description: Given precondition, When action, Then outcome
-  when_to_use: Behavior-driven tests, acceptance tests
-  example_structure: "describe('Calculator', () => {\n  it('should add two numbers', () => {\n    // Given\n    const calc = new Calculator();\n    // When\n    const sum = calc.add(2, 3);\n    // Then\n\
-    \    expect(sum).toBe(5);\n  });\n});"
-  anti_pattern: No clear separation of phases
-  languages: all
-- id: item_003
-  pattern: Test Double Types
-  category: Mocking
-  description: Dummy, Stub, Spy, Mock, Fake - know the difference
-  when_to_use: When isolating units from dependencies
-  example_structure: 'Dummy: placeholder, never called
+      expect(result).toBe(5);"
+    anti_pattern: Mixing arrange/act/assert throughout test
+    languages: all
+  - id: item_002
+    pattern: Given-When-Then
+    category: BDD
+    description: Given precondition, When action, Then outcome
+    when_to_use: Behavior-driven tests, acceptance tests
+    example_structure:
+      "describe('Calculator', () => {\n  it('should add two numbers', () => {\n    // Given\n    const calc = new Calculator();\n    // When\n    const sum = calc.add(2, 3);\n    // Then\n\
+      \    expect(sum).toBe(5);\n  });\n});"
+    anti_pattern: No clear separation of phases
+    languages: all
+  - id: item_003
+    pattern: Test Double Types
+    category: Mocking
+    description: Dummy, Stub, Spy, Mock, Fake - know the difference
+    when_to_use: When isolating units from dependencies
+    example_structure: "Dummy: placeholder, never called
 
-    Stub: returns canned answers
+      Stub: returns canned answers
 
-    Spy: records calls, allows verification
+      Spy: records calls, allows verification
 
-    Mock: verifies expectations
+      Mock: verifies expectations
 
-    Fake: working implementation (in-memory DB)'
-  anti_pattern: Over-mocking (testing implementation not behavior)
-  languages: all
-- id: item_004
-  pattern: Factory Pattern
-  category: Data
-  description: Create test data with sensible defaults
-  when_to_use: Many tests need similar objects
-  example_structure: "const userFactory = (overrides = {}) => ({\n  id: 'user-123',\n  name: 'Test User',\n  email: 'test@example.com',\n  ...overrides,\n});"
-  anti_pattern: Duplicating test data setup in each test
-  languages: all
-- id: item_005
-  pattern: Builder Pattern
-  category: Data
-  description: Fluent API for complex test objects
-  when_to_use: Complex objects with many optional fields
-  example_structure: "const user = new UserBuilder()\n  .withName('John')\n  .withEmail('john@test.com')\n  .withRole('admin')\n  .build();"
-  anti_pattern: Long constructor calls with many nulls
-  languages: all
-- id: item_006
-  pattern: Test Isolation
-  category: Principle
-  description: Each test runs independently, no shared state
-  when_to_use: Always
-  example_structure: "beforeEach(() => {\n  db = createFreshDatabase();\n});\nafterEach(() => {\n  db.cleanup();\n});"
-  anti_pattern: Tests depending on order or shared state
-  languages: all
-- id: item_007
-  pattern: Single Assertion
-  category: Principle
-  description: One logical assertion per test (can be multiple expects)
-  when_to_use: Unit tests
-  example_structure: "it('should return user name', () => {\n  expect(user.getFullName()).toBe('John Doe');\n});"
-  anti_pattern: 10+ assertions in one test making failures unclear
-  languages: all
-- id: item_008
-  pattern: Parameterized Tests
-  category: Technique
-  description: Same test logic with different inputs
-  when_to_use: Testing edge cases, boundaries
-  example_structure: "test.each([\n  [1, 1, 2],\n  [0, 0, 0],\n  [-1, 1, 0],\n])('add(%i, %i) = %i', (a, b, expected) => {\n  expect(add(a, b)).toBe(expected);\n});"
-  anti_pattern: Copy-paste tests for different inputs
-  languages: all
-- id: item_009
-  pattern: Snapshot Testing
-  category: Technique
-  description: Compare output against stored snapshot
-  when_to_use: UI components, API responses
-  example_structure: expect(component).toMatchSnapshot();
-  anti_pattern: Snapshots for logic/business rules
-  languages: javascript
-- id: item_010
-  pattern: Test Pyramid
-  category: Strategy
-  description: Many unit, fewer integration, fewest E2E
-  when_to_use: Overall test strategy
-  example_structure: 'Unit: 70%
+      Fake: working implementation (in-memory DB)"
+    anti_pattern: Over-mocking (testing implementation not behavior)
+    languages: all
+  - id: item_004
+    pattern: Factory Pattern
+    category: Data
+    description: Create test data with sensible defaults
+    when_to_use: Many tests need similar objects
+    example_structure: "const userFactory = (overrides = {}) => ({\n  id: 'user-123',\n  name: 'Test User',\n  email: 'test@example.com',\n  ...overrides,\n});"
+    anti_pattern: Duplicating test data setup in each test
+    languages: all
+  - id: item_005
+    pattern: Builder Pattern
+    category: Data
+    description: Fluent API for complex test objects
+    when_to_use: Complex objects with many optional fields
+    example_structure: "const user = new UserBuilder()\n  .withName('John')\n  .withEmail('john@test.com')\n  .withRole('admin')\n  .build();"
+    anti_pattern: Long constructor calls with many nulls
+    languages: all
+  - id: item_006
+    pattern: Test Isolation
+    category: Principle
+    description: Each test runs independently, no shared state
+    when_to_use: Always
+    example_structure: "beforeEach(() => {\n  db = createFreshDatabase();\n});\nafterEach(() => {\n  db.cleanup();\n});"
+    anti_pattern: Tests depending on order or shared state
+    languages: all
+  - id: item_007
+    pattern: Single Assertion
+    category: Principle
+    description: One logical assertion per test (can be multiple expects)
+    when_to_use: Unit tests
+    example_structure: "it('should return user name', () => {\n  expect(user.getFullName()).toBe('John Doe');\n});"
+    anti_pattern: 10+ assertions in one test making failures unclear
+    languages: all
+  - id: item_008
+    pattern: Parameterized Tests
+    category: Technique
+    description: Same test logic with different inputs
+    when_to_use: Testing edge cases, boundaries
+    example_structure: "test.each([\n  [1, 1, 2],\n  [0, 0, 0],\n  [-1, 1, 0],\n])('add(%i, %i) = %i', (a, b, expected) => {\n  expect(add(a, b)).toBe(expected);\n});"
+    anti_pattern: Copy-paste tests for different inputs
+    languages: all
+  - id: item_009
+    pattern: Snapshot Testing
+    category: Technique
+    description: Compare output against stored snapshot
+    when_to_use: UI components, API responses
+    example_structure: expect(component).toMatchSnapshot();
+    anti_pattern: Snapshots for logic/business rules
+    languages: javascript
+  - id: item_010
+    pattern: Test Pyramid
+    category: Strategy
+    description: Many unit, fewer integration, fewest E2E
+    when_to_use: Overall test strategy
+    example_structure: "Unit: 70%
 
-    Integration: 20%
+      Integration: 20%
 
-    E2E: 10%'
-  anti_pattern: Inverted pyramid (too many E2E, few unit)
-  languages: all
-- id: item_011
-  pattern: Integration Test
-  category: Type
-  description: Test component interactions with real dependencies
-  when_to_use: API routes, DB queries, service orchestration
-  example_structure: "it('creates user in database', async () => {\n  const response = await request(app)\n    .post('/users')\n    .send({ name: 'Test' });\n  expect(response.status).toBe(201);\n  const\
-    \ user = await db.users.findOne({ name: 'Test' });\n  expect(user).toBeDefined();\n});"
-  anti_pattern: Mocking everything in integration tests
-  languages: all
-- id: item_012
-  pattern: Contract Testing
-  category: Type
-  description: Verify API contracts between services
-  when_to_use: Microservices, API consumers/providers
-  example_structure: Pact, Spring Cloud Contract
-  anti_pattern: Trusting API documentation alone
-  languages: all
-- id: item_013
-  pattern: Mutation Testing
-  category: Coverage
-  description: Inject bugs to verify tests catch them
-  when_to_use: High-confidence critical paths
-  example_structure: Stryker (JS), PIT (Java), mutmut (Python)
-  anti_pattern: 100% line coverage but weak assertions
-  languages: all
-- id: item_014
-  pattern: Flaky Test Fix
-  category: Debugging
-  description: Identify and fix non-deterministic tests
-  when_to_use: Tests that fail randomly
-  example_structure: '- Remove time dependencies
+      E2E: 10%"
+    anti_pattern: Inverted pyramid (too many E2E, few unit)
+    languages: all
+  - id: item_011
+    pattern: Integration Test
+    category: Type
+    description: Test component interactions with real dependencies
+    when_to_use: API routes, DB queries, service orchestration
+    example_structure:
+      "it('creates user in database', async () => {\n  const response = await request(app)\n    .post('/users')\n    .send({ name: 'Test' });\n  expect(response.status).toBe(201);\n  const\
+      \ user = await db.users.findOne({ name: 'Test' });\n  expect(user).toBeDefined();\n});"
+    anti_pattern: Mocking everything in integration tests
+    languages: all
+  - id: item_012
+    pattern: Contract Testing
+    category: Type
+    description: Verify API contracts between services
+    when_to_use: Microservices, API consumers/providers
+    example_structure: Pact, Spring Cloud Contract
+    anti_pattern: Trusting API documentation alone
+    languages: all
+  - id: item_013
+    pattern: Mutation Testing
+    category: Coverage
+    description: Inject bugs to verify tests catch them
+    when_to_use: High-confidence critical paths
+    example_structure: Stryker (JS), PIT (Java), mutmut (Python)
+    anti_pattern: 100% line coverage but weak assertions
+    languages: all
+  - id: item_014
+    pattern: Flaky Test Fix
+    category: Debugging
+    description: Identify and fix non-deterministic tests
+    when_to_use: Tests that fail randomly
+    example_structure: "- Remove time dependencies
 
-    - Don''t rely on order
+      - Don't rely on order
 
-    - Wait for async properly
+      - Wait for async properly
 
-    - Isolate external services'
-  anti_pattern: Retrying until pass, @Ignore annotation
-  languages: all
-- id: item_015
-  pattern: Test Naming
-  category: Convention
-  description: Descriptive names that document behavior
-  when_to_use: All tests
-  example_structure: '''should return 404 when user not found''
+      - Isolate external services"
+    anti_pattern: Retrying until pass, @Ignore annotation
+    languages: all
+  - id: item_015
+    pattern: Test Naming
+    category: Convention
+    description: Descriptive names that document behavior
+    when_to_use: All tests
+    example_structure: "'should return 404 when user not found'
 
-    ''throws ValidationError for empty email'''
-  anti_pattern: '''test1'', ''testAdd'', cryptic names'
-  languages: all
+      'throws ValidationError for empty email'"
+    anti_pattern: "'test1', 'testAdd', cryptic names"
+    languages: all