João Salavisa
7b5b3f329d
* feat: add Linear integration
Mirrors the existing Jira integration so a workspace can connect to Linear
with a personal API key, browse and search issues, and start a Kandev task
from any issue. Backend uses Linear's GraphQL API with a workspace-scoped
config + secret store and a 90s auth-health poller; the frontend adds a
settings page, an issue dialog with state transitions, link/import buttons
in the task UI, and a paginated /linear browse page with a Start task flow.
* fix(linear): address PR review feedback
- Route httpListStates through Service.ListStates instead of clientFor
- Extract repeated workspace_id required string into a constant
- Log GetConfig errors during credential resolution instead of dropping them
- Clear popover error state on close in import + link buttons
- Pick the first workflow with steps in the quick task launcher (don't hard-pin to workflows[0])
- Reset useLinearEnabled state on workspace change via tag-based pattern
- Add cursor-pointer to anchor + Link elements per project convention
- Add tests: handlers_test.go, linear-api.test.ts, use-linear-enabled.test.ts, linear-issue-common.test.tsx
- Document internal/jira and internal/linear in CLAUDE.md/AGENTS.md
* fix(linear): address second-round PR review feedback
- Round Linear's fractional state position instead of truncating it via
int(math.Round(s.Position)) so adjacent fractional positions don't collapse
- Force LinearSettings to remount on workspace change with key={id} so the
previous workspace's config / form / testResult / teams cannot bleed into
the next workspace before the new fetches settle
- Broaden the legacy-value useLinearEnabled test to cover "true", "1", "yes",
and "legacy" so a regression to strict value === "true" would fail
* fix(linear): address third-round PR review feedback
- Propagate context.Canceled / context.DeadlineExceeded from ListStates in
GetIssue instead of swallowing them — a caller cancellation must not return
a partial-success response
- Drop the one-off contains() test helper in handlers_test.go and use
strings.Contains directly so the assertion is self-documenting
- Add getLinearIssue URL-shape test that locks identifier-as-path-segment
vs workspaceId-as-query-param so accidentally swapping them would fail
* test(linear): extract repeated literals in linear-api.test.ts
Pulls "ws-1", the API base URL, and the auth-method literal into module-
level constants so the assertions read as the route shape they care about
and the duplicate-strings ESLint rule (currently warn, threshold 4)
stays quiet as the file grows.
---------
Co-authored-by: Kandev Agent <agent@kandev.dev>
88 lines
3.4 KiB
TypeScript
88 lines
3.4 KiB
TypeScript
import { describe, it, expect, beforeEach, afterEach } from "vitest";
|
|
import { act, renderHook, waitFor } from "@testing-library/react";
|
|
import { useLinearEnabled } from "./use-linear-enabled";
|
|
|
|
const STORAGE_KEY = (workspaceId: string) => `kandev:linear:enabled:${workspaceId}:v1`;
|
|
|
|
describe("useLinearEnabled", () => {
|
|
beforeEach(() => {
|
|
window.localStorage.clear();
|
|
});
|
|
afterEach(() => {
|
|
window.localStorage.clear();
|
|
});
|
|
|
|
it("defaults to enabled=true when no localStorage entry exists", async () => {
|
|
const { result } = renderHook(() => useLinearEnabled("ws-1"));
|
|
await waitFor(() => expect(result.current.loaded).toBe(true));
|
|
expect(result.current.enabled).toBe(true);
|
|
});
|
|
|
|
it('reads enabled=false when stored as the literal string "false"', async () => {
|
|
window.localStorage.setItem(STORAGE_KEY("ws-1"), "false");
|
|
const { result } = renderHook(() => useLinearEnabled("ws-1"));
|
|
await waitFor(() => expect(result.current.loaded).toBe(true));
|
|
expect(result.current.enabled).toBe(false);
|
|
});
|
|
|
|
it.each(["true", "1", "yes", "legacy"])(
|
|
'treats persisted value %p as enabled — only the literal "false" disables',
|
|
async (storedValue) => {
|
|
window.localStorage.setItem(STORAGE_KEY("ws-1"), storedValue);
|
|
const { result } = renderHook(() => useLinearEnabled("ws-1"));
|
|
await waitFor(() => expect(result.current.loaded).toBe(true));
|
|
expect(result.current.enabled).toBe(true);
|
|
},
|
|
);
|
|
|
|
it("setEnabled persists to localStorage and updates state", async () => {
|
|
const { result } = renderHook(() => useLinearEnabled("ws-1"));
|
|
await waitFor(() => expect(result.current.loaded).toBe(true));
|
|
|
|
act(() => result.current.setEnabled(false));
|
|
|
|
expect(result.current.enabled).toBe(false);
|
|
expect(window.localStorage.getItem(STORAGE_KEY("ws-1"))).toBe("false");
|
|
});
|
|
|
|
it("ignores writes when no workspaceId is provided", async () => {
|
|
const { result } = renderHook(() => useLinearEnabled(undefined));
|
|
await waitFor(() => expect(result.current.loaded).toBe(true));
|
|
|
|
act(() => result.current.setEnabled(false));
|
|
|
|
// No workspace key means no persisted state and no in-memory flip — the
|
|
// setter is a no-op rather than silently writing under a sentinel key.
|
|
expect(result.current.enabled).toBe(true);
|
|
expect(window.localStorage.length).toBe(0);
|
|
});
|
|
|
|
it("re-runs the read when workspaceId changes", async () => {
|
|
window.localStorage.setItem(STORAGE_KEY("ws-1"), "false");
|
|
window.localStorage.setItem(STORAGE_KEY("ws-2"), "true");
|
|
|
|
const { result, rerender } = renderHook(({ id }) => useLinearEnabled(id), {
|
|
initialProps: { id: "ws-1" as string | undefined },
|
|
});
|
|
await waitFor(() => expect(result.current.loaded).toBe(true));
|
|
expect(result.current.enabled).toBe(false);
|
|
|
|
rerender({ id: "ws-2" });
|
|
await waitFor(() => expect(result.current.loaded).toBe(true));
|
|
expect(result.current.enabled).toBe(true);
|
|
});
|
|
|
|
it("propagates updates dispatched via the kandev:linear:enabled-changed event", async () => {
|
|
const { result } = renderHook(() => useLinearEnabled("ws-1"));
|
|
await waitFor(() => expect(result.current.loaded).toBe(true));
|
|
expect(result.current.enabled).toBe(true);
|
|
|
|
act(() => {
|
|
window.localStorage.setItem(STORAGE_KEY("ws-1"), "false");
|
|
window.dispatchEvent(new Event("kandev:linear:enabled-changed"));
|
|
});
|
|
|
|
await waitFor(() => expect(result.current.enabled).toBe(false));
|
|
});
|
|
});
|