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

package/src/__tests__/CollectInactiveRowWarnings.test.ts

@@ -0,0 +1,115 @@
+/**
+ * The apply's declared-but-inactive-row warnings have to survive the path that PREFETCHES its schema.
+ *
+ * The collection used to live inside the resolver's schema REBUILD, so the batch apply lost it twice:
+ * its own rebuild passed no collector, and handing the result down to the shared builder took the
+ * `prefetchedSourceSchema` branch, which skips the rebuild entirely. An operator whose selected table
+ * came back without a column therefore had nothing to read on the batch path while the single path
+ * explained it.
+ *
+ * The warnings never depended on the rebuild — they are the catalog's own `Status` rows — so the
+ * gathering is a function of (catalog, integration, requested names). These tests pin it against a
+ * literal catalog, which is also the only way to test it at all: the resolver imports schema-builder
+ * and schema-engine and cannot be loaded in a unit test.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CollectInactiveRowWarnings } from '../integration/InactiveRowWarnings.js';
+import type { CatalogStatusReader } from '../integration/InactiveRowWarnings.js';
+
+type Row = { ID: string; Name: string; Status: string | null };
+
+/** A catalog of objects, each with its fields. `Status` is the whole question. */
+function catalog(objects: Array<Row & { Fields: Array<{ Name: string; Status: string | null }> }>): CatalogStatusReader {
+    return {
+        GetActiveIntegrationObjects: () => objects.filter(o => o.Status === 'Active'),
+        GetIntegrationObjectsByIntegrationID: () => objects,
+        GetIntegrationObjectFields: (objectID: string) => objects.find(o => o.ID === objectID)?.Fields ?? [],
+    };
+}
+
+const contacts = {
+    ID: 'io-1', Name: 'Contacts', Status: 'Active',
+    Fields: [
+        { Name: 'ID', Status: 'Active' },
+        { Name: 'MiddleName', Status: 'Disabled' },
+    ],
+};
+const invoices = { ID: 'io-2', Name: 'Invoices', Status: 'Disabled', Fields: [{ Name: 'ID', Status: 'Active' }] };
+
+describe('CollectInactiveRowWarnings', () => {
+    it('names a deactivated FIELD of an object the apply does materialize', () => {
+        const warnings = CollectInactiveRowWarnings(catalog([contacts]), 'int-1', ['Contacts']);
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0]).toContain('Contacts:');
+        expect(warnings[0]).toContain('MiddleName (Disabled)');
+    });
+
+    it('reports a REQUESTED object that is not Active — the caller named it and got nothing', () => {
+        const warnings = CollectInactiveRowWarnings(catalog([contacts, invoices]), 'int-1', ['Contacts', 'Invoices']);
+        expect(warnings.some(w => w.includes('Invoices (Disabled)'))).toBe(true);
+    });
+
+    it('matches requested names case-insensitively, the way the apply resolves them', () => {
+        const warnings = CollectInactiveRowWarnings(catalog([contacts]), 'int-1', ['contacts']);
+        expect(warnings[0]).toContain('MiddleName (Disabled)');
+    });
+
+    it('reads fields ONLY for the objects in scope', () => {
+        // An out-of-scope object's own dropped fields are not this apply's business, and on a large
+        // catalog reporting them would bury the one line that matters.
+        const other = {
+            ID: 'io-3', Name: 'Events', Status: 'Active',
+            Fields: [{ Name: 'Venue', Status: 'Disabled' }],
+        };
+        const warnings = CollectInactiveRowWarnings(catalog([contacts, other]), 'int-1', ['Contacts']);
+        expect(warnings.join(' ')).not.toContain('Venue');
+    });
+
+    it('stays quiet about deactivated OBJECTS when nothing was requested by name', () => {
+        // The unfiltered apply. Hundreds of deactivated objects are the normal state of a large
+        // catalog; the field warnings for what IS materialized still come through.
+        const warnings = CollectInactiveRowWarnings(catalog([contacts, invoices]), 'int-1', []);
+        expect(warnings.join(' ')).not.toContain('Invoices');
+        expect(warnings.join(' ')).toContain('MiddleName (Disabled)');
+    });
+
+    it('says nothing when everything in scope is Active', () => {
+        const clean = {
+            ID: 'io-9', Name: 'Clean', Status: 'Active',
+            Fields: [{ Name: 'ID', Status: 'Active' }],
+        };
+        expect(CollectInactiveRowWarnings(catalog([clean]), 'int-1', ['Clean'])).toEqual([]);
+    });
+});
+
+/**
+ * Under a per-connection catalog the engine answers [] for a connection's fields during an apply, so
+ * every caller has to hand the helper the fields it loaded itself, or field-level warnings vanish.
+ * Read from source: the callers are resolver mutations that need a provider and a pipeline to run.
+ */
+describe('every inactive-row warning caller passes the connection\'s own fields', () => {
+    const SRC = readFileSync(join(__dirname, '..', 'resolvers', 'IntegrationDiscoveryResolver.ts'), 'utf-8');
+    const calls = [...SRC.matchAll(/this\.collectInactiveRowWarnings\(([\s\S]*?)\)\)?;/g)].map(m => m[1]);
+
+    it('finds the callers', () => {
+        expect(calls.length).toBeGreaterThanOrEqual(3);
+    });
+
+    it('passes scopedFields at every call', () => {
+        for (const args of calls) expect(args).toMatch(/scopedFields\s*,?\s*$/);
+    });
+
+    it('loads the fields BEFORE the batch branch, so the prefetched path has them too', () => {
+        const at = SRC.indexOf('if (prefetchedSourceSchema) {');
+        const load = SRC.lastIndexOf('const scopedFields = await LoadScopedFieldsForBuild(', at);
+        expect(at).toBeGreaterThan(-1);
+        expect(load).toBeGreaterThan(-1);
+        expect(at - load).toBeLessThan(400);
+    });
+
+    it('refreshes the catalog caches through the provider the mutation already holds', () => {
+        expect(SRC).not.toMatch(/refreshIntegrationCatalogCaches\(user\);/);
+    });
+});

package/src/__tests__/ConnectionPause.test.ts

@@ -0,0 +1,192 @@
+/**
+ * everything.txt C6: pausing a connection must actually pause it — and resuming must put back
+ * what pause took, not "everything".
+ *
+ * Each test below pins a way this went wrong or would go wrong. The two that matter most are
+ * `DecidePauseWrite` (a second pause must not erase the first pause's record) and the two guards
+ * in `DecideSchedulesToResume` (never resurrect a schedule the operator turned off themselves).
+ */
+import { describe, it, expect } from 'vitest';
+import {
+    DecideSchedulesToPause,
+    DecidePauseWrite,
+    DecideSchedulesToResume,
+    ReadPausedSchedules,
+    WritePausedSchedules,
+    DescribeCancelScope,
+    DescribeCancelOutcome,
+    DescribePauseOutcome,
+    PAUSED_SCHEDULES_KEY,
+    type ScheduleJobState,
+    type PausedScheduleRecord,
+} from '../integration/ConnectionPause.js';
+
+const job = (ID: string, Status: string | null, Kind: 'sync' | 'discovery' = 'sync'): ScheduleJobState =>
+    ({ ID, Status, Kind });
+
+describe('DecideSchedulesToPause', () => {
+    it('moves only the Active jobs', () => {
+        const out = DecideSchedulesToPause([job('a', 'Active'), job('b', 'Paused', 'discovery'), job('c', 'Active', 'discovery')]);
+        expect(out.map(r => r.ID)).toEqual(['a', 'c']);
+    });
+
+    it('leaves an already-Paused job out of the record, so resume cannot turn it on', () => {
+        // The whole point: 'b' was off before the pause. If it appeared here, resume would
+        // silently start a schedule the operator had deliberately stopped.
+        const out = DecideSchedulesToPause([job('b', 'Paused')]);
+        expect(out).toEqual([]);
+    });
+
+    it('ignores statuses that are neither Active nor Paused', () => {
+        expect(DecideSchedulesToPause([job('x', 'Disabled'), job('y', null)])).toEqual([]);
+    });
+
+    it('carries the kind through for the operator message', () => {
+        expect(DecideSchedulesToPause([job('a', 'Active', 'discovery')])).toEqual([{ ID: 'a', Kind: 'discovery' }]);
+    });
+});
+
+describe('DecidePauseWrite — the second pause must not erase the first', () => {
+    it('writes the record on a first pause', () => {
+        expect(DecidePauseWrite([], [{ ID: 'a', Kind: 'sync' }])).toEqual([{ ID: 'a', Kind: 'sync' }]);
+    });
+
+    it('REFUSES to overwrite a stored record with the empty set a re-pause produces', () => {
+        // Deactivate an already-deactivated connection: every job is Paused, so nothing is
+        // "moved" and newlyPaused is []. Writing that would lose the record and strand both
+        // schedules off forever, with no error anywhere.
+        const stored: PausedScheduleRecord[] = [{ ID: 'a', Kind: 'sync' }, { ID: 'b', Kind: 'discovery' }];
+        expect(DecidePauseWrite(stored, [])).toBeNull();
+    });
+
+    it('adds what a re-pause DID move to the stored record, keeping the stored entries as they were', () => {
+        // A schedule created or switched back on while paused, or a record a resume could not
+        // clear. Dropping the newly paused job would leave it paused with nothing to restore it.
+        const stored: PausedScheduleRecord[] = [{ ID: 'a', Kind: 'sync' }];
+        expect(DecidePauseWrite(stored, [{ ID: 'c', Kind: 'discovery' }])).toEqual([
+            { ID: 'a', Kind: 'sync' },
+            { ID: 'c', Kind: 'discovery' },
+        ]);
+    });
+
+    it('writes nothing when everything the re-pause moved is already recorded, whatever the id casing', () => {
+        const stored: PausedScheduleRecord[] = [{ ID: 'abc-1', Kind: 'sync' }];
+        expect(DecidePauseWrite(stored, [{ ID: 'ABC-1', Kind: 'sync' }])).toBeNull();
+    });
+
+    it('writes nothing when there is neither a stored record nor anything moved', () => {
+        expect(DecidePauseWrite([], [])).toBeNull();
+    });
+});
+
+describe('DecideSchedulesToResume', () => {
+    it('restores exactly the recorded jobs', () => {
+        const stored: PausedScheduleRecord[] = [{ ID: 'a', Kind: 'sync' }];
+        expect(DecideSchedulesToResume(stored, [job('a', 'Paused'), job('b', 'Paused')])).toEqual(['a']);
+    });
+
+    it('never touches a job that was NOT recorded, however it looks now', () => {
+        // 'b' is Paused and looks identical to 'a'. Only the record distinguishes them.
+        const out = DecideSchedulesToResume([{ ID: 'a', Kind: 'sync' }], [job('a', 'Paused'), job('b', 'Paused')]);
+        expect(out).not.toContain('b');
+    });
+
+    it('does not resurrect a recorded job that has since been deleted', () => {
+        expect(DecideSchedulesToResume([{ ID: 'gone', Kind: 'sync' }], [job('a', 'Paused')])).toEqual([]);
+    });
+
+    it('does not rewrite a recorded job someone already set back to Active', () => {
+        expect(DecideSchedulesToResume([{ ID: 'a', Kind: 'sync' }], [job('a', 'Active')])).toEqual([]);
+    });
+
+    it('returns nothing when the record is empty', () => {
+        expect(DecideSchedulesToResume([], [job('a', 'Paused')])).toEqual([]);
+    });
+});
+
+describe('Configuration round-trip', () => {
+    it('preserves unrelated keys when writing', () => {
+        const cfg = JSON.stringify({ discoveryMaxRecords: 50, catalogSource: 'perConnection' });
+        const out = JSON.parse(WritePausedSchedules(cfg, [{ ID: 'a', Kind: 'sync' }]));
+        expect(out.discoveryMaxRecords).toBe(50);
+        expect(out.catalogSource).toBe('perConnection');
+        expect(out[PAUSED_SCHEDULES_KEY]).toEqual([{ ID: 'a', Kind: 'sync' }]);
+    });
+
+    it('removes the key entirely when the record is cleared, rather than leaving []', () => {
+        const cfg = WritePausedSchedules(JSON.stringify({ a: 1 }), [{ ID: 'x', Kind: 'sync' }]);
+        const cleared = JSON.parse(WritePausedSchedules(cfg, []));
+        expect(PAUSED_SCHEDULES_KEY in cleared).toBe(false);
+        expect(cleared.a).toBe(1);
+    });
+
+    it('round-trips', () => {
+        const rec: PausedScheduleRecord[] = [{ ID: 'a', Kind: 'sync' }, { ID: 'b', Kind: 'discovery' }];
+        expect(ReadPausedSchedules(WritePausedSchedules(null, rec))).toEqual(rec);
+    });
+
+    it('reads nothing from null, junk, an array, or a non-array value', () => {
+        expect(ReadPausedSchedules(null)).toEqual([]);
+        expect(ReadPausedSchedules('not json {')).toEqual([]);
+        expect(ReadPausedSchedules('[1,2,3]')).toEqual([]);
+        expect(ReadPausedSchedules(JSON.stringify({ [PAUSED_SCHEDULES_KEY]: 'nope' }))).toEqual([]);
+    });
+
+    it('drops malformed entries instead of yielding an id-less record', () => {
+        // An entry with no ID would produce a restore target of undefined.
+        const cfg = JSON.stringify({ [PAUSED_SCHEDULES_KEY]: [{ Kind: 'sync' }, null, 7, { ID: '', Kind: 'sync' }, { ID: 'ok' }] });
+        expect(ReadPausedSchedules(cfg)).toEqual([{ ID: 'ok', Kind: 'sync' }]);
+    });
+
+    it('replaces, rather than refuses, when Configuration is unparseable', () => {
+        const out = JSON.parse(WritePausedSchedules('{broken', [{ ID: 'a', Kind: 'sync' }]));
+        expect(out[PAUSED_SCHEDULES_KEY]).toEqual([{ ID: 'a', Kind: 'sync' }]);
+    });
+});
+
+describe('DescribeCancelScope — reports what is TRUE, not what is reassuring', () => {
+    it('says none when nothing is live', () => {
+        expect(DescribeCancelScope({ liveRunPresent: false, durableRequestRecorded: false, runningInThisProcess: true }))
+            .toBe('none');
+    });
+
+    it('prefers durable when the request was recorded', () => {
+        expect(DescribeCancelScope({ liveRunPresent: true, durableRequestRecorded: true, runningInThisProcess: false }))
+            .toBe('durable');
+    });
+
+    it('falls back to this-process when only the in-process registry knows', () => {
+        expect(DescribeCancelScope({ liveRunPresent: true, durableRequestRecorded: false, runningInThisProcess: true }))
+            .toBe('this-process');
+    });
+
+    it('admits unknown when a run is live and neither signal reached it', () => {
+        // The tenant has no CancelRequestedAt column and the owner is another process.
+        expect(DescribeCancelScope({ liveRunPresent: true, durableRequestRecorded: false, runningInThisProcess: false }))
+            .toBe('unknown');
+    });
+
+    it('never promises a stop it cannot deliver', () => {
+        expect(DescribeCancelOutcome('unknown')).not.toMatch(/will stop/i);
+        expect(DescribeCancelOutcome('unknown')).toMatch(/no new sync will start/i);
+        expect(DescribeCancelOutcome('durable')).toMatch(/will stop after the current batch/i);
+        expect(DescribeCancelOutcome('none')).toBe('');
+    });
+});
+
+describe('DescribePauseOutcome', () => {
+    it('names both schedules when both moved', () => {
+        const msg = DescribePauseOutcome([{ ID: 'a', Kind: 'sync' }, { ID: 'b', Kind: 'discovery' }], false);
+        expect(msg).toMatch(/data sync and schema refresh/);
+        expect(msg).toMatch(/schedules\./);
+    });
+
+    it('is singular for one', () => {
+        expect(DescribePauseOutcome([{ ID: 'a', Kind: 'discovery' }], false)).toBe('Paused the schema refresh schedule.');
+    });
+
+    it('distinguishes "already paused" from "nothing to pause"', () => {
+        expect(DescribePauseOutcome([], true)).toMatch(/already paused/i);
+        expect(DescribePauseOutcome([], false)).toMatch(/No active schedules/i);
+    });
+});

package/src/__tests__/ConnectionPauseResolver.test.ts

@@ -0,0 +1,166 @@
+/**
+ * everything.txt C6 — "deactivate" has to stop the connection, not just flag it.
+ *
+ * Before this, IsActive=false stopped syncs (the engine checks it) and nothing else. The cron
+ * jobs kept firing, DISCOVERY was never gated at all — so a paused connection went on rescanning
+ * the vendor on a timer — and an in-flight sync ran to the end. Each test below pins one of the
+ * three things that now have to happen, plus the two things that must NOT.
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const SRC = readFileSync(join(__dirname, '..', 'resolvers', 'IntegrationDiscoveryResolver.ts'), 'utf-8');
+
+function methodBody(name: string): string {
+  const i = SRC.indexOf(`async ${name}(`);
+  expect(i, `${name} not found`).toBeGreaterThan(-1);
+  const rest = SRC.slice(i);
+  const end = rest.search(/\n    @(Query|Mutation)\(/);
+  return end === -1 ? rest : rest.slice(0, end);
+}
+
+describe('IntegrationDeactivateConnection — pause means pause', () => {
+  const body = () => methodBody('IntegrationDeactivateConnection');
+
+  it('writes IsActive=false before anything else can fail', () => {
+    // The flag is what every other actor reads. If a later step throws, the connection must
+    // still be paused — a half-done pause that left IsActive true would be the worst outcome.
+    const b = body();
+    const flag = b.indexOf('ci.IsActive = false');
+    const schedules = b.indexOf('findScheduledJobsForConnection');
+    expect(flag).toBeGreaterThan(-1);
+    expect(schedules).toBeGreaterThan(flag);
+  });
+
+  it('pauses the scheduled jobs', () => {
+    expect(body()).toMatch(/DecideSchedulesToPause/);
+    expect(body()).toMatch(/setScheduledJobStatus\([^)]*'Paused'/s);
+  });
+
+  it('records what it paused through the guard that survives a second pause', () => {
+    // DecidePauseWrite is the only thing standing between a re-pause and a lost record.
+    expect(body()).toMatch(/DecidePauseWrite/);
+    expect(body()).toMatch(/WritePausedSchedules/);
+  });
+
+  it('asks an in-flight sync to stop', () => {
+    expect(body()).toMatch(/CancelSyncAsync/);
+  });
+
+  it('reports how far the cancel actually reached instead of assuming', () => {
+    const b = body();
+    expect(b).toMatch(/DescribeCancelScope/);
+    expect(b).toMatch(/IsSyncRunningInThisProcess/);
+    expect(b).toMatch(/CancelScope/);
+  });
+
+  it('NEVER touches entity maps — those are the user\'s table selection, not pause state', () => {
+    const b = body();
+    expect(b).not.toMatch(/DisableUnselectedEntityMaps/);
+    expect(b).not.toMatch(/SetEntityMapEnabled/);
+    expect(b).not.toMatch(/Company Integration Entity Maps/);
+  });
+
+  it('returns the richer type, so a caller can tell a real stop from a hope', () => {
+    expect(SRC).toMatch(/@Mutation\(\(\) => DeactivateConnectionOutput\)\s*\n\s*async IntegrationDeactivateConnection/);
+  });
+});
+
+describe('IntegrationReactivateConnection — restore exactly what pause took', () => {
+  const body = () => methodBody('IntegrationReactivateConnection');
+
+  it('restores through the record, not by activating everything', () => {
+    const b = body();
+    expect(b).toMatch(/DecideSchedulesToResume/);
+    // The tell for the bug this avoids: no unconditional sweep to Active.
+    expect(b).not.toMatch(/jobs\.map\([^)]*'Active'/s);
+  });
+
+  it('consumes the record so the NEXT pause is not treated as a re-pause', () => {
+    // DecidePauseWrite refuses to write when a record is stored. Leaving a consumed record
+    // behind would make every future pause a silent no-op.
+    expect(body()).toMatch(/WritePausedSchedules\(ci\.Configuration, \[\]\)/);
+  });
+
+  it('still does not rescan the source by default', () => {
+    // Resuming a connection and rescanning its schema stay separate decisions.
+    expect(body()).toMatch(/@Arg\("runSchemaRefresh"[^\n]*defaultValue: false/);
+  });
+});
+
+describe('a Save() that returns false is never mistaken for one that worked', () => {
+  // Save() reports a logical failure by returning false, not by throwing. An unchecked save of the
+  // pause record strands the schedules it paused; an unchecked save of the cleared record makes the
+  // next pause record nothing.
+  for (const name of ['IntegrationDeactivateConnection', 'IntegrationReactivateConnection']) {
+    it(`${name} checks every ci.Save()`, () => {
+      const b = methodBody(name);
+      const all = b.match(/ci\.Save\(\)/g) ?? [];
+      const checked = b.match(/if \(!await ci\.Save\(\)\)/g) ?? [];
+      expect(all.length).toBeGreaterThan(1);
+      expect(checked.length).toBe(all.length);
+    });
+  }
+
+  it('pause saves its record BEFORE it moves any job, and moves nothing if that save fails', () => {
+    const b = methodBody('IntegrationDeactivateConnection');
+    const record = b.indexOf('ci.Configuration = WritePausedSchedules(');
+    const recordSave = b.indexOf('if (!await ci.Save())', record);
+    const firstMove = b.indexOf("setScheduledJobStatus(rec.ID, 'Paused'");
+    expect(record).toBeGreaterThan(-1);
+    expect(recordSave).toBeGreaterThan(record);
+    expect(firstMove).toBeGreaterThan(recordSave);
+    expect(b.slice(recordSave, firstMove)).toMatch(/throw new Error/);
+  });
+
+  it('resume says so on every reply when the record will not clear', () => {
+    const b = methodBody('IntegrationReactivateConnection');
+    expect(b).toMatch(/scheduleNote = ' The record of paused schedules could not be cleared/);
+    const carried = (b.match(/\+ scheduleNote/g) ?? []).length + (b.match(/\$\{scheduleNote\}/g) ?? []).length;
+    expect(carried).toBe(4);
+  });
+});
+
+describe('the connection job finder escapes through the shared helpers', () => {
+  it('validates the connection id with sqlUuid and quotes job type ids with EscapeSQLString', () => {
+    const i = SRC.indexOf('private async findScheduledJobsForConnection');
+    const b = SRC.slice(i, SRC.indexOf('private async describeIfPaused'));
+    expect(i).toBeGreaterThan(-1);
+    expect(b).not.toMatch(/\.replace\(\/'\/g/);
+    expect(b).toMatch(/sqlUuid\(companyIntegrationID, 'companyIntegrationID'\)/);
+    expect(b).toMatch(/EscapeSQLString\(id\)/);
+  });
+});
+
+describe('a paused connection is not scanned', () => {
+  it('the detached discovery start refuses', () => {
+    expect(methodBody('IntegrationStartSchemaRefresh')).toMatch(/describeIfPaused/);
+  });
+
+  it('the synchronous refresh refuses', () => {
+    expect(methodBody('IntegrationRefreshConnectorSchema')).toMatch(/describeIfPaused/);
+  });
+
+  it('schema evolution refuses', () => {
+    expect(methodBody('IntegrationSchemaEvolution')).toMatch(/describeIfPaused/);
+  });
+
+  it('both lock-taking paths check BEFORE acquiring the maintenance lock, so a refusal leaks no lock', () => {
+    for (const name of ['IntegrationRefreshConnectorSchema', 'IntegrationSchemaEvolution']) {
+      const b = methodBody(name);
+      const gate = b.indexOf('describeIfPaused');
+      const lock = b.indexOf('AcquireMaintenanceLock');
+      expect(gate, `${name}: gate missing`).toBeGreaterThan(-1);
+      expect(lock, `${name}: lock missing`).toBeGreaterThan(-1);
+      expect(gate, `${name}: gate must precede the lock`).toBeLessThan(lock);
+    }
+  });
+
+  it('the gate fails OPEN — an unreadable connection is not declared paused', () => {
+    const i = SRC.indexOf('private async describeIfPaused');
+    expect(i).toBeGreaterThan(-1);
+    const b = SRC.slice(i, i + 1400);
+    expect(b).toMatch(/catch[\s\S]*return null/);
+  });
+});

package/src/__tests__/ConnectionPauseSave.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Pause and resume, driven through the resolver with a Save() that returns false.
+ *
+ * Save() reports a logical failure by returning false rather than throwing, so the only way to
+ * prove a failed save is handled is to run the mutation against one. ConnectionPauseResolver.test.ts
+ * pins the shape of the code; these pin what happens.
+ */
+// type-graphql decorators call `Reflect.getMetadata`, which only exists once this polyfill is
+// loaded. MUST precede any import that pulls in the resolver file.
+import 'reflect-metadata';
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('type-graphql', () => {
+    const noopDecorator = () => () => undefined;
+    return {
+        Resolver: noopDecorator, Mutation: noopDecorator, Query: noopDecorator, Subscription: noopDecorator,
+        ObjectType: noopDecorator, InputType: noopDecorator, Field: noopDecorator, Arg: noopDecorator,
+        Args: noopDecorator, Ctx: noopDecorator, PubSub: noopDecorator, Root: noopDecorator,
+        Directive: noopDecorator, Authorized: noopDecorator, UseMiddleware: noopDecorator,
+        createUnionType: () => class {}, registerEnumType: () => undefined,
+        AuthorizationError: class AuthorizationError extends Error {},
+        Float: class {}, Int: class {}, ID: class {},
+    };
+});
+
+vi.mock('../config.js', () => ({ configInfo: { databaseSettings: { requestTimeout: 120_000 } } }));
+
+const state = vi.hoisted(() => ({
+    /** Every Save() result in order; anything past the end saves. */
+    saves: [] as boolean[],
+    /** The order things happened in, across the connection row and the jobs. */
+    events: [] as string[],
+    ci: null as null | Record<string, unknown>,
+}));
+
+vi.mock('../util.js', async importOriginal => ({
+    ...(await importOriginal<typeof import('../util.js')>()),
+    GetReadWriteProvider: () => ({
+        GetEntityObject: async () => state.ci,
+    }),
+}));
+
+const { IntegrationDiscoveryResolver } = await import('../resolvers/IntegrationDiscoveryResolver.js');
+const { IntegrationEngine } = await import('@memberjunction/integration-engine');
+const { ReadPausedSchedules, WritePausedSchedules } = await import('../integration/ConnectionPause.js');
+
+type Job = { ID: string; Status: string; Kind: 'sync' | 'discovery' };
+
+function connection(configuration: string | null): Record<string, unknown> {
+    const ci: Record<string, unknown> = {
+        IsActive: true,
+        ScheduleEnabled: true,
+        Configuration: configuration,
+        LatestResult: { Message: 'the database said no' },
+        InnerLoad: async () => true,
+        Save: async () => {
+            const ok = state.saves.length > 0 ? state.saves.shift()! : true;
+            state.events.push(`save:${ok ? 'ok' : 'failed'}:${ReadPausedSchedules(ci.Configuration as string).map(r => r.ID).join(',')}`);
+            return ok;
+        },
+    };
+    return ci;
+}
+
+function resolverWith(jobs: Job[]) {
+    return {
+        getAuthenticatedUser: () => ({ ID: 'user-1' }),
+        findScheduledJobsForConnection: async () => jobs,
+        setScheduledJobStatus: async (id: string, status: string) => {
+            state.events.push(`job:${id}:${status}`);
+            return true;
+        },
+        formatError: (e: unknown) => String(e),
+        startSchemaRefreshPipelineDetached: () => undefined,
+    };
+}
+
+const ctx = { providers: [] } as never;
+
+beforeEach(() => {
+    state.saves = [];
+    state.events = [];
+    vi.spyOn(IntegrationEngine, 'GetSyncProgressAsync').mockResolvedValue(null as never);
+});
+
+describe('IntegrationDeactivateConnection with a failing Save()', () => {
+    const jobs: Job[] = [
+        { ID: 'job-sync', Status: 'Active', Kind: 'sync' },
+        { ID: 'job-disc', Status: 'Active', Kind: 'discovery' },
+    ];
+
+    it('saves the record of what it will pause before it pauses anything', async () => {
+        state.ci = connection(null);
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationDeactivateConnection.call(resolverWith(jobs), 'ci-1', ctx);
+        expect(out.Success).toBe(true);
+        expect(out.SchedulesPaused).toBe(2);
+        expect(state.events.slice(0, 4)).toEqual([
+            'save:ok:',                      // IsActive = false
+            'save:ok:job-sync,job-disc',     // the record, before any job moves
+            'job:job-sync:Paused',
+            'job:job-disc:Paused',
+        ]);
+    });
+
+    it('pauses nothing, and says so, when the record will not save', async () => {
+        state.ci = connection(null);
+        state.saves = [true, false];
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationDeactivateConnection.call(resolverWith(jobs), 'ci-1', ctx);
+        expect(out.Success).toBe(true);
+        expect(out.SchedulesPaused).toBe(0);
+        expect(state.events.filter(e => e.startsWith('job:'))).toEqual([]);
+        expect(out.Message).toContain('Could not pause the schedules');
+    });
+
+    it('stops at the flag when IsActive will not save', async () => {
+        state.ci = connection(null);
+        state.saves = [false];
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationDeactivateConnection.call(resolverWith(jobs), 'ci-1', ctx);
+        expect(out.Success).toBe(false);
+        expect(state.events).toEqual(['save:failed:']);
+    });
+});
+
+describe('IntegrationReactivateConnection with a failing Save()', () => {
+    const paused: Job[] = [{ ID: 'job-sync', Status: 'Paused', Kind: 'sync' }];
+    const record = WritePausedSchedules(null, [{ ID: 'job-sync', Kind: 'sync' }]);
+
+    it('restores the recorded jobs and clears the record', async () => {
+        state.ci = connection(record);
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationReactivateConnection.call(resolverWith(paused), 'ci-1', false, false, ctx);
+        expect(out).toEqual({ Success: true, Message: 'Reactivated' });
+        expect(state.events).toEqual(['save:ok:job-sync', 'job:job-sync:Active', 'save:ok:']);
+    });
+
+    it('says so when the record will not clear, instead of reporting a clean resume', async () => {
+        state.ci = connection(record);
+        state.saves = [true, false];
+        const out = await IntegrationDiscoveryResolver.prototype.IntegrationReactivateConnection.call(resolverWith(paused), 'ci-1', false, false, ctx);
+        expect(out.Success).toBe(true);
+        expect(out.Message).toContain('could not be cleared');
+    });
+});