create-byan-agent 2.18.0 → 2.19.0

package/install/templates/_byan/workflow/simple/testarch/teach-me-testing/steps-e/step-e-01-assess-workflow.md

@@ -0,0 +1,141 @@
+---
+name: 'step-e-01-assess-workflow'
+description: 'Assess what needs to be edited in the teaching workflow'
+
+nextStepFile: './step-e-02-apply-edits.md'
+workflowPath: '../'
+advancedElicitationTask: '{project-root}/_byan/workflow/simple/advanced-elicitation/workflow.xml'
+partyModeWorkflow: '{project-root}/_byan/workflow/simple/party-mode/workflow.md'
+---
+
+# Edit Step 1: Assess What to Edit
+
+## STEP GOAL:
+
+To identify what the user wants to edit in the teach-me-testing workflow and gather requirements for the modifications.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read complete step file before action
+- ✅ SPEAK OUTPUT In {communication_language}
+
+### Role Reinforcement:
+
+- ✅ You are a workflow architect helping with modifications
+- ✅ Collaborative dialogue for understanding edit needs
+
+### Step-Specific Rules:
+
+- 🎯 Focus on understanding what to edit
+- 🚫 FORBIDDEN to make edits yet
+- 💬 Ask questions to clarify requirements
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Understand edit requirements
+- 💾 Document what needs editing
+- 📖 Prepare for edits in next step
+
+## MANDATORY SEQUENCE
+
+### 1. Welcome to Edit Mode
+
+"**Edit Mode: Teach Me Testing Workflow**
+
+What would you like to edit?
+
+**Common edits:**
+
+- Update session content (new concepts, updated examples)
+- Modify quiz questions
+- Add/remove knowledge fragments from session 7
+- Update TEA resource references
+- Change session durations or structure
+- Update role-based examples
+
+**Tell me what you'd like to change.**"
+
+### 2. Gather Edit Requirements
+
+Ask targeted questions based on their response:
+
+**If editing session content:**
+
+- Which session? (1-7)
+- What specific content needs updating?
+- Why the change? (outdated, incorrect, needs improvement)
+
+**If editing quiz questions:**
+
+- Which session's quiz?
+- Which question(s)?
+- What's wrong with current questions?
+
+**If editing session 7 fragments:**
+
+- Add new fragment category?
+- Update existing fragment references?
+- Change organization?
+
+**If editing templates:**
+
+- Progress template?
+- Session notes template?
+- Certificate template?
+- What fields need changing?
+
+**If editing data files:**
+
+- Curriculum structure?
+- Role customizations?
+- Resource mappings?
+
+### 3. Load Current Content
+
+Based on what they want to edit, load the relevant files:
+
+- Session step files (steps-c/step-04-session-\*.md)
+- Templates (`templates/*.md` or `*.yaml`)
+- Data files (data/\*.yaml)
+
+Show user the current content.
+
+### 4. Document Edit Plan
+
+"**Edit Plan:**
+
+**Target Files:**
+
+- {list files to be modified}
+
+**Changes Required:**
+
+- {list specific changes}
+
+**Reason:**
+
+- {why these edits are needed}
+
+Ready to proceed with edits?"
+
+### 5. Menu
+
+Display: **Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Apply Edits
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}, redisplay menu
+- IF P: Execute {partyModeWorkflow}, redisplay menu
+- IF C: Load, read entire file, then execute {nextStepFile}
+- IF Any other: help user, redisplay menu
+
+---
+
+## 🚨 SUCCESS METRICS
+
+✅ Edit requirements clearly understood, target files identified, edit plan documented, user approves plan.
+
+**Master Rule:** Understand before editing. Get clear requirements first.

package/install/templates/_byan/workflow/simple/testarch/test-design/instructions.md

@@ -0,0 +1,52 @@
+<!-- Powered by BMAD-CORE™ -->
+
+# Test Design and Risk Assessment
+
+**Workflow ID**: `_byan/connaissance/testarch/test-design`
+**Version**: 5.0 (Step-File Architecture)
+
+---
+
+## Overview
+
+Plans comprehensive test coverage strategy with risk assessment, priority classification, and execution ordering. This workflow operates in **two modes**:
+
+- **System-Level Mode (Phase 3)**: Testability review of architecture before solutioning gate check
+- **Epic-Level Mode (Phase 4)**: Per-epic test planning with risk assessment
+
+The workflow auto-detects which mode to use based on project phase and user intent.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This workflow uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self-contained instruction file
+- **Just-In-Time Loading**: Only the current step file is in memory
+- **Sequential Enforcement**: Execute steps in order without skipping
+- **State Tracking**: Write outputs only when instructed, then proceed
+
+### Step Processing Rules (Non-Negotiable)
+
+1. **READ COMPLETELY**: Read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order
+3. **WAIT FOR INPUT**: Halt when user input is required
+4. **LOAD NEXT**: Only load the next step file when directed
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+From `workflow.yaml`, resolve:
+
+- `config_source`, `output_folder`, `user_name`, `communication_language`, `document_output_language`, `date`
+
+### 2. First Step
+
+Load, read completely, and execute:
+`{project-root}/_byan/workflow/simple/testarch/test-design/steps-c/step-01-detect-mode.md`

package/install/templates/_byan/workflow/simple/testarch/test-design/steps-c/step-02-load-context.md

@@ -0,0 +1,127 @@
+---
+name: 'step-02-load-context'
+description: 'Load documents, configuration, and knowledge fragments for the chosen mode'
+nextStepFile: './step-03-risk-and-testability.md'
+knowledgeIndex: '{project-root}/_byan/connaissance/testarch/tea-index.csv'
+---
+
+# Step 2: Load Context & Knowledge Base
+
+## STEP GOAL
+
+Load the required documents, config flags, and knowledge fragments needed to produce accurate test design outputs.
+
+## MANDATORY EXECUTION RULES
+
+- 📖 Read the entire step file before acting
+- ✅ Speak in `{communication_language}`
+- 🎯 Only load artifacts required for the selected mode
+
+---
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Follow the MANDATORY SEQUENCE exactly
+- 💾 Record outputs before proceeding
+- 📖 Load the next step only when instructed
+
+## CONTEXT BOUNDARIES:
+
+- Available context: config, loaded artifacts, and knowledge fragments
+- Focus: this step's goal only
+- Limits: do not execute future steps
+- Dependencies: prior steps' outputs (if any)
+
+## MANDATORY SEQUENCE
+
+**CRITICAL:** Follow this sequence exactly. Do not skip, reorder, or improvise.
+
+## 1. Load Configuration
+
+From `{config_source}`:
+
+- Read `tea_use_playwright_utils`
+- Note `output_folder`
+
+---
+
+## 2. Load Project Artifacts (Mode-Specific)
+
+### System-Level Mode (Phase 3)
+
+Load:
+
+- PRD (FRs + NFRs)
+- ADRs or architecture decisions
+- Architecture / tech-spec document
+- Epics (for scope)
+
+Extract:
+
+- Tech stack & dependencies
+- Integration points
+- NFRs (performance, security, reliability, compliance)
+
+### Epic-Level Mode (Phase 4)
+
+Load:
+
+- Epic and story docs with acceptance criteria
+- PRD (if available)
+- Architecture / tech-spec (if available)
+- Prior system-level test-design outputs (if available)
+
+Extract:
+
+- Testable requirements
+- Integration points
+- Known coverage gaps
+
+---
+
+## 3. Analyze Existing Test Coverage (Epic-Level)
+
+If epic-level:
+
+- Scan the repository for existing tests (search for `tests/`, `spec`, `e2e`, `api` folders)
+- Identify coverage gaps and flaky areas
+- Note existing fixture and test patterns
+
+---
+
+## 4. Load Knowledge Base Fragments
+
+Use `{knowledgeIndex}` to select and load only relevant fragments.
+
+### System-Level Mode (Required)
+
+- `adr-quality-readiness-checklist.md`
+- `test-levels-framework.md`
+- `risk-governance.md`
+- `test-quality.md`
+
+### Epic-Level Mode (Required)
+
+- `risk-governance.md`
+- `probability-impact.md`
+- `test-levels-framework.md`
+- `test-priorities-matrix.md`
+
+---
+
+## 5. Confirm Loaded Inputs
+
+Summarize what was loaded and confirm with the user if anything is missing.
+
+Load next step: `{nextStepFile}`
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS:
+
+### ✅ SUCCESS:
+
+- Step completed in full with required outputs
+
+### ❌ SYSTEM FAILURE:
+
+- Skipped sequence steps or missing outputs
+  **Master Rule:** Skipping steps is FORBIDDEN.

package/install/templates/_byan/workflow/simple/testarch/test-design/test-design-qa-template.md

@@ -0,0 +1,296 @@
+# Test Design for QA: {Feature Name}
+
+**Purpose:** Test execution recipe for QA team. Defines what to test, how to test it, and what QA needs from other teams.
+
+**Date:** {date}
+**Author:** {author}
+**Status:** Draft
+**Project:** {project_name}
+
+**Related:** See Architecture doc (test-design-architecture.md) for testability concerns and architectural blockers.
+
+---
+
+## Executive Summary
+
+**Scope:** {Brief description of testing scope}
+
+**Risk Summary:**
+
+- Total Risks: {N} ({X} high-priority score ≥6, {Y} medium, {Z} low)
+- Critical Categories: {Categories with most high-priority risks}
+
+**Coverage Summary:**
+
+- P0 tests: ~{N} (critical paths, security)
+- P1 tests: ~{N} (important features, integration)
+- P2 tests: ~{N} (edge cases, regression)
+- P3 tests: ~{N} (exploratory, benchmarks)
+- **Total**: ~{N} tests (~{X}-{Y} weeks with 1 QA)
+
+---
+
+## Dependencies & Test Blockers
+
+**CRITICAL:** QA cannot proceed without these items from other teams.
+
+### Backend/Architecture Dependencies (Sprint 0)
+
+**Source:** See Architecture doc "Quick Guide" for detailed mitigation plans
+
+1. **{Dependency 1}** - {Team} - {Timeline}
+   - {What QA needs}
+   - {Why it blocks testing}
+
+2. **{Dependency 2}** - {Team} - {Timeline}
+   - {What QA needs}
+   - {Why it blocks testing}
+
+### QA Infrastructure Setup (Sprint 0)
+
+1. **Test Data Factories** - QA
+   - {Entity} factory with faker-based randomization
+   - Auto-cleanup fixtures for parallel safety
+
+2. **Test Environments** - QA
+   - Local: {Setup details}
+   - CI/CD: {Setup details}
+   - Staging: {Setup details}
+
+**Example factory pattern:**
+
+```typescript
+import { test } from '@seontechnologies/playwright-utils/api-request/fixtures';
+import { expect } from '@playwright/test';
+import { faker } from '@faker-js/faker';
+
+test('example test @p0', async ({ apiRequest }) => {
+  const testData = {
+    id: `test-${faker.string.uuid()}`,
+    email: faker.internet.email(),
+  };
+
+  const { status } = await apiRequest({
+    method: 'POST',
+    path: '/api/resource',
+    body: testData,
+  });
+
+  expect(status).toBe(201);
+});
+```
+
+---
+
+## Risk Assessment
+
+**Note:** Full risk details in Architecture doc. This section summarizes risks relevant to QA test planning.
+
+### High-Priority Risks (Score ≥6)
+
+| Risk ID    | Category | Description         | Score       | QA Test Coverage             |
+| ---------- | -------- | ------------------- | ----------- | ---------------------------- |
+| **{R-ID}** | {CAT}    | {Brief description} | **{Score}** | {How QA validates this risk} |
+
+### Medium/Low-Priority Risks
+
+| Risk ID | Category | Description         | Score   | QA Test Coverage             |
+| ------- | -------- | ------------------- | ------- | ---------------------------- |
+| {R-ID}  | {CAT}    | {Brief description} | {Score} | {How QA validates this risk} |
+
+---
+
+## Test Coverage Plan
+
+**IMPORTANT:** P0/P1/P2/P3 = **priority and risk level** (what to focus on if time-constrained), NOT execution timing. See "Execution Strategy" for when tests run.
+
+### P0 (Critical)
+
+**Criteria:** Blocks core functionality + High risk (≥6) + No workaround + Affects majority of users
+
+| Test ID    | Requirement   | Test Level | Risk Link | Notes   |
+| ---------- | ------------- | ---------- | --------- | ------- |
+| **P0-001** | {Requirement} | {Level}    | {R-ID}    | {Notes} |
+| **P0-002** | {Requirement} | {Level}    | {R-ID}    | {Notes} |
+
+**Total P0:** ~{N} tests
+
+---
+
+### P1 (High)
+
+**Criteria:** Important features + Medium risk (3-4) + Common workflows + Workaround exists but difficult
+
+| Test ID    | Requirement   | Test Level | Risk Link | Notes   |
+| ---------- | ------------- | ---------- | --------- | ------- |
+| **P1-001** | {Requirement} | {Level}    | {R-ID}    | {Notes} |
+| **P1-002** | {Requirement} | {Level}    | {R-ID}    | {Notes} |
+
+**Total P1:** ~{N} tests
+
+---
+
+### P2 (Medium)
+
+**Criteria:** Secondary features + Low risk (1-2) + Edge cases + Regression prevention
+
+| Test ID    | Requirement   | Test Level | Risk Link | Notes   |
+| ---------- | ------------- | ---------- | --------- | ------- |
+| **P2-001** | {Requirement} | {Level}    | {R-ID}    | {Notes} |
+
+**Total P2:** ~{N} tests
+
+---
+
+### P3 (Low)
+
+**Criteria:** Nice-to-have + Exploratory + Performance benchmarks + Documentation validation
+
+| Test ID    | Requirement   | Test Level | Notes   |
+| ---------- | ------------- | ---------- | ------- |
+| **P3-001** | {Requirement} | {Level}    | {Notes} |
+
+**Total P3:** ~{N} tests
+
+---
+
+## Execution Strategy
+
+**Philosophy:** Run everything in PRs unless there's significant infrastructure overhead. Playwright with parallelization is extremely fast (100s of tests in ~10-15 min).
+
+**Organized by TOOL TYPE:**
+
+### Every PR: Playwright Tests (~10-15 min)
+
+**All functional tests** (from any priority level):
+
+- All E2E, API, integration, unit tests using Playwright
+- Parallelized across {N} shards
+- Total: ~{N} Playwright tests (includes P0, P1, P2, P3)
+
+**Why run in PRs:** Fast feedback, no expensive infrastructure
+
+### Nightly: k6 Performance Tests (~30-60 min)
+
+**All performance tests** (from any priority level):
+
+- Load, stress, spike, endurance tests
+- Total: ~{N} k6 tests (may include P0, P1, P2)
+
+**Why defer to nightly:** Expensive infrastructure (k6 Cloud), long-running (10-40 min per test)
+
+### Weekly: Chaos & Long-Running (~hours)
+
+**Special infrastructure tests** (from any priority level):
+
+- Multi-region failover (requires AWS Fault Injection Simulator)
+- Disaster recovery (backup restore, 4+ hours)
+- Endurance tests (4+ hours runtime)
+
+**Why defer to weekly:** Very expensive infrastructure, very long-running, infrequent validation sufficient
+
+**Manual tests** (excluded from automation):
+
+- DevOps validation (deployment, monitoring)
+- Finance validation (cost alerts)
+- Documentation validation
+
+---
+
+## QA Effort Estimate
+
+**QA test development effort only** (excludes DevOps, Backend, Data Eng, Finance work):
+
+| Priority  | Count | Effort Range       | Notes                                             |
+| --------- | ----- | ------------------ | ------------------------------------------------- |
+| P0        | ~{N}  | ~{X}-{Y} weeks     | Complex setup (security, performance, multi-step) |
+| P1        | ~{N}  | ~{X}-{Y} weeks     | Standard coverage (integration, API tests)        |
+| P2        | ~{N}  | ~{X}-{Y} days      | Edge cases, simple validation                     |
+| P3        | ~{N}  | ~{X}-{Y} days      | Exploratory, benchmarks                           |
+| **Total** | ~{N}  | **~{X}-{Y} weeks** | **1 QA engineer, full-time**                      |
+
+**Assumptions:**
+
+- Includes test design, implementation, debugging, CI integration
+- Excludes ongoing maintenance (~10% effort)
+- Assumes test infrastructure (factories, fixtures) ready
+
+**Dependencies from other teams:**
+
+- See "Dependencies & Test Blockers" section for what QA needs from Backend, DevOps, Data Eng
+
+---
+
+## Appendix A: Code Examples & Tagging
+
+**Playwright Tags for Selective Execution:**
+
+```typescript
+import { test } from '@seontechnologies/playwright-utils/api-request/fixtures';
+import { expect } from '@playwright/test';
+
+// P0 critical test
+test('@P0 @API @Security unauthenticated request returns 401', async ({ apiRequest }) => {
+  const { status, body } = await apiRequest({
+    method: 'POST',
+    path: '/api/endpoint',
+    body: { data: 'test' },
+    skipAuth: true,
+  });
+
+  expect(status).toBe(401);
+  expect(body.error).toContain('unauthorized');
+});
+
+// P1 integration test
+test('@P1 @Integration data syncs correctly', async ({ apiRequest }) => {
+  // Seed data
+  await apiRequest({
+    method: 'POST',
+    path: '/api/seed',
+    body: {
+      /* test data */
+    },
+  });
+
+  // Validate
+  const { status, body } = await apiRequest({
+    method: 'GET',
+    path: '/api/resource',
+  });
+
+  expect(status).toBe(200);
+  expect(body).toHaveProperty('data');
+});
+```
+
+**Run specific tags:**
+
+```bash
+# Run only P0 tests
+npx playwright test --grep @P0
+
+# Run P0 + P1 tests
+npx playwright test --grep "@P0|@P1"
+
+# Run only security tests
+npx playwright test --grep @Security
+
+# Run all Playwright tests in PR (default)
+npx playwright test
+```
+
+---
+
+## Appendix B: Knowledge Base References
+
+- **Risk Governance**: `risk-governance.md` - Risk scoring methodology
+- **Test Priorities Matrix**: `test-priorities-matrix.md` - P0-P3 criteria
+- **Test Levels Framework**: `test-levels-framework.md` - E2E vs API vs Unit selection
+- **Test Quality**: `test-quality.md` - Definition of Done (no hard waits, <300 lines, <1.5 min)
+
+---
+
+**Generated by:** BMad TEA Agent
+**Workflow:** `_byan/connaissance/testarch/test-design`
+**Version:** 4.0 (BMad v6)