Skip to content

πŸ™Œ OpenHands: AI-Driven Development

test: cover unified git change ordering (#17307)

aivong-openhandsd75bfec9e6e9
diff --git a/__tests__/hooks/query/git-changes-ordering.test.tsx b/__tests__/hooks/query/git-changes-ordering.test.tsx
new file mode 100644
index 0000000000..a7e7da0cda
--- /dev/null
+++ b/__tests__/hooks/query/git-changes-ordering.test.tsx
@@ -0,0 +1,424 @@
+import React from "react";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { describe, expect, it, vi } from "vitest";
+import AgentServerGitService from "#/api/git-service/agent-server-git-service.api";
+import type { GitChange } from "#/api/open-hands.types";
+import type { AppConversation } from "#/api/conversation-service/agent-server-conversation-service.types";
+import { useUnifiedGetGitChanges } from "#/hooks/query/use-unified-get-git-changes";
+
+const mocks = vi.hoisted(() => ({
+ conversationId: "conversation-1" as string | undefined,
+ conversation: undefined as AppConversation | undefined,
+ runtimeIsReady: true,
+}));
+
+vi.mock("#/hooks/use-conversation-id", () => ({
+ useConversationId: () => ({ conversationId: mocks.conversationId }),
+}));
+
+vi.mock("#/hooks/query/use-active-conversation", () => ({
+ useActiveConversation: () => ({ data: mocks.conversation }),
+}));
+
+vi.mock("#/hooks/use-runtime-is-ready", () => ({
+ useRuntimeIsReady: () => mocks.runtimeIsReady,
+}));
+
+const getGitChanges = vi.spyOn(AgentServerGitService, "getGitChanges");
+
+const makeConversation = (
+ overrides: Partial<AppConversation> = {},
+): AppConversation => ({
+ id: "conversation-1",
+ created_by_user_id: "user-1",
+ selected_repository: "OpenHands/agent-canvas",
+ selected_branch: "main",
+ git_provider: "github",
+ title: "Mutation-tested changes",
+ trigger: "gui",
+ pr_number: [],
+ llm_model: null,
+ metrics: null,
+ created_at: "2026-07-13T00:00:00.000Z",
+ updated_at: "2026-07-13T00:00:00.000Z",
+ execution_status: null,
+ conversation_url: "https://runtime.example.test/conversations/conversation-1",
+ session_api_key: "session-key",
+ sandbox_id: "sandbox-1",
+ workspace: { working_dir: "/workspace/agent-canvas" },
+ sub_conversation_ids: [],
+ ...overrides,
+});
+
+const makeChange = (
+ path: string,
+ status: GitChange["status"] = "M",
+): GitChange => ({ path, status });
+
+function makeDeferred<T>() {
+ const resolver = { current: (_value: T) => {} };
+ const promise = new Promise<T>((resolve) => {
+ resolver.current = resolve;
+ });
+
+ return {
+ promise,
+ resolve: (value: T) => resolver.current(value),
+ };
+}
+
+function prepareHook(
+ overrides: {
+ conversationId?: string | undefined;
+ conversation?: AppConversation | undefined;
+ runtimeIsReady?: boolean;
+ } = {},
+) {
+ getGitChanges.mockReset();
+ mocks.conversationId = Object.hasOwn(overrides, "conversationId")
+ ? overrides.conversationId
+ : "conversation-1";
+ mocks.conversation = Object.hasOwn(overrides, "conversation")
+ ? overrides.conversation
+ : makeConversation();
+ mocks.runtimeIsReady = overrides.runtimeIsReady ?? true;
+
+ const queryClient = new QueryClient({
+ defaultOptions: {
+ queries: {
+ retry: false,
+ gcTime: Number.POSITIVE_INFINITY,
+ },
+ },
+ });
+
+ const wrapper = ({ children }: { children: React.ReactNode }) => (
+ <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+ );
+
+ return { queryClient, wrapper };
+}
+
+describe("git change loading and ordering", () => {
+ it("loads the current workspace changes with runtime credentials", async () => {
+ const changes = [
+ makeChange("src/new-file.ts", "A"),
+ makeChange("src/existing.ts"),
+ ];
+ const { wrapper } = prepareHook();
+ getGitChanges.mockResolvedValue(changes);
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+ expect(result.current).toMatchObject({
+ data: changes,
+ isLoading: false,
+ isFetching: false,
+ isSuccess: true,
+ isError: false,
+ error: null,
+ });
+ expect(result.current.refetch).toEqual(expect.any(Function));
+ expect(getGitChanges).toHaveBeenCalledOnce();
+ expect(getGitChanges).toHaveBeenCalledWith(
+ "conversation-1",
+ "https://runtime.example.test/conversations/conversation-1",
+ "session-key",
+ "/workspace/agent-canvas",
+ );
+ });
+
+ it("derives the git path from the selected repository when the workspace is blank", async () => {
+ const { wrapper } = prepareHook({
+ conversation: makeConversation({
+ selected_repository: "OpenHands/software-agent-sdk",
+ workspace: { working_dir: " " },
+ }),
+ });
+ getGitChanges.mockResolvedValue([]);
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+ expect(getGitChanges).toHaveBeenCalledWith(
+ "conversation-1",
+ expect.any(String),
+ "session-key",
+ "workspace/project/software-agent-sdk",
+ );
+ expect(result.current.data).toEqual([]);
+ });
+
+ it("uses the default git path while conversation metadata is still unavailable", async () => {
+ const { wrapper } = prepareHook({ conversation: undefined });
+ getGitChanges.mockResolvedValue([makeChange("README.md")]);
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+ expect(getGitChanges).toHaveBeenCalledWith(
+ "conversation-1",
+ undefined,
+ undefined,
+ "workspace/project",
+ );
+ });
+
+ it("uses the selected repository when its workspace has no working directory", async () => {
+ const { wrapper } = prepareHook({
+ conversation: makeConversation({
+ selected_repository: "OpenHands/openhands",
+ workspace: { working_dir: null },
+ }),
+ });
+ getGitChanges.mockResolvedValue([]);
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+ expect(getGitChanges).toHaveBeenCalledWith(
+ "conversation-1",
+ expect.any(String),
+ "session-key",
+ "workspace/project/openhands",
+ );
+ });
+
+ it("does not contact the backend until the runtime is ready", async () => {
+ const { wrapper } = prepareHook({ runtimeIsReady: false });
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+
+ await act(async () => {
+ await Promise.resolve();
+ });
+ expect(getGitChanges).not.toHaveBeenCalled();
+ expect(result.current).toMatchObject({
+ data: [],
+ isLoading: false,
+ isFetching: false,
+ isSuccess: false,
+ isError: false,
+ });
+ });
+
+ it("reports a clear error if a disabled query is manually run without a conversation id", async () => {
+ const { wrapper } = prepareHook({ conversationId: undefined });
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+
+ await act(async () => {
+ await result.current.refetch();
+ });
+ await waitFor(() => expect(result.current.isError).toBe(true));
+ expect(result.current.error).toEqual(new Error("No conversation ID"));
+ expect(getGitChanges).not.toHaveBeenCalled();
+ });
+
+ it("puts newly discovered files first and removes files absent from a refresh", async () => {
+ const originalChanges = [
+ makeChange("src/removed.ts", "D"),
+ makeChange("src/kept.ts"),
+ ];
+ const refreshedChanges = [
+ makeChange("src/kept.ts"),
+ makeChange("src/new.ts", "A"),
+ ];
+ const { wrapper } = prepareHook();
+ getGitChanges
+ .mockResolvedValueOnce(originalChanges)
+ .mockResolvedValueOnce(refreshedChanges);
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+ await waitFor(() => expect(result.current.data).toEqual(originalChanges));
+
+ await act(async () => {
+ await result.current.refetch();
+ });
+
+ await waitFor(() =>
+ expect(result.current.data).toEqual([
+ makeChange("src/new.ts", "A"),
+ makeChange("src/kept.ts"),
+ ]),
+ );
+ expect(getGitChanges).toHaveBeenCalledTimes(2);
+ });
+
+ it("ignores a refreshed payload when the backend returns the same array reference", async () => {
+ const sharedChanges = [makeChange("src/original.ts")];
+ const refresh = makeDeferred<GitChange[]>();
+ const { wrapper } = prepareHook();
+ getGitChanges
+ .mockResolvedValueOnce(sharedChanges)
+ .mockReturnValueOnce(refresh.promise);
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+ await waitFor(() => expect(result.current.data).toEqual(sharedChanges));
+
+ sharedChanges.push(makeChange("src/mutated-in-place.ts", "A"));
+ act(() => {
+ void result.current.refetch();
+ });
+ await waitFor(() => expect(result.current.isFetching).toBe(true));
+ await act(async () => {
+ refresh.resolve(sharedChanges);
+ });
+ await waitFor(() => expect(result.current.isFetching).toBe(false));
+
+ expect(getGitChanges).toHaveBeenCalledTimes(2);
+ expect(result.current.data).toEqual([makeChange("src/original.ts")]);
+ });
+
+ it("normalizes a single change returned by a legacy backend", async () => {
+ const singleChange = makeChange("legacy.txt", "U");
+ const { wrapper } = prepareHook();
+ getGitChanges.mockResolvedValue(
+ singleChange as unknown as Awaited<
+ ReturnType<typeof AgentServerGitService.getGitChanges>
+ >,
+ );
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+ expect(result.current.data).toEqual([singleChange]);
+ });
+
+ it("surfaces backend failures without retrying", async () => {
+ const backendError = new Error("runtime unavailable");
+ const { queryClient, wrapper } = prepareHook();
+ getGitChanges.mockRejectedValue(backendError);
+
+ const { result } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+
+ await waitFor(() => expect(result.current.isError).toBe(true));
+ expect(result.current.error).toBe(backendError);
+ expect(result.current.data).toEqual([]);
+ expect(getGitChanges).toHaveBeenCalledOnce();
+
+ const query = queryClient.getQueryCache().find({
+ queryKey: [
+ "file_changes",
+ "conversation-1",
+ "https://runtime.example.test/conversations/conversation-1",
+ "session-key",
+ "/workspace/agent-canvas",
+ ],
+ });
+ expect(query?.options).toMatchObject({
+ retry: false,
+ staleTime: 300_000,
+ gcTime: 900_000,
+ refetchOnMount: "always",
+ meta: { disableToast: true },
+ });
+ });
+
+ it("keeps query caches isolated across every runtime identity field", async () => {
+ const { wrapper } = prepareHook();
+ getGitChanges.mockImplementation(async () => [
+ makeChange(`response-${getGitChanges.mock.calls.length}.txt`),
+ ]);
+
+ const { rerender } = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+ await waitFor(() => expect(getGitChanges).toHaveBeenCalledTimes(1));
+
+ mocks.conversationId = "conversation-2";
+ rerender();
+ await waitFor(() => expect(getGitChanges).toHaveBeenCalledTimes(2));
+
+ mocks.conversation = makeConversation({
+ conversation_url: "https://runtime-2.example.test/conversations/2",
+ });
+ rerender();
+ await waitFor(() => expect(getGitChanges).toHaveBeenCalledTimes(3));
+
+ mocks.conversation = makeConversation({ session_api_key: "session-key-2" });
+ rerender();
+ await waitFor(() => expect(getGitChanges).toHaveBeenCalledTimes(4));
+
+ mocks.conversation = makeConversation({
+ workspace: { working_dir: "/workspace/other" },
+ });
+ rerender();
+ await waitFor(() => expect(getGitChanges).toHaveBeenCalledTimes(5));
+
+ mocks.conversation = makeConversation({
+ selected_repository: "OpenHands/another-repository",
+ workspace: null,
+ });
+ rerender();
+ await waitFor(() => expect(getGitChanges).toHaveBeenCalledTimes(6));
+ });
+
+ it("refetches on remount even while the cached changes are fresh", async () => {
+ const { queryClient, wrapper } = prepareHook();
+ const refresh = makeDeferred<GitChange[]>();
+ getGitChanges
+ .mockResolvedValueOnce([makeChange("cached.ts")])
+ .mockReturnValueOnce(refresh.promise);
+
+ const firstRender = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+ await waitFor(() => expect(getGitChanges).toHaveBeenCalledOnce());
+ await waitFor(() =>
+ expect(firstRender.result.current.data).toEqual([
+ makeChange("cached.ts"),
+ ]),
+ );
+ firstRender.unmount();
+
+ const secondRender = renderHook(() => useUnifiedGetGitChanges(), {
+ wrapper,
+ });
+ await waitFor(() => expect(getGitChanges).toHaveBeenCalledTimes(2));
+ await waitFor(() =>
+ expect(secondRender.result.current.isFetching).toBe(true),
+ );
+ expect(secondRender.result.current.data).toEqual([]);
+
+ await act(async () => {
+ refresh.resolve([makeChange("refreshed.ts")]);
+ });
+ await waitFor(() =>
+ expect(secondRender.result.current.data).toEqual([
+ makeChange("refreshed.ts"),
+ ]),
+ );
+ expect(
+ queryClient.getQueryState([
+ "file_changes",
+ "conversation-1",
+ "https://runtime.example.test/conversations/conversation-1",
+ "session-key",
+ "/workspace/agent-canvas",
+ ])?.status,
+ ).toBe("success");
+ });
+});