Тестування Data Access Layer (DAL) та кешування

Вхідний виклик із RSC
                                          │
                                          ▼
+-------------------------------------------------------------------------------+
| Рівень 1: React.cache() (Per-Request Memoization)                             |
| Життєвий цикл: 1 HTTP-запит. Дедуплікація за посилальною ідентичністю аргументів|
+-------------------------------------------------------------------------------+
     │ (Cache Miss)                                      │ (Cache Hit: той самий реквест)
     ▼                                                   ▼
+---------------------------------------------------+  Повернення з пам'яті
| Рівень 2: unstable_cache() (Next.js Data Cache)   |  без звернення до рівня 2
| Життєвий цикл: Крос-запитний, теги, TTL           |
+---------------------------------------------------+
     │ (Data Cache Miss)                                 │ (Cache Hit: за тегами/ключами)
     ▼                                                   ▼
+---------------------------------------------------+  Повернення з кешу
| Фізичний Data Access Layer                        |  без виконання SQL
| - Виконання SQL / Drizzle / Prisma                |
| - Перевірка прав поточної сесії                   |
+---------------------------------------------------+
     │
     ▼
[Реальна СУБД: PostgreSQL / MySQL]

import 'server-only';
import { cache } from 'react';
import { unstable_cache } from 'next/cache';
import { db } from '@/lib/db';
import { organizations } from '@/lib/schema';
import { eq } from 'drizzle-orm';

export interface OrganizationDTO {
  id: string;
  name: string;
  plan: 'free' | 'pro' | 'enterprise';
  createdAt: Date;
}

// Низькорівнева вибірка з бази даних
async function fetchOrganizationFromDb(orgId: string): Promise<OrganizationDTO | null> {
  const [record] = await db
    .select({
      id: organizations.id,
      name: organizations.name,
      plan: organizations.plan,
      createdAt: organizations.createdAt,
    })
    .from(organizations)
    .where(eq(organizations.id, orgId))
    .limit(1);

  return record ?? null;
}

// Крос-запитний кеш із тегами інвалідації
export const getCachedOrganization = (orgId: string) =>
  unstable_cache(
    async () => fetchOrganizationFromDb(orgId),
    ['organization-cache-key', orgId],
    {
      revalidate: 3600, // 1 година
      tags: [`org:${orgId}`, 'organizations'],
    }
  )();

// Підсумковий метод DAL із дедуплікацією всередині одного запиту
export const getOrganization = cache(async (orgId: string): Promise<OrganizationDTO | null> => {
  if (!orgId || typeof orgId !== 'string') {
    throw new Error('Некоректний ідентифікатор організації');
  }

  return getCachedOrganization(orgId);
});

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { cache } from 'react';

describe('React.cache (Per-Request Deduplication)', () => {
  it('дедуплікує паралельні виклики з ідентичними аргументами', async () => {
    const rawFetcherMock = vi.fn().mockImplementation(async (id: string) => {
      return { id, name: `Організація ${id}`, plan: 'enterprise' as const };
    });

    // Огортаємо мок у нативний React.cache
    const memoizedFetcher = cache(rawFetcherMock);

    // Симулюємо паралельні запити з різних серверних компонентів у межах одного рендеру
    const [result1, result2, result3] = await Promise.all([
      memoizedFetcher('org-123'),
      memoizedFetcher('org-123'),
      memoizedFetcher('org-123'),
    ]);

    // Перевіряємо еквівалентність результатів
    expect(result1).toEqual(result2);
    expect(result2).toEqual(result3);
    expect(result1.name).toBe('Організація org-123');

    // КЛЮЧОВИЙ АСЕРТ: фізичний виклик fetcher відбувся рівно 1 раз
    expect(rawFetcherMock).toHaveBeenCalledTimes(1);
    expect(rawFetcherMock).toHaveBeenCalledWith('org-123');
  });

  it('виконує окремі виклики для різних аргументів', async () => {
    const rawFetcherMock = vi.fn().mockImplementation(async (id: string) => ({ id }));
    const memoizedFetcher = cache(rawFetcherMock);

    await Promise.all([
      memoizedFetcher('org-A'),
      memoizedFetcher('org-B'),
    ]);

    expect(rawFetcherMock).toHaveBeenCalledTimes(2);
    expect(rawFetcherMock).toHaveBeenNthCalledWith(1, 'org-A');
    expect(rawFetcherMock).toHaveBeenNthCalledWith(2, 'org-B');
  });
});

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { unstable_cache } from 'next/cache';
import * as dbModule from '@/lib/db';

// Мокуємо unstable_cache для перехоплення метаданих конфігурації
vi.mock('next/cache', () => ({
  unstable_cache: vi.fn((fn: () => Promise<unknown>, keyParts?: string[], options?: { revalidate?: number; tags?: string[] }) => {
    // Повертаємо функцію-обгортку, яка надає метадані конфігурації
    return Object.assign(fn, {
      __keyParts: keyParts,
      __options: options,
    });
  }),
  revalidateTag: vi.fn(),
}));

vi.mock('@/lib/db', () => ({
  db: {
    select: vi.fn(),
  },
}));

describe('DAL: unstable_cache Configuration & Security', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('реєструє кеш з унікальним складеним ключем та коректними тегами', async () => {
    const { getCachedOrganization } = await import('./organization');

    getCachedOrganization('org-prod-42');

    // Перевіряємо, що unstable_cache був викликаний з очікуваними параметрами
    expect(unstable_cache).toHaveBeenCalledWith(
      expect.any(Function),
      ['organization-cache-key', 'org-prod-42'],
      {
        revalidate: 3600,
        tags: ['org:org-prod-42', 'organizations'],
      }
    );
  });

  it('гарантує, що ключ кешу запобігає змішуванню даних різних організацій', async () => {
    const { getCachedOrganization } = await import('./organization');

    getCachedOrganization('tenant-alpha');
    getCachedOrganization('tenant-beta');

    const calls = vi.mocked(unstable_cache).mock.calls;

    const keyAlpha = calls[0][1];
    const keyBeta = calls[1][1];

    expect(keyAlpha).toEqual(['organization-cache-key', 'tenant-alpha']);
    expect(keyBeta).toEqual(['organization-cache-key', 'tenant-beta']);
    expect(keyAlpha).not.toEqual(keyBeta);
  });
});

import { describe, it, expect, vi, beforeEach } from 'vitest';
import { updateOrganizationPlan } from './organization-mutations';
import { db } from '@/lib/db';
import { revalidateTag } from 'next/cache';

vi.mock('next/cache', () => ({
  revalidateTag: vi.fn(),
  revalidatePath: vi.fn(),
}));

vi.mock('@/lib/db', () => ({
  db: {
    update: vi.fn().mockReturnThis(),
    set: vi.fn().mockReturnThis(),
    where: vi.fn().mockResolvedValue([{ id: 'org-99' }]),
  },
}));

describe('updateOrganizationPlan Mutation', () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it('інвалідує тег конкретної організації після успішного оновлення', async () => {
    await updateOrganizationPlan('org-99', 'enterprise');

    // Перевіряємо виклик оновлення в БД
    expect(db.update).toHaveBeenCalled();

    // Перевіряємо точкове скидання тегу в Data Cache
    expect(revalidateTag).toHaveBeenCalledWith('org:org-99');
    // Не повинен скидати весь список, якщо оновлюється лише одиничний план
    expect(revalidateTag).not.toHaveBeenCalledWith('all-data');
  });
});