Skip to content

πŸ™Œ OpenHands: AI-Driven Development

test: kill event search filter mutants (#17336)

aivong-openhands1c11f7a7d9ba
diff --git a/src/api/event-service/event-service.api.test.ts b/src/api/event-service/event-service.api.test.ts
index 6c74ba2721..9957c0cc6b 100644
--- a/src/api/event-service/event-service.api.test.ts
+++ b/src/api/event-service/event-service.api.test.ts
@@ -1,56 +1,409 @@
import { beforeEach, describe, expect, it, vi } from "vitest";
-const { callCloudProxyMock } = vi.hoisted(() => ({
+const {
+ buildHttpBaseUrlMock,
+ callCloudProxyMock,
+ conversationClientConstructorMock,
+ getActiveBackendMock,
+ getAgentServerClientOptionsMock,
+ getAgentServerHttpClientOptionsMock,
+ getEventCountMock,
+ remoteEventsListConstructorMock,
+ remoteSearchMock,
+ respondToConfirmationMock,
+} = vi.hoisted(() => ({
+ buildHttpBaseUrlMock: vi.fn(),
callCloudProxyMock: vi.fn(),
+ conversationClientConstructorMock: vi.fn(),
+ getActiveBackendMock: vi.fn(),
+ getAgentServerClientOptionsMock: vi.fn(),
+ getAgentServerHttpClientOptionsMock: vi.fn(),
+ getEventCountMock: vi.fn(),
+ remoteEventsListConstructorMock: vi.fn(),
+ remoteSearchMock: vi.fn(),
+ respondToConfirmationMock: vi.fn(),
}));
vi.mock("@openhands/typescript-client/clients", () => ({
- ConversationClient: class {},
+ ConversationClient: class {
+ constructor(options: unknown) {
+ conversationClientConstructorMock(options);
+ }
+
+ respondToConfirmation = respondToConfirmationMock;
+ getEventCount = getEventCountMock;
+ },
}));
vi.mock("@openhands/typescript-client/events/remote-events-list", () => ({
- RemoteEventsList: class {},
+ RemoteEventsList: class {
+ constructor(options: unknown, conversationId: string) {
+ remoteEventsListConstructorMock(options, conversationId);
+ }
+
+ search = remoteSearchMock;
+ },
+}));
+vi.mock("#/utils/websocket-url", () => ({
+ buildHttpBaseUrl: buildHttpBaseUrlMock,
}));
vi.mock("../backend-registry/active-store", () => ({
- getActiveBackend: () => ({ backend: { kind: "cloud" } }),
+ getActiveBackend: getActiveBackendMock,
}));
vi.mock("../cloud/proxy", () => ({ callCloudProxy: callCloudProxyMock }));
vi.mock("../agent-server-client-options", () => ({
- getAgentServerClientOptions: vi.fn(),
- getAgentServerHttpClientOptions: vi.fn(),
+ getAgentServerClientOptions: getAgentServerClientOptionsMock,
+ getAgentServerHttpClientOptions: getAgentServerHttpClientOptionsMock,
}));
import EventService from "./event-service.api";
-describe("EventService.searchEvents strict pagination", () => {
+const cloudBackend = {
+ id: "cloud-backend",
+ name: "Cloud",
+ host: "https://app.example.com",
+ apiKey: "cloud-api-key",
+ kind: "cloud",
+};
+
+const localBackend = {
+ id: "local-backend",
+ name: "Local",
+ host: "http://localhost:3000",
+ apiKey: "local-api-key",
+ kind: "local",
+};
+
+function useBackend(backend: typeof cloudBackend | typeof localBackend): void {
+ getActiveBackendMock.mockReturnValue({ backend, orgId: null });
+}
+
+describe("EventService", () => {
beforeEach(() => {
- callCloudProxyMock.mockReset();
+ vi.resetAllMocks();
+ useBackend(cloudBackend);
+ buildHttpBaseUrlMock.mockReturnValue("https://runtime.example.com/base");
+ getAgentServerClientOptionsMock.mockReturnValue({
+ host: "http://local-client.example.com",
+ apiKey: "client-key",
+ workingDir: "workspace/project",
+ });
+ getAgentServerHttpClientOptionsMock.mockReturnValue({
+ baseUrl: "http://local-http.example.com",
+ apiKey: "http-key",
+ timeout: 60_000,
+ });
+ });
+
+ describe("respondToConfirmation", () => {
+ it("routes cloud confirmations through the runtime proxy with session authentication", async () => {
+ const request = { accept: false, reason: "Needs human review" };
+ callCloudProxyMock.mockResolvedValue({ success: true });
+
+ await expect(
+ EventService.respondToConfirmation(
+ "conversation-cloud",
+ "wss://runtime.example.com/base/api/conversations/conversation-cloud",
+ request,
+ "session-key",
+ ),
+ ).resolves.toEqual({ success: true });
+
+ expect(buildHttpBaseUrlMock).toHaveBeenCalledWith(
+ "wss://runtime.example.com/base/api/conversations/conversation-cloud",
+ );
+ expect(callCloudProxyMock).toHaveBeenCalledWith({
+ backend: cloudBackend,
+ method: "POST",
+ hostOverride: "https://runtime.example.com/base",
+ path: "/api/conversations/conversation-cloud/events/respond_to_confirmation",
+ body: request,
+ authMode: "session-api-key",
+ sessionApiKey: "session-key",
+ });
+ expect(conversationClientConstructorMock).not.toHaveBeenCalled();
+ });
+
+ it("uses the typed conversation client for local confirmations", async () => {
+ useBackend(localBackend);
+ respondToConfirmationMock.mockResolvedValue({ success: false });
+
+ await expect(
+ EventService.respondToConfirmation(
+ "conversation-local",
+ "http://localhost:3000/api/conversations/conversation-local",
+ { accept: true },
+ ),
+ ).resolves.toEqual({ success: false });
+
+ expect(getAgentServerClientOptionsMock).toHaveBeenCalledWith({
+ conversationUrl:
+ "http://localhost:3000/api/conversations/conversation-local",
+ sessionApiKey: undefined,
+ });
+ expect(conversationClientConstructorMock).toHaveBeenCalledWith({
+ host: "http://local-client.example.com",
+ apiKey: "client-key",
+ workingDir: "workspace/project",
+ });
+ expect(respondToConfirmationMock).toHaveBeenCalledWith(
+ "conversation-local",
+ { accept: true },
+ );
+ expect(callCloudProxyMock).not.toHaveBeenCalled();
+ });
});
- it("rethrows unsupported cloud pagination for completeness-sensitive callers", async () => {
- const paginationError = new Error("pagination unsupported");
- callCloudProxyMock.mockRejectedValue(paginationError);
-
- await expect(
- EventService.searchEvents("conversation-1", null, null, {
- limit: 100,
- sortOrder: "TIMESTAMP_DESC",
- strictPagination: true,
- }),
- ).rejects.toBe(paginationError);
+ describe("getEventCount", () => {
+ it("gets the cloud count from the runtime proxy", async () => {
+ callCloudProxyMock.mockResolvedValue(17);
+
+ await expect(
+ EventService.getEventCount(
+ "conversation-cloud",
+ "https://runtime.example.com/api/conversations/conversation-cloud",
+ null,
+ ),
+ ).resolves.toBe(17);
+
+ expect(buildHttpBaseUrlMock).toHaveBeenCalledWith(
+ "https://runtime.example.com/api/conversations/conversation-cloud",
+ );
+ expect(callCloudProxyMock).toHaveBeenCalledWith({
+ backend: cloudBackend,
+ method: "GET",
+ hostOverride: "https://runtime.example.com/base",
+ path: "/api/conversations/conversation-cloud/events/count",
+ authMode: "session-api-key",
+ sessionApiKey: null,
+ });
+ expect(conversationClientConstructorMock).not.toHaveBeenCalled();
+ });
+
+ it("gets the local count from the typed conversation client", async () => {
+ useBackend(localBackend);
+ getEventCountMock.mockResolvedValue(8);
+
+ await expect(
+ EventService.getEventCount(
+ "conversation-local",
+ "http://localhost:3000/api/conversations/conversation-local",
+ "session-key",
+ ),
+ ).resolves.toBe(8);
+
+ expect(getAgentServerClientOptionsMock).toHaveBeenCalledWith({
+ conversationUrl:
+ "http://localhost:3000/api/conversations/conversation-local",
+ sessionApiKey: "session-key",
+ });
+ expect(conversationClientConstructorMock).toHaveBeenCalledWith({
+ host: "http://local-client.example.com",
+ apiKey: "client-key",
+ workingDir: "workspace/project",
+ });
+ expect(getEventCountMock).toHaveBeenCalledWith("conversation-local");
+ expect(callCloudProxyMock).not.toHaveBeenCalled();
+ });
});
- it("retains the empty-page fallback for ordinary chat pagination", async () => {
- callCloudProxyMock.mockRejectedValue(new Error("pagination unsupported"));
- const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+ describe("searchEvents", () => {
+ it("caps cloud limits and forwards every supported history filter", async () => {
+ const event = { id: "event-1" };
+ callCloudProxyMock.mockResolvedValue({
+ items: [event],
+ next_page_id: "page-2",
+ });
+
+ await expect(
+ EventService.searchEvents("conversation-cloud", null, null, {
+ limit: 250,
+ pageId: "page-1",
+ sortOrder: "TIMESTAMP_DESC",
+ timestampGte: "2026-07-12T00:00:00.000Z",
+ timestampLt: "2026-07-13T00:00:00.000Z",
+ }),
+ ).resolves.toEqual({ items: [event], next_page_id: "page-2" });
+
+ expect(callCloudProxyMock).toHaveBeenCalledWith({
+ backend: cloudBackend,
+ method: "GET",
+ path: "/api/v1/conversation/conversation-cloud/events/search?limit=100&sort_order=TIMESTAMP_DESC&page_id=page-1&timestamp__gte=2026-07-12T00%3A00%3A00.000Z&timestamp__lt=2026-07-13T00%3A00%3A00.000Z",
+ });
+ });
+
+ it("uses default cloud options and normalizes a missing response", async () => {
+ callCloudProxyMock.mockResolvedValue(undefined);
+
+ await expect(
+ EventService.searchEvents("conversation-cloud"),
+ ).resolves.toEqual({ items: [], next_page_id: null });
+
+ expect(callCloudProxyMock).toHaveBeenCalledWith({
+ backend: cloudBackend,
+ method: "GET",
+ path: "/api/v1/conversation/conversation-cloud/events/search?limit=100",
+ });
+ });
+
+ it("preserves zero as an explicit cloud limit", async () => {
+ callCloudProxyMock.mockResolvedValue({});
+
+ await expect(
+ EventService.searchEvents("conversation-cloud", null, null, {
+ limit: 0,
+ }),
+ ).resolves.toEqual({ items: [], next_page_id: null });
+
+ expect(callCloudProxyMock).toHaveBeenCalledWith({
+ backend: cloudBackend,
+ method: "GET",
+ path: "/api/v1/conversation/conversation-cloud/events/search?limit=0",
+ });
+ });
+
+ it("rethrows cloud failures when no pagination filter was requested", async () => {
+ const searchError = new Error("cloud unavailable");
+ callCloudProxyMock.mockRejectedValue(searchError);
+
+ await expect(
+ EventService.searchEvents("conversation-cloud", null, null, {
+ limit: 25,
+ }),
+ ).rejects.toBe(searchError);
+ });
+
+ it("rethrows filtered cloud failures for completeness-sensitive callers", async () => {
+ const paginationError = new Error("pagination unsupported");
+ callCloudProxyMock.mockRejectedValue(paginationError);
+
+ await expect(
+ EventService.searchEvents("conversation-cloud", null, null, {
+ pageId: "page-2",
+ strictPagination: true,
+ }),
+ ).rejects.toBe(paginationError);
+ });
+
+ it("retains the empty-page fallback for ordinary cloud pagination", async () => {
+ callCloudProxyMock.mockRejectedValue(new Error("pagination unsupported"));
+ const warn = vi
+ .spyOn(console, "warn")
+ .mockImplementation(() => undefined);
+
+ await expect(
+ EventService.searchEvents("conversation-cloud", null, null, {
+ timestampLt: "2026-07-10T12:34:56.000Z",
+ }),
+ ).resolves.toEqual({ items: [], next_page_id: null });
+
+ expect(warn).toHaveBeenCalledWith(
+ "[EventService] Cloud backend doesn't support pagination filters. " +
+ "Falling back to initial load only. " +
+ "Server needs OpenHands/OpenHands#14399.",
+ );
+ warn.mockRestore();
+ });
+
+ it("treats a sort-only cloud failure as unsupported filtered pagination", async () => {
+ callCloudProxyMock.mockRejectedValue(new Error("pagination unsupported"));
+ const warn = vi
+ .spyOn(console, "warn")
+ .mockImplementation(() => undefined);
+
+ await expect(
+ EventService.searchEvents("conversation-cloud", null, null, {
+ sortOrder: "TIMESTAMP_DESC",
+ }),
+ ).resolves.toEqual({ items: [], next_page_id: null });
+
+ expect(callCloudProxyMock).toHaveBeenCalledWith({
+ backend: cloudBackend,
+ method: "GET",
+ path: "/api/v1/conversation/conversation-cloud/events/search?limit=100&sort_order=TIMESTAMP_DESC",
+ });
+ expect(warn).toHaveBeenCalledOnce();
+ warn.mockRestore();
+ });
+
+ it("recognizes a lower timestamp bound as a cloud pagination filter", async () => {
+ callCloudProxyMock.mockResolvedValue({
+ items: [],
+ next_page_id: null,
+ });
+
+ await EventService.searchEvents("conversation-cloud", null, null, {
+ timestampGte: "2026-07-10T12:34:56.000Z",
+ });
+
+ expect(callCloudProxyMock).toHaveBeenCalledWith({
+ backend: cloudBackend,
+ method: "GET",
+ path: "/api/v1/conversation/conversation-cloud/events/search?limit=100&timestamp__gte=2026-07-10T12%3A34%3A56.000Z",
+ });
+ });
+
+ it("passes all local filters to the remote events list", async () => {
+ useBackend(localBackend);
+ const event = { id: "event-local" };
+ remoteSearchMock.mockResolvedValue({
+ items: [event],
+ next_page_id: "local-page-2",
+ });
+
+ await expect(
+ EventService.searchEvents(
+ "conversation-local",
+ "http://localhost:3000/api/conversations/conversation-local",
+ "session-key",
+ {
+ limit: 40,
+ pageId: "local-page-1",
+ sortOrder: "TIMESTAMP",
+ timestampGte: "2026-07-11T00:00:00.000Z",
+ timestampLt: "2026-07-12T00:00:00.000Z",
+ },
+ ),
+ ).resolves.toEqual({
+ items: [event],
+ next_page_id: "local-page-2",
+ });
+
+ expect(getAgentServerHttpClientOptionsMock).toHaveBeenCalledWith({
+ conversationUrl:
+ "http://localhost:3000/api/conversations/conversation-local",
+ sessionApiKey: "session-key",
+ });
+ expect(remoteEventsListConstructorMock).toHaveBeenCalledWith(
+ {
+ baseUrl: "http://local-http.example.com",
+ apiKey: "http-key",
+ timeout: 60_000,
+ },
+ "conversation-local",
+ );
+ expect(remoteSearchMock).toHaveBeenCalledWith({
+ limit: 40,
+ page_id: "local-page-1",
+ sort_order: "TIMESTAMP",
+ timestamp__gte: "2026-07-11T00:00:00.000Z",
+ timestamp__lt: "2026-07-12T00:00:00.000Z",
+ });
+ expect(callCloudProxyMock).not.toHaveBeenCalled();
+ });
+
+ it("uses default local options and normalizes a missing page", async () => {
+ useBackend(localBackend);
+ remoteSearchMock.mockResolvedValue(undefined);
- await expect(
- EventService.searchEvents("conversation-1", null, null, {
- limit: 50,
- timestampLt: "2026-07-10T12:34:56.000Z",
- }),
- ).resolves.toEqual({ items: [], next_page_id: null });
+ await expect(
+ EventService.searchEvents("conversation-local"),
+ ).resolves.toEqual({ items: [], next_page_id: null });
- expect(warn).toHaveBeenCalledOnce();
- warn.mockRestore();
+ expect(getAgentServerHttpClientOptionsMock).toHaveBeenCalledWith({
+ conversationUrl: undefined,
+ sessionApiKey: undefined,
+ });
+ expect(remoteSearchMock).toHaveBeenCalledWith({ limit: 100 });
+ });
});
});