@google-cloud/cloud-run-mcp 1.5.0 → 1.7.0

package/test/local/cloud-api/build.test.js

@@ -0,0 +1,436 @@
+import assert from 'node:assert/strict';
+import { describe, it, mock } from 'node:test';
+import esmock from 'esmock';
+
+describe('triggerCloudBuild', () => {
+  it('should return a successful build and log correct messages', async () => {
+    const mockBuildId = 'mock-build-id';
+    const mockSuccessResult = {
+      id: mockBuildId,
+      status: 'SUCCESS',
+      results: { images: [{ name: 'gcr.io/mock-project/mock-image' }] },
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockSuccessResult]));
+    const logAndProgressMock = mock.fn();
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(), // Directly execute the function
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+    };
+
+    const result = await triggerCloudBuild(
+      context,
+      'mock-project',
+      'mock-location',
+      'mock-bucket',
+      'mock-blob',
+      'mock-repo',
+      'gcr.io/mock-project/mock-image',
+      true,
+      () => {}
+    );
+
+    assert.deepStrictEqual(result, mockSuccessResult);
+    assert.strictEqual(
+      context.cloudBuildClient.createBuild.mock.callCount(),
+      1
+    );
+    assert.strictEqual(context.cloudBuildClient.getBuild.mock.callCount(), 1);
+
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /completed successfully/);
+    assert.match(logCalls[3].arguments[0], /Image built/);
+  });
+
+  it('should throw an error for a failed build and log correct messages', async () => {
+    const mockBuildId = 'mock-build-id-failure';
+    const mockFailureResult = {
+      id: mockBuildId,
+      status: 'FAILURE',
+      logUrl: 'http://mock-log-url.com',
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockFailureResult]));
+    const logAndProgressMock = mock.fn();
+    const setTimeoutMock = mock.fn((resolve) => resolve());
+    mock.method(global, 'setTimeout', setTimeoutMock);
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+      loggingClient: {
+        getEntries: mock.fn(() =>
+          Promise.resolve([[{ data: 'log line 1' }, { data: 'log line 2' }]])
+        ),
+      },
+    };
+
+    await assert.rejects(
+      () =>
+        triggerCloudBuild(
+          context,
+          'mock-project',
+          'mock-location',
+          'mock-bucket',
+          'mock-blob',
+          'mock-repo',
+          'gcr.io/mock-project/mock-image',
+          true,
+          () => {}
+        ),
+      (err) => {
+        assert.match(err.message, /Build mock-build-id-failure failed/);
+        assert.match(err.message, /log line 1/);
+        assert.match(err.message, /log line 2/);
+        return true;
+      }
+    );
+
+    assert.strictEqual(
+      context.cloudBuildClient.createBuild.mock.callCount(),
+      1
+    );
+    assert.strictEqual(context.cloudBuildClient.getBuild.mock.callCount(), 1);
+    assert.strictEqual(context.loggingClient.getEntries.mock.callCount(), 1);
+    assert.strictEqual(setTimeoutMock.mock.callCount(), 1);
+    assert.strictEqual(setTimeoutMock.mock.calls[0].arguments[1], 10000);
+
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /failed with status: FAILURE/);
+    assert.match(logCalls[3].arguments[0], /Build logs:/);
+    assert.match(logCalls[4].arguments[0], /Attempting to fetch last/);
+    assert.match(logCalls[5].arguments[0], /Successfully fetched snippet/);
+  });
+
+  it('should use buildpacks when no Dockerfile is present', async () => {
+    const mockBuildId = 'mock-build-id-buildpacks';
+    const mockSuccessResult = {
+      id: mockBuildId,
+      status: 'SUCCESS',
+      results: { images: [{ name: 'gcr.io/mock-project/mock-image' }] },
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockSuccessResult]));
+    const createBuildMock = mock.fn(() =>
+      Promise.resolve([
+        {
+          metadata: {
+            build: {
+              id: mockBuildId,
+            },
+          },
+        },
+      ])
+    );
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: () => {},
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: createBuildMock,
+        getBuild: getBuildMock,
+      },
+    };
+
+    await triggerCloudBuild(
+      context,
+      'mock-project',
+      'mock-location',
+      'mock-bucket',
+      'mock-blob',
+      'mock-repo',
+      'gcr.io/mock-project/mock-image',
+      false, // hasDockerfile = false
+      () => {}
+    );
+
+    assert.strictEqual(createBuildMock.mock.callCount(), 1);
+    const buildArg = createBuildMock.mock.calls[0].arguments[0].build;
+    const buildStep = buildArg.steps[0];
+    assert.strictEqual(buildStep.name, 'gcr.io/k8s-skaffold/pack');
+  });
+
+  it('should poll for build status until completion', async () => {
+    const mockBuildId = 'mock-build-id-polling';
+    const mockWorkingResult = { id: mockBuildId, status: 'WORKING' };
+    const mockSuccessResult = {
+      id: mockBuildId,
+      status: 'SUCCESS',
+      results: { images: [{ name: 'gcr.io/mock-project/mock-image' }] },
+    };
+
+    let getBuildCallCount = 0;
+    const getBuildMock = mock.fn(() => {
+      getBuildCallCount++;
+      if (getBuildCallCount === 1) {
+        return Promise.resolve([mockWorkingResult]);
+      }
+      return Promise.resolve([mockSuccessResult]);
+    });
+
+    const logAndProgressMock = mock.fn();
+    const setTimeoutMock = mock.fn((resolve) => resolve());
+    mock.method(global, 'setTimeout', setTimeoutMock);
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+    };
+
+    await triggerCloudBuild(
+      context,
+      'mock-project',
+      'mock-location',
+      'mock-bucket',
+      'mock-blob',
+      'mock-repo',
+      'gcr.io/mock-project/mock-image',
+      true,
+      () => {}
+    );
+
+    assert.strictEqual(getBuildMock.mock.callCount(), 2);
+    assert.strictEqual(setTimeoutMock.mock.callCount(), 1);
+    assert.strictEqual(setTimeoutMock.mock.calls[0].arguments[1], 5000);
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /Build status: WORKING/);
+    assert.match(logCalls[3].arguments[0], /completed successfully/);
+    assert.match(logCalls[4].arguments[0], /Image built/);
+  });
+
+  it('should handle failed build when no logs are found', async () => {
+    const mockBuildId = 'mock-build-id-no-logs';
+    const mockFailureResult = {
+      id: mockBuildId,
+      status: 'FAILURE',
+      logUrl: 'http://mock-log-url.com',
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockFailureResult]));
+    const logAndProgressMock = mock.fn();
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+      loggingClient: {
+        getEntries: mock.fn(() => Promise.resolve([[]])), // No log entries
+      },
+    };
+
+    await assert.rejects(
+      () =>
+        triggerCloudBuild(
+          context,
+          'mock-project',
+          'mock-location',
+          'mock-bucket',
+          'mock-blob',
+          'mock-repo',
+          'gcr.io/mock-project/mock-image',
+          true,
+          () => {}
+        ),
+      (err) => {
+        assert.match(err.message, /Build mock-build-id-no-logs failed/);
+        assert.doesNotMatch(err.message, /Last log lines/);
+        return true;
+      }
+    );
+
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /failed with status: FAILURE/);
+    assert.match(logCalls[3].arguments[0], /Build logs:/);
+    assert.match(logCalls[4].arguments[0], /Attempting to fetch last/);
+    assert.match(logCalls[5].arguments[0], /No specific log entries retrieved/);
+  });
+
+  it('should handle error when fetching logs for a failed build', async () => {
+    const mockBuildId = 'mock-build-id-log-error';
+    const mockFailureResult = {
+      id: mockBuildId,
+      status: 'FAILURE',
+      logUrl: 'http://mock-log-url.com',
+    };
+
+    const getBuildMock = mock.fn(() => Promise.resolve([mockFailureResult]));
+    const logAndProgressMock = mock.fn();
+
+    const { triggerCloudBuild } = await esmock(
+      '../../../lib/cloud-api/build.js',
+      {
+        '../../../lib/cloud-api/helpers.js': {
+          callWithRetry: (fn) => fn(),
+        },
+        '../../../lib/util/helpers.js': {
+          logAndProgress: logAndProgressMock,
+        },
+      }
+    );
+
+    const context = {
+      cloudBuildClient: {
+        createBuild: mock.fn(() =>
+          Promise.resolve([
+            {
+              metadata: {
+                build: {
+                  id: mockBuildId,
+                },
+              },
+            },
+          ])
+        ),
+        getBuild: getBuildMock,
+      },
+      loggingClient: {
+        getEntries: mock.fn(() => Promise.reject(new Error('Log fetch error'))),
+      },
+    };
+
+    await assert.rejects(
+      () =>
+        triggerCloudBuild(
+          context,
+          'mock-project',
+          'mock-location',
+          'mock-bucket',
+          'mock-blob',
+          'mock-repo',
+          'gcr.io/mock-project/mock-image',
+          true,
+          () => {}
+        ),
+      (err) => {
+        assert.match(err.message, /Build mock-build-id-log-error failed/);
+        assert.doesNotMatch(err.message, /Last log lines/);
+        return true;
+      }
+    );
+
+    const { calls: logCalls } = logAndProgressMock.mock;
+    assert.match(logCalls[0].arguments[0], /Initiating Cloud Build/);
+    assert.match(logCalls[1].arguments[0], /Cloud Build job started/);
+    assert.match(logCalls[2].arguments[0], /failed with status: FAILURE/);
+    assert.match(logCalls[3].arguments[0], /Build logs:/);
+    assert.match(logCalls[4].arguments[0], /Attempting to fetch last/);
+    assert.match(
+      logCalls[5].arguments[0],
+      /Failed to fetch build logs snippet/
+    );
+  });
+});

package/test/local/cloud-api/projects.test.js

@@ -0,0 +1,18 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import esmock from 'esmock';
+
+describe('projects', () => {
+  describe('generateProjectId', () => {
+    it('should generate a project id in the correct format', async () => {
+      const { generateProjectId } = await esmock(
+        '../../../lib/cloud-api/projects.js',
+        {}
+      );
+
+      const projectId = generateProjectId();
+      assert.ok(projectId.startsWith('mcp-'));
+      assert.strictEqual(projectId.length, 11);
+    });
+  });
+});

package/test/local/deployment-helpers.test.js

@@ -0,0 +1,231 @@
+/*
+Copyright 2025 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { test, describe, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import esmock from 'esmock';
+import { DEPLOYMENT_CONFIG } from '../../lib/deployment/constants.js';
+
+describe('Deployment Helpers', () => {
+  const fsMock = {
+    statSync: mock.fn(),
+    existsSync: mock.fn(),
+    readFileSync: mock.fn(),
+  };
+
+  test('makeFileDeploymentMetadata correctly identifies Dockerfile in folder', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/folder';
+
+    // Mock isFolder logic
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    // Mock Dockerfile check
+    fsMock.existsSync.mock.mockImplementation((filePath) => {
+      if (filePath.endsWith('Dockerfile') || filePath.endsWith('dockerfile'))
+        return true;
+      return false;
+    });
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    assert.equal(result.hasDockerfile, true);
+  });
+
+  test('makeFileDeploymentMetadata correctly identifies Node.js project attributes', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/node-app';
+
+    // Mock isFolder
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    // Mock existsSync
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('Dockerfile')) return false;
+      if (p.endsWith('package.json')) return true;
+      return false;
+    });
+
+    // Mock readFileSync for package.json
+    fsMock.readFileSync.mock.mockImplementation(() =>
+      JSON.stringify({
+        scripts: { start: 'node server.js' },
+      })
+    );
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    assert.equal(result.hasDockerfile, false);
+    assert.equal(result.deploymentAttrs.runtime, 'nodejs');
+    assert.deepEqual(result.deploymentAttrs.cmd, ['node']);
+    assert.deepEqual(result.deploymentAttrs.args, ['server.js']);
+  });
+
+  test('makeFileDeploymentMetadata ignores Node.js if engines.node is present', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/node-app-engines';
+
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('package.json')) return true;
+      return false;
+    });
+
+    fsMock.readFileSync.mock.mockImplementation(() =>
+      JSON.stringify({
+        scripts: { start: 'node server.js' },
+        engines: { node: '>=14' },
+      })
+    );
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    assert.equal(result.deploymentAttrs.runtime, undefined);
+  });
+
+  test('makeFileDeploymentMetadata handles invalid package.json gracefully', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/bad-json-app';
+
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('package.json')) return true;
+      return false;
+    });
+
+    // Mock readFileSync to return invalid JSON
+    fsMock.readFileSync.mock.mockImplementation(() => '{ invalid json }');
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    // Should return empty deployment attrs
+    assert.equal(result.deploymentAttrs.runtime, undefined);
+  });
+
+  test('canDeployWithoutBuild returns true for valid Node.js zip deploy', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const metadata = {
+      hasDockerfile: false,
+      deploymentAttrs: {
+        runtime: 'nodejs',
+        cmd: ['node'],
+        args: ['index.js'],
+        baseImage: 'base-image',
+      },
+    };
+
+    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), true);
+  });
+
+  test('canDeployWithoutBuild returns false if Dockerfile exists', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const metadata = {
+      hasDockerfile: true,
+      deploymentAttrs: {
+        runtime: 'nodejs',
+        cmd: ['node'],
+        args: ['index.js'],
+      },
+    };
+
+    assert.equal(deploymentHelpers.canDeployWithoutBuild(metadata), false);
+  });
+
+  test('createDirectSourceDeploymentContainer creates correct object', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const input = {
+      bucketName: 'test-bucket',
+      fileName: 'source.tar.gz',
+      deploymentAttrs: {
+        cmd: ['node'],
+        args: ['server.js'],
+        baseImage: 'gcr.io/google-appengine/nodejs',
+      },
+    };
+
+    const result =
+      deploymentHelpers.createDirectSourceDeploymentContainer(input);
+
+    assert.deepEqual(result, {
+      image: DEPLOYMENT_CONFIG.NO_BUILD_IMAGE_TYPE,
+      baseImageUri: 'gcr.io/google-appengine/nodejs',
+      sourceCode: {
+        cloudStorageSource: {
+          bucket: 'test-bucket',
+          object: 'source.tar.gz',
+        },
+      },
+      command: ['node'],
+      args: ['server.js'],
+    });
+  });
+
+  test('makeFileDeploymentMetadata handles invalid package.json gracefully', async () => {
+    const deploymentHelpers = await esmock('../../lib/deployment/helpers.js', {
+      fs: fsMock,
+    });
+
+    const folderPath = '/absolute/path/to/bad-json-app';
+
+    fsMock.statSync.mock.mockImplementation(() => ({
+      isDirectory: () => true,
+    }));
+
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p.endsWith('package.json')) return true;
+      return false;
+    });
+
+    // Mock readFileSync to return invalid JSON
+    fsMock.readFileSync.mock.mockImplementation(() => '{ invalid json }');
+
+    const result = deploymentHelpers.makeFileDeploymentMetadata([folderPath]);
+
+    // Should return empty deployment attrs
+    assert.equal(result.deploymentAttrs.runtime, undefined);
+  });
+});