Automation test in SCI project

// File: without_api_generator.ts
test('Test case 1', async ({ request }) => {
  const newIssue = await request.post(`/repos/github-username/test-repo-1/issues`, {
    headers: {
      'Accept': 'application/vnd.github.v3+json',
      // Add GitHub personal access token.
      'Authorization': `token ${process.env.API_TOKEN}`,
    },
    data: {
      title: '[Bug] report 1',
      body: 'Bug description',
    },
  })
  expect(newIssue.ok()).toBeTruthy()

  const issues = await request.get(`/repos/github-username/test-repo-1/issues`, {
    headers: {
      'Accept': 'application/vnd.github.v3+json',
      // Add GitHub personal access token.
      'Authorization': `token ${process.env.API_TOKEN}`,
    },
  })
  expect(issues.ok()).toBeTruthy()
  expect(await issues.json()).toContainEqual(expect.objectContaining({
    title: '[Bug] report 1',
    body: 'Bug description',
  }))
})

// File: with_api_generator.ts
test('Test case 1', async ({ githubClient }) => {
  const newIssue = await githubClient.createIssue({
    data: {
      title: '[Bug] report 1',
      body: 'Bug description',
    },
  })
  expect(newIssue.ok()).toBeTruthy()

  const issues = await githubClient.getIssues()
  expect(issues.ok()).toBeTruthy()
  expect(await issues.json()).toContainEqual(expect.objectContaining({
    title: '[Bug] report 1',
    body: 'Bug description',
  }))
})

// File: http-client.eta
<%
const { apiConfig, generateResponses, config } = it;
%>

import { APIRequestContext } from 'playwright-core';

export type QueryParamsType = Record<string | number, any>;
export type ResponseFormat = keyof Omit<Body, "body" | "bodyUsed">;

export interface FullRequestParams extends Omit<RequestInit, "body"> {
  /** set parameter to `true` for call `securityWorker` for this request */
  secure?: boolean;
  /** request path */
  path: string;
  /** content type of request body */
  type?: string
  /** method of request */
  method?: string
  /** query params */
  query?: QueryParamsType;
  /** format of response (i.e. response.json() -> format: "json") */
  format?: ResponseFormat;
  /** request body */
  body?: unknown;
  /** base url */
  baseUrl?: string;
  /** request cancellation token */
  cancelToken?: CancelToken;
}

export type RequestParams = Omit<FullRequestParams, "body" | "query" | "path">

export type DataResponse<T, E> = {
  //[x: string]: any
  response: T
  error: E
  status: number
  statusText: string
}

export interface ApiConfig<SecurityDataType = unknown> {
  baseUrl?: string;
  baseApiParams?: Omit<RequestParams, "baseUrl" | "cancelToken" | "signal">;
  securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
  customFetch?: typeof fetch;
}

export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
  data: D;
  error: E;
}

type CancelToken = Symbol | string | number;

export enum ContentType {
  Json = "application/json",
  FormData = "multipart/form-data",
  UrlEncoded = "application/x-www-form-urlencoded",
  Text = "text/plain",
}

export class HttpClient<SecurityDataType = unknown> {
  public baseUrl: string = "<%~ apiConfig.baseUrl %>";
  private apiContext: APIRequestContext;
  private securityData: SecurityDataType | null = null;
  private securityWorker?: ApiConfig<SecurityDataType>["securityWorker"];
  private abortControllers = new Map<CancelToken, AbortController>();

  private getXRequestId(method: string, url: string): string {
    const randomString = Math.random()
    return `${method.toLowerCase()}-${url}-${randomString}`.replace(/[^a-zA-Z0-9]/g, '-')
  }

  private customFetch = (url, fetchParams: Parameters<typeof fetch>[1]) => {
    const { 'Content-Type': contentType, ...headers } = fetchParams.headers as Record<string, string>
    const fetchOptions = {
      headers: {
        ...headers,
        ...(contentType !== ContentType.FormData
          ? {
              'Content-Type': contentType,
            }
          : {}),
      },
      method: fetchParams.method,
    }

    if (contentType === ContentType.FormData) {
      fetchOptions['multipart'] = fetchParams.body
    } else {
      fetchOptions['data'] = fetchParams.body
    }

    return this.apiContext.fetch(url, fetchOptions)
  }

  private baseApiParams: RequestParams = {
    credentials: 'same-origin',
    headers: {},
    redirect: 'follow',
    referrerPolicy: 'no-referrer',
  }

  constructor(apiConfig: ApiConfig<SecurityDataType> = {}, apiContext: APIRequestContext) {
    Object.assign(this, apiConfig);
    this.apiContext = apiContext;
  }

  public setSecurityData = (data: SecurityDataType | null) => {
    this.securityData = data;
  }

  protected encodeQueryParam(key: string, value: any) {
    const encodedKey = encodeURIComponent(key);
    return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
  }

  protected addQueryParam(query: QueryParamsType, key: string) {
    return this.encodeQueryParam(key, query[key]);
  }

  protected addArrayQueryParam(query: QueryParamsType, key: string) {
    const value = query[key];
    return value.map((v: any) => this.encodeQueryParam(key, v)).join("&");
  }

  protected toQueryString(rawQuery?: QueryParamsType): string {
    const query = rawQuery || {};
    const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
    return keys
        .map((key) =>
          Array.isArray(query[key])
          ? this.addArrayQueryParam(query, key)
          : this.addQueryParam(query, key),
        )
        .join("&");
  }

  protected addQueryParams(rawQuery?: QueryParamsType): string {
    const queryString = this.toQueryString(rawQuery);
    return queryString ? `?${queryString}` : "";
  }

  private contentFormatters: Record<ContentType, (input: any) => any> = {
    [ContentType.Json]: (input:any) => input !== null && (typeof input === "object" || typeof input === "string") ? JSON.stringify(input) : input,
    [ContentType.Text]: (input:any) => input !== null && typeof input !== "string" ? JSON.stringify(input) : input,
    [ContentType.FormData]: (input: any) =>
      Object.keys(input || {}).reduce((formData, key) => {
        const property = input[key];
        formData[key] =
          property instanceof Blob ?
            property :
          typeof property === "object" && property !== null ?
            JSON.stringify(property) :
          `${property}`
        return formData;
      }, {}),
    [ContentType.UrlEncoded]: (input: any) => this.toQueryString(input),
  }

  protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams {
    return {
      ...this.baseApiParams,
      ...params1,
      ...(params2 || {}),
      headers: {
        ...(this.baseApiParams.headers || {}),
        ...(params1.headers || {}),
        ...((params2 && params2.headers) || {}),
      },
    };
  }

  protected createAbortSignal = (cancelToken: CancelToken): AbortSignal | undefined => {
    if (this.abortControllers.has(cancelToken)) {
      const abortController = this.abortControllers.get(cancelToken);
      if (abortController) {
        return abortController.signal;
      }
      return void 0;
    }

    const abortController = new AbortController();
    this.abortControllers.set(cancelToken, abortController);
    return abortController.signal;
  }

  public abortRequest = (cancelToken: CancelToken) => {
    const abortController = this.abortControllers.get(cancelToken)

    if (abortController) {
      abortController.abort();
      this.abortControllers.delete(cancelToken);
    }
  }

  public request = async <T = any, E = any>({
    body,
    secure,
    path,
    type,
    query,
    format,
    baseUrl,
    cancelToken,
    ...params
  }: FullRequestParams): Promise<DataResponse<T, E>> => {
    const secureParams = ((typeof secure === 'boolean' ? secure : this.baseApiParams.secure) && this.securityWorker && await this.securityWorker(this.securityData)) || {};
    const requestParams = this.mergeRequestParams(params, secureParams);
    const queryString = query && this.toQueryString(query);
    const payloadFormatter = this.contentFormatters[type || ContentType.Json];
    const responseFormat = format || requestParams.format;

    const customFetchParams: Parameters<typeof fetch>[1] = {
      ...requestParams,
      headers: {
        ...(requestParams.headers || {}),
        ...(type ? { 'Content-Type': type } : {}),
        'X-REQUEST_ID': this.getXRequestId(params.method, path),
      },
      signal: cancelToken ? this.createAbortSignal(cancelToken) : requestParams.signal,
    }

    if (typeof body !== 'undefined' && body !== null) {
      customFetchParams['body'] = payloadFormatter(body)
    }

    return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, customFetchParams).then(async (response) => {
      const returned: DataResponse<T, E> = {
        response: null,
        error: null,
        status: response.status(),
        statusText: response.statusText(),
      }

      if (responseFormat) {
        await response[responseFormat]()
          .then((data) => {
            if (response.ok()) {
              returned.response = data
            } else {
              returned.error = data
            }
          })
          .catch((e) => {
            returned.error = e
          })
      } else {
        const r = response as unknown as HttpResponse<T, E>
        returned.response = r.data
        returned.error = r.error
      }

      if (cancelToken) {
        this.abortControllers.delete(cancelToken)
      }

      return returned
    });
    };
}

// File: gen-api.ts
import { render } from 'eta'
import * as fs from 'fs'
import * as path from 'path'
import { generateApi, GenerateApiParams } from 'swagger-typescript-api'

import { toCamelCase } from '/path/to/string/utilities'

type RequestParameter = {
  name: string
  optional: boolean
  type: string
  description: string
}

type RequestPayload = {
  name: string
  optional: boolean
  type: string
}

type ParsedRequest = Request & {
  path: string
  parameters: RequestParameter[]
  payload?: RequestPayload
}

async function genOpenApi(swaggerPath: string, outputPath: string, typeAsAny = false) {
  const options: GenerateApiParams = {
    name: 'open-api.ts',
    output: outputPath,
    input: swaggerPath,
    templates: templatePath,
    httpClientType: 'fetch',
    generateUnionEnums: false,
    enumNamesAsValues: true,
    singleHttpClient: true,
    cleanOutput: true,
    modular: true,
    moduleNameFirstTag: true,
    generateResponses: true,
    generateClient: true,
    unwrapResponseData: true,
    extractEnums: true,
    extractResponseError: true,
    extractRequestBody: true,
    hooks: {
      onCreateRoute: (parsedRoute) => {
        const request = parsedRoute.request as ParsedRequest

        if (request.parameters.length > 0) {
          // Replace "{*abc}" to "${abc}"
          request.path = request.path.replace(/\{\*(\w+)\}/, '${$1}')
        }

        if (typeAsAny && request.payload) {
          request.payload.optional = true
          request.payload.type += ' | any'

          return {
            ...parsedRoute,
            request,
          }
        }
      },
    },
  }

  // Support type as any to check type validation rules of BE
  if (typeAsAny) {
    options.codeGenConstructs = (struct) => ({
      ...struct,
      TypeField: ({ readonly, key, value }) => {
        return `${readonly ? 'readonly' : ''} ${key}?: ${value} | any`
      },
    })
  }

  // Generate open-api files
  // ------------------------------
  try {
    const { files } = await generateApi(options)
    const fileList = files
      .filter((file) => !['data-contracts.ts'].includes(file.name))
      .map((file) => {
        const fileNameWithoutExtension = file.name.replace('.ts', '')

        return {
          fileName: file.name,
          className: fileNameWithoutExtension,
          instanceName: toCamelCase(fileNameWithoutExtension),
        }
      })
      .sort((a, b) => a.className.toLowerCase().localeCompare(b.className.toLowerCase()))

    const servicesConnectorPath = path.join(outputPath, 'services-connector.ts')
    fs.writeFileSync('/path/to/service-connector', renderTemplate('/path/to/service-connector-template', { fileList }))
  } catch (e) {
    console.error(e)
  }
}

// Generate open-api
;(async () => {
  await genOpenApi('/path/to/swagger.json', '/path/to/open-api/')
  await genOpenApi('/path/to/swagger.json', '/path/to/open-api-as-any/', true)
})()

// File: my-fixtures.ts
import { test as base } from '@playwright/test'
import { TodoPage } from './todo-page'
import { SettingsPage } from './settings-page'

// Declare the types of your fixtures.
type MyFixtures = {
  todoPage: TodoPage;
  settingsPage: SettingsPage;
};

// Extend base test by providing "todoPage" and "settingsPage".
// This new "test" can be used in multiple test files, and each of them will get the fixtures.
export const test = base.extend<MyFixtures>({
  todoPage: async ({ page }, use) => {
    // Set up the fixture.
    const todoPage = new TodoPage(page)
    await todoPage.goto()
    await todoPage.addToDo('item1')
    await todoPage.addToDo('item2')

    // Use the fixture value in the test.
    await use(todoPage)

    // Clean up the fixture.
    await todoPage.removeAll()
  },

  settingsPage: async ({ page }, use) => {
    await use(new SettingsPage(page))
  },
})
export { expect } from '@playwright/test'

// File: without_fixtures.ts
const { test } = require('@playwright/test')
const { TodoPage } = require('./todo-page')

test.describe('todo tests', () => {
  let todoPage

  test.beforeEach(async ({ page }) => {
    todoPage = new TodoPage(page)
    await todoPage.goto()
    await todoPage.addToDo('item1')
    await todoPage.addToDo('item2')
  })

  test.afterEach(async () => {
    await todoPage.removeAll()
  })

  test('should add an item', async () => {
    await todoPage.addToDo('my item')
    // ...
  })

  test('should remove an item', async () => {
    await todoPage.remove('item1')
    // ...
  })
})

// File: with_fixtures.ts
const { test } = require('@playwright/test')
const { TodoPage } = require('./todo-page')

test.describe('todo tests', () => {
  test.afterEach(async ({ todoPage }) => {
    await todoPage.removeAll()
  })

  test('should add an item', async ({ todoPage }) => {
    await todoPage.addToDo('my item')
    // ...
  })

  test('should remove an item', async ({ todoPage }) => {
    await todoPage.remove('item1')
    // ...
  })
})

// File: with-aliases.ts
describe('Test suite', () => {
  beforeAll(async ({}) => {
    // beforeAll hook
  })

  beforeEach(async ({}) => {
    // beforeEach hook
  })

  it('Test case #1', async ({}) => {
    // Test case script
  })

  it('Test case #2', async ({}) => {
    // Test case script
  })

  afterEach(async ({}) => {
    // afterEach hook
  })

  afterAll(async ({}) => {
    // afterAll hook
  })
})

// File: without-aliases.ts
test.describe('Test suite', () => {
  test.beforeAll(async ({}) => {
    // beforeAll hook
  })

  test.beforeEach(async ({}) => {
    // beforeEach hook
  })

  test('Test case #1', async ({}) => {
    // Test case script
  })

  test('Test case #2', async ({}) => {
    // Test case script
  })

  test.afterEach(async ({}) => {
    // afterEach hook
  })

  test.afterAll(async ({}) => {
    // afterAll hook
  })
})

// File: c57293.ts
// Link: https://moneyforwardvietnam.testrail.io/index.php?/cases/view/57293

...

it('C57293 Verify menu header after user logs on the SCI system successfully', async ({ globalHeader }) => {
  ...
})

// File: with-test-suite.ts
describe('Test suite', () => {
  beforeAll(async ({}) => {
    // beforeAll hook
  })

  beforeEach(async ({}) => {
    // beforeEach hook
  })

  it('Test case #1', async ({}) => {
    // Test case script
  })

  it('Test case #2', async ({}) => {
    // Test case script
  })

  afterEach(async ({}) => {
    // afterEach hook
  })

  afterAll(async ({}) => {
    // afterAll hook
  })
})

// File: without-test-suite.ts
beforeAll(async ({}) => {
  // beforeAll hook
})

beforeEach(async ({}) => {
  // beforeEach hook
})

it('Test case #1', async ({}) => {
  // Test case script
})

it('Test case #2', async ({}) => {
  // Test case script
})

afterEach(async ({}) => {
  // afterEach hook
})

afterAll(async ({}) => {
  // afterAll hook
})

// File: c57293.ts
// Link: https://moneyforwardvietnam.testrail.io/index.php?/cases/view/57293

import { accountData } from '@/data/account'
import { globalHeaderData } from '@/data/global-header'
import { ACCOUNT_0_STATE } from '@/libs/constants/store'
import { beforeEach, expect, it, use } from '@/libs/fixtures/e2e'

use({ storageState: ACCOUNT_0_STATE })

beforeEach(async ({ sendPackageListPage }) => {
  await sendPackageListPage.goto()
})

it('C57293 Verify menu header after user logs on the SCI system successfully', async ({ globalHeader }) => {
  // User dropdown
  await globalHeader.openUserDropdown()
  await expect(globalHeader.userDropdown).toContainText(accountData.user[0].name)
  await expect(globalHeader.userSettingButton).toContainText(globalHeaderData.userDropdown.userSettingText)
  await expect(globalHeader.userSettingButton).toHaveAttribute(
    'href',
    `${process.env.MFID_BASE_URL}${globalHeaderData.userDropdown.userSettingLink}`
  )
  await expect(globalHeader.logoutButton).toBeVisible()
  await expect(globalHeader.logoutButton).toContainText(globalHeaderData.userDropdown.logoutButtonText)

  // Office dropdown
  await globalHeader.openOfficeDropdown()
  await expect(globalHeader.switchOfficeButton).toBeVisible()
  await expect(globalHeader.officeDropdown).toContainText(accountData.office[0].tenantName)
  await expect(globalHeader.officeDropdown).toContainText(globalHeaderData.officeDropdown.officeBusinessNumberText)
  await expect(globalHeader.officeDropdown).toContainText(accountData.office[0].businessNumber)
  await expect(globalHeader.switchOfficeButton).toContainText(globalHeaderData.officeDropdown.switchOfficeButtonText)
})

// File: c57134.ts
// Link: https://moneyforwardvietnam.testrail.io/index.php?/cases/view/57134

import { accountData } from '@/data/receiver-account'
import { describe, expect, it } from '@/libs/fixtures/api'

/**
 * Endpoints: PUT /v1/user/terms
 */
describe('SCI-3365-Receiver can register MFID', () => {
  it('C57134-Verify agree the term process before user agrees the term', async ({ apiClient }) => {
    const loginResult = await apiClient.login(accountData.user[1].email, accountData.user[1].password)
    expect(loginResult.status).toBe(200)
    expect(loginResult.response).toHaveProperty('data')
    expect(loginResult.response.data.user).not.toBe(null)
    expect(loginResult.response.data.user.accept_terms).toBe(false)
    expect(loginResult.response.data.user.has_available_tenant).toBe(true)
  })
})

// File: my-awesome-reporter.ts
import type {
  FullConfig, FullResult, Reporter, Suite, TestCase, TestResult,
} from '@playwright/test/reporter'

class MyReporter implements Reporter {
  onBegin(config: FullConfig, suite: Suite) {
    console.log(`Starting the run with ${suite.allTests().length} tests`)
  }

  onTestBegin(test: TestCase, result: TestResult) {
    console.log(`Starting test ${test.title}`)
  }

  onTestEnd(test: TestCase, result: TestResult) {
    console.log(`Finished test ${test.title}: ${result.status}`)
  }

  onEnd(result: FullResult) {
    console.log(`Finished the run: ${result.status}`)
  }
}

export default MyReporter

// File: playwright.config.ts
import { defineConfig } from '@playwright/test'

export default defineConfig({
  reporter: './my-awesome-reporter.ts',
})

// File: summary-reporter.ts
import { FullConfig, Reporter, Suite } from '@playwright/test/reporter'
import * as fs from 'fs'

import { getCurrentDate, convertMsToTime } from './path/to/helpers'

export type AppName = 'sender' | 'receiver'
export type TestType = 'e2e' | 'api'

export type SummaryReporterOption = {
  outputFile: string
  appName: AppName
  testType: TestType
}

class SummaryReporter implements Reporter {
  private suiteList: Suite[] = []
  private readonly outputFile: string
  private readonly appName: AppName
  private readonly testType: TestType

  constructor({ outputFile, appName, testType }: SummaryReporterOption) {
    this.outputFile = outputFile
    this.appName = appName
    this.testType = testType
  }

  onBegin(config: FullConfig, suite: Suite) {
    this.suiteList.push(suite)
  }

  onEnd() {
    let total = 0
    let totalPassed = 0
    let totalFailed = 0
    let totalFlaky = 0
    let totalSkipped = 0
    let totalTimedOut = 0
    let totalInterrupted = 0
    let totalDuration = 0

    this.suiteList.forEach((suite) => {
      suite.allTests().forEach((test) => {
        let isPassed = false
        let isFailed = false
        let isFlaky = false
        test.results.forEach((result) => {
          result.status === 'skipped' && totalSkipped++
          result.status === 'timedOut' && totalTimedOut++
          result.status === 'interrupted' && totalInterrupted++
          result.duration

          if (result.retry === 0) {
            isPassed = result.status === 'passed'
            isFailed = result.status === 'failed'
          } else {
            if ((result.status === 'passed' && isFailed) || (result.status === 'passed' && isPassed)) {
              isFlaky = true
              isPassed = false
              isFailed = false
            }
          }

          totalDuration += result.duration
        })

        isPassed && totalPassed++
        isFailed && totalFailed++
        isFlaky && totalFlaky++
        total++
      })

      const passedRatio = (totalPassed / total) * 100

      fs.writeFileSync(
        this.outputFile,
        JSON.stringify({
          title: `[${this.testType.toUpperCase()}] [${this.appName.toUpperCase()}] Report for ${getCurrentDate()}`,
          total,
          totalPassed,
          totalFailed,
          totalFlaky,
          totalSkipped,
          totalTimedOut,
          totalInterrupted,
          passedRatio: isNaN(passedRatio) ? 'N/A' : `${passedRatio.toFixed(2)}%`,
          totalDuration: totalDuration === 0 ? 'N/A' : convertMsToTime(totalDuration),
        })
      )
    })
  }
}

export default SummaryReporter

// File: testrail-reporter.ts
import TestRail from '@dlenroc/testrail'
import { Reporter, TestCase, TestResult } from '@playwright/test/reporter'
import dayjs from 'dayjs'
import isoWeek from 'dayjs/plugin/isoWeek'
import * as fs from 'fs'

import { getCurrentDate, getCurrentWeek, getPrefixTitle, stripAnsi } from './path/to/helpers'

dayjs.extend(isoWeek)

export type AppName = 'sender' | 'receiver'
export type TestType = 'e2e' | 'api'

export type TestRailReporterOption = {
  outputFile: string
  host: string
  username: string
  password: string
  projectId: number
  suiteId: number
  appName: AppName
  testType: TestType
}

class TestRailReporter implements Reporter {
  private readonly testRailClient: TestRail
  private initTestMilestoneProcess: Promise<void>
  private testMilestone: TestRail.Milestone
  private testRun: TestRail.Run
  private readonly outputFile: string
  private readonly host: string
  private readonly projectId: number
  private readonly suiteId: number
  private readonly appName: AppName
  private readonly testType: TestType
  private testResultList: Array<TestRail.Result> = []
  private readonly STATUS_MAPPING = {
    passed: 1,
    failed: 5,
    timedOut: 5,
  }

  constructor({ username, password, ...options }: TestRailReporterOption) {
    Object.assign(this, options)
    this.testRailClient = new TestRail({
      host: options.host,
      username,
      password,
    })
  }

  // Event handlers
  // --------------------------------
  async onBegin() {
    this.initTestMilestoneProcess = this.initTestMilestone()
  }

  async onTestEnd(test: TestCase, result: TestResult) {
    await this.initTestResult(test, result)
  }

  async onEnd() {
    await this.initTestMilestoneProcess
    if (this.testResultList.length > 0) {
      await this.initTestRun()
      await this.updateTestResult()
    }
    this.genResult()
    await this.closeTestRun()
    await this.closeTestMilestone()
  }

  // Gen result
  // --------------------------------
  genResult() {
    fs.writeFileSync(
      this.outputFile,
      JSON.stringify({
        link: `${this.host}/index.php?/runs/view/${this?.testRun?.id || ''}`,
      })
    )
  }

  // TestRail businesses
  // --------------------------------
  async initTestMilestone() {
    const name = `[SCI] ${getPrefixTitle(this.appName, this.testType)} Milestone for ${getCurrentWeek()}`
    const milestoneList = await this.testRailClient.getMilestones(this.projectId, {
      is_completed: false,
    })

    let testMilestone = milestoneList.filter((item) => item.name === name)[0]
    if (!testMilestone) {
      testMilestone = await this.testRailClient.addMilestone(this.projectId, {
        name,
      })
    }

    if (!testMilestone.is_started) {
      testMilestone = await this.testRailClient.updateMilestone(testMilestone.id, {
        is_started: true,
      })
    }

    this.testMilestone = testMilestone
  }

  async closeTestMilestone() {
    if (dayjs().day() === 5) {
      await this.testRailClient.updateMilestone(this.testMilestone.id, {
        is_completed: true,
      })
    }
  }

  async initTestRun() {
    const name = `[SCI] ${getPrefixTitle(this.appName, this.testType)} Run for ${getCurrentDate()}`

    const testRunList = await this.testRailClient.getRuns(this.projectId, {
      suite_id: this.suiteId,
      milestone_id: this.testMilestone.id,
    })

    let testRun = testRunList.filter((item) => item.name === name)[0]
    if (!testRun) {
      testRun = await this.testRailClient.addRun(this.projectId, {
        suite_id: this.suiteId,
        milestone_id: this.testMilestone.id,
        name,
      })
    }

    if (!testRun.include_all) {
      testRun = await this.testRailClient.updateRun(this.projectId, {
        include_all: true,
      })
    }

    this.testRun = testRun
  }

  async closeTestRun() {
    await this.testRailClient.closeRun(this.testRun.id)
  }

  async initTestResult(test: TestCase, result: TestResult) {
    const testCaseIdList = test.title.match(/(C[0-9]+)/gi)?.map((item) => +item.replace(/c/i, ''))

    if (!Array.isArray(testCaseIdList) || testCaseIdList.length === 0) {
      return
    }

    if (result.status === 'skipped') {
      return
    }

    let runNumber = ''
    if (result.retry === 0) {
      runNumber = `First run`
    } else {
      runNumber = `Retry #${result.retry}`
    }

    let errorMessage = ''
    if (result.status === 'failed') {
      let errorDetails = ''
      errorDetails += stripAnsi(result.error.message)
      errorDetails += '\n'
      if (result.error.location) {
        errorDetails += `  at ${result.error.location.file}:${result.error.location.line}:${result.error.location.column}`
      }

      const errorArr = errorDetails.split('\n').map((item) => `        ${item}`)

      errorMessage += `\nError:\n\n${errorArr.join('\n')}`
    }

    this.testResultList = [
      ...this.testResultList,
      ...testCaseIdList.map(
        (item) =>
          ({
            case_id: item,
            status_id: this.STATUS_MAPPING[result.status],
            comment: `${runNumber}\n\nDuration: ${result.duration}ms\n\n${errorMessage}`,
          } as unknown as TestRail.Result)
      ),
    ]
  }

  async updateTestResult() {
    await this.testRailClient.addResultsForCases(this.testRun.id, {
      results: this.testResultList,
    })
  }
}

export default TestRailReporter