@neverinfamous/mysql-mcp 2.1.0 → 2.3.0

package/src/adapters/mysql/resources/__tests__/cluster.test.ts

@@ -1,105 +1,164 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createMockMySQLAdapter, createMockQueryResult, createMockRequestContext } from '../../../../__tests__/mocks/index.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createClusterResource } from '../cluster.js';
-
-describe('Cluster Resource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-    });
-
-    it('should return cluster status when group replication is enabled', async () => {
-        // Mock group_replication_group_name
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'group_replication_group_name', Value: 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' }
-        ]));
-
-        // Mock replication_group_members
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { id: '1', host: 'host1', port: 3306, state: 'ONLINE', role: 'PRIMARY', version: '8.0.35' },
-            { id: '2', host: 'host2', port: 3306, state: 'ONLINE', role: 'SECONDARY', version: '8.0.35' }
-        ]));
-
-        // Mock primary member query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { host: 'host1', port: 3306 }
-        ]));
-
-        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://cluster', mockContext) as any;
-
-        expect(result.groupReplicationEnabled).toBe(true);
-        expect(result.groupName).toBe('aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee');
-        expect(result.memberCount).toBe(2);
-        expect(result.primary).toBe('host1:3306');
-    });
-
-    it('should return disabled status if group name is empty', async () => {
-        // Mock group_replication_group_name with empty value
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'group_replication_group_name', Value: '' }
-        ]));
-
-        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://cluster', mockContext) as any;
-
-        expect(result.groupReplicationEnabled).toBe(false);
-        expect(result.message).toContain('not configured');
-    });
-
-    it('should return disabled status if variable query returns empty', async () => {
-        // Mock group_replication_group_name with no rows
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
-
-        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://cluster', mockContext) as any;
-
-        expect(result.groupReplicationEnabled).toBe(false);
-    });
-
-    it('should handle undefined rows gracefully', async () => {
-        // Mock empty result with undefined rows
-        mockAdapter.executeQuery.mockResolvedValueOnce({} as any);
-
-        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://cluster', mockContext) as any;
-
-        expect(result.groupReplicationEnabled).toBe(false);
-    });
-
-    it('should handle missing primary member', async () => {
-        // Mock group_replication_group_name
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'group_replication_group_name', Value: 'uuid' }
-        ]));
-
-        // Mock members (no primary)
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { id: '1', role: 'SECONDARY' }
-        ]));
-
-        // Mock primary query (empty)
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
-
-        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://cluster', mockContext) as any;
-
-        expect(result.groupReplicationEnabled).toBe(true);
-        expect(result.primary).toBeNull();
-    });
-
-    it('should handle errors gracefully', async () => {
-        mockAdapter.executeQuery.mockRejectedValue(new Error('DB Error'));
-
-        const resource = createClusterResource(mockAdapter as unknown as MySQLAdapter);
-        const result = await resource.handler('mysql://cluster', mockContext) as any;
-
-        expect(result.groupReplicationEnabled).toBe(false);
-        expect(result.message).toContain('Unable to retrieve');
-    });
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  createMockMySQLAdapter,
+  createMockQueryResult,
+  createMockRequestContext,
+} from "../../../../__tests__/mocks/index.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import { createClusterResource } from "../cluster.js";
+
+describe("Cluster Resource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+  });
+
+  it("should return cluster status when group replication is enabled", async () => {
+    // Mock group_replication_group_name
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        {
+          Variable_name: "group_replication_group_name",
+          Value: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        },
+      ]),
+    );
+
+    // Mock replication_group_members
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        {
+          id: "1",
+          host: "host1",
+          port: 3306,
+          state: "ONLINE",
+          role: "PRIMARY",
+          version: "8.0.35",
+        },
+        {
+          id: "2",
+          host: "host2",
+          port: 3306,
+          state: "ONLINE",
+          role: "SECONDARY",
+          version: "8.0.35",
+        },
+      ]),
+    );
+
+    // Mock primary member query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([{ host: "host1", port: 3306 }]),
+    );
+
+    const resource = createClusterResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://cluster",
+      mockContext,
+    )) as any;
+
+    expect(result.groupReplicationEnabled).toBe(true);
+    expect(result.groupName).toBe("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee");
+    expect(result.memberCount).toBe(2);
+    expect(result.primary).toBe("host1:3306");
+  });
+
+  it("should return disabled status if group name is empty", async () => {
+    // Mock group_replication_group_name with empty value
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: "group_replication_group_name", Value: "" },
+      ]),
+    );
+
+    const resource = createClusterResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://cluster",
+      mockContext,
+    )) as any;
+
+    expect(result.groupReplicationEnabled).toBe(false);
+    expect(result.message).toContain("not configured");
+  });
+
+  it("should return disabled status if variable query returns empty", async () => {
+    // Mock group_replication_group_name with no rows
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+    const resource = createClusterResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://cluster",
+      mockContext,
+    )) as any;
+
+    expect(result.groupReplicationEnabled).toBe(false);
+  });
+
+  it("should handle undefined rows gracefully", async () => {
+    // Mock empty result with undefined rows
+    mockAdapter.executeQuery.mockResolvedValueOnce({} as any);
+
+    const resource = createClusterResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://cluster",
+      mockContext,
+    )) as any;
+
+    expect(result.groupReplicationEnabled).toBe(false);
+  });
+
+  it("should handle missing primary member", async () => {
+    // Mock group_replication_group_name
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: "group_replication_group_name", Value: "uuid" },
+      ]),
+    );
+
+    // Mock members (no primary)
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([{ id: "1", role: "SECONDARY" }]),
+    );
+
+    // Mock primary query (empty)
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+    const resource = createClusterResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://cluster",
+      mockContext,
+    )) as any;
+
+    expect(result.groupReplicationEnabled).toBe(true);
+    expect(result.primary).toBeNull();
+  });
+
+  it("should handle errors gracefully", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(new Error("DB Error"));
+
+    const resource = createClusterResource(
+      mockAdapter as unknown as MySQLAdapter,
+    );
+    const result = (await resource.handler(
+      "mysql://cluster",
+      mockContext,
+    )) as any;
+
+    expect(result.groupReplicationEnabled).toBe(false);
+    expect(result.message).toContain("Unable to retrieve");
+  });
 });

package/src/adapters/mysql/resources/__tests__/docstore.test.ts

@@ -1,97 +1,104 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createDocstoreResource } from '../docstore.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
-
-describe('createDocstoreResource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-    let resource: ReturnType<typeof createDocstoreResource>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-        resource = createDocstoreResource(mockAdapter as unknown as MySQLAdapter);
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createDocstoreResource } from "../docstore.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+  createMockQueryResult,
+} from "../../../../__tests__/mocks/index.js";
+
+describe("createDocstoreResource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+  let resource: ReturnType<typeof createDocstoreResource>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+    resource = createDocstoreResource(mockAdapter as unknown as MySQLAdapter);
+  });
+
+  it("should correctly separate handler logic", () => {
+    expect(resource.name).toBe("Document Store Collections");
+    expect(typeof resource.handler).toBe("function");
+  });
+
+  it("should return correct info when X Plugin is active and collections exist", async () => {
+    // Mock X Plugin status query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([{ PLUGIN_STATUS: "ACTIVE" }]),
+    );
+
+    // Mock Collections query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { collection_name: "users", row_count: 100, size_bytes: 1024 },
+        { collection_name: "settings", row_count: 5, size_bytes: 512 },
+      ]),
+    );
+
+    const result = await resource.handler(resource.uri, mockContext);
+
+    expect(result).toEqual({
+      xPluginEnabled: true,
+      collectionCount: 2,
+      collections: [
+        { collection_name: "users", row_count: 100, size_bytes: 1024 },
+        { collection_name: "settings", row_count: 5, size_bytes: 512 },
+      ],
+      note: "X Plugin is active - X Protocol available on port 33060",
     });
 
-    it('should correctly separate handler logic', () => {
-        expect(resource.name).toBe('Document Store Collections');
-        expect(typeof resource.handler).toBe('function');
-    });
+    expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
+  });
 
-    it('should return correct info when X Plugin is active and collections exist', async () => {
-        // Mock X Plugin status query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { PLUGIN_STATUS: 'ACTIVE' }
-        ]));
-
-        // Mock Collections query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { collection_name: 'users', row_count: 100, size_bytes: 1024 },
-            { collection_name: 'settings', row_count: 5, size_bytes: 512 }
-        ]));
-
-        const result = await resource.handler(resource.uri, mockContext);
-
-        expect(result).toEqual({
-            xPluginEnabled: true,
-            collectionCount: 2,
-            collections: [
-                { collection_name: 'users', row_count: 100, size_bytes: 1024 },
-                { collection_name: 'settings', row_count: 5, size_bytes: 512 }
-            ],
-            note: 'X Plugin is active - X Protocol available on port 33060'
-        });
-
-        expect(mockAdapter.executeQuery).toHaveBeenCalledTimes(2);
-    });
+  it("should return correct info when X Plugin is INACTIVE", async () => {
+    // Mock X Plugin status query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([{ PLUGIN_STATUS: "INACTIVE" }]),
+    );
 
-    it('should return correct info when X Plugin is INACTIVE', async () => {
-        // Mock X Plugin status query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { PLUGIN_STATUS: 'INACTIVE' }
-        ]));
+    // Mock Collections query (empty)
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
 
-        // Mock Collections query (empty)
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+    const result = await resource.handler(resource.uri, mockContext);
 
-        const result = await resource.handler(resource.uri, mockContext);
-
-        expect(result).toEqual({
-            xPluginEnabled: false,
-            collectionCount: 0,
-            collections: [],
-            note: 'X Plugin not active - document store limited to SQL access'
-        });
+    expect(result).toEqual({
+      xPluginEnabled: false,
+      collectionCount: 0,
+      collections: [],
+      note: "X Plugin not active - document store limited to SQL access",
     });
+  });
 
-    it('should handle undefined rows gracefully', async () => {
-        // Mock X Plugin status query
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { PLUGIN_STATUS: 'ACTIVE' }
-        ]));
+  it("should handle undefined rows gracefully", async () => {
+    // Mock X Plugin status query
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([{ PLUGIN_STATUS: "ACTIVE" }]),
+    );
 
-        // Mock Collections query returning no rows property (e.g. some drivers might not return it)
-        mockAdapter.executeQuery.mockResolvedValueOnce({} as any);
+    // Mock Collections query returning no rows property (e.g. some drivers might not return it)
+    mockAdapter.executeQuery.mockResolvedValueOnce({} as any);
 
-        const result = await resource.handler(resource.uri, mockContext) as any;
+    const result = (await resource.handler(resource.uri, mockContext)) as any;
 
-        expect(result.collectionCount).toBe(0);
-        expect(result.collections).toEqual([]);
-    });
+    expect(result.collectionCount).toBe(0);
+    expect(result.collections).toEqual([]);
+  });
 
-    it('should handle errors gracefully', async () => {
-        mockAdapter.executeQuery.mockRejectedValue(new Error('Database unavailable'));
+  it("should handle errors gracefully", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(
+      new Error("Database unavailable"),
+    );
 
-        const result = await resource.handler(resource.uri, mockContext);
+    const result = await resource.handler(resource.uri, mockContext);
 
-        expect(result).toEqual({
-            xPluginEnabled: false,
-            collectionCount: 0,
-            collections: [],
-            error: 'Unable to retrieve document store information'
-        });
+    expect(result).toEqual({
+      xPluginEnabled: false,
+      collectionCount: 0,
+      collections: [],
+      error: "Unable to retrieve document store information",
     });
+  });
 });

package/src/adapters/mysql/resources/__tests__/events.test.ts

@@ -1,97 +1,108 @@
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createEventsResource } from '../events.js';
-import type { MySQLAdapter } from '../../MySQLAdapter.js';
-import { createMockMySQLAdapter, createMockRequestContext, createMockQueryResult } from '../../../../__tests__/mocks/index.js';
-
-describe('createEventsResource', () => {
-    let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
-    let mockContext: ReturnType<typeof createMockRequestContext>;
-    let resource: ReturnType<typeof createEventsResource>;
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAdapter = createMockMySQLAdapter();
-        mockContext = createMockRequestContext();
-        resource = createEventsResource(mockAdapter as unknown as MySQLAdapter);
-    });
-
-    it('should return scheduler enabled when variable is ON', async () => {
-        // Mock scheduler variable
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'event_scheduler', Value: 'ON' }
-        ]));
-
-        // Mock events list
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { schema_name: 'test', name: 'event1', status: 'ENABLED' }
-        ]));
-
-        const result = await resource.handler(resource.uri, mockContext);
-
-        expect(result).toEqual({
-            schedulerEnabled: true,
-            schedulerStatus: 'ON',
-            eventCount: 1,
-            events: [{ schema_name: 'test', name: 'event1', status: 'ENABLED' }]
-        });
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createEventsResource } from "../events.js";
+import type { MySQLAdapter } from "../../MySQLAdapter.js";
+import {
+  createMockMySQLAdapter,
+  createMockRequestContext,
+  createMockQueryResult,
+} from "../../../../__tests__/mocks/index.js";
+
+describe("createEventsResource", () => {
+  let mockAdapter: ReturnType<typeof createMockMySQLAdapter>;
+  let mockContext: ReturnType<typeof createMockRequestContext>;
+  let resource: ReturnType<typeof createEventsResource>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockAdapter = createMockMySQLAdapter();
+    mockContext = createMockRequestContext();
+    resource = createEventsResource(mockAdapter as unknown as MySQLAdapter);
+  });
+
+  it("should return scheduler enabled when variable is ON", async () => {
+    // Mock scheduler variable
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: "event_scheduler", Value: "ON" },
+      ]),
+    );
+
+    // Mock events list
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { schema_name: "test", name: "event1", status: "ENABLED" },
+      ]),
+    );
+
+    const result = await resource.handler(resource.uri, mockContext);
+
+    expect(result).toEqual({
+      schedulerEnabled: true,
+      schedulerStatus: "ON",
+      eventCount: 1,
+      events: [{ schema_name: "test", name: "event1", status: "ENABLED" }],
     });
-
-    it('should return scheduler disabled when variable is OFF', async () => {
-        // Mock scheduler variable
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([
-            { Variable_name: 'event_scheduler', Value: 'OFF' }
-        ]));
-
-        // Mock events list
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
-
-        const result = await resource.handler(resource.uri, mockContext);
-
-        expect(result).toEqual({
-            schedulerEnabled: false,
-            schedulerStatus: 'OFF',
-            eventCount: 0,
-            events: []
-        });
+  });
+
+  it("should return scheduler disabled when variable is OFF", async () => {
+    // Mock scheduler variable
+    mockAdapter.executeQuery.mockResolvedValueOnce(
+      createMockQueryResult([
+        { Variable_name: "event_scheduler", Value: "OFF" },
+      ]),
+    );
+
+    // Mock events list
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+
+    const result = await resource.handler(resource.uri, mockContext);
+
+    expect(result).toEqual({
+      schedulerEnabled: false,
+      schedulerStatus: "OFF",
+      eventCount: 0,
+      events: [],
     });
+  });
 
-    it('should handle missing variable execution gracefully (default OFF)', async () => {
-        // Mock scheduler variable empty result
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+  it("should handle missing variable execution gracefully (default OFF)", async () => {
+    // Mock scheduler variable empty result
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
 
-        // Mock events list
-        mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
+    // Mock events list
+    mockAdapter.executeQuery.mockResolvedValueOnce(createMockQueryResult([]));
 
-        const result = await resource.handler(resource.uri, mockContext);
+    const result = await resource.handler(resource.uri, mockContext);
 
-        expect(result).toEqual({
-            schedulerEnabled: false,
-            schedulerStatus: 'OFF',
-            eventCount: 0,
-            events: []
-        });
+    expect(result).toEqual({
+      schedulerEnabled: false,
+      schedulerStatus: "OFF",
+      eventCount: 0,
+      events: [],
     });
+  });
 
-    it('should propagate errors since no try/catch in handler', async () => {
-        mockAdapter.executeQuery.mockRejectedValue(new Error('DB Error'));
+  it("should propagate errors since no try/catch in handler", async () => {
+    mockAdapter.executeQuery.mockRejectedValue(new Error("DB Error"));
 
-        await expect(resource.handler(resource.uri, mockContext)).rejects.toThrow('DB Error');
-    });
-    it('should handle undefined rows gracefully', async () => {
-        // Mock scheduler variable with undefined rows
-        mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any);
+    await expect(resource.handler(resource.uri, mockContext)).rejects.toThrow(
+      "DB Error",
+    );
+  });
+  it("should handle undefined rows gracefully", async () => {
+    // Mock scheduler variable with undefined rows
+    mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any);
 
-        // Mock events list with undefined rows
-        mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any);
+    // Mock events list with undefined rows
+    mockAdapter.executeQuery.mockResolvedValueOnce({ rows: undefined } as any);
 
-        const result = await resource.handler(resource.uri, mockContext);
+    const result = await resource.handler(resource.uri, mockContext);
 
-        expect(result).toEqual({
-            schedulerEnabled: false,
-            schedulerStatus: 'OFF',
-            eventCount: 0,
-            events: []
-        });
+    expect(result).toEqual({
+      schedulerEnabled: false,
+      schedulerStatus: "OFF",
+      eventCount: 0,
+      events: [],
     });
+  });
 });