@zereight/mcp-gitlab 2.1.63 → 2.1.65

package/build/test/test-list-merge-requests.js

@@ -103,6 +103,42 @@ describe('list_merge_requests', () => {
         assert.ok(Array.isArray(mrs), 'Response should be an array');
         assert.strictEqual(mrs.length, 2, 'Should return 2 mock MRs');
     });
+    test('omits empty optional filters instead of sending mutually exclusive query parameters', async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler('get', '/merge_requests', (req, res) => {
+            capturedUrl = req.originalUrl;
+            const hasEmptyFilter = Object.values(req.query).some(value => value === '');
+            if (hasEmptyFilter) {
+                res.status(400).json({ message: 'empty filters are invalid' });
+                return;
+            }
+            res.json([]);
+        });
+        try {
+            const mrs = await callListMergeRequests({
+                assignee_id: '',
+                assignee_username: '',
+                author_id: '',
+                author_username: '',
+                reviewer_id: '',
+                reviewer_username: '',
+                milestone: ' ',
+                search: '\t',
+                target_branch: '  ',
+                source_branch: '\n',
+                labels: [],
+                approved_by_usernames: [],
+            }, {
+                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+            });
+            assert.deepStrictEqual(mrs, []);
+            assert.strictEqual(capturedUrl, '/api/v4/merge_requests');
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
     test('forwards approved_by_usernames in bracket-array form', async () => {
         let capturedUrl;
         mockGitLab.addMockHandler('get', '/merge_requests', (req, res) => {
@@ -122,4 +158,44 @@ describe('list_merge_requests', () => {
             mockGitLab.clearCustomHandlers();
         }
     });
+    test('drops blank entries inside array filters', async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler('get', '/merge_requests', (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            await callListMergeRequests({ labels: ['', '  ', 'bug'], approved_by_usernames: ['alice', ''] }, {
+                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+            });
+            assert.ok(capturedUrl, 'Mock handler should have received a request');
+            // Parse the query so the assertion does not depend on parameter order
+            const params = new URL(capturedUrl, 'http://localhost').searchParams;
+            assert.deepStrictEqual(params.getAll('labels'), ['bug'], 'Blank array entries should be dropped while non-blank ones are kept');
+            assert.deepStrictEqual(params.getAll('approved_by_usernames[]'), ['alice'], 'Blank array entries should be dropped while non-blank ones are kept');
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+    test('omits array filters whose entries are all blank', async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler('get', '/merge_requests', (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            const mrs = await callListMergeRequests({ labels: ['', ' '], approved_by_usernames: [''] }, {
+                GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+                GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+            });
+            assert.deepStrictEqual(mrs, []);
+            assert.ok(capturedUrl, 'Mock handler should have received a request');
+            assert.strictEqual(new URL(capturedUrl, 'http://localhost').search, '', 'Array filters with only blank entries should not be serialized');
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
 });

package/build/test/test-list-milestones.js

@@ -0,0 +1,145 @@
+import { describe, test, before, after } from "node:test";
+import assert from "node:assert";
+import { spawn } from "child_process";
+import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
+const MOCK_TOKEN = "glpat-mock-token-12345";
+const TEST_PROJECT_ID = "123";
+const TEST_GROUP_ID = "my-group";
+// Milestone tools live in the non-default "milestones" toolset
+const TOOLSET_ENV = { GITLAB_TOOLSETS: "milestones" };
+// Helper to run an MCP tool through the stdio server
+async function callTool(toolName, args, env) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("node", ["build/index.js"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ...TOOLSET_ENV,
+                ...env,
+                GITLAB_READ_ONLY_MODE: "true",
+            },
+        });
+        let output = "";
+        let errorOutput = "";
+        proc.stdout?.on("data", d => (output += d));
+        proc.stderr?.on("data", d => (errorOutput += d));
+        proc.on("close", code => {
+            if (code !== 0)
+                return reject(new Error(`Process exited with code ${code}: ${errorOutput}`));
+            const line = output.split("\n").find(l => l.startsWith("{"));
+            if (!line)
+                return reject(new Error("No JSON output found"));
+            try {
+                const response = JSON.parse(line);
+                if (response.error) {
+                    reject(new Error(JSON.stringify(response.error)));
+                    return;
+                }
+                const content = response.result?.content?.[0]?.text;
+                if (content) {
+                    try {
+                        resolve(JSON.parse(content));
+                    }
+                    catch {
+                        reject(new Error(`Failed to parse tool output JSON: ${content}`));
+                    }
+                }
+                else {
+                    resolve(response.result);
+                }
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+        proc.stdin?.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "tools/call",
+            params: { name: toolName, arguments: args },
+        }) + "\n");
+    });
+}
+describe("milestone list iids filters", () => {
+    let mockGitLab;
+    let mockGitLabUrl;
+    before(async () => {
+        const mockPort = await findMockServerPort();
+        mockGitLab = new MockGitLabServer({ port: mockPort, validTokens: [MOCK_TOKEN] });
+        await mockGitLab.start();
+        mockGitLabUrl = mockGitLab.getUrl();
+    });
+    after(async () => {
+        await mockGitLab.stop();
+    });
+    const env = () => ({
+        GITLAB_API_URL: `${mockGitLabUrl}/api/v4`,
+        GITLAB_PERSONAL_ACCESS_TOKEN: MOCK_TOKEN,
+    });
+    test("omits an empty iids filter for list_milestones", async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/milestones`, (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            const milestones = await callTool("list_milestones", { project_id: TEST_PROJECT_ID, iids: [] }, env());
+            assert.deepStrictEqual(milestones, []);
+            assert.ok(capturedUrl, "Mock handler should have received a request");
+            assert.strictEqual(new URL(capturedUrl, "http://localhost").search, "", "An empty iids array should not be serialized as `iids=`");
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+    test("forwards non-empty iids in bracket-array form", async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/milestones`, (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            await callTool("list_milestones", { project_id: TEST_PROJECT_ID, iids: [1, 2] }, env());
+            assert.ok(capturedUrl, "Mock handler should have received a request");
+            const params = new URL(capturedUrl, "http://localhost").searchParams;
+            assert.deepStrictEqual(params.getAll("iids[]"), ["1", "2"]);
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+    test("omits blank milestone filters", async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler("get", `/projects/${TEST_PROJECT_ID}/milestones`, (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            await callTool("list_milestones", { project_id: TEST_PROJECT_ID, iids: [], title: "  ", search: "" }, env());
+            assert.ok(capturedUrl, "Mock handler should have received a request");
+            assert.strictEqual(new URL(capturedUrl, "http://localhost").search, "", "Blank milestone filters should not be serialized");
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+    test("omits an empty iids filter for list_group_milestones", async () => {
+        let capturedUrl;
+        mockGitLab.addMockHandler("get", `/groups/${TEST_GROUP_ID}/milestones`, (req, res) => {
+            capturedUrl = req.originalUrl;
+            res.json([]);
+        });
+        try {
+            const milestones = await callTool("list_group_milestones", { group_id: TEST_GROUP_ID, iids: [], state: "active" }, env());
+            assert.deepStrictEqual(milestones, []);
+            assert.ok(capturedUrl, "Mock handler should have received a request");
+            const params = new URL(capturedUrl, "http://localhost").searchParams;
+            assert.equal(params.has("iids"), false, "An empty iids array should not be serialized as `iids=`");
+            assert.deepStrictEqual(params.getAll("iids[]"), []);
+            assert.deepStrictEqual(params.getAll("state"), ["active"]);
+        }
+        finally {
+            mockGitLab.clearCustomHandlers();
+        }
+    });
+});

package/build/test/test-permission-mode.js

@@ -7,6 +7,7 @@
  */
 import { describe, test, after, before } from "node:test";
 import assert from "node:assert";
+import { allTools, deleteTools, destructiveTools } from "../tools/registry.js";
 import { launchServer, findAvailablePort, cleanupServers, TransportMode, HOST, } from "./utils/server-launcher.js";
 import { MockGitLabServer, findMockServerPort } from "./utils/mock-gitlab-server.js";
 import { CustomHeaderClient } from "./clients/custom-header-client.js";
@@ -50,6 +51,29 @@ async function getToolNames(server) {
     await client.disconnect();
     return result.tools.map((t) => t.name);
 }
+/**
+ * Asserts that a query passes the modify-mode guard *and* is forwarded to GitLab. The mock
+ * server has no `/api/graphql` route, so the call comes back as a downstream
+ * "GraphQL request failed" — that failure is the evidence the guard let the query through,
+ * which a "does not throw" check alone would not provide.
+ */
+async function assertQueryReachesGitLab(server, query) {
+    const client = await connectClient(server);
+    try {
+        let outcome;
+        try {
+            outcome = JSON.stringify(await client.callTool("execute_graphql", { query }));
+        }
+        catch (error) {
+            outcome = error instanceof Error ? error.message : String(error);
+        }
+        assert.ok(!outcome.includes("modify mode"), `the guard must not fire for "${query}", got: ${outcome}`);
+        assert.ok(outcome.includes("GraphQL request failed"), `"${query}" should be forwarded to GitLab after passing the guard, got: ${outcome}`);
+    }
+    finally {
+        await client.disconnect();
+    }
+}
 const DELETE_SAMPLE_TOOLS = [
     "delete_issue",
     "delete_branch",
@@ -60,6 +84,16 @@ const DELETE_SAMPLE_TOOLS = [
     "delete_project_variable",
     "delete_webhook",
 ];
+// Destructive teardown tools whose names do not start with `delete_`. All five are listed
+// here (list-hiding) and exercised with explicit `callTool` literals below (call-rejection),
+// so the tool-coverage detector sees the call path too.
+const DESTRUCTIVE_SAMPLE_TOOLS = [
+    "cancel_pipeline",
+    "cancel_pipeline_job",
+    "stop_environment",
+    "stop_stale_environments",
+    "unprotect_branch",
+];
 const MODIFY_SAMPLE_TOOLS = [
     "create_issue",
     "update_issue",
@@ -67,9 +101,26 @@ const MODIFY_SAMPLE_TOOLS = [
     "create_branch",
     "push_files",
     "merge_merge_request",
-    "stop_stale_environments",
 ];
 const READ_SAMPLE_TOOLS = ["list_issues", "get_project", "list_merge_requests"];
+describe("Modify-mode deny list invariants", () => {
+    test("deleteTools is a subset of destructiveTools", () => {
+        for (const name of deleteTools) {
+            assert.ok(destructiveTools.has(name), `"${name}" is blocked in modify mode but missing from destructiveTools`);
+        }
+    });
+    test("every blocked tool exists in the registry", () => {
+        const names = new Set(allTools.map(tool => tool.name));
+        for (const name of deleteTools) {
+            assert.ok(names.has(name), `"${name}" is in deleteTools but not in allTools`);
+        }
+    });
+    test("every destructive sample tool is in the modify-mode deny list", () => {
+        for (const name of DESTRUCTIVE_SAMPLE_TOOLS) {
+            assert.ok(deleteTools.has(name), `"${name}" should be blocked in modify mode`);
+        }
+    });
+});
 describe("Permission Mode", { concurrency: 1 }, () => {
     before(async () => {
         const mockPort = await findMockServerPort();
@@ -94,7 +145,12 @@ describe("Permission Mode", { concurrency: 1 }, () => {
         after(() => cleanupServers(servers));
         test("exposes read, modify, and delete tools", async () => {
             const names = await getToolNames(server);
-            for (const name of [...READ_SAMPLE_TOOLS, ...MODIFY_SAMPLE_TOOLS, ...DELETE_SAMPLE_TOOLS]) {
+            for (const name of [
+                ...READ_SAMPLE_TOOLS,
+                ...MODIFY_SAMPLE_TOOLS,
+                ...DELETE_SAMPLE_TOOLS,
+                ...DESTRUCTIVE_SAMPLE_TOOLS,
+            ]) {
                 assert.ok(names.includes(name), `full mode: expected "${name}" to be present`);
             }
         });
@@ -117,6 +173,28 @@ describe("Permission Mode", { concurrency: 1 }, () => {
             }
             assert.ok(!names.some(n => n.startsWith("delete_")), "no delete_* tool should be listed");
         });
+        test("hides destructive stop/cancel/unprotect tools", async () => {
+            const names = await getToolNames(server);
+            for (const name of DESTRUCTIVE_SAMPLE_TOOLS) {
+                assert.ok(!names.includes(name), `modify mode: expected "${name}" to be absent`);
+            }
+        });
+        test("rejects destructive stop/cancel/unprotect tool calls", async () => {
+            const client = await connectClient(server);
+            try {
+                await assert.rejects(() => client.callTool("cancel_pipeline", { project_id: "1", pipeline_id: 1 }), (error) => error.message.includes("not allowed in modify mode"), "cancel_pipeline should be rejected in modify mode");
+                await assert.rejects(() => client.callTool("cancel_pipeline_job", { project_id: "1", job_id: 1 }), (error) => error.message.includes("not allowed in modify mode"), "cancel_pipeline_job should be rejected in modify mode");
+                await assert.rejects(() => client.callTool("stop_environment", { project_id: "1", environment_id: 1 }), (error) => error.message.includes("not allowed in modify mode"), "stop_environment should be rejected in modify mode");
+                await assert.rejects(() => client.callTool("stop_stale_environments", {
+                    project_id: "1",
+                    before: "2026-01-01T00:00:00Z",
+                }), (error) => error.message.includes("not allowed in modify mode"), "stop_stale_environments should be rejected in modify mode");
+                await assert.rejects(() => client.callTool("unprotect_branch", { project_id: "1", branch: "main" }), (error) => error.message.includes("not allowed in modify mode"), "unprotect_branch should be rejected in modify mode");
+            }
+            finally {
+                await client.disconnect();
+            }
+        });
         test("hides purge_dependency_proxy_cache", async () => {
             const names = await getToolNames(server);
             assert.ok(!names.includes("purge_dependency_proxy_cache"), "modify mode: purge_dependency_proxy_cache should be absent");
@@ -136,7 +214,7 @@ describe("Permission Mode", { concurrency: 1 }, () => {
             try {
                 await assert.rejects(() => client.callTool("execute_graphql", {
                     query: 'mutation { issueDelete(input: { projectPath: "g/p", iid: "1" }) { errors } }',
-                }), (error) => error.message.includes("delete mutations in modify mode"), "delete mutation should be rejected in modify mode");
+                }), (error) => error.message.includes("destructive mutations in modify mode"), "delete mutation should be rejected in modify mode");
             }
             finally {
                 await client.disconnect();
@@ -171,17 +249,30 @@ describe("Permission Mode", { concurrency: 1 }, () => {
             }
         });
         test("does not apply the modify-mode guard to non-delete mutations", async () => {
+            // issueSetSeverity writes, but nothing about it is destructive.
+            await assertQueryReachesGitLab(server, "mutation { issueSetSeverity(input: { severity: HIGH }) { errors } }");
+        });
+        test("does not apply the modify-mode guard when the alias looks destructive", async () => {
+            // "stop" is only the caller-chosen label here; the field is issueSetSeverity.
+            await assertQueryReachesGitLab(server, "mutation { stop: issueSetSeverity(input: { severity: HIGH }) { errors } }");
+        });
+        test("rejects a destructive mutation hidden behind a harmless alias", async () => {
             const client = await connectClient(server);
             try {
-                // The mock GitLab server has no GraphQL endpoint, so the call may fail
-                // downstream — but it must not fail with the modify-mode guard error.
-                await client.callTool("execute_graphql", {
-                    query: "mutation { issueSetSeverity(input: { severity: HIGH }) { errors } }",
-                });
-            }
-            catch (error) {
-                assert.ok(error instanceof Error);
-                assert.ok(!error.message.includes("modify mode"), `non-delete mutation should pass the guard, got: ${error.message}`);
+                await assert.rejects(() => client.callTool("execute_graphql", {
+                    query: "mutation { harmless: environmentStop(input: {}) { errors } }",
+                }), (error) => error.message.includes("destructive mutations in modify mode"), "a destructive field must be rejected even when aliased");
+            }
+            finally {
+                await client.disconnect();
+            }
+        });
+        test("rejects jobUnschedule", async () => {
+            const client = await connectClient(server);
+            try {
+                await assert.rejects(() => client.callTool("execute_graphql", {
+                    query: 'mutation { jobUnschedule(input: { id: "gid://gitlab/Ci::Build/1" }) { errors } }',
+                }), (error) => error.message.includes("destructive mutations in modify mode"), "jobUnschedule must be rejected in modify mode");
             }
             finally {
                 await client.disconnect();

package/build/test/test-remote-downloads.js

@@ -30,6 +30,7 @@ const RFC_FORWARDED_HEADERS = {
 // Minimal 1x1 transparent PNG
 const MINIMAL_PNG = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==', 'base64');
 const LARGE_FILE_TOKEN = 'glpat-largefile-test-token';
+const ATTACHMENT_TOKEN = 'glpat-attachment-test-token';
 const FAKE_ZIP = Buffer.from('PK\x03\x04fake-zip-content-for-testing');
 const MOCK_UPLOAD_RESPONSE = {
     id: 99,
@@ -52,7 +53,7 @@ describe('Remote Downloads - Download Proxy Endpoint', { timeout: 30_000 }, () =
         const mockPort = await findMockServerPort();
         mockGitLab = new MockGitLabServer({
             port: mockPort,
-            validTokens: [MOCK_TOKEN, LARGE_FILE_TOKEN],
+            validTokens: [MOCK_TOKEN, LARGE_FILE_TOKEN, ATTACHMENT_TOKEN],
         });
         // Mock artifact download
         mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/${TEST_JOB_ID}/artifacts`, (_req, res) => {
@@ -70,6 +71,13 @@ describe('Remote Downloads - Download Proxy Endpoint', { timeout: 30_000 }, () =
             res.set('Content-Type', 'text/plain');
             res.send('hello document content');
         });
+        // Mock attachment whose name contains a slash. The uploads route takes one filename
+        // segment, so the proxy has to request it as `nested%2Fdocument.txt`; a handler on
+        // `nested/document.txt` would match the wrong route shape and must not be hit.
+        mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/uploads/${TEST_SECRET}/nested%2Fdocument.txt`, (_req, res) => {
+            res.set('Content-Type', 'text/plain');
+            res.send('nested document content');
+        });
         // Mock large artifact (2MB) to verify streaming works for big files
         mockGitLab.addMockHandler('get', `/projects/${TEST_PROJECT_ID}/jobs/999/artifacts`, (_req, res) => {
             res.set('Content-Type', 'application/zip');
@@ -143,6 +151,11 @@ describe('Remote Downloads - Download Proxy Endpoint', { timeout: 30_000 }, () =
         const expectedSize = 2 * 1024 * 1024;
         assert.strictEqual(buf.length, expectedSize, `Should receive full 2MB (got ${buf.length} bytes)`);
     });
+    test('keeps a slash-bearing attachment filename inside one path segment', async () => {
+        const res = await fetch(`http://${HOST}:${serverPort}/downloads/attachment?project_id=${TEST_PROJECT_ID}&secret=${TEST_SECRET}&filename=${encodeURIComponent('nested/document.txt')}`, { headers: { 'Private-Token': ATTACHMENT_TOKEN } });
+        assert.strictEqual(res.status, 200, 'attachment proxy should route to one encoded segment');
+        assert.strictEqual(await res.text(), 'nested document content');
+    });
     test('returns 429 after exceeding rate limit', async () => {
         // Use a different token to get a fresh rate limit counter
         const rateLimitToken = 'glpat-ratelimit-test-token';

package/build/test/utils/graphql-query.test.js

@@ -89,8 +89,80 @@ describe("When graphqlQueryContainsDeleteOperation runs", () => {
         test("should detect delete mutations with variable definitions", () => {
             assert.equal(graphqlQueryContainsDeleteOperation("mutation DeleteIssue($id: IssueID!) { issueDelete(input: { id: $id }) { errors } }"), true);
         });
+        test("should detect comma-prefixed delete mutations", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation(', mutation M { issueDelete(input: { iid: "1" }) { id } }'), true);
+        });
+        test("should detect comma-prefixed delete mutations without whitespace", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation(',mutation{issueDelete(input:{iid:"1"}){id}}'), true);
+        });
+        test("should detect delete mutations after a comma-separated query", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("query HealthCheck { x }, mutation M { issueDelete(input: {}) { id } }"), true);
+        });
+        test("should allow comma-separated queries", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("query A { a }, query B { b }"), false);
+        });
         test("should conservatively block top-level fragment spreads in mutations", () => {
             assert.equal(graphqlQueryContainsDeleteOperation("mutation { ...f } fragment f on Mutation { issueDelete(input: {}) { errors } }"), true);
         });
     });
+    describe("with destructive mutations that are not named delete", () => {
+        test("should detect environmentStop", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation('mutation { environmentStop(input: { environmentId: "gid://gitlab/Environment/1" }) { errors } }'), true);
+        });
+        test("should detect pipelineCancel", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { pipelineCancel(input: {}) { errors } }"), true);
+        });
+        test("should detect clusterAgentTokenRevoke", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { clusterAgentTokenRevoke(input: {}) { errors } }"), true);
+        });
+        test("should detect jobUnschedule", () => {
+            // GitLab moves the scheduled job to manual and clears its scheduled state, so it
+            // is a teardown action even though no teardown verb is part of its name.
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { jobUnschedule(input: {}) { errors } }"), true);
+        });
+        test("should detect aliased destructive mutations", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { s: environmentStop(input: {}) { errors } }"), true);
+        });
+        test("should not treat an alias as a destructive mutation field", () => {
+            for (const query of [
+                "mutation { stop: issueSetSeverity(input: {}) { errors } }",
+                "mutation { revoke: issueSetSeverity(input: {}) { errors } }",
+                "mutation { terminate: updateIssue(input: {}) { issue { id } } }",
+            ]) {
+                assert.equal(graphqlQueryContainsDeleteOperation(query), false, query);
+            }
+        });
+        test("should not treat a spaced or comma-separated alias as a destructive field", () => {
+            for (const query of [
+                "mutation { stop : issueSetSeverity(input: {}) { errors } }",
+                "mutation { revoke,: issueSetSeverity(input: {}) { errors } }",
+                "mutation { terminate\n: updateIssue(input: {}) { issue { id } } }",
+            ]) {
+                assert.equal(graphqlQueryContainsDeleteOperation(query), false, query);
+            }
+        });
+        test("should still detect a destructive field after a spaced alias", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("mutation { harmless : environmentStop(input: {}) { errors } }"), true);
+        });
+        test("should still detect a destructive field hidden behind a harmless alias", () => {
+            for (const query of [
+                "mutation { harmless: environmentStop(input: {}) { errors } }",
+                "mutation { step: pipelineCancel(input: {}) { errors } }",
+            ]) {
+                assert.equal(graphqlQueryContainsDeleteOperation(query), true, query);
+            }
+        });
+        test("should detect destructive mutations in multi-operation documents", () => {
+            assert.equal(graphqlQueryContainsDeleteOperation("query A { project { id } } mutation B { environmentStop(input: {}) { errors } }"), true);
+        });
+        test("should still allow mutations without a destructive verb", () => {
+            for (const query of [
+                "mutation { issueMove(input: {}) { errors } }",
+                "mutation { mergeRequestMerge(input: {}) { errors } }",
+                "mutation { todoMarkDone(input: {}) { errors } }",
+            ]) {
+                assert.equal(graphqlQueryContainsDeleteOperation(query), false, query);
+            }
+        });
+    });
 });