hlk_autotest/tests/fixtures/customerFixture.ts

import { test as base } from '@playwright/test';
import { CustomerPage, CustomerDetailsPage, CustomerAnalysisPage } from '@/pages/customer';
import { Customer } from '@/utils/customer';

type MyFixture = {
    singleCustomerPage: {
        createCustomer: (customer: Customer) => Promise<void>;
        setInvalidCustomer: (customer: Customer) => Promise<void>;
    };
    moreCustomerPage: {
        createMoreCustomer: (customer: Customer[]) => Promise<void>;
        setMoreInvalidCustomer: (customer: Customer[]) => Promise<void>;
    };
    customerPage: CustomerPage;
    customerDetailsPage: CustomerDetailsPage;
    customerAnalysisPage: CustomerAnalysisPage;
    createCustomer: Customer;
    createCustomers: (customerNumber: number) => Promise<Customer[]>;
    createCustomCustomer: (customer: Customer) => Promise<void>;
    createCustomCustomers: (customers: Customer[]) => Promise<void>;
};

export const test = base.extend<MyFixture>({
    /**
     * 创建一个顾客
     */
    createCustomer: async ({ page, baseURL }, use) => {
        if (!baseURL) {
            throw new Error('baseUrl is required');
        }

        const customerPage = new CustomerPage(page);
        const customer = new Customer(1, 1);
        await customerPage.createCustomer(customer);
        await page.goto(baseURL);
        await use(customer);
        await page.goto(baseURL);
        await page.getByRole('button', { name: /开\s单/ }).waitFor();
        await page.goto('/#/member/member-schame');
        await customerPage.setInvalidCustomer(customer);
    },

    /**
     * 创建多个顾客
     */
    createCustomers: async ({ page, baseURL }, use): Promise<void> => {
        if (!baseURL) {
            throw new Error('baseUrl is required');
        }

        const customerPage = new CustomerPage(page);
        let createdCustomers: Customer[] = [];

        /**
         * 创建多个顾客
         * @param customerNumber { number } 顾客数量
         * @returns { Promise<Customer[]> } 顾客列表
         */
        const createCustomers = async (customerNumber: number): Promise<Customer[]> => {
            for (let i = 0; i < customerNumber; i++) {
                const customer = new Customer(1, 1);
                await customerPage.createCustomer(customer);
                createdCustomers.push(customer);
            }

            return createdCustomers;
        };

        await use(createCustomers);

        if (createdCustomers.length === 0) return;

        // 测试结束后将客户设置为无效
        await page.goto(baseURL);
        await page.getByRole('button', { name: /开\s单/ }).waitFor();
        await page.goto('/#/member/member-schame');
        await customerPage.setMoreInvalidCustomer(createdCustomers);
    },

    /**
     * 创建一个自定义顾客
     */
    createCustomCustomer: async ({ page, baseURL }, use) => {
        if (!baseURL) {
            throw new Error('baseUrl is required');
        }

        const customerPage = new CustomerPage(page);
        let tmp: Customer | undefined;
        const setCustomer = async (customer: Customer) => {
            await customerPage.createCustomer(customer);
            tmp = customer;
        };
        await use(setCustomer);

        if (!tmp) return;
        await page.goto(baseURL);
        await page.getByRole('button', { name: /开\s单/ }).waitFor();
        await page.goto('/#/member/member-schame');
        await customerPage.setInvalidCustomer(tmp);
    },

    /**
     * 创建多个自定义顾客
     */
    createCustomCustomers: async ({ page, baseURL }, use) => {
        if (!baseURL) {
            throw new Error('baseUrl is required');
        }
        const customerPage = new CustomerPage(page);
        let tmp: Customer[] | undefined;
        const setCustomers = async (customers: Customer[]) => {
            await customerPage.createMoreCustomer(customers);
            tmp = customers;
        };
        await use(setCustomers);

        if (!tmp) return;
        await page.goto(baseURL);
        await page.getByRole('button', { name: /开\s单/ }).waitFor();
        await page.goto('/#/member/member-schame');
        await customerPage.setMoreInvalidCustomer(tmp);
    },

    /**
     * 顾客页面
     */
    customerPage: async ({ page }, use) => {
        const customerPage = new CustomerPage(page);
        await use(customerPage);
    },

    /**
     * 顾客详情
     */
    customerDetailsPage: async ({ page }, use) => {
        const customerDetailsPage = new CustomerDetailsPage(page);
        await use(customerDetailsPage);
    },

    /**
     * 顾客分析
     */
    customerAnalysisPage: async ({ page }, use) => {
        const customerAnalysisPage = new CustomerAnalysisPage(page);
        await use(customerAnalysisPage);
    },
});