delete(svg): remove unused circle.svg file

- Deleted the circle.svg file from the public SVG assets as it is no longer needed in the project.
- This cleanup helps streamline the asset management and reduces unnecessary file clutter.

Author: tyler-dane

packages/web/src/public/svg/circle.svg

@@ -57,6 +57,7 @@ describe("useGcalSync", () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    jest.useFakeTimers();
     importingValue = false;
     awaitingValue = false;
     (useDispatch as jest.Mock).mockReturnValue(mockDispatch);
@@ -71,6 +72,10 @@ describe("useGcalSync", () => {
     });
   });
 
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
   it("sets up socket listeners", () => {
     renderHook(() => useGcalSync());
 
@@ -191,4 +196,203 @@ describe("useGcalSync", () => {
       );
     });
   });
+
+  describe("import flow interaction", () => {
+    it("shows spinner on import start and hides it on successful import end", () => {
+      // Capture socket handlers to simulate backend events
+      const handlers: Record<string, (...args: unknown[]) => void> = {};
+      (socket.on as jest.Mock).mockImplementation((event, handler) => {
+        handlers[event] = handler;
+      });
+
+      awaitingValue = true;
+      renderHook(() => useGcalSync());
+
+      // Verify handlers are registered
+      expect(handlers[IMPORT_GCAL_START]).toBeDefined();
+      expect(handlers[IMPORT_GCAL_END]).toBeDefined();
+
+      // Phase 1: Backend signals import start (spinner should appear)
+      handlers[IMPORT_GCAL_START](true);
+
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.clearImportResults(undefined),
+      );
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.importing(true),
+      );
+
+      mockDispatch.mockClear();
+
+      // Phase 2: Simulate backend processing time (e.g., 2 seconds)
+      jest.advanceTimersByTime(2000);
+
+      // Phase 3: Backend signals import complete with successful response
+      const successfulResponse = JSON.stringify({
+        eventsCount: 25,
+        calendarsCount: 3,
+      });
+      handlers[IMPORT_GCAL_END](successfulResponse);
+
+      // Spinner should disappear (importing set to false)
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.importing(false),
+      );
+      // Results should be set
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.setImportResults({
+          eventsCount: 25,
+          calendarsCount: 3,
+        }),
+      );
+      // Fetch should be triggered to load new events
+      expect(triggerFetch).toHaveBeenCalledWith({
+        reason: "IMPORT_COMPLETE",
+      });
+    });
+
+    it("hides spinner when import completes within timeout", () => {
+      const handlers: Record<string, (...args: unknown[]) => void> = {};
+      (socket.on as jest.Mock).mockImplementation((event, handler) => {
+        handlers[event] = handler;
+      });
+
+      awaitingValue = true;
+      renderHook(() => useGcalSync());
+
+      // Start import
+      handlers[IMPORT_GCAL_START](true);
+      mockDispatch.mockClear();
+
+      // Simulate a reasonable import duration (under 30 seconds)
+      const REASONABLE_IMPORT_TIME_MS = 15000;
+      jest.advanceTimersByTime(REASONABLE_IMPORT_TIME_MS);
+
+      // Import completes successfully
+      handlers[IMPORT_GCAL_END](
+        JSON.stringify({ eventsCount: 100, calendarsCount: 5 }),
+      );
+
+      // Verify spinner is hidden
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.importing(false),
+      );
+    });
+
+    it("handles rapid start/end sequence without state inconsistency", () => {
+      const handlers: Record<string, (...args: unknown[]) => void> = {};
+      (socket.on as jest.Mock).mockImplementation((event, handler) => {
+        handlers[event] = handler;
+      });
+
+      awaitingValue = true;
+      renderHook(() => useGcalSync());
+
+      // Rapid sequence: start → end (small import)
+      handlers[IMPORT_GCAL_START](true);
+      jest.advanceTimersByTime(100); // Very fast import
+      handlers[IMPORT_GCAL_END](
+        JSON.stringify({ eventsCount: 2, calendarsCount: 1 }),
+      );
+
+      // Final state should have importing=false
+      const importingCalls = mockDispatch.mock.calls.filter(
+        (call) =>
+          call[0] === importGCalSlice.actions.importing(true) ||
+          call[0] === importGCalSlice.actions.importing(false),
+      );
+
+      // Last importing call should be false (spinner hidden)
+      expect(mockDispatch).toHaveBeenLastCalledWith(
+        importGCalSlice.actions.setImportResults({
+          eventsCount: 2,
+          calendarsCount: 1,
+        }),
+      );
+    });
+
+    it("handles import end with empty payload gracefully", () => {
+      const handlers: Record<string, (...args: unknown[]) => void> = {};
+      (socket.on as jest.Mock).mockImplementation((event, handler) => {
+        handlers[event] = handler;
+      });
+
+      awaitingValue = true;
+      renderHook(() => useGcalSync());
+
+      handlers[IMPORT_GCAL_START](true);
+      mockDispatch.mockClear();
+
+      // Backend sends empty response (edge case)
+      handlers[IMPORT_GCAL_END](JSON.stringify({}));
+
+      // Should still hide spinner and set empty results
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.importing(false),
+      );
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.setImportResults({}),
+      );
+    });
+
+    it("handles import end with object payload (non-string)", () => {
+      const handlers: Record<string, (...args: unknown[]) => void> = {};
+      (socket.on as jest.Mock).mockImplementation((event, handler) => {
+        handlers[event] = handler;
+      });
+
+      awaitingValue = true;
+      renderHook(() => useGcalSync());
+
+      handlers[IMPORT_GCAL_START](true);
+      mockDispatch.mockClear();
+
+      // Backend sends object directly (alternative format)
+      handlers[IMPORT_GCAL_END]({ eventsCount: 50, calendarsCount: 4 });
+
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.importing(false),
+      );
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.setImportResults({
+          eventsCount: 50,
+          calendarsCount: 4,
+        }),
+      );
+    });
+
+    it("sets error state when backend returns malformed JSON", () => {
+      const handlers: Record<string, (...args: unknown[]) => void> = {};
+      (socket.on as jest.Mock).mockImplementation((event, handler) => {
+        handlers[event] = handler;
+      });
+      const consoleErrorSpy = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      awaitingValue = true;
+      renderHook(() => useGcalSync());
+
+      handlers[IMPORT_GCAL_START](true);
+      mockDispatch.mockClear();
+
+      // Backend sends malformed response
+      handlers[IMPORT_GCAL_END]("not valid json {{{");
+
+      // Should hide spinner
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.importing(false),
+      );
+      // Should set error
+      expect(mockDispatch).toHaveBeenCalledWith(
+        importGCalSlice.actions.setImportError(
+          "Failed to parse Google Calendar import results.",
+        ),
+      );
+      // Should NOT set results
+      expect(importGCalSlice.actions.setImportResults).not.toHaveBeenCalled();
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
 });