Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

4.2 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { type Session } from "next-auth";
import type * as SharedServer from "@langfuse/shared/src/server";
import { testFeatureFlags } from "@/src/__tests__/fixtures/feature-flags";
import { appRouter } from "@/src/server/api/root";
import { createInnerTRPCContext } from "@/src/server/api/trpc";
import { env } from "@/src/env.mjs";
import { getFeaturePreviewOptOutFlag } from "@/src/features/feature-flags/utils";
import { parseFlagsWithOrganizationDefaults } from "@/src/features/feature-flags/server/parseFlags";

const mocks = vi.hoisted(() => ({
  getObservationsForTraceFromEventsTable: vi.fn(async () => ({
    observations: [],
    totalCount: 0,
  })),
}));

vi.mock("@langfuse/shared/src/server", async (importOriginal) => ({
  ...(await importOriginal<typeof SharedServer>()),
  getObservationsForTraceFromEventsTable:
    mocks.getObservationsForTraceFromEventsTable,
  getTraceByIdFromEventsTable: vi.fn(async () => ({
    id: "trace-id",
    projectId: "project-id",
    timestamp: new Date("2026-01-01"),
    public: false,
    sessionId: null,
    input: null,
    output: null,
  })),
}));

describe("events.transcriptByTraceId preview access", () => {
  const originalExperimentalFeatures =
    env.LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES;
  const originalWriteMode = env.LANGFUSE_MIGRATION_V4_WRITE_MODE;
  beforeEach(() => {
    mocks.getObservationsForTraceFromEventsTable.mockClear();
    Object.assign(env, {
      LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES: "false",
      LANGFUSE_MIGRATION_V4_WRITE_MODE: "events_only",
    });
  });

  afterEach(() => {
    Object.assign(env, {
      LANGFUSE_ENABLE_EXPERIMENTAL_FEATURES: originalExperimentalFeatures,
      LANGFUSE_MIGRATION_V4_WRITE_MODE: originalWriteMode,
    });
  });

  it.each([
    {
      name: "user preview",
      flags: ["sessionViewV2", "sessionViewV2Timeline"],
      defaults: [],
      allowed: true,
    },
    { name: "default preview", flags: [], defaults: [], allowed: true },
    {
      name: "organization default",
      flags: [],
      defaults: ["sessionViewV2", "sessionViewV2Timeline"],
      allowed: true,
    },
    {
      name: "user opt-out",
      flags: [getFeaturePreviewOptOutFlag("sessionViewV2Timeline")],
      defaults: ["sessionViewV2", "sessionViewV2Timeline"],
      allowed: false,
    },
  ])("respects $name", async ({ flags, defaults, allowed }) => {
    const session = {
      expires: "1",
      user: {
        id: "user-id",
        name: "Test User",
        admin: false,
        canCreateOrganizations: true,
        featureFlags: testFeatureFlags(),
        organizations: [
          {
            id: "org-id",
            name: "Test Organization",
            role: "MEMBER",
            plan: "cloud:hobby",
            cloudConfig: undefined,
            metadata: {},
            aiFeaturesEnabled: false,
            aiTelemetryEnabled: false,
            featureFlags: parseFlagsWithOrganizationDefaults(flags, defaults, {
              email: "[email protected]",
              v4BetaEnabled: true,
            }),
            projects: [
              {
                id: "project-id",
                name: "Test Project",
                role: "MEMBER",
                retentionDays: 30,
                deletedAt: null,
                hasTraces: false,
                metadata: {},
                createdAt: new Date().toISOString(),
              },
            ],
          },
        ],
      },
      environment: {
        enableExperimentalFeatures: false,
        selfHostedInstancePlan: null,
      },
    } satisfies Session;
    const caller = appRouter.createCaller(
      createInnerTRPCContext({ session, headers: {} }),
    );
    const result = caller.events.transcriptByTraceId({
      projectId: "project-id",
      traceId: "trace-id",
    });
    if (!allowed) {
      await expect(result).rejects.toMatchObject({ code: "FORBIDDEN" });
      expect(
        mocks.getObservationsForTraceFromEventsTable,
      ).not.toHaveBeenCalled();
      return;
    }
    await expect(result).resolves.toEqual({ transcript: null, cutoff: false });
    expect(mocks.getObservationsForTraceFromEventsTable).toHaveBeenCalledTimes(
      2,
    );
  });
});