test: increase branch coverage to 78.68% (from 73.53%)

.github/workflows/ci.yml

@@ -176,7 +176,9 @@ jobs:
           SUPABASE_SERVICE_ROLE_KEY: ${{ env.SUPABASE_LOCAL_SERVICE_ROLE_KEY }}
           DATABASE_URL: postgresql://postgres:postgres@127.0.0.1:54322/postgres
           PLAYWRIGHT_BASE_URL: http://localhost:3333
-        run: npm run e2e
+        # Use npx directly, not npm run e2e: dotenv -e .env.test would override
+        # dynamic Supabase anon key with the static hardcoded key from .env.test.
+        run: npx playwright test
 
       - name: Upload Playwright report
         uses: actions/upload-artifact@v4

.gitignore

@@ -160,3 +160,4 @@ graphify-out/
 .nanostack/
 qa/
 .sisyphus/evidence/
+.omo/

playwright.config.ts

@@ -1,8 +1,10 @@
 import { defineConfig, devices } from '@playwright/test';
 import dotenv from 'dotenv';
 
-// override: true ensures .env.test values win over any pre-loaded .env.local
-dotenv.config({ path: '.env.test', override: true });
+// Load .env.test as defaults so local dev matches CI.
+// Do NOT use override: true — CI passes dynamic Supabase keys that must
+// take priority over the hardcoded demo key in .env.test.
+dotenv.config({ path: '.env.test' });
 
 export default defineConfig({
   testDir: './tests/e2e/specs',

src/ai/flows/workout-feedback-flow.test.ts

@@ -1,22 +1,34 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { WorkoutFeedbackOutput } from '@/ai/flows/workout-feedback-flow';
+
+const { mockFeedbackPrompt, mockDefinePrompt, mockDefineFlow, mockSetAttribute } = vi.hoisted(
+  () => {
+    const mockFeedbackPrompt = vi.fn();
+    const mockDefinePrompt = vi.fn((_config: unknown) => mockFeedbackPrompt);
+    const mockDefineFlow = vi.fn((_config: unknown, handler: unknown) => handler);
+    const mockSetAttribute = vi.fn();
+    return { mockFeedbackPrompt, mockDefinePrompt, mockDefineFlow, mockSetAttribute };
+  }
+);
 
 vi.mock('@/ai/genkit', () => ({
   ai: {
-    definePrompt: vi.fn(),
-    defineFlow: vi.fn(),
+    definePrompt: mockDefinePrompt,
+    defineFlow: mockDefineFlow,
   },
 }));
 
 vi.mock('@genkit-ai/google-genai', () => ({
   googleAI: { model: vi.fn(() => 'gemini-2.5-flash') },
 }));
 
-vi.mock('@/ai/flows/workout-feedback-flow', async () => {
-  return {
-    generateWorkoutFeedback: vi.fn(),
-  };
-});
+vi.mock('@sentry/nextjs', () => ({
+  startSpan: vi.fn(
+    async (
+      _config: unknown,
+      fn: (span: { setAttribute: typeof mockSetAttribute }) => Promise<unknown>
+    ) => fn({ setAttribute: mockSetAttribute })
+  ),
+}));
 
 import { generateWorkoutFeedback } from '@/ai/flows/workout-feedback-flow';
 
@@ -26,25 +38,23 @@ describe('generateWorkoutFeedback', () => {
   });
 
   it('returns fallback when no exercises completed (no AI call)', async () => {
-    vi.mocked(generateWorkoutFeedback).mockResolvedValue({
-      title: 'O primeiro passo é o mais importante!',
-      message: expect.any(String) as unknown as string,
-    });
-
     const result = await generateWorkoutFeedback({
       goal: 'Hipertrofia',
       completedExercises: [],
       totalExercises: 3,
     });
 
     expect(result.title).toBe('O primeiro passo é o mais importante!');
+    expect(result.message).toMatch(/nenhum exercício/i);
+    expect(mockFeedbackPrompt).not.toHaveBeenCalled();
   });
 
-  it('returns AI feedback when exercises are completed', async () => {
-    vi.mocked(generateWorkoutFeedback).mockResolvedValue({
+  it('returns AI feedback when exercises completed', async () => {
+    const aiResult = {
       title: 'Mandou bem!',
       message: 'Excelente sessão. Continue assim!',
-    });
+    };
+    mockFeedbackPrompt.mockResolvedValue({ output: aiResult });
 
     const result = await generateWorkoutFeedback({
       goal: 'Hipertrofia',
@@ -53,30 +63,19 @@ describe('generateWorkoutFeedback', () => {
     });
 
     expect(result.title).toBe('Mandou bem!');
-    expect(result.message).toBeTruthy();
+    expect(result.message).toBe('Excelente sessão. Continue assim!');
+    expect(mockFeedbackPrompt).toHaveBeenCalledTimes(1);
   });
 
-  it('propagates errors from AI call', async () => {
-    vi.mocked(generateWorkoutFeedback).mockRejectedValue(new Error('AI unavailable'));
+  it('throws when AI returns null output', async () => {
+    mockFeedbackPrompt.mockResolvedValue({ output: null });
 
     await expect(
       generateWorkoutFeedback({
-        goal: 'Força',
-        completedExercises: ['Agachamento'],
+        goal: 'Hipertrofia',
+        completedExercises: ['Supino Reto'],
         totalExercises: 1,
       })
-    ).rejects.toThrow('AI unavailable');
-  });
-});
-
-// Integration contract: WorkoutSession must handle the rejection gracefully
-describe('WorkoutSession feedback contract', () => {
-  it('fallback feedback shape is valid', () => {
-    const fallback: WorkoutFeedbackOutput = {
-      title: 'Treino Concluído!',
-      message: 'Continue assim!',
-    };
-    expect(fallback.title).toBeTruthy();
-    expect(fallback.message).toBeTruthy();
+    ).rejects.toThrow('workoutFeedbackFlow: output is null');
   });
 });

src/ai/flows/workout-generator-flow.test.ts

@@ -1,11 +1,14 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { z } from 'zod';
 
-const mockGenerate = vi.fn();
-const mockGenerateStream = vi.fn();
-const mockDefineFlow = vi.fn((_config: unknown, handler: unknown) => handler);
-const mockSetAttribute = vi.fn();
-const mockSpan = { setAttribute: mockSetAttribute };
+const { mockGenerate, mockGenerateStream, mockDefineFlow, mockSpan } = vi.hoisted(() => {
+  const mockGenerate = vi.fn();
+  const mockGenerateStream = vi.fn();
+  const mockDefineFlow = vi.fn((_config: unknown, handler: unknown) => handler);
+  const mockSetAttribute = vi.fn();
+  const mockSpan = { setAttribute: mockSetAttribute };
+  return { mockGenerate, mockGenerateStream, mockDefineFlow, mockSetAttribute, mockSpan };
+});
 
 vi.mock('@/ai/genkit', () => ({
   ai: {
@@ -151,6 +154,122 @@ describe('streamWorkoutPlan', () => {
       )(validInput, { sendChunk })
     ).rejects.toThrow('A IA não retornou um plano de treino válido.');
   });
+
+  it('uses observacoesAdicionais when provided', async () => {
+    mockGenerateStream.mockReturnValue({
+      stream: (async function* () {
+        yield { output: { planName: 'Plano', workouts: [] } };
+      })(),
+      response: Promise.resolve({
+        output: {
+          planName: 'Plano',
+          workouts: [],
+        },
+        usage: { inputTokens: 10, outputTokens: 20 },
+      }),
+    });
+
+    const { streamWorkoutPlan } = await import('@/ai/flows/workout-generator-flow');
+    const sendChunk = vi.fn();
+    const inputWithObs = { ...validInput, observacoesAdicionais: 'Lesão no joelho' };
+
+    const result = await (
+      streamWorkoutPlan as unknown as (
+        input: typeof inputWithObs,
+        ctx: { sendChunk: (chunk: unknown) => void }
+      ) => Promise<unknown>
+    )(inputWithObs, { sendChunk });
+
+    expect(result).toBeDefined();
+  });
+
+  it('handles missing usage stats with nullish coalescing', async () => {
+    const chunkOutput = {
+      planName: 'Plano Teste',
+      workouts: [],
+    };
+    mockGenerateStream.mockReturnValue({
+      stream: (async function* () {
+        yield { output: chunkOutput };
+      })(),
+      response: Promise.resolve({
+        output: {
+          planName: 'Plano Teste',
+          workouts: [
+            {
+              nome: 'Treino A',
+              objetivo: 'Hipertrofia',
+              diaSugerido: 1,
+              exercicios: [
+                {
+                  nomeExercicio: 'Supino Reto',
+                  grupoMuscular: 'Peito',
+                  series: 3,
+                  repeticoes: '10-12',
+                  observacoes: '',
+                },
+              ],
+            },
+          ],
+        },
+        usage: null,
+      }),
+    });
+
+    const { streamWorkoutPlan } = await import('@/ai/flows/workout-generator-flow');
+    const sendChunk = vi.fn();
+
+    const result = await (
+      streamWorkoutPlan as unknown as (
+        input: typeof validInput,
+        ctx: { sendChunk: (chunk: unknown) => void }
+      ) => Promise<unknown>
+    )(validInput, { sendChunk });
+
+    expect(result).toBeDefined();
+  });
+
+  it('throws when AI output fails schema validation', async () => {
+    mockGenerateStream.mockReturnValue({
+      stream: (async function* () {
+        yield {};
+      })(),
+      response: Promise.resolve({
+        output: {
+          planName: 123,
+          workouts: [
+            {
+              nome: 'A',
+              objetivo: 'Força',
+              diaSugerido: 1,
+              exercicios: [
+                {
+                  nomeExercicio: 'Supino',
+                  grupoMuscular: 'Peito',
+                  series: 3,
+                  repeticoes: '10',
+                  observacoes: '',
+                },
+              ],
+            },
+          ],
+        },
+        usage: { inputTokens: 10, outputTokens: 20 },
+      }),
+    });
+
+    const { streamWorkoutPlan } = await import('@/ai/flows/workout-generator-flow');
+    const sendChunk = vi.fn();
+
+    await expect(
+      (
+        streamWorkoutPlan as unknown as (
+          input: typeof validInput,
+          ctx: { sendChunk: (chunk: unknown) => void }
+        ) => Promise<unknown>
+      )(validInput, { sendChunk })
+    ).rejects.toThrow('A IA não retornou um plano de treino válido.');
+  });
 });
 
 describe('generateWorkoutPlan', () => {
@@ -190,6 +309,18 @@ describe('generateWorkoutPlan', () => {
     expect(mockGenerate).toHaveBeenCalled();
   });
 
+  it('handles undefined usage stats in generateWorkoutPlan', async () => {
+    mockGenerate.mockResolvedValue({
+      output: null,
+      usage: null,
+    });
+
+    const { generateWorkoutPlan } = await import('@/ai/flows/workout-generator-flow');
+    await expect(generateWorkoutPlan(validInput)).rejects.toThrow(
+      'A IA não retornou um plano de treino válido.'
+    );
+  });
+
   it('throws when output is null', async () => {
     mockGenerate.mockResolvedValue({
       output: null,