puerto 0.22.0

Puerto — Rust full-stack DDD framework CLI. Scaffolds Clean Architecture projects with auto-wired DI, SQLx support, and zero manual wiring. Formerly puerto-framework.
import { describe, expect, test } from "bun:test";
import { fireEvent, screen, waitFor } from "@testing-library/react";
import { {{ pascal }}Error } from "../../../../domain/{{ kebab }}/errors";
import type { {{ pascal }}Draft } from "../../../../domain/{{ kebab }}/model";
{%- for t in targets %}
import { fake{{ t.pascal }}Repository, {{ t.pascal }}Mother } from "../../../../test-support/{{ t.kebab }}";
{%- endfor %}
import { fake{{ pascal }}Repository, {{ pascal }}Mother } from "../../../../test-support/{{ kebab }}";
import { renderScreen } from "../../../../test-support/render";
{%- if fill_helpers %}
import { {{ fill_helpers | join(sep=", ") }} } from "../../../shared/forms";
{%- endif %}
import { {{ pascal }}FormContainer } from "./{{ kebab }}-form-container";

function type(label: string, value: string) {
  fireEvent.change(screen.getByLabelText(label), { target: { value } });
}
{%- if targets %}

/** Picks `id` in a reference's select, once its targets have loaded. */
async function choose(label: string, id: string) {
  const select = screen.getByLabelText(label);
  await waitFor(() => expect(select.querySelector(`option[value="${id}"]`)).not.toBeNull());
  fireEvent.change(select, { target: { value: id } });
}

/** The repositories the selects read, holding what `draft` references. */
function referencedBy(draft: {{ pascal }}Draft) {
  return {
{%- for t in targets %}
{%- if t.seeds_inline %}
    {{ t.camel }}Repository: fake{{ t.pascal }}Repository([{{ t.seeds | join(sep=", ") }}]),
{%- else %}
    {{ t.camel }}Repository: fake{{ t.pascal }}Repository([
{%- for seed in t.seeds %}
      {{ seed }},
{%- endfor %}
    ]),
{%- endif %}
{%- endfor %}
  };
}
{%- endif %}

/** Fills the empty form with `draft`, the way a user would. */
async function fillIn(draft: {{ pascal }}Draft) {
  await screen.findByText("Save");
{%- for f in fields %}
{%- if f.input == "checkbox" %}
  if (draft.{{ f.camel }}) fireEvent.click(screen.getByLabelText("{{ f.label }}"));
{%- elif f.input == "reference" %}
  await choose("{{ f.label }}", {{ f.draft_to_form }});
{%- else %}
  type("{{ f.label }}", {{ f.draft_to_form }});
{%- endif %}
{%- endfor %}
}

describe("{{ pascal }}FormContainer", () => {
  test("should create the {{ words }} from what was typed and show it", async () => {
    // Arrange
    const draft = {{ pascal }}Mother.draft();
    const {{ camel }}Repository = fake{{ pascal }}Repository();
{%- if targets %}
    const { history } = renderScreen(<{{ pascal }}FormContainer />, {
      {{ camel }}Repository,
      ...referencedBy(draft),
    });
{%- else %}
    const { history } = renderScreen(<{{ pascal }}FormContainer />, { {{ camel }}Repository });
{%- endif %}
    await fillIn(draft);

    // Act
    fireEvent.click(screen.getByText("Save"));

    // Assert
    await waitFor(() => expect(history.at(-1)).toStartWith("/{{ plural }}/"));
    const {
      items: [created],
    } = await {{ camel }}Repository.list({ limit: 1, offset: 0 });
    expect(created).toMatchObject(draft);
    expect(history.at(-1)).toBe(`/{{ plural }}/${created?.id}`);
  });

  test("should save the edited {{ words }} when an existing one is submitted", async () => {
    // Arrange
    const seeded = {{ pascal }}Mother.random();
    const {{ camel }}Repository = fake{{ pascal }}Repository([seeded]);
    const { history } = renderScreen(<{{ pascal }}FormContainer id={seeded.id} />, {
      {{ camel }}Repository,
{%- if targets %}
      ...referencedBy(seeded),
{%- endif %}
    });

    // Act
    fireEvent.click(await screen.findByText("Save"));

    // Assert
    await waitFor(() => expect(history.at(-1)).toBe(`/{{ plural }}/${seeded.id}`));
    expect(await {{ camel }}Repository.get(seeded.id)).toEqual(seeded);
  });

  test("should show the code itself when the API answers one the form does not know", async () => {
    // Arrange
    const code = "{{ snake }}.validacion.invalid";
    const {{ camel }}Repository = {
      ...fake{{ pascal }}Repository(),
      create: () => Promise.reject(new {{ pascal }}Error(code)),
    };
{%- if targets %}
    const draft = {{ pascal }}Mother.draft();
    renderScreen(<{{ pascal }}FormContainer />, {
      {{ camel }}Repository,
      ...referencedBy(draft),
    });
    await fillIn(draft);
{%- else %}
    renderScreen(<{{ pascal }}FormContainer />, { {{ camel }}Repository });
    await fillIn({{ pascal }}Mother.draft());
{%- endif %}

    // Act
    fireEvent.click(screen.getByText("Save"));

    // Assert
    expect((await screen.findByRole("alert")).textContent).toBe(code);
  });

  test("should say a {{ words }} with these values exists when the API answers a duplicate", async () => {
    // Arrange
    const {{ camel }}Repository = {
      ...fake{{ pascal }}Repository(),
      create: () => Promise.reject(new {{ pascal }}Error("{{ snake }}.duplicado")),
    };
{%- if targets %}
    const draft = {{ pascal }}Mother.draft();
    renderScreen(<{{ pascal }}FormContainer />, {
      {{ camel }}Repository,
      ...referencedBy(draft),
    });
    await fillIn(draft);
{%- else %}
    renderScreen(<{{ pascal }}FormContainer />, { {{ camel }}Repository });
    await fillIn({{ pascal }}Mother.draft());
{%- endif %}

    // Act
    fireEvent.click(screen.getByText("Save"));

    // Assert
    expect((await screen.findByRole("alert")).textContent).toBe(
      "{{ duplicate_text }}",
    );
  });
{%- for t in targets %}

  test("should offer every {{ t.words }} in the selects that reference one", async () => {
    // Arrange
    const {{ t.ident }} = {{ t.pascal }}Mother.random();

    // Act
    renderScreen(<{{ pascal }}FormContainer />, {
      {{ camel }}Repository: fake{{ pascal }}Repository(),
{%- for o in targets %}
{%- if o.pascal == t.pascal %}
      {{ t.camel }}Repository: fake{{ t.pascal }}Repository([{{ t.ident }}]),
{%- else %}
      {{ o.camel }}Repository: fake{{ o.pascal }}Repository(),
{%- endif %}
{%- endfor %}
    });

    // Assert
    const options = await screen.findAllByRole("option", { name: {{ t.ident }}.{{ t.label }} });
    expect(options).toHaveLength({{ t.fields | length }});
  });
{%- endfor %}
{%- if field_problem %}

  test("should show the message under its input when the API rejects one field", async () => {
    // Arrange
    const {{ camel }}Repository = {
      ...fake{{ pascal }}Repository(),
{%- if field_problem_inline %}
      create: () => Promise.reject(new {{ pascal }}Error("{{ field_problem.code }}")),
{%- else %}
      create: () =>
        Promise.reject(new {{ pascal }}Error("{{ field_problem.code }}")),
{%- endif %}
    };
{%- if targets %}
    const draft = {{ pascal }}Mother.draft();
    renderScreen(<{{ pascal }}FormContainer />, {
      {{ camel }}Repository,
      ...referencedBy(draft),
    });
    await fillIn(draft);
{%- else %}
    renderScreen(<{{ pascal }}FormContainer />, { {{ camel }}Repository });
    await fillIn({{ pascal }}Mother.draft());
{%- endif %}

    // Act
    fireEvent.click(screen.getByText("Save"));

    // Assert
    expect(await screen.findByText("{{ field_problem.text }}")).toBeTruthy();
    const input = screen.getByLabelText("{{ field_problem.label }}");
    expect(input.getAttribute("aria-invalid")).toBe("true");
    expect(screen.queryByRole("alert")).toBeNull();
  });
{%- endif %}
});