agents-cli-automation 1.0.18 → 1.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-cli-automation",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "Agents CLI",
   "type": "module",
   "bin": {

package/src/commands/init.js

@@ -32,7 +32,8 @@ export default async function initCommand() {
           "TypeScript (Recommended - Latest & Type Safe)",
           "JavaScript (ES Modules)",
           "Java (Maven + JUnit)",
-          "C# (NUnit + .NET)"
+          "C# (NUnit + .NET)",
+          "API+DB+UI Full Stack (All-in-One Template)"
         ]
       }
     ]);
@@ -52,6 +53,9 @@ export default async function initCommand() {
     } else if (language.includes("C#")) {
       templateFile = "playwright-agent-csharp.md";
       templateName = "C#";
+    }else if (language.includes("API+DB+UI")) {
+      templateFile = "playwright-agent-api-db-ui.md";
+      templateName = "API+DB+UI Full Stack";
     }
 
     const templatePath = path.resolve(__dirname, `../templates/${templateFile}`);

package/src/templates/playwright-agent-api-db-ui.md

@@ -0,0 +1,404 @@
+# Playwright Test Automation Framework
+
+**Name:** Playwright Agent - TypeScript Test Automation Framework
+
+**Description:** A comprehensive test automation framework built with Playwright and TypeScript for testing UI, API, and database layers. This framework demonstrates best practices for organizing test code, managing test data, implementing step definitions with Playwright BDD, and maintaining database state during testing. It provides examples of test-harness clients for database access, API calls, correlation tracking, and fixture management.
+
+---
+
+## Folder Structure
+
+```
+automation-framework/
+├─ package.json
+├─ tsconfig.json
+├─ playwright.config.ts
+├─ .env
+│
+├─ configs/
+│   ├─ projects/
+│   │   ├─ ui.project.ts
+│   │   ├─ api.project.ts
+│   │   ├─ db.project.ts
+│   │   └─ integrated.project.ts
+│   ├─ environments/
+│   └─ global-setup.ts
+│
+├─ scripts/
+│   ├─ seed-db.ts
+│   ├─ reset-db.ts
+│   └─ run-wrapper.ts
+│
+├─ src/
+│   ├─ core/
+│   │   ├─ test-harness/
+│   │   │   ├─ dbClient.ts
+│   │   │   └─ wrapperClient.ts
+│   │   ├─ fixtures/
+│   │   │   └─ context.fixture.ts
+│   │   └─ utils/
+│   │       ├─ logger.ts
+│   │       └─ correlation.ts
+│   │
+│   ├─ modules/
+│   │   ├─ scheduling-group/
+│   │   │   ├─ features/
+│   │   │   │   └─ create-scheduling-group.feature
+│   │   │   ├─ steps/
+│   │   │   │   └─ createSchedulingGroup.steps.ts
+│   │   │   ├─ read-models/
+│   │   │   │   └─ schedule.read.ts
+│   │   │   ├─ queries/
+│   │   │   │   └─ schedule.mutations.ts
+│   │   │   ├─ contracts/
+│   │   │   │   └─ schedule.wrapper.contract.ts
+│   │   │   └─ test-data/
+│   │   │       └─ schedule.seed.ts
+│   │   └─ <future-module>/
+│   │
+│   └─ shared/
+│       ├─ constants/
+│       ├─ types/
+│       └─ data-factory/
+│
+├─ reports/
+└─ README.md
+```
+
+## Environment Configuration
+
+### .env
+
+```bash
+# Database
+DB_HOST=localhost
+DB_PORT=1433
+DB_USER=sa
+DB_PASSWORD=YourStrong@Passw0rd
+DB_NAME=AutomationTestDB
+
+# Wrapper / API
+WRAPPER_URL=http://localhost:4000/test-wrapper
+
+# Test Config
+NODE_ENV=test
+```
+
+## Core Components
+
+### DB Client – `core/test-harness/dbClient.ts`
+
+```typescript
+import { ConnectionPool } from "mssql";
+import dotenv from "dotenv";
+dotenv.config();
+
+const pool = new ConnectionPool({
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+  server: process.env.DB_HOST,
+  database: process.env.DB_NAME,
+  options: { encrypt: true, trustServerCertificate: true }
+});
+
+export const dbClient = {
+  query: async (query: string, params?: Record<string, any>) => {
+    const connection = await pool.connect();
+    const request = connection.request();
+    if (params) {
+      for (const key in params) {
+        request.input(key, params[key]);
+      }
+    }
+    const result = await request.query(query);
+    return result.recordset;
+  }
+};
+```
+
+### Wrapper Client / API Layer – `core/test-harness/wrapperClient.ts`
+
+```typescript
+import axios from "axios";
+import { utils } from "../utils/correlation";
+
+export const wrapperClient = {
+  createSchedulingGroup: async (payload: any, user: any) => {
+    const correlationId = utils.getCorrelationId();
+
+    const headers = {
+      "x-correlation-id": correlationId,
+      "x-test-user-id": user.id
+    };
+
+    utils.log("Calling wrapper API", { payload, user });
+
+    const response = await axios.post(
+      `${process.env.WRAPPER_URL}/scheduling-groups`,
+      payload,
+      { headers }
+    );
+
+    utils.log("Wrapper API response", response.data);
+
+    return { ...response.data, correlationId };
+  }
+};
+```
+
+### Utilities – `core/utils/correlation.ts`
+
+```typescript
+import { v4 as uuidv4 } from "uuid";
+
+export const utils = {
+  getCorrelationId: (): string => uuidv4(),
+
+  normalizeTimestamps: (record: any) => {
+    if (record.createdAt) record.createdAt = "<timestamp>";
+    if (record.updatedAt) record.updatedAt = "<timestamp>";
+    return record;
+  },
+
+  log: (message: string, data?: any) => {
+    console.log(`[${new Date().toISOString()}] ${message}`, data || "");
+  }
+};
+```
+
+### Fixtures – `core/fixtures/context.fixture.ts`
+
+```typescript
+export const contextProvider = {
+  getCurrentUser: async () => {
+    return { id: "default-system-admin", role: "System Admin" };
+  },
+
+  createTestContext: () => {
+    return {
+      user: null,
+      payload: null,
+      response: null,
+      correlationId: null
+    };
+  }
+};
+```
+
+## Test Data & Database
+
+### Test Data Builder – `modules/scheduling-group/test-data/schedule.seed.ts`
+
+```typescript
+export const schedulingGroupBuilder = {
+  createValid: () => ({
+    name: `MorningNews_${Date.now()}`,
+    areaId: 101,
+    allocationsMenu: true,
+    notes: "Used for weekday planning",
+    teams: [201, 202]
+  })
+};
+```
+
+### Read-Models – `modules/scheduling-group/read-models/schedule.read.ts`
+
+```typescript
+import { dbClient } from "../../core/test-harness/dbClient";
+
+export const schedulingGroupRead = {
+  getByName: async (name: string) => {
+    const result = await dbClient.query(`SELECT * FROM SchedulingGroup WHERE Name = @name`, { name });
+    return result[0] || null;
+  },
+
+  getTeamsByGroupId: async (groupId: number) => {
+    return dbClient.query(`SELECT * FROM SchedulingGroupTeam WHERE SchedulingGroupId = @groupId`, { groupId });
+  },
+
+  getHistoryByGroupId: async (groupId: number) => {
+    return dbClient.query(
+      `SELECT * FROM SchedulingGroupHistory WHERE SchedulingGroupId = @groupId ORDER BY LastAmendedDate DESC`,
+      { groupId }
+    );
+  }
+};
+```
+
+### DB Stub / Invariants – `modules/scheduling-group/queries/schedule.mutations.ts`
+
+```typescript
+import { dbClient } from "../../core/test-harness/dbClient";
+
+export const schedulingGroupMutations = {
+  createSchedulingGroupStub: async (payload: any, userId: string) => {
+    const result = await dbClient.query(
+      `INSERT INTO SchedulingGroup (Name, AreaId, AllocationsMenu, Notes, LastAmendedBy, LastAmendedDate)
+       VALUES (@name, @areaId, @allocationsMenu, @notes, @userId, GETDATE());
+       SELECT SCOPE_IDENTITY() AS Id;`,
+      {
+        name: payload.name,
+        areaId: payload.areaId,
+        allocationsMenu: payload.allocationsMenu,
+        notes: payload.notes,
+        userId
+      }
+    );
+
+    const groupId = result[0].Id;
+
+    for (const teamId of payload.teams) {
+      await dbClient.query(
+        `INSERT INTO SchedulingGroupTeam (SchedulingGroupId, TeamId) VALUES (@groupId, @teamId)`,
+        { groupId, teamId }
+      );
+    }
+
+    await dbClient.query(
+      `INSERT INTO SchedulingGroupHistory (SchedulingGroupId, Name, AreaId, AllocationsMenu, Notes, LastAmendedBy, LastAmendedDate)
+       VALUES (@groupId, @name, @areaId, @allocationsMenu, @notes, @userId, GETDATE())`,
+      {
+        groupId,
+        name: payload.name,
+        areaId: payload.areaId,
+        allocationsMenu: payload.allocationsMenu,
+        notes: payload.notes,
+        userId
+      }
+    );
+
+    return groupId;
+  }
+};
+```
+
+## Test Implementation
+
+### Step Definitions – `modules/scheduling-group/steps/createSchedulingGroup.steps.ts`
+
+```typescript
+import { Given, When, Then } from "@cucumber/cucumber";
+import { wrapperClient } from "../../core/test-harness/wrapperClient";
+import { schedulingGroupMutations } from "../queries/schedule.mutations";
+import { schedulingGroupRead } from "../read-models/schedule.read";
+import { schedulingGroupBuilder } from "../test-data/schedule.seed";
+import { contextProvider } from "../../core/fixtures/context.fixture";
+import { utils } from "../../core/utils/correlation";
+import { expect } from "@playwright/test";
+
+Given("an Area Admin user is available", async function () {
+  this.context = contextProvider.createTestContext();
+  this.context.user = await contextProvider.getCurrentUser();
+});
+
+Given("a valid Scheduling Group payload is prepared", async function () {
+  this.context.payload = schedulingGroupBuilder.createValid();
+  utils.log("Payload prepared", this.context.payload);
+});
+
+When("the user creates the Scheduling Group via DB stub", async function () {
+  this.context.groupId = await schedulingGroupMutations.createSchedulingGroupStub(
+    this.context.payload,
+    this.context.user.id
+  );
+});
+
+Then("the Scheduling Group should exist in the database with correct invariants", async function () {
+  const record = await schedulingGroupRead.getByName(this.context.payload.name);
+  const normalized = utils.normalizeTimestamps(record);
+
+  expect(normalized).not.toBeNull();
+  expect(normalized.areaId).toBe(this.context.payload.areaId);
+  expect(normalized.allocationsMenu).toBe(this.context.payload.allocationsMenu);
+  expect(normalized.notes).toBe(this.context.payload.notes);
+
+  const teams = await schedulingGroupRead.getTeamsByGroupId(this.context.groupId);
+  expect(teams.map(t => t.TeamId)).toEqual(this.context.payload.teams);
+
+  const history = await schedulingGroupRead.getHistoryByGroupId(this.context.groupId);
+  expect(history.length).toBeGreaterThan(0);
+  expect(history[0].LastAmendedBy).toBe(this.context.user.id);
+});
+```
+
+### Feature File – `modules/scheduling-group/features/create-scheduling-group.feature`
+
+```gherkin
+Feature: Create Scheduling Group
+
+  Scenario: Area Admin creates a new Scheduling Group
+    Given an Area Admin user is available
+    And a valid Scheduling Group payload is prepared
+    When the user creates the Scheduling Group via DB stub
+    Then the Scheduling Group should exist in the database with correct invariants
+```
+
+## Database Scripts
+
+### Seed Script – `scripts/seed-db.ts`
+
+```typescript
+import { dbClient } from "../src/core/test-harness/dbClient";
+
+async function seed() {
+  await dbClient.query(`INSERT INTO Area(Id, Name) VALUES (101, 'London')`);
+  await dbClient.query(`
+    INSERT INTO SchedulingTeam(Id, Name, AreaId) 
+    VALUES (201,'TeamA',101), (202,'TeamB',101)
+  `);
+  console.log("DB seeded successfully");
+}
+
+seed();
+```
+
+### Reset Script – `scripts/reset-db.ts`
+
+```typescript
+import { dbClient } from "../src/core/test-harness/dbClient";
+
+async function reset() {
+  await dbClient.query(`TRUNCATE TABLE SchedulingGroup`);
+  await dbClient.query(`TRUNCATE TABLE SchedulingGroupTeam`);
+  await dbClient.query(`TRUNCATE TABLE SchedulingGroupHistory`);
+  console.log("DB reset successfully");
+}
+
+reset();
+```
+
+## Package Configuration
+
+### package.json Scripts
+
+```json
+{
+  "scripts": {
+    "seed-db": "ts-node scripts/seed-db.ts",
+    "reset-db": "ts-node scripts/reset-db.ts",
+    "apitest": "playwright test --project=api",
+    "uitest": "playwright test --project=ui",
+    "test": "playwright test --project=integrated"
+  }
+}
+```
+
+## Running Tests
+
+1. **Reset the database:**
+   ```bash
+   npm run reset-db
+   ```
+
+2. **Seed the database:**
+   ```bash
+   npm run seed-db
+   ```
+
+3. **Run API/DB tests:**
+   ```bash
+   npm run apitest
+   ```
+
+4. **View reports and logs:**
+   Check the `reports/` directory for HTML reports and detailed logs.