Architecture description

package dev.aulait.svqk.interfaces.issue;

import static org.junit.jupiter.api.Assertions.assertEquals;

import dev.aulait.svqk.arch.test.ConstraintViolationResponseDto;
import dev.aulait.svqk.arch.test.ValidationMessageUtils;
import io.quarkus.test.junit.QuarkusIntegrationTest;
import org.apache.commons.lang3.RandomStringUtils;
import org.junit.jupiter.api.Test;

@QuarkusIntegrationTest (1)
class IssueControllerIT {

  IssueClient client = new IssueClient(); (2)

  @Test (3)
  void testCrud() {
    IssueDto issue = IssueDataFactory.createRandomIssue(); (4)

    // Create
    int issueId = client.create(issue); (5)

    // Reference
    IssueDto createdIssue = client.get(issueId);
    assertEquals(issue.getSubject(), createdIssue.getSubject()); (6)

  }
}

package dev.aulait.svqk.interfaces.issue;

import static dev.aulait.svqk.arch.test.RestAssuredUtils.given;
import static dev.aulait.svqk.interfaces.issue.IssueController.*;

import dev.aulait.svqk.arch.test.ConstraintViolationResponseDto;

public class IssueClient {

  public Integer create(IssueDto issue) { (1)
    return Integer.parseInt(
        given() (2)
            .body(issue)
            .post(ISSUES_PATH)
            .then()
            .statusCode(200)
            .extract()
            .asString());
  }

package dev.aulait.svqk.interfaces.issue;

import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.RandomStringUtils;

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class IssueDataFactory {

  public static IssueDto createRandomIssue() { (1)
    IssueDto issue = new IssueDto();
    issue.setSubject("test subject: " + RandomStringUtils.randomAlphanumeric(5));

    IssueStatusDto status = new IssueStatusDto();
    status.setId("1");
    issue.setIssueStatus(status);

    TrackerDto tracker = new TrackerDto();

import { test } from '@playwright/test';
import { IssueFacade } from '../facades/IssueFacade';
import { DryRun } from '../arch/DryRun';
import TopPage from '../pages/top/TopPage';
import IssueInputFactory from '../factories/IssueFactory';

(1)
test('CRUD of Issue', async ({ page }) => {
  (2)
  const dryRun = DryRun.build();
  const topPage = new TopPage(page, dryRun);

  (3)
  const menuBar = await topPage.open();
  let issueListPage = await menuBar.gotoIssueListPage();
  let issueInputPage = await issueListPage.gotoNewIssuePage();

  // Create
  const issue = IssueInputFactory.createRandomIssue();
  await issueInputPage.save(issue);

  // Rererence
  const issueFacade = new IssueFacade(dryRun);
  issueInputPage = await issueFacade.referenceIssueBySubject(menuBar, issue.subject);

  // ...
});

import BaseFacade from '../arch/BaseFacade';
import MenuBar from '../pages/menu-bar/MenuBar';

export class IssueFacade extends BaseFacade {
  (1)
  async referenceIssueBySubject(menuBar: MenuBar, subject: string) {
    this.logStart('Issue Reference');

    (2)
    const issueListPage = await menuBar.gotoIssueListPage();
    await issueListPage.searchIssue({ text: subject });
    const issueInputPage = await issueListPage.gotoIssueBySubject(subject);

    (3)
    return issueInputPage;
  }
}

import IssueInputPageElement from './IssueInputPageElement';
import type { IssueModel } from '../../api/Api';
import BasePageElement from '../../arch/BasePageElement';

export default class IssueInputPage {
  private issueInputPageEl: IssueInputPageElement;

  constructor(page: BasePageElement) {
    (1)
    this.issueInputPageEl = new IssueInputPageElement(page);
  }

  (2)
  async save(issue: IssueModel) {
    (3)
    await this.issueInputPageEl.inputSubject(issue.subject);
    await this.issueInputPageEl.inputDescription(issue.description!);

    await this.issueInputPageEl.clickSaveBtn();
  }

  (4)
  async expectIssue(issue: IssueModel) {
    await this.issueInputPageEl.expectSubject(issue.subject);
    await this.issueInputPageEl.expectDescription(issue.description);
  }
}

import BasePageElement from '../../arch/BasePageElement';

(1)
export default class IssueInputPageElement extends BasePageElement {
  get pageNameKey() {
    return 'newIssue';
  }

  (2)
  async inputSubject(subject: string) {
    (3)
    await this.inputText('#subject', subject);
  }

  (4)
  async expectSubject(subject: string) {
    await this.expectText('#subject', subject);
  }

}

import type { IssueModel, IssueStatusModel } from '../api/Api';
import StringUtils from '../arch/StringUtils';

export default class IssueFactory {
  static create() {
    const issue = { issueStatus: {} as IssueStatusModel } as IssueModel;
    return issue;
  }

  (1)
  static createRandomIssue() {
    const issue = this.create();
    issue.subject = StringUtils.generateRandomString();
    issue.description = `${issue.subject}の説明`;

    return issue;
  }
}