Skip to content

armgit / umami

Public Imported from GitHub
0

Umami is a privacy-first web and product analytics platform. Traffic, campaigns, behavior, conversions, and revenue in one place. No cookies, no surveillance, self-hosted or in the cloud.

13.2 KB
Raw Blame
import { expect, test } from './fixtures';
import { UNKNOWN_UUID } from './helpers/constants';
import { dateRange } from './helpers/dates';
import { uniqueName } from './helpers/entities';

/**
 * Global setup records one replay on `seed.website` (see seed/dataset.ts):
 * three rrweb events spanning 20ms in a single chunk. Replay ids are visit ids.
 * Other specs may record extra replays concurrently, so list assertions look for
 * the seeded replay rather than asserting exact counts.
 *
 * Share tokens are rejected on every replay endpoint (session replay is never
 * exposed through public shares).
 */

const REPLAY_EVENT_COUNT = 3;

test.describe('Replays', () => {
  test.describe.configure({ mode: 'serial' });

  let base = '';

  test.beforeAll(({ seed }) => {
    base = `/api/websites/${seed.website.id}`;
  });

  // The seeded replay is shared with other specs: always leave it unsaved.
  test.afterAll(async ({ admin, seed }) => {
    await admin.post(`${base}/replays/saved/${seed.data.replayVisitId}`, { isSaved: false });
  });

  test('GET /api/websites/{websiteId}/replays lists recorded replays', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.get(`${base}/replays`, {
      params: dateRange(seed, { pageSize: 100 }),
    });
    const longOnly = await admin.get(`${base}/replays`, {
      params: dateRange(seed, { minDuration: 60_000, pageSize: 100 }),
    });
    const searched = await admin.get(`${base}/replays`, {
      params: dateRange(seed, { search: 'zzz-no-such-replay' }),
    });
    const shared = await (await share()).get(`${base}/replays`, { params: dateRange(seed) });
    const denied = await viewer.get(`${base}/replays`, { params: dateRange(seed) });
    const missingRange = await admin.get(`${base}/replays`);
    const badDuration = await admin.get(`${base}/replays`, {
      params: dateRange(seed, { minDuration: -1 }),
    });

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      data: expect.any(Array),
      count: expect.any(Number),
      page: 1,
      pageSize: 100,
    });

    const replay = response.body.data.find((row: any) => row.id === seed.data.replayVisitId);
    expect(replay).toEqual({
      id: seed.data.replayVisitId,
      websiteId: seed.website.id,
      sessionId: seed.data.replaySessionId,
      createdAt: expect.any(String),
      startedAt: expect.any(String),
      endedAt: expect.any(String),
      duration: expect.any(Number),
      eventCount: REPLAY_EVENT_COUNT,
      chunkCount: 1,
      browser: 'chrome',
      os: expect.any(String),
      device: expect.any(String),
      // Unresolved geo is null on Postgres but '' on ClickHouse (non-nullable String columns).
      country: seed.db === 'clickhouse' ? '' : null,
      city: seed.db === 'clickhouse' ? '' : null,
    });
    expect(replay.duration).toBe(
      new Date(replay.endedAt).getTime() - new Date(replay.startedAt).getTime(),
    );

    // The seeded replay only lasts 20ms.
    expect(longOnly.status).toBe(200);
    expect(longOnly.body.data.map((row: any) => row.id)).not.toContain(seed.data.replayVisitId);

    expect(searched.status).toBe(200);
    expect(searched.body.data).toHaveLength(0);

    expect(shared.status).toBe(401);
    expect(denied.status).toBe(401);
    expect(missingRange.status).toBe(400);
    expect(badDuration.status).toBe(400);
  });

  test('GET /api/websites/{websiteId}/replays/{replayId} returns the recorded events', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const response = await admin.get(`${base}/replays/${seed.data.replayVisitId}`);
    const shared = await (await share()).get(`${base}/replays/${seed.data.replayVisitId}`);
    const denied = await viewer.get(`${base}/replays/${seed.data.replayVisitId}`);
    const unknown = await admin.get(`${base}/replays/${UNKNOWN_UUID}`);

    expect(response.status).toBe(200);
    expect(response.body).toEqual({
      sessionId: seed.data.replaySessionId,
      events: expect.any(Array),
      startedAt: expect.any(String),
      endedAt: expect.any(String),
      eventCount: REPLAY_EVENT_COUNT,
      chunkCount: 1,
    });
    expect(response.body.events).toHaveLength(REPLAY_EVENT_COUNT);
    expect(response.body.events.map((event: any) => event.type)).toEqual([4, 2, 3]);
    expect(response.body.events[0]).toEqual({
      type: 4,
      data: { href: `https://${seed.data.hostname}/`, width: 1280, height: 800 },
      timestamp: expect.any(Number),
    });
    const timestamps = response.body.events.map((event: any) => event.timestamp);
    // ClickHouse stores replay bounds at second precision; Postgres keeps milliseconds.
    const bound = (value: number) =>
      seed.db === 'clickhouse' ? Math.floor(value / 1000) * 1000 : value;
    expect(bound(timestamps[0])).toBe(new Date(response.body.startedAt).getTime());
    expect(bound(timestamps[timestamps.length - 1])).toBe(
      new Date(response.body.endedAt).getTime(),
    );

    // Unknown replays are an empty recording, not a 404.
    expect(unknown.status).toBe(200);
    expect(unknown.body).toEqual({
      sessionId: null,
      events: [],
      startedAt: null,
      endedAt: null,
      eventCount: 0,
      chunkCount: 0,
    });

    expect(shared.status).toBe(401);
    expect(denied.status).toBe(401);
  });

  test('GET /api/websites/{websiteId}/replays/{replayId} truncates the events with until, chunkIndex and eventIndex', async ({
    admin,
    seed,
  }) => {
    const path = `${base}/replays/${seed.data.replayVisitId}`;
    const full = await admin.get(path);
    const secondTimestamp = full.body.events[1].timestamp;

    // `chunkIndex` is not an ordinal: /api/record stores each chunk under its ingest
    // timestamp in seconds (`timestamp || Date.now() / 1000`), so the parameter is an
    // inclusive upper bound on chunk timestamps.
    const nowSeconds = Math.floor(Date.now() / 1000);
    const startSeconds = Math.floor(new Date(full.body.startedAt).getTime() / 1000);

    const until = await admin.get(path, { params: { until: secondTimestamp } });
    const allChunks = await admin.get(path, { params: { chunkIndex: nowSeconds } });
    const beforeFirstChunk = await admin.get(path, { params: { chunkIndex: startSeconds - 1 } });
    const listed = await admin.get(`${base}/replays`, {
      params: dateRange(seed, { pageSize: 100 }),
    });

    expect(until.status).toBe(200);
    expect(until.body.events.map((event: any) => event.timestamp)).toEqual(
      full.body.events
        .map((event: any) => event.timestamp)
        .filter((timestamp: number) => timestamp <= secondTimestamp),
    );
    expect(until.body.events.length).toBeLessThan(REPLAY_EVENT_COUNT);

    expect(allChunks.status).toBe(200);
    expect(allChunks.body.events).toEqual(full.body.events);
    expect(allChunks.body.chunkCount).toBe(1);

    expect(beforeFirstChunk.status).toBe(200);
    expect(beforeFirstChunk.body).toMatchObject({ events: [], chunkCount: 0 });

    // `eventIndex` only applies to the chunk whose timestamp equals `chunkIndex`. The
    // seeded chunk was ingested without an explicit timestamp, so its key is the ingest
    // second, which sits within a second or two of the replay's `createdAt`.
    const replay = listed.body.data.find((row: any) => row.id === seed.data.replayVisitId);
    const createdSeconds = Math.floor(new Date(replay.createdAt).getTime() / 1000);
    const truncated: any[] = [];

    for (const chunkIndex of [createdSeconds - 2, createdSeconds - 1, createdSeconds]) {
      const response = await admin.get(path, { params: { chunkIndex, eventIndex: 0 } });

      expect(response.status).toBe(200);
      truncated.push(response.body.events);
    }

    expect(truncated).toContainEqual([full.body.events[0]]);
  });

  test('POST /api/websites/{websiteId}/replays/saved/{replayId} saves a replay', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const name = uniqueName('saved-replay');

    // Saving an already-saved replay fails with a unique-constraint 500 (it is not an
    // upsert), so start from a known unsaved state in case an earlier run aborted.
    await admin.post(`${base}/replays/saved/${seed.data.replayVisitId}`, { isSaved: false });

    const response = await admin.post(`${base}/replays/saved/${seed.data.replayVisitId}`, {
      isSaved: true,
      name,
    });
    const shared = await (await share()).post(`${base}/replays/saved/${seed.data.replayVisitId}`, {
      isSaved: true,
    });
    const denied = await viewer.post(`${base}/replays/saved/${seed.data.replayVisitId}`, {
      isSaved: true,
    });
    const missingFlag = await admin.post(`${base}/replays/saved/${seed.data.replayVisitId}`, {
      name,
    });
    const longName = await admin.post(`${base}/replays/saved/${seed.data.replayVisitId}`, {
      isSaved: true,
      name: 'x'.repeat(101),
    });

    expect(response.status).toBe(200);
    expect(response.body).toEqual({ ok: true });
    expect(shared.status).toBe(401);
    expect(denied.status).toBe(401);
    expect(missingFlag.status).toBe(400);
    expect(longName.status).toBe(400);

    const status = await admin.get(`${base}/replays/saved/${seed.data.replayVisitId}`);
    const saved = await admin.get(`${base}/replays/saved`, { params: { pageSize: 100 } });
    const searched = await admin.get(`${base}/replays/saved`, { params: { search: name } });
    const missed = await admin.get(`${base}/replays/saved`, {
      params: { search: 'zzz-no-such-saved-replay' },
    });
    const listShared = await (await share()).get(`${base}/replays/saved`);
    const listDenied = await viewer.get(`${base}/replays/saved`);
    const statusShared = await (await share()).get(
      `${base}/replays/saved/${seed.data.replayVisitId}`,
    );
    const statusDenied = await viewer.get(`${base}/replays/saved/${seed.data.replayVisitId}`);

    expect(status.status).toBe(200);
    expect(status.body.isSaved).toBeTruthy();

    expect(saved.status).toBe(200);
    expect(saved.body).toMatchObject({ data: expect.any(Array), count: expect.any(Number) });
    expect(saved.body.data).toEqual(
      expect.arrayContaining([
        expect.objectContaining({
          id: expect.any(String),
          websiteId: seed.website.id,
          visitId: seed.data.replayVisitId,
          name,
          createdAt: expect.any(String),
        }),
      ]),
    );

    expect(searched.status).toBe(200);
    expect(searched.body.data).toHaveLength(1);
    expect(searched.body.data[0]).toMatchObject({ visitId: seed.data.replayVisitId, name });
    expect(missed.body.data).toHaveLength(0);

    expect(listShared.status).toBe(401);
    expect(listDenied.status).toBe(401);
    expect(statusShared.status).toBe(401);
    expect(statusDenied.status).toBe(401);
  });

  test('POST /api/websites/{websiteId}/replays/saved/{replayId} unsaves a replay', async ({
    admin,
    seed,
  }) => {
    const response = await admin.post(`${base}/replays/saved/${seed.data.replayVisitId}`, {
      isSaved: false,
    });
    const status = await admin.get(`${base}/replays/saved/${seed.data.replayVisitId}`);
    const saved = await admin.get(`${base}/replays/saved`, { params: { pageSize: 100 } });
    const unknown = await admin.get(`${base}/replays/saved/${UNKNOWN_UUID}`);

    expect(response.status).toBe(200);
    expect(response.body).toEqual({ ok: true });
    expect(status.status).toBe(200);
    expect(status.body.isSaved).toBeFalsy();
    expect(saved.body.data.map((row: any) => row.visitId)).not.toContain(seed.data.replayVisitId);
    expect(unknown.status).toBe(200);
    expect(unknown.body.isSaved).toBeFalsy();
  });

  test('GET /api/websites/{websiteId}/sessions/{sessionId}/replays lists the replays of a session', async ({
    admin,
    share,
    viewer,
    seed,
  }) => {
    const path = `${base}/sessions/${seed.data.replaySessionId}/replays`;
    const response = await admin.get(path, { params: dateRange(seed) });
    const searched = await admin.get(path, {
      params: dateRange(seed, { search: 'zzz-no-such-replay' }),
    });
    const none = await admin.get(`${base}/sessions/${UNKNOWN_UUID}/replays`, {
      params: dateRange(seed),
    });
    const shared = await (await share()).get(path, { params: dateRange(seed) });
    const denied = await viewer.get(path, { params: dateRange(seed) });
    const missingRange = await admin.get(path);

    expect(response.status).toBe(200);
    expect(response.body).toMatchObject({
      data: expect.any(Array),
      count: expect.any(Number),
      page: 1,
      pageSize: expect.any(Number),
    });
    expect(response.body.data.length).toBeGreaterThan(0);
    for (const row of response.body.data) {
      expect(row).toMatchObject({
        id: expect.any(String),
        websiteId: seed.website.id,
        sessionId: seed.data.replaySessionId,
        eventCount: expect.any(Number),
        chunkCount: expect.any(Number),
        duration: expect.any(Number),
        startedAt: expect.any(String),
        endedAt: expect.any(String),
      });
    }
    expect(response.body.data.map((row: any) => row.id)).toContain(seed.data.replayVisitId);

    expect(searched.status).toBe(200);
    expect(searched.body.data).toHaveLength(0);

    expect(none.status).toBe(200);
    expect(none.body.data).toHaveLength(0);

    expect(shared.status).toBe(401);
    expect(denied.status).toBe(401);
    expect(missingRange.status).toBe(400);
  });
});