Files
kandev/apps/web/components/task-create-dialog-repository-autopick.test.ts
T
Carlos Florêncio f5dc6e2322 fix: persist task create last-used selections (#1550)
* fix: persist task create last-used selections

Record final task-create selections server-side.

Make dialog restore wait for backend settings before localStorage fallback.

Update pinned-action verification tests and split dockview rendering for lint.

* fix: address task create PR feedback

* fix: resolve task create review follow-ups

* test: cover task create service recording

* fix: address task create review regressions

* fix: avoid recording generated fresh branches

* fix: skip repo-only last-used task records

* fix: make task create settings updates atomic

* fix: clear stale task create cache

* fix: clear synced task create overlay

* fix: address task create review feedback

* fix: queue cached repository autopick

* fix: preserve partial task create settings

* fix: replace task create queued overlay

* fix: clear branch when recording repository

* test: cover task create queued payload

* test: remove unused user service helper

---------

Co-authored-by: root <root@kandev.ts.net>
2026-06-30 02:35:21 +01:00

169 lines
5.6 KiB
TypeScript

import { renderHook, waitFor } from "@testing-library/react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { useRepositoryAutoSelectEffect } from "./task-create-dialog-repository-autopick";
import type { DialogFormState, TaskRepoRow } from "@/components/task-create-dialog-types";
import type { Repository } from "@/lib/types/http";
import { STORAGE_KEYS } from "@/lib/settings/constants";
import {
readQueuedTaskCreateLastUsedState,
resetTaskCreateLastUsedSync,
} from "./task-create-dialog-handlers";
beforeEach(() => {
localStorage.clear();
resetTaskCreateLastUsedSync({ clearQueued: true });
});
function makeRepository(id: string): Repository {
return {
id,
workspace_id: "ws-1",
name: "repo",
source_type: "local",
local_path: "/repo",
default_branch: "main",
created_at: new Date().toISOString(),
updated_at: new Date().toISOString(),
} as Repository;
}
function makeRepoAutoSelectFs(
rows: TaskRepoRow[],
setRepositories: DialogFormState["setRepositories"],
): DialogFormState {
return {
repositories: rows,
useRemote: false,
setRepositories,
} as unknown as DialogFormState;
}
describe("useRepositoryAutoSelectEffect loading gates", () => {
it("waits for store-backed settings before falling back to an empty row", async () => {
window.localStorage.removeItem(STORAGE_KEYS.LAST_REPOSITORY_ID);
const setRepositories = vi.fn();
const fs = makeRepoAutoSelectFs([], setRepositories);
const { rerender } = renderHook(
({ loaded, lastUsedRepositoryId }) =>
useRepositoryAutoSelectEffect(
fs,
true,
"ws-1",
[makeRepository("repo-1"), makeRepository("repo-2")],
{
lastUsedRepositoryId,
userSettingsLoaded: loaded,
},
),
{ initialProps: { loaded: false, lastUsedRepositoryId: null as string | null } },
);
await new Promise((resolve) => setTimeout(resolve, 10));
expect(setRepositories).not.toHaveBeenCalled();
rerender({ loaded: true, lastUsedRepositoryId: "repo-2" });
await waitFor(() => expect(setRepositories).toHaveBeenCalled());
const updater = setRepositories.mock.calls[0]![0] as (prev: TaskRepoRow[]) => TaskRepoRow[];
expect(updater([])).toEqual([{ key: "row-0", repositoryId: "repo-2", branch: "" }]);
});
it("waits for store-backed settings before trusting a valid cached repository id", async () => {
window.localStorage.setItem(STORAGE_KEYS.LAST_REPOSITORY_ID, JSON.stringify("repo-1"));
const setRepositories = vi.fn();
const fs = makeRepoAutoSelectFs([], setRepositories);
renderHook(() =>
useRepositoryAutoSelectEffect(
fs,
true,
"ws-1",
[makeRepository("repo-1"), makeRepository("repo-2")],
{
lastUsedRepositoryId: null,
userSettingsLoaded: false,
},
),
);
await new Promise((resolve) => setTimeout(resolve, 10));
expect(setRepositories).not.toHaveBeenCalled();
expect(readQueuedTaskCreateLastUsedState()).toEqual({});
});
});
describe("useRepositoryAutoSelectEffect defaults", () => {
it("queues a consumed cached repository id until backend settings catch up", async () => {
window.localStorage.setItem(STORAGE_KEYS.LAST_REPOSITORY_ID, JSON.stringify("repo-1"));
const setRepositories = vi.fn();
const fs = makeRepoAutoSelectFs([], setRepositories);
renderHook(() =>
useRepositoryAutoSelectEffect(
fs,
true,
"ws-1",
[makeRepository("repo-1"), makeRepository("repo-2")],
{
lastUsedRepositoryId: null,
userSettingsLoaded: true,
},
),
);
await waitFor(() => expect(setRepositories).toHaveBeenCalled());
const updater = setRepositories.mock.calls[0]![0] as (prev: TaskRepoRow[]) => TaskRepoRow[];
expect(updater([])).toEqual([{ key: "row-0", repositoryId: "repo-1", branch: "" }]);
expect(readQueuedTaskCreateLastUsedState()).toMatchObject({
repositoryId: "repo-1",
branch: null,
});
});
it("fills an untouched placeholder row from store-backed settings when localStorage is not primed", async () => {
window.localStorage.removeItem(STORAGE_KEYS.LAST_REPOSITORY_ID);
const setRepositories = vi.fn();
const fs = makeRepoAutoSelectFs([{ key: "row-0", branch: "" }], setRepositories);
renderHook(() =>
useRepositoryAutoSelectEffect(
fs,
true,
"ws-1",
[makeRepository("repo-1"), makeRepository("repo-2")],
{ lastUsedRepositoryId: "repo-2" },
),
);
await waitFor(() => expect(setRepositories).toHaveBeenCalled());
const updater = setRepositories.mock.calls[0]![0] as (prev: TaskRepoRow[]) => TaskRepoRow[];
expect(updater([{ key: "row-0", branch: "" }])).toEqual([
{ key: "row-0", repositoryId: "repo-2", branch: "" },
]);
});
it("fills an empty repo row list from store-backed settings when localStorage is not primed", async () => {
window.localStorage.removeItem(STORAGE_KEYS.LAST_REPOSITORY_ID);
const setRepositories = vi.fn();
const fs = makeRepoAutoSelectFs([], setRepositories);
renderHook(() =>
useRepositoryAutoSelectEffect(
fs,
true,
"ws-1",
[makeRepository("repo-1"), makeRepository("repo-2")],
{ lastUsedRepositoryId: "repo-1" },
),
);
await waitFor(() => expect(setRepositories).toHaveBeenCalled());
const updater = setRepositories.mock.calls[0]![0] as (prev: TaskRepoRow[]) => TaskRepoRow[];
expect(updater([])).toEqual([{ key: "row-0", repositoryId: "repo-1", branch: "" }]);
});
});