@google-cloud/cloud-run-mcp 1.10.0 → 1.12.0

package/test/local/util.test.js

@@ -0,0 +1,361 @@
+/*
+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 path from 'path';
+import fs from 'fs';
+
+describe('Artifact Utilities', () => {
+  const fsMock = {
+    existsSync: mock.fn(),
+    mkdirSync: mock.fn(),
+    chmodSync: mock.fn(),
+    readFileSync: mock.fn(),
+    unlinkSync: mock.fn(),
+    createWriteStream: mock.fn(),
+  };
+
+  const cryptoMock = {
+    createHash: mock.fn(),
+  };
+
+  const helpersMock = {
+    logAndProgress: mock.fn(),
+  };
+
+  const clientsMock = {
+    getArtifactRegistryClient: mock.fn(),
+  };
+
+  const artifactParams = {
+    project: 'test-project',
+    location: 'test-location',
+    repository: 'test-repo',
+    artifactPath: 'test-path:1.0:bin',
+    displayName: 'Test Binary',
+  };
+
+  const sha256 =
+    'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
+
+  test('isBinaryUpToDate returns true if hashes match', async () => {
+    fsMock.existsSync.mock.mockImplementation(() => true);
+    fsMock.readFileSync.mock.mockImplementation(() => 'local-content');
+    cryptoMock.createHash.mock.mockImplementation(() => ({
+      update: mock.fn(() => ({
+        digest: mock.fn(() => sha256),
+      })),
+    }));
+
+    const artifactRegistryClientMock = {
+      filePath: mock.fn(() => 'resource-name'),
+      getFile: mock.fn(() => [
+        {
+          hashes: [
+            {
+              type: 'SHA256',
+              value: Buffer.from(sha256, 'hex').toString('base64'),
+            },
+          ],
+        },
+      ]),
+    };
+    clientsMock.getArtifactRegistryClient.mock.mockImplementation(
+      () => artifactRegistryClientMock
+    );
+
+    const { isBinaryUpToDate } = await esmock('../../lib/util/artifacts.js', {
+      fs: fsMock,
+      crypto: cryptoMock,
+      '../../lib/util/helpers.js': helpersMock,
+      '../../lib/clients.js': clientsMock,
+    });
+
+    const result = await isBinaryUpToDate(
+      '/bin/path',
+      artifactParams,
+      'token',
+      mock.fn()
+    );
+    assert.strictEqual(result, true);
+  });
+
+  test('isBinaryUpToDate returns false and unlinks if hashes do not match', async () => {
+    fsMock.existsSync.mock.mockImplementation(() => true);
+    fsMock.readFileSync.mock.mockImplementation(() => 'local-content');
+    fsMock.unlinkSync.mock.resetCalls();
+
+    cryptoMock.createHash.mock.mockImplementation(() => ({
+      update: mock.fn(() => ({
+        digest: mock.fn(() => 'different-hash'),
+      })),
+    }));
+
+    const artifactRegistryClientMock = {
+      filePath: mock.fn(() => 'resource-name'),
+      getFile: mock.fn(() => [
+        {
+          hashes: [
+            {
+              type: 'SHA256',
+              value: Buffer.from(sha256, 'hex').toString('base64'),
+            },
+          ],
+        },
+      ]),
+    };
+    clientsMock.getArtifactRegistryClient.mock.mockImplementation(
+      () => artifactRegistryClientMock
+    );
+
+    const { isBinaryUpToDate } = await esmock('../../lib/util/artifacts.js', {
+      fs: fsMock,
+      crypto: cryptoMock,
+      '../../lib/util/helpers.js': helpersMock,
+      '../../lib/clients.js': clientsMock,
+    });
+
+    const result = await isBinaryUpToDate(
+      '/bin/path',
+      artifactParams,
+      'token',
+      mock.fn()
+    );
+    assert.strictEqual(result, false);
+    assert.strictEqual(fsMock.unlinkSync.mock.callCount(), 1);
+  });
+
+  test('ensureRepositoryDownloaded downloads binary if it does not exist', async () => {
+    fsMock.existsSync.mock.mockImplementation((p) => {
+      if (p === '/bin/path') return false;
+      return true;
+    });
+    fsMock.createWriteStream.mock.resetCalls();
+
+    const artifactRegistryClientMock = {
+      filePath: mock.fn(() => 'resource-name'),
+      getFile: mock.fn(() => [{ hashes: [] }]),
+      auth: {
+        request: mock.fn(() => ({
+          data: {
+            pipe: (dest) => {
+              setTimeout(() => dest.emit('finish'), 10);
+              return dest;
+            },
+          },
+        })),
+      },
+    };
+    clientsMock.getArtifactRegistryClient.mock.mockImplementation(
+      () => artifactRegistryClientMock
+    );
+
+    const writeStreamMock = {
+      on: mock.fn(function (event, cb) {
+        if (event === 'finish') this.finishCb = cb;
+        return this;
+      }),
+      emit: mock.fn(function (event) {
+        if (event === 'finish' && this.finishCb) this.finishCb();
+      }),
+    };
+    fsMock.createWriteStream.mock.mockImplementation(() => writeStreamMock);
+
+    const { ensureRepositoryDownloaded } = await esmock(
+      '../../lib/util/artifacts.js',
+      {
+        fs: fsMock,
+        crypto: cryptoMock,
+        '../../lib/util/helpers.js': helpersMock,
+        '../../lib/clients.js': clientsMock,
+      }
+    );
+
+    const result = await ensureRepositoryDownloaded(
+      '/bin/path',
+      artifactParams,
+      'token',
+      mock.fn()
+    );
+    assert.strictEqual(result, '/bin/path');
+    assert.strictEqual(fsMock.createWriteStream.mock.callCount(), 1);
+  });
+});
+
+describe('Utility Helpers', () => {
+  test('extractAccessToken correctly extracts token from Bearer header', async () => {
+    const { extractAccessToken } = await import('../../lib/util/helpers.js');
+
+    assert.equal(extractAccessToken('Bearer my-token'), 'my-token');
+    assert.equal(extractAccessToken(''), undefined);
+    assert.equal(extractAccessToken(null), undefined);
+  });
+
+  describe('getProjectNumber', () => {
+    test('extracts project number from name in projects/NNNN format', async () => {
+      const getProjectMock = mock.fn(async () => [
+        { name: 'projects/123456789' },
+      ]);
+      const getProjectsClientMock = mock.fn(async () => ({
+        getProject: getProjectMock,
+      }));
+
+      const { getProjectNumber } = await esmock('../../lib/util/helpers.js', {
+        '../../lib/clients.js': {
+          getProjectsClient: getProjectsClientMock,
+        },
+      });
+
+      const projectId = 'test-project';
+      const accessToken = 'test-token';
+      const result = await getProjectNumber(projectId, accessToken);
+
+      assert.equal(result, '123456789');
+      assert.equal(getProjectsClientMock.mock.callCount(), 1);
+      assert.equal(
+        getProjectMock.mock.calls[0].arguments[0].name,
+        'projects/test-project'
+      );
+    });
+
+    test('falls back to projectNumber property if name structure is unexpected', async () => {
+      const getProjectMock = mock.fn(async () => [
+        { name: 'unexpected', projectNumber: '987654321' },
+      ]);
+      const getProjectsClientMock = mock.fn(async () => ({
+        getProject: getProjectMock,
+      }));
+
+      const { getProjectNumber } = await esmock('../../lib/util/helpers.js', {
+        '../../lib/clients.js': {
+          getProjectsClient: getProjectsClientMock,
+        },
+      });
+
+      const result = await getProjectNumber('test-project', 'test-token');
+
+      assert.equal(result, '987654321');
+    });
+  });
+
+  describe('calculateSourceFingerprint', () => {
+    test('calculates SHA256 of directory content deterministically', async () => {
+      const fsMock = {
+        promises: {
+          readdir: mock.fn(async (dir) => {
+            if (dir === '/src') {
+              return [
+                {
+                  name: 'b.txt',
+                  isFile: () => true,
+                  isDirectory: () => false,
+                },
+                {
+                  name: 'a.txt',
+                  isFile: () => true,
+                  isDirectory: () => false,
+                },
+                {
+                  name: 'subdir',
+                  isFile: () => false,
+                  isDirectory: () => true,
+                },
+              ];
+            }
+            if (dir === '/src/subdir') {
+              return [
+                {
+                  name: 'c.txt',
+                  isFile: () => true,
+                  isDirectory: () => false,
+                },
+              ];
+            }
+            return [];
+          }),
+          readFile: mock.fn(
+            async (file) => `content of ${path.basename(file)}`
+          ),
+        },
+      };
+
+      const { calculateSourceFingerprint } = await esmock(
+        '../../lib/util/helpers.js',
+        {
+          'node:fs': { promises: fsMock.promises },
+        }
+      );
+
+      const result = await calculateSourceFingerprint('/src');
+      assert.ok(result);
+      assert.equal(typeof result, 'string');
+      assert.equal(result.length, 64); // SHA256 hex length
+
+      // Verify readdir calls (recursive)
+      assert.equal(fsMock.promises.readdir.mock.callCount(), 2);
+    });
+  });
+
+  describe('sanitizeCloudRunServiceName', () => {
+    test('sanitizes various inputs correctly', async () => {
+      const { sanitizeCloudRunServiceName } =
+        await import('../../lib/util/helpers.js');
+
+      assert.equal(
+        sanitizeCloudRunServiceName('My-Service_Name'),
+        'my-service-name'
+      );
+      assert.equal(sanitizeCloudRunServiceName('123service'), 's-123service');
+      assert.equal(sanitizeCloudRunServiceName('-start-end-'), 'start-end');
+      assert.equal(
+        sanitizeCloudRunServiceName('a'.repeat(100)),
+        'a'.repeat(49)
+      );
+      assert.equal(
+        sanitizeCloudRunServiceName('Special!@#$%Chars'),
+        'special-chars'
+      );
+    });
+  });
+
+  describe('sanitizeLabelValue', () => {
+    test('sanitizes various inputs correctly', async () => {
+      const { sanitizeLabelValue } = await import('../../lib/util/helpers.js');
+
+      assert.equal(sanitizeLabelValue(''), '');
+      assert.equal(sanitizeLabelValue(null), '');
+      assert.equal(sanitizeLabelValue(undefined), '');
+      assert.equal(sanitizeLabelValue('valid-label'), 'valid-label');
+      assert.equal(sanitizeLabelValue('Upper-Case'), 'upper-case');
+      assert.equal(sanitizeLabelValue('invalid@char'), 'invalid-char');
+      assert.equal(
+        sanitizeLabelValue('1starts-with-number'),
+        '1starts-with-number'
+      );
+      assert.equal(
+        sanitizeLabelValue('-starts-with-dash'),
+        '-starts-with-dash'
+      );
+      assert.equal(sanitizeLabelValue('a'.repeat(70)), 'a'.repeat(63));
+      assert.equal(sanitizeLabelValue(12345), '12345');
+      assert.equal(sanitizeLabelValue(0), '0');
+      assert.equal(sanitizeLabelValue(true), 'true');
+      assert.equal(sanitizeLabelValue(false), 'false');
+    });
+  });
+});

package/test/need-gcp/deployer.test.js

@@ -51,7 +51,7 @@ describe('Cloud Run Deployments', () => {
     const config = {
       serviceName: 'hello-from-image',
       region: 'europe-west1',
-      files: ['example-sources-to-deploy/main.go'],
+      files: ['example-sources-to-deploy/golang/main.go'],
     };
     await assert.rejects(deploy(config), {
       message: 'Error: projectId is required in the configuration object.',

package/test/need-gcp/test-helpers.js

@@ -163,7 +163,11 @@ export async function setSourceDeployProjectPermissions(projectId) {
   const context = {
     serviceUsageClient: serviceUsageClient,
   };
-  await ensureApisEnabled(projectId, ['run.googleapis.com']);
+  await ensureApisEnabled(projectId, [
+    'run.googleapis.com',
+    'cloudbuild.googleapis.com',
+    'compute.googleapis.com',
+  ]);
   console.log('Adding editor role to Compute SA...');
   const projectNumber = await getProjectNumber(projectId);
   const member = `serviceAccount:${projectNumber}-compute@developer.gserviceaccount.com`;

package/test/need-gcp/workflows/deployment-workflows.test.js

@@ -26,6 +26,27 @@ import {
   setupProject,
 } from '../test-helpers.js';
 
+const GCP_REGION = 'asia-southeast1';
+const RUN_INGRESS_POLICY = process.env.RUN_INGRESS_POLICY || undefined;
+const ZIP_DEPLOY_SUCCESS_MESSAGE =
+  'Deployment completed successfully with zip deploy';
+const SOURCE_BUILD_DEPLOY_SUCCESS_MESSAGE =
+  'Deployment completed successfully with source build deploy';
+
+async function assertDeploymentSuccess(config, expectedMessage) {
+  let successMessage = '';
+  config.progressCallback = (p) => {
+    if (p.data === expectedMessage) {
+      successMessage = p.data;
+    }
+  };
+  if (RUN_INGRESS_POLICY) {
+    config.ingress = RUN_INGRESS_POLICY;
+  }
+  await deploy(config);
+  assert.strictEqual(successMessage, expectedMessage);
+}
+
 describe('Deployment workflows', () => {
   let projectId;
 
@@ -33,6 +54,8 @@ describe('Deployment workflows', () => {
     try {
       projectId = await setupProject();
       await setSourceDeployProjectPermissions(projectId);
+      console.log('Waiting 2 minutes for IAM propagation...');
+      await new Promise((resolve) => setTimeout(resolve, 120000));
     } catch (err) {
       console.error('Error during project creation and setup:', err);
       throw err;
@@ -43,9 +66,12 @@ describe('Deployment workflows', () => {
     const configImageDeploy = {
       projectId: projectId,
       serviceName: 'hello-scenario',
-      region: 'us-central1',
+      region: GCP_REGION,
       imageUrl: 'gcr.io/cloudrun/hello',
     };
+    if (RUN_INGRESS_POLICY) {
+      configImageDeploy.ingress = RUN_INGRESS_POLICY;
+    }
     await deployImage(configImageDeploy);
 
     console.log('Scenario-1: Deployment completed.');
@@ -55,7 +81,7 @@ describe('Deployment workflows', () => {
     const configFailingBuild = {
       projectId: projectId,
       serviceName: 'example-failing-app',
-      region: 'us-central1',
+      region: GCP_REGION,
       files: [
         {
           filename: 'main.txt',
@@ -64,6 +90,9 @@ describe('Deployment workflows', () => {
         },
       ],
     };
+    if (RUN_INGRESS_POLICY) {
+      configFailingBuild.ingress = RUN_INGRESS_POLICY;
+    }
     await assert.rejects(
       deploy(configFailingBuild),
       { message: /ERROR: failed to detect: no buildpacks participating/ },
@@ -73,26 +102,163 @@ describe('Deployment workflows', () => {
 
   test('Scenario-3: Starting deployment of Go app with file content...', async () => {
     const mainGoContent = await fs.readFile(
-      path.resolve('example-sources-to-deploy/main.go'),
+      path.resolve('example-sources-to-deploy/golang/main.go'),
       'utf-8'
     );
     const goModContent = await fs.readFile(
-      path.resolve('example-sources-to-deploy/go.mod'),
+      path.resolve('example-sources-to-deploy/golang/go.mod'),
       'utf-8'
     );
     const configGoWithContent = {
       projectId: projectId,
       serviceName: 'example-go-app-content',
-      region: 'us-central1',
+      region: GCP_REGION,
       files: [
         { filename: 'main.go', content: mainGoContent },
         { filename: 'go.mod', content: goModContent },
       ],
     };
-    await deploy(configGoWithContent);
+    await assertDeploymentSuccess(
+      configGoWithContent,
+      SOURCE_BUILD_DEPLOY_SUCCESS_MESSAGE
+    );
     console.log('Scenario-3: Deployment completed.');
   });
 
+  test('Scenario-4: Starting deployment of pip-based Python app with folder path... uses zip deploy', async () => {
+    const configPipProject = {
+      projectId: projectId,
+      serviceName: 'example-pip-project-folder-path',
+      region: GCP_REGION,
+      files: ['example-sources-to-deploy/python/pip-project'],
+    };
+    await assertDeploymentSuccess(configPipProject, ZIP_DEPLOY_SUCCESS_MESSAGE);
+    console.log('Scenario-4: Deployment completed.');
+  });
+
+  test('Scenario-5: Starting deployment of pip-based Python app with file-based content... uses source build deploy', async () => {
+    const mainPyContent = await fs.readFile(
+      path.resolve('example-sources-to-deploy/python/pip-project/main.py'),
+      'utf-8'
+    );
+    const requirementsTxtContent = await fs.readFile(
+      path.resolve(
+        'example-sources-to-deploy/python/pip-project/requirements.txt'
+      ),
+      'utf-8'
+    );
+    const configPipProject = {
+      projectId: projectId,
+      serviceName: 'example-pip-project-file-content',
+      region: GCP_REGION,
+      files: [
+        { filename: 'main.py', content: mainPyContent },
+        { filename: 'requirements.txt', content: requirementsTxtContent },
+      ],
+    };
+    await assertDeploymentSuccess(
+      configPipProject,
+      SOURCE_BUILD_DEPLOY_SUCCESS_MESSAGE
+    );
+    console.log('Scenario-5: Deployment completed.');
+  });
+
+  test('Scenario-6: Starting deployment of pyproject-based Python app with folder path... uses zip deploy', async () => {
+    const configPyprojectProject = {
+      projectId: projectId,
+      serviceName: 'example-pyproject-project-folder-path',
+      region: GCP_REGION,
+      files: ['example-sources-to-deploy/python/pyproject-project'],
+    };
+    await assertDeploymentSuccess(
+      configPyprojectProject,
+      ZIP_DEPLOY_SUCCESS_MESSAGE
+    );
+    console.log('Scenario-6: Deployment completed.');
+  });
+
+  test('Scenario-7: Starting deployment of pyproject-based Python app with file-based content... uses source build deploy', async () => {
+    const mainPyContent = await fs.readFile(
+      path.resolve(
+        'example-sources-to-deploy/python/pyproject-project/main.py'
+      ),
+      'utf-8'
+    );
+    const pyprojectContent = await fs.readFile(
+      path.resolve(
+        'example-sources-to-deploy/python/pyproject-project/pyproject.toml'
+      ),
+      'utf-8'
+    );
+    const configPyprojectProject = {
+      projectId: projectId,
+      serviceName: 'example-pyproject-project-file-content',
+      region: GCP_REGION,
+      files: [
+        { filename: 'main.py', content: mainPyContent },
+        { filename: 'pyproject.toml', content: pyprojectContent },
+      ],
+    };
+    await assertDeploymentSuccess(
+      configPyprojectProject,
+      SOURCE_BUILD_DEPLOY_SUCCESS_MESSAGE
+    );
+    console.log('Scenario-7: Deployment completed.');
+  });
+
+  test('Scenario-8: Starting deployment of Node.js app with folder path... uses zip deploy', async () => {
+    const configNodeProject = {
+      projectId: projectId,
+      serviceName: 'example-node-project-folder-path',
+      region: GCP_REGION,
+      files: ['example-sources-to-deploy/nodejs'],
+    };
+    await assertDeploymentSuccess(
+      configNodeProject,
+      ZIP_DEPLOY_SUCCESS_MESSAGE
+    );
+    console.log('Scenario-8: Deployment completed.');
+  });
+
+  test('Scenario-9: Starting deployment of Node.js app with file content... uses build deploy', async () => {
+    const packageJsonContent = await fs.readFile(
+      path.resolve('example-sources-to-deploy/nodejs/package.json'),
+      'utf-8'
+    );
+    const indexJsContent = await fs.readFile(
+      path.resolve('example-sources-to-deploy/nodejs/index.js'),
+      'utf-8'
+    );
+    const configNodeWithContent = {
+      projectId: projectId,
+      serviceName: 'example-node-project-file-content',
+      region: GCP_REGION,
+      files: [
+        { filename: 'package.json', content: packageJsonContent },
+        { filename: 'index.js', content: indexJsContent },
+      ],
+    };
+    await assertDeploymentSuccess(
+      configNodeWithContent,
+      SOURCE_BUILD_DEPLOY_SUCCESS_MESSAGE
+    );
+    console.log('Scenario-9: Deployment completed.');
+  });
+
+  test('Scenario-10: Starting deployment of Java app with folder path... uses source build deploy', async () => {
+    const configJavaProject = {
+      projectId: projectId,
+      serviceName: 'example-java-project-folder-path',
+      region: GCP_REGION,
+      files: ['example-sources-to-deploy/java'],
+    };
+    await assertDeploymentSuccess(
+      configJavaProject,
+      SOURCE_BUILD_DEPLOY_SUCCESS_MESSAGE
+    );
+    console.log('Scenario-10: Deployment completed.');
+  });
+
   after(async () => {
     // Clean up: delete the project created for tests
     cleanupProject(projectId);