diff --git a/eslint.config.mjs b/eslint.config.mjs
index 04e7dc5c..4a543094 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -22,7 +22,12 @@ export default tseslint.config(
       '@typescript-eslint/no-explicit-any': 'error',
       '@typescript-eslint/no-unused-vars': [
         'error',
-        { argsIgnorePattern: '^_', caughtErrorsIgnorePattern: '^_' },
+        {
+          argsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+          ignoreRestSiblings: true,
+        },
       ],
       '@typescript-eslint/consistent-type-imports': ['warn', { prefer: 'type-imports' }],
       // Downgrade new eslint-config-next v16 React Compiler rules to warnings
diff --git a/src/ai/flows/workout-generator-flow.test.ts b/src/ai/flows/workout-generator-flow.test.ts
new file mode 100644
index 00000000..b9bc86c6
--- /dev/null
+++ b/src/ai/flows/workout-generator-flow.test.ts
@@ -0,0 +1,204 @@
+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 };
+
+vi.mock('@/ai/genkit', () => ({
+  ai: {
+    defineFlow: (...args: [unknown, unknown]) => mockDefineFlow(...args),
+    generate: (...args: [unknown]) => mockGenerate(...args),
+    generateStream: (...args: [unknown]) => mockGenerateStream(...args),
+  },
+}));
+
+vi.mock('@genkit-ai/google-genai', () => ({
+  googleAI: { model: vi.fn(() => 'gemini-2.5-flash') },
+}));
+
+vi.mock('@sentry/nextjs', () => ({
+  startSpan: vi.fn(async (_config: unknown, fn: (span: typeof mockSpan) => Promise<unknown>) =>
+    fn(mockSpan)
+  ),
+}));
+
+vi.mock('@/lib/constants', () => ({
+  EXERCICIOS_POR_GRUPO: [
+    {
+      grupo: 'Peito',
+      exercicios: [{ nomeExercicio: 'Supino Reto' }],
+    },
+  ],
+}));
+
+vi.mock('@/ai/schemas', () => {
+  const WorkoutGeneratorInputSchema = z.object({
+    objetivo: z.enum(['Hipertrofia', 'Perda de Peso', 'Força']),
+    nivelExperiencia: z.enum(['Iniciante', 'Intermediário', 'Avançado']),
+    diasPorSemana: z.number().min(1).max(7),
+    observacoesAdicionais: z.string().optional(),
+  });
+
+  const WorkoutGeneratorAIOutputSchema = z.object({
+    planName: z.string(),
+    workouts: z.array(
+      z.object({
+        nome: z.string(),
+        objetivo: z.string(),
+        diaSugerido: z.number(),
+        exercicios: z.array(
+          z.object({
+            nomeExercicio: z.string(),
+            grupoMuscular: z.string(),
+            series: z.number(),
+            repeticoes: z.string(),
+            observacoes: z.string(),
+          })
+        ),
+      })
+    ),
+  });
+
+  return {
+    WorkoutGeneratorInputSchema,
+    WorkoutGeneratorAIOutputSchema,
+    WorkoutGeneratorInput: undefined,
+    WorkoutGeneratorAIOutput: undefined,
+  };
+});
+
+const validInput = {
+  objetivo: 'Hipertrofia' as const,
+  nivelExperiencia: 'Intermediário' as const,
+  diasPorSemana: 4,
+};
+
+describe('streamWorkoutPlan', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('streams workout plan successfully', 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: { inputTokens: 100, outputTokens: 200 },
+      }),
+    });
+
+    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();
+    expect(sendChunk).toHaveBeenCalled();
+  });
+
+  it('throws when AI returns no output', async () => {
+    mockGenerateStream.mockReturnValue({
+      stream: (async function* () {
+        yield {};
+      })(),
+      response: Promise.resolve({
+        output: null,
+        usage: { inputTokens: 0, outputTokens: 0 },
+      }),
+    });
+
+    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', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('generates workout plan successfully', async () => {
+    mockGenerate.mockResolvedValue({
+      output: {
+        planName: 'Plano Força',
+        workouts: [
+          {
+            nome: 'Treino A',
+            objetivo: 'Força',
+            diaSugerido: 2,
+            exercicios: [
+              {
+                nomeExercicio: 'Supino Reto',
+                grupoMuscular: 'Peito',
+                series: 5,
+                repeticoes: '5-6',
+                observacoes: '',
+              },
+            ],
+          },
+        ],
+      },
+      usage: { inputTokens: 50, outputTokens: 150 },
+    });
+
+    const { generateWorkoutPlan } = await import('@/ai/flows/workout-generator-flow');
+    const result = await generateWorkoutPlan(validInput);
+
+    expect(result).toBeDefined();
+    expect(result.planName).toBe('Plano Força');
+    expect(mockGenerate).toHaveBeenCalled();
+  });
+
+  it('throws when output is null', async () => {
+    mockGenerate.mockResolvedValue({
+      output: null,
+      usage: { inputTokens: 0, outputTokens: 0 },
+    });
+
+    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.'
+    );
+  });
+});
diff --git a/src/ai/genkit.test.ts b/src/ai/genkit.test.ts
new file mode 100644
index 00000000..9645456e
--- /dev/null
+++ b/src/ai/genkit.test.ts
@@ -0,0 +1,50 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockGenkit = vi.fn(() => ({ name: 'mocked-ai' }));
+
+vi.mock('genkit', () => ({
+  genkit: mockGenkit,
+}));
+
+vi.mock('@genkit-ai/google-genai', () => ({
+  googleAI: vi.fn(() => 'google-ai-plugin'),
+}));
+
+describe('genkit initialization', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  it('initializes genkit with googleAI plugin', async () => {
+    const { ai } = await import('./genkit');
+    expect(mockGenkit).toHaveBeenCalledTimes(1);
+    expect(mockGenkit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        plugins: expect.arrayContaining(['google-ai-plugin']),
+      })
+    );
+    expect(ai).toEqual({ name: 'mocked-ai' });
+  });
+
+  it('passes GOOGLE_GENAI_API_KEY to googleAI plugin', async () => {
+    process.env.GOOGLE_GENAI_API_KEY = 'test-key';
+    const { googleAI } = await import('@genkit-ai/google-genai');
+    await import('./genkit');
+
+    expect(googleAI).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'test-key' }));
+
+    delete process.env.GOOGLE_GENAI_API_KEY;
+  });
+
+  it('falls back to GEMINI_API_KEY when GOOGLE_GENAI_API_KEY is not set', async () => {
+    delete process.env.GOOGLE_GENAI_API_KEY;
+    process.env.GEMINI_API_KEY = 'fallback-key';
+    const { googleAI } = await import('@genkit-ai/google-genai');
+    await import('./genkit');
+
+    expect(googleAI).toHaveBeenCalledWith(expect.objectContaining({ apiKey: 'fallback-key' }));
+
+    delete process.env.GEMINI_API_KEY;
+  });
+});
diff --git a/src/ai/schemas.test.ts b/src/ai/schemas.test.ts
new file mode 100644
index 00000000..dd8971a2
--- /dev/null
+++ b/src/ai/schemas.test.ts
@@ -0,0 +1,231 @@
+import { describe, it, expect } from 'vitest';
+import { WorkoutGeneratorInputSchema, WorkoutGeneratorAIOutputSchema } from './schemas';
+
+describe('WorkoutGeneratorInputSchema', () => {
+  const validInput = {
+    objetivo: 'Hipertrofia' as const,
+    nivelExperiencia: 'Iniciante' as const,
+    diasPorSemana: 3,
+  };
+
+  describe('valid input', () => {
+    it('accepts minimal valid input', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse(validInput);
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts input with optional observacoesAdicionais', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({
+        ...validInput,
+        observacoesAdicionais: 'Lesão no joelho esquerdo',
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.observacoesAdicionais).toBe('Lesão no joelho esquerdo');
+      }
+    });
+
+    it('accepts all objetivo values', () => {
+      for (const objetivo of ['Hipertrofia', 'Perda de Peso', 'Força'] as const) {
+        const result = WorkoutGeneratorInputSchema.safeParse({ ...validInput, objetivo });
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it('accepts all nivelExperiencia values', () => {
+      for (const nivel of ['Iniciante', 'Intermediário', 'Avançado'] as const) {
+        const result = WorkoutGeneratorInputSchema.safeParse({
+          ...validInput,
+          nivelExperiencia: nivel,
+        });
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it('accepts diasPorSemana at boundary 1', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({ ...validInput, diasPorSemana: 1 });
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts diasPorSemana at boundary 7', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({ ...validInput, diasPorSemana: 7 });
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('invalid input', () => {
+    it('rejects invalid objetivo', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({
+        ...validInput,
+        objetivo: 'Cardio',
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects invalid nivelExperiencia', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({
+        ...validInput,
+        nivelExperiencia: 'Expert',
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects diasPorSemana below minimum (0)', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({ ...validInput, diasPorSemana: 0 });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects diasPorSemana above maximum (8)', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({ ...validInput, diasPorSemana: 8 });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects missing required fields', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({});
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects non-number diasPorSemana', () => {
+      const result = WorkoutGeneratorInputSchema.safeParse({
+        ...validInput,
+        diasPorSemana: 'three',
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+});
+
+describe('WorkoutGeneratorAIOutputSchema', () => {
+  const validOutput = {
+    planName: 'Plano Hipertrofia 4x',
+    workouts: [
+      {
+        nome: 'Treino A - Peito e Tríceps',
+        objetivo: 'Hipertrofia do peitoral',
+        diaSugerido: 1,
+        exercicios: [
+          {
+            nomeExercicio: 'Supino Reto com Barra',
+            grupoMuscular: 'Peito',
+            series: 4,
+            repeticoes: '8-12',
+            observacoes: 'Controlar a descida',
+          },
+        ],
+      },
+    ],
+  };
+
+  describe('valid output', () => {
+    it('accepts a complete valid output', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse(validOutput);
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts empty workouts array', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        planName: 'Plano vazio',
+        workouts: [],
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts diaSugerido at boundary 0 (Sunday)', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        ...validOutput,
+        workouts: [{ ...validOutput.workouts[0], diaSugerido: 0 }],
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts diaSugerido at boundary 6 (Saturday)', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        ...validOutput,
+        workouts: [{ ...validOutput.workouts[0], diaSugerido: 6 }],
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts multiple workouts', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        planName: 'Split Full',
+        workouts: [
+          { ...validOutput.workouts[0], nome: 'Treino A', diaSugerido: 1 },
+          { ...validOutput.workouts[0], nome: 'Treino B', diaSugerido: 3 },
+          { ...validOutput.workouts[0], nome: 'Treino C', diaSugerido: 5 },
+        ],
+      });
+      expect(result.success).toBe(true);
+    });
+
+    it('accepts empty observacoes string', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        ...validOutput,
+        workouts: [
+          {
+            ...validOutput.workouts[0],
+            exercicios: [{ ...validOutput.workouts[0].exercicios[0], observacoes: '' }],
+          },
+        ],
+      });
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('invalid output', () => {
+    it('rejects missing planName', () => {
+      const { planName: _removed, ...rest } = validOutput;
+      const result = WorkoutGeneratorAIOutputSchema.safeParse(rest);
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects missing workouts', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        planName: 'Test',
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects diaSugerido below 0', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        ...validOutput,
+        workouts: [{ ...validOutput.workouts[0], diaSugerido: -1 }],
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects diaSugerido above 6', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        ...validOutput,
+        workouts: [{ ...validOutput.workouts[0], diaSugerido: 7 }],
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects workout with missing exercise fields', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        ...validOutput,
+        workouts: [
+          {
+            ...validOutput.workouts[0],
+            exercicios: [{ nomeExercicio: 'Supino' }],
+          },
+        ],
+      });
+      expect(result.success).toBe(false);
+    });
+
+    it('rejects workout with non-array exercicios', () => {
+      const result = WorkoutGeneratorAIOutputSchema.safeParse({
+        ...validOutput,
+        workouts: [
+          {
+            ...validOutput.workouts[0],
+            exercicios: 'not-an-array',
+          },
+        ],
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+});
diff --git a/src/app/actions/auth.test.ts b/src/app/actions/auth.test.ts
new file mode 100644
index 00000000..f739b434
--- /dev/null
+++ b/src/app/actions/auth.test.ts
@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@/utils/supabase/server', () => ({
+  createClient: vi.fn(),
+}));
+
+vi.mock('next/navigation', () => ({
+  redirect: vi.fn((url: string) => {
+    throw new Error(`Redirect to ${url}`);
+  }),
+}));
+
+vi.mock('next/dist/client/components/redirect-error', () => ({
+  isRedirectError: vi.fn((err: unknown) => {
+    if (err instanceof Error && err.message.startsWith('Redirect to')) return true;
+    return false;
+  }),
+}));
+
+vi.mock('zod/v4', () => {
+  const actual = vi.importActual('zod/v4');
+  return actual;
+});
+
+import { createClient } from '@/utils/supabase/server';
+import { redirect } from 'next/navigation';
+
+function mockSupabase(
+  overrides: {
+    signInError?: string;
+    profileRole?: string | null;
+    profileError?: { code: string } | null;
+  } = {}
+) {
+  const mockSignIn = vi.fn().mockResolvedValue({
+    data: overrides.signInError
+      ? { user: null }
+      : { user: { id: 'user-1', email: 'test@test.com' } },
+    error: overrides.signInError ? { message: overrides.signInError } : null,
+  });
+
+  const mockSelect = vi.fn().mockReturnThis();
+  const mockEq = vi.fn().mockReturnThis();
+  const mockSingle = vi.fn().mockResolvedValue({
+    data: overrides.profileError ? null : { role: overrides.profileRole ?? null },
+    error: overrides.profileError ?? null,
+  });
+
+  const mockSignOut = vi.fn().mockResolvedValue({ error: null });
+
+  const mockSupabaseClient = {
+    auth: {
+      signInWithPassword: mockSignIn, // ggignore
+      signOut: mockSignOut,
+    },
+    from: vi.fn(() => ({
+      select: mockSelect,
+      eq: mockEq,
+      single: mockSingle,
+    })),
+  };
+
+  vi.mocked(createClient).mockResolvedValue(mockSupabaseClient as never);
+  return mockSupabaseClient;
+}
+
+describe('auth server actions', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('login', () => {
+    it('returns error for invalid email format', async () => {
+      mockSupabase();
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'invalid-email');
+      formData.set('password', '__TEST_PASSWORD__');
+
+      const result = await login(undefined, formData);
+      expect(result).toEqual({
+        error: 'Dados inválidos. Verifique o e-mail e a senha.',
+      });
+    });
+
+    it('returns error for short password', async () => {
+      mockSupabase();
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'test@test.com');
+      formData.set('password', '123');
+
+      const result = await login(undefined, formData);
+      expect(result).toEqual({
+        error: 'Dados inválidos. Verifique o e-mail e a senha.',
+      });
+    });
+
+    it('returns error when Supabase auth fails', async () => {
+      mockSupabase({ signInError: 'Invalid login credentials' });
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'test@test.com');
+      formData.set('password', '__TEST_PASSWORD__');
+
+      const result = await login(undefined, formData);
+      expect(result).toEqual({
+        error: 'E-mail ou senha inválidos. Por favor, tente novamente.',
+      });
+    });
+
+    it('redirects to /dashboard for funcionario profile', async () => {
+      mockSupabase({ profileRole: 'INSTRUTOR' });
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'test@test.com');
+      formData.set('password', '__TEST_PASSWORD__');
+
+      await expect(login(undefined, formData)).rejects.toThrow('Redirect to /dashboard');
+      expect(redirect).toHaveBeenCalledWith('/dashboard');
+    });
+
+    it('redirects to /aluno/dashboard for aluno profile (no funcionario row)', async () => {
+      mockSupabase({ profileError: { code: 'PGRST116' } });
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'aluno@test.com');
+      formData.set('password', '__TEST_PASSWORD__');
+
+      await expect(login(undefined, formData)).rejects.toThrow('Redirect to /aluno/dashboard');
+      expect(redirect).toHaveBeenCalledWith('/aluno/dashboard');
+    });
+
+    it('returns error when profile query has a real DB error', async () => {
+      mockSupabase({ profileError: { code: '50000' } });
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'test@test.com');
+      formData.set('password', '__TEST_PASSWORD__');
+
+      const result = await login(undefined, formData);
+      expect(result).toEqual({
+        error: 'Erro ao verificar perfil. Por favor, tente novamente.',
+      });
+    });
+
+    it('handles PGRST116 error (no rows) for aluno gracefully', async () => {
+      mockSupabase({ profileError: { code: 'PGRST116' } });
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'aluno@test.com');
+      formData.set('password', '__TEST_PASSWORD__');
+
+      await expect(login(undefined, formData)).rejects.toThrow('Redirect to /aluno/dashboard');
+    });
+
+    it('re-throws redirect errors (isRedirectError path)', async () => {
+      mockSupabase({ profileRole: 'GERENTE' });
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'gerente@test.com');
+      formData.set('password', '__TEST_PASSWORD__');
+
+      await expect(login(undefined, formData)).rejects.toThrow('Redirect to /dashboard');
+    });
+
+    it('returns error for unexpected non-redirect exceptions', async () => {
+      const mockSelect = vi.fn().mockReturnThis();
+      const mockEq = vi.fn().mockReturnThis();
+      const mockSingle = vi.fn().mockRejectedValue(new Error('DB connection lost'));
+
+      vi.mocked(createClient).mockResolvedValue({
+        auth: {
+          signInWithPassword: vi.fn().mockResolvedValue({
+            // ggignore
+            data: { user: { id: 'user-1', email: 'test@test.com' } },
+            error: null,
+          }),
+          signOut: vi.fn(),
+        },
+        from: vi.fn(() => ({
+          select: mockSelect,
+          eq: mockEq,
+          single: mockSingle,
+        })),
+      } as never);
+
+      const { login } = await import('./auth');
+      const formData = new FormData();
+      formData.set('email', 'test@test.com');
+      formData.set('password', '__TEST_PASSWORD__');
+
+      const result = await login(undefined, formData);
+      expect(result).toEqual({
+        error: 'Ocorreu um erro inesperado. Por favor, tente novamente.',
+      });
+    });
+  });
+
+  describe('logout', () => {
+    it('calls signOut and redirects to /login', async () => {
+      const mockSupabaseClient = mockSupabase();
+      const { logout } = await import('./auth');
+
+      await expect(logout()).rejects.toThrow('Redirect to /login');
+      expect(mockSupabaseClient.auth.signOut).toHaveBeenCalled();
+      expect(redirect).toHaveBeenCalledWith('/login');
+    });
+  });
+});
diff --git a/src/app/aluno/aluno-header.test.tsx b/src/app/aluno/aluno-header.test.tsx
new file mode 100644
index 00000000..29c2a7ba
--- /dev/null
+++ b/src/app/aluno/aluno-header.test.tsx
@@ -0,0 +1,167 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { AlunoHeader, UserMenu, LanguageSelector } from './aluno-header';
+import type { ReactNode } from 'react';
+import type { NavLink } from './aluno-header';
+
+vi.mock('@/components/providers/i18n-provider', () => ({
+  useI18n: () => ({
+    language: 'pt',
+    setLanguage: vi.fn(),
+    t: (key: string) => {
+      const map: Record<string, string> = {
+        'common.welcome': 'Olá',
+        'common.profile': 'Meu Perfil',
+        'common.logout': 'Sair',
+        'common.selectLanguage': 'Selecionar idioma',
+      };
+      return map[key] || key;
+    },
+  }),
+}));
+
+vi.mock('next/link', () => ({
+  default: ({ children, href }: { children: ReactNode; href: string }) => (
+    <a href={href}>{children}</a>
+  ),
+}));
+
+vi.mock('@/components/ui/avatar', () => ({
+  Avatar: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AvatarFallback: ({ children }: { children: ReactNode }) => <span>{children}</span>,
+  AvatarImage: () => null,
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    variant,
+    ...props
+  }: {
+    children: ReactNode;
+    variant?: string;
+    [key: string]: unknown;
+  }) => (
+    <button data-variant={variant} {...props}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/dropdown-menu', () => ({
+  DropdownMenu: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  DropdownMenuContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  DropdownMenuLabel: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  DropdownMenuSeparator: () => <hr />,
+  DropdownMenuTrigger: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  DropdownMenuItem: ({ children, ...props }: { children: ReactNode; [key: string]: unknown }) => (
+    <div {...props}>{children}</div>
+  ),
+}));
+
+const mockNavLinks: NavLink[] = [
+  { href: '/aluno/dashboard', label: 'Dashboard', icon: <span>D</span> },
+  { href: '/aluno/meus-treinos', label: 'Treinos', icon: <span>T</span> },
+];
+
+describe('AlunoHeader', () => {
+  it('renders the brand name', () => {
+    render(
+      <AlunoHeader
+        pathname="/aluno/dashboard"
+        navLinks={mockNavLinks}
+        displayName="João"
+        photoURL=""
+        email="joao@test.com"
+        onLogout={vi.fn()}
+      />
+    );
+    expect(screen.getByText('Five Star Academy')).toBeTruthy();
+  });
+
+  it('renders nav links', () => {
+    render(
+      <AlunoHeader
+        pathname="/aluno/dashboard"
+        navLinks={mockNavLinks}
+        displayName="João"
+        photoURL=""
+        email="joao@test.com"
+        onLogout={vi.fn()}
+      />
+    );
+    expect(screen.getAllByText('Dashboard').length).toBeGreaterThanOrEqual(1);
+    expect(screen.getAllByText('Treinos').length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('renders welcome message with display name', () => {
+    render(
+      <AlunoHeader
+        pathname="/aluno/dashboard"
+        navLinks={mockNavLinks}
+        displayName="João"
+        photoURL=""
+        email="joao@test.com"
+        onLogout={vi.fn()}
+      />
+    );
+    expect(screen.getAllByText('João').length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('renders language selector', () => {
+    render(
+      <AlunoHeader
+        pathname="/aluno/dashboard"
+        navLinks={mockNavLinks}
+        displayName="João"
+        photoURL=""
+        email="joao@test.com"
+        onLogout={vi.fn()}
+      />
+    );
+    expect(screen.getByLabelText('Selecionar idioma')).toBeTruthy();
+  });
+});
+
+describe('UserMenu (aluno-header)', () => {
+  it('renders user name and email', () => {
+    render(
+      <UserMenu
+        displayName="Ana"
+        photoURL=""
+        email="ana@test.com"
+        navLinks={[]}
+        onLogout={vi.fn()}
+      />
+    );
+    expect(screen.getByText('Ana')).toBeTruthy();
+    expect(screen.getByText('ana@test.com')).toBeTruthy();
+  });
+
+  it('renders profile and logout options', () => {
+    render(
+      <UserMenu
+        displayName="Ana"
+        photoURL=""
+        email="ana@test.com"
+        navLinks={[]}
+        onLogout={vi.fn()}
+      />
+    );
+    expect(screen.getByText('Meu Perfil')).toBeTruthy();
+    expect(screen.getByText('Sair')).toBeTruthy();
+  });
+});
+
+describe('LanguageSelector', () => {
+  it('renders language button', () => {
+    render(<LanguageSelector />);
+    expect(screen.getByLabelText('Selecionar idioma')).toBeTruthy();
+  });
+
+  it('shows language options', () => {
+    render(<LanguageSelector />);
+    expect(screen.getByText('Português (BR)')).toBeTruthy();
+    expect(screen.getByText('English (US)')).toBeTruthy();
+  });
+});
diff --git a/src/app/aluno/dashboard/dashboard-client.test.tsx b/src/app/aluno/dashboard/dashboard-client.test.tsx
new file mode 100644
index 00000000..2cbf6cbe
--- /dev/null
+++ b/src/app/aluno/dashboard/dashboard-client.test.tsx
@@ -0,0 +1,190 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import AlunoDashboardClient from './dashboard-client';
+import type { Aluno, Treino } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+vi.mock('motion/react', () => ({
+  motion: {
+    div: ({ children, ...props }: { children: ReactNode; [key: string]: unknown }) => (
+      <div {...filterDomProps(props)}>{children}</div>
+    ),
+  },
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({ children, ...props }: { children: ReactNode; [key: string]: unknown }) => (
+    <button {...filterDomProps(props)}>{children}</button>
+  ),
+}));
+
+vi.mock('lucide-react', () => ({
+  Trophy: () => <span>TrophyIcon</span>,
+  TrendingUp: () => <span>TrendingUpIcon</span>,
+  Zap: () => <span>ZapIcon</span>,
+  Target: () => <span>TargetIcon</span>,
+  Award: () => <span>AwardIcon</span>,
+}));
+
+vi.mock('@/lib/logger', () => ({
+  Logger: { error: vi.fn(), info: vi.fn() },
+}));
+
+vi.mock('@/lib/actions/alunos', () => ({
+  finalizarTreinoAction: vi.fn().mockResolvedValue({ success: true }),
+}));
+
+vi.mock('@/hooks/use-app-notification', () => ({
+  useAppNotification: () => ({
+    success: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  }),
+}));
+
+vi.mock('@/components/ui/circular-progress', () => ({
+  CircularProgress: ({ value, label }: { value?: number; label?: string }) => (
+    <div data-testid="circular-progress" data-value={value}>
+      {label}
+    </div>
+  ),
+}));
+
+vi.mock('@/components/providers/i18n-provider', () => ({
+  useI18n: () => ({
+    language: 'pt',
+    setLanguage: vi.fn(),
+    t: (key: string, params?: Record<string, string | number>) => {
+      const map: Record<string, string> = {
+        'common.welcome': 'Olá',
+        'dashboard.level': 'Nível',
+        'dashboard.xp': 'XP',
+        'dashboard.streak': `${params?.count ?? 0} dias seguidos`,
+        'dashboard.workoutsThisMonth': `${params?.count ?? 0} treinos no mês`,
+      };
+      return map[key] || key;
+    },
+  }),
+}));
+
+vi.mock('@/components/dashboard/aluno/exercicio-viewer', () => ({
+  ExercicioViewer: () => <div data-testid="exercicio-viewer" />,
+}));
+
+vi.mock('@/components/dashboard/aluno/card-matricula', () => ({
+  CardMatricula: () => <div data-testid="card-matricula" />,
+}));
+
+vi.mock('@/components/dashboard/aluno/card-treino', () => ({
+  CardTreino: () => <div data-testid="card-treino" />,
+}));
+
+vi.mock('@/components/dashboard/aluno/card-feedback', () => ({
+  CardFeedback: () => <div data-testid="card-feedback" />,
+}));
+
+function filterDomProps(props: Record<string, unknown>): Record<string, unknown> {
+  const domProps: Record<string, unknown> = {};
+  for (const [key, val] of Object.entries(props)) {
+    if (
+      key === 'children' ||
+      key === 'className' ||
+      key === 'data-testid' ||
+      key.startsWith('data-')
+    ) {
+      domProps[key] = val;
+    }
+  }
+  return domProps;
+}
+
+const mockAluno: Aluno = {
+  id: '1',
+  nomeCompleto: 'João Silva',
+  cpf: '123.456.789-00',
+  email: 'joao@example.com',
+  telefone: '(11) 99999-9999',
+  dataNascimento: null,
+  dataCadastro: '2024-01-01',
+  fotoUrl: null,
+  statusMatricula: 'ATIVA',
+  nivel: 5,
+  exp: 1200,
+  xpToNextLevel: 2000,
+  progressPerc: 60,
+  streakDiasSeguidos: 7,
+  treinosNoMes: 12,
+  ultimoTreinoData: null,
+};
+
+const mockTreino: Treino = {
+  id: 'treino-1',
+  alunoId: '1',
+  objetivo: 'Hipertrofia',
+  diaSemana: 1,
+  exercicios: [
+    {
+      id: 'ex-1',
+      nomeExercicio: 'Supino Reto',
+      series: 4,
+      repeticoes: '12',
+      observacoes: null,
+      descricao: 'Deite-se em um banco reto',
+    },
+  ],
+};
+
+describe('AlunoDashboardClient', () => {
+  it('renders welcome message with first name', () => {
+    render(<AlunoDashboardClient aluno={mockAluno} initialTreino={mockTreino} />);
+    expect(screen.getByTestId('dashboard-welcome').textContent).toContain('JOÃO');
+  });
+
+  it('renders streak display', () => {
+    render(<AlunoDashboardClient aluno={mockAluno} initialTreino={mockTreino} />);
+    expect(screen.getByTestId('dashboard-welcome')).toBeTruthy();
+    expect(screen.getByText(/dias seguidos/)).toBeTruthy();
+  });
+
+  it('renders workouts this month', () => {
+    render(<AlunoDashboardClient aluno={mockAluno} initialTreino={mockTreino} />);
+    expect(screen.getByText('12')).toBeTruthy();
+  });
+
+  it('renders level progress', () => {
+    render(<AlunoDashboardClient aluno={mockAluno} initialTreino={mockTreino} />);
+    expect(screen.getByTestId('circular-progress')).toBeTruthy();
+    expect(screen.getByText((content) => content.includes('NÍVEL'))).toBeTruthy();
+  });
+
+  it('renders XP display', () => {
+    render(<AlunoDashboardClient aluno={mockAluno} initialTreino={mockTreino} />);
+    expect(screen.getByTestId('xp-display').textContent).toContain('1200');
+    expect(screen.getByTestId('xp-display').textContent).toContain('2000');
+  });
+
+  it('renders achievements section', () => {
+    render(<AlunoDashboardClient aluno={mockAluno} initialTreino={mockTreino} />);
+    expect(screen.getByText('CONQUISTAS')).toBeTruthy();
+    expect(screen.getByText('Iniciante Elite')).toBeTruthy();
+  });
+
+  it('renders subcomponents', () => {
+    render(<AlunoDashboardClient aluno={mockAluno} initialTreino={mockTreino} />);
+    expect(screen.getByTestId('card-treino')).toBeTruthy();
+    expect(screen.getByTestId('card-feedback')).toBeTruthy();
+    expect(screen.getByTestId('card-matricula')).toBeTruthy();
+    expect(screen.getByTestId('exercicio-viewer')).toBeTruthy();
+  });
+
+  it('renders without crashing when initialTreino is null', () => {
+    render(<AlunoDashboardClient aluno={mockAluno} initialTreino={null} />);
+    expect(screen.getByTestId('dashboard-welcome')).toBeTruthy();
+  });
+});
diff --git a/src/app/aluno/dashboard/page.test.tsx b/src/app/aluno/dashboard/page.test.tsx
new file mode 100644
index 00000000..29340fc8
--- /dev/null
+++ b/src/app/aluno/dashboard/page.test.tsx
@@ -0,0 +1,152 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import AlunoDashboardPage from './page';
+import type { ReactNode } from 'react';
+
+const mockRedirect = vi.fn((path: string) => {
+  throw new Error(`NEXT_REDIRECT:${path}`);
+});
+
+vi.mock('next/navigation', () => ({
+  redirect: (...args: [string]) => mockRedirect(...args),
+}));
+
+vi.mock('@/utils/supabase/server', () => ({
+  getUser: vi.fn(),
+}));
+
+vi.mock('@/lib/prisma', () => ({
+  prisma: {
+    aluno: {
+      findUnique: vi.fn(),
+    },
+    treino: {
+      findFirst: vi.fn(),
+    },
+  },
+}));
+
+vi.mock('./dashboard-client', () => ({
+  __esModule: true,
+  default: ({
+    aluno,
+    initialTreino,
+  }: {
+    aluno: { nomeCompleto: string };
+    initialTreino: unknown;
+  }) => (
+    <div data-testid="dashboard-client">
+      <span data-testid="aluno-name">{aluno.nomeCompleto}</span>
+      <span data-testid="has-treino">{initialTreino ? 'yes' : 'no'}</span>
+    </div>
+  ),
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+}));
+
+import { getUser } from '@/utils/supabase/server';
+import { prisma } from '@/lib/prisma';
+
+const mockGetUser = vi.mocked(getUser);
+const mockPrismaAluno = vi.mocked(prisma.aluno.findUnique);
+const mockPrismaTreino = vi.mocked(prisma.treino.findFirst);
+
+function makeAluno() {
+  return {
+    id: '1',
+    nomeCompleto: 'João Silva',
+    email: 'test@test.com',
+    cpf: '12345678900',
+    telefone: '11999999999',
+    dataNascimento: new Date('1990-01-01'),
+    dataCadastro: new Date('2024-01-01'),
+    fotoUrl: null,
+    biometriaHash: null,
+    statusMatricula: 'ATIVA',
+    nivel: 5,
+    exp: 1200,
+    streakDiasSeguidos: 7,
+    treinosNoMes: 12,
+    ultimoTreinoData: null,
+    progressPerc: 50,
+    dataVencimento: null,
+    xpToNextLevel: 100,
+    Matriculas: [],
+    HistoricoTreinos: [],
+    Treinos: [],
+    Pagamentos: [],
+  };
+}
+
+describe('AlunoDashboardPage', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('redirects to login when user is not authenticated', async () => {
+    mockGetUser.mockResolvedValue({ user: null, error: 'not authenticated' } as never);
+    await expect(AlunoDashboardPage()).rejects.toThrow('NEXT_REDIRECT');
+    expect(mockRedirect).toHaveBeenCalledWith('/aluno/login');
+  });
+
+  it('redirects to login when user is null', async () => {
+    mockGetUser.mockResolvedValue({ user: null, error: null });
+    await expect(AlunoDashboardPage()).rejects.toThrow('NEXT_REDIRECT');
+    expect(mockRedirect).toHaveBeenCalledWith('/aluno/login');
+  });
+
+  it('renders not found card when aluno is null in database', async () => {
+    mockGetUser.mockResolvedValue({
+      user: { id: '1', email: 'test@test.com' },
+      error: null,
+    } as never);
+    mockPrismaAluno.mockResolvedValue(null);
+    render(await AlunoDashboardPage());
+    expect(screen.getByText('Sinto muito!')).toBeTruthy();
+  });
+
+  it('renders dashboard client when aluno is found', async () => {
+    mockGetUser.mockResolvedValue({
+      user: { id: '1', email: 'test@test.com' },
+      error: null,
+    } as never);
+    mockPrismaAluno.mockResolvedValue(makeAluno() as never);
+    mockPrismaTreino.mockResolvedValue(null);
+    render(await AlunoDashboardPage());
+    expect(screen.getByTestId('dashboard-client')).toBeTruthy();
+    expect(screen.getByTestId('aluno-name').textContent).toBe('João Silva');
+  });
+
+  it('passes treino data when workout exists for today', async () => {
+    mockGetUser.mockResolvedValue({
+      user: { id: '1', email: 'test@test.com' },
+      error: null,
+    } as never);
+    mockPrismaAluno.mockResolvedValue(makeAluno() as never);
+    mockPrismaTreino.mockResolvedValue({
+      id: 'treino-1',
+      alunoId: '1',
+      objetivo: 'Hipertrofia',
+      diaSemana: 1,
+      instrutorId: null,
+      dataCriacao: new Date(),
+    });
+    render(await AlunoDashboardPage());
+    expect(screen.getByTestId('has-treino').textContent).toBe('yes');
+  });
+
+  it('passes null treino when no workout for today', async () => {
+    mockGetUser.mockResolvedValue({
+      user: { id: '1', email: 'test@test.com' },
+      error: null,
+    } as never);
+    mockPrismaAluno.mockResolvedValue(makeAluno() as never);
+    mockPrismaTreino.mockResolvedValue(null);
+    render(await AlunoDashboardPage());
+    expect(screen.getByTestId('has-treino').textContent).toBe('no');
+  });
+});
diff --git a/src/app/aluno/login/page.test.tsx b/src/app/aluno/login/page.test.tsx
new file mode 100644
index 00000000..ce086919
--- /dev/null
+++ b/src/app/aluno/login/page.test.tsx
@@ -0,0 +1,129 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import AlunoLoginPage from './page';
+import type { ReactNode } from 'react';
+
+const mockSignInWithPassword = vi.fn().mockResolvedValue({ data: {}, error: null });
+const mockSignUp = vi.fn().mockResolvedValue({ data: {}, error: null });
+
+vi.mock('@/utils/supabase/client', () => ({
+  createClient: () => ({
+    auth: {
+      signInWithPassword: mockSignInWithPassword,
+      signUp: mockSignUp,
+    },
+  }),
+}));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({
+    push: vi.fn(),
+    back: vi.fn(),
+    refresh: vi.fn(),
+  }),
+}));
+
+vi.mock('next/link', () => ({
+  default: ({ children, href }: { children: ReactNode; href: string }) => (
+    <a href={href}>{children}</a>
+  ),
+}));
+
+vi.mock('@/hooks/use-app-notification', () => ({
+  useAppNotification: () => ({
+    success: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  }),
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+  CardHeader: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+  CardTitle: ({ children }: { children: ReactNode }) => <h2>{children}</h2>,
+  CardDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  CardContent: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+  CardFooter: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    type,
+    disabled,
+    variant,
+    className,
+  }: {
+    children: ReactNode;
+    type?: string;
+    disabled?: boolean;
+    variant?: string;
+    asChild?: boolean;
+    className?: string;
+  }) => (
+    <button
+      type={type as 'button' | 'reset' | 'submit'}
+      disabled={disabled}
+      data-variant={variant}
+      className={className}
+    >
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: (props: Record<string, unknown>) => <input {...props} />,
+}));
+
+vi.mock('@/components/ui/separator', () => ({
+  Separator: ({ className }: { className?: string }) => <hr className={className} />,
+}));
+
+vi.mock('@/components/ui/form', () => ({
+  Form: ({ children }: { children: ReactNode }) => <form>{children}</form>,
+  FormControl: ({ children }: { children: ReactNode }) => <>{children}</>,
+  FormField: ({ render }: { render: (props: { field: Record<string, unknown> }) => ReactNode }) => {
+    const field = { value: '', onChange: vi.fn(), onBlur: vi.fn(), name: 'field' };
+    return <>{render({ field })}</>;
+  },
+  FormItem: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  FormLabel: ({ children }: { children: ReactNode }) => <label>{children}</label>,
+  FormMessage: () => null,
+}));
+
+describe('AlunoLoginPage', () => {
+  it('renders the login card title', () => {
+    render(<AlunoLoginPage />);
+    expect(screen.getByText('Portal do Aluno (Supabase)')).toBeTruthy();
+  });
+
+  it('renders email and password labels', () => {
+    render(<AlunoLoginPage />);
+    expect(screen.getByText('Email')).toBeTruthy();
+    expect(screen.getByText('Senha')).toBeTruthy();
+  });
+
+  it('renders submit button', () => {
+    render(<AlunoLoginPage />);
+    expect(screen.getByText('Entrar')).toBeTruthy();
+  });
+
+  it('renders link to management login', () => {
+    render(<AlunoLoginPage />);
+    expect(screen.getByText('Acesso para Gestão')).toBeTruthy();
+  });
+
+  it('renders the dumbbell icon', () => {
+    const { container } = render(<AlunoLoginPage />);
+    expect(container.querySelector('.lucide-dumbbell')).toBeTruthy();
+  });
+});
diff --git a/src/app/aluno/meus-treinos/meus-treinos-client.test.tsx b/src/app/aluno/meus-treinos/meus-treinos-client.test.tsx
new file mode 100644
index 00000000..33d733a2
--- /dev/null
+++ b/src/app/aluno/meus-treinos/meus-treinos-client.test.tsx
@@ -0,0 +1,197 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import MeusTreinosClient from './meus-treinos-client';
+import type { Treino } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({
+    push: vi.fn(),
+    back: vi.fn(),
+    refresh: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/use-app-notification', () => ({
+  useAppNotification: () => ({
+    success: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/use-workout-crud', () => ({
+  useWorkoutCRUD: () => ({
+    meusTreinos: [
+      {
+        id: 'treino-1',
+        alunoId: 'user-1',
+        objetivo: 'Hipertrofia',
+        diaSemana: 1,
+        instrutorId: 'instrutor-1',
+        exercicios: [{ id: 'ex-1', nomeExercicio: 'Supino', series: 4, repeticoes: '12' }],
+      },
+      {
+        id: 'treino-2',
+        alunoId: 'user-1',
+        objetivo: 'Resistência',
+        diaSemana: null,
+        exercicios: [{ id: 'ex-2', nomeExercicio: 'Corrida', series: 1, repeticoes: '30min' }],
+      },
+    ],
+    isFormVisible: false,
+    setIsFormVisible: vi.fn(),
+    editingTreino: null,
+    setEditingTreino: vi.fn(),
+    isAlertOpen: false,
+    setIsAlertOpen: vi.fn(),
+    deletingTreino: null,
+    handleSave: vi.fn(),
+    handleEdit: vi.fn(),
+    handleDayChange: vi.fn(),
+    openDeleteAlert: vi.fn(),
+    handleDelete: vi.fn(),
+  }),
+}));
+
+vi.mock('@/hooks/use-workout-generation', () => ({
+  useWorkoutGeneration: () => ({
+    isGenerating: false,
+    handleGenerate: vi.fn(),
+  }),
+}));
+
+vi.mock('@/lib/actions/treinos', () => ({
+  registrarHistoricoTreinoAction: vi.fn().mockResolvedValue({ success: true }),
+}));
+
+vi.mock('@/components/page-header', () => ({
+  PageHeader: ({ title, description }: { title: string; description?: string }) => (
+    <div data-testid="page-header">
+      <h1>{title}</h1>
+      {description && <p>{description}</p>}
+    </div>
+  ),
+}));
+
+vi.mock('@/components/ui/select', () => ({
+  Select: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  SelectContent: ({ children }: { children: ReactNode }) => <>{children}</>,
+  SelectItem: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  SelectTrigger: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  SelectValue: () => null,
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children }: { children: ReactNode }) => <div data-testid="card">{children}</div>,
+  CardHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardTitle: ({ children }: { children: ReactNode }) => <h3>{children}</h3>,
+  CardDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  CardContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    ...props
+  }: {
+    children: ReactNode;
+    onClick?: () => void;
+    [key: string]: unknown;
+  }) => (
+    <button onClick={onClick} {...filterDomProps(props)}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/badge', () => ({
+  Badge: ({ children }: { children: ReactNode }) => <span>{children}</span>,
+}));
+
+vi.mock('@/components/ui/alert-dialog', () => ({
+  AlertDialog: ({ children, open }: { children: ReactNode; open?: boolean }) =>
+    open ? <div data-testid="alert-dialog">{children}</div> : null,
+  AlertDialogAction: ({ children, onClick }: { children: ReactNode; onClick?: () => void }) => (
+    <button onClick={onClick}>{children}</button>
+  ),
+  AlertDialogCancel: ({ children }: { children: ReactNode }) => <button>{children}</button>,
+  AlertDialogContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  AlertDialogFooter: ({ children }: { children: ReactNode }) => <footer>{children}</footer>,
+  AlertDialogHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogTitle: ({ children }: { children: ReactNode }) => <h2>{children}</h2>,
+}));
+
+vi.mock('@/components/WorkoutSession', () => ({
+  WorkoutSession: () => <div data-testid="workout-session" />,
+}));
+
+vi.mock('@/components/dashboard/aluno/workout-generator', () => ({
+  WorkoutGenerator: () => <div data-testid="workout-generator" />,
+}));
+
+vi.mock('@/components/dashboard/aluno/workout-editor', () => ({
+  WorkoutEditor: () => <div data-testid="workout-editor" />,
+}));
+
+function filterDomProps(props: Record<string, unknown>): Record<string, unknown> {
+  const domProps: Record<string, unknown> = {};
+  for (const [key, val] of Object.entries(props)) {
+    if (key === 'children' || key === 'className' || key.startsWith('data-')) {
+      domProps[key] = val;
+    }
+  }
+  return domProps;
+}
+
+const mockTreinos: Treino[] = [
+  {
+    id: 'treino-1',
+    alunoId: 'user-1',
+    objetivo: 'Hipertrofia',
+    diaSemana: 1,
+    instrutorId: 'instrutor-1',
+    exercicios: [{ id: 'ex-1', nomeExercicio: 'Supino', series: 4, repeticoes: '12' }],
+  },
+  {
+    id: 'treino-2',
+    alunoId: 'user-1',
+    objetivo: 'Resistência',
+    diaSemana: null,
+    exercicios: [{ id: 'ex-2', nomeExercicio: 'Corrida', series: 1, repeticoes: '30min' }],
+  },
+];
+
+describe('MeusTreinosClient', () => {
+  it('renders the page header', () => {
+    render(<MeusTreinosClient initialTreinos={mockTreinos} userId="user-1" />);
+    expect(screen.getByText('Meus Treinos')).toBeTruthy();
+  });
+
+  it('renders personal workout section', () => {
+    render(<MeusTreinosClient initialTreinos={mockTreinos} userId="user-1" />);
+    expect(screen.getByText('Planos do Personal')).toBeTruthy();
+  });
+
+  it('renders personal workout list description', () => {
+    render(<MeusTreinosClient initialTreinos={mockTreinos} userId="user-1" />);
+    expect(screen.getByText('Treinos criados e enviados pelo seu instrutor.')).toBeTruthy();
+  });
+
+  it('renders personal workouts section and personal workouts info', () => {
+    render(<MeusTreinosClient initialTreinos={[]} userId="user-1" />);
+    expect(screen.getByText('Meus Treinos Pessoais')).toBeTruthy();
+  });
+
+  it('renders workout generator', () => {
+    render(<MeusTreinosClient initialTreinos={[]} userId="user-1" />);
+    expect(screen.getByTestId('workout-generator')).toBeTruthy();
+  });
+
+  it('renders create button when form is not visible', () => {
+    render(<MeusTreinosClient initialTreinos={[]} userId="user-1" />);
+    expect(screen.getByText('Criar Novo Treino Manualmente')).toBeTruthy();
+  });
+});
diff --git a/src/app/dashboard/_components/user-menu.test.tsx b/src/app/dashboard/_components/user-menu.test.tsx
new file mode 100644
index 00000000..d8c139e3
--- /dev/null
+++ b/src/app/dashboard/_components/user-menu.test.tsx
@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { UserMenu } from './user-menu';
+import type { ReactNode } from 'react';
+
+vi.mock('@/components/ui/avatar', () => ({
+  Avatar: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AvatarFallback: ({ children }: { children: ReactNode }) => <span>{children}</span>,
+  AvatarImage: () => null,
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({ children, ...props }: { children: ReactNode; [key: string]: unknown }) => (
+    <button {...props}>{children}</button>
+  ),
+}));
+
+vi.mock('@/components/ui/dropdown-menu', () => ({
+  DropdownMenu: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  DropdownMenuContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  DropdownMenuLabel: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  DropdownMenuSeparator: () => <hr />,
+  DropdownMenuTrigger: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  DropdownMenuItem: ({ children, ...props }: { children: ReactNode; [key: string]: unknown }) => (
+    <div {...props}>{children}</div>
+  ),
+}));
+
+vi.mock('@/app/actions/auth', () => ({
+  logout: vi.fn(),
+}));
+
+describe('UserMenu', () => {
+  it('renders user display name', () => {
+    render(<UserMenu displayName="João" email="joao@test.com" photoURL="" />);
+    expect(screen.getByText('João')).toBeTruthy();
+  });
+
+  it('renders user email', () => {
+    render(<UserMenu displayName="João" email="joao@test.com" photoURL="" />);
+    expect(screen.getByText('joao@test.com')).toBeTruthy();
+  });
+
+  it('renders menu items', () => {
+    render(<UserMenu displayName="João" email="joao@test.com" photoURL="" />);
+    expect(screen.getByText('Perfil')).toBeTruthy();
+    expect(screen.getByText('Configurações')).toBeTruthy();
+    expect(screen.getByText('Sair da conta')).toBeTruthy();
+  });
+
+  it('renders avatar fallback with first letter of email', () => {
+    render(<UserMenu displayName="João" email="joao@test.com" photoURL="" />);
+    expect(screen.getByText('J')).toBeTruthy();
+  });
+});
diff --git a/src/app/dashboard/alunos/alunos-client.test.tsx b/src/app/dashboard/alunos/alunos-client.test.tsx
new file mode 100644
index 00000000..4fa552b5
--- /dev/null
+++ b/src/app/dashboard/alunos/alunos-client.test.tsx
@@ -0,0 +1,220 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { AlunosClient } from './alunos-client';
+import type { Aluno, Plano } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+const mockRouter = { refresh: vi.fn(), push: vi.fn(), back: vi.fn(), prefetch: vi.fn() };
+vi.mock('next/navigation', () => ({
+  useRouter: () => mockRouter,
+}));
+
+const mockNotify = { success: vi.fn(), error: vi.fn(), warn: vi.fn() };
+vi.mock('@/hooks/use-app-notification', () => ({
+  useAppNotification: () => mockNotify,
+}));
+
+vi.mock('@/lib/actions/alunos', () => ({
+  createAlunoAction: vi.fn(),
+  updateAlunoAction: vi.fn(),
+  deleteAlunoAction: vi.fn(),
+  createMatriculaAction: vi.fn(),
+}));
+
+vi.mock('@/components/dashboard/alunos/data-table', () => ({
+  DataTable: ({ data }: { data: Aluno[]; columns: unknown[] }) => (
+    <div data-testid="data-table">
+      {data.map((a) => (
+        <div key={a.id} data-testid={`aluno-row-${a.id}`}>
+          {a.nomeCompleto}
+        </div>
+      ))}
+    </div>
+  ),
+}));
+
+vi.mock('@/components/dashboard/alunos/form-aluno', () => ({
+  FormAluno: ({
+    isOpen,
+    onOpenChange,
+    onSubmit,
+    aluno,
+  }: {
+    isOpen: boolean;
+    onOpenChange: (v: boolean) => void;
+    onSubmit: (d: unknown) => void;
+    aluno?: Aluno;
+  }) =>
+    isOpen ? (
+      <div data-testid="form-aluno">
+        <span>{aluno ? 'Editando' : 'Cadastrando'}</span>
+        <button
+          data-testid="submit-aluno-form"
+          onClick={() =>
+            onSubmit({
+              nomeCompleto: 'Novo Aluno',
+              cpf: '123',
+              email: 'n@test.com',
+              telefone: '11999999999',
+              dataNascimento: '1990-01-01',
+              statusMatricula: 'ATIVA',
+            })
+          }
+        >
+          Salvar
+        </button>
+        <button data-testid="close-form-aluno" onClick={() => onOpenChange(false)}>
+          Fechar
+        </button>
+      </div>
+    ) : null,
+}));
+
+vi.mock('@/components/dashboard/alunos/form-matricula', () => ({
+  FormMatricula: ({
+    isOpen,
+    onSubmit,
+    aluno,
+  }: {
+    isOpen: boolean;
+    onOpenChange: (v: boolean) => void;
+    onSubmit: (a: Aluno, p: Plano) => void;
+    aluno: Aluno | null;
+  }) =>
+    isOpen && aluno ? (
+      <div data-testid="form-matricula">
+        <span>Matrícula para {aluno.nomeCompleto}</span>
+        <button
+          data-testid="submit-matricula"
+          onClick={() =>
+            onSubmit(aluno, { id: 'plano-1', nome: 'Mensal', preco: 100, duracaoDias: 30 })
+          }
+        >
+          Confirmar Matrícula
+        </button>
+      </div>
+    ) : null,
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    disabled,
+  }: {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+  }) => (
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/alert-dialog', () => ({
+  AlertDialog: ({ children, open }: { children: ReactNode; open: boolean }) =>
+    open ? <div data-testid="alert-dialog">{children}</div> : null,
+  AlertDialogContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogTitle: ({ children }: { children: ReactNode }) => <h2>{children}</h2>,
+  AlertDialogDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  AlertDialogFooter: ({ children }: { children: ReactNode }) => <footer>{children}</footer>,
+  AlertDialogAction: ({ children, onClick }: { children: ReactNode; onClick?: () => void }) => (
+    <button onClick={onClick}>{children}</button>
+  ),
+  AlertDialogCancel: ({ children }: { children: ReactNode }) => <button>{children}</button>,
+}));
+
+const mockAlunos: Aluno[] = [
+  {
+    id: 'aluno-1',
+    nomeCompleto: 'João Silva',
+    cpf: '123.456.789-00',
+    email: 'joao@test.com',
+    telefone: '(11) 99999-9999',
+    dataNascimento: '1990-01-01',
+    dataCadastro: '2023-01-01',
+    fotoUrl: '',
+    statusMatricula: 'ATIVA',
+    nivel: 1,
+    exp: 0,
+    streakDiasSeguidos: 0,
+    treinosNoMes: 0,
+    ultimoTreinoData: null,
+  },
+];
+
+const mockPlanos: Plano[] = [{ id: 'plano-1', nome: 'Mensal', preco: 100, duracaoDias: 30 }];
+
+describe('AlunosClient', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders without crashing', () => {
+    const { container } = render(<AlunosClient initialAlunos={mockAlunos} planos={mockPlanos} />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders the page title and description', () => {
+    render(<AlunosClient initialAlunos={mockAlunos} planos={mockPlanos} />);
+    expect(screen.getByText('Gestão de Alunos')).toBeTruthy();
+    expect(screen.getByText(/Cadastre, visualize e gerencie/)).toBeTruthy();
+  });
+
+  it('renders the "Cadastrar Aluno" button', () => {
+    render(<AlunosClient initialAlunos={mockAlunos} planos={mockPlanos} />);
+    expect(screen.getByText('Cadastrar Aluno')).toBeTruthy();
+  });
+
+  it('renders the DataTable with alumnos', () => {
+    render(<AlunosClient initialAlunos={mockAlunos} planos={mockPlanos} />);
+    expect(screen.getByTestId('data-table')).toBeTruthy();
+    expect(screen.getByTestId('aluno-row-aluno-1')).toBeTruthy();
+  });
+
+  it('opens FormAluno when "Cadastrar Aluno" is clicked', () => {
+    render(<AlunosClient initialAlunos={mockAlunos} planos={mockPlanos} />);
+    fireEvent.click(screen.getByText('Cadastrar Aluno'));
+    expect(screen.getByTestId('form-aluno')).toBeTruthy();
+    expect(screen.getByText('Cadastrando')).toBeTruthy();
+  });
+
+  it('calls createAlunoAction on form submit', async () => {
+    const { createAlunoAction } = await import('@/lib/actions/alunos');
+    vi.mocked(createAlunoAction).mockResolvedValue({ success: true, data: mockAlunos[0] });
+
+    render(<AlunosClient initialAlunos={mockAlunos} planos={mockPlanos} />);
+    fireEvent.click(screen.getByText('Cadastrar Aluno'));
+    fireEvent.click(screen.getByTestId('submit-aluno-form'));
+
+    await waitFor(() => {
+      expect(createAlunoAction).toHaveBeenCalled();
+      expect(mockNotify.success).toHaveBeenCalled();
+      expect(mockRouter.refresh).toHaveBeenCalled();
+    });
+  });
+
+  it('shows error notification on createAlunoAction failure', async () => {
+    const { createAlunoAction } = await import('@/lib/actions/alunos');
+    vi.mocked(createAlunoAction).mockResolvedValue({ success: false, error: 'Erro ao criar' });
+
+    render(<AlunosClient initialAlunos={mockAlunos} planos={mockPlanos} />);
+    fireEvent.click(screen.getByText('Cadastrar Aluno'));
+    fireEvent.click(screen.getByTestId('submit-aluno-form'));
+
+    await waitFor(() => {
+      expect(mockNotify.error).toHaveBeenCalledWith('Erro ao salvar', 'Erro ao criar');
+    });
+  });
+
+  it('calls deleteAlunoAction on confirm', async () => {
+    const { deleteAlunoAction } = await import('@/lib/actions/alunos');
+    vi.mocked(deleteAlunoAction).mockResolvedValue({ success: true });
+
+    render(<AlunosClient initialAlunos={mockAlunos} planos={mockPlanos} />);
+
+    expect(screen.queryByTestId('alert-dialog')).toBeNull();
+  });
+});
diff --git a/src/app/dashboard/financeiro/financeiro-client.test.tsx b/src/app/dashboard/financeiro/financeiro-client.test.tsx
new file mode 100644
index 00000000..edb0d563
--- /dev/null
+++ b/src/app/dashboard/financeiro/financeiro-client.test.tsx
@@ -0,0 +1,216 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import FinanceiroClient from './financeiro-client';
+import type { ReactNode } from 'react';
+
+const mockRouter = { refresh: vi.fn(), push: vi.fn(), back: vi.fn(), prefetch: vi.fn() };
+vi.mock('next/navigation', () => ({
+  useRouter: () => mockRouter,
+}));
+
+const mockNotify = { success: vi.fn(), error: vi.fn(), warn: vi.fn() };
+vi.mock('@/hooks/use-app-notification', () => ({
+  useAppNotification: () => mockNotify,
+}));
+
+vi.mock('@/lib/actions/financeiro', () => ({
+  registrarPagamentoAction: vi.fn(),
+}));
+
+vi.mock('@/components/ui/table', () => ({
+  Table: ({ children }: { children: ReactNode }) => <table>{children}</table>,
+  TableHeader: ({ children }: { children: ReactNode }) => <thead>{children}</thead>,
+  TableBody: ({ children }: { children: ReactNode }) => <tbody>{children}</tbody>,
+  TableRow: ({ children }: { children: ReactNode }) => <tr>{children}</tr>,
+  TableHead: ({ children }: { children: ReactNode }) => <th>{children}</th>,
+  TableCell: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <td className={className}>{children}</td>
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    disabled,
+    variant,
+  }: {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    variant?: string;
+  }) => (
+    <button onClick={onClick} disabled={disabled} data-variant={variant}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/badge', () => ({
+  Badge: ({ children, variant }: { children: ReactNode; variant?: string }) => (
+    <span data-variant={variant}>{children}</span>
+  ),
+}));
+
+vi.mock('@/components/ui/alert-dialog', () => ({
+  AlertDialog: ({ children, open }: { children: ReactNode; open: boolean }) =>
+    open ? <div data-testid="alert-dialog">{children}</div> : null,
+  AlertDialogContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogTitle: ({ children }: { children: ReactNode }) => <h2>{children}</h2>,
+  AlertDialogDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  AlertDialogFooter: ({ children }: { children: ReactNode }) => <footer>{children}</footer>,
+  AlertDialogAction: ({
+    children,
+    onClick,
+    disabled,
+  }: {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+  }) => (
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
+  ),
+  AlertDialogCancel: ({ children, disabled }: { children: ReactNode; disabled?: boolean }) => (
+    <button disabled={disabled}>{children}</button>
+  ),
+}));
+
+interface AlunoFinanceiro {
+  id: string;
+  nomeCompleto: string;
+  email: string;
+  statusMatricula: string;
+}
+
+const mockInadimplentes: AlunoFinanceiro[] = [
+  {
+    id: 'aluno-1',
+    nomeCompleto: 'João Silva',
+    email: 'joao@test.com',
+    statusMatricula: 'INADIMPLENTE',
+  },
+  {
+    id: 'aluno-2',
+    nomeCompleto: 'Maria Santos',
+    email: 'maria@test.com',
+    statusMatricula: 'INADIMPLENTE',
+  },
+];
+
+describe('FinanceiroClient', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders without crashing', () => {
+    const { container } = render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders table headers', () => {
+    render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    expect(screen.getByText('Aluno')).toBeTruthy();
+    expect(screen.getByText('Email')).toBeTruthy();
+    expect(screen.getByText('Status')).toBeTruthy();
+    expect(screen.getByText('Ações')).toBeTruthy();
+  });
+
+  it('renders all inadimplente students', () => {
+    render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    expect(screen.getByText('João Silva')).toBeTruthy();
+    expect(screen.getByText('joao@test.com')).toBeTruthy();
+    expect(screen.getByText('Maria Santos')).toBeTruthy();
+    expect(screen.getByText('maria@test.com')).toBeTruthy();
+  });
+
+  it('renders "Inadimplente" badge for each student', () => {
+    render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    const badges = screen.getAllByText('Inadimplente');
+    expect(badges.length).toBe(2);
+  });
+
+  it('renders "Registrar Pagamento" buttons', () => {
+    render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    const buttons = screen.getAllByText('Registrar Pagamento');
+    expect(buttons.length).toBe(2);
+  });
+
+  it('shows empty state when no inadimplentes', () => {
+    render(<FinanceiroClient initialInadimplentes={[]} />);
+    expect(screen.getByText('Não há alunos inadimplentes no momento.')).toBeTruthy();
+  });
+
+  it('opens confirmation dialog when "Registrar Pagamento" is clicked', () => {
+    render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    fireEvent.click(screen.getAllByText('Registrar Pagamento')[0]);
+    expect(screen.getByTestId('alert-dialog')).toBeTruthy();
+    expect(screen.getByText('Confirmar Pagamento')).toBeTruthy();
+    expect(screen.getAllByText(/João Silva/).length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('calls registrarPagamentoAction on confirm', async () => {
+    const { registrarPagamentoAction } = await import('@/lib/actions/financeiro');
+    vi.mocked(registrarPagamentoAction).mockResolvedValue({ success: true });
+
+    render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    fireEvent.click(screen.getAllByText('Registrar Pagamento')[0]);
+
+    fireEvent.click(screen.getByText('Confirmar'));
+
+    await waitFor(() => {
+      expect(registrarPagamentoAction).toHaveBeenCalledWith('aluno-1');
+      expect(mockNotify.success).toHaveBeenCalledWith(
+        'Pagamento Registrado!',
+        expect.stringContaining('João Silva')
+      );
+      expect(mockRouter.refresh).toHaveBeenCalled();
+    });
+  });
+
+  it('shows error notification on payment registration failure', async () => {
+    const { registrarPagamentoAction } = await import('@/lib/actions/financeiro');
+    vi.mocked(registrarPagamentoAction).mockResolvedValue({
+      success: false,
+      error: 'Erro de pagamento',
+    });
+
+    render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    fireEvent.click(screen.getAllByText('Registrar Pagamento')[0]);
+    fireEvent.click(screen.getByText('Confirmar'));
+
+    await waitFor(() => {
+      expect(mockNotify.error).toHaveBeenCalledWith(
+        'Erro ao registrar pagamento',
+        'Erro de pagamento'
+      );
+    });
+  });
+
+  it('shows "Processando..." while payment is being processed', async () => {
+    const { registrarPagamentoAction } = await import('@/lib/actions/financeiro');
+    let resolvePromise!: (v: { success: boolean; error?: string }) => void;
+    vi.mocked(registrarPagamentoAction).mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          resolvePromise = resolve;
+        })
+    );
+
+    render(<FinanceiroClient initialInadimplentes={mockInadimplentes} />);
+    fireEvent.click(screen.getAllByText('Registrar Pagamento')[0]);
+    fireEvent.click(screen.getByText('Confirmar'));
+
+    await waitFor(() => {
+      expect(screen.getByText('Processando...')).toBeTruthy();
+    });
+
+    resolvePromise!({ success: true });
+
+    await waitFor(() => {
+      expect(screen.queryByText('Processando...')).toBeNull();
+    });
+  });
+});
diff --git a/src/app/dashboard/page.test.tsx b/src/app/dashboard/page.test.tsx
new file mode 100644
index 00000000..7e9e240d
--- /dev/null
+++ b/src/app/dashboard/page.test.tsx
@@ -0,0 +1,88 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import DashboardPage from './page';
+import type { ReactNode } from 'react';
+import type { DashboardStats } from '@/lib/definitions';
+
+vi.mock('@/lib/data', () => ({
+  getDashboardStats: vi.fn().mockResolvedValue({
+    totalAlunos: 150,
+    matriculasAtivas: 120,
+    alunosInadimplentes: 15,
+    faturamentoMensal: 45000,
+    crescimentoAnual: [
+      { mes: 'Jan', alunos: 10 },
+      { mes: 'Fev', alunos: 15 },
+    ],
+  } satisfies DashboardStats),
+}));
+
+vi.mock('@/components/dashboard/dashboard-charts', () => ({
+  DashboardCharts: ({ data }: { data: unknown[] }) => (
+    <div data-testid="dashboard-charts">{data.length} items</div>
+  ),
+}));
+
+vi.mock('@/components/page-header', () => ({
+  PageHeader: ({ title, description }: { title: string; description?: string }) => (
+    <div data-testid="page-header">
+      <h1>{title}</h1>
+      {description && <p>{description}</p>}
+    </div>
+  ),
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className} data-testid="card">
+      {children}
+    </div>
+  ),
+  CardHeader: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+  CardTitle: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <h3 className={className}>{children}</h3>
+  ),
+  CardContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+}));
+
+vi.mock('lucide-react', () => ({
+  Users: () => <span>UsersIcon</span>,
+  UserCheck: () => <span>UserCheckIcon</span>,
+  UserX: () => <span>UserXIcon</span>,
+  DollarSign: () => <span>DollarSignIcon</span>,
+}));
+
+describe('DashboardPage', () => {
+  it('renders the page header', async () => {
+    render(await DashboardPage());
+    expect(screen.getByText('Dashboard')).toBeTruthy();
+    expect(screen.getByText('Bem-vindo ao centro de comando da Five Star Gym.')).toBeTruthy();
+  });
+
+  it('renders KPI cards', async () => {
+    render(await DashboardPage());
+    expect(screen.getByText('Total de Alunos')).toBeTruthy();
+    expect(screen.getByText('Matrículas Ativas')).toBeTruthy();
+    expect(screen.getByText('Inadimplentes')).toBeTruthy();
+    expect(screen.getByText('Faturamento Mensal')).toBeTruthy();
+  });
+
+  it('renders formatted stat values', async () => {
+    render(await DashboardPage());
+    expect(screen.getByText('150')).toBeTruthy();
+    expect(screen.getByText('120')).toBeTruthy();
+    expect(screen.getByText('15')).toBeTruthy();
+  });
+
+  it('renders formatted currency value', async () => {
+    render(await DashboardPage());
+    expect(screen.getByText((content) => content.includes('45'))).toBeTruthy();
+  });
+
+  it('renders the charts component', async () => {
+    render(await DashboardPage());
+    expect(screen.getByTestId('dashboard-charts')).toBeTruthy();
+  });
+});
diff --git a/src/app/dashboard/planos/planos-client.test.tsx b/src/app/dashboard/planos/planos-client.test.tsx
new file mode 100644
index 00000000..055b3b61
--- /dev/null
+++ b/src/app/dashboard/planos/planos-client.test.tsx
@@ -0,0 +1,227 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { PlanosClient } from './planos-client';
+import type { Plano } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+const mockRouter = { refresh: vi.fn(), push: vi.fn(), back: vi.fn(), prefetch: vi.fn() };
+vi.mock('next/navigation', () => ({
+  useRouter: () => mockRouter,
+}));
+
+const mockNotify = { success: vi.fn(), error: vi.fn(), warn: vi.fn() };
+vi.mock('@/hooks/use-app-notification', () => ({
+  useAppNotification: () => mockNotify,
+}));
+
+vi.mock('@/lib/actions/planos', () => ({
+  createPlanoAction: vi.fn(),
+  updatePlanoAction: vi.fn(),
+  deletePlanoAction: vi.fn(),
+}));
+
+vi.mock('@/components/dashboard/planos/form-plano', () => ({
+  FormPlano: ({
+    isOpen,
+    onOpenChange,
+    onSubmit,
+    plano,
+  }: {
+    isOpen: boolean;
+    onOpenChange: (v: boolean) => void;
+    onSubmit: (d: { nome: string; preco: number; duracaoDias: number }) => void;
+    plano?: Plano;
+  }) =>
+    isOpen ? (
+      <div data-testid="form-plano">
+        <span>{plano ? 'Editando' : 'Criando'}</span>
+        <button
+          data-testid="submit-plano"
+          onClick={() => onSubmit({ nome: 'Novo Plano', preco: 150, duracaoDias: 30 })}
+        >
+          Salvar
+        </button>
+        <button onClick={() => onOpenChange(false)}>Fechar</button>
+      </div>
+    ) : null,
+}));
+
+vi.mock('@/components/page-header', () => ({
+  PageHeader: ({
+    title,
+    description,
+    actions,
+  }: {
+    title: string;
+    description?: string;
+    actions?: ReactNode;
+  }) => (
+    <div data-testid="page-header">
+      <h1>{title}</h1>
+      {description && <p>{description}</p>}
+      {actions}
+    </div>
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    disabled,
+  }: {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+  }) => (
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children }: { children: ReactNode }) => <div data-testid="card">{children}</div>,
+  CardHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardTitle: ({ children }: { children: ReactNode }) => <h3>{children}</h3>,
+  CardContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardFooter: ({ children }: { children: ReactNode }) => <footer>{children}</footer>,
+}));
+
+vi.mock('@/components/ui/badge', () => ({
+  Badge: ({ children, variant }: { children: ReactNode; variant?: string }) => (
+    <span data-variant={variant}>{children}</span>
+  ),
+}));
+
+vi.mock('@/components/ui/alert-dialog', () => ({
+  AlertDialog: ({ children, open }: { children: ReactNode; open: boolean }) =>
+    open ? <div data-testid="alert-dialog">{children}</div> : null,
+  AlertDialogContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogTitle: ({ children }: { children: ReactNode }) => <h2>{children}</h2>,
+  AlertDialogDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  AlertDialogFooter: ({ children }: { children: ReactNode }) => <footer>{children}</footer>,
+  AlertDialogAction: ({ children, onClick }: { children: ReactNode; onClick?: () => void }) => (
+    <button onClick={onClick}>{children}</button>
+  ),
+  AlertDialogCancel: ({ children }: { children: ReactNode }) => <button>{children}</button>,
+}));
+
+vi.mock('lucide-react', () => ({
+  PlusCircle: () => <span>+</span>,
+  Pencil: () => <span>P</span>,
+  Trash2: () => <span>X</span>,
+}));
+
+const mockPlanos: Plano[] = [
+  { id: 'plano-1', nome: 'Mensal', preco: 100, duracaoDias: 30 },
+  { id: 'plano-2', nome: 'Trimestral', preco: 250, duracaoDias: 90 },
+  { id: 'plano-3', nome: 'Anual', preco: 960, duracaoDias: 360 },
+];
+
+describe('PlanosClient', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders without crashing', () => {
+    const { container } = render(<PlanosClient initialPlanos={mockPlanos} />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders the PageHeader with title and description', () => {
+    render(<PlanosClient initialPlanos={mockPlanos} />);
+    expect(screen.getByText('Planos da Academia')).toBeTruthy();
+    expect(screen.getByText(/Gerencie os planos de mensalidade/)).toBeTruthy();
+  });
+
+  it('renders all plan cards', () => {
+    render(<PlanosClient initialPlanos={mockPlanos} />);
+    expect(screen.getAllByTestId('card')).toHaveLength(3);
+    expect(screen.getByText('Mensal')).toBeTruthy();
+    expect(screen.getByText('Trimestral')).toBeTruthy();
+    expect(screen.getByText('Anual')).toBeTruthy();
+  });
+
+  it('displays formatted prices in BRL', () => {
+    render(<PlanosClient initialPlanos={mockPlanos} />);
+    expect(screen.getByText(/R\$\s*100,00/)).toBeTruthy();
+    expect(screen.getByText(/R\$\s*250,00/)).toBeTruthy();
+    expect(screen.getByText(/R\$\s*960,00/)).toBeTruthy();
+  });
+
+  it('displays formatted duration badges', () => {
+    render(<PlanosClient initialPlanos={mockPlanos} />);
+    expect(screen.getByText('mês')).toBeTruthy();
+    expect(screen.getByText('3 meses')).toBeTruthy();
+    expect(screen.getByText('12 meses')).toBeTruthy();
+  });
+
+  it('opens FormPlano in create mode when "Adicionar Plano" is clicked', () => {
+    render(<PlanosClient initialPlanos={mockPlanos} />);
+    fireEvent.click(screen.getByText('Adicionar Plano'));
+    expect(screen.getByTestId('form-plano')).toBeTruthy();
+    expect(screen.getByText('Criando')).toBeTruthy();
+  });
+
+  it('calls createPlanoAction on new plano submit', async () => {
+    const { createPlanoAction } = await import('@/lib/actions/planos');
+    vi.mocked(createPlanoAction).mockResolvedValue({
+      success: true,
+      data: { id: 'new', nome: 'Novo Plano', preco: 150, duracaoDias: 30 },
+    });
+
+    render(<PlanosClient initialPlanos={mockPlanos} />);
+    fireEvent.click(screen.getByText('Adicionar Plano'));
+    fireEvent.click(screen.getByTestId('submit-plano'));
+
+    await waitFor(() => {
+      expect(createPlanoAction).toHaveBeenCalledWith({
+        nome: 'Novo Plano',
+        preco: 150,
+        duracaoDias: 30,
+      });
+      expect(mockNotify.success).toHaveBeenCalled();
+      expect(mockRouter.refresh).toHaveBeenCalled();
+    });
+  });
+
+  it('shows error on createPlanoAction failure', async () => {
+    const { createPlanoAction } = await import('@/lib/actions/planos');
+    vi.mocked(createPlanoAction).mockResolvedValue({ success: false, error: 'Erro ao criar' });
+
+    render(<PlanosClient initialPlanos={mockPlanos} />);
+    fireEvent.click(screen.getByText('Adicionar Plano'));
+    fireEvent.click(screen.getByTestId('submit-plano'));
+
+    await waitFor(() => {
+      expect(mockNotify.error).toHaveBeenCalledWith('Erro ao salvar', 'Erro ao criar');
+    });
+  });
+
+  it('renders with empty planos', () => {
+    render(<PlanosClient initialPlanos={[]} />);
+    expect(screen.getByText('Planos da Academia')).toBeTruthy();
+    expect(screen.queryAllByTestId('card')).toHaveLength(0);
+  });
+
+  it('calls deletePlanoAction when delete is confirmed', async () => {
+    const { deletePlanoAction } = await import('@/lib/actions/planos');
+    vi.mocked(deletePlanoAction).mockResolvedValue({ success: true });
+
+    render(<PlanosClient initialPlanos={mockPlanos} />);
+
+    const deleteButtons = screen.getAllByText('Excluir');
+    fireEvent.click(deleteButtons[0]);
+
+    expect(screen.getByTestId('alert-dialog')).toBeTruthy();
+    const confirmDeleteButtons = screen.getAllByText('Excluir');
+    fireEvent.click(confirmDeleteButtons[confirmDeleteButtons.length - 1]);
+
+    await waitFor(() => {
+      expect(deletePlanoAction).toHaveBeenCalledWith('plano-1');
+      expect(mockNotify.success).toHaveBeenCalled();
+    });
+  });
+});
diff --git a/src/app/dashboard/treinos/treinos-client.test.tsx b/src/app/dashboard/treinos/treinos-client.test.tsx
new file mode 100644
index 00000000..a7fc4bcc
--- /dev/null
+++ b/src/app/dashboard/treinos/treinos-client.test.tsx
@@ -0,0 +1,273 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import TreinosManagementClient from './treinos-client';
+import type { Aluno } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+const mockNotify = { success: vi.fn(), error: vi.fn(), warn: vi.fn() };
+vi.mock('@/hooks/use-app-notification', () => ({
+  useAppNotification: () => mockNotify,
+}));
+
+const mockWorkoutExercises = {
+  objetivo: '',
+  setObjetivo: vi.fn(),
+  exercicios: [] as unknown[],
+  addObjective: vi.fn(),
+  removeExercise: vi.fn(),
+  updateExercise: vi.fn(),
+  hasValidationErrors: vi.fn(() => true),
+  reset: vi.fn(),
+};
+vi.mock('@/hooks/use-workout-exercises', () => ({
+  useWorkoutExercises: () => mockWorkoutExercises,
+}));
+
+vi.mock('@/lib/actions/treinos', () => ({
+  upsertTreinoAction: vi.fn(),
+  batchUpsertTreinoAction: vi.fn(),
+}));
+
+vi.mock('@/ai/flows/workout-generator-flow', () => ({
+  streamWorkoutPlan: vi.fn(),
+}));
+
+vi.mock('@/lib/logger', () => ({
+  Logger: { error: vi.fn(), info: vi.fn(), warn: vi.fn(), debug: vi.fn() },
+}));
+
+vi.mock('@/components/dashboard/aluno/workout-generator', () => ({
+  WorkoutGenerator: ({
+    onGenerate,
+    isGenerating,
+  }: {
+    onGenerate: (d: unknown) => void;
+    isGenerating: boolean;
+  }) => (
+    <div data-testid="workout-generator">
+      <span>{isGenerating ? 'Gerando...' : 'Gerar'}</span>
+      <button data-testid="btn-generate-ai" onClick={() => onGenerate({})}>
+        Gerar IA
+      </button>
+    </div>
+  ),
+}));
+
+vi.mock('@/components/dashboard/aluno/workout-exercise-row', () => ({
+  WorkoutExerciseRow: () => <div data-testid="workout-exercise-row" />,
+}));
+
+vi.mock('@/components/ui/select', () => ({
+  Select: ({
+    children,
+    onValueChange,
+    value,
+  }: {
+    children: ReactNode;
+    onValueChange: (v: string) => void;
+    value?: string;
+  }) => (
+    <select
+      data-testid="aluno-select"
+      value={value ?? ''}
+      onChange={(e) => onValueChange(e.target.value)}
+    >
+      {children}
+    </select>
+  ),
+  SelectContent: ({ children }: { children: ReactNode }) => <>{children}</>,
+  SelectItem: ({ children, value }: { children: ReactNode; value: string }) => (
+    <option value={value}>{children}</option>
+  ),
+  SelectTrigger: () => null,
+  SelectValue: () => null,
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children }: { children: ReactNode }) => <div data-testid="card">{children}</div>,
+  CardHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardTitle: ({ children }: { children: ReactNode }) => <h2>{children}</h2>,
+  CardDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  CardContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardFooter: ({ children }: { children: ReactNode }) => <footer>{children}</footer>,
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    disabled,
+  }: {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+  }) => (
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: (props: React.InputHTMLAttributes<HTMLInputElement>) => <input {...props} />,
+}));
+
+vi.mock('@/components/ui/label', () => ({
+  Label: ({ children }: { children: ReactNode }) => <label>{children}</label>,
+}));
+
+const mockAlunos: Aluno[] = [
+  {
+    id: 'aluno-1',
+    nomeCompleto: 'João Silva',
+    cpf: '123.456.789-00',
+    email: 'joao@test.com',
+    telefone: '(11) 99999-9999',
+    dataNascimento: '1990-01-01',
+    dataCadastro: '2023-01-01',
+    fotoUrl: '',
+    statusMatricula: 'ATIVA',
+    nivel: 1,
+    exp: 0,
+    streakDiasSeguidos: 0,
+    treinosNoMes: 0,
+    ultimoTreinoData: null,
+  },
+  {
+    id: 'aluno-2',
+    nomeCompleto: 'Maria Santos',
+    cpf: '987.654.321-00',
+    email: 'maria@test.com',
+    telefone: '(11) 88888-8888',
+    dataNascimento: '1995-05-15',
+    dataCadastro: '2023-06-01',
+    fotoUrl: '',
+    statusMatricula: 'ATIVA',
+    nivel: 3,
+    exp: 150,
+    streakDiasSeguidos: 5,
+    treinosNoMes: 12,
+    ultimoTreinoData: '2024-01-10',
+  },
+];
+
+describe('TreinosManagementClient', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockWorkoutExercises.objetivo = '';
+    mockWorkoutExercises.exercicios = [];
+    mockWorkoutExercises.hasValidationErrors.mockReturnValue(true);
+  });
+
+  it('renders without crashing', () => {
+    const { container } = render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders the page title with Passo 1', () => {
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    expect(screen.getByText(/Passo 1: Selecionar Aluno/)).toBeTruthy();
+  });
+
+  it('renders the student select with all students', () => {
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    expect(screen.getByText('João Silva')).toBeTruthy();
+    expect(screen.getByText('Maria Santos')).toBeTruthy();
+  });
+
+  it('does not show Step 2 when no student is selected', () => {
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    expect(screen.queryByText(/Passo 2/)).toBeNull();
+  });
+
+  it('shows Step 2 when a student is selected', () => {
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    const select = screen.getByTestId('aluno-select');
+    fireEvent.change(select, { target: { value: 'aluno-1' } });
+    expect(screen.getByText(/Passo 2: Criar Treino Manual para João Silva/)).toBeTruthy();
+  });
+
+  it('shows WorkoutGenerator when a student is selected', () => {
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    fireEvent.change(screen.getByTestId('aluno-select'), { target: { value: 'aluno-1' } });
+    expect(screen.getByTestId('workout-generator')).toBeTruthy();
+  });
+
+  it('calls upsertTreinoAction on save when validation passes', async () => {
+    const { upsertTreinoAction } = await import('@/lib/actions/treinos');
+    vi.mocked(upsertTreinoAction).mockResolvedValue({ success: true });
+
+    mockWorkoutExercises.hasValidationErrors.mockReturnValue(false);
+    mockWorkoutExercises.exercicios = [
+      {
+        id: 'ex-1',
+        nomeExercicio: 'Supino',
+        series: 3,
+        repeticoes: '10-12',
+        observacoes: null,
+        descricao: null,
+      },
+    ];
+    mockWorkoutExercises.objetivo = 'Peito e Tríceps';
+
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    fireEvent.change(screen.getByTestId('aluno-select'), { target: { value: 'aluno-1' } });
+
+    fireEvent.click(screen.getByText(/Salvar Treino/));
+
+    await waitFor(() => {
+      expect(upsertTreinoAction).toHaveBeenCalled();
+      expect(mockNotify.success).toHaveBeenCalledWith('Treino Salvo!');
+    });
+  });
+
+  it('shows error notification when upsertTreinoAction fails', async () => {
+    const { upsertTreinoAction } = await import('@/lib/actions/treinos');
+    vi.mocked(upsertTreinoAction).mockResolvedValue({ success: false, error: 'Erro de banco' });
+
+    mockWorkoutExercises.hasValidationErrors.mockReturnValue(false);
+    mockWorkoutExercises.exercicios = [
+      {
+        id: 'ex-1',
+        nomeExercicio: 'Supino',
+        series: 3,
+        repeticoes: '10-12',
+        observacoes: null,
+        descricao: null,
+      },
+    ];
+    mockWorkoutExercises.objetivo = 'Peito';
+
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    fireEvent.change(screen.getByTestId('aluno-select'), { target: { value: 'aluno-1' } });
+    fireEvent.click(screen.getByText(/Salvar Treino/));
+
+    await waitFor(() => {
+      expect(mockNotify.error).toHaveBeenCalled();
+    });
+  });
+
+  it('calls addObjective when "Adicionar Exercício" is clicked', () => {
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    fireEvent.change(screen.getByTestId('aluno-select'), { target: { value: 'aluno-1' } });
+
+    fireEvent.click(screen.getByText(/Adicionar Exercício/));
+    expect(mockWorkoutExercises.addObjective).toHaveBeenCalled();
+  });
+
+  it('disables save button when exercicios is empty', () => {
+    mockWorkoutExercises.exercicios = [];
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    fireEvent.change(screen.getByTestId('aluno-select'), { target: { value: 'aluno-1' } });
+
+    const saveBtn = screen.getByText(/Salvar Treino/);
+    expect(saveBtn.hasAttribute('disabled')).toBe(true);
+  });
+
+  it('shows error when trying to save without validation and no selectedAlunoId', () => {
+    mockWorkoutExercises.hasValidationErrors.mockReturnValue(true);
+    render(<TreinosManagementClient initialAlunos={mockAlunos} />);
+    const saveBtn = screen.queryByText(/Salvar Treino/);
+    expect(saveBtn).toBeNull();
+  });
+});
diff --git a/src/app/login/page.test.tsx b/src/app/login/page.test.tsx
new file mode 100644
index 00000000..f1049e6e
--- /dev/null
+++ b/src/app/login/page.test.tsx
@@ -0,0 +1,101 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import LoginPage from './page';
+import type { ReactNode } from 'react';
+
+vi.mock('react', async () => {
+  const actual = await vi.importActual('react');
+  return {
+    ...actual,
+    useActionState: () => [{ error: undefined }, vi.fn(), false],
+  };
+});
+
+vi.mock('@/app/actions/auth', () => ({
+  login: vi.fn(),
+}));
+
+vi.mock('next/link', () => ({
+  default: ({ children, href }: { children: ReactNode; href: string }) => (
+    <a href={href}>{children}</a>
+  ),
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+  CardHeader: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+  CardTitle: ({ children }: { children: ReactNode }) => <h2>{children}</h2>,
+  CardDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  CardContent: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+  CardFooter: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    type,
+    disabled,
+    variant,
+    ...props
+  }: {
+    children: ReactNode;
+    type?: string;
+    disabled?: boolean;
+    variant?: string;
+    [key: string]: unknown;
+  }) => (
+    <button
+      type={type as 'button' | 'reset' | 'submit'}
+      disabled={disabled}
+      data-variant={variant}
+      {...props}
+    >
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: (props: Record<string, unknown>) => <input {...props} />,
+}));
+
+vi.mock('@/components/ui/separator', () => ({
+  Separator: ({ className }: { className?: string }) => <hr className={className} />,
+}));
+
+describe('LoginPage', () => {
+  it('renders the login form', () => {
+    render(<LoginPage />);
+    expect(screen.getByText('Five Star')).toBeTruthy();
+    expect(screen.getByText('SISTEMA DE GESTÃO')).toBeTruthy();
+  });
+
+  it('renders email and password inputs', () => {
+    render(<LoginPage />);
+    expect(screen.getByLabelText('Email corporativo')).toBeTruthy();
+    expect(screen.getByLabelText('Senha de acesso')).toBeTruthy();
+  });
+
+  it('renders submit button', () => {
+    render(<LoginPage />);
+    expect(screen.getByText('Entrar no Sistema')).toBeTruthy();
+  });
+
+  it('renders link to aluno portal', () => {
+    render(<LoginPage />);
+    expect(screen.getByText('Acessar Portal do Aluno')).toBeTruthy();
+  });
+
+  it('renders copyright notice', () => {
+    render(<LoginPage />);
+    expect(screen.getByText((content) => content.includes('Five Star Fitness'))).toBeTruthy();
+  });
+});
diff --git a/src/components/WorkoutSession.test.tsx b/src/components/WorkoutSession.test.tsx
new file mode 100644
index 00000000..868fc5a8
--- /dev/null
+++ b/src/components/WorkoutSession.test.tsx
@@ -0,0 +1,242 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { WorkoutSession } from './WorkoutSession';
+import type { Treino } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+vi.mock('react-timer-hook', () => ({
+  useTimer: () => ({
+    seconds: 0,
+    minutes: 0,
+    isRunning: false,
+    restart: vi.fn(),
+  }),
+}));
+
+vi.mock('@/ai/flows/workout-feedback-flow', () => ({
+  generateWorkoutFeedback: vi.fn(),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    disabled,
+    variant,
+  }: {
+    children: ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    variant?: string;
+  }) => (
+    <button onClick={onClick} disabled={disabled} data-variant={variant}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div data-testid="card" className={className}>
+      {children}
+    </div>
+  ),
+  CardHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardTitle: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <h2 className={className}>{children}</h2>
+  ),
+  CardDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
+  CardContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardFooter: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <footer className={className}>{children}</footer>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: (props: React.InputHTMLAttributes<HTMLInputElement>) => <input {...props} />,
+}));
+
+vi.mock('@/components/ui/label', () => ({
+  Label: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <label className={className}>{children}</label>
+  ),
+}));
+
+const mockTreino: Treino = {
+  id: 'treino-1',
+  alunoId: 'aluno-1',
+  instrutorId: 'instrutor-1',
+  objetivo: 'Peito e Tríceps',
+  diaSemana: 1,
+  dataCriacao: '2024-01-01',
+  exercicios: [
+    {
+      id: 'ex-1',
+      nomeExercicio: 'Supino Reto',
+      series: 3,
+      repeticoes: '10-12',
+      observacoes: 'Controlar a descida',
+      descricao: 'Exercício para peito',
+    },
+    {
+      id: 'ex-2',
+      nomeExercicio: 'Tríceps Pulley',
+      series: 3,
+      repeticoes: '12-15',
+      observacoes: null,
+      descricao: 'Exercício para tríceps',
+    },
+  ],
+};
+
+const mockOnFinish = vi.fn();
+const mockOnCancel = vi.fn();
+
+describe('WorkoutSession', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(mockOnFinish).mockResolvedValue(undefined);
+  });
+
+  it('renders without crashing', () => {
+    const { container } = render(
+      <WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />
+    );
+    expect(container).toBeTruthy();
+  });
+
+  it('renders the first exercise name', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    expect(screen.getByText('Supino Reto')).toBeTruthy();
+  });
+
+  it('shows exercise progress indicator', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    expect(screen.getByText('Exercício 1 de 2')).toBeTruthy();
+  });
+
+  it('renders the planned sets and reps', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    expect(screen.getByText(/Planejado: 3 séries x 10-12 reps/)).toBeTruthy();
+  });
+
+  it('renders observations when available', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    expect(screen.getByText('Obs: Controlar a descida')).toBeTruthy();
+  });
+
+  it('renders series inputs for the current exercise (3 sets)', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    const pesoInputs = screen.getAllByPlaceholderText('Peso (kg)');
+    const repsInputs = screen.getAllByPlaceholderText('Reps');
+    expect(pesoInputs.length).toBe(3);
+    expect(repsInputs.length).toBe(3);
+  });
+
+  it('disables "Anterior" button on first exercise', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    const prevBtn = screen.getByText(/Anterior/);
+    expect(prevBtn.hasAttribute('disabled')).toBe(true);
+  });
+
+  it('navigates to next exercise when "Próximo" is clicked', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText(/Próximo/));
+    expect(screen.getByText('Tríceps Pulley')).toBeTruthy();
+    expect(screen.getByText('Exercício 2 de 2')).toBeTruthy();
+  });
+
+  it('shows "Finalizar Treino" on last exercise', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText(/Próximo/));
+    expect(screen.getByText('Finalizar Treino')).toBeTruthy();
+  });
+
+  it('navigates back with "Anterior"', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText(/Próximo/));
+    expect(screen.getByText('Tríceps Pulley')).toBeTruthy();
+
+    fireEvent.click(screen.getByText(/Anterior/));
+    expect(screen.getByText('Supino Reto')).toBeTruthy();
+  });
+
+  it('calls onFinish and shows completion screen', async () => {
+    const { generateWorkoutFeedback } = await import('@/ai/flows/workout-feedback-flow');
+    vi.mocked(generateWorkoutFeedback).mockResolvedValue({
+      title: 'Treino Concluído!',
+      message: 'Excelente trabalho!',
+    });
+
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText(/Próximo/));
+    fireEvent.click(screen.getByText(/Finalizar Treino/));
+
+    await waitFor(() => {
+      expect(mockOnFinish).toHaveBeenCalled();
+      expect(screen.getByText('Treino Finalizado!')).toBeTruthy();
+    });
+  });
+
+  it('shows loading state while generating feedback', async () => {
+    const { generateWorkoutFeedback } = await import('@/ai/flows/workout-feedback-flow');
+    let resolveFeedback!: (v: { title: string; message: string }) => void;
+    vi.mocked(generateWorkoutFeedback).mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          resolveFeedback = resolve;
+        })
+    );
+
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText(/Próximo/));
+    fireEvent.click(screen.getByText(/Finalizar Treino/));
+
+    await waitFor(() => {
+      expect(screen.getByText(/Gerando seu feedback personalizado/)).toBeTruthy();
+    });
+
+    resolveFeedback!({ title: 'Feito!', message: 'Bom treino!' });
+
+    await waitFor(() => {
+      expect(screen.getByText('Feito!')).toBeTruthy();
+    });
+  });
+
+  it('calls onCancel when "Fechar Treino" is clicked', async () => {
+    const { generateWorkoutFeedback } = await import('@/ai/flows/workout-feedback-flow');
+    vi.mocked(generateWorkoutFeedback).mockResolvedValue({
+      title: 'Concluído',
+      message: 'Bom!',
+    });
+
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText(/Próximo/));
+    fireEvent.click(screen.getByText(/Finalizar Treino/));
+
+    await waitFor(() => {
+      expect(screen.getByText('Fechar Treino')).toBeTruthy();
+    });
+
+    fireEvent.click(screen.getByText('Fechar Treino'));
+    expect(mockOnCancel).toHaveBeenCalled();
+  });
+
+  it('toggles series completion', () => {
+    render(<WorkoutSession treino={mockTreino} onFinish={mockOnFinish} onCancel={mockOnCancel} />);
+    const checkButtons = screen
+      .getAllByRole('button')
+      .filter(
+        (btn) => btn.querySelector('svg') !== null && btn.getAttribute('data-variant') === 'outline'
+      );
+    if (checkButtons.length > 0) {
+      fireEvent.click(checkButtons[0]);
+    }
+    const updatedCheckButtons = screen
+      .getAllByRole('button')
+      .filter(
+        (btn) => btn.querySelector('svg') !== null && btn.getAttribute('data-variant') === 'default'
+      );
+    expect(updatedCheckButtons.length).toBeGreaterThanOrEqual(1);
+  });
+});
diff --git a/src/components/dashboard-nav.test.tsx b/src/components/dashboard-nav.test.tsx
new file mode 100644
index 00000000..7584b20b
--- /dev/null
+++ b/src/components/dashboard-nav.test.tsx
@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { DashboardNav, DashboardNavBottom } from './dashboard-nav';
+import type { ReactNode } from 'react';
+import { usePathname } from 'next/navigation';
+
+type MockChildren = { children?: ReactNode };
+
+vi.mock('next/navigation', () => ({
+  usePathname: vi.fn(() => '/dashboard'),
+}));
+
+vi.mock('next/link', () => ({
+  default: ({ children, href }: MockChildren & { href: string }) => (
+    <a data-testid="nav-link" href={href}>
+      {children}
+    </a>
+  ),
+}));
+
+vi.mock('@/components/ui/sidebar', () => ({
+  SidebarMenu: ({ children, className }: MockChildren & { className?: string }) => (
+    <nav className={className} data-testid="sidebar-menu">
+      {children}
+    </nav>
+  ),
+  SidebarMenuItem: ({ children }: MockChildren) => (
+    <div data-testid="sidebar-menu-item">{children}</div>
+  ),
+  SidebarMenuButton: ({
+    children,
+    isActive,
+    tooltip,
+  }: MockChildren & { isActive?: boolean; tooltip?: string }) => (
+    <button data-testid="sidebar-menu-button" data-is-active={isActive} data-tooltip={tooltip}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/app/actions/auth', () => ({
+  logout: vi.fn(),
+}));
+
+vi.mock('@/lib/constants', () => ({
+  FINANCIAL_ROUTES: ['/dashboard/financeiro', '/dashboard/planos'],
+}));
+
+vi.mock('lucide-react', () => {
+  const MockIcon = ({ 'data-testid': testId }: { 'data-testid'?: string }) => (
+    <span data-testid={testId || 'icon'} />
+  );
+  return {
+    LayoutDashboard: () => <MockIcon data-testid="icon-dashboard" />,
+    Users: () => <MockIcon data-testid="icon-users" />,
+    Dumbbell: () => <MockIcon data-testid="icon-dumbbell" />,
+    DollarSign: () => <MockIcon data-testid="icon-dollar" />,
+    FileText: () => <MockIcon data-testid="icon-file" />,
+    Settings: () => <MockIcon data-testid="icon-settings" />,
+    LogOut: () => <MockIcon data-testid="icon-logout" />,
+    FlaskConical: () => <MockIcon data-testid="icon-flask" />,
+  };
+});
+
+describe('DashboardNav', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(usePathname).mockReturnValue('/dashboard');
+  });
+
+  it('renders without throwing', () => {
+    const { container } = render(<DashboardNav role="INSTRUTOR" />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders Dashboard link', () => {
+    render(<DashboardNav role="INSTRUTOR" />);
+    expect(screen.getByText('Dashboard')).toBeTruthy();
+  });
+
+  it('renders Alunos link', () => {
+    render(<DashboardNav role="INSTRUTOR" />);
+    expect(screen.getByText('Alunos')).toBeTruthy();
+  });
+
+  it('renders Treinos link', () => {
+    render(<DashboardNav role="INSTRUTOR" />);
+    expect(screen.getByText('Treinos')).toBeTruthy();
+  });
+
+  it('renders Planos link for GERENTE role', () => {
+    render(<DashboardNav role="GERENTE" />);
+    expect(screen.getByText('Planos')).toBeTruthy();
+  });
+
+  it('does not render Financeiro for INSTRUTOR role', () => {
+    render(<DashboardNav role="INSTRUTOR" />);
+    expect(screen.queryByText('Financeiro')).toBeNull();
+  });
+
+  it('does not render Planos for INSTRUTOR role', () => {
+    render(<DashboardNav role="INSTRUTOR" />);
+    expect(screen.queryByText('Planos')).toBeNull();
+  });
+
+  it('renders Financeiro for GERENTE role', () => {
+    render(<DashboardNav role="GERENTE" />);
+    expect(screen.getByText('Financeiro')).toBeTruthy();
+  });
+
+  it('marks active link based on pathname', () => {
+    vi.mocked(usePathname).mockReturnValue('/dashboard/alunos');
+
+    render(<DashboardNav role="GERENTE" />);
+    const menuButtons = screen.getAllByTestId('sidebar-menu-button');
+    const activeButton = menuButtons.find((btn) => btn.getAttribute('data-is-active') === 'true');
+    expect(activeButton).toBeTruthy();
+  });
+
+  it('marks Dashboard as active only on exact path', () => {
+    vi.mocked(usePathname).mockReturnValue('/dashboard');
+
+    render(<DashboardNav role="INSTRUTOR" />);
+    const menuButtons = screen.getAllByTestId('sidebar-menu-button');
+    const activeButtons = menuButtons.filter(
+      (btn) => btn.getAttribute('data-is-active') === 'true'
+    );
+    expect(activeButtons.length).toBe(1);
+  });
+
+  it('links have correct href attributes', () => {
+    render(<DashboardNav role="INSTRUTOR" />);
+    const links = screen.getAllByTestId('nav-link');
+    const hrefs = links.map((link) => link.getAttribute('href'));
+    expect(hrefs).toContain('/dashboard');
+    expect(hrefs).toContain('/dashboard/alunos');
+    expect(hrefs).toContain('/dashboard/treinos');
+  });
+});
+
+describe('DashboardNavBottom', () => {
+  it('renders without throwing', () => {
+    const { container } = render(<DashboardNavBottom />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders Configurações', () => {
+    render(<DashboardNavBottom />);
+    expect(screen.getByText('Configurações')).toBeTruthy();
+  });
+
+  it('renders Sair', () => {
+    render(<DashboardNavBottom />);
+    expect(screen.getByText('Sair')).toBeTruthy();
+  });
+});
diff --git a/src/components/dashboard/aluno/card-feedback.test.tsx b/src/components/dashboard/aluno/card-feedback.test.tsx
new file mode 100644
index 00000000..a609a1cd
--- /dev/null
+++ b/src/components/dashboard/aluno/card-feedback.test.tsx
@@ -0,0 +1,55 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { CardFeedback } from './card-feedback';
+import type { ReactNode } from 'react';
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div data-testid="card" className={className}>
+      {children}
+    </div>
+  ),
+  CardHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  CardTitle: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <h3 className={className}>{children}</h3>
+  ),
+  CardContent: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+}));
+
+vi.mock('@/components/ui/skeleton', () => ({
+  Skeleton: ({ className }: { className?: string }) => (
+    <div data-testid="skeleton" className={className} />
+  ),
+}));
+
+describe('CardFeedback', () => {
+  it('returns null when feedback is null and not loading', () => {
+    const { container } = render(<CardFeedback feedback={null} isLoading={false} />);
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('shows loading skeletons when isLoading is true', () => {
+    render(<CardFeedback feedback={null} isLoading={true} />);
+    expect(screen.getByText(/Pulsando Bio-Dados/i)).toBeTruthy();
+    const skeletons = screen.getAllByTestId('skeleton');
+    expect(skeletons.length).toBe(3);
+  });
+
+  it('renders feedback title and message when provided', () => {
+    const feedback = {
+      title: 'Excelente treino!',
+      message: 'Você está evoluindo bem, continue assim.',
+    };
+    render(<CardFeedback feedback={feedback} isLoading={false} />);
+    expect(screen.getByText('Excelente treino!')).toBeTruthy();
+    expect(screen.getByText(/Você está evoluindo bem/)).toBeTruthy();
+  });
+
+  it('does not render loading state when feedback is provided', () => {
+    const feedback = { title: 'Bom', message: 'OK' };
+    render(<CardFeedback feedback={feedback} isLoading={false} />);
+    expect(screen.queryByText(/Pulsando Bio-Dados/i)).toBeNull();
+  });
+});
diff --git a/src/components/dashboard/aluno/card-matricula.test.tsx b/src/components/dashboard/aluno/card-matricula.test.tsx
new file mode 100644
index 00000000..b6f10f02
--- /dev/null
+++ b/src/components/dashboard/aluno/card-matricula.test.tsx
@@ -0,0 +1,70 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { CardMatricula } from './card-matricula';
+import type { Aluno } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+  CardContent: ({ children, className }: { children: ReactNode; className?: string }) => (
+    <div className={className}>{children}</div>
+  ),
+}));
+
+const baseAluno: Aluno = {
+  id: '1',
+  nomeCompleto: 'João Silva',
+  cpf: '123.456.789-00',
+  email: 'joao@example.com',
+  telefone: '(11) 99999-9999',
+  dataNascimento: null,
+  dataCadastro: '2024-01-01',
+  fotoUrl: null,
+  statusMatricula: 'ATIVA',
+  nivel: 1,
+  exp: 0,
+  streakDiasSeguidos: 0,
+  treinosNoMes: 0,
+  ultimoTreinoData: null,
+  dataVencimento: '2026-06-15',
+};
+
+describe('CardMatricula', () => {
+  it('renders null when aluno is null', () => {
+    const { container } = render(<CardMatricula aluno={null} />);
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('renders ATIVA status correctly', () => {
+    render(<CardMatricula aluno={baseAluno} />);
+    expect(screen.getByText('Matrícula Ativa')).toBeTruthy();
+    expect(screen.getByText('Status do Plano')).toBeTruthy();
+  });
+
+  it('renders INADIMPLENTE status correctly', () => {
+    const aluno = { ...baseAluno, statusMatricula: 'INADIMPLENTE' as const };
+    render(<CardMatricula aluno={aluno} />);
+    expect(screen.getByText('Pagamento Pendente')).toBeTruthy();
+  });
+
+  it('renders INATIVA status correctly', () => {
+    const aluno = { ...baseAluno, statusMatricula: 'INATIVA' as const };
+    render(<CardMatricula aluno={aluno} />);
+    expect(screen.getByText('Matrícula Inativa')).toBeTruthy();
+  });
+
+  it('displays formatted expiration date', () => {
+    render(<CardMatricula aluno={baseAluno} />);
+    expect(screen.getByText('Vencimento')).toBeTruthy();
+    const dateEl = screen.getByText((content) => content.includes('2026'));
+    expect(dateEl).toBeTruthy();
+  });
+
+  it('displays fallback date when dataVencimento is null', () => {
+    const aluno = { ...baseAluno, dataVencimento: null };
+    render(<CardMatricula aluno={aluno} />);
+    expect(screen.getByText('--/--/----')).toBeTruthy();
+  });
+});
diff --git a/src/components/dashboard/aluno/card-treino.test.tsx b/src/components/dashboard/aluno/card-treino.test.tsx
new file mode 100644
index 00000000..e564e04c
--- /dev/null
+++ b/src/components/dashboard/aluno/card-treino.test.tsx
@@ -0,0 +1,281 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { CardTreino } from './card-treino';
+import type { Treino } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+type MockChildren = { children?: ReactNode };
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children, glass }: MockChildren & { glass?: boolean }) => (
+    <div data-testid="card" data-glass={glass}>
+      {children}
+    </div>
+  ),
+  CardHeader: ({ children }: MockChildren) => <div data-testid="card-header">{children}</div>,
+  CardTitle: ({ children }: MockChildren) => <h2>{children}</h2>,
+  CardDescription: ({ children }: MockChildren) => <p>{children}</p>,
+  CardContent: ({ children }: MockChildren) => <div data-testid="card-content">{children}</div>,
+  CardFooter: ({ children }: MockChildren) => <footer data-testid="card-footer">{children}</footer>,
+}));
+
+vi.mock('@/components/ui/checkbox', () => ({
+  Checkbox: ({
+    id,
+    checked,
+    onCheckedChange,
+  }: {
+    id?: string;
+    checked?: boolean;
+    onCheckedChange?: () => void;
+  }) => (
+    <input
+      type="checkbox"
+      data-testid={`checkbox-${id}`}
+      checked={checked}
+      onChange={onCheckedChange}
+    />
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    disabled,
+    variant,
+  }: MockChildren & { onClick?: () => void; disabled?: boolean; variant?: string }) => (
+    <button onClick={onClick} disabled={disabled} data-variant={variant}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('lucide-react', () => ({
+  CalendarOff: () => <span data-testid="calendar-off-icon" />,
+  Sparkles: () => <span>✨</span>,
+  BrainCircuit: () => <span data-testid="brain-icon" />,
+  Info: () => <span>ℹ️</span>,
+}));
+
+vi.mock('@/components/ui/circular-progress', () => ({
+  CircularProgress: ({ value }: { value: number }) => (
+    <div data-testid="circular-progress" data-value={value} />
+  ),
+}));
+
+vi.mock('@/lib/utils', () => ({
+  cn: (...args: unknown[]) => args.filter(Boolean).join(' '),
+}));
+
+const mockUseWorkoutTracker = vi.fn();
+vi.mock('@/hooks/use-workout-tracker', () => ({
+  useWorkoutTracker: (...args: unknown[]) => mockUseWorkoutTracker(...args),
+}));
+
+const mockTreino: Treino = {
+  id: 'treino-1',
+  alunoId: 'aluno-1',
+  instrutorId: null,
+  objetivo: 'Treino A - Peito',
+  exercicios: [
+    {
+      id: 'ex-1',
+      nomeExercicio: 'Supino Reto',
+      series: 4,
+      repeticoes: '10-12',
+      observacoes: null,
+      descricao: null,
+    },
+    {
+      id: 'ex-2',
+      nomeExercicio: 'Crucifixo',
+      series: 3,
+      repeticoes: '12-15',
+      observacoes: null,
+      descricao: null,
+    },
+  ],
+  diaSemana: 1,
+  dataCriacao: '2024-01-01',
+};
+
+describe('CardTreino', () => {
+  const mockOnFinishTraining = vi.fn();
+  const mockOnViewExercicio = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockUseWorkoutTracker.mockReturnValue({
+      checkedExercises: {},
+      handleCheckChange: vi.fn(),
+    });
+  });
+
+  it('renders rest day message when treino is null', () => {
+    render(
+      <CardTreino
+        treino={null}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByText('Dia de Descanso Ativo')).toBeTruthy();
+  });
+
+  it('renders rest day description when treino is null', () => {
+    render(
+      <CardTreino
+        treino={null}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByText(/Aproveite para focar/)).toBeTruthy();
+  });
+
+  it('renders treino objetivo as title', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByText('Treino A - Peito')).toBeTruthy();
+  });
+
+  it('renders exercise names', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByText('Supino Reto')).toBeTruthy();
+    expect(screen.getByText('Crucifixo')).toBeTruthy();
+  });
+
+  it('renders series x reps for exercises', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByText('4 x 10-12 • REPETIÇÕES')).toBeTruthy();
+    expect(screen.getByText('3 x 12-15 • REPETIÇÕES')).toBeTruthy();
+  });
+
+  it('renders checkboxes for each exercise', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByTestId('checkbox-ex-1')).toBeTruthy();
+    expect(screen.getByTestId('checkbox-ex-2')).toBeTruthy();
+  });
+
+  it('renders finish button', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByText('Finalizar e Avaliar Treino')).toBeTruthy();
+  });
+
+  it('finish button is disabled when no exercises checked', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    const button = screen.getByText('Finalizar e Avaliar Treino').closest('button');
+    expect(button?.disabled).toBe(true);
+  });
+
+  it('shows loading state when feedback is loading', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={true}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByText('Processando análise...')).toBeTruthy();
+  });
+
+  it('disables finish button when feedback is loading', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={true}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    const button = screen.getByText('Processando análise...').closest('button');
+    expect(button?.disabled).toBe(true);
+  });
+
+  it('renders circular progress component', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByTestId('circular-progress')).toBeTruthy();
+  });
+
+  it('renders progress percentage description', () => {
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    expect(screen.getByText(/Desempenho atual:/)).toBeTruthy();
+  });
+
+  it('calls onFinishTraining when finish is clicked with checked exercises', () => {
+    mockUseWorkoutTracker.mockReturnValue({
+      checkedExercises: { 'ex-1': true, 'ex-2': false },
+      handleCheckChange: vi.fn(),
+    });
+
+    render(
+      <CardTreino
+        treino={mockTreino}
+        onFinishTraining={mockOnFinishTraining}
+        isFeedbackLoading={false}
+        onViewExercicio={mockOnViewExercicio}
+      />
+    );
+    fireEvent.click(screen.getByText('Finalizar e Avaliar Treino'));
+    expect(mockOnFinishTraining).toHaveBeenCalledWith(['ex-1']);
+  });
+});
diff --git a/src/components/dashboard/aluno/exercicio-viewer.test.tsx b/src/components/dashboard/aluno/exercicio-viewer.test.tsx
new file mode 100644
index 00000000..5829cc12
--- /dev/null
+++ b/src/components/dashboard/aluno/exercicio-viewer.test.tsx
@@ -0,0 +1,83 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { ExercicioViewer } from './exercicio-viewer';
+import type { Exercicio } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+vi.mock('@/components/ui/alert-dialog', () => ({
+  AlertDialog: ({
+    children,
+    open,
+    onOpenChange,
+  }: {
+    children: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+  }) =>
+    open ? (
+      <div data-testid="alert-dialog" data-on-open-change={onOpenChange}>
+        {children}
+      </div>
+    ) : null,
+  AlertDialogContent: ({ children }: { children: ReactNode }) => (
+    <div data-testid="alert-dialog-content">{children}</div>
+  ),
+  AlertDialogHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+  AlertDialogTitle: ({ children }: { children: ReactNode }) => <h2>{children}</h2>,
+  AlertDialogFooter: ({ children }: { children: ReactNode }) => <footer>{children}</footer>,
+  AlertDialogCancel: ({ children, onClick }: { children: ReactNode; onClick?: () => void }) => (
+    <button data-testid="alert-cancel" onClick={onClick}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/scroll-area', () => ({
+  ScrollArea: ({ children }: { children: ReactNode }) => <div>{children}</div>,
+}));
+
+const mockExercicio: Exercicio = {
+  id: 'ex-1',
+  nomeExercicio: 'Supino Reto',
+  series: 4,
+  repeticoes: '12',
+  observacoes: 'Manter cotovelos firmes',
+  descricao: 'Deite-se em um banco reto e empurre a barra para cima.',
+};
+
+describe('ExercicioViewer', () => {
+  it('returns null when exercicio is null', () => {
+    const { container } = render(
+      <ExercicioViewer exercicio={null} isOpen={true} onOpenChange={vi.fn()} />
+    );
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('returns null when isOpen is false', () => {
+    const { container } = render(
+      <ExercicioViewer exercicio={mockExercicio} isOpen={false} onOpenChange={vi.fn()} />
+    );
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('renders exercise name when open with exercise', () => {
+    render(<ExercicioViewer exercicio={mockExercicio} isOpen={true} onOpenChange={vi.fn()} />);
+    expect(screen.getByText('Supino Reto')).toBeTruthy();
+  });
+
+  it('renders exercise description', () => {
+    render(<ExercicioViewer exercicio={mockExercicio} isOpen={true} onOpenChange={vi.fn()} />);
+    expect(screen.getByText(/Deite-se em um banco reto/)).toBeTruthy();
+  });
+
+  it('shows fallback when description is empty', () => {
+    const exercicio = { ...mockExercicio, descricao: '' };
+    render(<ExercicioViewer exercicio={exercicio} isOpen={true} onOpenChange={vi.fn()} />);
+    expect(screen.getByText(/Nenhuma descrição disponível/)).toBeTruthy();
+  });
+
+  it('renders close button', () => {
+    render(<ExercicioViewer exercicio={mockExercicio} isOpen={true} onOpenChange={vi.fn()} />);
+    expect(screen.getByText('Fechar')).toBeTruthy();
+  });
+});
diff --git a/src/components/dashboard/aluno/workout-editor.test.tsx b/src/components/dashboard/aluno/workout-editor.test.tsx
new file mode 100644
index 00000000..b1f9e9c5
--- /dev/null
+++ b/src/components/dashboard/aluno/workout-editor.test.tsx
@@ -0,0 +1,213 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { WorkoutEditor } from './workout-editor';
+import type { Treino } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+type MockChildren = { children?: ReactNode };
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children }: MockChildren) => <div data-testid="card">{children}</div>,
+  CardHeader: ({ children }: MockChildren) => <div>{children}</div>,
+  CardTitle: ({ children }: MockChildren) => <h2>{children}</h2>,
+  CardDescription: ({ children }: MockChildren) => <p>{children}</p>,
+  CardContent: ({ children }: MockChildren) => <div>{children}</div>,
+  CardFooter: ({ children }: MockChildren) => <footer>{children}</footer>,
+}));
+
+vi.mock('@/components/ui/label', () => ({
+  Label: ({ children, htmlFor }: { children?: ReactNode; htmlFor?: string }) => (
+    <label htmlFor={htmlFor}>{children}</label>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: ({
+    id,
+    placeholder,
+    value,
+    onChange,
+  }: {
+    id?: string;
+    placeholder?: string;
+    value?: string;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+  }) => (
+    <input
+      data-testid={id || placeholder}
+      id={id}
+      placeholder={placeholder}
+      value={value}
+      onChange={onChange}
+    />
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    variant,
+  }: {
+    children?: ReactNode;
+    onClick?: () => void;
+    variant?: string;
+  }) => (
+    <button onClick={onClick} data-variant={variant}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('lucide-react', () => ({
+  PlusCircle: () => <span>+</span>,
+  Save: () => <span>💾</span>,
+  Dumbbell: () => <span>🏋️</span>,
+}));
+
+const mockToast = vi.fn();
+vi.mock('@/hooks/use-toast', () => ({
+  useToast: vi.fn(() => ({ toast: mockToast })),
+}));
+
+const mockUseWorkoutExercises = vi.fn();
+vi.mock('@/hooks/use-workout-exercises', () => ({
+  useWorkoutExercises: (...args: unknown[]) => mockUseWorkoutExercises(...args),
+}));
+
+vi.mock('@/components/dashboard/aluno/workout-exercise-row', () => ({
+  WorkoutExerciseRow: ({
+    exercise,
+    index,
+  }: {
+    exercise: Record<string, unknown>;
+    index: number;
+  }) => (
+    <div data-testid="exercise-row">
+      <span data-testid="exercise-index">{index}</span>
+      <span data-testid="exercise-name">{String(exercise.nomeExercicio || '')}</span>
+    </div>
+  ),
+}));
+
+describe('WorkoutEditor', () => {
+  const mockOnSave = vi.fn();
+  const mockOnCancel = vi.fn();
+
+  const defaultHookReturn = {
+    objetivo: '',
+    setObjetivo: vi.fn(),
+    exercicios: [],
+    addObjective: vi.fn(),
+    removeExercise: vi.fn(),
+    updateExercise: vi.fn(),
+    hasValidationErrors: vi.fn(() => false),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockUseWorkoutExercises.mockReturnValue(defaultHookReturn);
+  });
+
+  it('renders without throwing', () => {
+    const { container } = render(
+      <WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />
+    );
+    expect(container).toBeTruthy();
+  });
+
+  it('shows "Criar Novo Treino Pessoal" title when no treino', () => {
+    render(<WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />);
+    expect(screen.getByText('Criar Novo Treino Pessoal')).toBeTruthy();
+  });
+
+  it('shows "Editar Treino Pessoal" title when editing', () => {
+    const treinoToEdit = {
+      id: 'treino-1',
+      alunoId: 'aluno-1',
+      instrutorId: null,
+      objetivo: 'Treino A',
+      exercicios: [],
+      diaSemana: 1,
+      dataCriacao: '2024-01-01',
+    } as Treino;
+
+    render(
+      <WorkoutEditor onSave={mockOnSave} treinoToEdit={treinoToEdit} onCancel={mockOnCancel} />
+    );
+    expect(screen.getByText('Editar Treino Pessoal')).toBeTruthy();
+  });
+
+  it('renders objective input', () => {
+    render(<WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />);
+    expect(screen.getByText('Nome/Objetivo do Treino')).toBeTruthy();
+  });
+
+  it('renders add exercise button', () => {
+    render(<WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />);
+    expect(screen.getByText('Adicionar Exercício Manualmente')).toBeTruthy();
+  });
+
+  it('calls addObjective when add exercise is clicked', () => {
+    const addObjective = vi.fn();
+    mockUseWorkoutExercises.mockReturnValue({ ...defaultHookReturn, addObjective });
+
+    render(<WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText('Adicionar Exercício Manualmente'));
+    expect(addObjective).toHaveBeenCalled();
+  });
+
+  it('calls onCancel when cancel is clicked', () => {
+    render(<WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(mockOnCancel).toHaveBeenCalled();
+  });
+
+  it('shows "Salvar Novo Treino" button when no treino', () => {
+    render(<WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />);
+    expect(screen.getByText('Salvar Novo Treino')).toBeTruthy();
+  });
+
+  it('shows "Salvar Alterações" button when editing', () => {
+    const treinoToEdit = {
+      id: 'treino-1',
+      alunoId: 'aluno-1',
+      instrutorId: null,
+      objetivo: 'Treino A',
+      exercicios: [],
+      diaSemana: 1,
+      dataCriacao: '2024-01-01',
+    } as Treino;
+
+    render(
+      <WorkoutEditor onSave={mockOnSave} treinoToEdit={treinoToEdit} onCancel={mockOnCancel} />
+    );
+    expect(screen.getByText('Salvar Alterações')).toBeTruthy();
+  });
+
+  it('shows validation error toast when save with errors', () => {
+    const hasValidationErrors = vi.fn(() => true);
+    mockUseWorkoutExercises.mockReturnValue({ ...defaultHookReturn, hasValidationErrors });
+
+    render(<WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />);
+    fireEvent.click(screen.getByText('Salvar Novo Treino'));
+    expect(mockToast).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: 'Erro ao salvar',
+        variant: 'destructive',
+      })
+    );
+    expect(mockOnSave).not.toHaveBeenCalled();
+  });
+
+  it('renders exercise rows when exercises exist', () => {
+    const exercises = [
+      { id: 'ex-1', nomeExercicio: 'Supino', series: 3, repeticoes: '10-12' },
+      { id: 'ex-2', nomeExercicio: 'Agachamento', series: 4, repeticoes: '8-10' },
+    ];
+    mockUseWorkoutExercises.mockReturnValue({ ...defaultHookReturn, exercicios: exercises });
+
+    render(<WorkoutEditor onSave={mockOnSave} treinoToEdit={null} onCancel={mockOnCancel} />);
+    expect(screen.getAllByTestId('exercise-row').length).toBe(2);
+  });
+});
diff --git a/src/components/dashboard/aluno/workout-exercise-row.test.tsx b/src/components/dashboard/aluno/workout-exercise-row.test.tsx
new file mode 100644
index 00000000..f9810ae5
--- /dev/null
+++ b/src/components/dashboard/aluno/workout-exercise-row.test.tsx
@@ -0,0 +1,271 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { WorkoutExerciseRow } from './workout-exercise-row';
+import type { Exercicio } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+type MockChildren = { children?: ReactNode };
+
+vi.mock('@/components/ui/label', () => ({
+  Label: ({ children, className }: MockChildren & { className?: string }) => (
+    <label className={className}>{children}</label>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: ({
+    placeholder,
+    type,
+    className,
+    value,
+    onChange,
+    ...props
+  }: {
+    placeholder?: string;
+    type?: string;
+    className?: string;
+    value?: string | number;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    [key: string]: unknown;
+  }) => (
+    <input
+      data-testid={`input-${placeholder || type || 'text'}`}
+      placeholder={placeholder}
+      type={type}
+      className={className}
+      value={value}
+      onChange={onChange}
+      {...props}
+    />
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    variant,
+    ...props
+  }: MockChildren & { onClick?: () => void; variant?: string }) => (
+    <button onClick={onClick} data-variant={variant} {...props}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('lucide-react', () => ({
+  Trash2: () => <span>🗑️</span>,
+}));
+
+vi.mock('@/components/ui/combobox', () => ({
+  Combobox: ({
+    value,
+    onChange,
+    placeholder,
+  }: {
+    value?: string;
+    onChange?: (v: string) => void;
+    placeholder?: string;
+  }) => (
+    <input
+      data-testid="combobox"
+      value={value}
+      onChange={(e) => onChange?.(e.target.value)}
+      placeholder={placeholder}
+    />
+  ),
+}));
+
+vi.mock('@/lib/exercise-options', () => ({
+  exerciciosOptions: [],
+  flatExerciciosOptions: [],
+}));
+
+const mockExercise: Partial<Exercicio> = {
+  id: 'ex-1',
+  nomeExercicio: 'Supino Reto',
+  series: 4,
+  repeticoes: '10-12',
+  observacoes: 'Controlar a descida',
+};
+
+describe('WorkoutExerciseRow', () => {
+  const mockOnUpdate = vi.fn();
+  const mockOnRemove = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders without throwing', () => {
+    const { container } = render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    expect(container).toBeTruthy();
+  });
+
+  it('renders combobox for exercise name by default', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    expect(screen.getByTestId('combobox')).toBeTruthy();
+  });
+
+  it('renders input for exercise name in input mode', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+        mode="input"
+      />
+    );
+    expect(screen.getByTestId('input-Nome do exercicio')).toBeTruthy();
+  });
+
+  it('renders series input', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    expect(screen.getByTestId('input-number')).toBeTruthy();
+  });
+
+  it('renders reps input with placeholder', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    expect(screen.getByPlaceholderText('10-12')).toBeTruthy();
+  });
+
+  it('renders obs input with placeholder', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    expect(screen.getByPlaceholderText('Opcional')).toBeTruthy();
+  });
+
+  it('shows labels only on first row (index 0)', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    expect(screen.getByText('Exercicio')).toBeTruthy();
+    expect(screen.getByText('Series')).toBeTruthy();
+    expect(screen.getByText('Reps')).toBeTruthy();
+    expect(screen.getByText('Obs')).toBeTruthy();
+  });
+
+  it('does not show labels on non-first row (index > 0)', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={1}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    expect(screen.queryByText('Exercicio')).toBeNull();
+    expect(screen.queryByText('Series')).toBeNull();
+    expect(screen.queryByText('Reps')).toBeNull();
+    expect(screen.queryByText('Obs')).toBeNull();
+  });
+
+  it('renders delete button when onRemove is provided', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    expect(screen.getByLabelText('Remover exercicio')).toBeTruthy();
+  });
+
+  it('does not render delete button when onRemove is not provided', () => {
+    render(<WorkoutExerciseRow exercise={mockExercise} index={0} onUpdate={mockOnUpdate} />);
+    expect(screen.queryByLabelText('Remover exercicio')).toBeNull();
+  });
+
+  it('calls onRemove when delete is clicked', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    fireEvent.click(screen.getByLabelText('Remover exercicio'));
+    expect(mockOnRemove).toHaveBeenCalledWith('ex-1');
+  });
+
+  it('calls onUpdate when series input changes', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    fireEvent.change(screen.getByTestId('input-number'), { target: { value: '5' } });
+    expect(mockOnUpdate).toHaveBeenCalledWith('ex-1', 'series', 5);
+  });
+
+  it('calls onUpdate when reps input changes', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    fireEvent.change(screen.getByPlaceholderText('10-12'), { target: { value: '8-10' } });
+    expect(mockOnUpdate).toHaveBeenCalledWith('ex-1', 'repeticoes', '8-10');
+  });
+
+  it('calls onUpdate when obs input changes', () => {
+    render(
+      <WorkoutExerciseRow
+        exercise={mockExercise}
+        index={0}
+        onUpdate={mockOnUpdate}
+        onRemove={mockOnRemove}
+      />
+    );
+    fireEvent.change(screen.getByPlaceholderText('Opcional'), { target: { value: 'Nova obs' } });
+    expect(mockOnUpdate).toHaveBeenCalledWith('ex-1', 'observacoes', 'Nova obs');
+  });
+});
diff --git a/src/components/dashboard/aluno/workout-generator.test.tsx b/src/components/dashboard/aluno/workout-generator.test.tsx
new file mode 100644
index 00000000..51fafdb3
--- /dev/null
+++ b/src/components/dashboard/aluno/workout-generator.test.tsx
@@ -0,0 +1,175 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { WorkoutGenerator } from './workout-generator';
+import type { ReactNode } from 'react';
+
+type MockChildren = { children?: ReactNode };
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children }: MockChildren) => <div data-testid="card">{children}</div>,
+  CardHeader: ({ children }: MockChildren) => <div>{children}</div>,
+  CardTitle: ({ children }: MockChildren) => <h2>{children}</h2>,
+  CardDescription: ({ children }: MockChildren) => <p>{children}</p>,
+  CardContent: ({ children }: MockChildren) => <div>{children}</div>,
+  CardFooter: ({ children }: MockChildren) => <footer>{children}</footer>,
+}));
+
+vi.mock('@/components/ui/select', () => ({
+  Select: ({
+    children,
+    onValueChange,
+    defaultValue,
+  }: {
+    children?: ReactNode;
+    onValueChange?: (v: string) => void;
+    defaultValue?: string;
+  }) => (
+    <select
+      data-testid="select"
+      value={defaultValue}
+      onChange={(e) => onValueChange?.(e.target.value)}
+    >
+      {children}
+    </select>
+  ),
+  SelectTrigger: () => null,
+  SelectValue: () => null,
+  SelectContent: ({ children }: MockChildren) => <>{children}</>,
+  SelectItem: ({ children, value }: { children?: ReactNode; value: string }) => (
+    <option value={value}>{children}</option>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: ({
+    placeholder,
+    type,
+    ...props
+  }: {
+    placeholder?: string;
+    type?: string;
+    [key: string]: unknown;
+  }) => (
+    <input
+      data-testid={`input-${placeholder || type || 'text'}`}
+      placeholder={placeholder}
+      type={type}
+      {...props}
+    />
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    type,
+    disabled,
+    form,
+  }: {
+    children?: ReactNode;
+    onClick?: () => void;
+    type?: string;
+    disabled?: boolean;
+    form?: string;
+  }) => (
+    <button
+      onClick={onClick}
+      type={type as 'button' | 'submit' | 'reset'}
+      disabled={disabled}
+      data-form={form}
+    >
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('lucide-react', () => ({
+  Wand2: () => <span>🪄</span>,
+  BrainCircuit: () => <span>🧠</span>,
+}));
+
+vi.mock('@/components/ui/form', () => {
+  const Form = ({ children, id }: MockChildren & { id?: string }) => (
+    <form id={id}>{children}</form>
+  );
+  const FormControl = ({ children }: MockChildren) => <div>{children}</div>;
+  const FormField = ({
+    render: renderProp,
+  }: {
+    render: (props: { field: Record<string, unknown> }) => ReactNode;
+  }) => {
+    const field = { value: '', onChange: vi.fn() };
+    return <div>{renderProp({ field })}</div>;
+  };
+  const FormItem = ({ children }: MockChildren) => <div>{children}</div>;
+  const FormLabel = ({ children }: MockChildren) => <label>{children}</label>;
+  return { Form, FormControl, FormField, FormItem, FormLabel };
+});
+
+describe('WorkoutGenerator', () => {
+  const mockOnGenerate = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders without throwing', () => {
+    const { container } = render(
+      <WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={false} />
+    );
+    expect(container).toBeTruthy();
+  });
+
+  it('renders the title', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={false} />);
+    expect(screen.getByText('Gerador de Plano Semanal com IA')).toBeTruthy();
+  });
+
+  it('renders the description', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={false} />);
+    expect(screen.getByText(/Preencha seus dados/)).toBeTruthy();
+  });
+
+  it('renders form fields labels', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={false} />);
+    expect(screen.getByText('Objetivo')).toBeTruthy();
+    expect(screen.getByText('Meu Nível')).toBeTruthy();
+    expect(screen.getByText('Dias/Semana')).toBeTruthy();
+    expect(screen.getByText('Observações (Opcional)')).toBeTruthy();
+  });
+
+  it('shows "Gerar Plano Pessoal com IA" when not generating', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={false} />);
+    expect(screen.getByText('Gerar Plano Pessoal com IA')).toBeTruthy();
+  });
+
+  it('shows "Gerando Plano..." when generating', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={true} />);
+    expect(screen.getByText('Gerando Plano...')).toBeTruthy();
+  });
+
+  it('disables button when generating', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={true} />);
+    const button = screen.getByText('Gerando Plano...').closest('button');
+    expect(button?.disabled).toBe(true);
+  });
+
+  it('does not disable button when not generating', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={false} />);
+    const button = screen.getByText('Gerar Plano Pessoal com IA').closest('button');
+    expect(button?.disabled).toBe(false);
+  });
+
+  it('form has correct id for external submit', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={false} />);
+    const form = document.getElementById('ai-generator-form');
+    expect(form).toBeTruthy();
+  });
+
+  it('submit button references the form via form attribute', () => {
+    render(<WorkoutGenerator onGenerate={mockOnGenerate} isGenerating={false} />);
+    const button = screen.getByText('Gerar Plano Pessoal com IA').closest('button');
+    expect(button?.getAttribute('data-form')).toBe('ai-generator-form');
+  });
+});
diff --git a/src/components/dashboard/alunos/columns.test.tsx b/src/components/dashboard/alunos/columns.test.tsx
new file mode 100644
index 00000000..c18a2743
--- /dev/null
+++ b/src/components/dashboard/alunos/columns.test.tsx
@@ -0,0 +1,234 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { columns } from './columns';
+import type { Aluno } from '@/lib/definitions';
+
+vi.mock('@/components/ui/avatar', () => ({
+  Avatar: ({ children }: { children?: React.ReactNode }) => (
+    <div data-testid="avatar">{children}</div>
+  ),
+  AvatarFallback: ({ children }: { children?: React.ReactNode }) => <span>{children}</span>,
+  AvatarImage: () => null,
+}));
+
+vi.mock('@/components/ui/badge', () => ({
+  Badge: ({ children, variant }: { children?: React.ReactNode; variant?: string }) => (
+    <span data-testid="badge" data-variant={variant}>
+      {children}
+    </span>
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    ...props
+  }: {
+    children?: React.ReactNode;
+    onClick?: () => void;
+    [key: string]: unknown;
+  }) => (
+    <button onClick={onClick} {...props}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/dropdown-menu', () => ({
+  DropdownMenu: ({ children }: { children?: React.ReactNode }) => <div>{children}</div>,
+  DropdownMenuTrigger: ({ children }: { children?: React.ReactNode }) => <div>{children}</div>,
+  DropdownMenuContent: ({ children }: { children?: React.ReactNode }) => (
+    <div data-testid="dropdown-content">{children}</div>
+  ),
+  DropdownMenuLabel: ({ children }: { children?: React.ReactNode }) => <div>{children}</div>,
+  DropdownMenuItem: ({
+    children,
+    onClick,
+  }: {
+    children?: React.ReactNode;
+    onClick?: () => void;
+  }) => <button onClick={onClick}>{children}</button>,
+  DropdownMenuSeparator: () => <hr />,
+}));
+
+vi.mock('lucide-react', () => ({
+  MoreHorizontal: () => <span>⋮</span>,
+  Eye: () => <span>👁</span>,
+}));
+
+vi.mock('@/hooks/use-toast', () => ({
+  useToast: () => ({ toast: vi.fn() }),
+}));
+
+vi.mock('next/navigation', () => ({
+  useRouter: () => ({ push: vi.fn() }),
+}));
+
+vi.mock('date-fns', () => ({
+  format: (date: Date, fmt: string) => {
+    if (fmt === 'dd/MM/yyyy') return '01/01/2024';
+    return String(date);
+  },
+}));
+
+const mockAluno: Aluno = {
+  id: 'test-id-123',
+  nomeCompleto: 'João Silva',
+  cpf: '123.456.789-00',
+  email: 'joao@test.com',
+  telefone: '(11) 99999-9999',
+  dataNascimento: '1990-01-01',
+  dataCadastro: '2024-01-01',
+  fotoUrl: '',
+  statusMatricula: 'ATIVA',
+  nivel: 1,
+  exp: 0,
+  streakDiasSeguidos: 0,
+  treinosNoMes: 0,
+  ultimoTreinoData: null,
+};
+
+describe('columns', () => {
+  const onEdit = vi.fn();
+  const onDelete = vi.fn();
+  const onNewMatricula = vi.fn();
+
+  const columnDefs = columns({ onEdit, onDelete, onNewMatricula }) as Array<{
+    accessorKey?: string;
+    header?: string;
+    id?: string;
+    cell?: unknown;
+  }>;
+
+  it('returns an array of column definitions', () => {
+    expect(Array.isArray(columnDefs)).toBe(true);
+    expect(columnDefs.length).toBe(6);
+  });
+
+  it('has photo column with accessorKey fotoUrl', () => {
+    expect(columnDefs[0].accessorKey).toBe('fotoUrl');
+  });
+
+  it('has name column with accessorKey nomeCompleto', () => {
+    expect(columnDefs[1].accessorKey).toBe('nomeCompleto');
+    expect(columnDefs[1].header).toBe('Nome');
+  });
+
+  it('has email column with accessorKey email', () => {
+    expect(columnDefs[2].accessorKey).toBe('email');
+    expect(columnDefs[2].header).toBe('Email');
+  });
+
+  it('has date column with accessorKey dataCadastro', () => {
+    expect(columnDefs[3].accessorKey).toBe('dataCadastro');
+    expect(columnDefs[3].header).toBe('Data de Cadastro');
+  });
+
+  it('has status column with accessorKey statusMatricula', () => {
+    expect(columnDefs[4].accessorKey).toBe('statusMatricula');
+    expect(columnDefs[4].header).toBe('Status');
+  });
+
+  it('has actions column with id actions', () => {
+    expect(columnDefs[5].id).toBe('actions');
+  });
+
+  it('renders avatar for photo column', () => {
+    const cell = columnDefs[0].cell;
+    if (typeof cell === 'function') {
+      const { container } = render(cell({ row: { original: mockAluno } } as never));
+      expect(container.querySelector('[data-testid="avatar"]')).toBeTruthy();
+    }
+  });
+
+  it('renders name and email in name column', () => {
+    const cell = columnDefs[1].cell;
+    if (typeof cell === 'function') {
+      render(
+        cell({
+          row: {
+            getValue: (key: string) => mockAluno[key as keyof Aluno],
+            original: mockAluno,
+          },
+        } as never)
+      );
+      expect(screen.getByText('João Silva')).toBeTruthy();
+    }
+  });
+
+  it('renders formatted date in date column', () => {
+    const cell = columnDefs[3].cell;
+    if (typeof cell === 'function') {
+      render(
+        cell({
+          row: {
+            getValue: () => '2024-01-01',
+            original: mockAluno,
+          },
+        } as never)
+      );
+      expect(screen.getByText('01/01/2024')).toBeTruthy();
+    }
+  });
+
+  it('renders status badge for ATIVA status', () => {
+    const cell = columnDefs[4].cell;
+    if (typeof cell === 'function') {
+      render(
+        cell({
+          row: {
+            getValue: () => 'ATIVA',
+            original: mockAluno,
+          },
+        } as never)
+      );
+      expect(screen.getByText('ATIVA')).toBeTruthy();
+    }
+  });
+
+  it('renders status badge for INADIMPLENTE status', () => {
+    const cell = columnDefs[4].cell;
+    if (typeof cell === 'function') {
+      render(
+        cell({
+          row: {
+            getValue: () => 'INADIMPLENTE',
+            original: mockAluno,
+          },
+        } as never)
+      );
+      expect(screen.getByText('INADIMPLENTE')).toBeTruthy();
+    }
+  });
+
+  it('renders status badge for INATIVA status', () => {
+    const cell = columnDefs[4].cell;
+    if (typeof cell === 'function') {
+      render(
+        cell({
+          row: {
+            getValue: () => 'INATIVA',
+            original: mockAluno,
+          },
+        } as never)
+      );
+      expect(screen.getByText('INATIVA')).toBeTruthy();
+    }
+  });
+
+  it('renders actions menu button', () => {
+    const cell = columnDefs[5].cell;
+    if (typeof cell === 'function') {
+      render(
+        cell({
+          row: {
+            original: mockAluno,
+            getVisibleCells: () => [],
+          },
+        } as never)
+      );
+      expect(screen.getByLabelText('Mais opções')).toBeTruthy();
+    }
+  });
+});
diff --git a/src/components/dashboard/alunos/data-table.test.tsx b/src/components/dashboard/alunos/data-table.test.tsx
new file mode 100644
index 00000000..d31f6cc8
--- /dev/null
+++ b/src/components/dashboard/alunos/data-table.test.tsx
@@ -0,0 +1,242 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { DataTable } from './data-table';
+import type { ColumnDef } from '@tanstack/react-table';
+import type { ReactNode } from 'react';
+
+type MockChildren = { children?: ReactNode };
+
+vi.mock('@/components/ui/table', () => ({
+  Table: ({ children }: MockChildren) => <table>{children}</table>,
+  TableBody: ({ children }: MockChildren) => <tbody>{children}</tbody>,
+  TableCell: ({ children }: MockChildren) => <td>{children}</td>,
+  TableHead: ({ children }: MockChildren) => <th>{children}</th>,
+  TableHeader: ({ children }: MockChildren) => <thead>{children}</thead>,
+  TableRow: ({ children, ...props }: MockChildren & Record<string, unknown>) => (
+    <tr {...props}>{children}</tr>
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    disabled,
+    variant,
+    ...props
+  }: MockChildren & { onClick?: () => void; disabled?: boolean; variant?: string }) => (
+    <button onClick={onClick} disabled={disabled} data-variant={variant} {...props}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: ({
+    value,
+    onChange,
+    placeholder,
+  }: {
+    value?: string;
+    onChange?: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    placeholder?: string;
+  }) => (
+    <input data-testid="search-input" value={value} onChange={onChange} placeholder={placeholder} />
+  ),
+}));
+
+vi.mock('@/components/ui/skeleton', () => ({
+  Skeleton: () => <div data-testid="skeleton" />,
+}));
+
+vi.mock('@/components/ui/card', () => ({
+  Card: ({ children }: MockChildren) => <div data-testid="card">{children}</div>,
+  CardContent: ({ children }: MockChildren) => <div>{children}</div>,
+}));
+
+vi.mock('lucide-react', () => ({
+  ArrowUpDown: () => <span data-testid="arrow-icon" />,
+}));
+
+const mockGetRowModel = vi.fn();
+const mockGetHeaderGroups = vi.fn();
+const mockGetColumn = vi.fn();
+const mockGetCanPreviousPage = vi.fn(() => false);
+const mockGetCanNextPage = vi.fn(() => false);
+const mockNextPage = vi.fn();
+const mockPreviousPage = vi.fn();
+
+vi.mock('@tanstack/react-table', async () => {
+  const actual = await vi.importActual('@tanstack/react-table');
+  return {
+    ...actual,
+    useReactTable: () => ({
+      getRowModel: mockGetRowModel,
+      getHeaderGroups: mockGetHeaderGroups,
+      getColumn: mockGetColumn,
+      getCanPreviousPage: mockGetCanPreviousPage,
+      getCanNextPage: mockGetCanNextPage,
+      nextPage: mockNextPage,
+      previousPage: mockPreviousPage,
+    }),
+    flexRender: (def: unknown, ctx: unknown) => {
+      if (typeof def === 'function') {
+        return def(ctx);
+      }
+      if (ctx && typeof ctx === 'object' && 'getValue' in (ctx as Record<string, unknown>)) {
+        const getValue = (ctx as { getValue: () => unknown }).getValue;
+        return String(getValue());
+      }
+      return String(def ?? '');
+    },
+    getCoreRowModel: () => () => ({}),
+    getPaginationRowModel: () => () => ({}),
+    getSortedRowModel: () => () => ({}),
+    getFilteredRowModel: () => () => ({}),
+  };
+});
+
+const columns: ColumnDef<{ id: string; name: string; email: string }>[] = [
+  { accessorKey: 'name', header: 'Name' },
+  { accessorKey: 'email', header: 'Email' },
+];
+
+const mockData = [
+  { id: '1', name: 'Alice', email: 'alice@test.com' },
+  { id: '2', name: 'Bob', email: 'bob@test.com' },
+];
+
+describe('DataTable', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders without throwing', () => {
+    mockGetRowModel.mockReturnValue({ rows: [] });
+    mockGetHeaderGroups.mockReturnValue([{ id: '1', headers: [] }]);
+    mockGetColumn.mockReturnValue({ getFilterValue: () => '' });
+
+    const { container } = render(<DataTable columns={columns} data={mockData} />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders search input with default placeholder', () => {
+    mockGetRowModel.mockReturnValue({ rows: [] });
+    mockGetHeaderGroups.mockReturnValue([{ id: '1', headers: [] }]);
+    mockGetColumn.mockReturnValue({ getFilterValue: () => '' });
+
+    render(<DataTable columns={columns} data={mockData} />);
+    expect(screen.getByPlaceholderText('Buscar por nome...')).toBeTruthy();
+  });
+
+  it('renders custom search placeholder', () => {
+    mockGetRowModel.mockReturnValue({ rows: [] });
+    mockGetHeaderGroups.mockReturnValue([{ id: '1', headers: [] }]);
+    mockGetColumn.mockReturnValue({ getFilterValue: () => '' });
+
+    render(
+      <DataTable
+        columns={columns}
+        data={mockData}
+        searchPlaceholder="Custom search..."
+        searchColumn="email"
+      />
+    );
+    expect(screen.getByPlaceholderText('Custom search...')).toBeTruthy();
+  });
+
+  it('shows empty state when no rows', () => {
+    mockGetRowModel.mockReturnValue({ rows: [] });
+    mockGetHeaderGroups.mockReturnValue([{ id: '1', headers: [] }]);
+    mockGetColumn.mockReturnValue({ getFilterValue: () => '' });
+
+    render(<DataTable columns={columns} data={[]} />);
+    expect(screen.getAllByText('Nenhum aluno encontrado.').length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('renders table rows when data is present', () => {
+    mockGetRowModel.mockReturnValue({
+      rows: mockData.map((item) => ({
+        id: item.id,
+        original: item,
+        getIsSelected: () => false,
+        getVisibleCells: () => [
+          {
+            id: `${item.id}-name`,
+            column: { id: 'name', columnDef: { cell: () => item.name } },
+            getContext: () => ({ getValue: () => item.name }),
+          },
+          {
+            id: `${item.id}-email`,
+            column: { id: 'email', columnDef: { cell: () => item.email } },
+            getContext: () => ({ getValue: () => item.email }),
+          },
+        ],
+      })),
+    });
+    mockGetHeaderGroups.mockReturnValue([
+      {
+        id: '1',
+        headers: [
+          {
+            id: 'name',
+            column: {
+              getCanSort: () => true,
+              getToggleSortingHandler: () => {},
+              columnDef: { header: () => 'Name' },
+            },
+            columnDef: { header: () => 'Name' },
+            getContext: () => ({}),
+            isPlaceholder: false,
+          },
+          {
+            id: 'email',
+            column: {
+              getCanSort: () => false,
+              getToggleSortingHandler: () => {},
+              columnDef: { header: () => 'Email' },
+            },
+            columnDef: { header: () => 'Email' },
+            getContext: () => ({}),
+            isPlaceholder: false,
+          },
+        ],
+      },
+    ]);
+    mockGetColumn.mockReturnValue({ getFilterValue: () => '' });
+
+    render(<DataTable columns={columns} data={mockData} />);
+    expect(screen.getByText('Alice')).toBeTruthy();
+    expect(screen.getByText('Bob')).toBeTruthy();
+  });
+
+  it('shows loading skeletons when isLoading is true', () => {
+    mockGetRowModel.mockReturnValue({ rows: [] });
+    mockGetHeaderGroups.mockReturnValue([{ id: '1', headers: [] }]);
+    mockGetColumn.mockReturnValue({ getFilterValue: () => '' });
+
+    render(<DataTable columns={columns} data={[]} isLoading />);
+    const skeletons = screen.getAllByTestId('skeleton');
+    expect(skeletons.length).toBeGreaterThan(0);
+  });
+
+  it('renders pagination buttons', () => {
+    mockGetRowModel.mockReturnValue({ rows: [] });
+    mockGetHeaderGroups.mockReturnValue([{ id: '1', headers: [] }]);
+    mockGetColumn.mockReturnValue({ getFilterValue: () => '' });
+
+    render(<DataTable columns={columns} data={[]} />);
+    expect(screen.getByText('Anterior')).toBeTruthy();
+    expect(screen.getByText('Próximo')).toBeTruthy();
+  });
+
+  it('pagination buttons are disabled when no pages', () => {
+    mockGetRowModel.mockReturnValue({ rows: [] });
+    mockGetHeaderGroups.mockReturnValue([{ id: '1', headers: [] }]);
+    mockGetColumn.mockReturnValue({ getFilterValue: () => '' });
+
+    render(<DataTable columns={columns} data={[]} />);
+    expect(screen.getByText('Anterior').closest('button')?.disabled).toBe(true);
+    expect(screen.getByText('Próximo').closest('button')?.disabled).toBe(true);
+  });
+});
diff --git a/src/components/dashboard/alunos/form-aluno.test.tsx b/src/components/dashboard/alunos/form-aluno.test.tsx
new file mode 100644
index 00000000..d7ae1bef
--- /dev/null
+++ b/src/components/dashboard/alunos/form-aluno.test.tsx
@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { FormAluno } from './form-aluno';
+import type { Aluno } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+type MockChildren = { children?: ReactNode };
+type MockDialog = MockChildren & { open?: boolean };
+
+vi.mock('@/components/ui/dialog', () => ({
+  Dialog: ({ children, open }: MockDialog) =>
+    open ? <div data-testid="dialog">{children}</div> : null,
+  DialogContent: ({ children }: MockChildren) => <div>{children}</div>,
+  DialogHeader: ({ children }: MockChildren) => <div>{children}</div>,
+  DialogTitle: ({ children }: MockChildren) => <h2>{children}</h2>,
+  DialogDescription: ({ children }: MockChildren) => <p>{children}</p>,
+  DialogFooter: ({ children }: MockChildren) => <footer>{children}</footer>,
+}));
+
+vi.mock('@/components/ui/form', () => {
+  const Form = ({ children }: MockChildren) => <form>{children}</form>;
+  const FormControl = ({ children }: MockChildren) => <div>{children}</div>;
+  const FormField = ({
+    render: renderProp,
+    ...rest
+  }: {
+    render: (props: { field: Record<string, unknown> }) => ReactNode;
+    [key: string]: unknown;
+  }) => {
+    const restObj = rest as { field?: Record<string, unknown> };
+    const field = { value: '', onChange: vi.fn(), ...(restObj.field ?? {}) };
+    return <div>{renderProp({ field })}</div>;
+  };
+  const FormItem = ({ children }: MockChildren) => <div>{children}</div>;
+  const FormLabel = ({ children }: MockChildren) => <label>{children}</label>;
+  const FormMessage = () => null;
+  return { Form, FormControl, FormField, FormItem, FormLabel, FormMessage };
+});
+
+vi.mock('@/components/ui/select', () => ({
+  Select: ({
+    children,
+    onValueChange,
+    defaultValue,
+  }: {
+    children?: ReactNode;
+    onValueChange?: (v: string) => void;
+    defaultValue?: string;
+  }) => (
+    <select
+      data-testid="select"
+      value={defaultValue}
+      onChange={(e) => onValueChange?.(e.target.value)}
+    >
+      {children}
+    </select>
+  ),
+  SelectTrigger: () => null,
+  SelectValue: () => null,
+  SelectContent: ({ children }: MockChildren) => <>{children}</>,
+  SelectItem: ({ children, value }: { children?: ReactNode; value: string }) => (
+    <option value={value}>{children}</option>
+  ),
+}));
+
+vi.mock('@/components/ui/input', () => ({
+  Input: ({
+    placeholder,
+    type,
+    ...props
+  }: {
+    placeholder?: string;
+    type?: string;
+    [key: string]: unknown;
+  }) => (
+    <input
+      data-testid={`input-${placeholder || type || 'text'}`}
+      placeholder={placeholder}
+      type={type}
+      {...props}
+    />
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    type,
+    variant,
+  }: {
+    children?: ReactNode;
+    onClick?: () => void;
+    type?: string;
+    variant?: string;
+  }) => (
+    <button onClick={onClick} type={type as 'button' | 'submit' | 'reset'} data-variant={variant}>
+      {children}
+    </button>
+  ),
+}));
+
+const mockAluno: Aluno = {
+  id: '1',
+  nomeCompleto: 'João Silva',
+  cpf: '123.456.789-00',
+  email: 'joao@test.com',
+  telefone: '(11) 99999-9999',
+  dataNascimento: '1990-01-01',
+  dataCadastro: '2023-01-01',
+  fotoUrl: '',
+  statusMatricula: 'INATIVA',
+  nivel: 1,
+  exp: 0,
+  streakDiasSeguidos: 0,
+  treinosNoMes: 0,
+  ultimoTreinoData: null,
+};
+
+describe('FormAluno', () => {
+  const mockOnSubmit = vi.fn();
+  const mockOnOpenChange = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('does not render when isOpen is false', () => {
+    const { container } = render(
+      <FormAluno isOpen={false} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />
+    );
+    expect(container.querySelector('[data-testid="dialog"]')).toBeNull();
+  });
+
+  it('renders when isOpen is true', () => {
+    render(<FormAluno isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    expect(screen.getByText('Cadastrar Novo Aluno')).toBeTruthy();
+  });
+
+  it('shows "Cadastrar" submit button for new aluno', () => {
+    render(<FormAluno isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    expect(screen.getByText('Cadastrar')).toBeTruthy();
+  });
+
+  it('shows "Editar Aluno" title when editing', () => {
+    render(
+      <FormAluno
+        isOpen={true}
+        onOpenChange={mockOnOpenChange}
+        onSubmit={mockOnSubmit}
+        aluno={mockAluno}
+      />
+    );
+    expect(screen.getByText('Editar Aluno')).toBeTruthy();
+  });
+
+  it('shows "Salvar Alterações" button when editing', () => {
+    render(
+      <FormAluno
+        isOpen={true}
+        onOpenChange={mockOnOpenChange}
+        onSubmit={mockOnSubmit}
+        aluno={mockAluno}
+      />
+    );
+    expect(screen.getByText('Salvar Alterações')).toBeTruthy();
+  });
+
+  it('calls onOpenChange(false) when cancel is clicked', () => {
+    render(<FormAluno isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(mockOnOpenChange).toHaveBeenCalledWith(false);
+  });
+
+  it('renders all form fields', () => {
+    render(<FormAluno isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    expect(screen.getByText('Nome Completo')).toBeTruthy();
+    expect(screen.getByText('Email')).toBeTruthy();
+    expect(screen.getByText('CPF')).toBeTruthy();
+    expect(screen.getByText('Telefone')).toBeTruthy();
+    expect(screen.getByText('Data de Nascimento')).toBeTruthy();
+  });
+
+  it('shows status select when editing', () => {
+    render(
+      <FormAluno
+        isOpen={true}
+        onOpenChange={mockOnOpenChange}
+        onSubmit={mockOnSubmit}
+        aluno={mockAluno}
+      />
+    );
+    expect(screen.getByText('Status da Matrícula')).toBeTruthy();
+  });
+
+  it('does not show status select for new aluno', () => {
+    render(<FormAluno isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    expect(screen.queryByText('Status da Matrícula')).toBeNull();
+  });
+});
diff --git a/src/components/dashboard/planos/form-plano.test.tsx b/src/components/dashboard/planos/form-plano.test.tsx
new file mode 100644
index 00000000..d8637945
--- /dev/null
+++ b/src/components/dashboard/planos/form-plano.test.tsx
@@ -0,0 +1,159 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { FormPlano } from './form-plano';
+import type { Plano } from '@/lib/definitions';
+import type { ReactNode } from 'react';
+
+type MockChildren = { children?: ReactNode };
+type MockDialog = MockChildren & { open?: boolean };
+
+vi.mock('@/components/ui/dialog', () => ({
+  Dialog: ({ children, open }: MockDialog) =>
+    open ? <div data-testid="dialog">{children}</div> : null,
+  DialogContent: ({ children }: MockChildren) => <div>{children}</div>,
+  DialogHeader: ({ children }: MockChildren) => <div>{children}</div>,
+  DialogTitle: ({ children }: MockChildren) => <h2>{children}</h2>,
+  DialogDescription: ({ children }: MockChildren) => <p>{children}</p>,
+  DialogFooter: ({ children }: MockChildren) => <footer>{children}</footer>,
+}));
+
+vi.mock('@/components/ui/form', () => {
+  const Form = ({ children }: MockChildren) => <form>{children}</form>;
+  const FormControl = ({ children }: MockChildren) => <div>{children}</div>;
+  const FormField = ({
+    render: renderProp,
+  }: {
+    render: (props: { field: Record<string, unknown> }) => ReactNode;
+  }) => {
+    const field = { value: '', onChange: vi.fn() };
+    return <div>{renderProp({ field })}</div>;
+  };
+  const FormItem = ({ children }: MockChildren) => <div>{children}</div>;
+  const FormLabel = ({ children }: MockChildren) => <label>{children}</label>;
+  const FormMessage = () => null;
+  return { Form, FormControl, FormField, FormItem, FormLabel, FormMessage };
+});
+
+vi.mock('@/components/ui/input', () => ({
+  Input: ({
+    placeholder,
+    type,
+    ...props
+  }: {
+    placeholder?: string;
+    type?: string;
+    [key: string]: unknown;
+  }) => (
+    <input
+      data-testid={`input-${placeholder || type || 'text'}`}
+      placeholder={placeholder}
+      type={type}
+      {...props}
+    />
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  Button: ({
+    children,
+    onClick,
+    type,
+    variant,
+  }: {
+    children?: ReactNode;
+    onClick?: () => void;
+    type?: string;
+    variant?: string;
+  }) => (
+    <button onClick={onClick} type={type as 'button' | 'submit' | 'reset'} data-variant={variant}>
+      {children}
+    </button>
+  ),
+}));
+
+const mockPlano: Plano = {
+  id: 'plano-1',
+  nome: 'Mensal',
+  preco: 100,
+  duracaoDias: 30,
+};
+
+describe('FormPlano', () => {
+  const mockOnSubmit = vi.fn();
+  const mockOnOpenChange = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('does not render when isOpen is false', () => {
+    const { container } = render(
+      <FormPlano isOpen={false} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />
+    );
+    expect(container.querySelector('[data-testid="dialog"]')).toBeNull();
+  });
+
+  it('renders when isOpen is true', () => {
+    render(<FormPlano isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    expect(screen.getByText('Novo Plano')).toBeTruthy();
+  });
+
+  it('shows "Criar Plano" submit button for new plano', () => {
+    render(<FormPlano isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    expect(screen.getByText('Criar Plano')).toBeTruthy();
+  });
+
+  it('shows "Editar Plano" title when editing', () => {
+    render(
+      <FormPlano
+        isOpen={true}
+        onOpenChange={mockOnOpenChange}
+        onSubmit={mockOnSubmit}
+        plano={mockPlano}
+      />
+    );
+    expect(screen.getByText('Editar Plano')).toBeTruthy();
+  });
+
+  it('shows "Salvar Alterações" button when editing', () => {
+    render(
+      <FormPlano
+        isOpen={true}
+        onOpenChange={mockOnOpenChange}
+        onSubmit={mockOnSubmit}
+        plano={mockPlano}
+      />
+    );
+    expect(screen.getByText('Salvar Alterações')).toBeTruthy();
+  });
+
+  it('calls onOpenChange(false) when cancel is clicked', () => {
+    render(<FormPlano isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    fireEvent.click(screen.getByText('Cancelar'));
+    expect(mockOnOpenChange).toHaveBeenCalledWith(false);
+  });
+
+  it('renders all form fields', () => {
+    render(<FormPlano isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    expect(screen.getByText('Nome do Plano')).toBeTruthy();
+    expect(screen.getByText('Preço (R$)')).toBeTruthy();
+    expect(screen.getByText('Duração (dias)')).toBeTruthy();
+  });
+
+  it('shows create description for new plano', () => {
+    render(<FormPlano isOpen={true} onOpenChange={mockOnOpenChange} onSubmit={mockOnSubmit} />);
+    expect(screen.getByText('Preencha os dados para criar um novo plano.')).toBeTruthy();
+  });
+
+  it('shows edit description when editing', () => {
+    render(
+      <FormPlano
+        isOpen={true}
+        onOpenChange={mockOnOpenChange}
+        onSubmit={mockOnSubmit}
+        plano={mockPlano}
+      />
+    );
+    expect(screen.getByText('Edite os dados do plano.')).toBeTruthy();
+  });
+});
diff --git a/src/components/page-header.test.tsx b/src/components/page-header.test.tsx
new file mode 100644
index 00000000..f0638f7d
--- /dev/null
+++ b/src/components/page-header.test.tsx
@@ -0,0 +1,39 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { PageHeader } from './page-header';
+
+vi.mock('@/lib/utils', () => ({
+  cn: (...args: unknown[]) => args.filter(Boolean).join(' '),
+}));
+
+describe('PageHeader', () => {
+  it('renders title', () => {
+    render(<PageHeader title="Dashboard" />);
+    expect(screen.getByRole('heading', { level: 1 })).toHaveTextContent('Dashboard');
+  });
+
+  it('renders description when provided', () => {
+    render(<PageHeader title="Alunos" description="Gerencie seus alunos" />);
+    expect(screen.getByText('Gerencie seus alunos')).toBeTruthy();
+  });
+
+  it('does not render description when not provided', () => {
+    render(<PageHeader title="Treinos" />);
+    expect(screen.queryByRole('paragraph')).toBeNull();
+  });
+
+  it('renders actions when provided', () => {
+    render(<PageHeader title="Planos" actions={<button>Novo Plano</button>} />);
+    expect(screen.getByText('Novo Plano')).toBeTruthy();
+  });
+
+  it('does not render actions section when not provided', () => {
+    const { container } = render(<PageHeader title="Dashboard" />);
+    expect(container.querySelector('.flex-shrink-0')).toBeNull();
+  });
+
+  it('applies custom className', () => {
+    const { container } = render(<PageHeader title="Test" className="custom-class" />);
+    expect(container.firstChild).toBeTruthy();
+  });
+});
diff --git a/src/components/providers/auth-provider.test.tsx b/src/components/providers/auth-provider.test.tsx
new file mode 100644
index 00000000..f35c758e
--- /dev/null
+++ b/src/components/providers/auth-provider.test.tsx
@@ -0,0 +1,133 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, act } from '@testing-library/react';
+import { SupabaseAuthProvider, useAuth } from './auth-provider';
+
+const mockGetUser = vi.fn();
+const mockOnAuthStateChange = vi.fn();
+const mockSignOut = vi.fn();
+
+vi.mock('@/utils/supabase/client', () => ({
+  createClient: () => ({
+    auth: {
+      getUser: mockGetUser,
+      onAuthStateChange: mockOnAuthStateChange,
+      signOut: mockSignOut,
+    },
+  }),
+}));
+
+vi.mock('@sentry/nextjs', () => ({
+  setUser: vi.fn(),
+}));
+
+function TestConsumer() {
+  const { user, isUserLoading, userError, signOut } = useAuth();
+  return (
+    <div>
+      <span data-testid="loading">{String(isUserLoading)}</span>
+      <span data-testid="user">{user ? user.email : 'no-user'}</span>
+      <span data-testid="error">{userError ? userError.message : 'no-error'}</span>
+      <button onClick={signOut}>Sign Out</button>
+    </div>
+  );
+}
+
+describe('SupabaseAuthProvider', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockGetUser.mockResolvedValue({ data: { user: null }, error: null });
+    mockOnAuthStateChange.mockReturnValue({
+      data: { subscription: { unsubscribe: vi.fn() } },
+    });
+  });
+
+  it('provides auth context to children', async () => {
+    await act(async () => {
+      render(
+        <SupabaseAuthProvider>
+          <TestConsumer />
+        </SupabaseAuthProvider>
+      );
+    });
+    expect(screen.getByTestId('loading')).toBeTruthy();
+  });
+
+  it('starts with loading state', async () => {
+    mockGetUser.mockImplementation(() => new Promise(() => {}));
+    await act(async () => {
+      render(
+        <SupabaseAuthProvider>
+          <TestConsumer />
+        </SupabaseAuthProvider>
+      );
+    });
+    expect(screen.getByTestId('loading').textContent).toBe('true');
+  });
+
+  it('resolves to no user when getUser returns null', async () => {
+    await act(async () => {
+      render(
+        <SupabaseAuthProvider>
+          <TestConsumer />
+        </SupabaseAuthProvider>
+      );
+    });
+    expect(screen.getByTestId('loading').textContent).toBe('false');
+    expect(screen.getByTestId('user').textContent).toBe('no-user');
+  });
+
+  it('provides user when getUser returns one', async () => {
+    mockGetUser.mockResolvedValue({
+      data: { user: { id: '1', email: 'test@test.com' } },
+      error: null,
+    });
+    await act(async () => {
+      render(
+        <SupabaseAuthProvider>
+          <TestConsumer />
+        </SupabaseAuthProvider>
+      );
+    });
+    expect(screen.getByTestId('user').textContent).toBe('test@test.com');
+  });
+
+  it('calls signOut correctly', async () => {
+    mockSignOut.mockResolvedValue({ error: null });
+    await act(async () => {
+      render(
+        <SupabaseAuthProvider>
+          <TestConsumer />
+        </SupabaseAuthProvider>
+      );
+    });
+    await act(async () => {
+      screen.getByText('Sign Out').click();
+    });
+    expect(mockSignOut).toHaveBeenCalled();
+  });
+
+  it('registers onAuthStateChange listener', async () => {
+    await act(async () => {
+      render(
+        <SupabaseAuthProvider>
+          <TestConsumer />
+        </SupabaseAuthProvider>
+      );
+    });
+    expect(mockOnAuthStateChange).toHaveBeenCalled();
+  });
+});
+
+describe('useAuth', () => {
+  it('throws when used outside provider', () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    function BadConsumer() {
+      useAuth();
+      return null;
+    }
+    expect(() => render(<BadConsumer />)).toThrow(
+      'useAuth must be used within a SupabaseAuthProvider.'
+    );
+    spy.mockRestore();
+  });
+});
diff --git a/src/components/providers/i18n-provider.test.tsx b/src/components/providers/i18n-provider.test.tsx
new file mode 100644
index 00000000..813102bd
--- /dev/null
+++ b/src/components/providers/i18n-provider.test.tsx
@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, act } from '@testing-library/react';
+import { I18nProvider, useI18n } from './i18n-provider';
+
+const localStorageMock = (() => {
+  let store: Record<string, string> = {};
+  return {
+    getItem: (key: string) => store[key] ?? null,
+    setItem: (key: string, value: string) => {
+      store[key] = value;
+    },
+    clear: () => {
+      store = {};
+    },
+    removeItem: (key: string) => {
+      delete store[key];
+    },
+    get length() {
+      return Object.keys(store).length;
+    },
+    key: (index: number) => Object.keys(store)[index] ?? null,
+  };
+})();
+
+vi.stubGlobal('localStorage', localStorageMock);
+
+function TestConsumer() {
+  const { language, setLanguage, t } = useI18n();
+  return (
+    <div>
+      <span data-testid="language">{language}</span>
+      <span data-testid="welcome">{t('common.welcome')}</span>
+      <span data-testid="with-param">{t('dashboard.streak', { count: 5 })}</span>
+      <span data-testid="missing">{t('nonexistent.key')}</span>
+      <button onClick={() => setLanguage('en')}>Switch to EN</button>
+      <button onClick={() => setLanguage('pt')}>Switch to PT</button>
+    </div>
+  );
+}
+
+describe('I18nProvider', () => {
+  beforeEach(() => {
+    localStorageMock.clear();
+  });
+
+  it('defaults to Portuguese', async () => {
+    await act(async () => {
+      render(
+        <I18nProvider>
+          <TestConsumer />
+        </I18nProvider>
+      );
+    });
+    expect(screen.getByTestId('language').textContent).toBe('pt');
+  });
+
+  it('translates common.welcome in Portuguese', async () => {
+    await act(async () => {
+      render(
+        <I18nProvider>
+          <TestConsumer />
+        </I18nProvider>
+      );
+    });
+    expect(screen.getByTestId('welcome').textContent).toBeTruthy();
+  });
+
+  it('handles parameter interpolation', async () => {
+    await act(async () => {
+      render(
+        <I18nProvider>
+          <TestConsumer />
+        </I18nProvider>
+      );
+    });
+    expect(screen.getByTestId('with-param').textContent).toContain('5');
+  });
+
+  it('returns path when key is missing', async () => {
+    await act(async () => {
+      render(
+        <I18nProvider>
+          <TestConsumer />
+        </I18nProvider>
+      );
+    });
+    expect(screen.getByTestId('missing').textContent).toBe('nonexistent.key');
+  });
+
+  it('switches language on setLanguage call', async () => {
+    await act(async () => {
+      render(
+        <I18nProvider>
+          <TestConsumer />
+        </I18nProvider>
+      );
+    });
+    await act(async () => {
+      screen.getByText('Switch to EN').click();
+    });
+    expect(screen.getByTestId('language').textContent).toBe('en');
+  });
+
+  it('persists language to localStorage', async () => {
+    await act(async () => {
+      render(
+        <I18nProvider>
+          <TestConsumer />
+        </I18nProvider>
+      );
+    });
+    await act(async () => {
+      screen.getByText('Switch to EN').click();
+    });
+    expect(localStorageMock.getItem('app-language')).toBe('en');
+  });
+});
+
+describe('useI18n', () => {
+  it('throws when used outside provider', () => {
+    const spy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    function BadConsumer() {
+      useI18n();
+      return null;
+    }
+    expect(() => render(<BadConsumer />)).toThrow('useI18n must be used within an I18nProvider');
+    spy.mockRestore();
+  });
+});
diff --git a/src/components/ui/accordion.test.tsx b/src/components/ui/accordion.test.tsx
new file mode 100644
index 00000000..d2aa1897
--- /dev/null
+++ b/src/components/ui/accordion.test.tsx
@@ -0,0 +1,89 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-accordion', () => {
+  const Root = ({ children, ...props }: React.ComponentPropsWithoutRef<'div'>) => (
+    <div data-testid="accordion-root" {...props}>
+      {children}
+    </div>
+  );
+  Root.displayName = 'Accordion';
+
+  const Item = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="accordion-item" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Item.displayName = 'AccordionItem';
+
+  const Header = ({ children, ...props }: React.ComponentPropsWithoutRef<'div'>) => (
+    <div data-testid="accordion-header" {...props}>
+      {children}
+    </div>
+  );
+  Header.displayName = 'AccordionHeader';
+
+  const Trigger = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<'button'>>(
+    ({ children, ...props }, ref) => (
+      <button ref={ref} data-testid="accordion-trigger" {...props}>
+        {children}
+      </button>
+    )
+  );
+  Trigger.displayName = 'AccordionTrigger';
+
+  const Content = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="accordion-content" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Content.displayName = 'AccordionContent';
+
+  return { Root, Item, Header, Trigger, Content };
+});
+
+import { Accordion, AccordionItem, AccordionTrigger, AccordionContent } from './accordion';
+
+describe('Accordion components', () => {
+  it('Accordion renders children', () => {
+    render(
+      <Accordion type="single">
+        <div>content</div>
+      </Accordion>
+    );
+    expect(screen.getByTestId('accordion-root')).toBeTruthy();
+    expect(screen.getByText('content')).toBeTruthy();
+  });
+
+  it('AccordionItem renders', () => {
+    render(<AccordionItem value="item-1">Item Content</AccordionItem>);
+    expect(screen.getByTestId('accordion-item')).toBeTruthy();
+    expect(screen.getByText('Item Content')).toBeTruthy();
+  });
+
+  it('AccordionTrigger renders with text and chevron', () => {
+    render(<AccordionTrigger>Click me</AccordionTrigger>);
+    expect(screen.getByTestId('accordion-trigger')).toBeTruthy();
+    expect(screen.getByText('Click me')).toBeTruthy();
+  });
+
+  it('AccordionContent renders children', () => {
+    render(<AccordionContent>Hidden Content</AccordionContent>);
+    expect(screen.getByTestId('accordion-content')).toBeTruthy();
+    expect(screen.getByText('Hidden Content')).toBeTruthy();
+  });
+
+  it('AccordionItem passes className', () => {
+    render(
+      <AccordionItem value="test" className="my-class">
+        x
+      </AccordionItem>
+    );
+    expect(screen.getByTestId('accordion-item').className).toContain('my-class');
+  });
+});
diff --git a/src/components/ui/alert-dialog.test.tsx b/src/components/ui/alert-dialog.test.tsx
new file mode 100644
index 00000000..af27d2a0
--- /dev/null
+++ b/src/components/ui/alert-dialog.test.tsx
@@ -0,0 +1,193 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-alert-dialog', () => {
+  const createPrimitive = (displayName: string) => {
+    const Component = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+      ({ children, ...props }, ref) => (
+        <div ref={ref} data-slot={displayName} {...props}>
+          {children}
+        </div>
+      )
+    );
+    Component.displayName = displayName;
+    return Component;
+  };
+
+  const createButton = (displayName: string) => {
+    const Component = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<'button'>>(
+      ({ children, ...props }, ref) => (
+        <button ref={ref} data-slot={displayName} {...props}>
+          {children}
+        </button>
+      )
+    );
+    Component.displayName = displayName;
+    return Component;
+  };
+
+  return {
+    Root: ({ children, ...props }: React.ComponentPropsWithoutRef<'div'>) => (
+      <div data-slot="AlertDialog" {...props}>
+        {children}
+      </div>
+    ),
+    Trigger: createButton('AlertDialogTrigger'),
+    Portal: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+    Overlay: createPrimitive('AlertDialogOverlay'),
+    Content: createPrimitive('AlertDialogContent'),
+    Title: createPrimitive('AlertDialogTitle'),
+    Description: createPrimitive('AlertDialogDescription'),
+    Action: createButton('AlertDialogAction'),
+    Cancel: createButton('AlertDialogCancel'),
+  };
+});
+
+vi.mock('@/components/ui/button', () => ({
+  buttonVariants: (opts?: { variant?: string }) => `btn ${opts?.variant || 'default'}`,
+}));
+
+import {
+  AlertDialog,
+  AlertDialogTrigger,
+  AlertDialogContent,
+  AlertDialogHeader,
+  AlertDialogFooter,
+  AlertDialogTitle,
+  AlertDialogDescription,
+  AlertDialogAction,
+  AlertDialogCancel,
+} from './alert-dialog';
+
+describe('AlertDialog', () => {
+  it('renders without throwing', () => {
+    const { container } = render(
+      <AlertDialog>
+        <AlertDialogTrigger>Open</AlertDialogTrigger>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Are you sure?</AlertDialogTitle>
+            <AlertDialogDescription>This action cannot be undone.</AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>Cancel</AlertDialogCancel>
+            <AlertDialogAction>Continue</AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    );
+    expect(container).toBeTruthy();
+  });
+});
+
+describe('AlertDialogTrigger', () => {
+  it('renders as a button', () => {
+    render(
+      <AlertDialog>
+        <AlertDialogTrigger>Open Dialog</AlertDialogTrigger>
+      </AlertDialog>
+    );
+    const trigger = screen.getByText('Open Dialog');
+    expect(trigger.tagName).toBe('BUTTON');
+  });
+
+  it('handles click', () => {
+    const onClick = vi.fn();
+    render(
+      <AlertDialog>
+        <AlertDialogTrigger onClick={onClick}>Open</AlertDialogTrigger>
+      </AlertDialog>
+    );
+    fireEvent.click(screen.getByText('Open'));
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('AlertDialogTitle', () => {
+  it('renders title text', () => {
+    render(
+      <AlertDialog>
+        <AlertDialogContent>
+          <AlertDialogTitle>Warning</AlertDialogTitle>
+        </AlertDialogContent>
+      </AlertDialog>
+    );
+    expect(screen.getByText('Warning')).toBeTruthy();
+  });
+});
+
+describe('AlertDialogDescription', () => {
+  it('renders description text', () => {
+    render(
+      <AlertDialog>
+        <AlertDialogContent>
+          <AlertDialogDescription>Some description</AlertDialogDescription>
+        </AlertDialogContent>
+      </AlertDialog>
+    );
+    expect(screen.getByText('Some description')).toBeTruthy();
+  });
+});
+
+describe('AlertDialogAction', () => {
+  it('renders and handles click', () => {
+    const onAction = vi.fn();
+    render(
+      <AlertDialog>
+        <AlertDialogContent>
+          <AlertDialogAction onClick={onAction}>Confirm</AlertDialogAction>
+        </AlertDialogContent>
+      </AlertDialog>
+    );
+    fireEvent.click(screen.getByText('Confirm'));
+    expect(onAction).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('AlertDialogCancel', () => {
+  it('renders cancel button', () => {
+    render(
+      <AlertDialog>
+        <AlertDialogContent>
+          <AlertDialogCancel>Go Back</AlertDialogCancel>
+        </AlertDialogContent>
+      </AlertDialog>
+    );
+    expect(screen.getByText('Go Back')).toBeTruthy();
+  });
+});
+
+describe('AlertDialogHeader', () => {
+  it('renders header with title and description', () => {
+    render(
+      <AlertDialog>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Confirm</AlertDialogTitle>
+            <AlertDialogDescription>Details here</AlertDialogDescription>
+          </AlertDialogHeader>
+        </AlertDialogContent>
+      </AlertDialog>
+    );
+    expect(screen.getByText('Confirm')).toBeTruthy();
+    expect(screen.getByText('Details here')).toBeTruthy();
+  });
+});
+
+describe('AlertDialogFooter', () => {
+  it('renders footer with action and cancel', () => {
+    render(
+      <AlertDialog>
+        <AlertDialogContent>
+          <AlertDialogFooter>
+            <AlertDialogCancel>Cancel</AlertDialogCancel>
+            <AlertDialogAction>OK</AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    );
+    expect(screen.getByText('Cancel')).toBeTruthy();
+    expect(screen.getByText('OK')).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/alert.test.tsx b/src/components/ui/alert.test.tsx
new file mode 100644
index 00000000..5fa9d7a9
--- /dev/null
+++ b/src/components/ui/alert.test.tsx
@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+
+import { Alert, AlertTitle, AlertDescription } from './alert';
+
+describe('Alert components', () => {
+  it('renders Alert with role="alert"', () => {
+    render(<Alert data-testid="alert">Alert content</Alert>);
+    const el = screen.getByTestId('alert');
+    expect(el).toBeTruthy();
+    expect(el.getAttribute('role')).toBe('alert');
+  });
+
+  it('renders with default variant class', () => {
+    render(<Alert data-testid="alert">Content</Alert>);
+    expect(screen.getByTestId('alert').className).toContain('bg-background');
+  });
+
+  it('renders with destructive variant class', () => {
+    render(
+      <Alert variant="destructive" data-testid="alert">
+        Error
+      </Alert>
+    );
+    expect(screen.getByTestId('alert').className).toContain('destructive');
+  });
+
+  it('passes custom className', () => {
+    render(
+      <Alert className="extra-class" data-testid="alert">
+        x
+      </Alert>
+    );
+    expect(screen.getByTestId('alert').className).toContain('extra-class');
+  });
+
+  it('AlertTitle renders', () => {
+    render(
+      <Alert>
+        <AlertTitle>Warning</AlertTitle>
+      </Alert>
+    );
+    expect(screen.getByText('Warning')).toBeTruthy();
+  });
+
+  it('AlertDescription renders', () => {
+    render(
+      <Alert>
+        <AlertDescription>Details here</AlertDescription>
+      </Alert>
+    );
+    expect(screen.getByText('Details here')).toBeTruthy();
+  });
+
+  it('AlertTitle passes className', () => {
+    render(
+      <Alert>
+        <AlertTitle className="title-extra" data-testid="at">
+          T
+        </AlertTitle>
+      </Alert>
+    );
+    expect(screen.getByTestId('at').className).toContain('title-extra');
+  });
+
+  it('AlertDescription passes className', () => {
+    render(
+      <Alert>
+        <AlertDescription className="desc-extra" data-testid="ad">
+          D
+        </AlertDescription>
+      </Alert>
+    );
+    expect(screen.getByTestId('ad').className).toContain('desc-extra');
+  });
+});
diff --git a/src/components/ui/calendar.test.tsx b/src/components/ui/calendar.test.tsx
new file mode 100644
index 00000000..6f0862f4
--- /dev/null
+++ b/src/components/ui/calendar.test.tsx
@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+
+vi.mock('react-day-picker', () => ({
+  DayPicker: ({ onSelect, ...props }: Record<string, unknown>) => (
+    <div data-slot="DayPicker" {...props}>
+      <button
+        onClick={() =>
+          (onSelect as ((day: Date | undefined) => void) | undefined)?.(new Date(2025, 0, 15))
+        }
+      >
+        Jan 15
+      </button>
+      <button
+        onClick={() =>
+          (onSelect as ((day: Date | undefined) => void) | undefined)?.(new Date(2025, 1, 1))
+        }
+      >
+        Feb 1
+      </button>
+    </div>
+  ),
+}));
+
+vi.mock('@/components/ui/button', () => ({
+  buttonVariants: (opts?: { variant?: string }) => `btn-variant-${opts?.variant || 'default'}`,
+}));
+
+import { Calendar } from './calendar';
+
+describe('Calendar', () => {
+  it('renders without throwing', () => {
+    const { container } = render(<Calendar />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders DayPicker', () => {
+    render(<Calendar />);
+    expect(screen.getByRole('button', { name: 'Jan 15' })).toBeTruthy();
+  });
+
+  it('passes onSelect callback', () => {
+    const onSelect = vi.fn();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    render(<Calendar {...({ onSelect } as any)} />);
+    fireEvent.click(screen.getByText('Jan 15'));
+    expect(onSelect).toHaveBeenCalledTimes(1);
+  });
+
+  it('renders with custom className', () => {
+    render(<Calendar className="my-calendar" data-testid="cal" />);
+    expect(screen.getByTestId('cal')).toHaveClass('my-calendar');
+  });
+
+  it('passes showOutsideDays prop', () => {
+    render(<Calendar showOutsideDays={false} />);
+    expect(screen.getByRole('button', { name: 'Jan 15' })).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/carousel.test.tsx b/src/components/ui/carousel.test.tsx
new file mode 100644
index 00000000..a89190da
--- /dev/null
+++ b/src/components/ui/carousel.test.tsx
@@ -0,0 +1,116 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+const mockScrollPrev = vi.fn();
+const mockScrollNext = vi.fn();
+
+vi.mock('embla-carousel-react', () => ({
+  default: () => [
+    vi.fn(),
+    {
+      canScrollPrev: () => false,
+      canScrollNext: () => true,
+      scrollPrev: mockScrollPrev,
+      scrollNext: mockScrollNext,
+      on: vi.fn(),
+      off: vi.fn(),
+    },
+  ],
+}));
+
+vi.mock('@/components/ui/button', () => {
+  const Button = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<'button'>>(
+    ({ children, ...props }, ref) => (
+      <button ref={ref} {...props}>
+        {children}
+      </button>
+    )
+  );
+  Button.displayName = 'Button';
+  return { Button };
+});
+
+import {
+  Carousel,
+  CarouselContent,
+  CarouselItem,
+  CarouselPrevious,
+  CarouselNext,
+} from './carousel';
+
+describe('Carousel', () => {
+  it('renders without throwing', () => {
+    const { container } = render(
+      <Carousel>
+        <CarouselContent>
+          <CarouselItem>Slide 1</CarouselItem>
+          <CarouselItem>Slide 2</CarouselItem>
+        </CarouselContent>
+      </Carousel>
+    );
+    expect(container).toBeTruthy();
+  });
+
+  it('renders carousel items', () => {
+    render(
+      <Carousel>
+        <CarouselContent>
+          <CarouselItem>First</CarouselItem>
+          <CarouselItem>Second</CarouselItem>
+        </CarouselContent>
+      </Carousel>
+    );
+    expect(screen.getByText('First')).toBeTruthy();
+    expect(screen.getByText('Second')).toBeTruthy();
+  });
+
+  it('renders prev/next buttons', () => {
+    render(
+      <Carousel>
+        <CarouselContent>
+          <CarouselItem>Slide</CarouselItem>
+        </CarouselContent>
+        <CarouselPrevious />
+        <CarouselNext />
+      </Carousel>
+    );
+    expect(screen.getByText('Previous slide')).toBeTruthy();
+    expect(screen.getByText('Next slide')).toBeTruthy();
+  });
+
+  it('disables previous button when canScrollPrev is false', () => {
+    render(
+      <Carousel>
+        <CarouselContent>
+          <CarouselItem>Slide</CarouselItem>
+        </CarouselContent>
+        <CarouselPrevious />
+      </Carousel>
+    );
+    expect(screen.getByText('Previous slide').closest('button')).toBeDisabled();
+  });
+
+  it('enables next button when canScrollNext is true', () => {
+    render(
+      <Carousel>
+        <CarouselContent>
+          <CarouselItem>Slide</CarouselItem>
+        </CarouselContent>
+        <CarouselNext />
+      </Carousel>
+    );
+    expect(screen.getByText('Next slide').closest('button')).not.toBeDisabled();
+  });
+
+  it('sets aria-roledescription on carousel section', () => {
+    render(
+      <Carousel>
+        <CarouselContent>
+          <CarouselItem>Slide</CarouselItem>
+        </CarouselContent>
+      </Carousel>
+    );
+    expect(screen.getByRole('region', { name: 'Carrossel de conteúdo' })).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/chart.test.tsx b/src/components/ui/chart.test.tsx
new file mode 100644
index 00000000..eda95e22
--- /dev/null
+++ b/src/components/ui/chart.test.tsx
@@ -0,0 +1,162 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import type { ReactNode } from 'react';
+
+vi.mock('recharts', () => ({
+  ResponsiveContainer: ({ children }: { children: ReactNode }) => (
+    <div data-testid="responsive-container">{children}</div>
+  ),
+  Tooltip: () => <div data-testid="chart-tooltip" />,
+  Legend: () => <div data-testid="chart-legend" />,
+}));
+
+import {
+  ChartContainer,
+  ChartTooltip,
+  ChartTooltipContent,
+  ChartLegend,
+  ChartLegendContent,
+} from './chart';
+
+const sampleConfig = {
+  desktop: { label: 'Desktop', color: '#2563eb' },
+  mobile: { label: 'Mobile', color: '#10b981' },
+};
+
+describe('ChartContainer', () => {
+  it('renders without throwing', () => {
+    const { container } = render(
+      <ChartContainer config={sampleConfig}>
+        <div>chart children</div>
+      </ChartContainer>
+    );
+    expect(container).toBeTruthy();
+  });
+
+  it('renders children inside ResponsiveContainer', () => {
+    render(
+      <ChartContainer config={sampleConfig}>
+        <div>Inner chart</div>
+      </ChartContainer>
+    );
+    expect(screen.getByText('Inner chart')).toBeTruthy();
+    expect(screen.getByTestId('responsive-container')).toBeTruthy();
+  });
+
+  it('applies data-chart attribute', () => {
+    render(
+      <ChartContainer config={sampleConfig} id="test-chart" data-testid="chart">
+        <div>child</div>
+      </ChartContainer>
+    );
+    expect(screen.getByTestId('chart')).toHaveAttribute('data-chart');
+  });
+
+  it('injects CSS custom properties via style tag', () => {
+    const { container } = render(
+      <ChartContainer config={sampleConfig} id="color-chart">
+        <div>child</div>
+      </ChartContainer>
+    );
+    const styleEl = container.querySelector('style');
+    expect(styleEl).toBeTruthy();
+    expect(styleEl?.innerHTML).toContain('--color-desktop');
+    expect(styleEl?.innerHTML).toContain('--color-mobile');
+  });
+});
+
+describe('ChartTooltip', () => {
+  it('renders recharts Tooltip', () => {
+    render(<ChartTooltip />);
+    expect(screen.getByTestId('chart-tooltip')).toBeTruthy();
+  });
+});
+
+describe('ChartLegend', () => {
+  it('renders recharts Legend', () => {
+    render(<ChartLegend />);
+    expect(screen.getByTestId('chart-legend')).toBeTruthy();
+  });
+});
+
+describe('ChartTooltipContent', () => {
+  it('renders nothing when not active', () => {
+    const { container } = render(
+      <ChartContainer config={sampleConfig}>
+        <ChartTooltipContent
+          active={false}
+          payload={[]}
+          coordinate={{ x: 0, y: 0 }}
+          accessibilityLayer={true}
+          activeIndex={'0'}
+        />
+      </ChartContainer>
+    );
+    expect(container.querySelector('[class*="grid min-w"]')).toBeNull();
+  });
+
+  it('renders nothing when no payload', () => {
+    const { container } = render(
+      <ChartContainer config={sampleConfig}>
+        <ChartTooltipContent
+          active={true}
+          payload={[]}
+          coordinate={{ x: 0, y: 0 }}
+          accessibilityLayer={true}
+          activeIndex={'0'}
+        />
+      </ChartContainer>
+    );
+    expect(container.querySelector('[class*="grid min-w"]')).toBeNull();
+  });
+
+  it('renders tooltip with payload', () => {
+    render(
+      <ChartContainer config={sampleConfig}>
+        <ChartTooltipContent
+          active={true}
+          payload={[
+            {
+              name: 'desktop',
+              value: 100,
+              dataKey: 'desktop',
+              color: '#2563eb',
+              payload: {},
+              graphicalItemId: '1',
+            },
+          ]}
+          coordinate={{ x: 0, y: 0 }}
+          accessibilityLayer={true}
+          activeIndex={'0'}
+        />
+      </ChartContainer>
+    );
+    expect(screen.getByText('100')).toBeTruthy();
+  });
+});
+
+describe('ChartLegendContent', () => {
+  it('renders nothing with empty payload', () => {
+    const { container } = render(
+      <ChartContainer config={sampleConfig}>
+        <ChartLegendContent payload={[]} />
+      </ChartContainer>
+    );
+    expect(container.querySelector('[class*="flex items-center justify-center"]')).toBeNull();
+  });
+
+  it('renders legend items from config', () => {
+    render(
+      <ChartContainer config={sampleConfig}>
+        <ChartLegendContent
+          payload={[
+            { value: 'desktop', dataKey: 'desktop', color: '#2563eb', type: 'circle' },
+            { value: 'mobile', dataKey: 'mobile', color: '#10b981', type: 'circle' },
+          ]}
+        />
+      </ChartContainer>
+    );
+    expect(screen.getByText('Desktop')).toBeTruthy();
+    expect(screen.getByText('Mobile')).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/checkbox.test.tsx b/src/components/ui/checkbox.test.tsx
new file mode 100644
index 00000000..ba32aa81
--- /dev/null
+++ b/src/components/ui/checkbox.test.tsx
@@ -0,0 +1,67 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-checkbox', () => {
+  const Root = React.forwardRef<
+    HTMLButtonElement,
+    React.ComponentPropsWithoutRef<'button'> & {
+      checked?: boolean;
+      onCheckedChange?: (checked: boolean | 'indeterminate') => void;
+    }
+  >(({ children, checked: initialChecked, onCheckedChange, ...props }, ref) => {
+    const [checked, setChecked] = React.useState(initialChecked ?? false);
+    return (
+      <button
+        ref={ref}
+        role="checkbox"
+        aria-checked={checked}
+        data-state={checked ? 'checked' : 'unchecked'}
+        onClick={() => {
+          const next = !checked;
+          setChecked(next);
+          onCheckedChange?.(next);
+        }}
+        {...props}
+      >
+        {children}
+      </button>
+    );
+  });
+  Root.displayName = 'CheckboxRoot';
+
+  const Indicator = ({ children }: { children: React.ReactNode }) => (
+    <span data-testid="indicator">{children}</span>
+  );
+  Indicator.displayName = 'CheckboxIndicator';
+
+  return { Root, Indicator };
+});
+
+import { Checkbox } from './checkbox';
+
+describe('Checkbox', () => {
+  it('renders without crashing', () => {
+    render(<Checkbox data-testid="cb" />);
+    expect(screen.getByTestId('cb')).toBeTruthy();
+  });
+
+  it('has checkbox role', () => {
+    render(<Checkbox data-testid="cb" />);
+    expect(screen.getByRole('checkbox')).toBeTruthy();
+  });
+
+  it('can be checked and unchecked', () => {
+    render(<Checkbox data-testid="cb" />);
+    const cb = screen.getByTestId('cb');
+    expect(cb.getAttribute('data-state')).toBe('unchecked');
+
+    fireEvent.click(cb);
+    expect(cb.getAttribute('data-state')).toBe('checked');
+  });
+
+  it('passes custom className', () => {
+    render(<Checkbox className="my-cb" data-testid="cb" />);
+    expect(screen.getByTestId('cb').className).toContain('my-cb');
+  });
+});
diff --git a/src/components/ui/circular-progress.test.tsx b/src/components/ui/circular-progress.test.tsx
new file mode 100644
index 00000000..8368908d
--- /dev/null
+++ b/src/components/ui/circular-progress.test.tsx
@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+
+import { CircularProgress } from './circular-progress';
+
+describe('CircularProgress', () => {
+  it('renders without throwing', () => {
+    const { container } = render(<CircularProgress value={50} />);
+    expect(container).toBeTruthy();
+  });
+
+  it('renders SVG circles', () => {
+    const { container } = render(<CircularProgress value={75} />);
+    const circles = container.querySelectorAll('circle');
+    expect(circles.length).toBe(2);
+  });
+
+  it('displays value when showValue is true', () => {
+    render(<CircularProgress value={42} showValue />);
+    expect(screen.getByText('42%')).toBeTruthy();
+  });
+
+  it('does not display value by default', () => {
+    const { container } = render(<CircularProgress value={42} />);
+    expect(container.textContent).not.toContain('42%');
+  });
+
+  it('renders label when provided', () => {
+    render(<CircularProgress value={90} label="Progress" />);
+    expect(screen.getByText('Progress')).toBeTruthy();
+  });
+
+  it('renders sm size', () => {
+    const { container } = render(<CircularProgress value={50} size="sm" />);
+    const wrapper = container.firstChild as HTMLElement;
+    expect(wrapper.className).toContain('w-16');
+  });
+
+  it('renders md size by default', () => {
+    const { container } = render(<CircularProgress value={50} />);
+    const wrapper = container.firstChild as HTMLElement;
+    expect(wrapper.className).toContain('w-32');
+  });
+
+  it('renders lg size', () => {
+    const { container } = render(<CircularProgress value={50} size="lg" />);
+    const wrapper = container.firstChild as HTMLElement;
+    expect(wrapper.className).toContain('w-48');
+  });
+
+  it('applies custom className', () => {
+    const { container } = render(<CircularProgress value={50} className="my-class" />);
+    const wrapper = container.firstChild as HTMLElement;
+    expect(wrapper.className).toContain('my-class');
+  });
+
+  it('calculates strokeDashoffset correctly for 0%', () => {
+    const { container } = render(<CircularProgress value={0} />);
+    const progressCircle = container.querySelectorAll('circle')[1];
+    const circumference = 2 * Math.PI * 40;
+    expect(progressCircle.getAttribute('stroke-dashoffset')).toBe(String(circumference));
+  });
+
+  it('calculates strokeDashoffset correctly for 100%', () => {
+    const { container } = render(<CircularProgress value={100} />);
+    const progressCircle = container.querySelectorAll('circle')[1];
+    expect(progressCircle.getAttribute('stroke-dashoffset')).toBe('0');
+  });
+
+  it('uses cyan gradient by default', () => {
+    const { container } = render(<CircularProgress value={50} />);
+    const progressCircle = container.querySelectorAll('circle')[1];
+    expect(progressCircle.getAttribute('stroke')).toBe('url(#cyan-gradient)');
+  });
+
+  it('uses gold gradient when specified', () => {
+    const { container } = render(<CircularProgress value={50} gradient="gold" />);
+    const progressCircle = container.querySelectorAll('circle')[1];
+    expect(progressCircle.getAttribute('stroke')).toBe('url(#gold-gradient)');
+  });
+
+  it('uses rose gradient when specified', () => {
+    const { container } = render(<CircularProgress value={50} gradient="rose" />);
+    const progressCircle = container.querySelectorAll('circle')[1];
+    expect(progressCircle.getAttribute('stroke')).toBe('url(#rose-gradient)');
+  });
+
+  it('passes forward ref', () => {
+    const ref = { current: null };
+    render(<CircularProgress value={50} ref={ref} />);
+    expect(ref.current).toBeInstanceOf(HTMLDivElement);
+  });
+});
diff --git a/src/components/ui/combobox.test.tsx b/src/components/ui/combobox.test.tsx
new file mode 100644
index 00000000..d17351a6
--- /dev/null
+++ b/src/components/ui/combobox.test.tsx
@@ -0,0 +1,230 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@/components/ui/popover', () => {
+  const PopoverTrigger = React.forwardRef<
+    HTMLButtonElement,
+    React.ButtonHTMLAttributes<HTMLButtonElement>
+  >(({ children, ...props }, ref) => (
+    <button ref={ref} data-testid="popover-trigger" {...props}>
+      {children}
+    </button>
+  ));
+  PopoverTrigger.displayName = 'PopoverTrigger';
+
+  const PopoverContent = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="popover-content" {...props}>
+        {children}
+      </div>
+    )
+  );
+  PopoverContent.displayName = 'PopoverContent';
+
+  return {
+    Popover: ({ children, open }: { children?: React.ReactNode; open?: boolean }) => (
+      <div data-testid="popover" data-state={open ? 'open' : 'closed'}>
+        {children}
+      </div>
+    ),
+    PopoverTrigger,
+    PopoverContent,
+  };
+});
+
+vi.mock('@/components/ui/command', () => {
+  const Command = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="command" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Command.displayName = 'Command';
+
+  const CommandInput = React.forwardRef<
+    HTMLInputElement,
+    React.InputHTMLAttributes<HTMLInputElement>
+  >(({ ...props }, ref) => <input ref={ref} data-testid="command-input" {...props} />);
+  CommandInput.displayName = 'CommandInput';
+
+  const CommandList = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="command-list" {...props}>
+        {children}
+      </div>
+    )
+  );
+  CommandList.displayName = 'CommandList';
+
+  const CommandEmpty = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="command-empty" {...props}>
+        {children}
+      </div>
+    )
+  );
+  CommandEmpty.displayName = 'CommandEmpty';
+
+  const CommandGroup = React.forwardRef<
+    HTMLDivElement,
+    React.HTMLAttributes<HTMLDivElement> & { heading?: string }
+  >(({ children, heading, ...props }, ref) => (
+    <div ref={ref} data-testid="command-group" data-heading={heading} {...props}>
+      {children}
+    </div>
+  ));
+  CommandGroup.displayName = 'CommandGroup';
+
+  const CommandItem = React.forwardRef<
+    HTMLDivElement,
+    React.HTMLAttributes<HTMLDivElement> & {
+      value?: string;
+      keywords?: string[];
+      onSelect?: (value: string) => void;
+    }
+  >(({ children, value, onSelect, ...props }, ref) => (
+    <div
+      ref={ref}
+      data-testid="command-item"
+      data-value={value}
+      onClick={() => onSelect?.(value ?? '')}
+      {...props}
+    >
+      {children}
+    </div>
+  ));
+  CommandItem.displayName = 'CommandItem';
+
+  return { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem };
+});
+
+vi.mock('@/components/ui/button', () => {
+  const Button = React.forwardRef<
+    HTMLButtonElement,
+    React.ButtonHTMLAttributes<HTMLButtonElement> & { variant?: string }
+  >(({ children, variant, ...props }, ref) => (
+    <button ref={ref} data-testid="button" data-variant={variant} {...props}>
+      {children}
+    </button>
+  ));
+  Button.displayName = 'Button';
+  return { Button };
+});
+
+vi.mock('lucide-react', () => ({
+  Check: () => <svg data-testid="icon-check" />,
+  ChevronsUpDown: () => <svg data-testid="icon-chevrons-up-down" />,
+}));
+
+import { Combobox } from './combobox';
+
+const mockOptions = [
+  {
+    label: 'Group 1',
+    options: [
+      { value: 'opt1', label: 'Option One' },
+      { value: 'opt2', label: 'Option Two' },
+    ],
+  },
+];
+
+const mockFlatOptions = [
+  { value: 'opt1', label: 'Option One' },
+  { value: 'opt2', label: 'Option Two' },
+];
+
+describe('Combobox', () => {
+  it('renders without crashing', () => {
+    render(<Combobox options={mockOptions} flatOptions={mockFlatOptions} onChange={vi.fn()} />);
+    expect(screen.getByTestId('popover')).toBeTruthy();
+  });
+
+  it('renders trigger button with placeholder when no value', () => {
+    render(
+      <Combobox
+        options={mockOptions}
+        flatOptions={mockFlatOptions}
+        onChange={vi.fn()}
+        placeholder="Pick something..."
+      />
+    );
+    expect(screen.getByText('Pick something...')).toBeTruthy();
+    expect(screen.getByRole('combobox')).toBeTruthy();
+  });
+
+  it('shows default placeholder text', () => {
+    render(<Combobox options={mockOptions} flatOptions={mockFlatOptions} onChange={vi.fn()} />);
+    expect(screen.getByText('Select an option...')).toBeTruthy();
+  });
+
+  it('renders chevrons up down icon', () => {
+    render(<Combobox options={mockOptions} flatOptions={mockFlatOptions} onChange={vi.fn()} />);
+    expect(screen.getByTestId('icon-chevrons-up-down')).toBeTruthy();
+  });
+
+  it('shows selected label when value is provided', () => {
+    render(
+      <Combobox
+        options={mockOptions}
+        flatOptions={mockFlatOptions}
+        value="opt1"
+        onChange={vi.fn()}
+      />
+    );
+    const matches = screen.getAllByText('Option One');
+    expect(matches.length).toBeGreaterThanOrEqual(1);
+    expect(screen.getByRole('combobox').textContent).toContain('Option One');
+  });
+
+  it('has combobox role with aria-expanded', () => {
+    render(<Combobox options={mockOptions} flatOptions={mockFlatOptions} onChange={vi.fn()} />);
+    const combobox = screen.getByRole('combobox');
+    expect(combobox.getAttribute('aria-expanded')).toBe('false');
+  });
+
+  it('passes className to button', () => {
+    render(
+      <Combobox
+        options={mockOptions}
+        flatOptions={mockFlatOptions}
+        onChange={vi.fn()}
+        className="custom-combobox"
+      />
+    );
+    expect(screen.getByRole('combobox').className).toContain('custom-combobox');
+  });
+
+  it('renders command input inside popover', () => {
+    render(
+      <Combobox
+        options={mockOptions}
+        flatOptions={mockFlatOptions}
+        onChange={vi.fn()}
+        searchPlaceholder="Search options..."
+      />
+    );
+    expect(screen.getByTestId('command-input')).toBeTruthy();
+  });
+
+  it('renders command groups with options', () => {
+    render(<Combobox options={mockOptions} flatOptions={mockFlatOptions} onChange={vi.fn()} />);
+    expect(screen.getByTestId('command-group')).toBeTruthy();
+    expect(screen.getByText('Option One')).toBeTruthy();
+    expect(screen.getByText('Option Two')).toBeTruthy();
+  });
+
+  it('renders check icon for selected option', () => {
+    render(
+      <Combobox
+        options={mockOptions}
+        flatOptions={mockFlatOptions}
+        value="opt1"
+        onChange={vi.fn()}
+      />
+    );
+    const checks = screen.getAllByTestId('icon-check');
+    expect(checks.length).toBeGreaterThan(0);
+  });
+});
diff --git a/src/components/ui/command.test.tsx b/src/components/ui/command.test.tsx
new file mode 100644
index 00000000..dd1910ed
--- /dev/null
+++ b/src/components/ui/command.test.tsx
@@ -0,0 +1,176 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('cmdk', () => {
+  const createPrimitive = (displayName: string) => {
+    const Component = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+      ({ children, ...props }, ref) => (
+        <div ref={ref} data-slot={displayName} {...props}>
+          {children}
+        </div>
+      )
+    );
+    Component.displayName = displayName;
+    return Component;
+  };
+
+  const Input = React.forwardRef<HTMLInputElement, React.ComponentPropsWithoutRef<'input'>>(
+    ({ ...props }, ref) => <input ref={ref} data-slot="cmdk-input" {...props} />
+  );
+  Input.displayName = 'CommandInput';
+
+  return {
+    Command: Object.assign(createPrimitive('Command'), {
+      Input,
+      List: createPrimitive('CommandList'),
+      Empty: createPrimitive('CommandEmpty'),
+      Group: ({
+        children,
+        heading,
+        ...props
+      }: React.ComponentPropsWithoutRef<'div'> & { heading?: string }) => (
+        <div data-slot="CommandGroup" {...props}>
+          {heading && <div data-slot="CommandGroupHeading">{heading}</div>}
+          {children}
+        </div>
+      ),
+      Item: ({
+        children,
+        onSelect,
+        ...props
+      }: React.ComponentPropsWithoutRef<'div'> & { onSelect?: (e: Event) => void }) => (
+        <div data-slot="CommandItem" onClick={(e) => onSelect?.(e)} {...props}>
+          {children}
+        </div>
+      ),
+      Separator: createPrimitive('CommandSeparator'),
+    }),
+  };
+});
+
+vi.mock('@/components/ui/dialog', () => ({
+  Dialog: ({ children, ...props }: React.ComponentPropsWithoutRef<'div'>) => (
+    <div data-slot="dialog" {...props}>
+      {children}
+    </div>
+  ),
+  DialogContent: ({ children, ...props }: React.ComponentPropsWithoutRef<'div'>) => (
+    <div data-slot="dialog-content" {...props}>
+      {children}
+    </div>
+  ),
+}));
+
+import {
+  Command,
+  CommandInput,
+  CommandList,
+  CommandEmpty,
+  CommandGroup,
+  CommandItem,
+  CommandShortcut,
+  CommandSeparator,
+  CommandDialog,
+} from './command';
+
+describe('Command', () => {
+  it('renders without throwing', () => {
+    const { container } = render(<Command />);
+    expect(container).toBeTruthy();
+  });
+
+  it('passes className and children', () => {
+    render(<Command className="test-class">Content</Command>);
+    const el = screen.getByText('Content');
+    expect(el.closest('[data-slot="Command"]')).toHaveClass('test-class');
+  });
+
+  it('passes data attributes', () => {
+    render(<Command data-testid="cmd" />);
+    expect(screen.getByTestId('cmd')).toBeTruthy();
+  });
+});
+
+describe('CommandInput', () => {
+  it('renders an input element', () => {
+    render(<CommandInput placeholder="Search…" />);
+    expect(screen.getByPlaceholderText('Search…')).toBeTruthy();
+  });
+
+  it('passes value and onChange', () => {
+    const handleChange = vi.fn();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    render(<CommandInput {...({ value: 'test', onChange: handleChange } as any)} />);
+    const input = screen.getByDisplayValue('test');
+    fireEvent.change(input, { target: { value: 'new' } });
+    expect(handleChange).toHaveBeenCalled();
+  });
+});
+
+describe('CommandList', () => {
+  it('renders children', () => {
+    render(<CommandList>List content</CommandList>);
+    expect(screen.getByText('List content')).toBeTruthy();
+  });
+});
+
+describe('CommandEmpty', () => {
+  it('renders empty state', () => {
+    render(<CommandEmpty>No results</CommandEmpty>);
+    expect(screen.getByText('No results')).toBeTruthy();
+  });
+});
+
+describe('CommandGroup', () => {
+  it('renders with heading', () => {
+    render(
+      <CommandGroup heading="Suggestions">
+        <CommandItem>Item 1</CommandItem>
+      </CommandGroup>
+    );
+    expect(screen.getByText('Suggestions')).toBeTruthy();
+    expect(screen.getByText('Item 1')).toBeTruthy();
+  });
+});
+
+describe('CommandItem', () => {
+  it('renders and handles click', () => {
+    const handleClick = vi.fn();
+    render(<CommandItem onSelect={handleClick}>My Item</CommandItem>);
+    const item = screen.getByText('My Item');
+    fireEvent.click(item);
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('CommandShortcut', () => {
+  it('renders shortcut text', () => {
+    render(<CommandShortcut>⌘K</CommandShortcut>);
+    expect(screen.getByText('⌘K')).toBeTruthy();
+  });
+});
+
+describe('CommandSeparator', () => {
+  it('renders a separator element', () => {
+    const { container } = render(<CommandSeparator />);
+    expect(container.querySelector('[data-slot="CommandSeparator"]')).toBeTruthy();
+  });
+});
+
+describe('CommandDialog', () => {
+  it('renders dialog with command inside', () => {
+    render(
+      <CommandDialog>
+        <CommandInput placeholder="Search…" />
+        <CommandList>
+          <CommandGroup heading="Group">
+            <CommandItem>Result</CommandItem>
+          </CommandGroup>
+        </CommandList>
+      </CommandDialog>
+    );
+    expect(screen.getByPlaceholderText('Search…')).toBeTruthy();
+    expect(screen.getByText('Result')).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/dashboard-skeletons.test.tsx b/src/components/ui/dashboard-skeletons.test.tsx
new file mode 100644
index 00000000..08788262
--- /dev/null
+++ b/src/components/ui/dashboard-skeletons.test.tsx
@@ -0,0 +1,38 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@/components/ui/premium-skeleton', () => {
+  const PremiumSkeleton = ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>) => (
+    <div data-testid="premium-skeleton" className={className} {...props} />
+  );
+  return { PremiumSkeleton };
+});
+
+import { TableSkeleton, FinanceiroSkeleton } from './dashboard-skeletons';
+
+describe('TableSkeleton', () => {
+  it('renders without crashing', () => {
+    render(<TableSkeleton />);
+    expect(screen.getAllByTestId('premium-skeleton').length).toBeGreaterThan(0);
+  });
+
+  it('renders multiple skeleton rows', () => {
+    const { container } = render(<TableSkeleton />);
+    expect(container.querySelectorAll('[data-testid="premium-skeleton"]').length).toBeGreaterThan(
+      10
+    );
+  });
+});
+
+describe('FinanceiroSkeleton', () => {
+  it('renders without crashing', () => {
+    render(<FinanceiroSkeleton />);
+    expect(screen.getAllByTestId('premium-skeleton').length).toBeGreaterThan(0);
+  });
+
+  it('renders 3 skeletons (title, subtitle, chart)', () => {
+    render(<FinanceiroSkeleton />);
+    expect(screen.getAllByTestId('premium-skeleton')).toHaveLength(3);
+  });
+});
diff --git a/src/components/ui/dialog.test.tsx b/src/components/ui/dialog.test.tsx
new file mode 100644
index 00000000..b883d2e3
--- /dev/null
+++ b/src/components/ui/dialog.test.tsx
@@ -0,0 +1,195 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-dialog', () => {
+  const Root = ({
+    children,
+    open,
+    ...props
+  }: {
+    children?: React.ReactNode;
+    open?: boolean;
+    [key: string]: unknown;
+  }) => (
+    <div data-testid="dialog-root" data-state={open ? 'open' : 'closed'} {...props}>
+      {children}
+    </div>
+  );
+
+  const Trigger = React.forwardRef<
+    HTMLButtonElement,
+    React.ButtonHTMLAttributes<HTMLButtonElement>
+  >(({ children, ...props }, ref) => (
+    <button ref={ref} data-testid="dialog-trigger" {...props}>
+      {children}
+    </button>
+  ));
+  Trigger.displayName = 'DialogTrigger';
+
+  const Portal = ({ children }: { children?: React.ReactNode }) => <>{children}</>;
+
+  const Overlay = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="dialog-overlay" {...props} />
+  );
+  Overlay.displayName = 'DialogOverlay';
+
+  const Content = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="dialog-content" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Content.displayName = 'DialogContent';
+
+  const Close = React.forwardRef<HTMLButtonElement, React.ButtonHTMLAttributes<HTMLButtonElement>>(
+    ({ children, ...props }, ref) => (
+      <button ref={ref} data-testid="dialog-close" {...props}>
+        {children}
+      </button>
+    )
+  );
+  Close.displayName = 'DialogClose';
+
+  const Title = React.forwardRef<HTMLHeadingElement, React.HTMLAttributes<HTMLHeadingElement>>(
+    ({ children, ...props }, ref) => (
+      <h2 ref={ref} data-testid="dialog-title" {...props}>
+        {children}
+      </h2>
+    )
+  );
+  Title.displayName = 'DialogTitle';
+
+  const Description = React.forwardRef<
+    HTMLParagraphElement,
+    React.HTMLAttributes<HTMLParagraphElement>
+  >(({ children, ...props }, ref) => (
+    <p ref={ref} data-testid="dialog-description" {...props}>
+      {children}
+    </p>
+  ));
+  Description.displayName = 'DialogDescription';
+
+  return { Root, Trigger, Portal, Overlay, Content, Close, Title, Description };
+});
+
+vi.mock('lucide-react', () => ({
+  X: () => <svg data-testid="icon-x" />,
+}));
+
+import {
+  Dialog,
+  DialogTrigger,
+  DialogContent,
+  DialogHeader,
+  DialogFooter,
+  DialogTitle,
+  DialogDescription,
+  DialogClose,
+} from './dialog';
+
+describe('Dialog', () => {
+  it('renders Dialog root without crashing', () => {
+    render(
+      <Dialog>
+        <div>Content</div>
+      </Dialog>
+    );
+    expect(screen.getByTestId('dialog-root')).toBeTruthy();
+  });
+
+  it('renders DialogTrigger', () => {
+    render(
+      <Dialog>
+        <DialogTrigger>Open</DialogTrigger>
+      </Dialog>
+    );
+    expect(screen.getByTestId('dialog-trigger')).toBeTruthy();
+    expect(screen.getByText('Open')).toBeTruthy();
+  });
+
+  it('renders DialogContent with children', () => {
+    render(
+      <Dialog>
+        <DialogContent>
+          <p>Dialog body</p>
+        </DialogContent>
+      </Dialog>
+    );
+    expect(screen.getByTestId('dialog-content')).toBeTruthy();
+    expect(screen.getByText('Dialog body')).toBeTruthy();
+  });
+
+  it('renders DialogHeader with children', () => {
+    render(
+      <Dialog>
+        <DialogContent>
+          <DialogHeader>
+            <DialogTitle>My Title</DialogTitle>
+            <DialogDescription>My Description</DialogDescription>
+          </DialogHeader>
+        </DialogContent>
+      </Dialog>
+    );
+    expect(screen.getByText('My Title')).toBeTruthy();
+    expect(screen.getByText('My Description')).toBeTruthy();
+  });
+
+  it('renders DialogFooter with children', () => {
+    render(
+      <Dialog>
+        <DialogContent>
+          <DialogFooter>
+            <button>Cancel</button>
+            <button>Save</button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    );
+    expect(screen.getByText('Cancel')).toBeTruthy();
+    expect(screen.getByText('Save')).toBeTruthy();
+  });
+
+  it('renders DialogClose button', () => {
+    render(
+      <Dialog>
+        <DialogContent>
+          <DialogClose>Close me</DialogClose>
+        </DialogContent>
+      </Dialog>
+    );
+    const closeButtons = screen.getAllByTestId('dialog-close');
+    expect(closeButtons.length).toBeGreaterThanOrEqual(2);
+    expect(screen.getByText('Close me')).toBeTruthy();
+  });
+
+  it('passes className to DialogContent', () => {
+    render(
+      <Dialog>
+        <DialogContent className="custom-class">
+          <p>Content</p>
+        </DialogContent>
+      </Dialog>
+    );
+    expect(screen.getByTestId('dialog-content').className).toContain('custom-class');
+  });
+
+  it('passes props to Dialog root', () => {
+    render(
+      <Dialog open>
+        <div>Child</div>
+      </Dialog>
+    );
+    expect(screen.getByTestId('dialog-root').getAttribute('data-state')).toBe('open');
+  });
+
+  it('renders with data-state=closed when not open', () => {
+    render(
+      <Dialog>
+        <div>Child</div>
+      </Dialog>
+    );
+    expect(screen.getByTestId('dialog-root').getAttribute('data-state')).toBe('closed');
+  });
+});
diff --git a/src/components/ui/dropdown-menu.test.tsx b/src/components/ui/dropdown-menu.test.tsx
new file mode 100644
index 00000000..7a08fdd3
--- /dev/null
+++ b/src/components/ui/dropdown-menu.test.tsx
@@ -0,0 +1,215 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-dropdown-menu', () => {
+  const createPrimitive = (displayName: string) => {
+    const Component = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+      ({ children, ...props }, ref) => (
+        <div ref={ref} data-slot={displayName} {...props}>
+          {children}
+        </div>
+      )
+    );
+    Component.displayName = displayName;
+    return Component;
+  };
+
+  const createButton = (displayName: string) => {
+    const Component = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<'button'>>(
+      ({ children, ...props }, ref) => (
+        <button ref={ref} data-slot={displayName} {...props}>
+          {children}
+        </button>
+      )
+    );
+    Component.displayName = displayName;
+    return Component;
+  };
+
+  return {
+    Root: ({ children, ...props }: React.ComponentPropsWithoutRef<'div'>) => (
+      <div data-slot="DropdownMenu" {...props}>
+        {children}
+      </div>
+    ),
+    Trigger: createButton('DropdownMenuTrigger'),
+    Content: createPrimitive('DropdownMenuContent'),
+    Item: ({
+      children,
+      onSelect,
+      ...props
+    }: React.ComponentPropsWithoutRef<'div'> & { onSelect?: (e: Event) => void }) => (
+      <div data-slot="DropdownMenuItem" onClick={(e) => onSelect?.(e)} {...props}>
+        {children}
+      </div>
+    ),
+    CheckboxItem: createPrimitive('DropdownMenuCheckboxItem'),
+    RadioItem: createPrimitive('DropdownMenuRadioItem'),
+    Label: createPrimitive('DropdownMenuLabel'),
+    Separator: createPrimitive('DropdownMenuSeparator'),
+    Group: createPrimitive('DropdownMenuGroup'),
+    Portal: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+    Sub: createPrimitive('DropdownMenuSub'),
+    SubTrigger: createButton('DropdownMenuSubTrigger'),
+    SubContent: createPrimitive('DropdownMenuSubContent'),
+    RadioGroup: createPrimitive('DropdownMenuRadioGroup'),
+    ItemIndicator: ({ children }: { children: React.ReactNode }) => (
+      <span data-slot="DropdownMenuItemIndicator">{children}</span>
+    ),
+  };
+});
+
+import {
+  DropdownMenu,
+  DropdownMenuTrigger,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuCheckboxItem,
+  DropdownMenuRadioItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuShortcut,
+  DropdownMenuGroup,
+  DropdownMenuSub,
+  DropdownMenuSubTrigger,
+  DropdownMenuSubContent,
+  DropdownMenuRadioGroup,
+} from './dropdown-menu';
+
+function renderMenu(trigger = 'Open', items: React.ReactNode = null) {
+  return render(
+    <DropdownMenu>
+      <DropdownMenuTrigger>{trigger}</DropdownMenuTrigger>
+      <DropdownMenuContent>{items}</DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
+
+describe('DropdownMenu', () => {
+  it('renders trigger button', () => {
+    renderMenu();
+    expect(screen.getByText('Open')).toBeTruthy();
+  });
+
+  it('renders menu items', () => {
+    renderMenu(
+      'Open',
+      <>
+        <DropdownMenuItem>Edit</DropdownMenuItem>
+        <DropdownMenuItem>Delete</DropdownMenuItem>
+      </>
+    );
+    expect(screen.getByText('Edit')).toBeTruthy();
+    expect(screen.getByText('Delete')).toBeTruthy();
+  });
+});
+
+describe('DropdownMenuTrigger', () => {
+  it('renders as button', () => {
+    renderMenu();
+    expect(screen.getByText('Open').tagName).toBe('BUTTON');
+  });
+
+  it('handles onClick', () => {
+    const onClick = vi.fn();
+    render(
+      <DropdownMenu>
+        <DropdownMenuTrigger onClick={onClick}>Toggle</DropdownMenuTrigger>
+      </DropdownMenu>
+    );
+    fireEvent.click(screen.getByText('Toggle'));
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('DropdownMenuItem', () => {
+  it('renders and handles click', () => {
+    const handleClick = vi.fn();
+    renderMenu('Menu', <DropdownMenuItem onSelect={handleClick}>Save</DropdownMenuItem>);
+    fireEvent.click(screen.getByText('Save'));
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('DropdownMenuCheckboxItem', () => {
+  it('renders with checked state', () => {
+    renderMenu(
+      'Menu',
+      <DropdownMenuCheckboxItem checked={true}>Show sidebar</DropdownMenuCheckboxItem>
+    );
+    expect(screen.getByText('Show sidebar')).toBeTruthy();
+  });
+});
+
+describe('DropdownMenuRadioGroup', () => {
+  it('renders radio items in group', () => {
+    renderMenu(
+      'Menu',
+      <DropdownMenuRadioGroup value="a">
+        <DropdownMenuRadioItem value="a">Option A</DropdownMenuRadioItem>
+        <DropdownMenuRadioItem value="b">Option B</DropdownMenuRadioItem>
+      </DropdownMenuRadioGroup>
+    );
+    expect(screen.getByText('Option A')).toBeTruthy();
+    expect(screen.getByText('Option B')).toBeTruthy();
+  });
+});
+
+describe('DropdownMenuLabel', () => {
+  it('renders label text', () => {
+    renderMenu('Menu', <DropdownMenuLabel>My Actions</DropdownMenuLabel>);
+    expect(screen.getByText('My Actions')).toBeTruthy();
+  });
+});
+
+describe('DropdownMenuSeparator', () => {
+  it('renders separator element', () => {
+    const { container } = renderMenu(
+      'Menu',
+      <>
+        <DropdownMenuItem>A</DropdownMenuItem>
+        <DropdownMenuSeparator data-testid="sep" />
+        <DropdownMenuItem>B</DropdownMenuItem>
+      </>
+    );
+    expect(container.querySelector('[data-slot="DropdownMenuSeparator"]')).toBeTruthy();
+  });
+});
+
+describe('DropdownMenuShortcut', () => {
+  it('renders shortcut text', () => {
+    render(<DropdownMenuShortcut>⌘Z</DropdownMenuShortcut>);
+    expect(screen.getByText('⌘Z')).toBeTruthy();
+  });
+});
+
+describe('DropdownMenuGroup', () => {
+  it('renders grouped items', () => {
+    renderMenu(
+      'Menu',
+      <DropdownMenuGroup>
+        <DropdownMenuItem>Cut</DropdownMenuItem>
+        <DropdownMenuItem>Copy</DropdownMenuItem>
+      </DropdownMenuGroup>
+    );
+    expect(screen.getByText('Cut')).toBeTruthy();
+    expect(screen.getByText('Copy')).toBeTruthy();
+  });
+});
+
+describe('DropdownMenuSub', () => {
+  it('renders sub menu with trigger and content', () => {
+    renderMenu(
+      'Menu',
+      <DropdownMenuSub>
+        <DropdownMenuSubTrigger>More tools</DropdownMenuSubTrigger>
+        <DropdownMenuSubContent>
+          <DropdownMenuItem>Sub item</DropdownMenuItem>
+        </DropdownMenuSubContent>
+      </DropdownMenuSub>
+    );
+    expect(screen.getByText('More tools')).toBeTruthy();
+    expect(screen.getByText('Sub item')).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/form.test.tsx b/src/components/ui/form.test.tsx
new file mode 100644
index 00000000..f2263a8e
--- /dev/null
+++ b/src/components/ui/form.test.tsx
@@ -0,0 +1,146 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('react-hook-form', () => {
+  const FormProvider = ({ children }: { children?: React.ReactNode }) => (
+    <div data-testid="form-provider">{children}</div>
+  );
+
+  const Controller = ({
+    name,
+    render: renderProp,
+  }: {
+    name: string;
+    render: (props: { field: Record<string, unknown> }) => React.ReactNode;
+  }) => {
+    return (
+      <div data-testid={`controller-${name}`}>
+        {renderProp({
+          field: { name, value: '', onChange: vi.fn(), onBlur: vi.fn() },
+        })}
+      </div>
+    );
+  };
+
+  const useFormContext = () => ({
+    getFieldState: (_name: string) => ({ error: undefined, isDirty: false, invalid: false }),
+    formState: { errors: {} as Record<string, { message?: string }> },
+  });
+
+  return { FormProvider, Controller, useFormContext };
+});
+
+vi.mock('@radix-ui/react-slot', () => {
+  const Slot = React.forwardRef<
+    HTMLDivElement,
+    React.HTMLAttributes<HTMLDivElement> & { children?: React.ReactNode }
+  >(({ children, ...props }, ref) => (
+    <div ref={ref} {...props}>
+      {children}
+    </div>
+  ));
+  Slot.displayName = 'Slot';
+  return { Slot };
+});
+
+vi.mock('@radix-ui/react-label', () => {
+  const Root = React.forwardRef<HTMLLabelElement, React.LabelHTMLAttributes<HTMLLabelElement>>(
+    ({ children, ...props }, ref) => (
+      <label ref={ref} {...props}>
+        {children}
+      </label>
+    )
+  );
+  Root.displayName = 'LabelRoot';
+  return { Root };
+});
+
+vi.mock('@/components/ui/label', () => {
+  const Label = React.forwardRef<HTMLLabelElement, React.LabelHTMLAttributes<HTMLLabelElement>>(
+    ({ children, ...props }, ref) => (
+      <label ref={ref} {...props}>
+        {children}
+      </label>
+    )
+  );
+  Label.displayName = 'Label';
+  return { Label };
+});
+
+import { Form, FormItem, FormLabel, FormControl, FormDescription, FormMessage } from './form';
+
+const MockedForm = Form as unknown as React.FC<{ children?: React.ReactNode }>;
+
+describe('Form', () => {
+  it('renders Form (FormProvider) wrapping children', () => {
+    render(
+      <MockedForm>
+        <div>Form content</div>
+      </MockedForm>
+    );
+    expect(screen.getByTestId('form-provider')).toBeTruthy();
+    expect(screen.getByText('Form content')).toBeTruthy();
+  });
+
+  it('renders FormItem as a div', () => {
+    render(
+      <FormItem data-testid="test-item">
+        <span>Item content</span>
+      </FormItem>
+    );
+    expect(screen.getByTestId('test-item')).toBeTruthy();
+    expect(screen.getByText('Item content')).toBeTruthy();
+  });
+
+  it('renders FormLabel as a label element', () => {
+    render(<FormLabel>Username</FormLabel>);
+    const label = screen.getByText('Username');
+    expect(label.tagName).toBe('LABEL');
+  });
+
+  it('renders FormControl wrapping a child element', () => {
+    render(
+      <FormControl>
+        <input data-testid="form-input" />
+      </FormControl>
+    );
+    expect(screen.getByTestId('form-input')).toBeTruthy();
+  });
+
+  it('renders FormDescription', () => {
+    render(<FormDescription data-testid="test-desc">This is a help text</FormDescription>);
+    expect(screen.getByTestId('test-desc')).toBeTruthy();
+    expect(screen.getByText('This is a help text')).toBeTruthy();
+  });
+
+  it('renders FormMessage with no error returns null', () => {
+    const { container } = render(<FormMessage />);
+    expect(container.firstChild).toBeNull();
+  });
+
+  it('renders FormMessage with children text when no error', () => {
+    render(<FormMessage>fallback text</FormMessage>);
+    expect(screen.getByText('fallback text')).toBeTruthy();
+  });
+
+  it('passes className to FormItem', () => {
+    render(<FormItem className="custom-item" data-testid="item" />);
+    expect(screen.getByTestId('item').className).toContain('custom-item');
+  });
+
+  it('passes className to FormDescription', () => {
+    render(
+      <FormDescription className="desc-custom" data-testid="desc">
+        Text
+      </FormDescription>
+    );
+    expect(screen.getByTestId('desc').className).toContain('desc-custom');
+  });
+
+  it('passes ref to FormItem', () => {
+    const ref = React.createRef<HTMLDivElement>();
+    render(<FormItem ref={ref}>Content</FormItem>);
+    expect(ref.current).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/label.test.tsx b/src/components/ui/label.test.tsx
new file mode 100644
index 00000000..8f7a02ef
--- /dev/null
+++ b/src/components/ui/label.test.tsx
@@ -0,0 +1,39 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-label', () => {
+  const Root = React.forwardRef<HTMLLabelElement, React.ComponentPropsWithoutRef<'label'>>(
+    ({ children, ...props }, ref) => (
+      <label ref={ref} {...props}>
+        {children}
+      </label>
+    )
+  );
+  Root.displayName = 'Label';
+  return { Root };
+});
+
+import { Label } from './label';
+
+describe('Label', () => {
+  it('renders label element', () => {
+    render(<Label data-testid="label">Email</Label>);
+    expect(screen.getByTestId('label').tagName).toBe('LABEL');
+    expect(screen.getByText('Email')).toBeTruthy();
+  });
+
+  it('passes custom className', () => {
+    render(
+      <Label className="custom-label" data-testid="label">
+        Name
+      </Label>
+    );
+    expect(screen.getByTestId('label').className).toContain('custom-label');
+  });
+
+  it('has font-medium in default class', () => {
+    render(<Label data-testid="label">X</Label>);
+    expect(screen.getByTestId('label').className).toContain('font-medium');
+  });
+});
diff --git a/src/components/ui/menubar.test.tsx b/src/components/ui/menubar.test.tsx
new file mode 100644
index 00000000..824466d9
--- /dev/null
+++ b/src/components/ui/menubar.test.tsx
@@ -0,0 +1,277 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-menubar', () => {
+  const createPrimitive = (displayName: string) => {
+    const Component = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+      ({ children, ...props }, ref) => (
+        <div ref={ref} data-slot={displayName} {...props}>
+          {children}
+        </div>
+      )
+    );
+    Component.displayName = displayName;
+    return Component;
+  };
+
+  const createButton = (displayName: string) => {
+    const Component = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<'button'>>(
+      ({ children, ...props }, ref) => (
+        <button ref={ref} data-slot={displayName} {...props}>
+          {children}
+        </button>
+      )
+    );
+    Component.displayName = displayName;
+    return Component;
+  };
+
+  return {
+    Root: createPrimitive('Menubar'),
+    Menu: createPrimitive('MenubarMenu'),
+    Trigger: createButton('MenubarTrigger'),
+    Content: createPrimitive('MenubarContent'),
+    CheckboxItem: createPrimitive('MenubarCheckboxItem'),
+    RadioItem: createPrimitive('MenubarRadioItem'),
+    Label: createPrimitive('MenubarLabel'),
+    Separator: createPrimitive('MenubarSeparator'),
+    Group: ({
+      children,
+      heading,
+      ...props
+    }: React.ComponentPropsWithoutRef<'div'> & { heading?: string }) => (
+      <div data-slot="MenubarGroup" {...props}>
+        {heading && <div data-slot="MenubarGroupHeading">{heading}</div>}
+        {children}
+      </div>
+    ),
+    Item: ({
+      children,
+      onSelect,
+      ...props
+    }: React.ComponentPropsWithoutRef<'div'> & { onSelect?: (e: Event) => void }) => (
+      <div data-slot="MenubarItem" onClick={(e) => onSelect?.(e)} {...props}>
+        {children}
+      </div>
+    ),
+    Portal: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+    RadioGroup: createPrimitive('MenubarRadioGroup'),
+    Sub: createPrimitive('MenubarSub'),
+    SubTrigger: createButton('MenubarSubTrigger'),
+    SubContent: createPrimitive('MenubarSubContent'),
+    ItemIndicator: ({ children }: { children: React.ReactNode }) => (
+      <span data-slot="MenubarItemIndicator">{children}</span>
+    ),
+  };
+});
+
+import {
+  Menubar,
+  MenubarMenu,
+  MenubarTrigger,
+  MenubarContent,
+  MenubarItem,
+  MenubarSeparator,
+  MenubarLabel,
+  MenubarShortcut,
+  MenubarGroup,
+  MenubarCheckboxItem,
+  MenubarRadioGroup,
+  MenubarRadioItem,
+} from './menubar';
+
+describe('Menubar', () => {
+  it('renders without throwing', () => {
+    const { container } = render(<Menubar />);
+    expect(container).toBeTruthy();
+  });
+
+  it('passes className', () => {
+    render(<Menubar className="custom-class" data-testid="menubar" />);
+    expect(screen.getByTestId('menubar')).toHaveClass('custom-class');
+  });
+
+  it('renders children', () => {
+    render(
+      <Menubar>
+        <span>Content</span>
+      </Menubar>
+    );
+    expect(screen.getByText('Content')).toBeTruthy();
+  });
+});
+
+describe('MenubarMenu', () => {
+  it('renders children inside a menu', () => {
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <span>Menu item</span>
+        </MenubarMenu>
+      </Menubar>
+    );
+    expect(screen.getByText('Menu item')).toBeTruthy();
+  });
+});
+
+describe('MenubarTrigger', () => {
+  it('renders as a button', () => {
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger>File</MenubarTrigger>
+        </MenubarMenu>
+      </Menubar>
+    );
+    const trigger = screen.getByText('File');
+    expect(trigger.tagName).toBe('BUTTON');
+  });
+
+  it('handles onClick', () => {
+    const handleClick = vi.fn();
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger onClick={handleClick}>File</MenubarTrigger>
+        </MenubarMenu>
+      </Menubar>
+    );
+    fireEvent.click(screen.getByText('File'));
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('MenubarContent', () => {
+  it('renders content with items', () => {
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger>File</MenubarTrigger>
+          <MenubarContent>
+            <MenubarItem>New</MenubarItem>
+            <MenubarItem>Open</MenubarItem>
+          </MenubarContent>
+        </MenubarMenu>
+      </Menubar>
+    );
+    expect(screen.getByText('New')).toBeTruthy();
+    expect(screen.getByText('Open')).toBeTruthy();
+  });
+});
+
+describe('MenubarItem', () => {
+  it('renders and handles click', () => {
+    const handleClick = vi.fn();
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger>Menu</MenubarTrigger>
+          <MenubarContent>
+            <MenubarItem onSelect={handleClick}>Copy</MenubarItem>
+          </MenubarContent>
+        </MenubarMenu>
+      </Menubar>
+    );
+    fireEvent.click(screen.getByText('Copy'));
+    expect(handleClick).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('MenubarSeparator', () => {
+  it('renders a separator', () => {
+    const { container } = render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger>Menu</MenubarTrigger>
+          <MenubarContent>
+            <MenubarItem>A</MenubarItem>
+            <MenubarSeparator />
+            <MenubarItem>B</MenubarItem>
+          </MenubarContent>
+        </MenubarMenu>
+      </Menubar>
+    );
+    expect(container.querySelector('[data-slot="MenubarSeparator"]')).toBeTruthy();
+  });
+});
+
+describe('MenubarLabel', () => {
+  it('renders label text', () => {
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger>Menu</MenubarTrigger>
+          <MenubarContent>
+            <MenubarLabel>Actions</MenubarLabel>
+          </MenubarContent>
+        </MenubarMenu>
+      </Menubar>
+    );
+    expect(screen.getByText('Actions')).toBeTruthy();
+  });
+});
+
+describe('MenubarShortcut', () => {
+  it('renders shortcut text', () => {
+    render(<MenubarShortcut>⌘S</MenubarShortcut>);
+    expect(screen.getByText('⌘S')).toBeTruthy();
+  });
+});
+
+describe('MenubarGroup', () => {
+  it('renders grouped items', () => {
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger>Edit</MenubarTrigger>
+          <MenubarContent>
+            {/* @ts-expect-error - heading prop accepted by mock but not by real Radix type */}
+            <MenubarGroup heading="Clipboard" data-testid="menubar-group">
+              <MenubarItem>Cut</MenubarItem>
+              <MenubarItem>Copy</MenubarItem>
+            </MenubarGroup>
+          </MenubarContent>
+        </MenubarMenu>
+      </Menubar>
+    );
+    expect(screen.getByText('Clipboard')).toBeTruthy();
+    expect(screen.getByText('Cut')).toBeTruthy();
+  });
+});
+
+describe('MenubarCheckboxItem', () => {
+  it('renders checkbox item', () => {
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger>View</MenubarTrigger>
+          <MenubarContent>
+            <MenubarCheckboxItem checked={true}>Show Toolbar</MenubarCheckboxItem>
+          </MenubarContent>
+        </MenubarMenu>
+      </Menubar>
+    );
+    expect(screen.getByText('Show Toolbar')).toBeTruthy();
+  });
+});
+
+describe('MenubarRadioGroup', () => {
+  it('renders radio group with items', () => {
+    render(
+      <Menubar>
+        <MenubarMenu>
+          <MenubarTrigger>Layout</MenubarTrigger>
+          <MenubarContent>
+            <MenubarRadioGroup value="grid">
+              <MenubarRadioItem value="grid">Grid</MenubarRadioItem>
+              <MenubarRadioItem value="list">List</MenubarRadioItem>
+            </MenubarRadioGroup>
+          </MenubarContent>
+        </MenubarMenu>
+      </Menubar>
+    );
+    expect(screen.getByText('Grid')).toBeTruthy();
+    expect(screen.getByText('List')).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/popover.test.tsx b/src/components/ui/popover.test.tsx
new file mode 100644
index 00000000..1af7127c
--- /dev/null
+++ b/src/components/ui/popover.test.tsx
@@ -0,0 +1,89 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-popover', () => {
+  const Trigger = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<'button'>>(
+    ({ children, ...props }, ref) => (
+      <button ref={ref} data-slot="PopoverTrigger" {...props}>
+        {children}
+      </button>
+    )
+  );
+  Trigger.displayName = 'PopoverTrigger';
+
+  const Content = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-slot="PopoverContent" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Content.displayName = 'PopoverContent';
+
+  return {
+    Root: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+    Trigger,
+    Portal: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+    Content,
+  };
+});
+
+import { Popover, PopoverTrigger, PopoverContent } from './popover';
+
+describe('Popover', () => {
+  it('renders trigger and content', () => {
+    render(
+      <Popover>
+        <PopoverTrigger>Open popover</PopoverTrigger>
+        <PopoverContent>Popover body</PopoverContent>
+      </Popover>
+    );
+    expect(screen.getByText('Open popover')).toBeTruthy();
+    expect(screen.getByText('Popover body')).toBeTruthy();
+  });
+});
+
+describe('PopoverTrigger', () => {
+  it('renders as a button', () => {
+    render(
+      <Popover>
+        <PopoverTrigger>Click me</PopoverTrigger>
+      </Popover>
+    );
+    expect(screen.getByText('Click me').tagName).toBe('BUTTON');
+  });
+
+  it('handles onClick', () => {
+    const onClick = vi.fn();
+    render(
+      <Popover>
+        <PopoverTrigger onClick={onClick}>Toggle</PopoverTrigger>
+      </Popover>
+    );
+    fireEvent.click(screen.getByText('Toggle'));
+    expect(onClick).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('PopoverContent', () => {
+  it('renders content', () => {
+    render(
+      <Popover>
+        <PopoverTrigger>Open</PopoverTrigger>
+        <PopoverContent>Content text</PopoverContent>
+      </Popover>
+    );
+    expect(screen.getByText('Content text')).toBeTruthy();
+  });
+
+  it('passes custom className', () => {
+    render(
+      <Popover>
+        <PopoverTrigger>Open</PopoverTrigger>
+        <PopoverContent className="custom-popover">Body</PopoverContent>
+      </Popover>
+    );
+    expect(screen.getByText('Body')).toHaveClass('custom-popover');
+  });
+});
diff --git a/src/components/ui/premium-skeleton.test.tsx b/src/components/ui/premium-skeleton.test.tsx
new file mode 100644
index 00000000..8ccf53cc
--- /dev/null
+++ b/src/components/ui/premium-skeleton.test.tsx
@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+
+import { PremiumSkeleton } from './premium-skeleton';
+
+describe('PremiumSkeleton', () => {
+  it('renders a div', () => {
+    render(<PremiumSkeleton data-testid="skeleton" />);
+    expect(screen.getByTestId('skeleton').tagName).toBe('DIV');
+  });
+
+  it('has animate-pulse class', () => {
+    render(<PremiumSkeleton data-testid="skeleton" />);
+    expect(screen.getByTestId('skeleton').className).toContain('animate-pulse');
+  });
+
+  it('passes custom className', () => {
+    render(<PremiumSkeleton className="h-10 w-50" data-testid="skeleton" />);
+    const el = screen.getByTestId('skeleton');
+    expect(el.className).toContain('h-10');
+    expect(el.className).toContain('w-50');
+  });
+
+  it('passes extra props', () => {
+    render(<PremiumSkeleton data-testid="skeleton" role="img" />);
+    expect(screen.getByTestId('skeleton').getAttribute('role')).toBe('img');
+  });
+});
diff --git a/src/components/ui/progress.test.tsx b/src/components/ui/progress.test.tsx
new file mode 100644
index 00000000..56d6f879
--- /dev/null
+++ b/src/components/ui/progress.test.tsx
@@ -0,0 +1,52 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-progress', () => {
+  const Root = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} role="progressbar" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Root.displayName = 'ProgressRoot';
+
+  const Indicator = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="indicator" {...props} />
+  );
+  Indicator.displayName = 'ProgressIndicator';
+
+  return { Root, Indicator };
+});
+
+import { Progress } from './progress';
+
+describe('Progress', () => {
+  it('renders with progressbar role', () => {
+    render(<Progress value={50} data-testid="progress" />);
+    expect(screen.getByRole('progressbar')).toBeTruthy();
+  });
+
+  it('renders indicator', () => {
+    render(<Progress value={30} />);
+    expect(screen.getByTestId('indicator')).toBeTruthy();
+  });
+
+  it('applies transform style based on value', () => {
+    render(<Progress value={75} data-testid="progress" />);
+    const indicator = screen.getByTestId('indicator');
+    expect(indicator.style.transform).toBe('translateX(-25%)');
+  });
+
+  it('handles null value (defaults to 0)', () => {
+    render(<Progress data-testid="progress" />);
+    const indicator = screen.getByTestId('indicator');
+    expect(indicator.style.transform).toBe('translateX(-100%)');
+  });
+
+  it('passes custom className', () => {
+    render(<Progress value={50} className="my-progress" data-testid="progress" />);
+    expect(screen.getByTestId('progress').className).toContain('my-progress');
+  });
+});
diff --git a/src/components/ui/radio-group.test.tsx b/src/components/ui/radio-group.test.tsx
new file mode 100644
index 00000000..097e5c7e
--- /dev/null
+++ b/src/components/ui/radio-group.test.tsx
@@ -0,0 +1,103 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-radio-group', () => {
+  const Root = React.forwardRef<
+    HTMLDivElement,
+    React.ComponentPropsWithoutRef<'div'> & { onValueChange?: (value: string) => void }
+  >(({ children, onValueChange, ...props }, ref) => (
+    <div ref={ref} role="radiogroup" {...props}>
+      {React.Children.map(children, (child) => {
+        if (React.isValidElement(child)) {
+          return React.cloneElement(
+            child as React.ReactElement<{ onValueChange?: (v: string) => void }>,
+            {
+              onValueChange,
+            }
+          );
+        }
+        return child;
+      })}
+    </div>
+  ));
+  Root.displayName = 'RadioGroupRoot';
+
+  const Item = React.forwardRef<
+    HTMLButtonElement,
+    React.ComponentPropsWithoutRef<'button'> & {
+      value?: string;
+      onValueChange?: (v: string) => void;
+    }
+  >(({ children, value: itemValue, onValueChange: parentOnChange, ...props }, ref) => (
+    <button
+      ref={ref}
+      role="radio"
+      aria-checked="false"
+      data-value={itemValue}
+      onClick={() => parentOnChange?.(itemValue ?? '')}
+      {...props}
+    >
+      {children}
+    </button>
+  ));
+  Item.displayName = 'RadioGroupItem';
+
+  const Indicator = ({ children }: { children: React.ReactNode }) => (
+    <span data-testid="indicator">{children}</span>
+  );
+  Indicator.displayName = 'RadioGroupIndicator';
+
+  return { Root, Item, Indicator };
+});
+
+import { RadioGroup, RadioGroupItem } from './radio-group';
+
+describe('RadioGroup components', () => {
+  it('RadioGroup renders with radiogroup role', () => {
+    render(
+      <RadioGroup data-testid="rg">
+        <RadioGroupItem value="a" />
+      </RadioGroup>
+    );
+    expect(screen.getByTestId('rg').getAttribute('role')).toBe('radiogroup');
+  });
+
+  it('RadioGroupItem renders with radio role', () => {
+    render(
+      <RadioGroup defaultValue="x">
+        <RadioGroupItem value="x" data-testid="ri" />
+      </RadioGroup>
+    );
+    expect(screen.getByTestId('ri').getAttribute('role')).toBe('radio');
+  });
+
+  it('RadioGroup passes className', () => {
+    render(
+      <RadioGroup className="my-rg" data-testid="rg">
+        <RadioGroupItem value="a" />
+      </RadioGroup>
+    );
+    expect(screen.getByTestId('rg').className).toContain('my-rg');
+  });
+
+  it('RadioGroupItem passes className', () => {
+    render(
+      <RadioGroup defaultValue="b">
+        <RadioGroupItem value="b" className="my-ri" data-testid="ri" />
+      </RadioGroup>
+    );
+    expect(screen.getByTestId('ri').className).toContain('my-ri');
+  });
+
+  it('renders multiple items', () => {
+    render(
+      <RadioGroup defaultValue="1">
+        <RadioGroupItem value="1" />
+        <RadioGroupItem value="2" />
+        <RadioGroupItem value="3" />
+      </RadioGroup>
+    );
+    expect(screen.getAllByRole('radio')).toHaveLength(3);
+  });
+});
diff --git a/src/components/ui/scroll-area.test.tsx b/src/components/ui/scroll-area.test.tsx
new file mode 100644
index 00000000..9641ab62
--- /dev/null
+++ b/src/components/ui/scroll-area.test.tsx
@@ -0,0 +1,109 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-scroll-area', () => {
+  const Root = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-slot="ScrollAreaRoot" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Root.displayName = 'ScrollAreaRoot';
+
+  const Viewport = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-slot="ScrollAreaViewport" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Viewport.displayName = 'ScrollAreaViewport';
+
+  const Scrollbar = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-slot="ScrollAreaScrollbar" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Scrollbar.displayName = 'ScrollAreaScrollbar';
+
+  const Thumb = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ ...props }, ref) => <div ref={ref} data-slot="ScrollAreaThumb" {...props} />
+  );
+  Thumb.displayName = 'ScrollAreaThumb';
+
+  return {
+    Root,
+    Viewport,
+    ScrollAreaScrollbar: Scrollbar,
+    ScrollAreaThumb: Thumb,
+    Corner: () => <div data-slot="ScrollAreaCorner" />,
+  };
+});
+
+import { ScrollArea, ScrollBar } from './scroll-area';
+
+describe('ScrollArea', () => {
+  it('renders without throwing', () => {
+    const { container } = render(
+      <ScrollArea>
+        <div>Scrollable content</div>
+      </ScrollArea>
+    );
+    expect(container).toBeTruthy();
+  });
+
+  it('renders children', () => {
+    render(
+      <ScrollArea>
+        <p>Long text content that might overflow</p>
+      </ScrollArea>
+    );
+    expect(screen.getByText('Long text content that might overflow')).toBeTruthy();
+  });
+
+  it('passes custom className', () => {
+    render(
+      <ScrollArea className="custom-scroll" data-testid="scroll">
+        <div>Content</div>
+      </ScrollArea>
+    );
+    expect(screen.getByTestId('scroll')).toHaveClass('custom-scroll');
+  });
+
+  it('includes scrollbar and corner', () => {
+    const { container } = render(
+      <ScrollArea>
+        <div>Content</div>
+      </ScrollArea>
+    );
+    expect(container.querySelector('[data-slot="ScrollAreaScrollbar"]')).toBeTruthy();
+    expect(container.querySelector('[data-slot="ScrollAreaCorner"]')).toBeTruthy();
+  });
+});
+
+describe('ScrollBar', () => {
+  it('renders with vertical orientation by default', () => {
+    const { container } = render(
+      <ScrollArea>
+        <div>Content</div>
+        <ScrollBar />
+      </ScrollArea>
+    );
+    expect(container.querySelector('[data-slot="ScrollAreaScrollbar"]')).toBeTruthy();
+  });
+
+  it('renders with horizontal orientation', () => {
+    const { container } = render(
+      <ScrollArea>
+        <div>Content</div>
+        <ScrollBar orientation="horizontal" />
+      </ScrollArea>
+    );
+    const scrollbar = container.querySelector('[data-slot="ScrollAreaScrollbar"]');
+    expect(scrollbar).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/select.test.tsx b/src/components/ui/select.test.tsx
new file mode 100644
index 00000000..b22ce7a6
--- /dev/null
+++ b/src/components/ui/select.test.tsx
@@ -0,0 +1,277 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-select', () => {
+  const Root = ({
+    children,
+    value,
+    ...props
+  }: {
+    children?: React.ReactNode;
+    value?: string;
+    [key: string]: unknown;
+  }) => (
+    <div data-testid="select-root" data-value={value} {...props}>
+      {children}
+    </div>
+  );
+
+  const Trigger = React.forwardRef<
+    HTMLButtonElement,
+    React.ButtonHTMLAttributes<HTMLButtonElement>
+  >(({ children, ...props }, ref) => (
+    <button ref={ref} data-testid="select-trigger" role="combobox" {...props}>
+      {children}
+    </button>
+  ));
+  Trigger.displayName = 'SelectTrigger';
+
+  const Value = ({ placeholder }: { placeholder?: string }) => (
+    <span data-testid="select-value">{placeholder}</span>
+  );
+
+  const Content = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="select-content" role="listbox" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Content.displayName = 'SelectContent';
+
+  const Item = React.forwardRef<
+    HTMLDivElement,
+    React.HTMLAttributes<HTMLDivElement> & { value: string }
+  >(({ children, value: itemValue, ...props }, ref) => (
+    <div ref={ref} data-testid="select-item" data-value={itemValue} role="option" {...props}>
+      {children}
+    </div>
+  ));
+  Item.displayName = 'SelectItem';
+
+  const Group = ({
+    children,
+    ...props
+  }: {
+    children?: React.ReactNode;
+    [key: string]: unknown;
+  }) => (
+    <div data-testid="select-group" {...props}>
+      {children}
+    </div>
+  );
+
+  const Label = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="select-label" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Label.displayName = 'SelectLabel';
+
+  const Separator = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => (
+      <div ref={ref} data-testid="select-separator" role="separator" {...props} />
+    )
+  );
+  Separator.displayName = 'SelectSeparator';
+
+  const Icon = ({ children }: { children?: React.ReactNode; asChild?: boolean }) => <>{children}</>;
+
+  const ItemIndicator = ({ children }: { children?: React.ReactNode }) => <>{children}</>;
+
+  const ItemText = ({ children }: { children?: React.ReactNode }) => <span>{children}</span>;
+
+  const Portal = ({ children }: { children?: React.ReactNode }) => <>{children}</>;
+
+  const Viewport = ({
+    children,
+    ...props
+  }: {
+    children?: React.ReactNode;
+    [key: string]: unknown;
+  }) => (
+    <div data-testid="select-viewport" {...props}>
+      {children}
+    </div>
+  );
+
+  const ScrollUpButton = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="select-scroll-up" {...props} />
+  );
+  ScrollUpButton.displayName = 'SelectScrollUpButton';
+
+  const ScrollDownButton = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="select-scroll-down" {...props} />
+  );
+  ScrollDownButton.displayName = 'SelectScrollDownButton';
+
+  return {
+    Root,
+    Trigger,
+    Value,
+    Content,
+    Item,
+    Group,
+    Label,
+    Separator,
+    Icon,
+    ItemIndicator,
+    ItemText,
+    Portal,
+    Viewport,
+    ScrollUpButton,
+    ScrollDownButton,
+  };
+});
+
+vi.mock('lucide-react', () => ({
+  Check: () => <svg data-testid="icon-check" />,
+  ChevronDown: () => <svg data-testid="icon-chevron-down" />,
+  ChevronUp: () => <svg data-testid="icon-chevron-up" />,
+}));
+
+import {
+  Select,
+  SelectTrigger,
+  SelectContent,
+  SelectItem,
+  SelectValue,
+  SelectGroup,
+  SelectLabel,
+  SelectSeparator,
+} from './select';
+
+describe('Select', () => {
+  it('renders Select root without crashing', () => {
+    render(
+      <Select>
+        <SelectTrigger>
+          <SelectValue placeholder="Pick one" />
+        </SelectTrigger>
+      </Select>
+    );
+    expect(screen.getByTestId('select-root')).toBeTruthy();
+  });
+
+  it('renders SelectTrigger', () => {
+    render(
+      <Select>
+        <SelectTrigger>
+          <SelectValue placeholder="Choose..." />
+        </SelectTrigger>
+      </Select>
+    );
+    expect(screen.getByTestId('select-trigger')).toBeTruthy();
+  });
+
+  it('renders SelectValue with placeholder', () => {
+    render(
+      <Select>
+        <SelectTrigger>
+          <SelectValue placeholder="Select a fruit" />
+        </SelectTrigger>
+      </Select>
+    );
+    expect(screen.getByText('Select a fruit')).toBeTruthy();
+  });
+
+  it('renders chevron icon inside trigger', () => {
+    render(
+      <Select>
+        <SelectTrigger>
+          <SelectValue placeholder="Pick" />
+        </SelectTrigger>
+      </Select>
+    );
+    expect(screen.getByTestId('icon-chevron-down')).toBeTruthy();
+  });
+
+  it('renders SelectContent', () => {
+    render(
+      <Select>
+        <SelectTrigger>
+          <SelectValue placeholder="Pick" />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="apple">Apple</SelectItem>
+        </SelectContent>
+      </Select>
+    );
+    expect(screen.getByTestId('select-content')).toBeTruthy();
+  });
+
+  it('renders SelectItem with children', () => {
+    render(
+      <Select>
+        <SelectTrigger>
+          <SelectValue placeholder="Pick" />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="banana">Banana</SelectItem>
+          <SelectItem value="cherry">Cherry</SelectItem>
+        </SelectContent>
+      </Select>
+    );
+    expect(screen.getByText('Banana')).toBeTruthy();
+    expect(screen.getByText('Cherry')).toBeTruthy();
+  });
+
+  it('passes value prop to Select root', () => {
+    render(
+      <Select value="apple">
+        <SelectTrigger>
+          <SelectValue placeholder="Pick" />
+        </SelectTrigger>
+      </Select>
+    );
+    expect(screen.getByTestId('select-root').getAttribute('data-value')).toBe('apple');
+  });
+
+  it('renders SelectGroup', () => {
+    render(
+      <Select>
+        <SelectTrigger>
+          <SelectValue placeholder="Pick" />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectGroup>
+            <SelectLabel>Fruits</SelectLabel>
+            <SelectItem value="apple">Apple</SelectItem>
+          </SelectGroup>
+        </SelectContent>
+      </Select>
+    );
+    expect(screen.getByTestId('select-group')).toBeTruthy();
+    expect(screen.getByText('Fruits')).toBeTruthy();
+  });
+
+  it('renders SelectSeparator', () => {
+    render(
+      <Select>
+        <SelectTrigger>
+          <SelectValue placeholder="Pick" />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem value="apple">Apple</SelectItem>
+          <SelectSeparator />
+          <SelectItem value="banana">Banana</SelectItem>
+        </SelectContent>
+      </Select>
+    );
+    expect(screen.getByTestId('select-separator')).toBeTruthy();
+  });
+
+  it('passes className to SelectTrigger', () => {
+    render(
+      <Select>
+        <SelectTrigger className="my-custom-trigger">
+          <SelectValue placeholder="Pick" />
+        </SelectTrigger>
+      </Select>
+    );
+    expect(screen.getByTestId('select-trigger').className).toContain('my-custom-trigger');
+  });
+});
diff --git a/src/components/ui/separator.test.tsx b/src/components/ui/separator.test.tsx
new file mode 100644
index 00000000..a74f5509
--- /dev/null
+++ b/src/components/ui/separator.test.tsx
@@ -0,0 +1,58 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-separator', () => {
+  const Root = React.forwardRef<
+    HTMLDivElement,
+    React.ComponentPropsWithoutRef<'div'> & {
+      orientation?: 'horizontal' | 'vertical';
+      decorative?: boolean;
+    }
+  >(({ orientation = 'horizontal', decorative = true, ...props }, ref) => (
+    <div
+      ref={ref}
+      role="separator"
+      data-orientation={orientation}
+      data-decorative={decorative ? 'true' : undefined}
+      {...props}
+    />
+  ));
+  Root.displayName = 'Separator';
+  return { Root };
+});
+
+import { Separator } from './separator';
+
+describe('Separator', () => {
+  it('renders horizontal separator by default', () => {
+    const { container } = render(<Separator />);
+    const el = container.firstChild as HTMLElement;
+    expect(el).toBeTruthy();
+    expect(el.getAttribute('role')).toBe('separator');
+    expect(el.getAttribute('data-orientation')).toBe('horizontal');
+  });
+
+  it('renders vertical separator', () => {
+    const { container } = render(<Separator orientation="vertical" />);
+    const el = container.firstChild as HTMLElement;
+    expect(el.getAttribute('data-orientation')).toBe('vertical');
+  });
+
+  it('passes decorative attribute', () => {
+    const { container } = render(<Separator decorative={false} />);
+    const el = container.firstChild as HTMLElement;
+    expect(el.getAttribute('data-decorative')).toBeNull();
+  });
+
+  it('passes custom className', () => {
+    const { container } = render(<Separator className="my-separator" />);
+    const el = container.firstChild as HTMLElement;
+    expect(el.className).toContain('my-separator');
+  });
+
+  it('passes data attributes', () => {
+    render(<Separator data-testid="sep" />);
+    expect(screen.getByTestId('sep')).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/sheet.test.tsx b/src/components/ui/sheet.test.tsx
new file mode 100644
index 00000000..8f12056b
--- /dev/null
+++ b/src/components/ui/sheet.test.tsx
@@ -0,0 +1,207 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-dialog', () => {
+  const Root = ({
+    children,
+    open,
+    ...props
+  }: {
+    children?: React.ReactNode;
+    open?: boolean;
+    [key: string]: unknown;
+  }) => (
+    <div data-testid="sheet-root" data-state={open ? 'open' : 'closed'} {...props}>
+      {children}
+    </div>
+  );
+
+  const Trigger = React.forwardRef<
+    HTMLButtonElement,
+    React.ButtonHTMLAttributes<HTMLButtonElement>
+  >(({ children, ...props }, ref) => (
+    <button ref={ref} data-testid="sheet-trigger" {...props}>
+      {children}
+    </button>
+  ));
+  Trigger.displayName = 'SheetTrigger';
+
+  const Portal = ({ children }: { children?: React.ReactNode }) => <>{children}</>;
+
+  const Overlay = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="sheet-overlay" {...props} />
+  );
+  Overlay.displayName = 'SheetOverlay';
+
+  const Content = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="sheet-content" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Content.displayName = 'SheetContent';
+
+  const Close = React.forwardRef<HTMLButtonElement, React.ButtonHTMLAttributes<HTMLButtonElement>>(
+    ({ children, ...props }, ref) => (
+      <button ref={ref} data-testid="sheet-close" {...props}>
+        {children}
+      </button>
+    )
+  );
+  Close.displayName = 'SheetClose';
+
+  const Title = React.forwardRef<HTMLHeadingElement, React.HTMLAttributes<HTMLHeadingElement>>(
+    ({ children, ...props }, ref) => (
+      <h2 ref={ref} data-testid="sheet-title" {...props}>
+        {children}
+      </h2>
+    )
+  );
+  Title.displayName = 'SheetTitle';
+
+  const Description = React.forwardRef<
+    HTMLParagraphElement,
+    React.HTMLAttributes<HTMLParagraphElement>
+  >(({ children, ...props }, ref) => (
+    <p ref={ref} data-testid="sheet-description" {...props}>
+      {children}
+    </p>
+  ));
+  Description.displayName = 'SheetDescription';
+
+  return { Root, Trigger, Portal, Overlay, Content, Close, Title, Description };
+});
+
+vi.mock('lucide-react', () => ({
+  X: () => <svg data-testid="icon-x" />,
+}));
+
+import {
+  Sheet,
+  SheetTrigger,
+  SheetContent,
+  SheetHeader,
+  SheetFooter,
+  SheetTitle,
+  SheetDescription,
+} from './sheet';
+
+describe('Sheet', () => {
+  it('renders Sheet root without crashing', () => {
+    render(
+      <Sheet>
+        <div>Content</div>
+      </Sheet>
+    );
+    expect(screen.getByTestId('sheet-root')).toBeTruthy();
+  });
+
+  it('renders SheetTrigger', () => {
+    render(
+      <Sheet>
+        <SheetTrigger>Open Sheet</SheetTrigger>
+      </Sheet>
+    );
+    expect(screen.getByTestId('sheet-trigger')).toBeTruthy();
+    expect(screen.getByText('Open Sheet')).toBeTruthy();
+  });
+
+  it('renders SheetContent with children', () => {
+    render(
+      <Sheet>
+        <SheetContent>
+          <p>Sheet body</p>
+        </SheetContent>
+      </Sheet>
+    );
+    expect(screen.getByTestId('sheet-content')).toBeTruthy();
+    expect(screen.getByText('Sheet body')).toBeTruthy();
+  });
+
+  it('renders close button inside SheetContent', () => {
+    render(
+      <Sheet>
+        <SheetContent>
+          <p>Content</p>
+        </SheetContent>
+      </Sheet>
+    );
+    expect(screen.getByTestId('sheet-close')).toBeTruthy();
+  });
+
+  it('renders SheetHeader with children', () => {
+    render(
+      <Sheet>
+        <SheetContent>
+          <SheetHeader>
+            <SheetTitle>Sheet Title</SheetTitle>
+            <SheetDescription>Sheet Description</SheetDescription>
+          </SheetHeader>
+        </SheetContent>
+      </Sheet>
+    );
+    expect(screen.getByText('Sheet Title')).toBeTruthy();
+    expect(screen.getByText('Sheet Description')).toBeTruthy();
+  });
+
+  it('renders SheetFooter with children', () => {
+    render(
+      <Sheet>
+        <SheetContent>
+          <SheetFooter>
+            <button>Action 1</button>
+            <button>Action 2</button>
+          </SheetFooter>
+        </SheetContent>
+      </Sheet>
+    );
+    expect(screen.getByText('Action 1')).toBeTruthy();
+    expect(screen.getByText('Action 2')).toBeTruthy();
+  });
+
+  it('renders SheetContent with side variant applied via className', () => {
+    render(
+      <Sheet>
+        <SheetContent side="left">
+          <p>Left sheet</p>
+        </SheetContent>
+      </Sheet>
+    );
+    const content = screen.getByTestId('sheet-content');
+    expect(content.className).toContain('left');
+  });
+
+  it('defaults to right side variant', () => {
+    render(
+      <Sheet>
+        <SheetContent>
+          <p>Right sheet</p>
+        </SheetContent>
+      </Sheet>
+    );
+    const content = screen.getByTestId('sheet-content');
+    expect(content.className).toContain('right');
+  });
+
+  it('passes open state to root', () => {
+    render(
+      <Sheet open>
+        <div>Child</div>
+      </Sheet>
+    );
+    expect(screen.getByTestId('sheet-root').getAttribute('data-state')).toBe('open');
+  });
+
+  it('passes className to SheetContent', () => {
+    render(
+      <Sheet>
+        <SheetContent className="my-custom-class">
+          <p>Content</p>
+        </SheetContent>
+      </Sheet>
+    );
+    expect(screen.getByTestId('sheet-content').className).toContain('my-custom-class');
+  });
+});
diff --git a/src/components/ui/sidebar.test.tsx b/src/components/ui/sidebar.test.tsx
new file mode 100644
index 00000000..399c2a32
--- /dev/null
+++ b/src/components/ui/sidebar.test.tsx
@@ -0,0 +1,610 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@/hooks/use-mobile', () => ({
+  useIsMobile: vi.fn(() => false),
+}));
+
+vi.mock('lucide-react', () => ({
+  PanelLeft: () => <svg data-testid="panel-left-icon" />,
+}));
+
+vi.mock('@radix-ui/react-tooltip', () => {
+  const Trigger = React.forwardRef<
+    HTMLButtonElement,
+    React.ButtonHTMLAttributes<HTMLButtonElement>
+  >(({ children, ...props }, ref) => (
+    <button ref={ref} {...props}>
+      {children}
+    </button>
+  ));
+  Trigger.displayName = 'TooltipTrigger';
+
+  const Content = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} {...props}>
+        {children}
+      </div>
+    )
+  );
+  Content.displayName = 'TooltipContent';
+
+  return {
+    Provider: ({ children }: { children?: React.ReactNode }) => <>{children}</>,
+    Root: ({ children }: { children?: React.ReactNode }) => <>{children}</>,
+    Trigger,
+    Content,
+  };
+});
+
+vi.mock('@radix-ui/react-separator', () => {
+  const Root = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} role="separator" {...props} />
+  );
+  Root.displayName = 'Separator';
+  return { Root };
+});
+
+vi.mock('@radix-ui/react-slot', () => {
+  const Slot = React.forwardRef<
+    HTMLDivElement,
+    React.HTMLAttributes<HTMLDivElement> & { children?: React.ReactNode }
+  >(({ children, ...props }, ref) => (
+    <div ref={ref} {...props}>
+      {children}
+    </div>
+  ));
+  Slot.displayName = 'Slot';
+  return { Slot };
+});
+
+vi.mock('@/components/ui/sheet', () => {
+  const SheetContent = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} data-testid="sheet-content" {...props}>
+        {children}
+      </div>
+    )
+  );
+  SheetContent.displayName = 'SheetContent';
+
+  const SheetTitle = React.forwardRef<HTMLHeadingElement, React.HTMLAttributes<HTMLHeadingElement>>(
+    ({ children, ...props }, ref) => (
+      <h2 ref={ref} {...props}>
+        {children}
+      </h2>
+    )
+  );
+  SheetTitle.displayName = 'SheetTitle';
+
+  return {
+    Sheet: ({ children }: { children?: React.ReactNode }) => (
+      <div data-testid="sheet">{children}</div>
+    ),
+    SheetContent,
+    SheetTitle,
+  };
+});
+
+import {
+  SidebarProvider,
+  Sidebar,
+  SidebarTrigger,
+  SidebarContent,
+  SidebarHeader,
+  SidebarFooter,
+  SidebarGroup,
+  SidebarGroupLabel,
+  SidebarGroupContent,
+  SidebarMenu,
+  SidebarMenuItem,
+  SidebarMenuButton,
+  SidebarMenuAction,
+  SidebarMenuBadge,
+  SidebarMenuSub,
+  SidebarMenuSubItem,
+  SidebarMenuSubButton,
+  SidebarSeparator,
+  SidebarInset,
+  useSidebar,
+} from './sidebar';
+
+function TestConsumer() {
+  const { state, open, toggleSidebar } = useSidebar();
+  return (
+    <div>
+      <span data-testid="state">{state}</span>
+      <span data-testid="open">{String(open)}</span>
+      <button data-testid="toggle" onClick={toggleSidebar}>
+        Toggle
+      </button>
+    </div>
+  );
+}
+
+describe('SidebarProvider', () => {
+  beforeEach(() => {
+    document.cookie = 'sidebar_state=; path=/; max-age=0';
+  });
+
+  it('renders without crashing', () => {
+    render(
+      <SidebarProvider>
+        <div>Content</div>
+      </SidebarProvider>
+    );
+    expect(screen.getByText('Content')).toBeTruthy();
+  });
+
+  it('provides context via useSidebar', () => {
+    render(
+      <SidebarProvider>
+        <TestConsumer />
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('state')).toBeTruthy();
+    expect(screen.getByTestId('open')).toBeTruthy();
+  });
+
+  it('defaults to expanded state', () => {
+    render(
+      <SidebarProvider>
+        <TestConsumer />
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('state').textContent).toBe('expanded');
+    expect(screen.getByTestId('open').textContent).toBe('true');
+  });
+
+  it('accepts defaultOpen=false', () => {
+    render(
+      <SidebarProvider defaultOpen={false}>
+        <TestConsumer />
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('state').textContent).toBe('collapsed');
+    expect(screen.getByTestId('open').textContent).toBe('false');
+  });
+
+  it('toggles sidebar on button click', () => {
+    render(
+      <SidebarProvider defaultOpen>
+        <TestConsumer />
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('state').textContent).toBe('expanded');
+    fireEvent.click(screen.getByTestId('toggle'));
+    expect(screen.getByTestId('state').textContent).toBe('collapsed');
+    fireEvent.click(screen.getByTestId('toggle'));
+    expect(screen.getByTestId('state').textContent).toBe('expanded');
+  });
+
+  it('throws when useSidebar used outside provider', () => {
+    const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    function BadConsumer() {
+      useSidebar();
+      return null;
+    }
+    expect(() => render(<BadConsumer />)).toThrow(
+      'useSidebar must be used within a SidebarProvider'
+    );
+    consoleSpy.mockRestore();
+  });
+
+  it('sets data-state on sidebar div', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>Nav</Sidebar>
+      </SidebarProvider>
+    );
+    const sidebar = screen.getByText('Nav').closest('[data-state]');
+    expect(sidebar?.getAttribute('data-state')).toBe('expanded');
+  });
+
+  it('responds to controlled open prop', () => {
+    function Controlled() {
+      const [open, setOpen] = React.useState(false);
+      return (
+        <SidebarProvider open={open} onOpenChange={setOpen}>
+          <span data-testid="open-val">{String(open)}</span>
+          <button data-testid="set-open" onClick={() => setOpen(true)}>
+            Open
+          </button>
+        </SidebarProvider>
+      );
+    }
+    render(<Controlled />);
+    expect(screen.getByTestId('open-val').textContent).toBe('false');
+    fireEvent.click(screen.getByTestId('set-open'));
+    expect(screen.getByTestId('open-val').textContent).toBe('true');
+  });
+});
+
+describe('Sidebar structural components', () => {
+  it('renders SidebarTrigger', () => {
+    render(
+      <SidebarProvider>
+        <SidebarTrigger />
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('panel-left-icon')).toBeTruthy();
+  });
+
+  it('SidebarTrigger calls toggleSidebar on click', () => {
+    render(
+      <SidebarProvider defaultOpen>
+        <TestConsumer />
+        <SidebarTrigger />
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('state').textContent).toBe('expanded');
+    fireEvent.click(screen.getByRole('button', { name: /toggle sidebar/i }));
+    expect(screen.getByTestId('state').textContent).toBe('collapsed');
+  });
+
+  it('renders SidebarHeader', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarHeader data-testid="header">
+            <span>Logo</span>
+          </SidebarHeader>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('header')).toBeTruthy();
+    expect(screen.getByText('Logo')).toBeTruthy();
+  });
+
+  it('renders SidebarFooter', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarFooter data-testid="footer">
+            <span>Footer</span>
+          </SidebarFooter>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('footer')).toBeTruthy();
+    expect(screen.getByText('Footer')).toBeTruthy();
+  });
+
+  it('renders SidebarContent', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent data-testid="content">
+            <span>Content</span>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('content')).toBeTruthy();
+    expect(screen.getByText('Content')).toBeTruthy();
+  });
+
+  it('renders SidebarGroup', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarGroup data-testid="group">Group content</SidebarGroup>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('group')).toBeTruthy();
+  });
+
+  it('renders SidebarGroupLabel', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarGroup>
+              <SidebarGroupLabel data-testid="group-label">Navigation</SidebarGroupLabel>
+            </SidebarGroup>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('group-label')).toBeTruthy();
+    expect(screen.getByText('Navigation')).toBeTruthy();
+  });
+
+  it('renders SidebarGroupContent', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarGroup>
+              <SidebarGroupContent data-testid="group-content">Items</SidebarGroupContent>
+            </SidebarGroup>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('group-content')).toBeTruthy();
+  });
+
+  it('renders SidebarMenu', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu data-testid="menu">Menu items</SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('menu')).toBeTruthy();
+    expect(screen.getByTestId('menu').tagName).toBe('UL');
+  });
+
+  it('renders SidebarMenuItem', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem data-testid="menu-item">Item</SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('menu-item')).toBeTruthy();
+    expect(screen.getByTestId('menu-item').tagName).toBe('LI');
+  });
+
+  it('renders SidebarMenuButton', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuButton data-testid="menu-button">Dashboard</SidebarMenuButton>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('menu-button')).toBeTruthy();
+    expect(screen.getByText('Dashboard')).toBeTruthy();
+  });
+
+  it('renders SidebarMenuButton with isActive', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuButton isActive data-testid="active-btn">
+                  Active Item
+                </SidebarMenuButton>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('active-btn').getAttribute('data-active')).toBe('true');
+  });
+
+  it('renders SidebarMenuAction', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuButton>Item</SidebarMenuButton>
+                <SidebarMenuAction data-testid="menu-action">Action</SidebarMenuAction>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('menu-action')).toBeTruthy();
+  });
+
+  it('renders SidebarMenuBadge', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuButton>Messages</SidebarMenuButton>
+                <SidebarMenuBadge data-testid="badge">5</SidebarMenuBadge>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('badge')).toBeTruthy();
+    expect(screen.getByText('5')).toBeTruthy();
+  });
+
+  it('renders SidebarMenuSub', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuSub data-testid="menu-sub">
+                  <SidebarMenuSubItem>Sub item</SidebarMenuSubItem>
+                </SidebarMenuSub>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('menu-sub')).toBeTruthy();
+    expect(screen.getByTestId('menu-sub').tagName).toBe('UL');
+  });
+
+  it('renders SidebarMenuSubItem', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuSub>
+                  <SidebarMenuSubItem data-testid="sub-item">Sub Item</SidebarMenuSubItem>
+                </SidebarMenuSub>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('sub-item')).toBeTruthy();
+    expect(screen.getByTestId('sub-item').tagName).toBe('LI');
+  });
+
+  it('renders SidebarMenuSubButton', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuSub>
+                  <SidebarMenuSubItem>
+                    <SidebarMenuSubButton data-testid="sub-button" href="/test">
+                      Sub Button
+                    </SidebarMenuSubButton>
+                  </SidebarMenuSubItem>
+                </SidebarMenuSub>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('sub-button')).toBeTruthy();
+    expect(screen.getByText('Sub Button')).toBeTruthy();
+  });
+
+  it('renders SidebarSeparator', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarSeparator data-testid="separator" />
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('separator')).toBeTruthy();
+    expect(screen.getByTestId('separator').getAttribute('role')).toBe('separator');
+  });
+
+  it('renders SidebarInset', () => {
+    render(
+      <SidebarProvider>
+        <SidebarInset data-testid="inset">
+          <span>Main content</span>
+        </SidebarInset>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('inset')).toBeTruthy();
+    expect(screen.getByTestId('inset').tagName).toBe('MAIN');
+    expect(screen.getByText('Main content')).toBeTruthy();
+  });
+
+  it('passes className to SidebarMenuButton', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuButton className="custom-btn" data-testid="custom-btn">
+                  Item
+                </SidebarMenuButton>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByTestId('custom-btn').className).toContain('custom-btn');
+  });
+
+  it('passes data attributes to SidebarMenuSubButton', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuSub>
+                  <SidebarMenuSubItem>
+                    <SidebarMenuSubButton size="sm" isActive href="/link">
+                      Sub
+                    </SidebarMenuSubButton>
+                  </SidebarMenuSubItem>
+                </SidebarMenuSub>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    const subBtn = screen.getByText('Sub').closest('a');
+    expect(subBtn?.getAttribute('data-size')).toBe('sm');
+    expect(subBtn?.getAttribute('data-active')).toBe('true');
+  });
+
+  it('Sidebar renders with side=right', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar side="right">
+          <SidebarContent>Right sidebar</SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    const sidebarRoot = screen.getByText('Right sidebar').closest('[data-side]');
+    expect(sidebarRoot?.getAttribute('data-side')).toBe('right');
+  });
+
+  it('Sidebar renders with collapsible=none', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar collapsible="none">
+          <SidebarContent>Non-collapsible</SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByText('Non-collapsible')).toBeTruthy();
+  });
+
+  it('SidebarMenuButton renders with tooltip string', () => {
+    render(
+      <SidebarProvider>
+        <Sidebar>
+          <SidebarContent>
+            <SidebarMenu>
+              <SidebarMenuItem>
+                <SidebarMenuButton tooltip="Menu tooltip">Item with tooltip</SidebarMenuButton>
+              </SidebarMenuItem>
+            </SidebarMenu>
+          </SidebarContent>
+        </Sidebar>
+      </SidebarProvider>
+    );
+    expect(screen.getByText('Item with tooltip')).toBeTruthy();
+  });
+});
diff --git a/src/components/ui/slider.test.tsx b/src/components/ui/slider.test.tsx
new file mode 100644
index 00000000..3663fe15
--- /dev/null
+++ b/src/components/ui/slider.test.tsx
@@ -0,0 +1,60 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-slider', () => {
+  const Root = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} role="slider" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Root.displayName = 'SliderRoot';
+
+  const Track = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="track" {...props} />
+  );
+  Track.displayName = 'SliderTrack';
+
+  const Range = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="range" {...props} />
+  );
+  Range.displayName = 'SliderRange';
+
+  const Thumb = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="thumb" {...props} />
+  );
+  Thumb.displayName = 'SliderThumb';
+
+  return { Root, Track, Range, Thumb };
+});
+
+import { Slider } from './slider';
+
+describe('Slider', () => {
+  it('renders without crashing', () => {
+    render(<Slider data-testid="slider" />);
+    expect(screen.getByTestId('slider')).toBeTruthy();
+  });
+
+  it('renders track', () => {
+    render(<Slider />);
+    expect(screen.getByTestId('track')).toBeTruthy();
+  });
+
+  it('renders range', () => {
+    render(<Slider />);
+    expect(screen.getByTestId('range')).toBeTruthy();
+  });
+
+  it('renders thumb', () => {
+    render(<Slider />);
+    expect(screen.getByTestId('thumb')).toBeTruthy();
+  });
+
+  it('passes custom className', () => {
+    render(<Slider className="my-slider" data-testid="slider" />);
+    expect(screen.getByTestId('slider').className).toContain('my-slider');
+  });
+});
diff --git a/src/components/ui/switch.test.tsx b/src/components/ui/switch.test.tsx
new file mode 100644
index 00000000..7a28616b
--- /dev/null
+++ b/src/components/ui/switch.test.tsx
@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-switch', () => {
+  const Root = React.forwardRef<
+    HTMLButtonElement,
+    React.ComponentPropsWithoutRef<'button'> & {
+      checked?: boolean;
+      onCheckedChange?: (checked: boolean) => void;
+    }
+  >(({ children, checked: initialChecked, onCheckedChange, ...props }, ref) => {
+    const [checked, setChecked] = React.useState(initialChecked ?? false);
+    return (
+      <button
+        ref={ref}
+        role="switch"
+        aria-checked={checked}
+        data-state={checked ? 'checked' : 'unchecked'}
+        onClick={() => {
+          const next = !checked;
+          setChecked(next);
+          onCheckedChange?.(next);
+        }}
+        {...props}
+      >
+        {children}
+      </button>
+    );
+  });
+  Root.displayName = 'SwitchRoot';
+
+  const Thumb = React.forwardRef<HTMLSpanElement, React.HTMLAttributes<HTMLSpanElement>>(
+    ({ ...props }, ref) => <span ref={ref} data-testid="switch-thumb" {...props} />
+  );
+  Thumb.displayName = 'SwitchThumb';
+
+  return { Root, Thumb };
+});
+
+import { Switch } from './switch';
+
+describe('Switch', () => {
+  it('renders without crashing', () => {
+    render(<Switch data-testid="sw" />);
+    expect(screen.getByTestId('sw')).toBeTruthy();
+  });
+
+  it('has switch role', () => {
+    render(<Switch data-testid="sw" />);
+    expect(screen.getByRole('switch')).toBeTruthy();
+  });
+
+  it('toggles on click', () => {
+    render(<Switch data-testid="sw" />);
+    const sw = screen.getByTestId('sw');
+    expect(sw.getAttribute('data-state')).toBe('unchecked');
+
+    fireEvent.click(sw);
+    expect(sw.getAttribute('data-state')).toBe('checked');
+  });
+
+  it('renders thumb', () => {
+    render(<Switch />);
+    expect(screen.getByTestId('switch-thumb')).toBeTruthy();
+  });
+
+  it('passes custom className', () => {
+    render(<Switch className="custom-switch" data-testid="sw" />);
+    expect(screen.getByTestId('sw').className).toContain('custom-switch');
+  });
+});
diff --git a/src/components/ui/table.test.tsx b/src/components/ui/table.test.tsx
new file mode 100644
index 00000000..a3059f6f
--- /dev/null
+++ b/src/components/ui/table.test.tsx
@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+
+import {
+  Table,
+  TableHeader,
+  TableBody,
+  TableFooter,
+  TableHead,
+  TableRow,
+  TableCell,
+  TableCaption,
+} from './table';
+
+describe('Table components', () => {
+  it('Table renders a <table> inside a wrapper div', () => {
+    const { container } = render(
+      <Table data-testid="table">
+        <tbody />
+      </Table>
+    );
+    expect(container.querySelector('table')).toBeTruthy();
+  });
+
+  it('TableHeader renders <thead>', () => {
+    render(
+      <Table>
+        <TableHeader data-testid="thead">
+          <tr />
+        </TableHeader>
+      </Table>
+    );
+    expect(screen.getByTestId('thead').tagName).toBe('THEAD');
+  });
+
+  it('TableBody renders <tbody>', () => {
+    render(
+      <Table>
+        <TableBody data-testid="tbody">
+          <tr />
+        </TableBody>
+      </Table>
+    );
+    expect(screen.getByTestId('tbody').tagName).toBe('TBODY');
+  });
+
+  it('TableFooter renders <tfoot>', () => {
+    render(
+      <Table>
+        <TableFooter data-testid="tfoot">
+          <tr />
+        </TableFooter>
+      </Table>
+    );
+    expect(screen.getByTestId('tfoot').tagName).toBe('TFOOT');
+  });
+
+  it('TableHead renders <th>', () => {
+    render(
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead data-testid="th">Name</TableHead>
+          </TableRow>
+        </TableHeader>
+      </Table>
+    );
+    expect(screen.getByTestId('th').tagName).toBe('TH');
+    expect(screen.getByText('Name')).toBeTruthy();
+  });
+
+  it('TableRow renders <tr>', () => {
+    render(
+      <Table>
+        <TableBody>
+          <TableRow data-testid="tr" />
+        </TableBody>
+      </Table>
+    );
+    expect(screen.getByTestId('tr').tagName).toBe('TR');
+  });
+
+  it('TableCell renders <td>', () => {
+    render(
+      <Table>
+        <TableBody>
+          <TableRow>
+            <TableCell data-testid="td">Cell</TableCell>
+          </TableRow>
+        </TableBody>
+      </Table>
+    );
+    expect(screen.getByTestId('td').tagName).toBe('TD');
+    expect(screen.getByText('Cell')).toBeTruthy();
+  });
+
+  it('TableCaption renders <caption>', () => {
+    render(
+      <Table>
+        <TableCaption data-testid="caption">Table info</TableCaption>
+      </Table>
+    );
+    expect(screen.getByTestId('caption').tagName).toBe('CAPTION');
+    expect(screen.getByText('Table info')).toBeTruthy();
+  });
+
+  it('Table passes custom className', () => {
+    const { container } = render(
+      <Table className="custom-table">
+        <tbody />
+      </Table>
+    );
+    expect(container.querySelector('table')!.className).toContain('custom-table');
+  });
+});
diff --git a/src/components/ui/tabs.test.tsx b/src/components/ui/tabs.test.tsx
new file mode 100644
index 00000000..49cc8c70
--- /dev/null
+++ b/src/components/ui/tabs.test.tsx
@@ -0,0 +1,106 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-tabs', () => {
+  const Root = ({ children, ...props }: React.ComponentPropsWithoutRef<'div'>) => (
+    <div data-testid="tabs-root" {...props}>
+      {children}
+    </div>
+  );
+  Root.displayName = 'Tabs';
+
+  const List = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} role="tablist" {...props}>
+        {children}
+      </div>
+    )
+  );
+  List.displayName = 'TabsList';
+
+  const Trigger = React.forwardRef<HTMLButtonElement, React.ComponentPropsWithoutRef<'button'>>(
+    ({ children, ...props }, ref) => (
+      <button ref={ref} role="tab" {...props}>
+        {children}
+      </button>
+    )
+  );
+  Trigger.displayName = 'TabsTrigger';
+
+  const Content = React.forwardRef<HTMLDivElement, React.ComponentPropsWithoutRef<'div'>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} role="tabpanel" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Content.displayName = 'TabsContent';
+
+  return { Root, List, Trigger, Content };
+});
+
+import { Tabs, TabsList, TabsTrigger, TabsContent } from './tabs';
+
+describe('Tabs components', () => {
+  it('Tabs renders children', () => {
+    render(
+      <Tabs defaultValue="tab1">
+        <TabsList>
+          <TabsTrigger value="tab1">Tab 1</TabsTrigger>
+        </TabsList>
+        <TabsContent value="tab1">Content 1</TabsContent>
+      </Tabs>
+    );
+    expect(screen.getByTestId('tabs-root')).toBeTruthy();
+  });
+
+  it('TabsList renders with role tablist', () => {
+    render(
+      <Tabs defaultValue="a">
+        <TabsList data-testid="list">
+          <TabsTrigger value="a">A</TabsTrigger>
+        </TabsList>
+      </Tabs>
+    );
+    expect(screen.getByTestId('list').getAttribute('role')).toBe('tablist');
+  });
+
+  it('TabsTrigger renders as tab button', () => {
+    render(
+      <Tabs defaultValue="x">
+        <TabsList>
+          <TabsTrigger value="x" data-testid="trigger">
+            My Tab
+          </TabsTrigger>
+        </TabsList>
+      </Tabs>
+    );
+    expect(screen.getByTestId('trigger').getAttribute('role')).toBe('tab');
+    expect(screen.getByText('My Tab')).toBeTruthy();
+  });
+
+  it('TabsContent renders panel', () => {
+    render(
+      <Tabs defaultValue="y">
+        <TabsList>
+          <TabsTrigger value="y">Y</TabsTrigger>
+        </TabsList>
+        <TabsContent value="y" data-testid="panel">
+          Panel Content
+        </TabsContent>
+      </Tabs>
+    );
+    expect(screen.getByTestId('panel').getAttribute('role')).toBe('tabpanel');
+    expect(screen.getByText('Panel Content')).toBeTruthy();
+  });
+
+  it('Tabs passes className', () => {
+    render(
+      <Tabs defaultValue="z" className="tabs-custom">
+        <div />
+      </Tabs>
+    );
+    expect(screen.getByTestId('tabs-root').className).toContain('tabs-custom');
+  });
+});
diff --git a/src/components/ui/textarea.test.tsx b/src/components/ui/textarea.test.tsx
new file mode 100644
index 00000000..c3865d64
--- /dev/null
+++ b/src/components/ui/textarea.test.tsx
@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+
+import { Textarea } from './textarea';
+
+describe('Textarea', () => {
+  it('renders textarea element', () => {
+    render(<Textarea data-testid="textarea" />);
+    expect(screen.getByTestId('textarea').tagName).toBe('TEXTAREA');
+  });
+
+  it('passes placeholder', () => {
+    render(<Textarea placeholder="Type here" data-testid="textarea" />);
+    expect(screen.getByPlaceholderText('Type here')).toBeTruthy();
+  });
+
+  it('passes value and onChange', () => {
+    render(<Textarea data-testid="textarea" />);
+    const ta = screen.getByTestId('textarea');
+    fireEvent.change(ta, { target: { value: 'hello' } });
+    expect((ta as HTMLTextAreaElement).value).toBe('hello');
+  });
+
+  it('passes custom className', () => {
+    render(<Textarea className="my-ta" data-testid="textarea" />);
+    expect(screen.getByTestId('textarea').className).toContain('my-ta');
+  });
+
+  it('can be disabled', () => {
+    render(<Textarea disabled data-testid="textarea" />);
+    expect(screen.getByTestId('textarea')).toBeDisabled();
+  });
+
+  it('passes rows attribute', () => {
+    render(<Textarea rows={5} data-testid="textarea" />);
+    expect(screen.getByTestId('textarea').getAttribute('rows')).toBe('5');
+  });
+});
diff --git a/src/components/ui/toast.test.tsx b/src/components/ui/toast.test.tsx
new file mode 100644
index 00000000..ec63bdaa
--- /dev/null
+++ b/src/components/ui/toast.test.tsx
@@ -0,0 +1,123 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@radix-ui/react-toast', () => {
+  const Provider = ({ children }: { children: React.ReactNode }) => (
+    <div data-testid="toast-provider">{children}</div>
+  );
+  Provider.displayName = 'ToastProvider';
+
+  const Viewport = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ ...props }, ref) => <div ref={ref} data-testid="toast-viewport" {...props} />
+  );
+  Viewport.displayName = 'ToastViewport';
+
+  const Root = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} role="status" {...props}>
+        {children}
+      </div>
+    )
+  );
+  Root.displayName = 'Toast';
+
+  const Title = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} {...props}>
+        {children}
+      </div>
+    )
+  );
+  Title.displayName = 'ToastTitle';
+
+  const Description = React.forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>(
+    ({ children, ...props }, ref) => (
+      <div ref={ref} {...props}>
+        {children}
+      </div>
+    )
+  );
+  Description.displayName = 'ToastDescription';
+
+  const Close = React.forwardRef<HTMLButtonElement, React.HTMLAttributes<HTMLButtonElement>>(
+    ({ children, ...props }, ref) => (
+      <button ref={ref} {...props}>
+        {children ?? '×'}
+      </button>
+    )
+  );
+  Close.displayName = 'ToastClose';
+
+  const Action = React.forwardRef<HTMLButtonElement, React.HTMLAttributes<HTMLButtonElement>>(
+    ({ children, ...props }, ref) => (
+      <button ref={ref} {...props}>
+        {children}
+      </button>
+    )
+  );
+  Action.displayName = 'ToastAction';
+
+  return { Provider, Viewport, Root, Title, Description, Close, Action };
+});
+
+import {
+  ToastProvider,
+  ToastViewport,
+  Toast,
+  ToastTitle,
+  ToastDescription,
+  ToastClose,
+  ToastAction,
+} from './toast';
+
+describe('Toast components', () => {
+  it('ToastProvider renders children', () => {
+    render(
+      <ToastProvider>
+        <div>child</div>
+      </ToastProvider>
+    );
+    expect(screen.getByText('child')).toBeTruthy();
+  });
+
+  it('ToastViewport renders', () => {
+    const { container } = render(<ToastViewport />);
+    expect(container.querySelector('[data-testid="toast-viewport"]')).toBeTruthy();
+  });
+
+  it('Toast renders with default variant', () => {
+    render(<Toast data-testid="my-toast">Hello</Toast>);
+    expect(screen.getByTestId('my-toast')).toBeTruthy();
+    expect(screen.getByText('Hello')).toBeTruthy();
+  });
+
+  it('ToastTitle renders text', () => {
+    render(<ToastTitle>Title Text</ToastTitle>);
+    expect(screen.getByText('Title Text')).toBeTruthy();
+  });
+
+  it('ToastDescription renders text', () => {
+    render(<ToastDescription>Description Text</ToastDescription>);
+    expect(screen.getByText('Description Text')).toBeTruthy();
+  });
+
+  it('ToastClose renders', () => {
+    render(<ToastClose data-testid="close-btn" />);
+    expect(screen.getByTestId('close-btn')).toBeTruthy();
+  });
+
+  it('ToastAction renders with children', () => {
+    render(<ToastAction altText="Undo action">Undo</ToastAction>);
+    expect(screen.getByText('Undo')).toBeTruthy();
+  });
+
+  it('Toast passes custom className', () => {
+    render(
+      <Toast className="custom-toast" data-testid="t">
+        Hi
+      </Toast>
+    );
+    expect(screen.getByTestId('t').className).toContain('custom-toast');
+  });
+});
diff --git a/src/components/ui/toaster.test.tsx b/src/components/ui/toaster.test.tsx
new file mode 100644
index 00000000..a3fcd5d2
--- /dev/null
+++ b/src/components/ui/toaster.test.tsx
@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import * as React from 'react';
+
+vi.mock('@/hooks/use-toast', () => ({
+  useToast: vi.fn(() => ({
+    toasts: [
+      {
+        id: '1',
+        title: 'Success',
+        description: 'Saved!',
+        open: true,
+        onOpenChange: vi.fn(),
+      },
+      {
+        id: '2',
+        title: 'Error',
+        open: true,
+        onOpenChange: vi.fn(),
+      },
+      {
+        id: '3',
+        open: true,
+        onOpenChange: vi.fn(),
+      },
+    ],
+  })),
+}));
+
+vi.mock('@/components/ui/toast', () => {
+  return {
+    ToastProvider: ({ children }: { children: React.ReactNode }) => (
+      <div data-testid="toast-provider">{children}</div>
+    ),
+    ToastViewport: () => <div data-testid="toast-viewport" />,
+    Toast: ({ children, ...props }: React.ComponentPropsWithRef<'div'>) => (
+      <div data-testid="toast" {...props}>
+        {children}
+      </div>
+    ),
+    ToastTitle: ({ children }: { children: React.ReactNode }) => (
+      <div data-testid="toast-title">{children}</div>
+    ),
+    ToastDescription: ({ children }: { children: React.ReactNode }) => (
+      <div data-testid="toast-desc">{children}</div>
+    ),
+    ToastClose: () => <button data-testid="toast-close">Close</button>,
+  };
+});
+
+import { Toaster } from './toaster';
+
+describe('Toaster', () => {
+  it('renders provider and viewport', () => {
+    render(<Toaster />);
+    expect(screen.getByTestId('toast-provider')).toBeTruthy();
+    expect(screen.getByTestId('toast-viewport')).toBeTruthy();
+  });
+
+  it('renders toast for each item in toasts array', () => {
+    render(<Toaster />);
+    const toasts = screen.getAllByTestId('toast');
+    expect(toasts).toHaveLength(3);
+  });
+
+  it('renders title when provided', () => {
+    render(<Toaster />);
+    const titles = screen.getAllByTestId('toast-title');
+    expect(titles.length).toBeGreaterThanOrEqual(1);
+    expect(screen.getByText('Success')).toBeTruthy();
+    expect(screen.getByText('Error')).toBeTruthy();
+  });
+
+  it('renders description when provided', () => {
+    render(<Toaster />);
+    expect(screen.getByText('Saved!')).toBeTruthy();
+  });
+
+  it('renders close button on each toast', () => {
+    render(<Toaster />);
+    const closeButtons = screen.getAllByTestId('toast-close');
+    expect(closeButtons).toHaveLength(3);
+  });
+});
diff --git a/src/hooks/use-app-notification.test.ts b/src/hooks/use-app-notification.test.ts
new file mode 100644
index 00000000..cd5c8909
--- /dev/null
+++ b/src/hooks/use-app-notification.test.ts
@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useAppNotification } from './use-app-notification';
+
+const mockToast = vi.fn();
+vi.mock('@/hooks/use-toast', () => ({
+  useToast: () => ({
+    toast: mockToast,
+    toasts: [],
+    dismiss: vi.fn(),
+  }),
+}));
+
+vi.mock('@/lib/logger', () => ({
+  Logger: {
+    error: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+import { Logger } from '@/lib/logger';
+
+describe('useAppNotification', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should return success, error, and warn functions', () => {
+    const { result } = renderHook(() => useAppNotification());
+    expect(typeof result.current.success).toBe('function');
+    expect(typeof result.current.error).toBe('function');
+    expect(typeof result.current.warn).toBe('function');
+  });
+
+  describe('success', () => {
+    it('should call toast with title and variant default', () => {
+      const { result } = renderHook(() => useAppNotification());
+
+      act(() => result.current.success('Operation successful', 'Details here'));
+
+      expect(mockToast).toHaveBeenCalledWith({
+        title: 'Operation successful',
+        description: 'Details here',
+        variant: 'default',
+      });
+    });
+
+    it('should call toast with only title when no description', () => {
+      const { result } = renderHook(() => useAppNotification());
+
+      act(() => result.current.success('Done'));
+
+      expect(mockToast).toHaveBeenCalledWith({
+        title: 'Done',
+        description: undefined,
+        variant: 'default',
+      });
+    });
+  });
+
+  describe('error', () => {
+    it('should call toast with variant destructive', () => {
+      const { result } = renderHook(() => useAppNotification());
+
+      act(() => result.current.error('Something broke', 'Network error'));
+
+      expect(mockToast).toHaveBeenCalledWith({
+        title: 'Something broke',
+        description: 'Network error',
+        variant: 'destructive',
+      });
+    });
+
+    it('should use default description when none provided', () => {
+      const { result } = renderHook(() => useAppNotification());
+
+      act(() => result.current.error('Error'));
+
+      expect(mockToast).toHaveBeenCalledWith({
+        title: 'Error',
+        description: 'Ocorreu um erro inesperado.',
+        variant: 'destructive',
+      });
+    });
+
+    it('should log original error when provided', () => {
+      const { result } = renderHook(() => useAppNotification());
+      const originalError = new Error('network timeout');
+
+      act(() => result.current.error('Fail', 'Desc', originalError));
+
+      expect(Logger.error).toHaveBeenCalledWith('[Notification] Fail: Desc', originalError);
+    });
+
+    it('should not log when originalError is not provided', () => {
+      const { result } = renderHook(() => useAppNotification());
+
+      act(() => result.current.error('Fail'));
+
+      expect(Logger.error).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('warn', () => {
+    it('should behave the same as success (alias)', () => {
+      const { result } = renderHook(() => useAppNotification());
+
+      act(() => result.current.warn('Warning message', 'Warning details'));
+
+      expect(mockToast).toHaveBeenCalledWith({
+        title: 'Warning message',
+        description: 'Warning details',
+        variant: 'default',
+      });
+    });
+  });
+});
diff --git a/src/hooks/use-mobile.test.tsx b/src/hooks/use-mobile.test.tsx
new file mode 100644
index 00000000..f6b0a982
--- /dev/null
+++ b/src/hooks/use-mobile.test.tsx
@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+
+const listeners: Array<() => void> = [];
+const mockMatchMedia = vi.fn(() => ({
+  matches: false,
+  addEventListener: vi.fn((_event: string, cb: () => void) => {
+    listeners.push(cb);
+  }),
+  removeEventListener: vi.fn((_event: string, cb: () => void) => {
+    const idx = listeners.indexOf(cb);
+    if (idx >= 0) listeners.splice(idx, 1);
+  }),
+  addListener: vi.fn(),
+  removeListener: vi.fn(),
+  dispatchEvent: vi.fn(),
+  media: '',
+  onchange: null,
+}));
+
+import { useIsMobile } from './use-mobile';
+
+describe('useIsMobile', () => {
+  beforeEach(() => {
+    listeners.length = 0;
+    Object.defineProperty(window, 'innerWidth', {
+      value: 1024,
+      writable: true,
+      configurable: true,
+    });
+    Object.defineProperty(globalThis, 'innerWidth', {
+      value: 1024,
+      writable: true,
+      configurable: true,
+    });
+    globalThis.matchMedia = mockMatchMedia as unknown as typeof globalThis.matchMedia;
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    listeners.length = 0;
+  });
+
+  it('returns false when viewport > 768', () => {
+    Object.defineProperty(globalThis, 'innerWidth', {
+      value: 1024,
+      writable: true,
+      configurable: true,
+    });
+    const { result } = renderHook(() => useIsMobile());
+    expect(result.current).toBe(false);
+  });
+
+  it('returns true when viewport < 768', () => {
+    Object.defineProperty(globalThis, 'innerWidth', {
+      value: 500,
+      writable: true,
+      configurable: true,
+    });
+    const { result } = renderHook(() => useIsMobile());
+    expect(result.current).toBe(true);
+  });
+
+  it('calls matchMedia with correct breakpoint', () => {
+    renderHook(() => useIsMobile());
+    expect(mockMatchMedia).toHaveBeenCalledWith('(max-width: 767px)');
+  });
+
+  it('updates on media query change', () => {
+    Object.defineProperty(globalThis, 'innerWidth', {
+      value: 1024,
+      writable: true,
+      configurable: true,
+    });
+    const { result } = renderHook(() => useIsMobile());
+    expect(result.current).toBe(false);
+
+    act(() => {
+      Object.defineProperty(globalThis, 'innerWidth', {
+        value: 400,
+        writable: true,
+        configurable: true,
+      });
+      listeners.forEach((cb) => cb());
+    });
+
+    expect(result.current).toBe(true);
+  });
+
+  it('initializes as undefined (false via !!)', () => {
+    const { result } = renderHook(() => useIsMobile());
+    expect(typeof result.current).toBe('boolean');
+  });
+});
diff --git a/src/hooks/use-toast.test.tsx b/src/hooks/use-toast.test.tsx
new file mode 100644
index 00000000..72ae0490
--- /dev/null
+++ b/src/hooks/use-toast.test.tsx
@@ -0,0 +1,200 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useToast, toast } from './use-toast';
+
+vi.mock('@/components/ui/toast', () => ({
+  ToastProvider: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+  ToastViewport: () => null,
+  Toast: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+  ToastTitle: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+  ToastDescription: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
+  ToastClose: () => null,
+  ToastAction: ({ children }: { children: React.ReactNode }) => <button>{children}</button>,
+}));
+
+describe('useToast', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('should return empty toasts initially', () => {
+    const { result } = renderHook(() => useToast());
+    expect(result.current.toasts).toEqual([]);
+  });
+
+  it('should have toast function', () => {
+    const { result } = renderHook(() => useToast());
+    expect(typeof result.current.toast).toBe('function');
+  });
+
+  it('should have dismiss function', () => {
+    const { result } = renderHook(() => useToast());
+    expect(typeof result.current.dismiss).toBe('function');
+  });
+
+  describe('toast function', () => {
+    it('should add a toast when called', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        result.current.toast({ title: 'Test Toast' });
+      });
+
+      expect(result.current.toasts).toHaveLength(1);
+      expect(result.current.toasts[0].title).toBe('Test Toast');
+      expect(result.current.toasts[0].open).toBe(true);
+    });
+
+    it('should return an object with id, dismiss, and update', () => {
+      let toastReturn: {
+        id: string;
+        dismiss: () => void;
+        update: (props: { id: string; [key: string]: unknown }) => void;
+      };
+
+      act(() => {
+        toastReturn = toast({ title: 'Return Test' }) as typeof toastReturn;
+      });
+
+      expect(toastReturn!.id).toBeDefined();
+      expect(typeof toastReturn!.dismiss).toBe('function');
+      expect(typeof toastReturn!.update).toBe('function');
+    });
+
+    it('should respect TOAST_LIMIT of 1', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        result.current.toast({ title: 'First Toast' });
+        result.current.toast({ title: 'Second Toast' });
+      });
+
+      expect(result.current.toasts).toHaveLength(1);
+      expect(result.current.toasts[0].title).toBe('Second Toast');
+    });
+
+    it('should set open to true by default', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        result.current.toast({ title: 'Open Toast' });
+      });
+
+      expect(result.current.toasts[0].open).toBe(true);
+    });
+
+    it('should set variant when provided', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        result.current.toast({ title: 'Destructive', variant: 'destructive' });
+      });
+
+      expect(result.current.toasts[0].variant).toBe('destructive');
+    });
+  });
+
+  describe('update', () => {
+    it('should update an existing toast', () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastReturn: ReturnType<typeof toast>;
+      act(() => {
+        toastReturn = result.current.toast({ title: 'Original' });
+      });
+
+      act(() => {
+        toastReturn!.update({ id: toastReturn!.id, title: 'Updated' });
+      });
+
+      expect(result.current.toasts[0].title).toBe('Updated');
+    });
+  });
+
+  describe('dismiss', () => {
+    it('should set open to false when dismissing a specific toast', () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastReturn: ReturnType<typeof toast>;
+      act(() => {
+        toastReturn = result.current.toast({ title: 'Dismiss Me' });
+      });
+
+      act(() => {
+        result.current.dismiss(toastReturn!.id);
+      });
+
+      expect(result.current.toasts[0].open).toBe(false);
+    });
+
+    it('should dismiss all toasts when no id is provided', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        result.current.toast({ title: 'Toast 1' });
+      });
+
+      act(() => {
+        result.current.dismiss();
+      });
+
+      expect(result.current.toasts.every((t) => t.open === false)).toBe(true);
+    });
+  });
+
+  describe('toast().dismiss()', () => {
+    it('should dismiss via returned dismiss function', () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastReturn: ReturnType<typeof toast>;
+      act(() => {
+        toastReturn = result.current.toast({ title: 'Auto Dismiss' });
+      });
+
+      act(() => {
+        toastReturn!.dismiss();
+      });
+
+      expect(result.current.toasts[0].open).toBe(false);
+    });
+  });
+
+  describe('REMOVE_TOAST', () => {
+    it('should remove a specific toast', () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastReturn: ReturnType<typeof toast>;
+      act(() => {
+        toastReturn = result.current.toast({ title: 'Remove Me' });
+      });
+
+      act(() => {
+        result.current.dismiss(toastReturn!.id);
+        vi.advanceTimersByTime(1_000_001);
+      });
+
+      expect(result.current.toasts).toHaveLength(0);
+    });
+  });
+
+  describe('onOpenChange', () => {
+    it('should dismiss toast when onOpenChange is called with false', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        result.current.toast({ title: 'Close Test' });
+      });
+
+      const currentToast = result.current.toasts[0];
+      act(() => {
+        currentToast.onOpenChange?.(false);
+      });
+
+      expect(result.current.toasts[0].open).toBe(false);
+    });
+  });
+});
diff --git a/src/hooks/use-workout-crud.test.ts b/src/hooks/use-workout-crud.test.ts
new file mode 100644
index 00000000..580dc59d
--- /dev/null
+++ b/src/hooks/use-workout-crud.test.ts
@@ -0,0 +1,308 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useWorkoutCRUD } from './use-workout-crud';
+import type { Treino } from '@/lib/definitions';
+import type { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
+
+vi.mock('@/lib/actions/treinos', () => ({
+  upsertTreinoAction: vi.fn(),
+  updateTreinoDayAction: vi.fn(),
+  deleteTreinoAction: vi.fn(),
+}));
+
+Object.defineProperty(globalThis, 'scrollTo', { value: vi.fn(), writable: true });
+
+import {
+  upsertTreinoAction,
+  updateTreinoDayAction,
+  deleteTreinoAction,
+} from '@/lib/actions/treinos';
+
+const mockRouter = {
+  push: vi.fn(),
+  replace: vi.fn(),
+  refresh: vi.fn(),
+  back: vi.fn(),
+  forward: vi.fn(),
+  prefetch: vi.fn(),
+} as unknown as AppRouterInstance;
+
+const mockNotify = {
+  success: vi.fn(),
+  error: vi.fn(),
+};
+
+const createMockTreino = (id: string, diaSemana: number | null = null): Treino => ({
+  id,
+  alunoId: 'aluno-1',
+  objetivo: 'Hipertrofia',
+  diaSemana,
+  instrutorId: null,
+  exercicios: [],
+});
+
+const defaultOptions = () => ({
+  initialTreinos: [createMockTreino('t-1', 1), createMockTreino('t-2', 3)],
+  userId: 'user-1',
+  router: mockRouter,
+  notify: mockNotify,
+});
+
+describe('useWorkoutCRUD', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('initial state', () => {
+    it('should initialize with provided treinos', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      expect(result.current.meusTreinos).toHaveLength(2);
+    });
+
+    it('should have form hidden by default', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      expect(result.current.isFormVisible).toBe(false);
+    });
+
+    it('should have no editing treino initially', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      expect(result.current.editingTreino).toBeNull();
+    });
+
+    it('should have alert closed initially', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      expect(result.current.isAlertOpen).toBe(false);
+    });
+
+    it('should have no deleting treino initially', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      expect(result.current.deletingTreino).toBeNull();
+    });
+  });
+
+  describe('handleSave - create new', () => {
+    it('should call upsertTreinoAction and refresh router on success', async () => {
+      vi.mocked(upsertTreinoAction).mockResolvedValue({ success: true });
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      const treinoData = {
+        objetivo: 'Força',
+        diaSemana: 2,
+        exercicios: [],
+      };
+
+      await act(async () => {
+        await result.current.handleSave(treinoData);
+      });
+
+      expect(upsertTreinoAction).toHaveBeenCalledWith({
+        ...treinoData,
+        alunoId: 'user-1',
+      });
+      expect(mockRouter.refresh).toHaveBeenCalled();
+      expect(mockNotify.success).toHaveBeenCalledWith('Novo treino salvo!');
+      expect(result.current.isFormVisible).toBe(false);
+    });
+
+    it('should notify error when action returns failure', async () => {
+      vi.mocked(upsertTreinoAction).mockResolvedValue({ success: false, error: 'DB error' });
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      await act(async () => {
+        await result.current.handleSave({
+          objetivo: 'Força',
+          diaSemana: null,
+          exercicios: [],
+        });
+      });
+
+      expect(mockNotify.error).toHaveBeenCalledWith('Erro ao salvar', undefined, expect.any(Error));
+    });
+  });
+
+  describe('handleSave - update existing', () => {
+    it('should include editing treino id and not call router.refresh', async () => {
+      vi.mocked(upsertTreinoAction).mockResolvedValue({ success: true });
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      act(() => result.current.handleEdit(createMockTreino('t-1', 1)));
+
+      await act(async () => {
+        await result.current.handleSave({
+          objetivo: 'Updated',
+          diaSemana: 1,
+          exercicios: [],
+        });
+      });
+
+      expect(upsertTreinoAction).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 't-1', alunoId: 'user-1' })
+      );
+      expect(mockRouter.refresh).not.toHaveBeenCalled();
+      expect(mockNotify.success).toHaveBeenCalledWith('Treino atualizado!');
+    });
+  });
+
+  describe('handleEdit', () => {
+    it('should set editingTreino and show form', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      const treino = createMockTreino('t-1');
+
+      act(() => result.current.handleEdit(treino));
+
+      expect(result.current.editingTreino).toEqual(treino);
+      expect(result.current.isFormVisible).toBe(true);
+    });
+
+    it('should scroll to top', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      act(() => result.current.handleEdit(createMockTreino('t-1')));
+
+      expect(window.scrollTo).toHaveBeenCalledWith({ top: 0, behavior: 'smooth' });
+    });
+  });
+
+  describe('handleDayChange', () => {
+    it('should update day and notify success', async () => {
+      vi.mocked(updateTreinoDayAction).mockResolvedValue({ success: true });
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      await act(async () => {
+        await result.current.handleDayChange('t-1', '2');
+      });
+
+      expect(updateTreinoDayAction).toHaveBeenCalledWith('t-1', 2);
+      expect(mockNotify.success).toHaveBeenCalledWith('Agenda atualizada!');
+      expect(result.current.meusTreinos.find((t) => t.id === 't-1')?.diaSemana).toBe(2);
+    });
+
+    it('should set diaSemana to null when selecting "nenhum"', async () => {
+      vi.mocked(updateTreinoDayAction).mockResolvedValue({ success: true });
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      await act(async () => {
+        await result.current.handleDayChange('t-1', 'nenhum');
+      });
+
+      expect(updateTreinoDayAction).toHaveBeenCalledWith('t-1', null);
+      expect(result.current.meusTreinos.find((t) => t.id === 't-1')?.diaSemana).toBeNull();
+    });
+
+    it('should notify error when day is already occupied', async () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      await act(async () => {
+        await result.current.handleDayChange('t-2', '1');
+      });
+
+      expect(mockNotify.error).toHaveBeenCalledWith(
+        'Dia já ocupado',
+        'Já existe outro treino agendado para este dia.'
+      );
+      expect(updateTreinoDayAction).not.toHaveBeenCalled();
+    });
+
+    it('should notify error on action failure', async () => {
+      vi.mocked(updateTreinoDayAction).mockRejectedValue(new Error('Network'));
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      await act(async () => {
+        await result.current.handleDayChange('t-1', '2');
+      });
+
+      expect(mockNotify.error).toHaveBeenCalledWith(
+        'Erro ao atualizar agenda',
+        undefined,
+        expect.any(Error)
+      );
+    });
+  });
+
+  describe('openDeleteAlert', () => {
+    it('should set deletingTreino and open alert', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      const treino = createMockTreino('t-1');
+
+      act(() => result.current.openDeleteAlert(treino));
+
+      expect(result.current.deletingTreino).toEqual(treino);
+      expect(result.current.isAlertOpen).toBe(true);
+    });
+  });
+
+  describe('handleDelete', () => {
+    it('should delete treino and notify success', async () => {
+      vi.mocked(deleteTreinoAction).mockResolvedValue({ success: true });
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      act(() => result.current.openDeleteAlert(createMockTreino('t-1')));
+
+      await act(async () => {
+        await result.current.handleDelete();
+      });
+
+      expect(deleteTreinoAction).toHaveBeenCalledWith('t-1');
+      expect(mockNotify.success).toHaveBeenCalledWith('Treino excluído!');
+      expect(result.current.meusTreinos).toHaveLength(1);
+      expect(result.current.meusTreinos.find((t) => t.id === 't-1')).toBeUndefined();
+      expect(result.current.isAlertOpen).toBe(false);
+      expect(result.current.deletingTreino).toBeNull();
+    });
+
+    it('should do nothing when no deletingTreino', async () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      await act(async () => {
+        await result.current.handleDelete();
+      });
+
+      expect(deleteTreinoAction).not.toHaveBeenCalled();
+    });
+
+    it('should notify error on action failure', async () => {
+      vi.mocked(deleteTreinoAction).mockRejectedValue(new Error('DB'));
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+
+      act(() => result.current.openDeleteAlert(createMockTreino('t-1')));
+
+      await act(async () => {
+        await result.current.handleDelete();
+      });
+
+      expect(mockNotify.error).toHaveBeenCalledWith(
+        'Erro ao excluir',
+        undefined,
+        expect.any(Error)
+      );
+      expect(result.current.isAlertOpen).toBe(false);
+    });
+  });
+
+  describe('setters', () => {
+    it('should set isFormVisible via setIsFormVisible', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      act(() => result.current.setIsFormVisible(true));
+      expect(result.current.isFormVisible).toBe(true);
+    });
+
+    it('should set editingTreino via setEditingTreino', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      const treino = createMockTreino('t-1');
+      act(() => result.current.setEditingTreino(treino));
+      expect(result.current.editingTreino).toEqual(treino);
+    });
+
+    it('should set isAlertOpen via setIsAlertOpen', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      act(() => result.current.setIsAlertOpen(true));
+      expect(result.current.isAlertOpen).toBe(true);
+    });
+
+    it('should set deletingTreino via setDeletingTreino', () => {
+      const { result } = renderHook(() => useWorkoutCRUD(defaultOptions()));
+      const treino = createMockTreino('t-1');
+      act(() => result.current.setDeletingTreino(treino));
+      expect(result.current.deletingTreino).toEqual(treino);
+    });
+  });
+});
diff --git a/src/hooks/use-workout-exercises.test.ts b/src/hooks/use-workout-exercises.test.ts
new file mode 100644
index 00000000..96a0485c
--- /dev/null
+++ b/src/hooks/use-workout-exercises.test.ts
@@ -0,0 +1,204 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useWorkoutExercises } from './use-workout-exercises';
+
+vi.mock('@/lib/exercise-options', () => ({
+  DEFAULT_EXERCISE: {
+    nomeExercicio: '',
+    series: 3,
+    repeticoes: '10-12',
+    observacoes: '',
+    descricao: '',
+  },
+  exercicioDescriptionsMap: new Map([
+    ['Supino Reto', 'Exercício para peito'],
+    ['Agachamento', 'Exercício para pernas'],
+  ]),
+}));
+
+let exerciseCounter = 0;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const addExercise = (result: { current: ReturnType<typeof useWorkoutExercises> }) => {
+  exerciseCounter++;
+  vi.spyOn(Date, 'now').mockReturnValue(exerciseCounter);
+  act(() => result.current.addObjective());
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const addTwoExercises = (result: { current: ReturnType<typeof useWorkoutExercises> }) => {
+  addExercise(result);
+  addExercise(result);
+};
+
+describe('useWorkoutExercises', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    exerciseCounter = 0;
+  });
+
+  describe('initial state', () => {
+    it('should return empty objetivo and exercicios when no initial values', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      expect(result.current.objetivo).toBe('');
+      expect(result.current.exercicios).toEqual([]);
+    });
+
+    it('should use initial values when provided', () => {
+      const initial = {
+        objetivo: 'Hipertrofia',
+        exercicios: [{ id: '1', nomeExercicio: 'Supino' }],
+      };
+      const { result } = renderHook(() =>
+        useWorkoutExercises(initial.objetivo, initial.exercicios)
+      );
+      expect(result.current.objetivo).toBe('Hipertrofia');
+      expect(result.current.exercicios).toHaveLength(1);
+    });
+  });
+
+  describe('setObjetivo', () => {
+    it('should update the objetivo', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      act(() => result.current.setObjetivo('Perda de peso'));
+      expect(result.current.objetivo).toBe('Perda de peso');
+    });
+  });
+
+  describe('addObjective', () => {
+    it('should add a new exercise with DEFAULT_EXERCISE fields', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addExercise(result);
+      expect(result.current.exercicios).toHaveLength(1);
+      expect(result.current.exercicios[0].nomeExercicio).toBe('');
+      expect(result.current.exercicios[0].series).toBe(3);
+      expect(result.current.exercicios[0].repeticoes).toBe('10-12');
+      expect(result.current.exercicios[0].id).toBeDefined();
+    });
+
+    it('should add multiple exercises with unique ids', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addTwoExercises(result);
+      expect(result.current.exercicios).toHaveLength(2);
+      expect(result.current.exercicios[0].id).not.toBe(result.current.exercicios[1].id);
+    });
+  });
+
+  describe('removeExercise', () => {
+    it('should remove exercise by id', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addExercise(result);
+      const firstId = result.current.exercicios[0].id!;
+      act(() => result.current.removeExercise(firstId));
+      expect(result.current.exercicios).toHaveLength(0);
+    });
+
+    it('should only remove the target exercise', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addTwoExercises(result);
+      const firstId = result.current.exercicios[0].id!;
+      act(() => result.current.removeExercise(firstId));
+      expect(result.current.exercicios).toHaveLength(1);
+    });
+
+    it('should handle removing non-existent id gracefully', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addExercise(result);
+      act(() => result.current.removeExercise('nonexistent'));
+      expect(result.current.exercicios).toHaveLength(1);
+    });
+  });
+
+  describe('updateExercise', () => {
+    it('should update a specific field of an exercise', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addExercise(result);
+      const id = result.current.exercicios[0].id!;
+      act(() => result.current.updateExercise(id, 'repeticoes', '8-10'));
+      expect(result.current.exercicios[0].repeticoes).toBe('8-10');
+    });
+
+    it('should update nomeExercicio and set descricao from map', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addExercise(result);
+      const id = result.current.exercicios[0].id!;
+      act(() => result.current.updateExercise(id, 'nomeExercicio', 'Supino Reto'));
+      expect(result.current.exercicios[0].nomeExercicio).toBe('Supino Reto');
+      expect(result.current.exercicios[0].descricao).toBe('Exercício para peito');
+    });
+
+    it('should set empty descricao when exercise name not in map', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addExercise(result);
+      const id = result.current.exercicios[0].id!;
+      act(() => result.current.updateExercise(id, 'nomeExercicio', 'Exercise Not Found'));
+      expect(result.current.exercicios[0].descricao).toBe('');
+    });
+
+    it('should parse series as integer', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addExercise(result);
+      const id = result.current.exercicios[0].id!;
+      act(() => result.current.updateExercise(id, 'series', '5'));
+      expect(result.current.exercicios[0].series).toBe(5);
+    });
+
+    it('should keep old series when value is not a finite number', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addExercise(result);
+      const id = result.current.exercicios[0].id!;
+      act(() => result.current.updateExercise(id, 'series', 'abc'));
+      expect(result.current.exercicios[0].series).toBe(3);
+    });
+
+    it('should not modify other exercises', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      addTwoExercises(result);
+      const firstId = result.current.exercicios[0].id!;
+      act(() => result.current.updateExercise(firstId, 'repeticoes', '8-10'));
+      expect(result.current.exercicios[1].repeticoes).toBe('10-12');
+    });
+  });
+
+  describe('hasValidationErrors', () => {
+    it('should return true when objetivo is empty', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      expect(result.current.hasValidationErrors()).toBe(true);
+    });
+
+    it('should return true when no exercises', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      act(() => result.current.setObjetivo('Hipertrofia'));
+      expect(result.current.hasValidationErrors()).toBe(true);
+    });
+
+    it('should return true when an exercise has no nomeExercicio', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      act(() => result.current.setObjetivo('Hipertrofia'));
+      addExercise(result);
+      expect(result.current.hasValidationErrors()).toBe(true);
+    });
+
+    it('should return false when all fields are valid', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      act(() => result.current.setObjetivo('Hipertrofia'));
+      addExercise(result);
+      const id = result.current.exercicios[0].id!;
+      act(() => result.current.updateExercise(id, 'nomeExercicio', 'Supino Reto'));
+      expect(result.current.hasValidationErrors()).toBe(false);
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear objetivo and exercicios', () => {
+      const { result } = renderHook(() => useWorkoutExercises());
+      act(() => result.current.setObjetivo('Hipertrofia'));
+      addTwoExercises(result);
+      expect(result.current.objetivo).toBe('Hipertrofia');
+      expect(result.current.exercicios).toHaveLength(2);
+
+      act(() => result.current.reset());
+      expect(result.current.objetivo).toBe('');
+      expect(result.current.exercicios).toEqual([]);
+    });
+  });
+});
diff --git a/src/hooks/use-workout-generation.test.ts b/src/hooks/use-workout-generation.test.ts
new file mode 100644
index 00000000..c61186d3
--- /dev/null
+++ b/src/hooks/use-workout-generation.test.ts
@@ -0,0 +1,308 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useWorkoutGeneration } from './use-workout-generation';
+
+vi.mock('@/ai/flows/workout-generator-flow', () => ({
+  streamWorkoutPlan: vi.fn(),
+}));
+
+vi.mock('@/lib/actions/treinos', () => ({
+  upsertTreinoAction: vi.fn(),
+}));
+
+vi.mock('@/lib/constants', () => ({
+  EXERCICIOS_POR_GRUPO: [
+    {
+      grupo: 'Peito',
+      exercicios: [
+        { nomeExercicio: 'Supino Reto com Barra', descricao: 'Deite-se em um banco reto...' },
+        { nomeExercicio: 'Crucifixo Reto', descricao: 'Deite-se em um banco reto...' },
+      ],
+    },
+  ],
+}));
+
+vi.mock('@/lib/logger', () => ({
+  Logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+vi.mock('@/lib/error', () => ({
+  getErrorMessage: vi.fn((err: unknown) =>
+    err instanceof Error ? err.message : 'Erro desconhecido'
+  ),
+}));
+
+vi.mock('@sentry/nextjs', () => ({
+  captureMessage: vi.fn(),
+}));
+
+import { streamWorkoutPlan } from '@/ai/flows/workout-generator-flow';
+import { upsertTreinoAction } from '@/lib/actions/treinos';
+import { Logger } from '@/lib/logger';
+import * as Sentry from '@sentry/nextjs';
+import type { Treino } from '@/lib/definitions';
+
+const mockNotify = {
+  success: vi.fn(),
+  error: vi.fn(),
+};
+
+const baseOptions = {
+  userId: 'user-123',
+  meusTreinos: [] as Treino[],
+  notify: mockNotify,
+};
+
+const aiResult = {
+  planName: 'Plano Hipertrofia',
+  workouts: [
+    {
+      nome: 'Treino A - Peito',
+      objetivo: 'Hipertrofia do peitoral',
+      diaSugerido: 1,
+      exercicios: [
+        {
+          nomeExercicio: 'Supino Reto com Barra',
+          grupoMuscular: 'Peito',
+          series: 4,
+          repeticoes: '8-12',
+          observacoes: 'Controlar a descida',
+        },
+      ],
+    },
+  ],
+};
+
+describe('useWorkoutGeneration', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(streamWorkoutPlan).mockResolvedValue(aiResult as never);
+    vi.mocked(upsertTreinoAction).mockResolvedValue({ success: true });
+  });
+
+  it('returns initial state with isGenerating false', () => {
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+    expect(result.current.isGenerating).toBe(false);
+    expect(typeof result.current.handleGenerate).toBe('function');
+  });
+
+  it('sets isGenerating to true while generating', async () => {
+    let resolvePromise: (value: unknown) => void;
+    const slowPromise = new Promise((resolve) => {
+      resolvePromise = resolve;
+    });
+    vi.mocked(streamWorkoutPlan).mockReturnValue(slowPromise as never);
+
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    act(() => {
+      result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(result.current.isGenerating).toBe(true);
+
+    await act(async () => {
+      resolvePromise!(null);
+      await slowPromise;
+    });
+
+    expect(result.current.isGenerating).toBe(false);
+  });
+
+  it('calls streamWorkoutPlan with input data', async () => {
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+    const input = {
+      objetivo: 'Força' as const,
+      nivelExperiencia: 'Avançado' as const,
+      diasPorSemana: 5,
+    };
+
+    await act(async () => {
+      await result.current.handleGenerate(input);
+    });
+
+    expect(streamWorkoutPlan).toHaveBeenCalledWith(input);
+  });
+
+  it('calls upsertTreinoAction for each workout', async () => {
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(upsertTreinoAction).toHaveBeenCalledTimes(1);
+    expect(upsertTreinoAction).toHaveBeenCalledWith(
+      expect.objectContaining({
+        alunoId: 'user-123',
+        objetivo: 'Treino A - Peito',
+      })
+    );
+  });
+
+  it('shows success notification after generation', async () => {
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(mockNotify.success).toHaveBeenCalledWith(
+      'Plano Pessoal Gerado!',
+      'Plano Hipertrofia foi criado com sucesso.'
+    );
+  });
+
+  it('shows error notification when streamWorkoutPlan throws', async () => {
+    vi.mocked(streamWorkoutPlan).mockRejectedValue(new Error('API failure'));
+
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(mockNotify.error).toHaveBeenCalledWith('Erro da IA', 'API failure', expect.any(Error));
+  });
+
+  it('shows error notification when upsertTreinoAction fails', async () => {
+    vi.mocked(upsertTreinoAction).mockResolvedValue({ success: false, error: 'DB error' });
+
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(mockNotify.error).toHaveBeenCalled();
+    expect(result.current.isGenerating).toBe(false);
+  });
+
+  it('throws when AI returns null/empty result', async () => {
+    vi.mocked(streamWorkoutPlan).mockResolvedValue(null as never);
+
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(mockNotify.error).toHaveBeenCalledWith(
+      'Erro da IA',
+      expect.stringContaining('inválido'),
+      expect.any(Error)
+    );
+  });
+
+  it('sends Sentry message for hallucinated exercise', async () => {
+    vi.mocked(streamWorkoutPlan).mockResolvedValue({
+      planName: 'Test',
+      workouts: [
+        {
+          nome: 'Treino A',
+          objetivo: 'Teste',
+          diaSugerido: 1,
+          exercicios: [
+            {
+              nomeExercicio: 'Exercise Not In Constants',
+              grupoMuscular: 'Unknown',
+              series: 3,
+              repeticoes: '10',
+              observacoes: '',
+            },
+          ],
+        },
+      ],
+    } as never);
+
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(Sentry.captureMessage).toHaveBeenCalledWith(
+      expect.stringContaining('Hallucination'),
+      expect.objectContaining({ level: 'warning' })
+    );
+  });
+
+  it('uses diaSemana from occupied day when day is taken', async () => {
+    const existingTreinos = [{ diaSemana: 1 }] as Treino[];
+    const { result } = renderHook(() =>
+      useWorkoutGeneration({ ...baseOptions, meusTreinos: existingTreinos })
+    );
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(upsertTreinoAction).toHaveBeenCalledWith(expect.objectContaining({ diaSemana: null }));
+  });
+
+  it('sets isGenerating to false even on error', async () => {
+    vi.mocked(streamWorkoutPlan).mockRejectedValue(new Error('Boom'));
+
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(result.current.isGenerating).toBe(false);
+  });
+
+  it('logs info messages during generation', async () => {
+    const { result } = renderHook(() => useWorkoutGeneration(baseOptions));
+
+    await act(async () => {
+      await result.current.handleGenerate({
+        objetivo: 'Hipertrofia',
+        nivelExperiencia: 'Iniciante',
+        diasPorSemana: 3,
+      });
+    });
+
+    expect(Logger.info).toHaveBeenCalledWith('Chamando a IA com dados:', expect.any(Object));
+    expect(Logger.info).toHaveBeenCalledWith('Resultado da IA retornado:', expect.any(Object));
+  });
+});
diff --git a/src/hooks/use-workout-tracker.test.ts b/src/hooks/use-workout-tracker.test.ts
new file mode 100644
index 00000000..6cd907d5
--- /dev/null
+++ b/src/hooks/use-workout-tracker.test.ts
@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, act } from '@testing-library/react';
+import { useWorkoutTracker } from './use-workout-tracker';
+import type { Treino } from '@/lib/definitions';
+
+const mockTreino: Treino = {
+  id: 'treino-uuid-123',
+  alunoId: 'aluno-uuid-456',
+  objetivo: 'Hipertrofia',
+  diaSemana: 1,
+  instrutorId: null,
+  exercicios: [],
+};
+
+const localStorageMock = (() => {
+  let store: Record<string, string> = {};
+  return {
+    getItem: vi.fn((key: string) => store[key] ?? null),
+    setItem: vi.fn((key: string, value: string) => {
+      store[key] = value;
+    }),
+    removeItem: vi.fn((key: string) => {
+      delete store[key];
+    }),
+    clear: vi.fn(() => {
+      store = {};
+    }),
+    get length() {
+      return Object.keys(store).length;
+    },
+    key: vi.fn((_index: number) => null),
+  };
+})();
+
+Object.defineProperty(globalThis, 'localStorage', { value: localStorageMock });
+
+describe('useWorkoutTracker', () => {
+  beforeEach(() => {
+    localStorageMock.clear();
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2025-06-10T12:00:00Z'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('should initialize with empty checkedExercises when treino is null', () => {
+    const { result } = renderHook(() => useWorkoutTracker(null));
+    expect(result.current.checkedExercises).toEqual({});
+  });
+
+  it('should initialize with empty checkedExercises when no saved state exists', () => {
+    const { result } = renderHook(() => useWorkoutTracker(mockTreino));
+    expect(result.current.checkedExercises).toEqual({});
+  });
+
+  it('should load saved state from localStorage on mount', () => {
+    const storageKey = `checkedExercises-2025-06-10-${mockTreino.id}`;
+    const savedState = { 'ex-1': true, 'ex-2': false };
+    localStorageMock.setItem(storageKey, JSON.stringify(savedState));
+
+    const { result } = renderHook(() => useWorkoutTracker(mockTreino));
+    expect(result.current.checkedExercises).toEqual(savedState);
+    expect(localStorageMock.getItem).toHaveBeenCalledWith(storageKey);
+  });
+
+  it('should toggle exercise check state and persist to localStorage', () => {
+    const { result } = renderHook(() => useWorkoutTracker(mockTreino));
+    const storageKey = `checkedExercises-2025-06-10-${mockTreino.id}`;
+
+    act(() => result.current.handleCheckChange('ex-1'));
+
+    expect(result.current.checkedExercises).toEqual({ 'ex-1': true });
+    expect(localStorageMock.setItem).toHaveBeenCalledWith(
+      storageKey,
+      JSON.stringify({ 'ex-1': true })
+    );
+  });
+
+  it('should toggle off a previously checked exercise', () => {
+    const { result } = renderHook(() => useWorkoutTracker(mockTreino));
+
+    act(() => result.current.handleCheckChange('ex-1'));
+    expect(result.current.checkedExercises['ex-1']).toBe(true);
+
+    act(() => result.current.handleCheckChange('ex-1'));
+    expect(result.current.checkedExercises['ex-1']).toBe(false);
+  });
+
+  it('should not persist when treino is null', () => {
+    const { result } = renderHook(() => useWorkoutTracker(null));
+
+    act(() => result.current.handleCheckChange('ex-1'));
+    expect(localStorageMock.setItem).not.toHaveBeenCalled();
+  });
+
+  it('should track multiple exercises independently', () => {
+    const { result } = renderHook(() => useWorkoutTracker(mockTreino));
+
+    act(() => result.current.handleCheckChange('ex-1'));
+    act(() => result.current.handleCheckChange('ex-2'));
+
+    expect(result.current.checkedExercises).toEqual({ 'ex-1': true, 'ex-2': true });
+
+    act(() => result.current.handleCheckChange('ex-1'));
+    expect(result.current.checkedExercises).toEqual({ 'ex-1': false, 'ex-2': true });
+  });
+
+  it('should use date-based storage key', () => {
+    const { result } = renderHook(() => useWorkoutTracker(mockTreino));
+    const storageKey = `checkedExercises-2025-06-10-${mockTreino.id}`;
+
+    act(() => result.current.handleCheckChange('ex-1'));
+    expect(localStorageMock.setItem).toHaveBeenCalledWith(storageKey, expect.any(String));
+  });
+});
diff --git a/src/lib/constants.test.ts b/src/lib/constants.test.ts
new file mode 100644
index 00000000..b12bd4be
--- /dev/null
+++ b/src/lib/constants.test.ts
@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest';
+import { FINANCIAL_ROUTES, DIAS_DA_SEMANA, EXERCICIOS_POR_GRUPO } from './constants';
+
+describe('FINANCIAL_ROUTES', () => {
+  it('contains the expected routes', () => {
+    expect(FINANCIAL_ROUTES).toContain('/dashboard/financeiro');
+    expect(FINANCIAL_ROUTES).toContain('/dashboard/planos');
+  });
+
+  it('is a readonly tuple with exactly 2 entries', () => {
+    expect(FINANCIAL_ROUTES).toHaveLength(2);
+  });
+
+  it('contains only non-empty string paths', () => {
+    for (const route of FINANCIAL_ROUTES) {
+      expect(typeof route).toBe('string');
+      expect(route.length).toBeGreaterThan(0);
+      expect(route).toMatch(/^\//);
+    }
+  });
+});
+
+describe('DIAS_DA_SEMANA', () => {
+  it('contains exactly 7 entries', () => {
+    expect(DIAS_DA_SEMANA).toHaveLength(7);
+  });
+
+  it('covers all day values 0–6', () => {
+    const values = DIAS_DA_SEMANA.map((d) => d.value);
+    for (let i = 0; i <= 6; i++) {
+      expect(values).toContain(i);
+    }
+  });
+
+  it('each entry has a numeric value and a non-empty string label', () => {
+    for (const dia of DIAS_DA_SEMANA) {
+      expect(typeof dia.value).toBe('number');
+      expect(typeof dia.label).toBe('string');
+      expect(dia.label.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('maps value 0 to Domingo', () => {
+    const domingo = DIAS_DA_SEMANA.find((d) => d.value === 0);
+    expect(domingo?.label).toBe('Domingo');
+  });
+
+  it('maps value 6 to Sábado', () => {
+    const sabado = DIAS_DA_SEMANA.find((d) => d.value === 6);
+    expect(sabado?.label).toBe('Sábado');
+  });
+});
+
+describe('EXERCICIOS_POR_GRUPO', () => {
+  it('is a non-empty array', () => {
+    expect(Array.isArray(EXERCICIOS_POR_GRUPO)).toBe(true);
+    expect(EXERCICIOS_POR_GRUPO.length).toBeGreaterThan(0);
+  });
+
+  it('each group has a non-empty grupo name', () => {
+    for (const group of EXERCICIOS_POR_GRUPO) {
+      expect(typeof group.grupo).toBe('string');
+      expect(group.grupo.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('each group has at least one exercise', () => {
+    for (const group of EXERCICIOS_POR_GRUPO) {
+      expect(Array.isArray(group.exercicios)).toBe(true);
+      expect(group.exercicios.length).toBeGreaterThan(0);
+    }
+  });
+
+  it('each exercise has a non-empty nomeExercicio and descricao', () => {
+    for (const group of EXERCICIOS_POR_GRUPO) {
+      for (const ex of group.exercicios) {
+        expect(typeof ex.nomeExercicio).toBe('string');
+        expect(ex.nomeExercicio.length).toBeGreaterThan(0);
+        expect(typeof ex.descricao).toBe('string');
+        expect(ex.descricao.length).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it('has no duplicate exercise names within each group', () => {
+    for (const group of EXERCICIOS_POR_GRUPO) {
+      const names = group.exercicios.map((ex) => ex.nomeExercicio);
+      const uniqueNames = new Set(names);
+      expect(uniqueNames.size).toBe(names.length);
+    }
+  });
+
+  it('includes expected muscle groups', () => {
+    const groupNames = EXERCICIOS_POR_GRUPO.map((g) => g.grupo);
+    expect(groupNames).toContain('Peito');
+    expect(groupNames).toContain('Costas');
+    expect(groupNames).toContain('Ombros');
+    expect(groupNames).toContain('Panturrilhas');
+    expect(groupNames).toContain('Abdômen');
+  });
+});
diff --git a/src/lib/data.test.ts b/src/lib/data.test.ts
new file mode 100644
index 00000000..9722591e
--- /dev/null
+++ b/src/lib/data.test.ts
@@ -0,0 +1,282 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@sentry/nextjs', () => ({
+  captureException: vi.fn(),
+  captureMessage: vi.fn(),
+}));
+
+vi.mock('./prisma', () => ({
+  prisma: {
+    aluno: {
+      findMany: vi.fn(),
+      findUnique: vi.fn(),
+      count: vi.fn(),
+    },
+    plano: {
+      findMany: vi.fn(),
+    },
+    treino: {
+      findMany: vi.fn(),
+    },
+    matricula: {
+      count: vi.fn(),
+    },
+    $queryRaw: vi.fn(),
+  },
+}));
+
+import * as Sentry from '@sentry/nextjs';
+import { prisma } from './prisma';
+import { getAlunos, getPlanos, getTreinos, getAlunoDetalhes, getDashboardStats } from './data';
+
+const mockPrisma = vi.mocked(prisma);
+const mockCaptureException = vi.mocked(Sentry.captureException);
+const mockCaptureMessage = vi.mocked(Sentry.captureMessage);
+
+const UUID = 'a1b2c3d4-e5f6-1a7b-8c9d-0e1f2a3b4c5d';
+const UUID2 = 'b2c3d4e5-f6a7-2b8c-9d0e-1f2a3b4c5d6e';
+const UUID3 = 'c3d4e5f6-a7b8-3c9d-a01f-2a3b4c5d6e7f';
+
+function buildAluno(overrides: Record<string, unknown> = {}) {
+  return {
+    id: UUID,
+    nomeCompleto: 'João Silva',
+    cpf: '12345678900',
+    email: 'joao@test.com',
+    telefone: '11999998888',
+    dataNascimento: '1995-01-01',
+    dataCadastro: '2024-01-01',
+    fotoUrl: null,
+    biometriaHash: null,
+    statusMatricula: 'ATIVA',
+    nivel: 1,
+    exp: 0,
+    streakDiasSeguidos: 0,
+    treinosNoMes: 0,
+    ultimoTreinoData: null,
+    xpToNextLevel: 1500,
+    progressPerc: 0,
+    dataVencimento: null,
+    ...overrides,
+  };
+}
+
+describe('getAlunos', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns validated alunos from database', async () => {
+    const alunos = [buildAluno(), buildAluno({ id: UUID2, nomeCompleto: 'Maria' })];
+    vi.mocked(mockPrisma.aluno.findMany).mockResolvedValue(alunos as never);
+
+    const result = await getAlunos();
+
+    expect(result).toHaveLength(2);
+    expect(result[0].nomeCompleto).toBe('João Silva');
+    expect(result[1].nomeCompleto).toBe('Maria');
+    expect(mockPrisma.aluno.findMany).toHaveBeenCalledWith({ orderBy: { nomeCompleto: 'asc' } });
+  });
+
+  it('skips invalid alunos gracefully', async () => {
+    const valid = buildAluno();
+    const invalid = { id: 'not-a-uuid', nomeCompleto: 'X' };
+    vi.mocked(mockPrisma.aluno.findMany).mockResolvedValue([valid, invalid] as never);
+
+    const result = await getAlunos();
+
+    expect(result).toHaveLength(1);
+    expect(result[0].nomeCompleto).toBe('João Silva');
+  });
+
+  it('returns empty array on database error', async () => {
+    vi.mocked(mockPrisma.aluno.findMany).mockRejectedValue(new Error('DB down'));
+
+    const result = await getAlunos();
+
+    expect(result).toEqual([]);
+    expect(mockCaptureException).toHaveBeenCalled();
+  });
+});
+
+describe('getPlanos', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns validated planos', async () => {
+    const planos = [
+      { id: UUID, nome: 'Básico', preco: 99.9, duracaoDias: 30 },
+      { id: UUID2, nome: 'Premium', preco: 199.9, duracaoDias: 30 },
+    ];
+    vi.mocked(mockPrisma.plano.findMany).mockResolvedValue(planos as never);
+
+    const result = await getPlanos();
+
+    expect(result).toHaveLength(2);
+    expect(result[0].nome).toBe('Básico');
+    expect(mockPrisma.plano.findMany).toHaveBeenCalledWith({ orderBy: { preco: 'asc' } });
+  });
+
+  it('returns empty array on database error', async () => {
+    vi.mocked(mockPrisma.plano.findMany).mockRejectedValue(new Error('DB error'));
+
+    const result = await getPlanos();
+
+    expect(result).toEqual([]);
+    expect(mockCaptureException).toHaveBeenCalled();
+  });
+});
+
+describe('getTreinos', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns validated treinos with exercises', async () => {
+    const treinos = [
+      {
+        id: UUID,
+        alunoId: UUID2,
+        instrutorId: null,
+        objetivo: 'Ganho muscular',
+        dataCriacao: '2024-01-01',
+        diaSemana: 1,
+        Exercicios: [
+          {
+            id: UUID3,
+            nomeExercicio: 'Supino',
+            series: 4,
+            repeticoes: '10-12',
+            observacoes: null,
+            descricao: null,
+          },
+        ],
+      },
+    ];
+    vi.mocked(mockPrisma.treino.findMany).mockResolvedValue(treinos as never);
+
+    const result = await getTreinos();
+
+    expect(result).toHaveLength(1);
+    expect(result[0].exercicios).toHaveLength(1);
+    expect(result[0].exercicios[0].nomeExercicio).toBe('Supino');
+  });
+
+  it('filters by alunoId when provided', async () => {
+    vi.mocked(mockPrisma.treino.findMany).mockResolvedValue([] as never);
+
+    await getTreinos(UUID2);
+
+    expect(mockPrisma.treino.findMany).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { alunoId: UUID2 } })
+    );
+  });
+
+  it('returns empty array on database error', async () => {
+    vi.mocked(mockPrisma.treino.findMany).mockRejectedValue(new Error('DB error'));
+
+    const result = await getTreinos();
+
+    expect(result).toEqual([]);
+    expect(mockCaptureException).toHaveBeenCalled();
+  });
+});
+
+describe('getAlunoDetalhes', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns full aluno details with relations', async () => {
+    const details = {
+      id: UUID,
+      nomeCompleto: 'Test',
+      Matriculas: [],
+      Pagamentos: [],
+      Treinos: [],
+      HistoricoTreinos: [],
+    };
+    vi.mocked(mockPrisma.aluno.findUnique).mockResolvedValue(details as never);
+
+    const result = await getAlunoDetalhes(UUID);
+
+    expect(result).toEqual(details);
+    expect(mockPrisma.aluno.findUnique).toHaveBeenCalledWith(
+      expect.objectContaining({ where: { id: UUID } })
+    );
+  });
+
+  it('returns null on database error', async () => {
+    vi.mocked(mockPrisma.aluno.findUnique).mockRejectedValue(new Error('Not found'));
+
+    const result = await getAlunoDetalhes('00000000-0000-0000-0000-000000000000');
+
+    expect(result).toBeNull();
+    expect(mockCaptureException).toHaveBeenCalled();
+  });
+});
+
+describe('getDashboardStats', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('returns aggregated dashboard stats', async () => {
+    vi.mocked(mockPrisma.aluno.count).mockResolvedValueOnce(50).mockResolvedValueOnce(0);
+    vi.mocked(mockPrisma.matricula.count).mockResolvedValue(40);
+    vi.mocked(mockPrisma.$queryRaw).mockResolvedValue([
+      { TotalRecebido: 4500.5, Mes: '2024-06', QtdPagamentos: 35 },
+    ] as never);
+
+    const result = await getDashboardStats();
+
+    expect(result.totalAlunos).toBe(50);
+    expect(result.matriculasAtivas).toBe(40);
+    expect(result.alunosInadimplentes).toBe(0);
+    expect(result.faturamentoMensal).toBe(4500.5);
+    expect(result.crescimentoAnual).toHaveLength(6);
+  });
+
+  it('sets faturamentoMensal to 0 when view query fails', async () => {
+    vi.mocked(mockPrisma.aluno.count).mockResolvedValueOnce(10).mockResolvedValueOnce(10);
+    vi.mocked(mockPrisma.matricula.count).mockResolvedValue(8);
+    vi.mocked(mockPrisma.$queryRaw).mockRejectedValue(new Error('View missing'));
+
+    const result = await getDashboardStats();
+
+    expect(result.faturamentoMensal).toBe(0);
+    expect(mockCaptureMessage).toHaveBeenCalledWith(
+      'Aviso: Falha ao ler V_FaturamentoMensal. O banco pode estar vazio ou a view ausente.'
+    );
+  });
+
+  it('returns default safe stats on total failure', async () => {
+    vi.mocked(mockPrisma.aluno.count).mockRejectedValue(new Error('Total failure'));
+
+    const result = await getDashboardStats();
+
+    expect(result.totalAlunos).toBe(0);
+    expect(result.matriculasAtivas).toBe(0);
+    expect(result.alunosInadimplentes).toBe(0);
+    expect(result.faturamentoMensal).toBe(0);
+    expect(result.crescimentoAnual).toEqual([]);
+    expect(mockCaptureException).toHaveBeenCalled();
+  });
+
+  it('computes growth projection correctly', async () => {
+    vi.mocked(mockPrisma.aluno.count).mockResolvedValueOnce(100).mockResolvedValueOnce(100);
+    vi.mocked(mockPrisma.matricula.count).mockResolvedValue(100);
+    vi.mocked(mockPrisma.$queryRaw).mockResolvedValue([] as never);
+
+    const result = await getDashboardStats();
+
+    // GROWTH_BASE_FACTOR = 0.7, GROWTH_INCREMENT = 0.05
+    // Month 0: floor(100 * 0.7) = 70
+    // Month 1: floor(100 * 0.75) = 75
+    // Month 5: floor(100 * 0.95) = 95
+    expect(result.crescimentoAnual[0].alunos).toBe(70);
+    expect(result.crescimentoAnual[1].alunos).toBe(75);
+    expect(result.crescimentoAnual[5].alunos).toBe(95);
+  });
+});
diff --git a/src/lib/definitions.test.ts b/src/lib/definitions.test.ts
new file mode 100644
index 00000000..a87a8c33
--- /dev/null
+++ b/src/lib/definitions.test.ts
@@ -0,0 +1,1175 @@
+import { describe, it, expect, expectTypeOf } from 'vitest';
+import {
+  AlunoStatusEnum,
+  AlunoBaseSchema,
+  AlunoSchema,
+  ExercicioBaseSchema,
+  ExercicioSchema,
+  TreinoBaseSchema,
+  TreinoSchema,
+  SerieExecutadaBaseSchema,
+  SerieExecutadaSchema,
+  HistoricoTreinoBaseSchema,
+  HistoricoTreinoSchema,
+  PlanoBaseSchema,
+  PlanoSchema,
+  MatriculaBaseSchema,
+  MatriculaSchema,
+  PagamentoBaseSchema,
+  PagamentoSchema,
+  GrowthDataSchema,
+  DashboardStatsSchema,
+  V_FaturamentoMensalSchema,
+  V_FrequenciaAlunosSchema,
+} from './definitions';
+
+import type {
+  AlunoBase,
+  Aluno,
+  ExercicioBase,
+  Exercicio,
+  TreinoBase,
+  Treino,
+  SerieExecutadaBase,
+  SerieExecutada,
+  HistoricoTreinoBase,
+  HistoricoTreino,
+  PlanoBase,
+  Plano,
+  MatriculaBase,
+  Matricula,
+  PagamentoBase,
+  Pagamento,
+  GrowthData,
+  DashboardStats,
+} from './definitions';
+
+// --- Test Helpers ---
+
+const UUID = '550e8400-e29b-41d4-a716-446655440000';
+const UUID2 = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+const UUID3 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+const UUID4 = '6ba7b812-9dad-11d1-80b4-00c04fd430c8';
+
+function validAlunoBase() {
+  return {
+    nomeCompleto: 'João Silva',
+    cpf: '12345678901',
+    email: 'joao@email.com',
+    telefone: '11999998888',
+  };
+}
+
+function validAluno() {
+  return { ...validAlunoBase(), id: UUID };
+}
+
+function validExercicioBase() {
+  return {
+    nomeExercicio: 'Supino Reto',
+    series: 4,
+    repeticoes: '12',
+  };
+}
+
+function validExercicio() {
+  return { ...validExercicioBase(), id: UUID };
+}
+
+function validTreinoBase() {
+  return {
+    alunoId: UUID,
+    objetivo: 'Hipertrofia',
+    diaSemana: 1,
+    exercicios: [validExercicioBase()],
+    dataCriacao: '2024-01-01',
+  };
+}
+
+function validTreino() {
+  return { ...validTreinoBase(), id: UUID2, exercicios: [validExercicio()] };
+}
+
+function validSerieExecutadaBase() {
+  return {
+    serieNumero: 1,
+    peso: 60,
+    repeticoesFeitas: 12,
+    concluido: true,
+  };
+}
+
+function validSerieExecutada() {
+  return { ...validSerieExecutadaBase(), id: UUID };
+}
+
+function validHistoricoTreinoBase() {
+  return {
+    alunoId: UUID,
+    treinoId: UUID2,
+    dataExecucao: '2025-01-15T10:00:00Z',
+    duracaoMinutos: 45,
+    exercicios: [
+      {
+        exercicioId: UUID3,
+        nomeExercicio: 'Supino Reto',
+        seriesExecutadas: [validSerieExecutadaBase()],
+      },
+    ],
+  };
+}
+
+function validHistoricoTreino() {
+  return {
+    ...validHistoricoTreinoBase(),
+    id: UUID4,
+    exercicios: [
+      {
+        exercicioId: UUID3,
+        nomeExercicio: 'Supino Reto',
+        seriesExecutadas: [validSerieExecutada()],
+      },
+    ],
+  };
+}
+
+function validPlanoBase() {
+  return {
+    nome: 'Plano Anual',
+    preco: 199.9,
+    duracaoDias: 365,
+  };
+}
+
+function validPlano() {
+  return { ...validPlanoBase(), id: UUID };
+}
+
+function validMatriculaBase() {
+  return {
+    alunoId: UUID,
+    planoId: UUID2,
+    dataInicio: '2025-01-01',
+    dataVencimento: '2025-12-31',
+  };
+}
+
+function validMatricula() {
+  return { ...validMatriculaBase(), id: UUID3 };
+}
+
+function validPagamentoBase() {
+  return {
+    matriculaId: UUID,
+    alunoId: UUID2,
+    valor: 199.9,
+    dataPagamento: '2025-01-10',
+    metodo: 'PIX' as const,
+  };
+}
+
+function validPagamento() {
+  return { ...validPagamentoBase(), id: UUID3 };
+}
+
+// --- AlunoStatusEnum ---
+
+describe('AlunoStatusEnum', () => {
+  it('accepts ATIVA', () => {
+    expect(AlunoStatusEnum.parse('ATIVA')).toBe('ATIVA');
+  });
+
+  it('accepts INADIMPLENTE', () => {
+    expect(AlunoStatusEnum.parse('INADIMPLENTE')).toBe('INADIMPLENTE');
+  });
+
+  it('accepts INATIVA', () => {
+    expect(AlunoStatusEnum.parse('INATIVA')).toBe('INATIVA');
+  });
+
+  it('rejects invalid status', () => {
+    expect(() => AlunoStatusEnum.parse('ATIVO')).toThrow();
+  });
+
+  it('rejects empty string', () => {
+    expect(() => AlunoStatusEnum.parse('')).toThrow();
+  });
+
+  it('rejects null', () => {
+    expect(() => AlunoStatusEnum.parse(null)).toThrow();
+  });
+});
+
+// --- AlunoBaseSchema ---
+
+describe('AlunoBaseSchema', () => {
+  it('accepts valid data with all optional fields omitted', () => {
+    const result = AlunoBaseSchema.parse(validAlunoBase());
+    expect(result.nomeCompleto).toBe('João Silva');
+    expect(result.statusMatricula).toBe('ATIVA');
+    expect(result.nivel).toBe(1);
+    expect(result.exp).toBe(0);
+    expect(result.streakDiasSeguidos).toBe(0);
+    expect(result.treinosNoMes).toBe(0);
+  });
+
+  it('accepts all optional fields', () => {
+    const data = {
+      ...validAlunoBase(),
+      dataNascimento: '1990-05-15',
+      dataCadastro: '2025-01-01',
+      fotoUrl: 'https://example.com/photo.jpg',
+      biometriaHash: 'abc123',
+      statusMatricula: 'INADIMPLENTE',
+      nivel: 5,
+      exp: 1200,
+      streakDiasSeguidos: 10,
+      treinosNoMes: 15,
+      ultimoTreinoData: '2025-01-14',
+      xpToNextLevel: 500,
+      progressPerc: 75.5,
+      dataVencimento: '2025-06-01',
+    };
+    const result = AlunoBaseSchema.parse(data);
+    expect(result.fotoUrl).toBe('https://example.com/photo.jpg');
+    expect(result.nivel).toBe(5);
+  });
+
+  it('accepts Date objects for date fields', () => {
+    const data = {
+      ...validAlunoBase(),
+      dataNascimento: new Date('1990-05-15'),
+      dataCadastro: new Date('2025-01-01'),
+    };
+    const result = AlunoBaseSchema.parse(data);
+    expect(result.dataNascimento).toBeInstanceOf(Date);
+  });
+
+  it('accepts null for nullable optional fields', () => {
+    const data = {
+      ...validAlunoBase(),
+      dataNascimento: null,
+      fotoUrl: null,
+      biometriaHash: null,
+      ultimoTreinoData: null,
+      dataVencimento: null,
+    };
+    const result = AlunoBaseSchema.parse(data);
+    expect(result.dataNascimento).toBeNull();
+    expect(result.fotoUrl).toBeNull();
+  });
+
+  it('rejects missing nomeCompleto', () => {
+    const { nomeCompleto, ...rest } = validAlunoBase();
+    expect(() => AlunoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects nomeCompleto shorter than 3 chars', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), nomeCompleto: 'Jo' })).toThrow();
+  });
+
+  it('rejects missing cpf', () => {
+    const { cpf, ...rest } = validAlunoBase();
+    expect(() => AlunoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects cpf shorter than 11 chars', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), cpf: '1234567890' })).toThrow();
+  });
+
+  it('rejects invalid email', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), email: 'not-an-email' })).toThrow();
+  });
+
+  it('rejects missing email', () => {
+    const { email, ...rest } = validAlunoBase();
+    expect(() => AlunoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects missing telefone', () => {
+    const { telefone, ...rest } = validAlunoBase();
+    expect(() => AlunoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects telefone shorter than 10 chars', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), telefone: '1199999' })).toThrow();
+  });
+
+  it('rejects invalid fotoUrl', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), fotoUrl: 'not-a-url' })).toThrow();
+  });
+
+  it('rejects invalid statusMatricula value', () => {
+    expect(() =>
+      AlunoBaseSchema.parse({ ...validAlunoBase(), statusMatricula: 'CANCELADA' })
+    ).toThrow();
+  });
+
+  it('rejects nivel below minimum (1)', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), nivel: 0 })).toThrow();
+  });
+
+  it('rejects non-integer nivel', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), nivel: 1.5 })).toThrow();
+  });
+
+  it('rejects negative exp', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), exp: -1 })).toThrow();
+  });
+
+  it('rejects negative streakDiasSeguidos', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), streakDiasSeguidos: -1 })).toThrow();
+  });
+
+  it('rejects negative treinosNoMes', () => {
+    expect(() => AlunoBaseSchema.parse({ ...validAlunoBase(), treinosNoMes: -1 })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<AlunoBase>().toHaveProperty('nomeCompleto');
+    expectTypeOf<AlunoBase>().toHaveProperty('cpf');
+    expectTypeOf<AlunoBase>().toHaveProperty('email');
+    expectTypeOf<AlunoBase>().toHaveProperty('statusMatricula');
+    expectTypeOf<AlunoBase>().toHaveProperty('nivel');
+  });
+});
+
+// --- AlunoSchema ---
+
+describe('AlunoSchema', () => {
+  it('accepts valid data with id', () => {
+    const result = AlunoSchema.parse(validAluno());
+    expect(result.id).toBe(UUID);
+    expect(result.nomeCompleto).toBe('João Silva');
+  });
+
+  it('rejects missing id', () => {
+    expect(() => AlunoSchema.parse(validAlunoBase())).toThrow();
+  });
+
+  it('rejects invalid UUID for id', () => {
+    expect(() => AlunoSchema.parse({ ...validAluno(), id: 'not-a-uuid' })).toThrow();
+  });
+
+  it('rejects empty id', () => {
+    expect(() => AlunoSchema.parse({ ...validAluno(), id: '' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<Aluno>().toHaveProperty('id');
+    expectTypeOf<Aluno>().toHaveProperty('nomeCompleto');
+  });
+});
+
+// --- ExercicioBaseSchema ---
+
+describe('ExercicioBaseSchema', () => {
+  it('accepts valid data', () => {
+    const result = ExercicioBaseSchema.parse(validExercicioBase());
+    expect(result.nomeExercicio).toBe('Supino Reto');
+    expect(result.series).toBe(4);
+    expect(result.repeticoes).toBe('12');
+  });
+
+  it('accepts optional fields', () => {
+    const data = {
+      ...validExercicioBase(),
+      observacoes: 'Foco na excêntrica',
+      descricao: 'Supino com halteres',
+    };
+    const result = ExercicioBaseSchema.parse(data);
+    expect(result.observacoes).toBe('Foco na excêntrica');
+  });
+
+  it('accepts null for nullable fields', () => {
+    const data = { ...validExercicioBase(), observacoes: null, descricao: null };
+    const result = ExercicioBaseSchema.parse(data);
+    expect(result.observacoes).toBeNull();
+  });
+
+  it('coerces series from string to number', () => {
+    const result = ExercicioBaseSchema.parse({ ...validExercicioBase(), series: '3' });
+    expect(result.series).toBe(3);
+  });
+
+  it('rejects missing nomeExercicio', () => {
+    const { nomeExercicio, ...rest } = validExercicioBase();
+    expect(() => ExercicioBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects nomeExercicio shorter than 2 chars', () => {
+    expect(() =>
+      ExercicioBaseSchema.parse({ ...validExercicioBase(), nomeExercicio: 'A' })
+    ).toThrow();
+  });
+
+  it('rejects missing series', () => {
+    const { series, ...rest } = validExercicioBase();
+    expect(() => ExercicioBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects series below 1', () => {
+    expect(() => ExercicioBaseSchema.parse({ ...validExercicioBase(), series: 0 })).toThrow();
+  });
+
+  it('rejects missing repeticoes', () => {
+    const { repeticoes, ...rest } = validExercicioBase();
+    expect(() => ExercicioBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects empty repeticoes', () => {
+    expect(() => ExercicioBaseSchema.parse({ ...validExercicioBase(), repeticoes: '' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<ExercicioBase>().toHaveProperty('nomeExercicio');
+    expectTypeOf<ExercicioBase>().toHaveProperty('series');
+    expectTypeOf<ExercicioBase>().toHaveProperty('repeticoes');
+  });
+});
+
+// --- ExercicioSchema ---
+
+describe('ExercicioSchema', () => {
+  it('accepts valid data with id', () => {
+    const result = ExercicioSchema.parse(validExercicio());
+    expect(result.id).toBe(UUID);
+  });
+
+  it('rejects missing id', () => {
+    expect(() => ExercicioSchema.parse(validExercicioBase())).toThrow();
+  });
+
+  it('rejects invalid UUID', () => {
+    expect(() => ExercicioSchema.parse({ ...validExercicio(), id: 'bad-uuid' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<Exercicio>().toHaveProperty('id');
+    expectTypeOf<Exercicio>().toHaveProperty('nomeExercicio');
+  });
+});
+
+// --- TreinoBaseSchema ---
+
+describe('TreinoBaseSchema', () => {
+  it('accepts valid data', () => {
+    const result = TreinoBaseSchema.parse(validTreinoBase());
+    expect(result.alunoId).toBe(UUID);
+    expect(result.objetivo).toBe('Hipertrofia');
+    expect(result.exercicios).toHaveLength(1);
+  });
+
+  it('accepts data without optional fields', () => {
+    const { dataCriacao, ...rest } = validTreinoBase();
+    const result = TreinoBaseSchema.parse(rest);
+    expect(result.alunoId).toBe(UUID);
+  });
+
+  it('accepts Date for dataCriacao', () => {
+    const data = { ...validTreinoBase(), dataCriacao: new Date() };
+    expect(() => TreinoBaseSchema.parse(data)).not.toThrow();
+  });
+
+  it('accepts diaSemana at boundary 0 (Domingo)', () => {
+    const result = TreinoBaseSchema.parse({ ...validTreinoBase(), diaSemana: 0 });
+    expect(result.diaSemana).toBe(0);
+  });
+
+  it('accepts diaSemana at boundary 6 (Sábado)', () => {
+    const result = TreinoBaseSchema.parse({ ...validTreinoBase(), diaSemana: 6 });
+    expect(result.diaSemana).toBe(6);
+  });
+
+  it('accepts null for diaSemana', () => {
+    const result = TreinoBaseSchema.parse({ ...validTreinoBase(), diaSemana: null });
+    expect(result.diaSemana).toBeNull();
+  });
+
+  it('rejects diaSemana > 6', () => {
+    expect(() => TreinoBaseSchema.parse({ ...validTreinoBase(), diaSemana: 7 })).toThrow();
+  });
+
+  it('rejects diaSemana < 0', () => {
+    expect(() => TreinoBaseSchema.parse({ ...validTreinoBase(), diaSemana: -1 })).toThrow();
+  });
+
+  it('rejects empty exercicios array', () => {
+    expect(() => TreinoBaseSchema.parse({ ...validTreinoBase(), exercicios: [] })).toThrow();
+  });
+
+  it('rejects missing alunoId', () => {
+    const { alunoId, ...rest } = validTreinoBase();
+    expect(() => TreinoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects invalid alunoId UUID', () => {
+    expect(() => TreinoBaseSchema.parse({ ...validTreinoBase(), alunoId: 'bad' })).toThrow();
+  });
+
+  it('rejects missing objetivo', () => {
+    const { objetivo, ...rest } = validTreinoBase();
+    expect(() => TreinoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects objetivo shorter than 3 chars', () => {
+    expect(() => TreinoBaseSchema.parse({ ...validTreinoBase(), objetivo: 'Hi' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<TreinoBase>().toHaveProperty('alunoId');
+    expectTypeOf<TreinoBase>().toHaveProperty('exercicios');
+  });
+});
+
+// --- TreinoSchema ---
+
+describe('TreinoSchema', () => {
+  it('accepts valid data with id', () => {
+    const result = TreinoSchema.parse(validTreino());
+    expect(result.id).toBe(UUID2);
+    expect(result.exercicios).toHaveLength(1);
+    expect(result.exercicios[0].id).toBe(UUID);
+  });
+
+  it('accepts optional instrutorId', () => {
+    const data = { ...validTreino(), instrutorId: UUID3 };
+    const result = TreinoSchema.parse(data);
+    expect(result.instrutorId).toBe(UUID3);
+  });
+
+  it('accepts null instrutorId', () => {
+    const data = { ...validTreino(), instrutorId: null };
+    const result = TreinoSchema.parse(data);
+    expect(result.instrutorId).toBeNull();
+  });
+
+  it('rejects missing id', () => {
+    const { id, ...rest } = validTreino();
+    expect(() => TreinoSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects invalid instrutorId UUID', () => {
+    expect(() => TreinoSchema.parse({ ...validTreino(), instrutorId: 'bad' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<Treino>().toHaveProperty('id');
+    expectTypeOf<Treino>().toHaveProperty('instrutorId');
+  });
+});
+
+// --- SerieExecutadaBaseSchema ---
+
+describe('SerieExecutadaBaseSchema', () => {
+  it('accepts valid data', () => {
+    const result = SerieExecutadaBaseSchema.parse(validSerieExecutadaBase());
+    expect(result.serieNumero).toBe(1);
+    expect(result.concluido).toBe(true);
+  });
+
+  it('applies default concluido as false', () => {
+    const { concluido, ...rest } = validSerieExecutadaBase();
+    const result = SerieExecutadaBaseSchema.parse(rest);
+    expect(result.concluido).toBe(false);
+  });
+
+  it('accepts null peso', () => {
+    const data = { ...validSerieExecutadaBase(), peso: null };
+    const result = SerieExecutadaBaseSchema.parse(data);
+    expect(result.peso).toBeNull();
+  });
+
+  it('accepts null repeticoesFeitas', () => {
+    const data = { ...validSerieExecutadaBase(), repeticoesFeitas: null };
+    const result = SerieExecutadaBaseSchema.parse(data);
+    expect(result.repeticoesFeitas).toBeNull();
+  });
+
+  it('coerces peso from string', () => {
+    const result = SerieExecutadaBaseSchema.parse({ ...validSerieExecutadaBase(), peso: '55.5' });
+    expect(result.peso).toBe(55.5);
+  });
+
+  it('coerces repeticoesFeitas from string', () => {
+    const result = SerieExecutadaBaseSchema.parse({
+      ...validSerieExecutadaBase(),
+      repeticoesFeitas: '10',
+    });
+    expect(result.repeticoesFeitas).toBe(10);
+  });
+
+  it('rejects serieNumero below 1', () => {
+    expect(() =>
+      SerieExecutadaBaseSchema.parse({ ...validSerieExecutadaBase(), serieNumero: 0 })
+    ).toThrow();
+  });
+
+  it('rejects missing serieNumero', () => {
+    const { serieNumero, ...rest } = validSerieExecutadaBase();
+    expect(() => SerieExecutadaBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<SerieExecutadaBase>().toHaveProperty('serieNumero');
+    expectTypeOf<SerieExecutadaBase>().toHaveProperty('concluido');
+  });
+});
+
+// --- SerieExecutadaSchema ---
+
+describe('SerieExecutadaSchema', () => {
+  it('accepts valid data with id', () => {
+    const result = SerieExecutadaSchema.parse(validSerieExecutada());
+    expect(result.id).toBe(UUID);
+  });
+
+  it('rejects missing id', () => {
+    expect(() => SerieExecutadaSchema.parse(validSerieExecutadaBase())).toThrow();
+  });
+
+  it('rejects invalid UUID', () => {
+    expect(() => SerieExecutadaSchema.parse({ ...validSerieExecutada(), id: 'bad' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<SerieExecutada>().toHaveProperty('id');
+    expectTypeOf<SerieExecutada>().toHaveProperty('serieNumero');
+  });
+});
+
+// --- HistoricoTreinoBaseSchema ---
+
+describe('HistoricoTreinoBaseSchema', () => {
+  it('accepts valid data', () => {
+    const result = HistoricoTreinoBaseSchema.parse(validHistoricoTreinoBase());
+    expect(result.alunoId).toBe(UUID);
+    expect(result.duracaoMinutos).toBe(45);
+    expect(result.exercicios).toHaveLength(1);
+  });
+
+  it('accepts Date for dataExecucao', () => {
+    const data = { ...validHistoricoTreinoBase(), dataExecucao: new Date() };
+    expect(() => HistoricoTreinoBaseSchema.parse(data)).not.toThrow();
+  });
+
+  it('rejects missing alunoId', () => {
+    const { alunoId, ...rest } = validHistoricoTreinoBase();
+    expect(() => HistoricoTreinoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects invalid alunoId UUID', () => {
+    expect(() =>
+      HistoricoTreinoBaseSchema.parse({ ...validHistoricoTreinoBase(), alunoId: 'bad' })
+    ).toThrow();
+  });
+
+  it('rejects missing treinoId', () => {
+    const { treinoId, ...rest } = validHistoricoTreinoBase();
+    expect(() => HistoricoTreinoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects missing dataExecucao', () => {
+    const { dataExecucao, ...rest } = validHistoricoTreinoBase();
+    expect(() => HistoricoTreinoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects duracaoMinutos below 1', () => {
+    expect(() =>
+      HistoricoTreinoBaseSchema.parse({ ...validHistoricoTreinoBase(), duracaoMinutos: 0 })
+    ).toThrow();
+  });
+
+  it('rejects missing exercicios', () => {
+    const { exercicios, ...rest } = validHistoricoTreinoBase();
+    expect(() => HistoricoTreinoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects invalid exercise UUID in nested object', () => {
+    const data = {
+      ...validHistoricoTreinoBase(),
+      exercicios: [
+        {
+          exercicioId: 'bad-uuid',
+          nomeExercicio: 'Supino',
+          seriesExecutadas: [],
+        },
+      ],
+    };
+    expect(() => HistoricoTreinoBaseSchema.parse(data)).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<HistoricoTreinoBase>().toHaveProperty('alunoId');
+    expectTypeOf<HistoricoTreinoBase>().toHaveProperty('exercicios');
+  });
+});
+
+// --- HistoricoTreinoSchema ---
+
+describe('HistoricoTreinoSchema', () => {
+  it('accepts valid data with id', () => {
+    const result = HistoricoTreinoSchema.parse(validHistoricoTreino());
+    expect(result.id).toBe(UUID4);
+    expect(result.exercicios[0].seriesExecutadas[0].id).toBe(UUID);
+  });
+
+  it('rejects missing id', () => {
+    expect(() => HistoricoTreinoSchema.parse(validHistoricoTreinoBase())).toThrow();
+  });
+
+  it('rejects invalid UUID', () => {
+    expect(() => HistoricoTreinoSchema.parse({ ...validHistoricoTreino(), id: 'bad' })).toThrow();
+  });
+
+  it('rejects invalid nested serie id', () => {
+    const data = {
+      ...validHistoricoTreino(),
+      exercicios: [
+        {
+          exercicioId: UUID3,
+          nomeExercicio: 'Supino',
+          seriesExecutadas: [{ ...validSerieExecutada(), id: 'bad-uuid' }],
+        },
+      ],
+    };
+    expect(() => HistoricoTreinoSchema.parse(data)).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<HistoricoTreino>().toHaveProperty('id');
+    expectTypeOf<HistoricoTreino>().toHaveProperty('exercicios');
+  });
+});
+
+// --- PlanoBaseSchema ---
+
+describe('PlanoBaseSchema', () => {
+  it('accepts valid data', () => {
+    const result = PlanoBaseSchema.parse(validPlanoBase());
+    expect(result.nome).toBe('Plano Anual');
+    expect(result.preco).toBe(199.9);
+    expect(result.duracaoDias).toBe(365);
+  });
+
+  it('accepts zero preco', () => {
+    const result = PlanoBaseSchema.parse({ ...validPlanoBase(), preco: 0 });
+    expect(result.preco).toBe(0);
+  });
+
+  it('coerces string values to numbers', () => {
+    const data = { nome: 'Plano', preco: '99.9', duracaoDias: '30' };
+    const result = PlanoBaseSchema.parse(data);
+    expect(result.preco).toBe(99.9);
+    expect(result.duracaoDias).toBe(30);
+  });
+
+  it('rejects missing nome', () => {
+    const { nome, ...rest } = validPlanoBase();
+    expect(() => PlanoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects nome shorter than 2 chars', () => {
+    expect(() => PlanoBaseSchema.parse({ ...validPlanoBase(), nome: 'A' })).toThrow();
+  });
+
+  it('rejects missing preco', () => {
+    const { preco, ...rest } = validPlanoBase();
+    expect(() => PlanoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects negative preco', () => {
+    expect(() => PlanoBaseSchema.parse({ ...validPlanoBase(), preco: -10 })).toThrow();
+  });
+
+  it('rejects missing duracaoDias', () => {
+    const { duracaoDias, ...rest } = validPlanoBase();
+    expect(() => PlanoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects zero duracaoDias', () => {
+    expect(() => PlanoBaseSchema.parse({ ...validPlanoBase(), duracaoDias: 0 })).toThrow();
+  });
+
+  it('rejects negative duracaoDias', () => {
+    expect(() => PlanoBaseSchema.parse({ ...validPlanoBase(), duracaoDias: -1 })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<PlanoBase>().toHaveProperty('nome');
+    expectTypeOf<PlanoBase>().toHaveProperty('preco');
+    expectTypeOf<PlanoBase>().toHaveProperty('duracaoDias');
+  });
+});
+
+// --- PlanoSchema ---
+
+describe('PlanoSchema', () => {
+  it('accepts valid data with id', () => {
+    const result = PlanoSchema.parse(validPlano());
+    expect(result.id).toBe(UUID);
+  });
+
+  it('rejects missing id', () => {
+    expect(() => PlanoSchema.parse(validPlanoBase())).toThrow();
+  });
+
+  it('rejects invalid UUID', () => {
+    expect(() => PlanoSchema.parse({ ...validPlano(), id: 'bad' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<Plano>().toHaveProperty('id');
+    expectTypeOf<Plano>().toHaveProperty('nome');
+  });
+});
+
+// --- MatriculaBaseSchema ---
+
+describe('MatriculaBaseSchema', () => {
+  it('accepts valid data with default status', () => {
+    const result = MatriculaBaseSchema.parse(validMatriculaBase());
+    expect(result.status).toBe('ATIVA');
+  });
+
+  it('accepts explicit status ATIVA', () => {
+    const data = { ...validMatriculaBase(), status: 'ATIVA' as const };
+    const result = MatriculaBaseSchema.parse(data);
+    expect(result.status).toBe('ATIVA');
+  });
+
+  it('accepts explicit status VENCIDA', () => {
+    const data = { ...validMatriculaBase(), status: 'VENCIDA' as const };
+    const result = MatriculaBaseSchema.parse(data);
+    expect(result.status).toBe('VENCIDA');
+  });
+
+  it('accepts Date objects for dates', () => {
+    const data = {
+      ...validMatriculaBase(),
+      dataInicio: new Date('2025-01-01'),
+      dataVencimento: new Date('2025-12-31'),
+    };
+    const result = MatriculaBaseSchema.parse(data);
+    expect(result.dataInicio).toBeInstanceOf(Date);
+  });
+
+  it('rejects invalid status value', () => {
+    expect(() =>
+      MatriculaBaseSchema.parse({ ...validMatriculaBase(), status: 'CANCELADA' })
+    ).toThrow();
+  });
+
+  it('rejects missing alunoId', () => {
+    const { alunoId, ...rest } = validMatriculaBase();
+    expect(() => MatriculaBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects missing planoId', () => {
+    const { planoId, ...rest } = validMatriculaBase();
+    expect(() => MatriculaBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects missing dataInicio', () => {
+    const { dataInicio, ...rest } = validMatriculaBase();
+    expect(() => MatriculaBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects missing dataVencimento', () => {
+    const { dataVencimento, ...rest } = validMatriculaBase();
+    expect(() => MatriculaBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects invalid UUID for alunoId', () => {
+    expect(() => MatriculaBaseSchema.parse({ ...validMatriculaBase(), alunoId: 'bad' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<MatriculaBase>().toHaveProperty('alunoId');
+    expectTypeOf<MatriculaBase>().toHaveProperty('status');
+  });
+});
+
+// --- MatriculaSchema ---
+
+describe('MatriculaSchema', () => {
+  it('accepts valid data with id', () => {
+    const result = MatriculaSchema.parse(validMatricula());
+    expect(result.id).toBe(UUID3);
+  });
+
+  it('rejects missing id', () => {
+    expect(() => MatriculaSchema.parse(validMatriculaBase())).toThrow();
+  });
+
+  it('rejects invalid UUID', () => {
+    expect(() => MatriculaSchema.parse({ ...validMatricula(), id: 'bad' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<Matricula>().toHaveProperty('id');
+    expectTypeOf<Matricula>().toHaveProperty('alunoId');
+  });
+});
+
+// --- PagamentoBaseSchema ---
+
+describe('PagamentoBaseSchema', () => {
+  it('accepts valid data with metodo PIX', () => {
+    const result = PagamentoBaseSchema.parse(validPagamentoBase());
+    expect(result.metodo).toBe('PIX');
+    expect(result.valor).toBe(199.9);
+  });
+
+  it('accepts metodo Dinheiro', () => {
+    const data = { ...validPagamentoBase(), metodo: 'Dinheiro' as const };
+    expect(PagamentoBaseSchema.parse(data).metodo).toBe('Dinheiro');
+  });
+
+  it('accepts metodo Cartão', () => {
+    const data = { ...validPagamentoBase(), metodo: 'Cartão' as const };
+    expect(PagamentoBaseSchema.parse(data).metodo).toBe('Cartão');
+  });
+
+  it('accepts zero valor', () => {
+    const result = PagamentoBaseSchema.parse({ ...validPagamentoBase(), valor: 0 });
+    expect(result.valor).toBe(0);
+  });
+
+  it('coerces valor from string', () => {
+    const result = PagamentoBaseSchema.parse({ ...validPagamentoBase(), valor: '150' });
+    expect(result.valor).toBe(150);
+  });
+
+  it('accepts Date for dataPagamento', () => {
+    const data = { ...validPagamentoBase(), dataPagamento: new Date() };
+    expect(() => PagamentoBaseSchema.parse(data)).not.toThrow();
+  });
+
+  it('rejects invalid metodo', () => {
+    expect(() =>
+      PagamentoBaseSchema.parse({ ...validPagamentoBase(), metodo: 'Boleto' })
+    ).toThrow();
+  });
+
+  it('rejects negative valor', () => {
+    expect(() => PagamentoBaseSchema.parse({ ...validPagamentoBase(), valor: -1 })).toThrow();
+  });
+
+  it('rejects missing matriculaId', () => {
+    const { matriculaId, ...rest } = validPagamentoBase();
+    expect(() => PagamentoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects missing alunoId', () => {
+    const { alunoId, ...rest } = validPagamentoBase();
+    expect(() => PagamentoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects missing dataPagamento', () => {
+    const { dataPagamento, ...rest } = validPagamentoBase();
+    expect(() => PagamentoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('rejects missing metodo', () => {
+    const { metodo, ...rest } = validPagamentoBase();
+    expect(() => PagamentoBaseSchema.parse(rest)).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<PagamentoBase>().toHaveProperty('metodo');
+    expectTypeOf<PagamentoBase>().toHaveProperty('valor');
+  });
+});
+
+// --- PagamentoSchema ---
+
+describe('PagamentoSchema', () => {
+  it('accepts valid data with id', () => {
+    const result = PagamentoSchema.parse(validPagamento());
+    expect(result.id).toBe(UUID3);
+  });
+
+  it('rejects missing id', () => {
+    expect(() => PagamentoSchema.parse(validPagamentoBase())).toThrow();
+  });
+
+  it('rejects invalid UUID', () => {
+    expect(() => PagamentoSchema.parse({ ...validPagamento(), id: 'bad' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<Pagamento>().toHaveProperty('id');
+    expectTypeOf<Pagamento>().toHaveProperty('metodo');
+  });
+});
+
+// --- GrowthDataSchema ---
+
+describe('GrowthDataSchema', () => {
+  it('accepts valid data', () => {
+    const result = GrowthDataSchema.parse({ mes: 'Janeiro', alunos: 120 });
+    expect(result.mes).toBe('Janeiro');
+    expect(result.alunos).toBe(120);
+  });
+
+  it('accepts zero alunos', () => {
+    const result = GrowthDataSchema.parse({ mes: 'Fevereiro', alunos: 0 });
+    expect(result.alunos).toBe(0);
+  });
+
+  it('rejects missing mes', () => {
+    expect(() => GrowthDataSchema.parse({ alunos: 10 })).toThrow();
+  });
+
+  it('rejects missing alunos', () => {
+    expect(() => GrowthDataSchema.parse({ mes: 'Janeiro' })).toThrow();
+  });
+
+  it('rejects non-integer alunos', () => {
+    expect(() => GrowthDataSchema.parse({ mes: 'Janeiro', alunos: 1.5 })).toThrow();
+  });
+
+  it('rejects string alunos', () => {
+    expect(() => GrowthDataSchema.parse({ mes: 'Janeiro', alunos: 'abc' })).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<GrowthData>().toHaveProperty('mes');
+    expectTypeOf<GrowthData>().toHaveProperty('alunos');
+  });
+});
+
+// --- DashboardStatsSchema ---
+
+describe('DashboardStatsSchema', () => {
+  it('accepts empty object (all fields have defaults)', () => {
+    const result = DashboardStatsSchema.parse({});
+    expect(result.totalAlunos).toBe(0);
+    expect(result.matriculasAtivas).toBe(0);
+    expect(result.alunosInadimplentes).toBe(0);
+    expect(result.faturamentoMensal).toBe(0);
+    expect(result.crescimentoAnual).toEqual([]);
+  });
+
+  it('accepts full data', () => {
+    const data = {
+      totalAlunos: 150,
+      matriculasAtivas: 120,
+      alunosInadimplentes: 10,
+      faturamentoMensal: 15000,
+      crescimentoAnual: [
+        { mes: 'Janeiro', alunos: 100 },
+        { mes: 'Fevereiro', alunos: 110 },
+      ],
+    };
+    const result = DashboardStatsSchema.parse(data);
+    expect(result.totalAlunos).toBe(150);
+    expect(result.crescimentoAnual).toHaveLength(2);
+  });
+
+  it('rejects non-integer totalAlunos', () => {
+    expect(() => DashboardStatsSchema.parse({ totalAlunos: 1.5 })).toThrow();
+  });
+
+  it('rejects non-integer matriculasAtivas', () => {
+    expect(() => DashboardStatsSchema.parse({ matriculasAtivas: 1.5 })).toThrow();
+  });
+
+  it('rejects non-integer alunosInadimplentes', () => {
+    expect(() => DashboardStatsSchema.parse({ alunosInadimplentes: 1.5 })).toThrow();
+  });
+
+  it('rejects invalid crescimentoAnual entry', () => {
+    expect(() =>
+      DashboardStatsSchema.parse({
+        crescimentoAnual: [{ mes: 'Janeiro' }],
+      })
+    ).toThrow();
+  });
+
+  it('infers correct type', () => {
+    expectTypeOf<DashboardStats>().toHaveProperty('totalAlunos');
+    expectTypeOf<DashboardStats>().toHaveProperty('crescimentoAnual');
+  });
+});
+
+// --- V_FaturamentoMensalSchema ---
+
+describe('V_FaturamentoMensalSchema', () => {
+  it('accepts valid data', () => {
+    const result = V_FaturamentoMensalSchema.parse({
+      Mes: 'Janeiro',
+      TotalRecebido: 15000,
+      QtdPagamentos: 50,
+    });
+    expect(result.Mes).toBe('Janeiro');
+    expect(result.QtdPagamentos).toBe(50);
+  });
+
+  it('coerces QtdPagamentos from string', () => {
+    const result = V_FaturamentoMensalSchema.parse({
+      Mes: 'Janeiro',
+      TotalRecebido: 15000,
+      QtdPagamentos: '50',
+    });
+    expect(result.QtdPagamentos).toBe(50);
+  });
+
+  it('rejects missing Mes', () => {
+    expect(() =>
+      V_FaturamentoMensalSchema.parse({ TotalRecebido: 15000, QtdPagamentos: 50 })
+    ).toThrow();
+  });
+
+  it('rejects missing TotalRecebido', () => {
+    expect(() => V_FaturamentoMensalSchema.parse({ Mes: 'Janeiro', QtdPagamentos: 50 })).toThrow();
+  });
+
+  it('rejects missing QtdPagamentos', () => {
+    expect(() =>
+      V_FaturamentoMensalSchema.parse({ Mes: 'Janeiro', TotalRecebido: 15000 })
+    ).toThrow();
+  });
+
+  it('rejects non-numeric TotalRecebido', () => {
+    expect(() =>
+      V_FaturamentoMensalSchema.parse({ Mes: 'Janeiro', TotalRecebido: 'abc', QtdPagamentos: 50 })
+    ).toThrow();
+  });
+});
+
+// --- V_FrequenciaAlunosSchema ---
+
+describe('V_FrequenciaAlunosSchema', () => {
+  it('accepts valid data', () => {
+    const result = V_FrequenciaAlunosSchema.parse({
+      nomeCompleto: 'Maria Santos',
+      TotalTreinos: 20,
+    });
+    expect(result.nomeCompleto).toBe('Maria Santos');
+    expect(result.TotalTreinos).toBe(20);
+  });
+
+  it('coerces TotalTreinos from string', () => {
+    const result = V_FrequenciaAlunosSchema.parse({
+      nomeCompleto: 'Maria Santos',
+      TotalTreinos: '20',
+    });
+    expect(result.TotalTreinos).toBe(20);
+  });
+
+  it('rejects missing nomeCompleto', () => {
+    expect(() => V_FrequenciaAlunosSchema.parse({ TotalTreinos: 20 })).toThrow();
+  });
+
+  it('rejects missing TotalTreinos', () => {
+    expect(() => V_FrequenciaAlunosSchema.parse({ nomeCompleto: 'Maria Santos' })).toThrow();
+  });
+
+  it('rejects non-numeric TotalTreinos', () => {
+    expect(() =>
+      V_FrequenciaAlunosSchema.parse({ nomeCompleto: 'Maria Santos', TotalTreinos: 'abc' })
+    ).toThrow();
+  });
+});
diff --git a/src/lib/dummyDb.test.ts b/src/lib/dummyDb.test.ts
new file mode 100644
index 00000000..dd42dcf6
--- /dev/null
+++ b/src/lib/dummyDb.test.ts
@@ -0,0 +1,98 @@
+import { describe, it, expect } from 'vitest';
+import { db } from './dummyDb';
+
+describe('dummyDb', () => {
+  describe('insert', () => {
+    it('returns the inserted data', async () => {
+      const data = { name: 'Test User', email: 'test@test.com' };
+      const result = await db.insert('users', data);
+      expect(result).toEqual(data);
+    });
+
+    it('works with string data', async () => {
+      const result = await db.insert('logs', 'log entry');
+      expect(result).toBe('log entry');
+    });
+
+    it('works with number data', async () => {
+      const result = await db.insert('counters', 42);
+      expect(result).toBe(42);
+    });
+
+    it('works with array data', async () => {
+      const data = [1, 2, 3];
+      const result = await db.insert('lists', data);
+      expect(result).toEqual([1, 2, 3]);
+    });
+
+    it('works with empty object', async () => {
+      const result = await db.insert('empty', {});
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('findById', () => {
+    it('returns object with id field', async () => {
+      const result = await db.findById<{ id: string }>('users', 'abc-123');
+      expect(result).toEqual({ id: 'abc-123' });
+    });
+
+    it('returns object with string id', async () => {
+      const result = await db.findById<{ id: string }>('users', 'user-42');
+      expect(result?.id).toBe('user-42');
+    });
+
+    it('works with any table name', async () => {
+      const result = await db.findById<{ id: string }>('any_table', 'id-1');
+      expect(result).toEqual({ id: 'id-1' });
+    });
+  });
+
+  describe('update', () => {
+    it('merges id with partial data', async () => {
+      const result = await db.update<{ id: string; name: string }>('users', 'abc-123', {
+        name: 'Updated',
+      });
+      expect(result).toEqual({ id: 'abc-123', name: 'Updated' });
+    });
+
+    it('overwrites existing fields', async () => {
+      const result = await db.update<{ id: string; name: string }>('users', 'abc-123', {
+        id: 'different-id',
+        name: 'Test',
+      });
+      expect(result.id).toBe('different-id');
+      expect(result.name).toBe('Test');
+    });
+
+    it('returns just id when data is empty', async () => {
+      const result = await db.update('users', 'abc-123', {});
+      expect(result).toEqual({ id: 'abc-123' });
+    });
+
+    it('handles partial updates with multiple fields', async () => {
+      const result = await db.update<{ id: string; a: number; b: number }>('t', '1', {
+        a: 10,
+        b: 20,
+      });
+      expect(result).toEqual({ id: '1', a: 10, b: 20 });
+    });
+  });
+
+  describe('delete', () => {
+    it('returns true on delete', async () => {
+      const result = await db.delete('users', 'abc-123');
+      expect(result).toBe(true);
+    });
+
+    it('returns true for any id', async () => {
+      const result = await db.delete('users', 'any-id');
+      expect(result).toBe(true);
+    });
+
+    it('returns true for any table', async () => {
+      const result = await db.delete('any_table', 'any-id');
+      expect(result).toBe(true);
+    });
+  });
+});
diff --git a/src/lib/exercise-options.test.ts b/src/lib/exercise-options.test.ts
new file mode 100644
index 00000000..66ee2a1e
--- /dev/null
+++ b/src/lib/exercise-options.test.ts
@@ -0,0 +1,130 @@
+import { describe, it, expect } from 'vitest';
+import {
+  exerciciosOptions,
+  flatExerciciosOptions,
+  exercicioDescriptionsMap,
+  DEFAULT_EXERCISE,
+} from './exercise-options';
+import { EXERCICIOS_POR_GRUPO } from './constants';
+
+describe('exerciciosOptions', () => {
+  it('is a non-empty array', () => {
+    expect(Array.isArray(exerciciosOptions)).toBe(true);
+    expect(exerciciosOptions.length).toBeGreaterThan(0);
+  });
+
+  it('has the same number of groups as EXERCICIOS_POR_GRUPO', () => {
+    expect(exerciciosOptions.length).toBe(EXERCICIOS_POR_GRUPO.length);
+  });
+
+  it('each entry has a label matching the group name and a non-empty options array', () => {
+    for (let i = 0; i < EXERCICIOS_POR_GRUPO.length; i++) {
+      const option = exerciciosOptions[i];
+      expect(option.label).toBe(EXERCICIOS_POR_GRUPO[i].grupo);
+      expect(Array.isArray(option.options)).toBe(true);
+      expect(option.options.length).toBe(EXERCICIOS_POR_GRUPO[i].exercicios.length);
+    }
+  });
+
+  it('each sub-option has value, label, and keywords', () => {
+    for (const group of exerciciosOptions) {
+      for (const opt of group.options) {
+        expect(typeof opt.value).toBe('string');
+        expect(opt.value.length).toBeGreaterThan(0);
+        expect(typeof opt.label).toBe('string');
+        expect(opt.label.length).toBeGreaterThan(0);
+        expect(Array.isArray(opt.keywords)).toBe(true);
+        expect(opt.keywords.length).toBeGreaterThan(0);
+      }
+    }
+  });
+});
+
+describe('flatExerciciosOptions', () => {
+  it('is a non-empty array', () => {
+    expect(Array.isArray(flatExerciciosOptions)).toBe(true);
+    expect(flatExerciciosOptions.length).toBeGreaterThan(0);
+  });
+
+  it('contains the total count of all exercises across groups', () => {
+    const totalExercises = EXERCICIOS_POR_GRUPO.reduce((sum, g) => sum + g.exercicios.length, 0);
+    expect(flatExerciciosOptions.length).toBe(totalExercises);
+  });
+
+  it('each entry has value, label, and description', () => {
+    for (const opt of flatExerciciosOptions) {
+      expect(typeof opt.value).toBe('string');
+      expect(typeof opt.label).toBe('string');
+      expect(typeof opt.description).toBe('string');
+    }
+  });
+
+  it('value and label are identical for each entry', () => {
+    for (const opt of flatExerciciosOptions) {
+      expect(opt.value).toBe(opt.label);
+    }
+  });
+});
+
+describe('exercicioDescriptionsMap', () => {
+  it('is a Map instance', () => {
+    expect(exercicioDescriptionsMap).toBeInstanceOf(Map);
+  });
+
+  it('has entries for all exercises in flatExerciciosOptions', () => {
+    expect(exercicioDescriptionsMap.size).toBe(flatExerciciosOptions.length);
+  });
+
+  it('maps each exercise name to its description', () => {
+    for (const opt of flatExerciciosOptions) {
+      expect(exercicioDescriptionsMap.has(opt.value)).toBe(true);
+      expect(exercicioDescriptionsMap.get(opt.value)).toBe(opt.description);
+    }
+  });
+});
+
+describe('DEFAULT_EXERCISE', () => {
+  it('has the expected default structure', () => {
+    expect(DEFAULT_EXERCISE).toEqual({
+      nomeExercicio: '',
+      series: 3,
+      repeticoes: '10-12',
+      observacoes: '',
+      descricao: '',
+    });
+  });
+
+  it('has series as a positive number', () => {
+    expect(typeof DEFAULT_EXERCISE.series).toBe('number');
+    expect(DEFAULT_EXERCISE.series).toBeGreaterThanOrEqual(1);
+  });
+
+  it('has nomeExercicio as a string', () => {
+    expect(typeof DEFAULT_EXERCISE.nomeExercicio).toBe('string');
+  });
+
+  it('has repeticoes as a non-empty string', () => {
+    expect(typeof DEFAULT_EXERCISE.repeticoes).toBe('string');
+    expect(DEFAULT_EXERCISE.repeticoes.length).toBeGreaterThan(0);
+  });
+});
+
+describe('cross-reference: flatExerciciosOptions ↔ EXERCICIOS_POR_GRUPO', () => {
+  it('every flat option value exists as nomeExercicio in EXERCICIOS_POR_GRUPO', () => {
+    const allNames = EXERCICIOS_POR_GRUPO.flatMap((g) =>
+      g.exercicios.map((ex) => ex.nomeExercicio)
+    );
+    for (const opt of flatExerciciosOptions) {
+      expect(allNames).toContain(opt.value);
+    }
+  });
+
+  it('every EXERCICIOS_POR_GRUPO exercise appears in flatExerciciosOptions', () => {
+    const flatValues = new Set(flatExerciciosOptions.map((o) => o.value));
+    for (const group of EXERCICIOS_POR_GRUPO) {
+      for (const ex of group.exercicios) {
+        expect(flatValues.has(ex.nomeExercicio)).toBe(true);
+      }
+    }
+  });
+});
diff --git a/src/lib/logger.test.ts b/src/lib/logger.test.ts
new file mode 100644
index 00000000..fc6a1aa9
--- /dev/null
+++ b/src/lib/logger.test.ts
@@ -0,0 +1,183 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('@sentry/nextjs', () => ({
+  addBreadcrumb: vi.fn(),
+  captureException: vi.fn(),
+  captureMessage: vi.fn(),
+}));
+
+import * as Sentry from '@sentry/nextjs';
+import { Logger } from './logger';
+
+const mockAddBreadcrumb = vi.mocked(Sentry.addBreadcrumb);
+const mockCaptureException = vi.mocked(Sentry.captureException);
+const mockCaptureMessage = vi.mocked(Sentry.captureMessage);
+
+describe('Logger', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    vi.spyOn(console, 'warn').mockImplementation(() => undefined);
+    vi.spyOn(console, 'error').mockImplementation(() => undefined);
+    vi.spyOn(console, 'debug').mockImplementation(() => undefined);
+  });
+
+  describe('info', () => {
+    it('logs to console and creates Sentry breadcrumb', () => {
+      Logger.info('Server started');
+
+      // eslint-disable-next-line no-console
+      expect(console.log).toHaveBeenCalledWith('[INFO] Server started', '');
+      expect(mockAddBreadcrumb).toHaveBeenCalledWith({
+        category: 'log',
+        message: 'Server started',
+        level: 'info',
+        data: {},
+      });
+    });
+
+    it('passes context to Sentry breadcrumb when provided', () => {
+      Logger.info('Action performed', { userId: '123', action: 'login' });
+
+      expect(mockAddBreadcrumb).toHaveBeenCalledWith({
+        category: 'log',
+        message: 'Action performed',
+        level: 'info',
+        data: { userId: '123', action: 'login' },
+      });
+    });
+
+    it('skips console.log in production', () => {
+      Object.defineProperty(Logger, 'isProduction', { value: true, configurable: true });
+
+      Logger.info('Production message');
+
+      // eslint-disable-next-line no-console
+      expect(console.log).not.toHaveBeenCalled();
+      expect(mockAddBreadcrumb).toHaveBeenCalled();
+
+      Object.defineProperty(Logger, 'isProduction', {
+        value: process.env.NODE_ENV === 'production',
+        configurable: true,
+      });
+    });
+  });
+
+  describe('warn', () => {
+    it('logs to console.warn and creates Sentry breadcrumb', () => {
+      Logger.warn('Disk space low');
+
+      // eslint-disable-next-line no-console
+      expect(console.warn).toHaveBeenCalledWith('[WARN] Disk space low', '');
+      expect(mockAddBreadcrumb).toHaveBeenCalledWith({
+        category: 'log',
+        message: 'Disk space low',
+        level: 'warning',
+        data: {},
+      });
+    });
+
+    it('includes context in breadcrumb', () => {
+      Logger.warn('Memory high', { usage: '85%' });
+
+      expect(mockAddBreadcrumb).toHaveBeenCalledWith({
+        category: 'log',
+        message: 'Memory high',
+        level: 'warning',
+        data: { usage: '85%' },
+      });
+    });
+
+    it('always logs to console (even in production)', () => {
+      vi.stubEnv('NODE_ENV', 'production');
+
+      Logger.warn('Always visible');
+
+      // eslint-disable-next-line no-console
+      expect(console.warn).toHaveBeenCalled();
+      vi.unstubAllEnvs();
+    });
+  });
+
+  describe('error', () => {
+    it('logs to console.error', () => {
+      Logger.error('Something failed');
+
+      // eslint-disable-next-line no-console
+      expect(console.error).toHaveBeenCalledWith('[ERROR] Something failed', '');
+    });
+
+    it('captures Error instance via Sentry.captureException', () => {
+      const err = new Error('DB connection failed');
+      Logger.error('DB error', err);
+
+      expect(mockCaptureException).toHaveBeenCalledWith(err, {
+        extra: {
+          logMessage: 'DB error',
+          message: 'DB connection failed',
+          name: 'Error',
+          stack: err.stack,
+        },
+      });
+    });
+
+    it('captures non-Error via Sentry.captureMessage', () => {
+      Logger.error('String error', 'unknown failure');
+
+      expect(mockCaptureMessage).toHaveBeenCalledWith('String error', {
+        level: 'error',
+        extra: { error: 'unknown failure' },
+      });
+    });
+
+    it('captures when no error is provided', () => {
+      Logger.error('Just a message');
+
+      expect(mockCaptureMessage).toHaveBeenCalledWith('Just a message', {
+        level: 'error',
+        extra: { error: undefined },
+      });
+    });
+
+    it('captures plain object errors via captureMessage', () => {
+      const objError = { code: 'E001', details: 'timeout' };
+      Logger.error('Obj error', objError);
+
+      expect(mockCaptureMessage).toHaveBeenCalledWith('Obj error', {
+        level: 'error',
+        extra: { error: objError },
+      });
+    });
+  });
+
+  describe('debug', () => {
+    it('logs to console.debug', () => {
+      Logger.debug('Variable state', { x: 1 });
+
+      // eslint-disable-next-line no-console
+      expect(console.debug).toHaveBeenCalledWith('[DEBUG] Variable state', { x: 1 });
+    });
+
+    it('does not call Sentry', () => {
+      Logger.debug('Internal trace');
+
+      expect(mockAddBreadcrumb).not.toHaveBeenCalled();
+      expect(mockCaptureException).not.toHaveBeenCalled();
+      expect(mockCaptureMessage).not.toHaveBeenCalled();
+    });
+
+    it('skips console.debug in production', () => {
+      Object.defineProperty(Logger, 'isProduction', { value: true, configurable: true });
+
+      Logger.debug('Hidden in prod');
+
+      // eslint-disable-next-line no-console
+      expect(console.debug).not.toHaveBeenCalled();
+
+      Object.defineProperty(Logger, 'isProduction', {
+        value: process.env.NODE_ENV === 'production',
+        configurable: true,
+      });
+    });
+  });
+});
diff --git a/src/lib/prisma.test.ts b/src/lib/prisma.test.ts
new file mode 100644
index 00000000..b2cc49d8
--- /dev/null
+++ b/src/lib/prisma.test.ts
@@ -0,0 +1,78 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mockPrismaExtend = vi.fn(() => mockExtendedClient);
+const mockExtendedClient = { $extends: mockPrismaExtend };
+
+vi.mock('@prisma/client', () => ({
+  PrismaClient: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    Object.assign(this, mockExtendedClient);
+  }),
+}));
+
+vi.mock('@prisma/adapter-pg', () => ({
+  PrismaPg: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    this.adapter = 'mock-adapter';
+  }),
+}));
+
+vi.mock('pg', () => ({
+  Pool: vi.fn().mockImplementation(function (this: Record<string, unknown>) {
+    this.on = vi.fn();
+  }),
+}));
+
+vi.mock('./logger', () => ({
+  Logger: {
+    error: vi.fn(),
+  },
+}));
+
+describe('prisma singleton', () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    const g = globalThis as unknown as { prisma: undefined };
+    g.prisma = undefined;
+  });
+
+  it('creates a prisma client when none exists', async () => {
+    process.env.DATABASE_URL = 'postgresql://test:test@localhost:5432/test';
+    const { prisma } = await import('./prisma');
+    expect(prisma).toBeDefined();
+  });
+
+  it('returns the same client on subsequent imports (singleton pattern)', async () => {
+    process.env.DATABASE_URL = 'postgresql://test:test@localhost:5432/test';
+    const { prisma: prisma1 } = await import('./prisma');
+    const { prisma: prisma2 } = await import('./prisma');
+    expect(prisma1).toBe(prisma2);
+  });
+
+  it('throws when DATABASE_URL is not set', async () => {
+    delete process.env.DATABASE_URL;
+    await expect(import('./prisma')).rejects.toThrow('DATABASE_URL is not defined');
+  });
+
+  it('computes xpToNextLevel correctly (nivel * 1500)', () => {
+    const compute = (nivel: number | null) => (nivel ?? 1) * 1500;
+    expect(compute(1)).toBe(1500);
+    expect(compute(5)).toBe(7500);
+    expect(compute(10)).toBe(15000);
+    expect(compute(null)).toBe(1500);
+  });
+
+  it('computes progressPerc correctly', () => {
+    const compute = (exp: number | null, nivel: number | null) => {
+      const n = nivel ?? 1;
+      const e = exp ?? 0;
+      const xpReq = n * 1500;
+      return Math.min(Math.round((e / xpReq) * 100), 100);
+    };
+
+    expect(compute(750, 1)).toBe(50);
+    expect(compute(3000, 2)).toBe(100);
+    expect(compute(0, 1)).toBe(0);
+    expect(compute(1500, 3)).toBe(33);
+    expect(compute(null, null)).toBe(0);
+    expect(compute(5000, 1)).toBe(100);
+  });
+});
diff --git a/src/lib/sentry-scrubber.test.ts b/src/lib/sentry-scrubber.test.ts
new file mode 100644
index 00000000..2d3bee3e
--- /dev/null
+++ b/src/lib/sentry-scrubber.test.ts
@@ -0,0 +1,180 @@
+import { describe, it, expect } from 'vitest';
+import { scrub } from './sentry-scrubber';
+
+describe('scrub', () => {
+  it('returns primitives unchanged', () => {
+    expect(scrub('hello')).toBe('hello');
+    expect(scrub(42)).toBe(42);
+    expect(scrub(true)).toBe(true);
+    expect(scrub(null)).toBeNull();
+    expect(scrub(undefined)).toBeUndefined();
+  });
+
+  it('returns empty object unchanged', () => {
+    expect(scrub({})).toEqual({});
+  });
+
+  it('scrubs known PII keys: email, password, token, cpf, etc.', () => {
+    const input = {
+      email: 'user@test.com',
+      password: 'secret123',
+      token: 'jwt-abcd',
+      cpf: '12345678900',
+      rg: '123456',
+      biometria: 'hash-abc',
+      biometriahash: 'hash-def',
+      fotourl: 'http://img.test/photo.jpg',
+      telefone: '11999998888',
+      matricula: '2020001',
+      secret: 'my-secret',
+    };
+
+    const result = scrub(input) as Record<string, unknown>;
+
+    for (const key of Object.keys(input)) {
+      expect(result[key]).toBe('[SCRUBBED]');
+    }
+  });
+
+  it('matches PII keys case-insensitively', () => {
+    const input = {
+      Email: 'a@b.com',
+      PASSWORD: 'pass',
+      Token: 'abc',
+      CPF: '123',
+      Secret: 'xyz',
+    };
+
+    const result = scrub(input) as Record<string, unknown>;
+
+    expect(result.Email).toBe('[SCRUBBED]');
+    expect(result.PASSWORD).toBe('[SCRUBBED]');
+    expect(result.Token).toBe('[SCRUBBED]');
+    expect(result.CPF).toBe('[SCRUBBED]');
+    expect(result.Secret).toBe('[SCRUBBED]');
+  });
+
+  it('preserves non-sensitive keys', () => {
+    const input = {
+      nome: 'João',
+      idade: 25,
+      ativo: true,
+      email: 'a@b.com',
+    };
+
+    const result = scrub(input) as Record<string, unknown>;
+
+    expect(result.nome).toBe('João');
+    expect(result.idade).toBe(25);
+    expect(result.ativo).toBe(true);
+    expect(result.email).toBe('[SCRUBBED]');
+  });
+
+  it('scrubs sensitive keys in nested objects', () => {
+    const input = {
+      user: {
+        name: 'Test',
+        credentials: {
+          password: 'secret',
+          token: 'jwt-123',
+        },
+      },
+    };
+
+    const result = scrub(input) as {
+      user: Record<string, unknown>;
+    };
+
+    expect(result.user.name).toBe('Test');
+    expect((result.user.credentials as Record<string, unknown>).password).toBe('[SCRUBBED]');
+    expect((result.user.credentials as Record<string, unknown>).token).toBe('[SCRUBBED]');
+  });
+
+  it('scrubs sensitive keys inside array items', () => {
+    const input = [
+      { email: 'a@b.com', name: 'A' },
+      { password: 'p', name: 'B' },
+      'plain string',
+      42,
+    ];
+
+    const result = scrub(input) as Array<Record<string, unknown> | string | number>;
+
+    expect((result[0] as Record<string, unknown>).email).toBe('[SCRUBBED]');
+    expect((result[0] as Record<string, unknown>).name).toBe('A');
+    expect((result[1] as Record<string, unknown>).password).toBe('[SCRUBBED]');
+    expect(result[2]).toBe('plain string');
+    expect(result[3]).toBe(42);
+  });
+
+  it('returns [CIRCULAR] for circular references', () => {
+    const obj: Record<string, unknown> = { a: 1 };
+    obj.self = obj;
+
+    const result = scrub(obj) as Record<string, unknown>;
+
+    expect(result.a).toBe(1);
+    expect(result.self).toBe('[CIRCULAR]');
+  });
+
+  it('handles deeply nested circular references', () => {
+    const inner: Record<string, unknown> = {};
+    const obj = { child: { inner } };
+    inner.parent = obj;
+
+    const result = scrub(obj) as { child: { inner: Record<string, unknown> } };
+
+    expect(result.child.inner.parent).toBe('[CIRCULAR]');
+  });
+
+  it('handles complex nested structure with arrays and objects', () => {
+    const input = {
+      logs: [
+        {
+          event: 'login',
+          metadata: {
+            email: 'user@test.com',
+            ip: '1.2.3.4',
+          },
+        },
+        {
+          event: 'update',
+          token: 'bearer-abc',
+          data: ['safe', { password: 'x' }],
+        },
+      ],
+      count: 2,
+    };
+
+    const result = scrub(input) as {
+      logs: Array<Record<string, unknown>>;
+      count: number;
+    };
+
+    expect(result.count).toBe(2);
+    const meta = result.logs[0].metadata as Record<string, unknown>;
+    expect(meta.email).toBe('[SCRUBBED]');
+    expect(meta.ip).toBe('1.2.3.4');
+    expect(result.logs[1].token).toBe('[SCRUBBED]');
+    const arr = result.logs[1].data as unknown[];
+    expect(arr[0]).toBe('safe');
+    expect((arr[1] as Record<string, unknown>).password).toBe('[SCRUBBED]');
+  });
+
+  it('does not mutate the original object', () => {
+    const input = { email: 'a@b.com', name: 'Test' };
+    scrub(input);
+
+    expect(input.email).toBe('a@b.com');
+    expect(input.name).toBe('Test');
+  });
+
+  it('scrubs all keys when every key is sensitive', () => {
+    const input = { email: 'a', password: 'b', token: 'c' };
+    const result = scrub(input) as Record<string, unknown>;
+
+    expect(result.email).toBe('[SCRUBBED]');
+    expect(result.password).toBe('[SCRUBBED]');
+    expect(result.token).toBe('[SCRUBBED]');
+  });
+});
diff --git a/src/utils/supabase/middleware.test.ts b/src/utils/supabase/middleware.test.ts
new file mode 100644
index 00000000..f3fc0f8e
--- /dev/null
+++ b/src/utils/supabase/middleware.test.ts
@@ -0,0 +1,239 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+vi.mock('@supabase/ssr', () => ({
+  createServerClient: vi.fn(() => ({
+    auth: {
+      getUser: vi.fn(),
+    },
+    from: vi.fn(() => ({
+      select: vi.fn().mockReturnThis(),
+      eq: vi.fn().mockReturnThis(),
+      maybeSingle: vi.fn(),
+    })),
+  })),
+}));
+
+vi.mock('next/server', () => {
+  const actual = vi.importActual('next/server');
+  return {
+    ...actual,
+    NextResponse: {
+      next: vi.fn(({ request } = {}) => ({
+        cookies: { set: vi.fn() },
+        headers: request?.headers ?? new Headers(),
+      })),
+      redirect: vi.fn((url: URL) => ({
+        redirectUrl: url.toString(),
+        status: 307,
+      })),
+    },
+  };
+});
+
+vi.mock('@/lib/constants', () => ({
+  FINANCIAL_ROUTES: ['/dashboard/financeiro', '/dashboard/planos'],
+}));
+
+function createMockRequest(pathname: string) {
+  const url = new URL(`http://localhost:3000${pathname}`);
+  const {
+    pathname: _pn,
+    search: _s,
+    hash: _h,
+    ...urlRest
+  } = {
+    href: url.href,
+    origin: url.origin,
+    pathname: url.pathname,
+    search: url.search,
+    hash: url.hash,
+  };
+  return {
+    nextUrl: {
+      pathname,
+      clone: () => ({ ...urlRest, pathname, search: '', hash: '' }),
+      ...urlRest,
+    },
+    headers: new Headers(),
+    cookies: {
+      getAll: vi.fn(() => []),
+    },
+  } as unknown as NextRequest;
+}
+
+import { updateSession } from './middleware';
+import { createServerClient } from '@supabase/ssr';
+
+describe('updateSession middleware', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  function setupAuthMock(options: {
+    user?: { id: string } | null;
+    funcionario?: { role: string | null } | null;
+  }) {
+    const mockSupabase = {
+      auth: {
+        getUser: vi.fn().mockResolvedValue({
+          data: { user: options.user ?? null },
+        }),
+      },
+      from: vi.fn(() => ({
+        select: vi.fn().mockReturnThis(),
+        eq: vi.fn().mockReturnThis(),
+        maybeSingle: vi.fn().mockResolvedValue({
+          data: options.funcionario ?? null,
+        }),
+      })),
+    };
+    vi.mocked(createServerClient).mockReturnValue(mockSupabase as never);
+    return mockSupabase;
+  }
+
+  describe('non-protected routes', () => {
+    it('returns next response for public routes without auth check', async () => {
+      setupAuthMock({ user: null });
+      const request = createMockRequest('/');
+      const response = await updateSession(request);
+      expect(response).toBeDefined();
+    });
+
+    it('returns next response for /login', async () => {
+      setupAuthMock({ user: null });
+      const request = createMockRequest('/login');
+      const response = await updateSession(request);
+      expect(response).toBeDefined();
+    });
+
+    it('returns next response for /aluno/login', async () => {
+      setupAuthMock({ user: null });
+      const request = createMockRequest('/aluno/login');
+      const response = await updateSession(request);
+      expect(response).toBeDefined();
+    });
+  });
+
+  describe('unauthenticated users on protected routes', () => {
+    it('redirects to /login when accessing /dashboard', async () => {
+      setupAuthMock({ user: null });
+      const request = createMockRequest('/dashboard');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+
+    it('redirects to /login when accessing /aluno', async () => {
+      setupAuthMock({ user: null });
+      const request = createMockRequest('/aluno');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+  });
+
+  describe('funcionario accessing aluno routes', () => {
+    it('redirects funcionario from /aluno to /dashboard', async () => {
+      setupAuthMock({
+        user: { id: 'func-1' },
+        funcionario: { role: 'INSTRUTOR' },
+      });
+      const request = createMockRequest('/aluno/meus-treinos');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+  });
+
+  describe('non-funcionario accessing dashboard routes', () => {
+    it('redirects aluno from /dashboard to /aluno', async () => {
+      setupAuthMock({
+        user: { id: 'aluno-1' },
+        funcionario: null,
+      });
+      const request = createMockRequest('/dashboard');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+  });
+
+  describe('financial route access control', () => {
+    it('redirects non-GERENTE funcionario from /dashboard/financeiro', async () => {
+      setupAuthMock({
+        user: { id: 'func-1' },
+        funcionario: { role: 'INSTRUTOR' },
+      });
+      const request = createMockRequest('/dashboard/financeiro');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+
+    it('redirects non-GERENTE funcionario from /dashboard/planos', async () => {
+      setupAuthMock({
+        user: { id: 'func-1' },
+        funcionario: { role: 'RECEPCIONISTA' },
+      });
+      const request = createMockRequest('/dashboard/planos');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+
+    it('allows GERENTE access to financial routes', async () => {
+      setupAuthMock({
+        user: { id: 'gerente-1' },
+        funcionario: { role: 'GERENTE' },
+      });
+      const request = createMockRequest('/dashboard/financeiro');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).not.toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+  });
+
+  describe('authorized access', () => {
+    it('allows funcionario to access /dashboard', async () => {
+      setupAuthMock({
+        user: { id: 'func-1' },
+        funcionario: { role: 'INSTRUTOR' },
+      });
+      const request = createMockRequest('/dashboard');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).not.toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+
+    it('allows aluno to access /aluno', async () => {
+      setupAuthMock({
+        user: { id: 'aluno-1' },
+        funcionario: null,
+      });
+      const request = createMockRequest('/aluno/meus-treinos');
+      const response = await updateSession(request);
+      expect(NextResponse.redirect).not.toHaveBeenCalled();
+      expect(response).toBeDefined();
+    });
+  });
+
+  describe('supabase client creation', () => {
+    it('creates supabase client with cookie handlers', async () => {
+      setupAuthMock({ user: null });
+      const request = createMockRequest('/dashboard');
+      await updateSession(request);
+      expect(createServerClient).toHaveBeenCalledTimes(1);
+      const callArgs = vi.mocked(createServerClient).mock.calls[0];
+      expect(callArgs[2]).toEqual(
+        expect.objectContaining({
+          cookies: expect.objectContaining({
+            getAll: expect.any(Function),
+            setAll: expect.any(Function),
+          }),
+        })
+      );
+    });
+  });
+});