mongodb-provider.test.ts

/**
 * MongoDB Provider Integration Tests
 *
 * Uses mock.module() from bun:test to mock the 'mongodb' driver
 * before importing the MongoDBProvider class.
 */
import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
import type { DatabaseConnection } from "@/lib/types";

// ============================================================================
// Mock Setup — MUST come before provider import
// ============================================================================

// Track mock instances for assertions
let mockCollectionData: Record<string, unknown>[] = [];
let mockCollections: { name: string; type: string }[] = [
  { name: "users", type: "collection" },
  { name: "orders", type: "collection" },
];
let mockCurrentOps: Record<string, unknown>[] = [];

const createMockCursor = (data: Record<string, unknown>[]) => {
  const cursor = {
    project: () => cursor,
    sort: () => cursor,
    skip: () => cursor,
    limit: () => cursor,
    toArray: async () => data,
    close: async () => {},
  };
  return cursor;
};

/**
 * The server's own answer for a command that is not supported on a view: code 166,
 * `CommandNotSupportedOnView`. Reproduced here because it is what one view in a
 * database used to do to the WHOLE schema read - `estimatedDocumentCount()` and
 * `indexes()` were unguarded, so the first view aborted every collection after it.
 */
const commandNotSupportedOnView = (command: string, name: string): Error => {
  const error = new Error(`Namespace testdb.${name} is a view, not a collection`) as Error & { code: number };
  error.code = 166;
  error.name = `MongoServerError(${command})`;
  return error;
};

const isMockView = (name: string): boolean => mockCollections.some((c) => c.name === name && c.type === "view");

const createMockCollection = (name = "users") => ({
  find: () => createMockCursor(mockCollectionData),
  findOne: async () => mockCollectionData[0] || null,
  aggregate: () => ({
    toArray: async () => mockCollectionData,
  }),
  countDocuments: async () => mockCollectionData.length,
  distinct: async (field: string) => mockCollectionData.map((d) => d[field]),
  insertOne: async () => ({
    insertedId: "new-id-123",
    acknowledged: true,
  }),
  insertMany: async (docs: Record<string, unknown>[]) => ({
    insertedCount: docs.length,
    insertedIds: docs.map((_, i) => `id-${i}`),
  }),
  updateOne: async () => ({
    matchedCount: 1,
    modifiedCount: 1,
  }),
  updateMany: async () => ({
    matchedCount: 2,
    modifiedCount: 2,
  }),
  deleteOne: async () => ({ deletedCount: 1 }),
  deleteMany: async () => ({ deletedCount: 3 }),
  estimatedDocumentCount: async () => {
    if (isMockView(name)) throw commandNotSupportedOnView("count", name);
    return 42;
  },
  indexes: async () => {
    if (isMockView(name)) throw commandNotSupportedOnView("listIndexes", name);
    return [
      { name: "_id_", key: { _id: 1 }, unique: true },
      { name: "email_1", key: { email: 1 }, unique: false },
    ];
  },
});

const mockCommandResults: Record<string, unknown> = {};

const createMockDb = () => ({
  command: async (cmd: Record<string, unknown>) => {
    if (cmd.ping) return { ok: 1 };
    if (cmd.collStats) {
      if (isMockView(String(cmd.collStats))) throw commandNotSupportedOnView("collStats", String(cmd.collStats));
      return { size: 1024, totalIndexSize: 512, count: 42 };
    }
    if (cmd.validate) return { ok: 1, valid: true };
    if (cmd.compact) return { ok: 1 };
    return mockCommandResults;
  },
  listCollections: () => ({
    toArray: async () => mockCollections,
  }),
  collection: (name?: string) => createMockCollection(name),
  stats: async () => ({
    dataSize: 2048,
    indexSize: 512,
    storageSize: 4096,
    collections: 2,
    objects: 100,
  }),
  admin: () => ({
    serverStatus: async () => ({
      connections: { current: 5, available: 95 },
      uptime: 86400,
      wiredTiger: {
        cache: {
          "pages read into cache": 10,
          "pages requested from the cache": 1000,
          "bytes currently in the cache": 5000000,
          "maximum bytes configured": 10000000,
        },
      },
      opcounters: { query: 100, insert: 50, update: 30, delete: 20 },
    }),
    command: async (cmd: Record<string, unknown>) => {
      if (cmd.currentOp) return { inprog: mockCurrentOps };
      if (cmd.buildInfo) return { version: "7.0.0" };
      return {};
    },
  }),
});

class MockObjectId {
  private _str: string;
  constructor(str?: string) {
    this._str = str || "mock-object-id-123456789012";
  }
  toString() {
    return this._str;
  }
}

class MockBinary {
  private _data: Buffer;
  constructor(data?: Buffer | string) {
    this._data = Buffer.from(data || "binary-data");
  }
  length() {
    return this._data.length;
  }
}

class MockDecimal128 {
  private _val: string;
  constructor(val?: string) {
    this._val = val || "123.456";
  }
  toString() {
    return this._val;
  }
}

mock.module("mongodb", () => ({
  MongoClient: class MockMongoClient {
    private _uri: string;
    private _opts: unknown;

    constructor(uri: string, opts?: unknown) {
      this._uri = uri;
      this._opts = opts;
    }

    async connect() {
      // noop — connection established
    }

    async close() {
      // noop — connection closed
    }

    db() {
      return createMockDb();
    }
  },
  ObjectId: MockObjectId,
  Binary: MockBinary,
  Decimal128: MockDecimal128,
}));

// ============================================================================
// Provider import — AFTER mock registration
// ============================================================================

const { MongoDBProvider } = await import("@/lib/db/providers/document/mongodb");
const { DatabaseConfigError } = await import("@/lib/db/errors");

// ============================================================================
// Test Config
// ============================================================================

const baseConfig: DatabaseConnection = {
  id: "test-mongo",
  name: "Test Mongo",
  type: "mongodb",
  host: "localhost",
  port: 27017,
  database: "testdb",
  createdAt: new Date(),
};

// ============================================================================
// Tests
// ============================================================================

describe("MongoDBProvider", () => {
  let provider: InstanceType<typeof MongoDBProvider>;

  beforeEach(() => {
    mockCollectionData = [
      { _id: new MockObjectId("aaa"), name: "Alice", email: "alice@test.com" },
      { _id: new MockObjectId("bbb"), name: "Bob", email: "bob@test.com" },
    ];
    mockCollections = [
      { name: "users", type: "collection" },
      { name: "orders", type: "collection" },
    ];
    mockCurrentOps = [];
    provider = new MongoDBProvider({ ...baseConfig });
  });

  afterEach(async () => {
    try {
      await provider.disconnect();
    } catch {
      // ignore
    }
  });

  // --------------------------------------------------------------------------
  // Validation
  // --------------------------------------------------------------------------

  describe("validation", () => {
    test("throws when host is missing and no connectionString", () => {
      expect(
        () =>
          new MongoDBProvider({
            ...baseConfig,
            host: undefined,
            connectionString: undefined,
          }),
      ).toThrow(DatabaseConfigError);
    });

    test("throws when database is missing and no connectionString", () => {
      expect(
        () =>
          new MongoDBProvider({
            ...baseConfig,
            database: undefined,
            connectionString: undefined,
          }),
      ).toThrow(DatabaseConfigError);
    });

    test("connectionString bypasses host/database requirement", () => {
      expect(
        () =>
          new MongoDBProvider({
            ...baseConfig,
            host: undefined,
            database: undefined,
            connectionString: "mongodb://remote:27017/mydb",
          }),
      ).not.toThrow();
    });
  });

  // --------------------------------------------------------------------------
  // Connection lifecycle
  // --------------------------------------------------------------------------

  describe("connect / disconnect", () => {
    test("connect succeeds and marks provider as connected", async () => {
      await provider.connect();
      expect(provider.isConnected()).toBe(true);
    });

    test("disconnect succeeds and marks provider as disconnected", async () => {
      await provider.connect();
      await provider.disconnect();
      expect(provider.isConnected()).toBe(false);
    });

    test("double connect is idempotent", async () => {
      await provider.connect();
      await provider.connect(); // should not throw
      expect(provider.isConnected()).toBe(true);
    });
  });

  // --------------------------------------------------------------------------
  // getCapabilities()
  // --------------------------------------------------------------------------

  describe("getCapabilities()", () => {
    test("returns correct capability metadata", () => {
      const caps = provider.getCapabilities();
      expect(caps.queryLanguage).toBe("json");
      expect(caps.defaultPort).toBe(27017);
      expect(caps.supportsCreateTable).toBe(false);
      // No SQL at all here: the query language is JSON commands, so the inline row
      // editor's `UPDATE ... SET` has nothing to run against (#269).
      expect(caps.supportsInlineRowEdit).toBe(false);
      // MongoDB has no foreign key constraint, so an empty `foreignKeys` here is the
      // engine's model and not this database's shape (#414).
      expect(caps.declaresForeignKeys).toBe(false);
      expect(caps.supportsConnectionString).toBe(true);
      expect(caps.supportsMaintenance).toBe(true);
      expect(caps.explainFormat).toBeUndefined();
      expect(caps.supportsExplain).toBe(caps.explainFormat !== undefined);
    });
  });

  // --------------------------------------------------------------------------
  // getLabels()
  // --------------------------------------------------------------------------

  describe("getLabels()", () => {
    test("returns correct provider labels", () => {
      const labels = provider.getLabels();
      expect(labels.entityName).toBe("Collection");
      expect(labels.rowName).toBe("document");
      expect(labels.selectAction).toBe("Find Documents");
    });
  });

  // --------------------------------------------------------------------------
  // prepareQuery()
  // --------------------------------------------------------------------------

  describe("prepareQuery()", () => {
    test("returns query unchanged with wasLimited=false", () => {
      const input = '{"collection":"users","operation":"find"}';
      const prepared = provider.prepareQuery(input);
      expect(prepared.query).toBe(input);
      expect(prepared.wasLimited).toBe(false);
    });
  });

  // --------------------------------------------------------------------------
  // query()
  // --------------------------------------------------------------------------

  describe("query()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("find operation returns rows", async () => {
      const result = await provider.query(JSON.stringify({ collection: "users", operation: "find", filter: {} }));
      expect(result.rows).toBeArray();
      expect(result.rows.length).toBe(2);
      expect(result.executionTime).toBeGreaterThanOrEqual(0);
      // ObjectId should be serialized to string
      expect(typeof result.rows[0]._id).toBe("string");
    });

    test("findOne returns a single document", async () => {
      const result = await provider.query(
        JSON.stringify({ collection: "users", operation: "findOne", filter: { name: "Alice" } }),
      );
      expect(result.rows.length).toBe(1);
      expect(result.rows[0].name).toBe("Alice");
    });

    test("aggregate works", async () => {
      const result = await provider.query(
        JSON.stringify({
          collection: "users",
          operation: "aggregate",
          pipeline: [{ $group: { _id: null, count: { $sum: 1 } } }],
        }),
      );
      expect(result.rows).toBeArray();
    });

    test("count returns document count", async () => {
      const result = await provider.query(JSON.stringify({ collection: "users", operation: "count", filter: {} }));
      expect(result.rows.length).toBe(1);
      expect(result.rows[0].count).toBe(2);
    });

    test("insertOne returns insertedId", async () => {
      const result = await provider.query(
        JSON.stringify({
          collection: "users",
          operation: "insertOne",
          documents: [{ name: "Charlie" }],
        }),
      );
      expect(result.rows[0].insertedId).toBe("new-id-123");
      expect(result.rows[0].acknowledged).toBe(true);
      expect(result.rowCount).toBe(1);
    });

    test("unsupported operation throws QueryError", async () => {
      await expect(provider.query(JSON.stringify({ collection: "users", operation: "drop" }))).rejects.toThrow();
    });

    test("invalid JSON throws QueryError", async () => {
      await expect(provider.query("not valid json")).rejects.toThrow();
    });

    test("missing collection throws QueryError", async () => {
      await expect(provider.query(JSON.stringify({ operation: "find" }))).rejects.toThrow();
    });
  });

  // --------------------------------------------------------------------------
  // getSchema()
  // --------------------------------------------------------------------------

  describe("getSchema()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns collections with inferred columns from sampled docs", async () => {
      const schemas = await provider.getSchema();
      expect(schemas).toBeArray();
      expect(schemas.length).toBe(2); // users + orders

      const usersSchema = schemas.find((s) => s.name === "users");
      expect(usersSchema).toBeDefined();
      expect(usersSchema!.rowCount).toBe(42);
      expect(usersSchema!.columns.length).toBeGreaterThan(0);

      // _id field should be first and marked primary
      const idCol = usersSchema!.columns[0];
      expect(idCol.name).toBe("_id");
      expect(idCol.isPrimary).toBe(true);

      // indexes should be present
      expect(usersSchema!.indexes!.length).toBe(2);
    });

    test("lists a view, and does not ask a view the two questions MongoDB refuses on one", async () => {
      // The defect this pins (#414): `listCollections()` returns views, and both
      // `estimatedDocumentCount()` and `indexes()` answer CommandNotSupportedOnView
      // (code 166) on one. Both calls were unguarded, so a single view in the
      // database aborted the entire schema read - the user lost every collection,
      // not just the view.
      mockCollections = [
        { name: "users", type: "collection" },
        { name: "active_users", type: "view" },
        { name: "orders", type: "collection" },
      ];

      const schemas = await provider.getSchema();

      // The view is LISTED. A user who created it wants to see it, and its fields are
      // readable by exactly the sample this provider already takes.
      expect(schemas.map((s) => s.name)).toEqual(["users", "active_users", "orders"]);
      const view = schemas.find((s) => s.name === "active_users")!;
      expect(view.columns.length).toBeGreaterThan(0);
      // And what a view genuinely has no answer for is left ABSENT rather than
      // reported as zero: a view holds no documents of its own and carries no
      // indexes, and `rowCount: 0` would read as "this view is empty".
      expect(view.rowCount).toBeUndefined();
      expect(view.size).toBeUndefined();
      expect(view.indexes).toEqual([]);
      // The collections after it are still read, which is the half of the defect a
      // user actually noticed.
      expect(schemas.find((s) => s.name === "orders")!.rowCount).toBe(42);
    });
  });

  // --------------------------------------------------------------------------
  // getHealth()
  // --------------------------------------------------------------------------

  describe("getHealth()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns health info with connections and database size", async () => {
      const health = await provider.getHealth();
      expect(health.activeConnections).toBe(5);
      expect(typeof health.databaseSize).toBe("string");
      expect(typeof health.cacheHitRatio).toBe("string");
    });

    test("maps in-progress operations to active sessions", async () => {
      mockCurrentOps = [
        {
          opid: 123,
          client: "127.0.0.1:5555",
          ns: "testdb.users",
          active: true,
          command: { find: "users" },
          microsecs_running: 2500000,
        },
        { active: false },
      ];
      const health = await provider.getHealth();
      expect(health.activeSessions.length).toBe(2);
      expect(health.activeSessions[0].pid).toBe(123);
      expect(health.activeSessions[0].user).toBe("127.0.0.1:5555");
      expect(health.activeSessions[0].database).toBe("testdb.users");
      expect(health.activeSessions[0].state).toBe("active");
      expect(health.activeSessions[0].query).toContain("find");
      expect(health.activeSessions[0].duration).toBe("2.50s");
      // Missing fields fall back to defaults
      expect(health.activeSessions[1].pid).toBe("N/A");
      expect(health.activeSessions[1].user).toBe("N/A");
      expect(health.activeSessions[1].database).toBe("testdb");
      expect(health.activeSessions[1].state).toBe("idle");
      expect(health.activeSessions[1].duration).toBe("N/A");
    });
  });

  // --------------------------------------------------------------------------
  // runMaintenance()
  // --------------------------------------------------------------------------

  describe("runMaintenance()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("analyze validates collections", async () => {
      const result = await provider.runMaintenance("analyze", "users");
      expect(result.success).toBe(true);
      expect(result.message).toContain("Validated");
    });

    test("vacuum compacts collections", async () => {
      const result = await provider.runMaintenance("vacuum", "users");
      expect(result.success).toBe(true);
      expect(result.message).toContain("Compacted");
    });

    test("unsupported maintenance type throws", async () => {
      await expect(provider.runMaintenance("flush" as never)).rejects.toThrow();
    });
  });

  // --------------------------------------------------------------------------
  // getOverview()
  // --------------------------------------------------------------------------

  describe("getOverview()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns version, uptime, connections, size, counts", async () => {
      const overview = await provider.getOverview();
      expect(typeof overview.version).toBe("string");
      expect(typeof overview.uptime).toBe("string");
      expect(typeof overview.activeConnections).toBe("number");
      expect(typeof overview.maxConnections).toBe("number");
      expect(typeof overview.databaseSize).toBe("string");
      expect(typeof overview.databaseSizeBytes).toBe("number");
      expect(typeof overview.tableCount).toBe("number");
      expect(typeof overview.indexCount).toBe("number");
    });
  });

  // --------------------------------------------------------------------------
  // getPerformanceMetrics()
  // --------------------------------------------------------------------------

  describe("getPerformanceMetrics()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns cache hit ratio and connection pool metrics", async () => {
      const metrics = await provider.getPerformanceMetrics();
      expect(typeof metrics.cacheHitRatio).toBe("number");
      expect(metrics.cacheHitRatio).toBeGreaterThanOrEqual(0);
    });
  });

  // --------------------------------------------------------------------------
  // getSlowQueries()
  // --------------------------------------------------------------------------

  describe("getSlowQueries()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns slow query data", async () => {
      const slow = await provider.getSlowQueries();
      expect(slow).toBeArray();
    });
  });

  // --------------------------------------------------------------------------
  // getActiveSessions()
  // --------------------------------------------------------------------------

  describe("getActiveSessions()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns session data", async () => {
      const sessions = await provider.getActiveSessions();
      expect(sessions).toBeArray();
    });

    test("maps in-progress operations with duration formatting for every range", async () => {
      mockCurrentOps = [
        {
          opid: 1,
          client: "10.0.0.1:4444",
          ns: "testdb.orders",
          appName: "mongosh",
          active: true,
          command: { find: "orders" },
          microsecs_running: 500000, // 500ms
          waitingForLock: true,
          lockStats: { acquireCount: 1 },
        },
        { opid: 2, microsecs_running: 5000000 }, // 5.0s
        { opid: 3, microsecs_running: 120000000 }, // 2m 0s
        { opid: 4, microsecs_running: 7260000000 }, // 2h 1m
      ];
      const sessions = await provider.getActiveSessions();
      expect(sessions.length).toBe(4);

      // Fully populated op
      expect(sessions[0].pid).toBe(1);
      expect(sessions[0].user).toBe("10.0.0.1:4444");
      expect(sessions[0].database).toBe("testdb");
      expect(sessions[0].applicationName).toBe("mongosh");
      expect(sessions[0].clientAddr).toBe("10.0.0.1");
      expect(sessions[0].state).toBe("active");
      expect(sessions[0].query).toContain("find");
      expect(sessions[0].duration).toBe("500ms");
      expect(sessions[0].durationMs).toBe(500);
      expect(sessions[0].waitEventType).toBe("Lock");
      expect(sessions[0].waitEvent).toBe("Acquiring lock");

      // Sparse op falls back to defaults
      expect(sessions[1].pid).toBe(2);
      expect(sessions[1].user).toBe("N/A");
      expect(sessions[1].database).toBe("testdb");
      expect(sessions[1].applicationName).toBeUndefined();
      expect(sessions[1].clientAddr).toBeUndefined();
      expect(sessions[1].state).toBe("idle");
      expect(sessions[1].waitEventType).toBeUndefined();
      expect(sessions[1].waitEvent).toBeUndefined();

      // Duration formatting across seconds / minutes / hours ranges
      expect(sessions[1].duration).toBe("5.0s");
      expect(sessions[2].duration).toBe("2m 0s");
      expect(sessions[3].duration).toBe("2h 1m");
    });

    test("respects the limit option", async () => {
      mockCurrentOps = [
        { opid: 1, microsecs_running: 1000 },
        { opid: 2, microsecs_running: 2000 },
        { opid: 3, microsecs_running: 3000 },
      ];
      const sessions = await provider.getActiveSessions({ limit: 2 });
      expect(sessions.length).toBe(2);
    });
  });

  // --------------------------------------------------------------------------
  // getTableStats()
  // --------------------------------------------------------------------------

  describe("getTableStats()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns collection stats", async () => {
      const stats = await provider.getTableStats();
      expect(stats).toBeArray();
    });
  });

  // --------------------------------------------------------------------------
  // getIndexStats()
  // --------------------------------------------------------------------------

  describe("getIndexStats()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns index stats for collections", async () => {
      const stats = await provider.getIndexStats();
      expect(stats).toBeArray();
    });
  });

  // --------------------------------------------------------------------------
  // getStorageStats()
  // --------------------------------------------------------------------------

  describe("getStorageStats()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns storage stats", async () => {
      const stats = await provider.getStorageStats();
      expect(stats).toBeArray();
      expect(stats.length).toBeGreaterThan(0);
      expect(typeof stats[0].name).toBe("string");
      expect(typeof stats[0].size).toBe("string");
      expect(typeof stats[0].sizeBytes).toBe("number");
    });
  });

  // --------------------------------------------------------------------------
  // BSON serialization
  // --------------------------------------------------------------------------

  describe("BSON serialization", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("ObjectId is serialized to string in query results", async () => {
      const result = await provider.query(JSON.stringify({ collection: "users", operation: "find", filter: {} }));
      expect(typeof result.rows[0]._id).toBe("string");
    });

    test("insertMany returns correct count", async () => {
      const result = await provider.query(
        JSON.stringify({
          collection: "users",
          operation: "insertMany",
          documents: [{ name: "A" }, { name: "B" }, { name: "C" }],
        }),
      );
      expect(result.rows[0].insertedCount).toBe(3);
      // rowCount is rows.length (1 result row) since rows.length > 0
      expect(result.rowCount).toBe(1);
    });

    test("updateOne returns matched/modified counts", async () => {
      const result = await provider.query(
        JSON.stringify({
          collection: "users",
          operation: "updateOne",
          filter: { name: "Alice" },
          update: { $set: { name: "Alice Updated" } },
        }),
      );
      expect(result.rows[0].matchedCount).toBe(1);
      expect(result.rows[0].modifiedCount).toBe(1);
    });

    test("updateMany returns matched/modified counts", async () => {
      const result = await provider.query(
        JSON.stringify({
          collection: "users",
          operation: "updateMany",
          filter: {},
          update: { $set: { active: true } },
        }),
      );
      expect(result.rows[0].matchedCount).toBe(2);
      expect(result.rows[0].modifiedCount).toBe(2);
    });

    test("deleteOne returns deletedCount", async () => {
      const result = await provider.query(
        JSON.stringify({
          collection: "users",
          operation: "deleteOne",
          filter: { name: "Alice" },
        }),
      );
      expect(result.rows[0].deletedCount).toBe(1);
      expect(result.rowCount).toBe(1);
    });

    test("deleteMany returns deletedCount", async () => {
      const result = await provider.query(
        JSON.stringify({
          collection: "users",
          operation: "deleteMany",
          filter: {},
        }),
      );
      expect(result.rows[0].deletedCount).toBe(3);
      // rowCount is rows.length (1 result row) since rows.length > 0
      expect(result.rowCount).toBe(1);
    });

    test("distinct returns values", async () => {
      const result = await provider.query(
        JSON.stringify({
          collection: "users",
          operation: "distinct",
          filter: "name",
        }),
      );
      expect(result.rows).toBeArray();
    });
  });

  // --------------------------------------------------------------------------
  // getMonitoringData()
  // --------------------------------------------------------------------------

  describe("getMonitoringData()", () => {
    beforeEach(async () => {
      await provider.connect();
    });

    test("returns monitoring data with all sections", async () => {
      const data = await provider.getMonitoringData();
      expect(data.timestamp).toBeInstanceOf(Date);
      expect(data.overview).toBeDefined();
      expect(data.performance).toBeDefined();
      expect(data.slowQueries).toBeArray();
      expect(data.activeSessions).toBeArray();
    });
  });
});