Add AI test generator, .env setup, prompt templates, and documentation updates

Author: kavitaj11

.env.example

@@ -0,0 +1 @@
+OPENAI_API_KEY=

.github/workflows/playwright.yml

@@ -19,6 +19,8 @@ jobs:
       run: npx playwright install --with-deps
     - name: Run Playwright tests
       run: npx playwright test
+    - name: Run Playwright Component Tests (CT)
+      run: npx playwright test -c playwright-ct.config.js
     - uses: actions/upload-artifact@v4
       if: ${{ !cancelled() }}
       with:

.gitignore

@@ -19,7 +19,8 @@ Thumbs.db
 
 # VS Code
 .vscode/
-
+*.db
+!testdata/*.csv
 # Misc
 *.swp
 *.swo
@@ -34,7 +35,4 @@ dist/
 # IDE
 .idea/
 
-# Ignore Excel/DB test data
-*.xlsx
-*.csv
-*.db
+

README-ai.md

@@ -0,0 +1,64 @@
+# AI Test Generator (OpenAI-powered)
+
+This module enables AI-driven Playwright test generation using OpenAI's API and prompt templates.
+
+## Features
+- Generates Playwright tests from prompt templates and config data
+- Supports CSV-driven test data, API endpoints, and DB config
+- Uses OpenAI API for intelligent test creation
+- Secure API key management via `.env`
+
+## Usage
+1. **Set up OpenAI API Key:**
+   - Copy `.env.example` to `.env` and add your OpenAI API key:
+     ```
+     OPENAI_API_KEY=your-openai-api-key-here
+     ```
+2. **Install dependencies:**
+   - Run:
+     ```
+     npm install
+     ```
+3. **Configure appConfig:**
+   - Edit `config/appConfig.js` to set paths for test data, API endpoints, and DB config.
+4. **Edit prompt templates:**
+   - Update or create prompt files in `prompts/` (e.g., `playwright_login_test_generation.txt`).
+5. **Run the generator:**
+   - Execute:
+     ```
+     node ai/generate_generic_tests_ai.js
+     ```
+   - The generated test will be saved to `tests/mab/AI_GeneratedTest.spec.js`.
+
+## Customization
+- Add new prompt templates for different test scenarios.
+- Update `ai/generate_generic_tests_ai.js` to use your desired prompt file.
+
+## Security
+- `.env` is gitignored by default.
+- Never commit your API key.
+
+## Troubleshooting
+- Ensure your OpenAI API key is valid and set in `.env`.
+- If you see `Missing credentials` errors, check your `.env` setup.
+- For OpenAI API errors, verify your network and API quota.
+
+## Example Prompt Template
+See `prompts/playwright_login_test_generation.txt` for a sample login test prompt.
+
+## License
+MIT
+
+**Experimental Stage:**
+This AI test generator is currently in an experimental phase. Features and workflows may change, and reliability is not guaranteed for production use. Feedback and contributions are welcome!
+
+## Future Enhancements Planned
+
+- Support for Playwright API and DB test generation
+- Multi-prompt scenario chaining
+- Improved error handling and reporting
+- Integration with CI/CD pipelines
+- Customizable output file locations
+- Enhanced prompt templating and variable injection
+- Support for other AI providers (Azure, Anthropic, etc.)
+- Automated test validation and coverage analysis

ai/generate_generic_tests_ai.js

@@ -0,0 +1,49 @@
+// Generic AI-powered Test Generator
+// Place this in ai/
+// Requires: npm install openai
+
+const fs = require('fs');
+const path = require('path');
+const { OpenAI } = require('openai');
+
+// Example input files
+
+const appConfig = require('../config/appConfig');
+const csvPath = path.join(__dirname, '..', appConfig.testDataPath);
+const apiPath = path.join(__dirname, '..', appConfig.apiEndpointsPath);
+const dbConfigPath = path.join(__dirname, '..', appConfig.dbConfigPath);
+
+const configData = JSON.stringify(appConfig, null, 2);
+const csvData = fs.existsSync(csvPath) ? fs.readFileSync(csvPath, 'utf8') : '';
+const apiData = fs.existsSync(apiPath) ? fs.readFileSync(apiPath, 'utf8') : '';
+const dbConfigData = fs.existsSync(dbConfigPath) ? fs.readFileSync(dbConfigPath, 'utf8') : '';
+
+const outputPath = path.join(__dirname, '../tests/mab/AI_GeneratedTest.spec.js');
+
+// ...existing code...
+// To generate login tests, use the login prompt file:
+const promptTemplatePath = path.join(__dirname, '../prompts/playwright_login_test_generation.txt');
+let prompt = fs.readFileSync(promptTemplatePath, 'utf8');
+prompt = prompt.replace('{{config}}', configData)
+               .replace('{{csv}}', csvData)
+               .replace('{{api}}', apiData)
+               .replace('{{db}}', dbConfigData);
+
+
+const openai = new OpenAI({
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+async function generateTest() {
+  const response = await openai.completions.create({
+    model: 'text-davinci-003',
+    prompt,
+    max_tokens: 1500,
+    temperature: 0.2,
+  });
+  const testCode = response.choices[0].text;
+  fs.writeFileSync(outputPath, testCode);
+  console.log('AI-generated test file:', outputPath);
+}
+
+generateTest();

config/appConfig.js

@@ -1,3 +1,6 @@
 module.exports = {
-    baseUrl: 'https://k11softwaresolutions.com'
+    baseUrl: 'https://k11softwaresolutions.com',
+    testDataPath: '../testdata/login_data.csv',
+    apiEndpointsPath: '../testdata/api_endpoints.json',
+    dbConfigPath: '../testdata/db_config.json'
 };

doc/ai-vs-user-representation.md

@@ -0,0 +1,43 @@
+# AI-Driven Testing vs Accurate User Representation
+
+## Balancing AI-Augmented Automation and Real User Flows
+
+AI-driven testing (such as AI-powered locators, auto-healing selectors, and smart test generation) is transforming how we approach test automation. However, maintaining accurate user representation—ensuring tests reflect real user behavior and business intent—is critical for meaningful quality assurance.
+
+---
+
+## How We Balance Both in K11TechLab
+
+### 1. AI-Augmented Features
+- **AI Locators:** Use AI to identify robust selectors, reducing flaky tests.
+- **Auto-Healing:** Automatically update selectors when UI changes, minimizing maintenance.
+- **Smart Test Generation:** Leverage AI to suggest test cases based on user flows and analytics.
+
+### 2. User-Centric Test Design
+- **Page Object Model (POM):** Abstracts UI for business-readable tests.
+- **Manual Review:** All AI-generated tests are reviewed for business logic and user intent.
+- **Realistic Data:** Use real or production-like data for test scenarios.
+- **Assertions:** Focus on user-visible outcomes, not just DOM changes.
+
+### 3. Hybrid Approach
+- **AI for Maintenance:** Use AI to keep tests stable and up-to-date.
+- **Human for Intent:** QA engineers ensure tests reflect real user journeys, edge cases, and business rules.
+- **Feedback Loop:** AI suggestions are validated and refined by human testers.
+
+---
+
+## Practical Example
+- AI locators identify elements for login form.
+- Test flow is designed to match real user login steps.
+- Assertions check for dashboard visibility, not just form submission.
+- If UI changes, auto-healing updates selectors, but test logic remains user-focused.
+
+---
+
+## Summary
+
+AI-driven testing accelerates automation and reduces maintenance, but human oversight is essential to ensure tests represent real user actions and business value. K11TechLab combines both for robust, meaningful quality engineering.
+
+---
+
+*This approach enables rapid, resilient automation while keeping user experience and business goals at the center of testing.*

doc/context-aware-testing-benefits.md

@@ -0,0 +1,54 @@
+# Context-Aware Testing with MCP and Playwright: Real-World Benefits
+
+## What Is Context-Aware Testing?
+Context-aware testing means your tests adapt to the application's state, user flows, and runtime conditions. By using a Model Context Protocol (MCP) and tools like XState with Playwright, you capture and leverage runtime metadata, making tests smarter and more resilient.
+
+---
+
+## Real-Life Advantages
+
+### 1. Robustness Against UI Changes
+- Tests use dynamic context and locator maps, so they are less brittle when UI changes.
+- Auto-healing selectors and context logs help quickly identify and fix broken tests.
+
+### 2. Better Coverage of User Journeys
+- State machines (XState) model real user flows, ensuring tests reflect business logic.
+- Context logs show which paths were exercised, helping QA teams spot gaps.
+
+### 3. Smarter Failure Analysis
+- When a test fails, context logs and saved reports show the exact state transitions and outcomes.
+- This makes debugging faster and more actionable.
+
+### 4. Data-Driven and Adaptive Testing
+- Tests can adapt based on runtime metadata (e.g., feature flags, user roles, app state).
+- This enables more realistic, production-like test scenarios.
+
+### 5. Automated Reporting and Traceability
+- Test results and context logs are saved as JSON artifacts for traceability.
+- Teams can review historical runs, analyze trends, and improve test reliability.
+
+---
+
+## Example: Login Flow
+- The MCP test models the login flow as a state machine.
+- It logs every state transition (e.g., start → enteringCredentials → loggingIn → dashboard/error).
+- If the login fails, the test checks for the error element and logs the outcome.
+- The result is saved in reports/mcp for audit and analysis.
+
+---
+
+## Why It Matters
+- **Faster Debugging:** Context logs pinpoint where and why a test failed.
+- **Resilience:** Tests adapt to app changes, reducing maintenance.
+- **Business Alignment:** State machines ensure tests match real user journeys.
+- **Traceability:** Saved reports provide evidence for compliance and quality audits.
+- **Continuous Improvement:** Teams can use context data to refine tests and coverage.
+
+---
+
+## Conclusion
+Context-aware testing with MCP and Playwright enables smarter, more reliable, and business-aligned automation. It helps teams deliver quality faster, with less maintenance and more actionable insights.
+
+---
+
+*Adopt context-aware testing to future-proof your QA and accelerate digital transformation!*

doc/context-aware-testing-roadmap.md

@@ -0,0 +1,53 @@
+# Context-Aware Testing Infrastructure: Roadmap
+
+## 1. Evaluate Current Test Infrastructure
+- Review existing Playwright and Cypress test suites for context-awareness.
+- Identify gaps: Are tests aware of app state, user flows, and runtime conditions?
+- Document current metadata capture (e.g., logs, screenshots, traces).
+
+## 2. Pilot MCP-Style Testing
+- Prototype Model Context Protocol (MCP) testing using Playwright or Cypress.
+- Integrate XState for state machine modeling of user flows and app states.
+- Run pilot tests to validate context-driven scenarios.
+
+## 3. Build Minimal Context Engine
+- Develop a lightweight engine to capture runtime metadata:
+  - App state (XState)
+  - User actions
+  - Network requests
+  - UI changes
+- Store metadata alongside test artifacts for analysis.
+
+## 4. Integrate AI Decision Logic / Rule Engines
+- Add AI or rule-based logic to:
+  - Select relevant tests based on app state
+  - Adapt test flows dynamically
+  - Flag tests for review based on context changes
+- Use open-source AI libraries or custom rule engines.
+
+## 5. Iterate & Measure
+- Track test relevance: Are tests covering meaningful user flows?
+- Monitor reliability: Are flaky tests reduced?
+- Measure performance: Is test execution faster and more targeted?
+- Refine context engine and AI logic based on feedback.
+
+---
+
+## Example Workflow
+1. Test starts, context engine captures app state.
+2. XState models user journey; AI logic selects relevant tests.
+3. Tests adapt to runtime conditions (e.g., feature flags, user roles).
+4. Metadata is stored for traceability and analysis.
+5. Results are reviewed, improvements tracked.
+
+---
+
+## Benefits
+- Smarter, more resilient tests
+- Better coverage of real user scenarios
+- Reduced maintenance and flakiness
+- Actionable insights for QA and dev teams
+
+---
+
+*This roadmap enables context-aware, AI-augmented testing for modern JavaScript apps using Playwright or Cypress.*