Skip to content

πŸ™Œ OpenHands: AI-Driven Development

test: cover service routing and repository queries (#17309)

aivong-openhandsd3faa02b608b
diff --git a/__tests__/api/agent-profiles-service.test.ts b/__tests__/api/agent-profiles-service.test.ts
new file mode 100644
index 0000000000..d5f1b8697e
--- /dev/null
+++ b/__tests__/api/agent-profiles-service.test.ts
@@ -0,0 +1,146 @@
+import { describe, expect, it, vi } from "vitest";
+import AgentProfilesService from "#/api/agent-profiles-service/agent-profiles-service.api";
+
+const mocks = vi.hoisted(() => ({
+ kind: "local" as "local" | "cloud",
+ list: vi.fn(),
+ get: vi.fn(),
+ save: vi.fn(),
+ remove: vi.fn(),
+ rename: vi.fn(),
+ activate: vi.fn(),
+ cloudList: vi.fn(),
+ cloudGet: vi.fn(),
+ cloudSave: vi.fn(),
+ cloudRemove: vi.fn(),
+ cloudRename: vi.fn(),
+ cloudActivate: vi.fn(),
+ Client: vi.fn(),
+ clientOptions: vi.fn(),
+}));
+
+vi.mock("#/api/backend-registry/active-store", () => ({
+ getActiveBackend: () => ({ backend: { kind: mocks.kind } }),
+}));
+
+vi.mock("#/api/agent-server-client-options", () => ({
+ getAgentServerClientOptions: mocks.clientOptions,
+}));
+
+vi.mock("@openhands/typescript-client/clients", () => ({
+ AgentProfilesClient: mocks.Client,
+}));
+
+vi.mock("#/api/cloud/agent-profiles-service.api", () => ({
+ listCloudAgentProfiles: mocks.cloudList,
+ getCloudAgentProfile: mocks.cloudGet,
+ saveCloudAgentProfile: mocks.cloudSave,
+ deleteCloudAgentProfile: mocks.cloudRemove,
+ renameCloudAgentProfile: mocks.cloudRename,
+ activateCloudAgentProfile: mocks.cloudActivate,
+}));
+
+const setupMocks = () => {
+ vi.clearAllMocks();
+ mocks.kind = "local";
+ mocks.clientOptions.mockReturnValue({ host: "http://localhost" });
+ mocks.Client.mockImplementation(function AgentProfilesClientMock() {
+ return {
+ listAgentProfiles: mocks.list,
+ getAgentProfile: mocks.get,
+ saveAgentProfile: mocks.save,
+ deleteAgentProfile: mocks.remove,
+ renameAgentProfile: mocks.rename,
+ activateAgentProfile: mocks.activate,
+ };
+ });
+ for (const [mock, source] of [
+ [mocks.list, "local-list"],
+ [mocks.get, "local-get"],
+ [mocks.save, "local-save"],
+ [mocks.remove, "local-remove"],
+ [mocks.rename, "local-rename"],
+ [mocks.activate, "local-activate"],
+ [mocks.cloudList, "cloud-list"],
+ [mocks.cloudGet, "cloud-get"],
+ [mocks.cloudSave, "cloud-save"],
+ [mocks.cloudRemove, "cloud-remove"],
+ [mocks.cloudRename, "cloud-rename"],
+ [mocks.cloudActivate, "cloud-activate"],
+ ] as const) {
+ mock.mockResolvedValue({ source });
+ }
+};
+
+describe("AgentProfilesService", () => {
+ it("exports the seeded default profile name", async () => {
+ vi.resetModules();
+ const { WELL_KNOWN_DEFAULT_AGENT_PROFILE_NAME } = await import(
+ "#/api/agent-profiles-service/agent-profiles-service.api"
+ );
+ expect(WELL_KNOWN_DEFAULT_AGENT_PROFILE_NAME).toBe("default");
+ });
+
+ it("routes every operation through a fresh local SDK client", async () => {
+ setupMocks();
+ const profile = { agent: "CodeActAgent" } as never;
+ const results = await Promise.all([
+ AgentProfilesService.listProfiles(),
+ AgentProfilesService.getProfile("default", "encrypted"),
+ AgentProfilesService.getProfile("plain"),
+ AgentProfilesService.saveProfile("default", profile),
+ AgentProfilesService.deleteProfile("old"),
+ AgentProfilesService.renameProfile("old", "new"),
+ AgentProfilesService.activateProfile("profile-id"),
+ ]);
+
+ expect(mocks.Client).toHaveBeenCalledTimes(7);
+ expect(results).toEqual([
+ { source: "local-list" },
+ { source: "local-get" },
+ { source: "local-get" },
+ { source: "local-save" },
+ { source: "local-remove" },
+ { source: "local-rename" },
+ { source: "local-activate" },
+ ]);
+ expect(mocks.get).toHaveBeenNthCalledWith(1, "default", {
+ exposeSecrets: "encrypted",
+ });
+ expect(mocks.get).toHaveBeenNthCalledWith(2, "plain", {});
+ expect(mocks.save).toHaveBeenCalledWith("default", profile);
+ expect(mocks.remove).toHaveBeenCalledWith("old");
+ expect(mocks.rename).toHaveBeenCalledWith("old", "new");
+ expect(mocks.activate).toHaveBeenCalledWith("profile-id");
+ });
+
+ it("routes every operation to the cloud service", async () => {
+ setupMocks();
+ mocks.kind = "cloud";
+ const profile = { agent: "CodeActAgent" } as never;
+ const results = await Promise.all([
+ AgentProfilesService.listProfiles(),
+ AgentProfilesService.getProfile("default", "encrypted"),
+ AgentProfilesService.saveProfile("default", profile),
+ AgentProfilesService.deleteProfile("old"),
+ AgentProfilesService.renameProfile("old", "new"),
+ AgentProfilesService.activateProfile("profile-id"),
+ ]);
+
+ expect(mocks.cloudList).toHaveBeenCalledOnce();
+ expect(results).toEqual([
+ { source: "cloud-list" },
+ { source: "cloud-get" },
+ { source: "cloud-save" },
+ { source: "cloud-remove" },
+ { source: "cloud-rename" },
+ { source: "cloud-activate" },
+ ]);
+ expect(mocks.cloudGet).toHaveBeenCalledWith("default");
+ expect(mocks.cloudSave).toHaveBeenCalledWith("default", profile);
+ expect(mocks.cloudRemove).toHaveBeenCalledWith("old");
+ expect(mocks.cloudRename).toHaveBeenCalledWith("old", "new");
+ expect(mocks.cloudActivate).toHaveBeenCalledWith("profile-id");
+ expect(mocks.Client).not.toHaveBeenCalled();
+ });
+});
diff --git a/__tests__/hooks/query/use-git-repositories.test.ts b/__tests__/hooks/query/use-git-repositories.test.ts
new file mode 100644
index 0000000000..cf7fd77b21
--- /dev/null
+++ b/__tests__/hooks/query/use-git-repositories.test.ts
@@ -0,0 +1,286 @@
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import GitService from "#/api/git-service/git-service.api";
+import { useGitRepositories } from "#/hooks/query/use-git-repositories";
+import type { RepositoryPage } from "#/types/git";
+
+interface CapturedQueryConfig {
+ queryKey: unknown[];
+ queryFn(context: { pageParam: unknown }): Promise<RepositoryPage>;
+ getNextPageParam(
+ lastPage: RepositoryPage,
+ allPages: RepositoryPage[],
+ lastPageParam: unknown,
+ ): unknown;
+ initialPageParam: unknown;
+ enabled: boolean;
+ staleTime: number;
+ gcTime: number;
+ refetchOnWindowFocus: boolean;
+}
+
+const mocks = vi.hoisted(() => ({
+ providers: undefined as string[] | undefined,
+ installations: undefined as string[] | undefined,
+ backend: { id: "local", kind: "local" as "local" | "cloud" },
+ orgId: null as string | null,
+ queryConfig: null as CapturedQueryConfig | null,
+ repos: {
+ data: undefined as unknown,
+ isLoading: false,
+ isError: false,
+ hasNextPage: false,
+ isFetchingNextPage: false,
+ fetchNextPage: vi.fn(),
+ },
+}));
+
+vi.mock("@tanstack/react-query", () => ({
+ useInfiniteQuery: (config: CapturedQueryConfig) => {
+ mocks.queryConfig = config;
+ return mocks.repos;
+ },
+}));
+
+vi.mock("#/hooks/use-user-providers", () => ({
+ useUserProviders: () => ({ providers: mocks.providers }),
+}));
+
+vi.mock("#/hooks/query/use-app-installations", () => ({
+ useAppInstallations: () => ({
+ data:
+ mocks.installations === undefined
+ ? undefined
+ : { items: mocks.installations, next_page_id: null },
+ }),
+}));
+
+vi.mock("#/contexts/active-backend-context", () => ({
+ useActiveBackend: () => ({
+ backend: mocks.backend,
+ orgId: mocks.orgId,
+ }),
+}));
+
+function config(): CapturedQueryConfig {
+ if (!mocks.queryConfig) throw new Error("query config was not captured");
+ return mocks.queryConfig;
+}
+
+const emptyPage = (nextPageId: string | null = null): RepositoryPage => ({
+ items: [],
+ next_page_id: nextPageId,
+});
+
+describe("useGitRepositories", () => {
+ const setupMocks = () => {
+ if (vi.isMockFunction(GitService.retrieveUserGitRepositories)) {
+ vi.mocked(GitService.retrieveUserGitRepositories).mockRestore();
+ }
+ if (vi.isMockFunction(GitService.retrieveInstallationRepositories)) {
+ vi.mocked(GitService.retrieveInstallationRepositories).mockRestore();
+ }
+ vi.clearAllMocks();
+ mocks.providers = undefined;
+ mocks.installations = undefined;
+ mocks.backend = { id: "local", kind: "local" };
+ mocks.orgId = null;
+ mocks.queryConfig = null;
+ mocks.repos.data = undefined;
+ mocks.repos.isLoading = false;
+ mocks.repos.isError = false;
+ mocks.repos.hasNextPage = false;
+ mocks.repos.isFetchingNextPage = false;
+ mocks.repos.fetchNextPage.mockReset();
+ };
+
+ it("disables and rejects a query without a provider", async () => {
+ setupMocks();
+ const { result } = renderHook(() => useGitRepositories({ provider: null }));
+
+ expect(config()).toMatchObject({
+ queryKey: ["repositories", null, false, 30, "local", null],
+ initialPageParam: null,
+ enabled: false,
+ staleTime: 300000,
+ gcTime: 900000,
+ refetchOnWindowFocus: false,
+ });
+ await expect(config().queryFn({ pageParam: null })).rejects.toThrow(
+ "Provider is required",
+ );
+ expect(result.current).toMatchObject({
+ data: undefined,
+ isLoading: false,
+ isError: false,
+ hasNextPage: false,
+ isFetchingNextPage: false,
+ fetchNextPage: mocks.repos.fetchNextPage,
+ });
+ });
+
+ it("loads direct user repositories with default and explicit cursors", async () => {
+ setupMocks();
+ mocks.providers = ["github"];
+ mocks.installations = ["irrelevant-for-local-backends"];
+ mocks.orgId = "org-1";
+ const retrieve = vi
+ .spyOn(GitService, "retrieveUserGitRepositories")
+ .mockResolvedValue(emptyPage("next"));
+
+ renderHook(() => useGitRepositories({ provider: "github", pageSize: 12 }));
+
+ expect(config().queryKey).toEqual([
+ "repositories",
+ "github",
+ false,
+ 12,
+ "local",
+ "org-1",
+ ]);
+ expect(config().enabled).toBe(true);
+ expect(config().initialPageParam).toBeNull();
+ await expect(config().queryFn({ pageParam: null })).resolves.toEqual(
+ emptyPage("next"),
+ );
+ await config().queryFn({ pageParam: "cursor-2" });
+ expect(retrieve).toHaveBeenNthCalledWith(1, "github", undefined, 12);
+ expect(retrieve).toHaveBeenNthCalledWith(2, "github", "cursor-2", 12);
+ expect(config().getNextPageParam(emptyPage("next"), [], null)).toBe("next");
+ expect(config().getNextPageParam(emptyPage(), [], "next")).toBeNull();
+ });
+
+ it("loads and paginates installation repositories", async () => {
+ setupMocks();
+ mocks.providers = ["github"];
+ mocks.installations = ["installation-a", "installation-b"];
+ mocks.backend = { id: "cloud", kind: "cloud" };
+ const retrieve = vi
+ .spyOn(GitService, "retrieveInstallationRepositories")
+ .mockResolvedValue(emptyPage("page-2"));
+
+ renderHook(() => useGitRepositories({ provider: "github" }));
+
+ expect(config().queryKey).toEqual([
+ "repositories",
+ "github",
+ true,
+ 30,
+ "cloud",
+ null,
+ ["installation-a", "installation-b"],
+ ]);
+ expect(config().initialPageParam).toEqual({
+ installationIndex: 0,
+ pageId: null,
+ });
+ await config().queryFn({
+ pageParam: { installationIndex: 1, pageId: null },
+ });
+ await config().queryFn({
+ pageParam: { installationIndex: 0, pageId: "page-2" },
+ });
+ expect(retrieve).toHaveBeenNthCalledWith(
+ 1,
+ "github",
+ 1,
+ mocks.installations,
+ undefined,
+ 30,
+ );
+ expect(retrieve).toHaveBeenNthCalledWith(
+ 2,
+ "github",
+ 0,
+ mocks.installations,
+ "page-2",
+ 30,
+ );
+
+ expect(
+ config().getNextPageParam(emptyPage("next"), [], {
+ installationIndex: 0,
+ pageId: null,
+ }),
+ ).toEqual({ installationIndex: 0, pageId: "next" });
+ expect(
+ config().getNextPageParam(emptyPage(), [], {
+ installationIndex: 0,
+ pageId: "last",
+ }),
+ ).toEqual({ installationIndex: 1, pageId: null });
+ expect(
+ config().getNextPageParam(emptyPage(), [], {
+ installationIndex: 1,
+ pageId: null,
+ }),
+ ).toBeUndefined();
+ });
+
+ it("requires the installation list for installation-based providers", async () => {
+ setupMocks();
+ mocks.providers = ["bitbucket"];
+ mocks.installations = undefined;
+
+ renderHook(() => useGitRepositories({ provider: "bitbucket" }));
+
+ expect(config().queryKey.at(-1)).toEqual([]);
+ expect(config().enabled).toBe(false);
+ await expect(
+ config().queryFn({
+ pageParam: { installationIndex: 0, pageId: null },
+ }),
+ ).rejects.toThrow("Missing installation list");
+ });
+
+ it.each([
+ ["explicitly disabled", false, ["github"], ["installation"], false],
+ ["no connected providers", true, [], ["installation"], false],
+ ["empty installations", true, ["github"], [], false],
+ ["ready", true, ["github"], ["installation"], true],
+ ])(
+ "sets enabled=false when %s",
+ (_label, enabled, providers, installations, expected) => {
+ setupMocks();
+ mocks.backend = { id: "cloud", kind: "cloud" };
+ mocks.providers = providers;
+ mocks.installations = installations;
+
+ renderHook(() => useGitRepositories({ provider: "github", enabled }));
+
+ expect(config().enabled).toBe(expected);
+ },
+ );
+
+ it("stays disabled while connected providers are unresolved", () => {
+ setupMocks();
+ mocks.providers = undefined;
+
+ renderHook(() => useGitRepositories({ provider: "github" }));
+
+ expect(config().enabled).toBe(false);
+ });
+
+ it("loads more only when another page exists and no request is active", () => {
+ setupMocks();
+ mocks.providers = ["github"];
+ mocks.repos.hasNextPage = true;
+ const { result, rerender } = renderHook(() =>
+ useGitRepositories({ provider: "github" }),
+ );
+
+ act(() => result.current.onLoadMore());
+ expect(mocks.repos.fetchNextPage).toHaveBeenCalledOnce();
+
+ mocks.repos.isFetchingNextPage = true;
+ rerender();
+ act(() => result.current.onLoadMore());
+ expect(mocks.repos.fetchNextPage).toHaveBeenCalledOnce();
+
+ mocks.repos.hasNextPage = false;
+ mocks.repos.isFetchingNextPage = false;
+ rerender();
+ act(() => result.current.onLoadMore());
+ expect(mocks.repos.fetchNextPage).toHaveBeenCalledOnce();
+ });
+});