#Extend and maintain Test Runner

import { defineNode, z } from '@midscene/test';
import {
  defineProjectSetup,
  defineTestProject,
} from '@midscene/test/config';
import { createMidsceneNodes } from '@midscene/test/midscene';
import { PlaywrightAgent } from '@midscene/web/playwright';
import { chromium, type Browser, type Page } from 'playwright';

interface ProjectContext {
  browser: Browser;
  page: Page;
  agent?: PlaywrightAgent;
}

const geoInputSchema = z.strictObject({
  latitude: z.number().describe('Latitude of the mocked location.'),
  longitude: z.number().describe('Longitude of the mocked location.'),
});

// 1. Register a custom Node that mocks a GPS location
const mockLocation = defineNode<
  typeof geoInputSchema,
  unknown,
  ProjectContext
>({
  name: 'browser.mockLocation',
  title: 'Mock location',
  description: "Mock the browser's GPS location.",
  inputSchema: geoInputSchema,
  async execute({ input, context }) {
    const browserContext = context.page.context();
    // Grant geolocation permission and set the coordinates
    await browserContext.grantPermissions(['geolocation']);
    await browserContext.setGeolocation({
      latitude: input.latitude,
      longitude: input.longitude,
    });
  },
});

// Integrate Midscene's built-in AI Nodes, such as aiAct and aiAssert
const midsceneNodes = createMidsceneNodes<ProjectContext>({
  getAgent: ({ context }) => {
    context.agent ??= new PlaywrightAgent(context.page);
    return context.agent;
  },
});

// 2. Define browser environment setup and cleanup
const playwrightSetup = defineProjectSetup<ProjectContext>({
  name: 'playwright',
  platform: 'web',
  async setup({ onTeardown }) {
    const browser = await chromium.launch({ headless: true });
    onTeardown(() => browser.close());
    const browserContext = await browser.newContext();
    const page = await browserContext.newPage();
    return { browser, page };
  },
});

// 3. Export the project configuration
export default defineTestProject<ProjectContext>({
  projects: [
    {
      name: 'chromium',
      platform: 'web',
      setup: playwrightSetup,
      files: { include: ['cases/**/*.{yaml,yml}'] },
    },
  ],
  nodes: [mockLocation, ...midsceneNodes],
});

import { defineNode, z } from '@midscene/test';

const orderInputSchema = z.strictObject({
  sku: z.string().min(1).describe('SKU of the product to order.'),
  quantity: z.number().int().positive().describe('Quantity to order.'),
});

interface ProjectContext {
  apiBaseUrl: string;
}

const createOrder = defineNode<
  typeof orderInputSchema,
  { id: string },
  ProjectContext
>({
  name: 'order.create',
  title: 'Create order',
  description: 'Create a product order through the test API.',
  inputSchema: orderInputSchema,

  async execute({ input, context, signal }) {
    const response = await fetch(`${context.apiBaseUrl}/test/orders`, {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
      },
      body: JSON.stringify({
        sku: input.sku,
        quantity: input.quantity,
      }),
      signal,
    });

    if (!response.ok) {
      throw new Error(`Failed to create order: HTTP ${response.status}`);
    }

    const order = (await response.json()) as { id: string };
    return {
      summary: `Created order ${order.id}`,
      data: order,
    };
  },
});

const refundInputSchema = z.strictObject({
  orderId: z.string().min(1).describe('ID of the order to refund.'),
  reason: z.string().optional().describe('Reason for the refund.'),
});

const refundOrder = defineNode({
  name: 'order.refund',
  description: 'Request a refund for an existing order.',
  inputSchema: refundInputSchema,
  async execute({ input }) {
    // input is inferred as { orderId: string; reason?: string }
    await refund(input.orderId, input.reason);
  },
});

import { defineNode, z } from '@midscene/test';
import type { PlaywrightAgent } from '@midscene/web/playwright';
import type { Page } from 'playwright';

interface ProjectContext {
  agent: PlaywrightAgent;
  appBaseUrl: string;
  page: Page;
  orderId?: string; // Share test state across Nodes
  orderService: {
    create(input: { status: 'paid' }): Promise<{ id: string }>;
    remove(orderId: string): Promise<void>;
  };
}

const emptyInputSchema = z.strictObject({});
const prepareOrderInputSchema = z.strictObject({
  status: z.literal('paid').describe('Status of the order to create.'),
});

const getOrderId = (context: ProjectContext) => {
  if (!context.orderId) {
    throw new Error('The test order has not been created.');
  }
  return context.orderId;
};

// 1. Prepare the order environment
const prepareOrder = defineNode<
  typeof prepareOrderInputSchema,
  { orderId: string },
  ProjectContext
>({
  name: 'order.prepare',
  description: 'Call the order service to create a test order.',
  inputSchema: prepareOrderInputSchema,
  async execute({ input, context }) {
    const order = await context.orderService.create(input);
    context.orderId = order.id; // Save the ID in the context
    return {
      summary: `Created test order ${order.id}`,
      data: { orderId: order.id },
    };
  },
});

// 2. Access the saved order state
const openRefundPage = defineNode<
  typeof emptyInputSchema,
  unknown,
  ProjectContext
>({
  name: 'browser.openRefundPage',
  description: "Open the current test order's refund page.",
  inputSchema: emptyInputSchema,
  async execute({ context }) {
    const orderId = getOrderId(context);
    await context.page.goto(`${context.appBaseUrl}/orders/${orderId}/refund`);
  },
});

// 3. Clean up the business environment
const cleanupOrder = defineNode<
  typeof emptyInputSchema,
  unknown,
  ProjectContext
>({
  name: 'order.cleanup',
  description: 'Delete the current test order.',
  inputSchema: emptyInputSchema,
  async execute({ context }) {
    const orderId = getOrderId(context);
    await context.orderService.remove(orderId);
    delete context.orderId; // Restore a clean context
  },
});

export const refundNodes = [prepareOrder, openRefundPage, cleanupOrder];

import { createMidsceneNodes } from '@midscene/test/midscene';

const midsceneNodes = createMidsceneNodes<ProjectContext>({
  getAgent: ({ context }) => {
    context.agent ??= new PlaywrightAgent(context.page);
    return context.agent;
  },
});

export default defineTestProject<ProjectContext>({
  projects: [
    {
      name: 'android-smoke',
      platform: 'android',
      setup: doraAndroidSetup,
      files: {
        include: ['cases/**/*.{yaml,yml}'],
        exclude: ['cases/**/*.draft.yaml'],
      },
      tags: { include: ['smoke'], exclude: ['manual'] },
      retry: 1,
      variables: { appUri: 'com.example.app' },
    },
  ],
  test: {
    maxConcurrency: 1, // Maximum number of active Execution Projects
    bail: 0, // Stop scheduling new tasks after this many failed cases when > 0
    testTimeout: 120_000,
  },
  output: {
    reportDir: './midscene_run/report',
  },
  nodes: [createOrder, ...midsceneNodes],
});