@memberjunction/server 6.2.0-edge.6 → 6.2.0-edge.8

package/src/__tests__/TagGovernanceResolver.test.ts

@@ -10,12 +10,15 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
  * how errors are surfaced.
  */
 
-const { promoteCalls, rejectCalls, rebuildCalls, healthCalls, behaviorFlags } = vi.hoisted(() => ({
+const { promoteCalls, rejectCalls, rebuildCalls, healthCalls, mergeCalls, recomputeCalls, configCalls, behaviorFlags } = vi.hoisted(() => ({
     promoteCalls: [] as Array<{ id: string; strategy: unknown; user: unknown }>,
     rejectCalls: [] as Array<{ id: string; notes: string | null; user: unknown }>,
     rebuildCalls: [] as Array<{ user: unknown }>,
     healthCalls: [] as Array<{ thresholds: unknown; user: unknown }>,
-    behaviorFlags: { promoteThrows: false, rejectThrows: false, rebuildThrows: false, healthThrows: false },
+    mergeCalls: [] as Array<{ sourceTagIDs: string[]; survivingTagID: string; user: unknown }>,
+    recomputeCalls: [] as Array<{ user: unknown }>,
+    configCalls: [] as Array<{ forceRefresh: boolean; user: unknown }>,
+    behaviorFlags: { promoteThrows: false, rejectThrows: false, rebuildThrows: false, healthThrows: false, mergeThrows: false },
 }));
 
 vi.mock('@memberjunction/tag-engine', () => ({
@@ -30,10 +33,18 @@ vi.mock('@memberjunction/tag-engine', () => ({
                 rejectCalls.push({ id, notes, user });
                 if (behaviorFlags.rejectThrows) throw new Error('reject-fail');
             },
+            MergeTags: async (sourceTagIDs: string[], survivingTagID: string, user: unknown) => {
+                mergeCalls.push({ sourceTagIDs, survivingTagID, user });
+                if (behaviorFlags.mergeThrows) throw new Error('merge-fail');
+                return { ItemsMoved: 4, TaggedItemsMoved: 7 };
+            },
         },
     },
     TagEngine: {
         Instance: {
+            Config: async (forceRefresh: boolean, user: unknown) => {
+                configCalls.push({ forceRefresh, user });
+            },
             RebuildTagEmbeddings: async (user: unknown) => {
                 rebuildCalls.push({ user });
                 if (behaviorFlags.rebuildThrows) throw new Error('rebuild-fail');
@@ -59,6 +70,17 @@ vi.mock('@memberjunction/tag-engine', () => ({
     },
 }));
 
+vi.mock('@memberjunction/tag-engine-base', () => ({
+    TagCoOccurrenceEngine: {
+        Instance: {
+            RecomputeCoOccurrence: async (user: unknown) => {
+                recomputeCalls.push({ user });
+                return { PairsUpdated: 12, PairsDeleted: 3 };
+            },
+        },
+    },
+}));
+
 // Minimal type-graphql shim — we only need the decorators to be no-ops so the
 // resolver class can load. Method behavior is what we test.
 vi.mock('type-graphql', () => ({
@@ -98,10 +120,14 @@ describe('TagGovernanceResolver', () => {
         rejectCalls.length = 0;
         rebuildCalls.length = 0;
         healthCalls.length = 0;
+        mergeCalls.length = 0;
+        recomputeCalls.length = 0;
+        configCalls.length = 0;
         behaviorFlags.promoteThrows = false;
         behaviorFlags.rejectThrows = false;
         behaviorFlags.rebuildThrows = false;
         behaviorFlags.healthThrows = false;
+        behaviorFlags.mergeThrows = false;
         resolver = new TagGovernanceResolver();
     });
 
@@ -252,4 +278,36 @@ describe('TagGovernanceResolver', () => {
             expect(r.ErrorMessage).toBe('health-fail');
         });
     });
+
+    // ---- MergeTags ---------------------------------------------------------
+
+    describe('MergeTags', () => {
+        it('calls TagEngine.Instance.Config first and delegates to TagGovernanceEngine.Instance.MergeTags', async () => {
+            const r = await resolver.MergeTags(['src-1'], 'surviving-1', ctx() as never);
+            expect(r.Success).toBe(true);
+            expect(r.ItemsMoved).toBe(4);
+            expect(r.TaggedItemsMoved).toBe(7);
+            expect(configCalls).toHaveLength(1);
+            expect(mergeCalls[0]).toMatchObject({ sourceTagIDs: ['src-1'], survivingTagID: 'surviving-1' });
+        });
+
+        it('maps engine errors into ErrorMessage', async () => {
+            behaviorFlags.mergeThrows = true;
+            const r = await resolver.MergeTags(['src-1'], 'surviving-1', ctx() as never);
+            expect(r.Success).toBe(false);
+            expect(r.ItemsMoved).toBe(0);
+            expect(r.TaggedItemsMoved).toBe(0);
+            expect(r.ErrorMessage).toBe('merge-fail');
+        });
+    });
+
+    // ---- RecomputeTagCoOccurrence ------------------------------------------
+
+    describe('RecomputeTagCoOccurrence', () => {
+        it('delegates to TagCoOccurrenceEngine.Instance.RecomputeCoOccurrence', async () => {
+            const r = await resolver.RecomputeTagCoOccurrence(ctx() as never);
+            expect(r).toEqual({ PairsUpdated: 12, PairsDeleted: 3 });
+            expect(recomputeCalls).toHaveLength(1);
+        });
+    });
 });

package/src/__tests__/TaskGraphActionRunner.durablePayload.test.ts

@@ -170,7 +170,7 @@ describe('TaskGraphActionRunner: outputs must be storable', () => {
         expect(result).toMatchObject({ Success: true, Output: { AgentRunID: 'RUN-1' }, ActionLogID: 'LOG-2' });
     });
 
-    it('merges structured JSON Message properties into Output and aliases handle/Handle', async () => {
+    it('merges structured JSON Message properties into Output without synthesizing handle/Handle aliases', async () => {
         vi.mocked(ActionEngineServer.Instance.RunAction).mockResolvedValue({
             Success: true,
             Message: JSON.stringify({
@@ -188,10 +188,10 @@ describe('TaskGraphActionRunner: outputs must be storable', () => {
         expect(result.Success).toBe(true);
         expect(result.Output).toMatchObject({
             handle: 'doc-handle-99',
-            Handle: 'doc-handle-99',
             documentType: 'pdf',
             fileName: 'Sales_Demo_Report.pdf',
         });
+        expect(result.Output).not.toHaveProperty('Handle');
     });
 });
 

package/src/__tests__/TaskGraphAgentRunner.test.ts

@@ -1,19 +1,54 @@
 /**
- * Tests for `TaskGraphAgentRunner`.
- *
- * Verifies that when a task node in a durable task graph executes a specialist agent
- * (such as Query Builder or Research Report Writer) and finishes with a payload,
- * the runner resolves the originating `ConversationDetailID` and persists artifacts
- * via `AgentRunner.ProcessAgentArtifacts`.
+ * Tests for `TaskGraphAgentRunner`:
+ * - VS-CON-7 preset resolution (`ConfigurationPresetName`)
+ * - VS-INV-2b / VS-QA-3 #9 `parentAgentHierarchy` from submitted task
+ * - Specialist agent artifact persistence (`ProcessAgentArtifacts`), `CanUserRunAgent` permission check,
+ *   task Name/Description prompt formatting, and output normalization.
  */
 import 'reflect-metadata';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+import type { TaskAgentRunParams } from '@memberjunction/task-graph';
 
-vi.mock('@memberjunction/core', () => ({
-    LogError: vi.fn(),
-    LogStatus: vi.fn(),
+const {
+    runAgent,
+    processAgentArtifacts,
+    canUserRunAgent,
+    mockEngineAgents,
+    mockGetAgentConfigurationPresets,
+    mockEngineConfig,
+    mockRunView,
+    mockLogError,
+} = vi.hoisted(() => ({
+    runAgent: vi.fn(),
+    processAgentArtifacts: vi.fn(),
+    canUserRunAgent: vi.fn().mockResolvedValue(true),
+    mockEngineAgents: [
+        { ID: 'agent-1', Name: 'Storyboard Artist' },
+        { ID: 'qb-agent' },
+        { ID: 'writer-agent' },
+    ] as Array<{ ID: string; Name?: string }>,
+    mockGetAgentConfigurationPresets: vi.fn(),
+    mockEngineConfig: vi.fn(),
+    mockRunView: vi.fn(),
+    mockLogError: vi.fn(),
 }));
 
+const mockRunAgent = runAgent;
+
+vi.mock('@memberjunction/core', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('@memberjunction/core')>();
+    return {
+        ...actual,
+        LogError: (...args: unknown[]) => mockLogError(...args),
+        LogStatus: vi.fn(),
+        RunView: class {
+            static FromMetadataProvider = () => ({ RunView: mockRunView });
+            RunView = mockRunView;
+        },
+    };
+});
+
 vi.mock('@memberjunction/generic-database-provider', () => ({
     UserCache: {
         Instance: { Users: [] },
@@ -31,31 +66,251 @@ vi.mock('@memberjunction/ai-core-plus', () => ({
 }));
 vi.mock('@memberjunction/ai', () => ({ ChatMessageRole: { user: 'user' } }));
 
-const { runAgent, processAgentArtifacts, canUserRunAgent, mockEngineAgents } = vi.hoisted(() => ({
-    runAgent: vi.fn(),
-    processAgentArtifacts: vi.fn(),
-    canUserRunAgent: vi.fn().mockResolvedValue(true),
-    mockEngineAgents: [{ ID: 'qb-agent' }, { ID: 'writer-agent' }] as Array<{ ID: string }>,
-}));
 vi.mock('@memberjunction/ai-agents', () => ({
     AgentRunner: class {
         RunAgent = runAgent;
         ProcessAgentArtifacts = processAgentArtifacts;
     },
 }));
+
 vi.mock('@memberjunction/aiengine', () => ({
     AIEngine: {
         get Instance() {
             return {
+                Config: mockEngineConfig,
                 Agents: mockEngineAgents,
                 CanUserRunAgent: canUserRunAgent,
+                GetAgentConfigurationPresets: mockGetAgentConfigurationPresets,
+                FindActiveAgentConfigurationPreset: (agentId: string, presetName: string) => {
+                    const target = presetName.trim().toLowerCase();
+                    if (!target) return undefined;
+                    const presets = (mockGetAgentConfigurationPresets(agentId, true) ?? []) as Array<{
+                        Name?: string;
+                        DisplayName?: string;
+                    }>;
+                    return presets.find((p) => p.Name?.trim().toLowerCase() === target)
+                        ?? presets.find((p) => p.DisplayName?.trim().toLowerCase() === target);
+                },
             };
         },
     },
 }));
 
 import { TaskGraphAgentRunner } from '../services/TaskGraphAgentRunner';
-import type { IMetadataProvider, UserInfo } from '@memberjunction/core';
+
+interface SubmittingRunOverrides {
+    ID?: string;
+    ConfigurationID?: string | null;
+    Agent?: string | null;
+    AgentID?: string | null;
+    ParentRunID?: string | null;
+    LoadSuccess?: boolean;
+}
+
+function makeParams(
+    overrides: Partial<TaskAgentRunParams> = {},
+    parentConfigurationID: string | null = 'parent-cfg-1',
+    submittingRunOverrides: SubmittingRunOverrides = {},
+): TaskAgentRunParams {
+    const loadSuccess = submittingRunOverrides.LoadSuccess ?? true;
+    const provider = {
+        GetEntityObject: vi.fn().mockImplementation(async (entityName: string) => {
+            if (entityName === 'MJ: AI Agents') {
+                return {
+                    Load: vi.fn().mockResolvedValue(true),
+                    ID: overrides.AgentID ?? 'agent-1',
+                    Name: 'Storyboard Artist',
+                };
+            }
+            if (entityName === 'MJ: Tasks') {
+                return {
+                    Load: vi.fn().mockResolvedValue(false),
+                };
+            }
+            return {
+                Load: vi.fn().mockResolvedValue(loadSuccess),
+                ID: submittingRunOverrides.ID ?? 'submitting-run-1',
+                ConfigurationID:
+                    'ConfigurationID' in submittingRunOverrides
+                        ? submittingRunOverrides.ConfigurationID
+                        : parentConfigurationID,
+                Agent: submittingRunOverrides.Agent ?? null,
+                AgentID: submittingRunOverrides.AgentID ?? null,
+                ParentRunID: submittingRunOverrides.ParentRunID ?? null,
+            };
+        }),
+    } as unknown as IMetadataProvider;
+
+    return {
+        TaskID: 'task-1',
+        AgentID: 'agent-1',
+        InputPayload: 'Draw the opening shot',
+        DependencyOutputs: new Map(),
+        SubmittingAgentRunID: 'submitting-run-1',
+        Provider: provider,
+        ContextUser: { ID: 'user-1' } as unknown as UserInfo,
+        ...overrides,
+    };
+}
+
+describe('VS-CON-7: TaskGraphAgentRunner preset resolution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        canUserRunAgent.mockResolvedValue(true);
+        processAgentArtifacts.mockResolvedValue(undefined);
+        mockEngineConfig.mockResolvedValue(undefined);
+        mockRunAgent.mockResolvedValue({
+            success: true,
+            agentRun: { ID: 'child-run-1', Message: 'Done' },
+            payload: { result: 'ok' },
+        });
+    });
+
+    it('resolves ConfigurationPresetName to the matching preset AIConfigurationID', async () => {
+        mockGetAgentConfigurationPresets.mockReturnValue([
+            {
+                ID: 'preset-draft',
+                Name: 'Draft',
+                DisplayName: 'Draft Mode',
+                AIConfigurationID: 'cfg-draft-1',
+                Status: 'Active',
+            },
+            {
+                ID: 'preset-high',
+                Name: 'High',
+                DisplayName: 'High Fidelity',
+                AIConfigurationID: 'cfg-high-1',
+                Status: 'Active',
+            },
+        ]);
+
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(
+            makeParams({ ConfigurationPresetName: 'high fidelity' })
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].configurationId).toBe('cfg-high-1');
+    });
+
+    it('passes configurationId: undefined when the matched preset has NULL AIConfigurationID, even if the submitting run has a ConfigurationID', async () => {
+        mockGetAgentConfigurationPresets.mockReturnValue([
+            {
+                ID: 'preset-default',
+                Name: 'SystemDefault',
+                DisplayName: 'System Default',
+                AIConfigurationID: null,
+                Status: 'Active',
+            },
+        ]);
+
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(
+            makeParams({ ConfigurationPresetName: 'SystemDefault' }, 'parent-cfg-1')
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].configurationId).toBeUndefined();
+    });
+
+    it('falls back to the submitting run ConfigurationID when ConfigurationPresetName is not specified', async () => {
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(makeParams({}, 'parent-cfg-99'));
+
+        expect(result.Success).toBe(true);
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].configurationId).toBe('parent-cfg-99');
+    });
+
+    it('fails the task with a clear message when ConfigurationPresetName does not match any active preset at run time', async () => {
+        mockGetAgentConfigurationPresets.mockReturnValue([
+            {
+                ID: 'preset-draft',
+                Name: 'Draft',
+                DisplayName: 'Draft Mode',
+                AIConfigurationID: 'cfg-draft-1',
+                Status: 'Active',
+            },
+        ]);
+
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(
+            makeParams({ ConfigurationPresetName: 'DeletedPreset' })
+        );
+
+        expect(result.Success).toBe(false);
+        expect(result.ErrorMessage).toBe(
+            "Agent 'Storyboard Artist' has no active preset 'DeletedPreset'. Available: Draft."
+        );
+        expect(mockRunAgent).not.toHaveBeenCalled();
+    });
+});
+
+describe('VS-INV-2b / VS-QA-3 #9: TaskGraphAgentRunner parentAgentHierarchy from submitted task', () => {
+    const RUN_B_ID = '22222222-2222-4222-8222-222222222222';
+    const RUN_C_ID = '33333333-3333-4333-8333-333333333333';
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        canUserRunAgent.mockResolvedValue(true);
+        processAgentArtifacts.mockResolvedValue(undefined);
+        mockEngineConfig.mockResolvedValue(undefined);
+        mockRunAgent.mockResolvedValue({
+            success: true,
+            agentRun: { ID: 'child-run-1', Message: 'Done' },
+            payload: { result: 'ok' },
+        });
+    });
+
+    it('reads root-first ParentAgentHierarchy carried from the submitted task without running RunView in a loop (VS-QA-3 #9)', async () => {
+        const runner = new TaskGraphAgentRunner();
+        const params = makeParams(
+            {
+                SubmittingAgentRunID: RUN_C_ID,
+                ParentAgentHierarchy: ['A', 'B', 'C'],
+            },
+            'parent-cfg-1',
+            { ID: RUN_C_ID, Agent: 'C', ParentRunID: RUN_B_ID },
+        );
+
+        const result = await runner.RunAgentForTask(params);
+
+        expect(result.Success).toBe(true);
+        expect(mockRunView).not.toHaveBeenCalled();
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].parentAgentHierarchy).toEqual(['A', 'B', 'C']);
+    });
+
+    it('falls back to the loaded parentRun agent name when ParentAgentHierarchy is omitted, with zero RunView calls', async () => {
+        const runner = new TaskGraphAgentRunner();
+        const params = makeParams(
+            { SubmittingAgentRunID: RUN_C_ID },
+            'parent-cfg-1',
+            { ID: RUN_C_ID, Agent: 'C', ParentRunID: RUN_B_ID },
+        );
+
+        const result = await runner.RunAgentForTask(params);
+
+        expect(result.Success).toBe(true);
+        expect(mockRunView).not.toHaveBeenCalled();
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].parentAgentHierarchy).toEqual(['C']);
+    });
+
+    it('passes undefined parentAgentHierarchy and performs no RunView reads when there is no parentRun and no ParentAgentHierarchy', async () => {
+        const runner = new TaskGraphAgentRunner();
+        const result = await runner.RunAgentForTask(
+            makeParams({ SubmittingAgentRunID: undefined }),
+        );
+
+        expect(result.Success).toBe(true);
+        expect(mockRunView).not.toHaveBeenCalled();
+        expect(mockRunAgent).toHaveBeenCalledTimes(1);
+        expect(mockRunAgent.mock.calls[0][0].parentAgentHierarchy).toBeUndefined();
+    });
+});
 
 describe('TaskGraphAgentRunner', () => {
     beforeEach(() => {
@@ -264,3 +519,4 @@ describe('TaskGraphAgentRunner', () => {
     });
 });
 
+

package/src/__tests__/ViewOperationsHandler.test.ts

@@ -267,16 +267,13 @@ describe('ViewOperationsHandler.getEntityViews', () => {
         expect(outcome.error).toBe('timeout talking to DB');
     });
 
-    it('KNOWN GAP: the entity name is interpolated into ExtraFilter without escaping', async () => {
-        // Reachable only for names registered in metadata, so a hostile value requires a
-        // hostile entity name — but an entity legitimately named with an apostrophe
-        // (e.g. "O'Brien Records") already produces a broken/injectable filter today.
+    it('escapes single quotes in the entity name when building ExtraFilter', async () => {
         registerEntity("O'Brien Records", true);
         mockRunViewFn.mockResolvedValue({ Success: true, Results: [] });
 
         await ViewOperationsHandler.getEntityViews("O'Brien Records", makeUser());
 
         const executed = mockRunViewFn.mock.calls[0][0] as RunViewParams;
-        expect(executed.ExtraFilter).toBe(`Entity = 'O'Brien Records'`); // quote NOT doubled
+        expect(executed.ExtraFilter).toBe(`Entity = 'O''Brien Records'`);
     });
 });

package/src/__tests__/WorkQueueHostService.test.ts

@@ -56,9 +56,9 @@ function enabled(overrides: Partial<WorkQueueConfig> = {}): WorkQueueConfig {
 }
 
 describe('workQueue configuration', () => {
-    it('defaults to disabled, running every MJWorker subscription once enabled', () => {
+    it('defaults to enabled, running every MJWorker subscription out of the box', () => {
         expect(WorkQueueSchema.parse({})).toEqual({
-            enabled: false, systemUserEmail: 'system@memberjunction.org', subscriptions: [{ name: '*', concurrency: 4 }],
+            enabled: true, systemUserEmail: 'system@memberjunction.org', subscriptions: [{ name: '*', concurrency: 4 }],
             idlePollMinMs: 250, idlePollMaxMs: 5000, shutdownDrainMs: 8000, sweeperEnabled: true, sweeperIntervalMs: 60000,
             reconcileIntervalMs: 30000,
         });
@@ -94,7 +94,7 @@ describe('host configuration helpers', () => {
 describe('StartWorkQueueHost', () => {
     it('starts nothing when the section is disabled', async () => {
         const rec = recorder();
-        expect(await StartWorkQueueHost(WorkQueueSchema.parse({}), PROVIDER, PROVIDER_SOURCE, rec.Dependencies)).toBeNull();
+        expect(await StartWorkQueueHost(WorkQueueSchema.parse({ enabled: false }), PROVIDER, PROVIDER_SOURCE, rec.Dependencies)).toBeNull();
         expect(rec.EngineCalls).toBe(0);
     });
 
@@ -109,9 +109,18 @@ describe('StartWorkQueueHost', () => {
         await expect(StartWorkQueueHost(enabled(), PROVIDER, PROVIDER_SOURCE, rec.Dependencies)).rejects.toThrow('System user not found with email: system@memberjunction.org');
     });
 
-    it('names the setting to fix when the placeholder email from DEFAULT_SERVER_CONFIG is still in effect', async () => {
-        const rec = recorder();
-        await expect(StartWorkQueueHost(enabled({ systemUserEmail: 'not.set@nowhere.com' }), PROVIDER, PROVIDER_SOURCE, rec.Dependencies))
+    it('falls back to FindSystemUser when default systemUserEmail is not literal in UserCache', async () => {
+        const rec = recorder([]);
+        rec.Dependencies.FindSystemUser = () => SYSTEM_USER;
+        const host = await StartWorkQueueHost(WorkQueueSchema.parse({}), PROVIDER, PROVIDER_SOURCE, rec.Dependencies);
+        expect(host).not.toBeNull();
+        expect(rec.EngineCalls).toBe(1);
+    });
+
+    it('names the setting to fix when an explicit custom email is not found even if FindSystemUser exists', async () => {
+        const rec = recorder([]);
+        rec.Dependencies.FindSystemUser = () => SYSTEM_USER;
+        await expect(StartWorkQueueHost(enabled({ systemUserEmail: 'missing-worker@example.com' }), PROVIDER, PROVIDER_SOURCE, rec.Dependencies))
             .rejects.toThrow('set workQueue.systemUserEmail');
     });
 
@@ -126,7 +135,16 @@ describe('StartWorkQueueHost', () => {
 });
 
 describe('MJServerWorkQueueProviderSource', () => {
-    it('falls back to the shared server provider when there is no SQL Server pool', async () => {
+    it('mints an independent provider instance when fallback implements CreateIndependentInstance (e.g. PostgreSQL)', async () => {
+        const independent = { Name: 'independent-pg-provider' } as IMetadataProvider;
+        const createIndependent = vi.fn().mockResolvedValue(independent);
+        const pgFallback = Object.assign({}, PROVIDER, { CreateIndependentInstance: createIndependent });
+        const source = new MJServerWorkQueueProviderSource(null, pgFallback);
+        expect(await source.CreateProvider()).toBe(independent);
+        expect(createIndependent).toHaveBeenCalledTimes(1);
+    });
+
+    it('falls back to the shared server provider when there is no SQL Server pool and no CreateIndependentInstance', async () => {
         const source = new MJServerWorkQueueProviderSource(null, PROVIDER);
         expect(await source.CreateProvider()).toBe(PROVIDER);
     });