@credibledata/cred-cli 0.0.103 → 0.0.105

package/dist/commands/connection/updateconnection.spec.js

@@ -0,0 +1,625 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const api_1 = require("../../client/api");
+const clientconfiguration_1 = require("../../clientconfiguration");
+const logger_1 = require("../../logger");
+const host_1 = require("../../setup-core/host");
+const utils = __importStar(require("../../utils"));
+const updateconnection_1 = require("./updateconnection");
+// The stored connection as a read returns it: no secrets.
+const stored = {
+    name: "bq_demo",
+    type: "bigquery",
+    bigqueryConnection: {
+        defaultProjectId: "vscode-demo",
+        location: "US",
+        serviceAccountKeyJson: undefined,
+    },
+    includeTables: ["sales.*"],
+};
+describe("mergeConnectionUpdate", () => {
+    // The use case: the service-account key is old. A file with only the new
+    // key, sent as it is, would clear the project id, because the update
+    // replaces the whole connection.
+    it("rotates a key and keeps everything else", () => {
+        const { connection, changed } = (0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            bigqueryConnection: { serviceAccountKeyJson: '{"new":"key"}' },
+        });
+        (0, chai_1.expect)(connection).to.deep.equal({
+            name: "bq_demo",
+            type: "bigquery",
+            bigqueryConnection: {
+                defaultProjectId: "vscode-demo",
+                location: "US",
+                serviceAccountKeyJson: '{"new":"key"}',
+            },
+            includeTables: ["sales.*"],
+        });
+        (0, chai_1.expect)(changed).to.eql(["bigqueryConnection.serviceAccountKeyJson"]);
+    });
+    // Every update sent re-indexes the connection, so re-applying the same
+    // file must list nothing and send nothing.
+    it("lists nothing as changed when the file repeats the stored values", () => {
+        const { changed } = (0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            type: "bigquery",
+            bigqueryConnection: {
+                defaultProjectId: "vscode-demo",
+                location: "US",
+            },
+            includeTables: ["sales.*"],
+        });
+        (0, chai_1.expect)(changed).to.eql([]);
+        (0, chai_1.expect)((0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            bigqueryConnection: { location: "EU" },
+            includeTables: ["sales.*", "ops.*"],
+        }).changed).to.eql(["bigqueryConnection.location", "includeTables"]);
+    });
+    // A read never returns secrets, so echoing a blank one back must omit it:
+    // the server keeps a stored secret only when its field is left out.
+    it("leaves out blank stored values instead of sending them empty", () => {
+        const withBlank = Object.assign(Object.assign({}, stored), { bigqueryConnection: {
+                defaultProjectId: "p",
+                serviceAccountKeyJson: "",
+            } });
+        const { connection } = (0, updateconnection_1.mergeConnectionUpdate)(withBlank, {
+            name: "bq_demo",
+            bigqueryConnection: { location: "EU" },
+        });
+        (0, chai_1.expect)(connection
+            .bigqueryConnection).to.deep.equal({ defaultProjectId: "p", location: "EU" });
+    });
+    it("carries a postgres proxy over, since the update would remove it", () => {
+        const pg = {
+            name: "pg",
+            type: "postgres",
+            postgresConnection: { host: "db" },
+            proxy: { type: "ssh", host: "bastion" },
+            includeTables: ["public.*"],
+        };
+        const { connection } = (0, updateconnection_1.mergeConnectionUpdate)(pg, {
+            name: "pg",
+            postgresConnection: { password: "new" },
+        });
+        (0, chai_1.expect)(connection.proxy).to.deep.equal({ type: "ssh", host: "bastion" });
+    });
+    // A read returns every attached database; a file naming one of them must
+    // not drop the others, and the server merges stored secrets by position,
+    // so the stored order has to survive.
+    it("merges attached databases by name and keeps the ones the file leaves out", () => {
+        var _a;
+        const duck = {
+            name: "lake",
+            type: "duckdb",
+            duckdbConnection: {
+                attachedDatabases: [
+                    {
+                        name: "a",
+                        type: "bigquery",
+                        bigqueryConnection: { defaultProjectId: "pa" },
+                    },
+                    {
+                        name: "b",
+                        type: "postgres",
+                        postgresConnection: { host: "hb" },
+                    },
+                ],
+            },
+            includeTables: ["a.*"],
+        };
+        const { connection, changed } = (0, updateconnection_1.mergeConnectionUpdate)(duck, {
+            name: "lake",
+            duckdbConnection: {
+                attachedDatabases: [
+                    {
+                        name: "a",
+                        bigqueryConnection: { serviceAccountKeyJson: "k" },
+                    },
+                ],
+            },
+        });
+        (0, chai_1.expect)((_a = connection.duckdbConnection) === null || _a === void 0 ? void 0 : _a.attachedDatabases).to.deep.equal([
+            {
+                name: "a",
+                type: "bigquery",
+                bigqueryConnection: {
+                    defaultProjectId: "pa",
+                    serviceAccountKeyJson: "k",
+                },
+            },
+            { name: "b", type: "postgres", postgresConnection: { host: "hb" } },
+        ]);
+        (0, chai_1.expect)(changed).to.eql([
+            "duckdbConnection.attachedDatabases[a].bigqueryConnection.serviceAccountKeyJson",
+        ]);
+    });
+    it("keeps the rest of a nested block, like a DuckLake catalog", () => {
+        const lake = {
+            name: "dl",
+            type: "ducklake",
+            ducklakeConnection: {
+                catalog: {
+                    metadataSchema: "meta",
+                    postgresConnection: { host: "h", userName: "u", password: "" },
+                },
+                storage: { gcsConnection: { keyId: "id" } },
+            },
+            includeTables: ["main.*"],
+        };
+        const { connection, changed } = (0, updateconnection_1.mergeConnectionUpdate)(lake, {
+            name: "dl",
+            ducklakeConnection: {
+                catalog: { postgresConnection: { password: "new" } },
+            },
+        });
+        (0, chai_1.expect)(connection.ducklakeConnection).to.deep.equal({
+            catalog: {
+                metadataSchema: "meta",
+                postgresConnection: { host: "h", userName: "u", password: "new" },
+            },
+            storage: { gcsConnection: { keyId: "id" } },
+        });
+        (0, chai_1.expect)(changed).to.eql([
+            "ducklakeConnection.catalog.postgresConnection.password",
+        ]);
+    });
+    // Sent whole, a proxy holding only the new key loses its host, and the
+    // server refuses the update for want of a bastion host.
+    it("rotates an SSH proxy key and keeps the proxy's host", () => {
+        const pg = {
+            name: "pg",
+            type: "postgres",
+            postgresConnection: { host: "db" },
+            proxy: {
+                type: "ssh",
+                ssh: { host: "bastion", username: "u", port: 22 },
+            },
+            includeTables: ["public.*"],
+        };
+        const { connection, changed } = (0, updateconnection_1.mergeConnectionUpdate)(pg, {
+            name: "pg",
+            proxy: { ssh: { privateKey: "new" } },
+        });
+        (0, chai_1.expect)(connection.proxy).to.deep.equal({
+            type: "ssh",
+            ssh: { host: "bastion", username: "u", port: 22, privateKey: "new" },
+        });
+        (0, chai_1.expect)(changed).to.eql(["proxy.ssh.privateKey"]);
+    });
+    it("keeps a connection's query metadata", () => {
+        const tagged = Object.assign(Object.assign({}, stored), { queryMetadata: { team: "growth" } });
+        const { connection } = (0, updateconnection_1.mergeConnectionUpdate)(tagged, {
+            name: "bq_demo",
+            bigqueryConnection: { location: "EU" },
+        });
+        (0, chai_1.expect)(connection.queryMetadata).to.deep.equal({ team: "growth" });
+    });
+    // The server clears a list the update leaves out, so null clears it.
+    it("clears a table list the file sets to null", () => {
+        const { connection, changed } = (0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            includeTables: null,
+            excludeAllTables: true,
+        });
+        (0, chai_1.expect)(connection.includeTables).to.equal(undefined);
+        (0, chai_1.expect)(connection.excludeAllTables).to.equal(true);
+        (0, chai_1.expect)(changed).to.eql(["includeTables", "excludeAllTables"]);
+    });
+    // Without includeTables the server stops indexing the connection, so a
+    // password change on one stored with none (an older connection) did that.
+    it("refuses an update that would stop indexing the connection", () => {
+        const noTables = Object.assign(Object.assign({}, stored), { includeTables: undefined, excludeAllTables: false });
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(noTables, {
+            name: "bq_demo",
+            bigqueryConnection: { serviceAccountKeyJson: "k" },
+        })).to.throw("'bq_demo' would have no includeTables after this update, and the server stops indexing a connection without them.");
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(stored, { name: "bq_demo", includeTables: [] })).to.throw("would have no includeTables");
+    });
+    // A read reports a connection that is not indexed as excludeAllTables:
+    // true; sent back, it kept the file's includeTables from being indexed.
+    it("refuses includeTables on a connection that is not indexed, unless the file turns indexing on", () => {
+        const unindexed = Object.assign(Object.assign({}, stored), { excludeAllTables: true });
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(unindexed, {
+            name: "bq_demo",
+            includeTables: ["orders.*"],
+        })).to.throw('Fix: add "excludeAllTables": false to the file.');
+        const { connection } = (0, updateconnection_1.mergeConnectionUpdate)(unindexed, {
+            name: "bq_demo",
+            includeTables: ["orders.*"],
+            excludeAllTables: false,
+        });
+        (0, chai_1.expect)(connection.includeTables).to.eql(["orders.*"]);
+        (0, chai_1.expect)(connection.excludeAllTables).to.equal(false);
+    });
+    // `type` is an ordinary key in query metadata; only the connection and an
+    // attached database are typed.
+    it("changes a query-metadata tag named type", () => {
+        const tagged = Object.assign(Object.assign({}, stored), { queryMetadata: { type: "internal", team: "growth" } });
+        const { connection, changed } = (0, updateconnection_1.mergeConnectionUpdate)(tagged, {
+            name: "bq_demo",
+            queryMetadata: { type: "external" },
+        });
+        (0, chai_1.expect)(connection.queryMetadata).to.deep.equal({
+            type: "external",
+            team: "growth",
+        });
+        (0, chai_1.expect)(changed).to.eql(["queryMetadata.type"]);
+    });
+    // A read never returns a secret, and the server keeps one that is left
+    // out, so the prompt listed a change that never happened.
+    it("refuses null on a secret, which the server would keep", () => {
+        const pg = {
+            name: "pg",
+            type: "postgres",
+            postgresConnection: { host: "db" },
+            includeTables: ["public.*"],
+        };
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(pg, {
+            name: "pg",
+            postgresConnection: { password: null },
+        })).to.throw("The file sets 'pg' postgresConnection.password to null, and the stored connection has no value there to clear");
+    });
+    it("refuses null on a whole block", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            bigqueryConnection: null,
+        })).to.throw("The file sets 'bq_demo' bigqueryConnection to null, which would remove the whole block.");
+    });
+    it("refuses a proxy on a connection that is not postgres", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            proxy: { ssh: { privateKey: "k" } },
+        })).to.throw("only postgres connections take a proxy");
+    });
+    it("refuses to change a connection's type", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(stored, { name: "bq_demo", type: "postgres" })).to.throw("is a bigquery connection, and the file says postgres");
+    });
+    // A DuckDB connection with two attached databases, as a read returns it.
+    const duck = {
+        name: "lake",
+        type: "duckdb",
+        duckdbConnection: {
+            attachedDatabases: [
+                {
+                    name: "a",
+                    type: "bigquery",
+                    bigqueryConnection: { defaultProjectId: "pa" },
+                },
+                { name: "b", type: "postgres", postgresConnection: { host: "hb" } },
+            ],
+        },
+        includeTables: ["a.*"],
+    };
+    // Sent as it was, [] cleared every attached database; a list matched by
+    // name that names nothing changes nothing.
+    it("keeps every attached database when the file gives an empty list", () => {
+        const { connection, changed } = (0, updateconnection_1.mergeConnectionUpdate)(duck, {
+            name: "lake",
+            duckdbConnection: { attachedDatabases: [] },
+        });
+        (0, chai_1.expect)(connection.duckdbConnection).to.deep.equal(duck.duckdbConnection);
+        (0, chai_1.expect)(changed).to.eql([]);
+    });
+    it("refuses null for attached databases, which would remove them all", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(duck, {
+            name: "lake",
+            duckdbConnection: { attachedDatabases: null },
+        })).to.throw("The file sets 'lake' duckdbConnection.attachedDatabases to null, which would remove every entry.");
+    });
+    // Without a name it cannot be matched, and replacing the list with the
+    // file's would drop the others.
+    it("refuses an attached database without a name", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(duck, {
+            name: "lake",
+            duckdbConnection: {
+                attachedDatabases: [
+                    { bigqueryConnection: { serviceAccountKeyJson: "k" } },
+                ],
+            },
+        })).to.throw("Every entry of 'lake' duckdbConnection.attachedDatabases in the file needs the \"name\" of the entry it changes or adds, and 1 has none.");
+    });
+    it("refuses an attached database named twice", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(duck, {
+            name: "lake",
+            duckdbConnection: {
+                attachedDatabases: [
+                    { name: "a", bigqueryConnection: { location: "EU" } },
+                    { name: "a", bigqueryConnection: { location: "US" } },
+                ],
+            },
+        })).to.throw("The file names a more than once");
+    });
+    // Merged, the new type kept the old one's settings and secrets beside it.
+    it("refuses to change an attached database's type", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(duck, {
+            name: "lake",
+            duckdbConnection: {
+                attachedDatabases: [
+                    { name: "a", type: "s3", s3Connection: { accessKeyId: "x" } },
+                ],
+            },
+        })).to.throw("'lake' duckdbConnection.attachedDatabases[a] is a bigquery entry, and the file says s3. Fix: a different type is a different database");
+    });
+    it("refuses another type's block on an attached database", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(duck, {
+            name: "lake",
+            duckdbConnection: {
+                attachedDatabases: [
+                    { name: "b", bigqueryConnection: { location: "EU" } },
+                ],
+            },
+        })).to.throw("Fix: put the changes under duckdbConnection.attachedDatabases[b].postgresConnection.");
+        // The block's name has a digit.
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(duck, {
+            name: "lake",
+            duckdbConnection: {
+                attachedDatabases: [
+                    { name: "b", s3Connection: { accessKeyId: "AKIA" } },
+                ],
+            },
+        })).to.throw("so the file's s3Connection does not apply to it");
+    });
+    // It was never read, so the rest of the file was sent without it.
+    it("refuses another type's block on the connection", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            postgresConnection: { password: "p" },
+            includeTables: ["sales.*"],
+        })).to.throw("'bq_demo' is a bigquery connection, so the file's postgresConnection does not apply to it. Fix: put the changes under bigqueryConnection.");
+    });
+    it("refuses a field the command does not change, blank or not", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            includeTable: ["sales.*"],
+        })).to.throw("The file sets includeTable on 'bq_demo', which this command does not change.");
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(stored, { name: "bq_demo", includeTable: "" })).to.throw("The file sets includeTable on 'bq_demo'");
+    });
+    // Replacing the object with the value would drop the fields beside it.
+    it("refuses a value where the stored connection has an object", () => {
+        (0, chai_1.expect)(() => (0, updateconnection_1.mergeConnectionUpdate)(stored, {
+            name: "bq_demo",
+            bigqueryConnection: "key",
+        })).to.throw("'bq_demo' bigqueryConnection is an object in the stored connection, and the file gives a value.");
+    });
+});
+describe("cred update connection", () => {
+    let sandbox;
+    let workDir;
+    let savedExitCode;
+    beforeEach(() => {
+        sandbox = sinon_1.default.createSandbox();
+        sandbox.stub(logger_1.logger);
+        sandbox.stub(console, "log");
+        workDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "update-connection-"));
+        savedExitCode = process.exitCode;
+        process.exitCode = 0;
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "doesConfigExists")
+            .returns(true);
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "getOrganization")
+            .returns("acme");
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "getProject")
+            .returns("analytics");
+        sandbox
+            .stub(clientconfiguration_1.ClientConfiguration.prototype, "getHeaders")
+            .returns({ Authorization: "Bearer t" });
+    });
+    afterEach(() => {
+        sandbox.restore();
+        process.exitCode = savedExitCode;
+        fs_1.default.rmSync(workDir, { recursive: true, force: true });
+    });
+    function file(contents) {
+        const filePath = path_1.default.join(workDir, "changes.json");
+        fs_1.default.writeFileSync(filePath, JSON.stringify(contents));
+        return filePath;
+    }
+    it("reads the stored connection, then sends the merged one", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "getConnection")
+            .resolves({ data: stored });
+        const update = sandbox
+            .stub(api_1.ConnectionsApi.prototype, "updateConnection")
+            .resolves({ data: {} });
+        yield (0, updateconnection_1.updateConnections)("http://cp", file([
+            {
+                name: "bq_demo",
+                bigqueryConnection: { serviceAccountKeyJson: "k" },
+            },
+        ]), false, true);
+        (0, chai_1.expect)(update.firstCall.args.slice(0, 3)).to.eql([
+            "acme",
+            "analytics",
+            "bq_demo",
+        ]);
+        (0, chai_1.expect)(update.firstCall.args[3]).to.deep.include({
+            bigqueryConnection: {
+                defaultProjectId: "vscode-demo",
+                location: "US",
+                serviceAccountKeyJson: "k",
+            },
+        });
+        (0, chai_1.expect)(process.exitCode).to.equal(0);
+    }));
+    it("sends nothing when the file repeats the stored connection", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "getConnection")
+            .resolves({ data: stored });
+        const update = sandbox.stub(api_1.ConnectionsApi.prototype, "updateConnection");
+        yield (0, updateconnection_1.updateConnections)("http://cp", file({
+            name: "bq_demo",
+            bigqueryConnection: { location: "US" },
+            includeTables: ["sales.*"],
+        }), false, true);
+        (0, chai_1.expect)(update.called).to.equal(false);
+        (0, chai_1.expect)(logger_1.logger.info.firstCall.args[0]).to.equal("Nothing to change in bq_demo: the file changes no stored value.");
+        (0, chai_1.expect)(process.exitCode).to.equal(0);
+    }));
+    // The agent contract: a question that cannot be asked exits 2 naming
+    // --yes. Asked inside the update's try, it was reported as a failed update.
+    it("refuses without a terminal by asking for --yes, and sends nothing", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "getConnection")
+            .resolves({ data: stored });
+        const update = sandbox.stub(api_1.ConnectionsApi.prototype, "updateConnection");
+        // CI runs with a TTY attached, so "no terminal" has to be asked for.
+        const saved = process.env.CRED_NON_INTERACTIVE;
+        process.env.CRED_NON_INTERACTIVE = "1";
+        const error = yield (0, updateconnection_1.updateConnections)("http://cp", file({ name: "bq_demo", bigqueryConnection: { location: "EU" } }), false, false).catch((e) => e);
+        if (saved === undefined)
+            delete process.env.CRED_NON_INTERACTIVE;
+        else
+            process.env.CRED_NON_INTERACTIVE = saved;
+        (0, chai_1.expect)(error).to.be.instanceOf(host_1.NeedsInputError);
+        (0, chai_1.expect)(String(error.message)).to.contain("Pass --yes");
+        (0, chai_1.expect)(update.called).to.equal(false);
+    }));
+    // Confirming can refresh the session; the update after it has to carry the
+    // refreshed token, not the one read before the question.
+    it("reads the headers again for each call", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "getConnection")
+            .resolves({ data: stored });
+        const update = sandbox
+            .stub(api_1.ConnectionsApi.prototype, "updateConnection")
+            .resolves({ data: {} });
+        clientconfiguration_1.ClientConfiguration.prototype.getHeaders
+            .onFirstCall()
+            .returns({ Authorization: "Bearer old" })
+            .returns({ Authorization: "Bearer new" });
+        yield (0, updateconnection_1.updateConnections)("http://cp", file({ name: "bq_demo", bigqueryConnection: { location: "EU" } }), false, true);
+        (0, chai_1.expect)(update.firstCall.args[4]).to.deep.include({
+            headers: { Authorization: "Bearer new" },
+        });
+    }));
+    // The server tests the merged connection and refuses a bad one; that has to
+    // reach the exit code, and later entries still run.
+    it("exits 1 when the server refuses the update, and goes on to the next entry", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "getConnection")
+            .resolves({ data: stored });
+        const update = sandbox.stub(api_1.ConnectionsApi.prototype, "updateConnection");
+        update.onFirstCall().rejects(Object.assign(new Error("Request failed with status code 400"), {
+            isAxiosError: true,
+            response: { status: 400, data: { message: "bad key" } },
+        }));
+        update.onSecondCall().resolves({ data: {} });
+        yield (0, updateconnection_1.updateConnections)("http://cp", file([
+            { name: "bq_demo", bigqueryConnection: { location: "EU" } },
+            { name: "bq_demo", bigqueryConnection: { location: "ASIA" } },
+        ]), false, true);
+        (0, chai_1.expect)(update.callCount).to.equal(2);
+        (0, chai_1.expect)(logger_1.logger.error.calledWith("Failed to update connection bq_demo")).to.equal(true);
+        (0, chai_1.expect)(process.exitCode).to.equal(1);
+    }));
+    it("exits 1 and sends nothing for a connection that does not exist", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox.stub(api_1.ConnectionsApi.prototype, "getConnection").rejects(Object.assign(new Error("Request failed with status code 404"), {
+            isAxiosError: true,
+            response: { status: 404, data: {} },
+        }));
+        const update = sandbox.stub(api_1.ConnectionsApi.prototype, "updateConnection");
+        yield (0, updateconnection_1.updateConnections)("http://cp", file({ name: "nope" }), false, true);
+        (0, chai_1.expect)(update.called).to.equal(false);
+        (0, chai_1.expect)(process.exitCode).to.equal(1);
+    }));
+    // Declining one entry used to end the run, so the entries after it were
+    // never sent.
+    it("skips only the entry the user declines, and goes on to the next", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "getConnection")
+            .resolves({ data: stored });
+        const update = sandbox
+            .stub(api_1.ConnectionsApi.prototype, "updateConnection")
+            .resolves({ data: {} });
+        sandbox
+            .stub(utils, "getConfirmation")
+            .onFirstCall()
+            .resolves(false)
+            .onSecondCall()
+            .resolves(true);
+        yield (0, updateconnection_1.updateConnections)("http://cp", file([
+            { name: "bq_demo", bigqueryConnection: { location: "EU" } },
+            { name: "bq_demo", bigqueryConnection: { location: "ASIA" } },
+        ]), false, false);
+        (0, chai_1.expect)(update.callCount).to.equal(1);
+        (0, chai_1.expect)(update.firstCall.args[3].bigqueryConnection).to.deep.include({ location: "ASIA" });
+        (0, chai_1.expect)(logger_1.logger.info.calledWith("Skipped bq_demo: not confirmed, nothing sent.")).to.equal(true);
+        (0, chai_1.expect)(process.exitCode).to.equal(0);
+    }));
+    it("says when the connection will not be indexed", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "getConnection")
+            .resolves({ data: Object.assign(Object.assign({}, stored), { excludeAllTables: true }) });
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "updateConnection")
+            .resolves({ data: {} });
+        const confirm = sandbox.stub(utils, "getConfirmation").resolves(true);
+        yield (0, updateconnection_1.updateConnections)("http://cp", file({ name: "bq_demo", bigqueryConnection: { location: "EU" } }), false, false);
+        (0, chai_1.expect)(confirm.firstCall.args[0]).to.equal("Update bigqueryConnection.location on connection bq_demo in acme/analytics? It will not be indexed (excludeAllTables is true).");
+    }));
+    it("prints the fix for a file it refuses, and sends nothing", () => __awaiter(void 0, void 0, void 0, function* () {
+        sandbox
+            .stub(api_1.ConnectionsApi.prototype, "getConnection")
+            .resolves({ data: stored });
+        const update = sandbox.stub(api_1.ConnectionsApi.prototype, "updateConnection");
+        yield (0, updateconnection_1.updateConnections)("http://cp", file({ name: "bq_demo", postgresConnection: { password: "p" } }), false, true);
+        (0, chai_1.expect)(update.called).to.equal(false);
+        (0, chai_1.expect)(logger_1.logger.error.calledWith("'bq_demo' is a bigquery connection, so the file's postgresConnection does not apply to it. Fix: put the changes under bigqueryConnection.")).to.equal(true);
+        (0, chai_1.expect)(process.exitCode).to.equal(1);
+    }));
+});
+//# sourceMappingURL=updateconnection.spec.js.map