fix(tests+async): corrige test drift pós-Lovable + setState pós-unmount em páginas admin/auth

src/components/security/useSecurityData.ts

@@ -1,7 +1,7 @@
 /**
  * useSecurityData — Hook que carrega métricas, logins e alertas de segurança
  */
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
 import { supabase } from '@/integrations/supabase/client';
 import { use2FA } from '@/hooks/auth';
 import { useAllowedIPs } from '@/hooks/admin';
@@ -54,15 +54,20 @@ export function useSecurityData(effectiveUserId: string | undefined, isManagingO
   const [notifications, setNotifications] = useState<SecurityNotification[]>([]);
   const [isLoading, setIsLoading] = useState(true);
 
+  // Guarda de montagem: evita setState após o unmount (await que resolve
+  // após o teardown vaza "window is not defined" em testes).
+  const mountedRef = useRef(true);
+
   const loadSecurityData = useCallback(async () => {
     if (!effectiveUserId) return;
-    setIsLoading(true);
+    if (mountedRef.current) setIsLoading(true);
     try {
       const { data: attempts } = await supabase
         .from('login_attempts').select('*')
         .eq('user_id', effectiveUserId)
         .order('created_at', { ascending: false }).limit(20);
 
+      if (!mountedRef.current) return;
       setLoginAttempts((attempts as LoginAttempt[]) || []);
 
       const { count: devicesCount } = await supabase
@@ -74,6 +79,7 @@ export function useSecurityData(effectiveUserId: string | undefined, isManagingO
         .eq('user_id', effectiveUserId).eq('type', 'security')
         .order('created_at', { ascending: false }).limit(10);
 
+      if (!mountedRef.current) return;
       setNotifications((notifs as SecurityNotification[]) || []);
 
       const failedAttempts = attempts?.filter(a => !a.success).length || 0;
@@ -95,13 +101,20 @@ export function useSecurityData(effectiveUserId: string | undefined, isManagingO
         securityAlerts: unreadAlerts,
       });
     } catch (error) {
+      if (!mountedRef.current) return;
       console.error('Error loading security data:', error);
     } finally {
-      setIsLoading(false);
+      if (mountedRef.current) setIsLoading(false);
     }
   }, [effectiveUserId, is2FAEnabled, allowedIPs]);
 
-  useEffect(() => { if (effectiveUserId) loadSecurityData(); }, [effectiveUserId, loadSecurityData]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (effectiveUserId) loadSecurityData();
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [effectiveUserId, loadSecurityData]);
 
   return { metrics, loginAttempts, notifications, isLoading, is2FAEnabled, is2FALoading, allowedIPs };
 }

src/pages/admin/AdminSegurancaAcessoPage.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useEffect, useMemo } from 'react';
+import React, { useState, useEffect, useMemo, useRef } from 'react';
 import { z } from 'zod';
 import { supabase } from '@/integrations/supabase/client';
 import { PageSEO } from '@/components/seo/PageSEO';
@@ -117,8 +117,13 @@ export default function AdminSegurancaAcessoPage() {
   });
   const { toast } = useToast();
 
+  // Guarda de montagem: evita setState após o unmount (o fetchAll é chamado
+  // pelo effect inicial, pelo polling de 30s e por handlers; sem isso, um await
+  // que resolve após o teardown vaza "window is not defined" nos testes).
+  const mountedRef = useRef(true);
+
   const fetchAll = async () => {
-    setIsLoading(true);
+    if (mountedRef.current) setIsLoading(true);
     try {
       const [botRes, rateRes, ipRes] = await Promise.all([
         supabase
@@ -133,24 +138,30 @@ export default function AdminSegurancaAcessoPage() {
           .limit(100),
         supabase.from('ip_access_control').select('*').order('created_at', { ascending: false }),
       ]);
+      if (!mountedRef.current) return;
       if (botRes.error) throw botRes.error;
       if (rateRes.error) throw rateRes.error;
       if (ipRes.error) throw ipRes.error;
       setBotLogs(botRes.data || []);
       setRateLimits(rateRes.data || []);
       setIpList(ipRes.data || []);
     } catch (err) {
+      if (!mountedRef.current) return;
       const msg = err instanceof Error ? err.message : 'Erro desconhecido';
       toast({ title: 'Erro ao carregar', description: msg, variant: 'destructive' });
     } finally {
-      setIsLoading(false);
+      if (mountedRef.current) setIsLoading(false);
     }
   };
 
   useEffect(() => {
+    mountedRef.current = true;
     fetchAll();
     const interval = setInterval(fetchAll, 30000); // 30s polling
-    return () => clearInterval(interval);
+    return () => {
+      mountedRef.current = false;
+      clearInterval(interval);
+    };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 

src/pages/admin/PermissionsPage.tsx

@@ -34,22 +34,29 @@ export default function PermissionsPage() {
   const { toast } = useToast();
 
   useEffect(() => {
-    fetchPermissions();
+    // Guarda de cancelamento: evita setState após o unmount.
+    let cancelled = false;
+    fetchPermissions(() => cancelled);
+    return () => {
+      cancelled = true;
+    };
   }, []);
 
-  const fetchPermissions = async () => {
+  const fetchPermissions = async (isCancelled: () => boolean = () => false) => {
     try {
       const { data, error } = await supabase
         .from('permissions')
         .select('*')
         .order('category', { ascending: true });
 
+      if (isCancelled()) return;
       if (error) throw error;
       setPermissions(data || []);
     } catch (error: unknown) {
+      if (isCancelled()) return;
       toast({ title: 'Erro', description: error instanceof Error ? error.message : String(error), variant: 'destructive' });
     } finally {
-      setIsLoading(false);
+      if (!isCancelled()) setIsLoading(false);
     }
   };
 

src/pages/admin/RolePermissionsPage.tsx

@@ -53,25 +53,33 @@ export default function RolePermissionsPage() {
   const { toast } = useToast();
 
   useEffect(() => {
-    fetchData();
+    // Guarda de cancelamento: evita setState após o unmount (em testes, o
+    // await pode resolver depois do teardown e vazar "window is not defined").
+    let cancelled = false;
+    fetchData(() => cancelled);
+    return () => {
+      cancelled = true;
+    };
   }, []);
 
-  const fetchData = async () => {
+  const fetchData = async (isCancelled: () => boolean = () => false) => {
     try {
       const [permRes, rolePermRes] = await Promise.all([
         supabase.from('permissions').select('*').order('category'),
         supabase.from('role_permissions').select('*'),
       ]);
 
+      if (isCancelled()) return;
       if (permRes.error) throw permRes.error;
       if (rolePermRes.error) throw rolePermRes.error;
 
       setPermissions(permRes.data || []);
       setRolePermissions(rolePermRes.data || []);
     } catch (error: unknown) {
+      if (isCancelled()) return;
       toast({ title: 'Erro ao carregar dados', description: error.message, variant: 'destructive' });
     } finally {
-      setIsLoading(false);
+      if (!isCancelled()) setIsLoading(false);
     }
   };
 

src/pages/admin/RolesPage.tsx

@@ -29,22 +29,30 @@ export default function RolesPage() {
   const { toast } = useToast();
 
   useEffect(() => {
-    fetchRoles();
+    // Guarda de cancelamento: evita setState após o unmount (em testes, o
+    // await pode resolver depois do teardown e vazar "window is not defined").
+    let cancelled = false;
+    fetchRoles(() => cancelled);
+    return () => {
+      cancelled = true;
+    };
   }, []);
 
-  const fetchRoles = async () => {
+  const fetchRoles = async (isCancelled: () => boolean = () => false) => {
     try {
       const { data, error } = await supabase
         .from('roles')
         .select('*')
         .order('name');
 
+      if (isCancelled()) return;
       if (error) throw error;
       setRoles(data || []);
     } catch (error: unknown) {
+      if (isCancelled()) return;
       toast({ title: 'Erro', description: error instanceof Error ? error.message : String(error), variant: 'destructive' });
     } finally {
-      setIsLoading(false);
+      if (!isCancelled()) setIsLoading(false);
     }
   };
 

src/pages/admin/StorageTestPage.tsx

@@ -19,10 +19,11 @@ export default function StorageTestPage() {
 
   const bucketName = "test-external-storage";
 
-  const fetchFiles = async () => {
-    setLoadingFiles(true);
+  const fetchFiles = async (isCancelled: () => boolean = () => false) => {
+    if (!isCancelled()) setLoadingFiles(true);
     try {
       const { data, error } = await supabase.storage.from(bucketName).list();
+      if (isCancelled()) return;
       if (error) {
         if (error.message.includes("does not exist")) {
            toast({
@@ -36,19 +37,25 @@ export default function StorageTestPage() {
       }
       setFiles(data || []);
     } catch (error: any) {
+      if (isCancelled()) return;
       console.error("Error fetching files:", error);
       toast({
         title: "Erro ao buscar arquivos",
         description: error.message,
         variant: "destructive",
       });
     } finally {
-      setLoadingFiles(false);
+      if (!isCancelled()) setLoadingFiles(false);
     }
   };
 
   useEffect(() => {
-    fetchFiles();
+    // Guarda de cancelamento: evita setState após o unmount.
+    let cancelled = false;
+    fetchFiles(() => cancelled);
+    return () => {
+      cancelled = true;
+    };
   }, []);
 
   const handleUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
@@ -243,7 +250,7 @@ export default function StorageTestPage() {
                       Listagem do bucket <code>{bucketName}</code>.
                     </CardDescription>
                   </div>
-                  <Button variant="ghost" size="sm" onClick={fetchFiles} disabled={loadingFiles} className="text-white/60 hover:text-white">
+                  <Button variant="ghost" size="sm" onClick={() => fetchFiles()} disabled={loadingFiles} className="text-white/60 hover:text-white">
                     Atualizar Lista
                   </Button>
                 </div>

src/pages/auth/Auth.tsx

@@ -137,18 +137,26 @@ export default function Auth() {
 
   // Fetch IP, geolocation and backend status
   useEffect(() => {
+    // Guarda de cancelamento: evita setState após o unmount do componente.
+    // Sem isso, os awaits de loadInfo podem resolver depois do teardown e
+    // disparar setDbStatus/setCurrentIP fora do ciclo de vida do React
+    // (em testes, isso vaza como "ReferenceError: window is not defined").
+    let cancelled = false;
+
     const loadInfo = async () => {
       // 1. IP Info
       try {
         const { data, error } = await supabase.functions.invoke('get-visitor-info');
-        if (!error && data) {
+        if (!cancelled && !error && data) {
           if (data.ip) setCurrentIP(data.ip);
           if (data.city) setGeoLocation(`${data.city}, ${data.country_code}`);
         }
       } catch {
         // silent fail
       }
 
+      if (cancelled) return;
+
       // 2. Principal Backend (Directly from env or client)
       const principalUrl = import.meta.env.VITE_EXTERNAL_SUPABASE_URL || import.meta.env.VITE_SUPABASE_URL;
       const isExternal = !!import.meta.env.VITE_EXTERNAL_SUPABASE_URL;
@@ -169,6 +177,8 @@ export default function Auth() {
           body: { operation: 'ping' }
         });
 
+        if (cancelled) return;
+
         if (!error && data?.ok) {
           setDbStatus(prev => ({
             ...prev,
@@ -183,11 +193,17 @@ export default function Auth() {
           setDbStatus(prev => ({ ...prev, external: { ok: false, loading: false } }));
         }
       } catch {
-        setDbStatus(prev => ({ ...prev, external: { ok: false, loading: false } }));
+        if (!cancelled) {
+          setDbStatus(prev => ({ ...prev, external: { ok: false, loading: false } }));
+        }
       }
     };
 
     loadInfo();
+
+    return () => {
+      cancelled = true;
+    };
   }, []);
 
   // Redirect if already logged in (only on initial load)

tests/components/BridgeStatusBanner.test.tsx

@@ -90,7 +90,6 @@ describe('BridgeStatusBanner — visibilidade por papel e ambiente', () => {
     emit({ type: 'unavailable', reason: 'timeout' } as any);
     expect(screen.getByRole('alert')).toBeInTheDocument();
     expect(screen.getByText(/Catálogo temporariamente indisponível/i)).toBeInTheDocument();
-    expect(screen.getByText(/instabilidade momentânea/i)).toBeInTheDocument();
   });
 
   it('usuário dev: exibe avisos de infra e avisos críticos com cópia técnica', () => {

tests/components/DevInfraGateMatrix.test.tsx

@@ -19,11 +19,15 @@ describe('DevInfraGate Matrix — Parameterized Permission Tests', () => {
     vi.clearAllMocks();
   });
 
+  // DevOnlyBridgeOverlay usa <DevOnly strict>: a visibilidade é decidida
+  // EXCLUSIVAMENTE por `isDev` (role dev real). O override `isAllowed`
+  // (env/localStorage) é IGNORADO no modo strict — por isso expectedVisible
+  // acompanha `isDev`, não `isAllowed`.
   const testCases = [
-    { isAllowed: true,  isDev: true,  expectedVisible: true,  desc: 'Usuário Dev com permissão aprovada' },
-    { isAllowed: true,  isDev: false, expectedVisible: true,  desc: 'Usuário não-Dev mas com permissão aprovada (ex: override ou Admin)' },
-    { isAllowed: false, isDev: true,  expectedVisible: false, desc: 'Usuário Dev mas com permissão negada (ex: env gate desligado)' },
-    { isAllowed: false, isDev: false, expectedVisible: false, desc: 'Usuário comum com permissão negada' },
+    { isAllowed: true,  isDev: true,  expectedVisible: true,  desc: 'Dev real (isDev=true) — monta independente de isAllowed' },
+    { isAllowed: true,  isDev: false, expectedVisible: false, desc: 'Não-Dev com override isAllowed=true — strict IGNORA override, NÃO monta' },
+    { isAllowed: false, isDev: true,  expectedVisible: true,  desc: 'Dev real com isAllowed=false — strict usa isDev, MONTA' },
+    { isAllowed: false, isDev: false, expectedVisible: false, desc: 'Usuário comum (isDev=false) — NÃO monta' },
   ];
 
   it.each(testCases)('$desc -> visível: $expectedVisible', async ({ isAllowed, isDev, expectedVisible }) => {

tests/components/DevOnlyBridgeOverlay.test.tsx

@@ -41,15 +41,19 @@ describe('DevOnlyBridgeOverlay — gate por papel + SSOT', () => {
     expect(await screen.findByTestId('bridge-metrics-overlay-mock')).toBeInTheDocument();
   });
 
-  it('gate SSOT desligado (env=false) bloqueia mesmo dev', () => {
+  // DevOnlyBridgeOverlay usa <DevOnly strict>, que decide EXCLUSIVAMENTE por
+  // `isDev` (role dev real) e IGNORA overrides de env/localStorage (isAllowed).
+  // Os dois casos abaixo cobrem justamente essa diferença entre `isDev` e
+  // `isAllowed`.
+  it('strict ignora override: isDev=true monta mesmo com isAllowed=false', async () => {
     vi.mocked(useDevGate).mockReturnValue({ isAllowed: false, isDev: true });
-    const { container } = render(<DevOnlyBridgeOverlay />);
-    expect(container).toBeEmptyDOMElement();
+    render(<DevOnlyBridgeOverlay />);
+    expect(await screen.findByTestId('bridge-metrics-overlay-mock')).toBeInTheDocument();
   });
 
-  it('gate SSOT habilitado por override (localStorage) renderiza mesmo para não-dev', async () => {
+  it('strict ignora override: isAllowed=true mas isDev=false NÃO monta', () => {
     vi.mocked(useDevGate).mockReturnValue({ isAllowed: true, isDev: false });
-    render(<DevOnlyBridgeOverlay />);
-    expect(await screen.findByTestId('bridge-metrics-overlay-mock')).toBeInTheDocument();
+    const { container } = render(<DevOnlyBridgeOverlay />);
+    expect(container).toBeEmptyDOMElement();
   });
 });

tests/components/pages/MagicUp.test.tsx

@@ -72,6 +72,9 @@ describe("MagicUp", () => {
   it("renders without crashing", async () => {
     const { default: MagicUp } = await import("@/pages/tools/MagicUp");
     renderWithProviders(<MagicUp />);
-    expect(screen.getByTestId("main-layout")).toBeInTheDocument();
+    // MagicUp é uma página de conteúdo: o MainLayout é aplicado pelo roteador,
+    // não pela própria página. Validamos o marcador real que o componente
+    // expõe (o título da página) para garantir que renderizou sem crashar.
+    expect(await screen.findByTestId("page-title-magic-up")).toBeInTheDocument();
   });
 });