test(pav-5): add frontend tests for OAuth integration

- Add getGoogleAuthUrl tests to authService tests
- Add refreshUser tests to AuthContext tests
- Create AuthCallback page tests (loading, redirect on success/failure)

Brings branch coverage above 80% threshold.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

frontend/tests/unit/context/AuthContext.test.tsx

@@ -16,7 +16,7 @@ vi.mock("@/services/api", () => ({
 import { AuthProvider, useAuth } from "@/context/AuthContext";
 
 function TestConsumer() {
-  const { user, isLoading, login, logout } = useAuth();
+  const { user, isLoading, login, logout, refreshUser } = useAuth();
   return (
     <div>
       <span data-testid="loading">{String(isLoading)}</span>
@@ -25,6 +25,7 @@ function TestConsumer() {
         login
       </button>
       <button onClick={() => logout()}>logout</button>
+      <button onClick={() => refreshUser()}>refresh</button>
     </div>
   );
 }
@@ -146,4 +147,58 @@ describe("AuthContext", () => {
     render(<Naked />);
     expect(screen.getByTestId("ctx")).toBeInTheDocument();
   });
+
+  it("refreshUser atualiza o usuário ao chamar /auth/me novamente", async () => {
+    mockApiGet.mockRejectedValueOnce(new Error("Unauthorized"));
+
+    renderWithProvider();
+
+    await waitFor(() => {
+      expect(screen.getByTestId("loading").textContent).toBe("false");
+    });
+
+    expect(screen.getByTestId("user").textContent).toBe("null");
+
+    mockApiGet.mockResolvedValueOnce({
+      data: { user: { id: "2", email: "novo@teste.com", name: "Novo" } },
+    });
+
+    await act(async () => {
+      screen.getByRole("button", { name: /refresh/i }).click();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("loading").textContent).toBe("false");
+    });
+
+    const user = JSON.parse(screen.getByTestId("user").textContent!);
+    expect(user.id).toBe("2");
+    expect(user.email).toBe("novo@teste.com");
+  });
+
+  it("refreshUser define user como null quando /auth/me falha", async () => {
+    mockApiGet.mockResolvedValueOnce({
+      data: { user: { id: "1", email: "joao@teste.com" } },
+    });
+
+    renderWithProvider();
+
+    await waitFor(() => {
+      expect(screen.getByTestId("loading").textContent).toBe("false");
+    });
+
+    expect(screen.getByTestId("user").textContent).not.toBe("null");
+
+    mockApiGet.mockRejectedValueOnce(new Error("Unauthorized"));
+
+    await act(async () => {
+      screen.getByRole("button", { name: /refresh/i }).click();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("loading").textContent).toBe("false");
+    });
+
+    expect(screen.getByTestId("user").textContent).toBe("null");
+  });
 });

frontend/tests/unit/pages/auth/AuthCallback.test.tsx

@@ -0,0 +1,90 @@
+import { render, screen, waitFor } from "@testing-library/react";
+import { describe, expect, it, vi, beforeEach } from "vitest";
+import "@testing-library/jest-dom/vitest";
+
+const mockNavigate = vi.fn();
+vi.mock("react-router-dom", () => ({
+  useNavigate: () => mockNavigate,
+}));
+
+const mockUseAuth = vi.fn();
+vi.mock("@/context/AuthContext", () => ({
+  useAuth: () => mockUseAuth(),
+}));
+
+vi.mock("@/Loading", () => ({
+  default: () => <div data-testid="loading">Loading...</div>,
+}));
+
+import AuthCallback from "@/pages/auth/AuthCallback";
+
+describe("AuthCallback", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("mostra loading enquanto isLoading é true", () => {
+    mockUseAuth.mockReturnValue({
+      user: null,
+      isLoading: true,
+      refreshUser: vi.fn(),
+    });
+
+    render(<AuthCallback />);
+
+    expect(screen.getByTestId("loading")).toBeInTheDocument();
+  });
+
+  it("navega para /app quando user existe", async () => {
+    const refreshUser = vi.fn();
+    mockUseAuth
+      .mockReturnValueOnce({ user: null, isLoading: true, refreshUser })
+      .mockReturnValue({
+        user: { id: "1", email: "test@test.com" },
+        isLoading: false,
+        refreshUser,
+      });
+
+    const { rerender } = render(<AuthCallback />);
+
+    expect(refreshUser).toHaveBeenCalled();
+
+    rerender(<AuthCallback />);
+
+    await waitFor(() => {
+      expect(mockNavigate).toHaveBeenCalledWith("/app", { replace: true });
+    });
+  });
+
+  it("navega para /login com erro quando user é null", async () => {
+    const refreshUser = vi.fn();
+    mockUseAuth
+      .mockReturnValueOnce({ user: null, isLoading: true, refreshUser })
+      .mockReturnValue({ user: null, isLoading: false, refreshUser });
+
+    const { rerender } = render(<AuthCallback />);
+
+    expect(refreshUser).toHaveBeenCalled();
+
+    rerender(<AuthCallback />);
+
+    await waitFor(() => {
+      expect(mockNavigate).toHaveBeenCalledWith("/login?error=oauth_failed", {
+        replace: true,
+      });
+    });
+  });
+
+  it("chama refreshUser ao montar", () => {
+    const refreshUser = vi.fn();
+    mockUseAuth.mockReturnValue({
+      user: null,
+      isLoading: true,
+      refreshUser,
+    });
+
+    render(<AuthCallback />);
+
+    expect(refreshUser).toHaveBeenCalledTimes(1);
+  });
+});

frontend/tests/unit/services/auth.service.test.tsx

@@ -252,4 +252,48 @@ describe("authService", () => {
       );
     });
   });
+
+  describe("getGoogleAuthUrl", () => {
+    it("should return Google auth URL on success", async () => {
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({
+          jsonData: { url: "https://accounts.google.com/o/oauth2/auth?state=abc" },
+        })
+      );
+
+      const url = await auth.getGoogleAuthUrl();
+
+      expect(url).toBe("https://accounts.google.com/o/oauth2/auth?state=abc");
+      expect(fetchMock).toHaveBeenCalledWith(
+        expect.stringContaining("/api/auth/google/url"),
+        expect.objectContaining({ credentials: "include" })
+      );
+    });
+
+    it("should throw error on failure with message", async () => {
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({
+          ok: false,
+          status: 500,
+          jsonData: { message: "Provider unavailable" },
+        })
+      );
+
+      await expect(auth.getGoogleAuthUrl()).rejects.toThrow("Provider unavailable");
+    });
+
+    it("should throw error on failure without message", async () => {
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({
+          ok: false,
+          status: 500,
+          jsonData: {},
+        })
+      );
+
+      await expect(auth.getGoogleAuthUrl()).rejects.toThrow(
+        "Falha ao obter URL de autenticacao Google."
+      );
+    });
+  });
 });