From a40f3cb07d204eb00bb41a59368b47ad4ff94430 Mon Sep 17 00:00:00 2001
From: durgesh-ninave-crest <durgesh.ninave@crestdata.ai>
Date: Wed, 9 Apr 2025 12:16:33 +0530
Subject: [PATCH 1/7] feat(parametermanager): Added samples for create, get,
 list and render global parameter & parameter version

---
 parametermanager/createParam.js               |  53 ++++
 parametermanager/createParamVersion.js        |  75 ++++++
 .../createParamVersionWithSecret.js           |  85 ++++++
 parametermanager/createStructuredParam.js     |  69 +++++
 .../createStructuredParamVersion.js           |  77 ++++++
 parametermanager/getParam.js                  |  60 +++++
 parametermanager/getParamVersion.js           |  75 ++++++
 parametermanager/listParamVersions.js         |  62 +++++
 parametermanager/listParams.js                |  59 ++++
 parametermanager/package.json                 |  29 ++
 parametermanager/renderParamVersion.js        |  78 ++++++
 parametermanager/test/.eslintrc.yml           |  17 ++
 .../test/parametermanager.test.js             | 253 ++++++++++++++++++
 13 files changed, 992 insertions(+)
 create mode 100644 parametermanager/createParam.js
 create mode 100644 parametermanager/createParamVersion.js
 create mode 100644 parametermanager/createParamVersionWithSecret.js
 create mode 100644 parametermanager/createStructuredParam.js
 create mode 100644 parametermanager/createStructuredParamVersion.js
 create mode 100644 parametermanager/getParam.js
 create mode 100644 parametermanager/getParamVersion.js
 create mode 100644 parametermanager/listParamVersions.js
 create mode 100644 parametermanager/listParams.js
 create mode 100644 parametermanager/package.json
 create mode 100644 parametermanager/renderParamVersion.js
 create mode 100644 parametermanager/test/.eslintrc.yml
 create mode 100644 parametermanager/test/parametermanager.test.js

diff --git a/parametermanager/createParam.js b/parametermanager/createParam.js
new file mode 100644
index 0000000000..27a64f653d
--- /dev/null
+++ b/parametermanager/createParam.js
@@ -0,0 +1,53 @@
+// 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.
+
+'use strict';
+
+/**
+ * Creates a global parameter using the Parameter Manager SDK.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameter is to be created.
+ * @param {string} parameterId - The ID of the parameter to create. This ID must be unique within the project.
+ */
+async function main(projectId = 'my-project', parameterId = 'my-parameter') {
+  // [START parametermanager_create_param]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'YOUR_PROJECT_ID';
+  // const parameterId = 'YOUR_PARAMETER_ID';
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function createParam() {
+    const parent = client.locationPath(projectId, 'global');
+    const request = {
+      parent: parent,
+      parameterId: parameterId,
+    };
+
+    const [parameter] = await client.createParameter(request);
+    console.log(`Created parameter: ${parameter.name}`);
+  }
+
+  await createParam();
+  // [END parametermanager_create_param]
+}
+
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/createParamVersion.js b/parametermanager/createParamVersion.js
new file mode 100644
index 0000000000..9c383022e6
--- /dev/null
+++ b/parametermanager/createParamVersion.js
@@ -0,0 +1,75 @@
+// 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.
+
+'use strict';
+
+/**
+ * Creates a parameter version globally for unstructured data.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameter is to be created
+ * @param {string} parameterId - The ID of the parameter for which the version is to be created.
+ * @param {string} parameterVersionId - The ID of the parameter version to be created.
+ * @param {string} payload - The unformatted string payload to be stored in the new parameter version.
+ */
+async function main(
+  projectId = 'my-project',
+  parameterId = 'my-parameter',
+  parameterVersionId = 'v1',
+  payload = 'This is unstructured data'
+) {
+  // [START parametermanager_create_param_version]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'YOUR_PROJECT_ID';
+  // const parameterId = 'YOUR_PARAMETER_ID';
+  // const parameterVersionId = 'YOUR_PARAMETER_VERSION_ID';
+  // const payload = 'This is unstructured data';
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function createParamVersion() {
+    // Construct the parent resource name
+    const parent = client.parameterPath(projectId, 'global', parameterId);
+
+    // Construct the parameter version
+    const parameterVersion = {
+      payload: {
+        data: Buffer.from(payload, 'utf8'),
+      },
+    };
+
+    // Construct the request
+    const request = {
+      parent: parent,
+      parameterVersionId: parameterVersionId,
+      parameterVersion: parameterVersion,
+    };
+
+    // Create the parameter version
+    const [response] = await client.createParameterVersion(request);
+    console.log(`Created parameter version: ${response.name}`);
+  }
+
+  await createParamVersion();
+  // [END parametermanager_create_param_version]
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/createParamVersionWithSecret.js b/parametermanager/createParamVersionWithSecret.js
new file mode 100644
index 0000000000..5e1bb26e02
--- /dev/null
+++ b/parametermanager/createParamVersionWithSecret.js
@@ -0,0 +1,85 @@
+// 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.
+
+'use strict';
+
+/**
+ * Creates a new version of an existing parameter in the global location
+ * of the specified project using the Google Cloud Parameter Manager SDK.
+ * The payload is specified as a JSON string and includes a reference to a secret.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameter is located.
+ * @param {string} parameterId - The ID of the parameter for which the version is to be created.
+ * @param {string} parameterVersionId - The ID of the parameter version to be created.
+ * @param {string} secretId - The ID of the secret to be referenced.
+ */
+async function main(
+  projectId = 'my-project',
+  parameterId = 'my-parameter',
+  parameterVersionId = 'v1',
+  secretId = 'projects/my-project/secrets/application-secret/version/latest'
+) {
+  // [START parametermanager_create_param_version_with_secret]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'YOUR_PROJECT_ID';
+  // const parameterId = 'YOUR_PARAMETER_ID';
+  // const parameterVersionId = 'YOUR_PARAMETER_VERSION_ID';
+  // const secretId = 'YOUR_SECRET_ID'; // For example projects/my-project/secrets/application-secret/version/latest
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function createParamVersionWithSecret() {
+    // Construct the parent resource name
+    const parent = client.parameterPath(projectId, 'global', parameterId);
+
+    // Construct the JSON data with secret references
+    const jsonData = {
+      db_user: 'test_user',
+      db_password: `__REF__(//secretmanager.googleapis.com/${secretId})`,
+    };
+
+    // Construct the parameter version
+    const parameterVersion = {
+      payload: {
+        data: Buffer.from(JSON.stringify(jsonData), 'utf8'),
+      },
+    };
+
+    // Construct the request
+    const request = {
+      parent: parent,
+      parameterVersionId: parameterVersionId,
+      parameterVersion: parameterVersion,
+    };
+
+    // Create the parameter version
+    const [response] = await client.createParameterVersion(request);
+    console.log(
+      `Created parameter version with secret references: ${response.name}`
+    );
+  }
+
+  await createParamVersionWithSecret();
+  // [END parametermanager_create_param_version_with_secret]
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/createStructuredParam.js b/parametermanager/createStructuredParam.js
new file mode 100644
index 0000000000..2385d2e9b4
--- /dev/null
+++ b/parametermanager/createStructuredParam.js
@@ -0,0 +1,69 @@
+// 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.
+
+'use strict';
+
+const {protos} = require('@google-cloud/parametermanager');
+
+/**
+ * Creates a parameter in the global location of the specified
+ * project with specified format using the Google Cloud Parameter Manager SDK.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameter is to be created.
+ * @param {string} parameterId - The ID of the parameter to create. This ID must be unique within the project.
+ * @param {string} formatType - The format type of the parameter (UNFORMATTED, YAML, JSON).
+ */
+async function main(
+  projectId = 'my-project',
+  parameterId = 'my-json-parameter',
+  formatType = protos.google.cloud.parametermanager.v1.ParameterFormat.JSON
+) {
+  // [START parametermanager_create_structured_param]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const {protos} = require('@google-cloud/parametermanager');
+  // const projectId = 'YOUR_PROJECT_ID';
+  // const parameterId = 'YOUR_PARAMETER_ID';
+  // const formatType = protos.google.cloud.parametermanager.v1.ParameterFormat.JSON;
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function createStructuredParam() {
+    const parent = client.locationPath(projectId, 'global');
+    const request = {
+      parent: parent,
+      parameterId: parameterId,
+      parameter: {
+        format: formatType,
+      },
+    };
+
+    const [parameter] = await client.createParameter(request);
+    console.log(
+      `Created parameter ${parameter.name} with format ${parameter.format}`
+    );
+  }
+
+  await createStructuredParam();
+  // [END parametermanager_create_structured_param]
+}
+
+// This sample demonstrates how to create a parameter for structured data of JSON type.
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/createStructuredParamVersion.js b/parametermanager/createStructuredParamVersion.js
new file mode 100644
index 0000000000..eee1859d34
--- /dev/null
+++ b/parametermanager/createStructuredParamVersion.js
@@ -0,0 +1,77 @@
+// 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.
+
+'use strict';
+
+/**
+ * Creates a new version of an existing parameter in the global location
+ * of the specified project using the Google Cloud Parameter Manager SDK.
+ * The payload is specified as a JSON format.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameter is to be created.
+ * @param {string} parameterId - The ID of the parameter to create. This ID must be unique within the project.
+ * @param {string} parameterVersionId - The ID of the parameter version to be created.
+ * @param {Object} payload - The JSON payload data to be stored in the parameter version.
+ */
+async function main(
+  projectId = 'my-project',
+  parameterId = 'my-parameter',
+  parameterVersionId = 'v1',
+  payload = {username: 'test-user', host: 'localhost'}
+) {
+  // [START parametermanager_create_structured_param_version]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'YOUR_PROJECT_ID';
+  // const parameterId = 'YOUR_PARAMETER_ID';
+  // const parameterVersionId = 'YOUR_PARAMETER_VERSION_ID';
+  // const jsonData = {username: "test-user", host: "localhost"};
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function createStructuredParamVersion() {
+    // Construct the parent resource name
+    const parent = client.parameterPath(projectId, 'global', parameterId);
+
+    // Construct the parameter version
+    const parameterVersion = {
+      payload: {
+        data: Buffer.from(JSON.stringify(payload), 'utf8'),
+      },
+    };
+
+    // Construct the request
+    const request = {
+      parent: parent,
+      parameterVersionId: parameterVersionId,
+      parameterVersion: parameterVersion,
+    };
+
+    // Create the parameter version
+    const [response] = await client.createParameterVersion(request);
+    console.log(`Created parameter version: ${response.name}`);
+  }
+
+  await createStructuredParamVersion();
+  // [END parametermanager_create_structured_param_version]
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/getParam.js b/parametermanager/getParam.js
new file mode 100644
index 0000000000..bc63bae1c8
--- /dev/null
+++ b/parametermanager/getParam.js
@@ -0,0 +1,60 @@
+// 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.
+
+'use strict';
+
+/**
+ * Retrieves a parameter from the global location of the specified
+ * project using the Google Cloud Parameter Manager SDK.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameter is located.
+ * @param {string} parameterId - The ID of the parameter to retrieve.
+ */
+async function main(projectId = 'my-project', parameterId = 'my-parameter') {
+  // [START parametermanager_get_param]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'my-project';
+  // const parameterId = 'my-parameter';
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function getParam() {
+    // Construct the fully qualified parameter name
+    const name = client.parameterPath(projectId, 'global', parameterId);
+
+    // Get the parameter
+    const [parameter] = await client.getParameter({
+      name: name,
+    });
+
+    // Find more details for the Parameter object here:
+    // https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters#Parameter
+    console.log(
+      `Found parameter ${parameter.name} with format ${parameter.format}`
+    );
+  }
+
+  await getParam();
+  // [END parametermanager_get_param]
+}
+
+// The command-line arguments are passed as an array to main()
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/getParamVersion.js b/parametermanager/getParamVersion.js
new file mode 100644
index 0000000000..914d21a0a3
--- /dev/null
+++ b/parametermanager/getParamVersion.js
@@ -0,0 +1,75 @@
+// 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.
+
+'use strict';
+
+/**
+ * Retrieves the details of a specific version of an existing parameter in the specified
+ * project using the Google Cloud Parameter Manager SDK.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameter is located.
+ * @param {string} parameterId - The ID of the parameter for which the version details are to be retrieved.
+ * @param {string} versionId - The version ID of the parameter to retrieve.
+ */
+async function main(
+  projectId = 'my-project',
+  parameterId = 'my-parameter',
+  versionId = 'v1'
+) {
+  // [START parametermanager_get_param_version]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'my-project';
+  // const parameterId = 'my-parameter';
+  // const versionId = 'v1';
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function getParamVersion() {
+    // Construct the fully qualified parameter version name
+    const name = client.parameterVersionPath(
+      projectId,
+      'global',
+      parameterId,
+      versionId
+    );
+
+    // Get the parameter version
+    const [parameterVersion] = await client.getParameterVersion({
+      name: name,
+    });
+    // Find more details for the Parameter Version object here:
+    // https://cloud.google.com/secret-manager/parameter-manager/docs/reference/rest/v1/projects.locations.parameters.versions#ParameterVersion
+    console.log(
+      `Found parameter version ${parameterVersion.name} with state ${parameterVersion.disabled ? 'disabled' : 'enabled'}`
+    );
+    if (!parameterVersion.disabled) {
+      console.log(
+        `Payload: ${parameterVersion.payload.data.toString('utf-8')}`
+      );
+    }
+  }
+
+  await getParamVersion();
+  // [END parametermanager_get_param_version]
+}
+
+// The command-line arguments are passed as an array to main()
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/listParamVersions.js b/parametermanager/listParamVersions.js
new file mode 100644
index 0000000000..01e67f775d
--- /dev/null
+++ b/parametermanager/listParamVersions.js
@@ -0,0 +1,62 @@
+// 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.
+
+'use strict';
+
+/**
+ *
+ * Lists all versions of an existing parameter in the global location
+ * of the specified project using the Google Cloud Parameter Manager SDK.
+ *
+ * @param {string} projectId - The Google Cloud project ID where parameter is located.
+ * @param {string} parameterId - The parameter ID for which versions are to be listed.
+ */
+async function main(projectId = 'my-project', parameterId = 'my-parameter') {
+  // [START parametermanager_list_param_versions]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'my-project';
+  // const parameterId = 'my-parameter';
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function listParamVersions() {
+    // Construct the parent string for listing parameter versions globally
+    const parent = client.parameterPath(projectId, 'global', parameterId);
+
+    const request = {
+      parent: parent,
+    };
+
+    // Use listParameterVersionsAsync to handle pagination automatically
+    const iterable = await client.listParameterVersionsAsync(request);
+
+    for await (const version of iterable) {
+      console.log(
+        `Found parameter version ${version.name} with state ${version.disabled ? 'disabled' : 'enabled'}`
+      );
+    }
+  }
+
+  await listParamVersions();
+  // [END parametermanager_list_param_versions]
+}
+
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/listParams.js b/parametermanager/listParams.js
new file mode 100644
index 0000000000..0b5b0f84fd
--- /dev/null
+++ b/parametermanager/listParams.js
@@ -0,0 +1,59 @@
+// 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.
+
+'use strict';
+
+/**
+ * Lists all parameters in the global location for the specified
+ * project using the Google Cloud Parameter Manager SDK.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameters are located.
+ */
+async function main(projectId = 'my-project') {
+  // [START parametermanager_list_params]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'my-project';
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function listParams() {
+    // Construct the parent string for listing parameters globally
+    const parent = client.locationPath(projectId, 'global');
+
+    const request = {
+      parent: parent,
+    };
+
+    // Use listParametersAsync to handle pagination automatically
+    const iterable = await client.listParametersAsync(request);
+
+    for await (const parameter of iterable) {
+      console.log(
+        `Found parameter ${parameter.name} with format ${parameter.format}`
+      );
+    }
+  }
+
+  await listParams();
+  // [END parametermanager_list_params]
+}
+
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/package.json b/parametermanager/package.json
new file mode 100644
index 0000000000..62cca15a15
--- /dev/null
+++ b/parametermanager/package.json
@@ -0,0 +1,29 @@
+{
+  "name": "nodejs-parameter-manager-samples",
+  "private": true,
+  "license": "Apache-2.0",
+  "files": [
+    "*.js"
+  ],
+  "author": "Google LLC",
+  "repository": "googleapis/nodejs-parameter-manager",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "c8 mocha --recursive test/ --timeout=800000"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "@google-cloud/parametermanager": "^0.1.0"
+  },
+  "devDependencies": {
+    "@google-cloud/secret-manager": "^5.6.0",
+    "c8": "^10.1.3",
+    "chai": "^4.5.0",
+    "mocha": "^11.1.0",
+    "uuid": "^11.0.5"
+  }
+}
diff --git a/parametermanager/renderParamVersion.js b/parametermanager/renderParamVersion.js
new file mode 100644
index 0000000000..65ace26239
--- /dev/null
+++ b/parametermanager/renderParamVersion.js
@@ -0,0 +1,78 @@
+// 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.
+
+'use strict';
+
+/**
+ * Retrieves and renders the details of a specific version of an
+ * existing parameter in the global location of the specified project
+ * using the Google Cloud Parameter Manager SDK.
+ *
+ * @param {string} projectId - The Google Cloud project ID where the parameter is located.
+ * @param {string} parameterId - The ID of the parameter for which version details are to be rendered.
+ * @param {string} parameterVersionId - The ID of the parameter version to be rendered.
+ */
+async function main(
+  projectId = 'my-project',
+  parameterId = 'my-parameter',
+  parameterVersionId = 'v1'
+) {
+  // [START parametermanager_render_param_version]
+  /**
+   * TODO(developer): Uncomment these variables before running the sample.
+   */
+  // const projectId = 'YOUR_PROJECT_ID';
+  // const parameterId = 'YOUR_PARAMETER_ID';
+  // const parameterVersionId = 'YOUR_PARAMETER_VERSION_ID';
+
+  // Imports the Parameter Manager library
+  const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+
+  // Instantiates a client
+  const client = new ParameterManagerClient();
+
+  async function renderParamVersion() {
+    // Construct the parameter version name
+    const name = client.parameterVersionPath(
+      projectId,
+      'global',
+      parameterId,
+      parameterVersionId
+    );
+
+    // Construct the request
+    const request = {
+      name: name,
+    };
+
+    // Render the parameter version
+    const [response] = await client.renderParameterVersion(request);
+    console.log(`Rendered parameter version: ${response.parameterVersion}`);
+
+    // If the parameter contains secret references, they will be resolved
+    // and the actual secret values will be included in the rendered output.
+    // Be cautious with logging or displaying this information.
+    console.log(
+      'Rendered payload: ',
+      response.renderedPayload.toString('utf-8')
+    );
+  }
+
+  await renderParamVersion();
+  // [END parametermanager_render_param_version]
+}
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+main(...args).catch(console.error);
diff --git a/parametermanager/test/.eslintrc.yml b/parametermanager/test/.eslintrc.yml
new file mode 100644
index 0000000000..9351c489b5
--- /dev/null
+++ b/parametermanager/test/.eslintrc.yml
@@ -0,0 +1,17 @@
+# 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.
+
+---
+env:
+  mocha: true
\ No newline at end of file
diff --git a/parametermanager/test/parametermanager.test.js b/parametermanager/test/parametermanager.test.js
new file mode 100644
index 0000000000..f9005a9550
--- /dev/null
+++ b/parametermanager/test/parametermanager.test.js
@@ -0,0 +1,253 @@
+// 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.
+
+'use strict';
+
+const {assert} = require('chai');
+const cp = require('child_process');
+const {v4: uuidv4} = require('uuid');
+
+const {ParameterManagerClient} = require('@google-cloud/parametermanager');
+const client = new ParameterManagerClient();
+
+const {SecretManagerServiceClient} = require('@google-cloud/secret-manager');
+const secretClient = new SecretManagerServiceClient();
+
+let projectId;
+const locationId = process.env.GCLOUD_LOCATION || 'us-central1';
+const options = {};
+options.apiEndpoint = `parametermanager.${locationId}.rep.googleapis.com`;
+
+const secretOptions = {};
+secretOptions.apiEndpoint = `secretmanager.${locationId}.rep.googleapis.com`;
+
+const execSync = cmd => cp.execSync(cmd, {encoding: 'utf-8'});
+
+const secretId = `test-secret-${uuidv4()}`;
+const parameterId = `test-parameter-${uuidv4()}`;
+const parameterVersionId = 'v1';
+
+let parameter;
+let parameterVersion;
+let secret;
+let secretVersion;
+
+describe('Parameter Manager samples', () => {
+  const parametersToDelete = [];
+
+  before(async () => {
+    projectId = await client.getProjectId();
+
+    // Create a secret
+    [secret] = await secretClient.createSecret({
+      parent: `projects/${projectId}`,
+      secretId: secretId,
+      secret: {
+        replication: {
+          automatic: {},
+        },
+      },
+    });
+
+    // Create a secret version
+    [secretVersion] = await secretClient.addSecretVersion({
+      parent: secret.name,
+      payload: {
+        data: Buffer.from('my super secret data', 'utf-8'),
+      },
+    });
+
+    // Create a test global parameter
+    [parameter] = await client.createParameter({
+      parent: `projects/${projectId}/locations/global`,
+      parameterId: parameterId,
+      parameter: {
+        format: 'JSON',
+      },
+    });
+    parametersToDelete.push(parameter.name);
+
+    // Create a version for the global parameter
+    [parameterVersion] = await client.createParameterVersion({
+      parent: parameter.name,
+      parameterVersionId: parameterVersionId,
+      parameterVersion: {
+        payload: {
+          data: Buffer.from(JSON.stringify({key: 'global_value'}), 'utf-8'),
+        },
+      },
+    });
+  });
+
+  after(async () => {
+    // Clean up
+    parametersToDelete.forEach(async parameterName => {
+      await client.deleteParameterVersion({
+        name: `${parameterName}/versions/v1`,
+      });
+      if (parameterName === parameter.name) {
+        await client.deleteParameterVersion({
+          name: `${parameterName}/versions/v12`,
+        });
+      }
+      await client.deleteParameter({name: parameterName});
+    });
+    await secretClient.deleteSecret({
+      name: secret.name,
+    });
+  });
+
+  it('should create parameter version with secret references', async () => {
+    const output = execSync(
+      `node createParamVersionWithSecret.js ${projectId} ${parameterId} ${parameterVersionId}2 ${secretVersion.name}`
+    );
+    assert.include(
+      output,
+      `Created parameter version with secret references: projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}2`
+    );
+  });
+
+  it('should create a structured parameter', async () => {
+    const output = execSync(
+      `node createStructuredParam.js ${projectId} ${parameterId}-2`
+    );
+    parametersToDelete.push(
+      client.parameterPath(projectId, 'global', `${parameterId}-2`)
+    );
+    assert.include(
+      output,
+      `Created parameter projects/${projectId}/locations/global/parameters/${parameterId}-2 with format JSON`
+    );
+  });
+
+  it('should create a unstructured parameter', async () => {
+    const output = execSync(
+      `node createParam.js ${projectId} ${parameterId}-3`
+    );
+    parametersToDelete.push(
+      client.parameterPath(projectId, 'global', `${parameterId}-3`)
+    );
+    assert.include(
+      output,
+      `Created parameter: projects/${projectId}/locations/global/parameters/${parameterId}-3`
+    );
+  });
+
+  it('should create a structured parameter version', async () => {
+    const output = execSync(
+      `node createStructuredParamVersion.js ${projectId} ${parameterId}-2 ${parameterVersionId}`
+    );
+    assert.include(
+      output,
+      `Created parameter version: projects/${projectId}/locations/global/parameters/${parameterId}-2/versions/${parameterVersionId}`
+    );
+  });
+
+  it('should create a unstructured parameter version', async () => {
+    const output = execSync(
+      `node createParamVersion.js ${projectId} ${parameterId}-3 ${parameterVersionId}`
+    );
+    assert.include(
+      output,
+      `Created parameter version: projects/${projectId}/locations/global/parameters/${parameterId}-3/versions/${parameterVersionId}`
+    );
+  });
+
+  it('should list parameters', async () => {
+    const output = execSync(`node listParams.js ${projectId}`);
+    assert.include(
+      output,
+      `Found parameter ${parameter.name} with format ${parameter.format}`
+    );
+    assert.include(
+      output,
+      `Found parameter projects/${projectId}/locations/global/parameters/${parameterId}-2 with format JSON`
+    );
+    assert.include(
+      output,
+      `Found parameter projects/${projectId}/locations/global/parameters/${parameterId}-3 with format UNFORMATTED`
+    );
+  });
+
+  it('should get a parameter', async () => {
+    const output = execSync(`node getParam.js ${projectId} ${parameterId}`);
+    assert.include(
+      output,
+      `Found parameter ${parameter.name} with format ${parameter.format}`
+    );
+  });
+
+  it('should list parameter versions', async () => {
+    const output = execSync(
+      `node listParamVersions.js ${projectId} ${parameterId}`
+    );
+    assert.include(
+      output,
+      `Found parameter version ${parameterVersion.name} with state enabled`
+    );
+    assert.include(
+      output,
+      `Found parameter version ${parameterVersion.name}2 with state enabled`
+    );
+  });
+
+  it('should get a parameter version', async () => {
+    const output = execSync(
+      `node getParamVersion.js ${projectId} ${parameterId} ${parameterVersionId}2`
+    );
+    assert.include(
+      output,
+      `Found parameter version ${parameterVersion.name}2 with state enabled`
+    );
+    assert.include(
+      output,
+      `Payload: {"db_user":"test_user","db_password":"__REF__(//secretmanager.googleapis.com/${secretVersion.name})"}`
+    );
+  });
+
+  it('should render parameter version', async () => {
+    // Get the current IAM policy.
+    const [policy] = await secretClient.getIamPolicy({
+      resource: secret.name,
+    });
+
+    // Add the user with accessor permissions to the bindings list.
+    policy.bindings.push({
+      role: 'roles/secretmanager.secretAccessor',
+      members: [parameter.policyMember.iamPolicyUidPrincipal],
+    });
+
+    // Save the updated IAM policy.
+    await secretClient.setIamPolicy({
+      resource: secret.name,
+      policy: policy,
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 120000));
+
+    const output = execSync(
+      `node renderParamVersion.js ${projectId} ${parameterId} ${parameterVersionId}2`
+    );
+    assert.include(output, 'Rendered parameter version:');
+    assert.include(
+      output,
+      `/parameters/${parameterId}/versions/${parameterVersionId}2`
+    );
+    assert.include(output, 'Rendered payload:');
+    assert.include(
+      output,
+      '{"db_user":"test_user","db_password":"my super secret data"}'
+    );
+  });
+});

From 8d7aedcf9471bd9eadf3c4986b15f3d2cec491b6 Mon Sep 17 00:00:00 2001
From: durgesh-ninave-crest <durgesh.ninave@crestdata.ai>
Date: Fri, 25 Apr 2025 17:12:19 +0530
Subject: [PATCH 2/7] fix(parametermanager): update samples and testcases

---
 parametermanager/createParam.js               |  17 +-
 parametermanager/createParamVersion.js        |  22 ++-
 .../createParamVersionWithSecret.js           |  22 ++-
 parametermanager/createStructuredParam.js     |  18 ++-
 .../createStructuredParamVersion.js           |  22 ++-
 parametermanager/getParam.js                  |  18 ++-
 parametermanager/getParamVersion.js           |  18 ++-
 parametermanager/listParamVersions.js         |  21 ++-
 parametermanager/listParams.js                |  21 ++-
 parametermanager/renderParamVersion.js        |  24 ++-
 .../test/parametermanager.test.js             | 149 ++++++++----------
 11 files changed, 217 insertions(+), 135 deletions(-)

diff --git a/parametermanager/createParam.js b/parametermanager/createParam.js
index 27a64f653d..71f51fd028 100644
--- a/parametermanager/createParam.js
+++ b/parametermanager/createParam.js
@@ -43,11 +43,22 @@ async function main(projectId = 'my-project', parameterId = 'my-parameter') {
 
     const [parameter] = await client.createParameter(request);
     console.log(`Created parameter: ${parameter.name}`);
+    return parameter;
   }
 
-  await createParam();
+  return await createParam();
   // [END parametermanager_create_param]
 }
+module.exports.main = main;
 
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/createParamVersion.js b/parametermanager/createParamVersion.js
index 9c383022e6..62a74e26be 100644
--- a/parametermanager/createParamVersion.js
+++ b/parametermanager/createParamVersion.js
@@ -62,14 +62,24 @@ async function main(
     };
 
     // Create the parameter version
-    const [response] = await client.createParameterVersion(request);
-    console.log(`Created parameter version: ${response.name}`);
+    const [paramVersion] = await client.createParameterVersion(request);
+    console.log(`Created parameter version: ${paramVersion.name}`);
+    return paramVersion;
   }
 
-  await createParamVersion();
+  return await createParamVersion();
   // [END parametermanager_create_param_version]
 }
+module.exports.main = main;
 
-// Parse command line arguments
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/createParamVersionWithSecret.js b/parametermanager/createParamVersionWithSecret.js
index 5e1bb26e02..91da150d7c 100644
--- a/parametermanager/createParamVersionWithSecret.js
+++ b/parametermanager/createParamVersionWithSecret.js
@@ -70,16 +70,26 @@ async function main(
     };
 
     // Create the parameter version
-    const [response] = await client.createParameterVersion(request);
+    const [paramVersion] = await client.createParameterVersion(request);
     console.log(
-      `Created parameter version with secret references: ${response.name}`
+      `Created parameter version with secret references: ${paramVersion.name}`
     );
+    return paramVersion;
   }
 
-  await createParamVersionWithSecret();
+  return await createParamVersionWithSecret();
   // [END parametermanager_create_param_version_with_secret]
 }
+module.exports.main = main;
 
-// Parse command line arguments
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/createStructuredParam.js b/parametermanager/createStructuredParam.js
index 2385d2e9b4..86a9e8abab 100644
--- a/parametermanager/createStructuredParam.js
+++ b/parametermanager/createStructuredParam.js
@@ -58,12 +58,22 @@ async function main(
     console.log(
       `Created parameter ${parameter.name} with format ${parameter.format}`
     );
+    return parameter;
   }
 
-  await createStructuredParam();
+  return await createStructuredParam();
   // [END parametermanager_create_structured_param]
 }
+module.exports.main = main;
 
-// This sample demonstrates how to create a parameter for structured data of JSON type.
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/createStructuredParamVersion.js b/parametermanager/createStructuredParamVersion.js
index eee1859d34..f8d65b7e7e 100644
--- a/parametermanager/createStructuredParamVersion.js
+++ b/parametermanager/createStructuredParamVersion.js
@@ -64,14 +64,24 @@ async function main(
     };
 
     // Create the parameter version
-    const [response] = await client.createParameterVersion(request);
-    console.log(`Created parameter version: ${response.name}`);
+    const [paramVersion] = await client.createParameterVersion(request);
+    console.log(`Created parameter version: ${paramVersion.name}`);
+    return paramVersion;
   }
 
-  await createStructuredParamVersion();
+  return await createStructuredParamVersion();
   // [END parametermanager_create_structured_param_version]
 }
+module.exports.main = main;
 
-// Parse command line arguments
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/getParam.js b/parametermanager/getParam.js
index bc63bae1c8..35385c8e77 100644
--- a/parametermanager/getParam.js
+++ b/parametermanager/getParam.js
@@ -49,12 +49,22 @@ async function main(projectId = 'my-project', parameterId = 'my-parameter') {
     console.log(
       `Found parameter ${parameter.name} with format ${parameter.format}`
     );
+    return parameter;
   }
 
-  await getParam();
+  return await getParam();
   // [END parametermanager_get_param]
 }
+module.exports.main = main;
 
-// The command-line arguments are passed as an array to main()
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/getParamVersion.js b/parametermanager/getParamVersion.js
index 914d21a0a3..4f343e8087 100644
--- a/parametermanager/getParamVersion.js
+++ b/parametermanager/getParamVersion.js
@@ -64,12 +64,22 @@ async function main(
         `Payload: ${parameterVersion.payload.data.toString('utf-8')}`
       );
     }
+    return parameterVersion;
   }
 
-  await getParamVersion();
+  return await getParamVersion();
   // [END parametermanager_get_param_version]
 }
+module.exports.main = main;
 
-// The command-line arguments are passed as an array to main()
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/listParamVersions.js b/parametermanager/listParamVersions.js
index 01e67f775d..9a2c1cda40 100644
--- a/parametermanager/listParamVersions.js
+++ b/parametermanager/listParamVersions.js
@@ -45,18 +45,29 @@ async function main(projectId = 'my-project', parameterId = 'my-parameter') {
     };
 
     // Use listParameterVersionsAsync to handle pagination automatically
-    const iterable = await client.listParameterVersionsAsync(request);
+    const parameterVersions = await client.listParameterVersionsAsync(request);
 
-    for await (const version of iterable) {
+    for await (const version of parameterVersions) {
       console.log(
         `Found parameter version ${version.name} with state ${version.disabled ? 'disabled' : 'enabled'}`
       );
     }
+    return parameterVersions;
   }
 
-  await listParamVersions();
+  return await listParamVersions();
   // [END parametermanager_list_param_versions]
 }
+module.exports.main = main;
 
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/listParams.js b/parametermanager/listParams.js
index 0b5b0f84fd..9af78d499c 100644
--- a/parametermanager/listParams.js
+++ b/parametermanager/listParams.js
@@ -42,18 +42,29 @@ async function main(projectId = 'my-project') {
     };
 
     // Use listParametersAsync to handle pagination automatically
-    const iterable = await client.listParametersAsync(request);
+    const parameters = await client.listParametersAsync(request);
 
-    for await (const parameter of iterable) {
+    for await (const parameter of parameters) {
       console.log(
         `Found parameter ${parameter.name} with format ${parameter.format}`
       );
     }
+    return parameters;
   }
 
-  await listParams();
+  return await listParams();
   // [END parametermanager_list_params]
 }
+module.exports.main = main;
 
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/renderParamVersion.js b/parametermanager/renderParamVersion.js
index 65ace26239..37a35c5a48 100644
--- a/parametermanager/renderParamVersion.js
+++ b/parametermanager/renderParamVersion.js
@@ -57,22 +57,32 @@ async function main(
     };
 
     // Render the parameter version
-    const [response] = await client.renderParameterVersion(request);
-    console.log(`Rendered parameter version: ${response.parameterVersion}`);
+    const [parameterVersion] = await client.renderParameterVersion(request);
+    console.log(`Rendered parameter version: ${parameterVersion.parameterVersion}`);
 
     // If the parameter contains secret references, they will be resolved
     // and the actual secret values will be included in the rendered output.
     // Be cautious with logging or displaying this information.
     console.log(
       'Rendered payload: ',
-      response.renderedPayload.toString('utf-8')
+      parameterVersion.renderedPayload.toString('utf-8')
     );
+    return parameterVersion;
   }
 
-  await renderParamVersion();
+  return await renderParamVersion();
   // [END parametermanager_render_param_version]
 }
+module.exports.main = main;
 
-// Parse command line arguments
-const args = process.argv.slice(2);
-main(...args).catch(console.error);
+/* c8 ignore next 10 */
+if (require.main === module) {
+  main(...process.argv.slice(2)).catch(err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+  process.on('unhandledRejection', err => {
+    console.error(err.message);
+    process.exitCode = 1;
+  });
+}
diff --git a/parametermanager/test/parametermanager.test.js b/parametermanager/test/parametermanager.test.js
index f9005a9550..a5cd184f19 100644
--- a/parametermanager/test/parametermanager.test.js
+++ b/parametermanager/test/parametermanager.test.js
@@ -32,8 +32,6 @@ options.apiEndpoint = `parametermanager.${locationId}.rep.googleapis.com`;
 const secretOptions = {};
 secretOptions.apiEndpoint = `secretmanager.${locationId}.rep.googleapis.com`;
 
-const execSync = cmd => cp.execSync(cmd, {encoding: 'utf-8'});
-
 const secretId = `test-secret-${uuidv4()}`;
 const parameterId = `test-parameter-${uuidv4()}`;
 const parameterVersionId = 'v1';
@@ -109,111 +107,100 @@ describe('Parameter Manager samples', () => {
   });
 
   it('should create parameter version with secret references', async () => {
-    const output = execSync(
-      `node createParamVersionWithSecret.js ${projectId} ${parameterId} ${parameterVersionId}2 ${secretVersion.name}`
-    );
-    assert.include(
-      output,
-      `Created parameter version with secret references: projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}2`
-    );
+    const sample = require('../createParamVersionWithSecret');
+    const parameterVersion = await sample.main(
+      projectId,
+      parameterId,
+      parameterVersionId+"2",
+      secretVersion.name
+    );
+    assert.exists(parameterVersion);
+    assert.equal(parameterVersion.name, `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}2`);
   });
 
   it('should create a structured parameter', async () => {
-    const output = execSync(
-      `node createStructuredParam.js ${projectId} ${parameterId}-2`
+    const sample = require('../createStructuredParam');
+    const parameter = await sample.main(
+      projectId,
+      parameterId+"-2",
     );
+    assert.exists(parameter);
+    assert.equal(parameter.name, `projects/${projectId}/locations/global/parameters/${parameterId}-2`);
     parametersToDelete.push(
       client.parameterPath(projectId, 'global', `${parameterId}-2`)
     );
-    assert.include(
-      output,
-      `Created parameter projects/${projectId}/locations/global/parameters/${parameterId}-2 with format JSON`
-    );
   });
 
   it('should create a unstructured parameter', async () => {
-    const output = execSync(
-      `node createParam.js ${projectId} ${parameterId}-3`
+    const sample = require('../createParam');
+    const parameter = await sample.main(
+      projectId,
+      parameterId+"-3",
     );
+    assert.exists(parameter);
+    assert.equal(parameter.name, `projects/${projectId}/locations/global/parameters/${parameterId}-3`);
     parametersToDelete.push(
       client.parameterPath(projectId, 'global', `${parameterId}-3`)
     );
-    assert.include(
-      output,
-      `Created parameter: projects/${projectId}/locations/global/parameters/${parameterId}-3`
-    );
   });
 
   it('should create a structured parameter version', async () => {
-    const output = execSync(
-      `node createStructuredParamVersion.js ${projectId} ${parameterId}-2 ${parameterVersionId}`
-    );
-    assert.include(
-      output,
-      `Created parameter version: projects/${projectId}/locations/global/parameters/${parameterId}-2/versions/${parameterVersionId}`
-    );
+    const sample = require('../createStructuredParamVersion');
+    const parameterVersion = await sample.main(
+      projectId,
+      parameterId+"-2",
+      parameterVersionId,
+    );
+    assert.exists(parameterVersion);
+    assert.equal(parameterVersion.name, `projects/${projectId}/locations/global/parameters/${parameterId}-2/versions/${parameterVersionId}`);
   });
 
   it('should create a unstructured parameter version', async () => {
-    const output = execSync(
-      `node createParamVersion.js ${projectId} ${parameterId}-3 ${parameterVersionId}`
-    );
-    assert.include(
-      output,
-      `Created parameter version: projects/${projectId}/locations/global/parameters/${parameterId}-3/versions/${parameterVersionId}`
+    const sample = require('../createParamVersion');
+    const parameterVersion = await sample.main(
+      projectId,
+      parameterId+"-3",
+      parameterVersionId,
     );
+    assert.exists(parameterVersion);
   });
 
   it('should list parameters', async () => {
-    const output = execSync(`node listParams.js ${projectId}`);
-    assert.include(
-      output,
-      `Found parameter ${parameter.name} with format ${parameter.format}`
-    );
-    assert.include(
-      output,
-      `Found parameter projects/${projectId}/locations/global/parameters/${parameterId}-2 with format JSON`
-    );
-    assert.include(
-      output,
-      `Found parameter projects/${projectId}/locations/global/parameters/${parameterId}-3 with format UNFORMATTED`
+    const sample = require('../listParams');
+    const parameters = await sample.main(
+      projectId,
     );
+    assert.exists(parameters);
   });
 
   it('should get a parameter', async () => {
-    const output = execSync(`node getParam.js ${projectId} ${parameterId}`);
-    assert.include(
-      output,
-      `Found parameter ${parameter.name} with format ${parameter.format}`
+    const sample = require('../getParam');
+    const parameter = await sample.main(
+      projectId,
+      parameterId,
     );
+    assert.exists(parameter);
+    assert.equal(parameter.name, `projects/${projectId}/locations/global/parameters/${parameterId}`)
   });
 
   it('should list parameter versions', async () => {
-    const output = execSync(
-      `node listParamVersions.js ${projectId} ${parameterId}`
-    );
-    assert.include(
-      output,
-      `Found parameter version ${parameterVersion.name} with state enabled`
-    );
-    assert.include(
-      output,
-      `Found parameter version ${parameterVersion.name}2 with state enabled`
+    const sample = require('../listParamVersions');
+    const parameterVersions = await sample.main(
+      projectId,
+      parameterId,
     );
+    assert.exists(parameterVersions);
   });
 
   it('should get a parameter version', async () => {
-    const output = execSync(
-      `node getParamVersion.js ${projectId} ${parameterId} ${parameterVersionId}2`
-    );
-    assert.include(
-      output,
-      `Found parameter version ${parameterVersion.name}2 with state enabled`
-    );
-    assert.include(
-      output,
-      `Payload: {"db_user":"test_user","db_password":"__REF__(//secretmanager.googleapis.com/${secretVersion.name})"}`
-    );
+    const sample = require('../getParamVersion');
+    const parameterVersion = await sample.main(
+      projectId,
+      parameterId,
+      parameterVersionId,
+    );
+    assert.exists(parameterVersion);
+    assert.equal(parameterVersion.name, `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}`)
   });
 
   it('should render parameter version', async () => {
@@ -234,20 +221,12 @@ describe('Parameter Manager samples', () => {
       policy: policy,
     });
 
-    await new Promise(resolve => setTimeout(resolve, 120000));
-
-    const output = execSync(
-      `node renderParamVersion.js ${projectId} ${parameterId} ${parameterVersionId}2`
-    );
-    assert.include(output, 'Rendered parameter version:');
-    assert.include(
-      output,
-      `/parameters/${parameterId}/versions/${parameterVersionId}2`
-    );
-    assert.include(output, 'Rendered payload:');
-    assert.include(
-      output,
-      '{"db_user":"test_user","db_password":"my super secret data"}'
+    const sample = require('../renderParamVersion');
+    const parameterVersion = await sample.main(
+      projectId,
+      parameterId,
+      parameterVersionId,
     );
+    assert.exists(parameterVersion);
   });
 });

From 45b9a00549b0c3ad0154cfa0e9f4f8499470f4f8 Mon Sep 17 00:00:00 2001
From: durgesh-ninave-crest <durgesh.ninave@crestdata.ai>
Date: Fri, 25 Apr 2025 18:12:19 +0530
Subject: [PATCH 3/7] fix(parametermanager): fix linting issue

---
 parametermanager/renderParamVersion.js        |  4 +-
 .../test/parametermanager.test.js             | 81 +++++++++----------
 2 files changed, 39 insertions(+), 46 deletions(-)

diff --git a/parametermanager/renderParamVersion.js b/parametermanager/renderParamVersion.js
index 37a35c5a48..8e94cdd845 100644
--- a/parametermanager/renderParamVersion.js
+++ b/parametermanager/renderParamVersion.js
@@ -58,7 +58,9 @@ async function main(
 
     // Render the parameter version
     const [parameterVersion] = await client.renderParameterVersion(request);
-    console.log(`Rendered parameter version: ${parameterVersion.parameterVersion}`);
+    console.log(
+      `Rendered parameter version: ${parameterVersion.parameterVersion}`
+    );
 
     // If the parameter contains secret references, they will be resolved
     // and the actual secret values will be included in the rendered output.
diff --git a/parametermanager/test/parametermanager.test.js b/parametermanager/test/parametermanager.test.js
index a5cd184f19..675988f003 100644
--- a/parametermanager/test/parametermanager.test.js
+++ b/parametermanager/test/parametermanager.test.js
@@ -15,7 +15,6 @@
 'use strict';
 
 const {assert} = require('chai');
-const cp = require('child_process');
 const {v4: uuidv4} = require('uuid');
 
 const {ParameterManagerClient} = require('@google-cloud/parametermanager');
@@ -37,7 +36,6 @@ const parameterId = `test-parameter-${uuidv4()}`;
 const parameterVersionId = 'v1';
 
 let parameter;
-let parameterVersion;
 let secret;
 let secretVersion;
 
@@ -75,17 +73,6 @@ describe('Parameter Manager samples', () => {
       },
     });
     parametersToDelete.push(parameter.name);
-
-    // Create a version for the global parameter
-    [parameterVersion] = await client.createParameterVersion({
-      parent: parameter.name,
-      parameterVersionId: parameterVersionId,
-      parameterVersion: {
-        payload: {
-          data: Buffer.from(JSON.stringify({key: 'global_value'}), 'utf-8'),
-        },
-      },
-    });
   });
 
   after(async () => {
@@ -111,21 +98,24 @@ describe('Parameter Manager samples', () => {
     const parameterVersion = await sample.main(
       projectId,
       parameterId,
-      parameterVersionId+"2",
+      parameterVersionId + '2',
       secretVersion.name
     );
     assert.exists(parameterVersion);
-    assert.equal(parameterVersion.name, `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}2`);
+    assert.equal(
+      parameterVersion.name,
+      `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}2`
+    );
   });
 
   it('should create a structured parameter', async () => {
     const sample = require('../createStructuredParam');
-    const parameter = await sample.main(
-      projectId,
-      parameterId+"-2",
-    );
+    const parameter = await sample.main(projectId, parameterId + '-2');
     assert.exists(parameter);
-    assert.equal(parameter.name, `projects/${projectId}/locations/global/parameters/${parameterId}-2`);
+    assert.equal(
+      parameter.name,
+      `projects/${projectId}/locations/global/parameters/${parameterId}-2`
+    );
     parametersToDelete.push(
       client.parameterPath(projectId, 'global', `${parameterId}-2`)
     );
@@ -133,12 +123,12 @@ describe('Parameter Manager samples', () => {
 
   it('should create a unstructured parameter', async () => {
     const sample = require('../createParam');
-    const parameter = await sample.main(
-      projectId,
-      parameterId+"-3",
-    );
+    const parameter = await sample.main(projectId, parameterId + '-3');
     assert.exists(parameter);
-    assert.equal(parameter.name, `projects/${projectId}/locations/global/parameters/${parameterId}-3`);
+    assert.equal(
+      parameter.name,
+      `projects/${projectId}/locations/global/parameters/${parameterId}-3`
+    );
     parametersToDelete.push(
       client.parameterPath(projectId, 'global', `${parameterId}-3`)
     );
@@ -148,47 +138,45 @@ describe('Parameter Manager samples', () => {
     const sample = require('../createStructuredParamVersion');
     const parameterVersion = await sample.main(
       projectId,
-      parameterId+"-2",
-      parameterVersionId,
+      parameterId + '-2',
+      parameterVersionId
     );
     assert.exists(parameterVersion);
-    assert.equal(parameterVersion.name, `projects/${projectId}/locations/global/parameters/${parameterId}-2/versions/${parameterVersionId}`);
+    assert.equal(
+      parameterVersion.name,
+      `projects/${projectId}/locations/global/parameters/${parameterId}-2/versions/${parameterVersionId}`
+    );
   });
 
   it('should create a unstructured parameter version', async () => {
     const sample = require('../createParamVersion');
     const parameterVersion = await sample.main(
       projectId,
-      parameterId+"-3",
-      parameterVersionId,
+      parameterId + '-3',
+      parameterVersionId
     );
     assert.exists(parameterVersion);
   });
 
   it('should list parameters', async () => {
     const sample = require('../listParams');
-    const parameters = await sample.main(
-      projectId,
-    );
+    const parameters = await sample.main(projectId);
     assert.exists(parameters);
   });
 
   it('should get a parameter', async () => {
     const sample = require('../getParam');
-    const parameter = await sample.main(
-      projectId,
-      parameterId,
-    );
+    const parameter = await sample.main(projectId, parameterId);
     assert.exists(parameter);
-    assert.equal(parameter.name, `projects/${projectId}/locations/global/parameters/${parameterId}`)
+    assert.equal(
+      parameter.name,
+      `projects/${projectId}/locations/global/parameters/${parameterId}`
+    );
   });
 
   it('should list parameter versions', async () => {
     const sample = require('../listParamVersions');
-    const parameterVersions = await sample.main(
-      projectId,
-      parameterId,
-    );
+    const parameterVersions = await sample.main(projectId, parameterId);
     assert.exists(parameterVersions);
   });
 
@@ -197,10 +185,13 @@ describe('Parameter Manager samples', () => {
     const parameterVersion = await sample.main(
       projectId,
       parameterId,
-      parameterVersionId,
+      parameterVersionId + '2'
     );
     assert.exists(parameterVersion);
-    assert.equal(parameterVersion.name, `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}`)
+    assert.equal(
+      parameterVersion.name,
+      `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}2`
+    );
   });
 
   it('should render parameter version', async () => {
@@ -225,7 +216,7 @@ describe('Parameter Manager samples', () => {
     const parameterVersion = await sample.main(
       projectId,
       parameterId,
-      parameterVersionId,
+      parameterVersionId + '2'
     );
     assert.exists(parameterVersion);
   });

From 857876d70532d0428d9a6f35e0eaa84ec92ff664 Mon Sep 17 00:00:00 2001
From: durgesh-ninave-crest <durgesh.ninave@crestdata.ai>
Date: Mon, 28 Apr 2025 11:17:31 +0530
Subject: [PATCH 4/7] fix(parametermanager): update test cases

---
 parametermanager/test/parametermanager.test.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/parametermanager/test/parametermanager.test.js b/parametermanager/test/parametermanager.test.js
index 675988f003..25d939f18c 100644
--- a/parametermanager/test/parametermanager.test.js
+++ b/parametermanager/test/parametermanager.test.js
@@ -111,27 +111,27 @@ describe('Parameter Manager samples', () => {
   it('should create a structured parameter', async () => {
     const sample = require('../createStructuredParam');
     const parameter = await sample.main(projectId, parameterId + '-2');
+    parametersToDelete.push(
+      client.parameterPath(projectId, 'global', `${parameterId}-2`)
+    );
     assert.exists(parameter);
     assert.equal(
       parameter.name,
       `projects/${projectId}/locations/global/parameters/${parameterId}-2`
     );
-    parametersToDelete.push(
-      client.parameterPath(projectId, 'global', `${parameterId}-2`)
-    );
   });
 
   it('should create a unstructured parameter', async () => {
     const sample = require('../createParam');
     const parameter = await sample.main(projectId, parameterId + '-3');
+    parametersToDelete.push(
+      client.parameterPath(projectId, 'global', `${parameterId}-3`)
+    );
     assert.exists(parameter);
     assert.equal(
       parameter.name,
       `projects/${projectId}/locations/global/parameters/${parameterId}-3`
     );
-    parametersToDelete.push(
-      client.parameterPath(projectId, 'global', `${parameterId}-3`)
-    );
   });
 
   it('should create a structured parameter version', async () => {

From 717a76fa041b867fd4846dd80f0773ac310a53e4 Mon Sep 17 00:00:00 2001
From: durgesh-ninave-crest <durgesh.ninave@crestdata.ai>
Date: Fri, 2 May 2025 11:29:36 +0530
Subject: [PATCH 5/7] fix(parametermanager): update testcases and function
 arguments

---
 parametermanager/createParam.js               |   2 +-
 parametermanager/createParamVersion.js        |   7 +-
 .../createParamVersionWithSecret.js           |   7 +-
 parametermanager/createStructuredParam.js     |   8 +-
 .../createStructuredParamVersion.js           |   7 +-
 parametermanager/getParam.js                  |   2 +-
 parametermanager/getParamVersion.js           |   6 +-
 parametermanager/listParamVersions.js         |   2 +-
 parametermanager/listParams.js                |   2 +-
 parametermanager/renderParamVersion.js        |   6 +-
 .../test/parametermanager.test.js             | 101 ++++++++++++------
 11 files changed, 77 insertions(+), 73 deletions(-)

diff --git a/parametermanager/createParam.js b/parametermanager/createParam.js
index 71f51fd028..d65ac75e03 100644
--- a/parametermanager/createParam.js
+++ b/parametermanager/createParam.js
@@ -20,7 +20,7 @@
  * @param {string} projectId - The Google Cloud project ID where the parameter is to be created.
  * @param {string} parameterId - The ID of the parameter to create. This ID must be unique within the project.
  */
-async function main(projectId = 'my-project', parameterId = 'my-parameter') {
+async function main(projectId, parameterId) {
   // [START parametermanager_create_param]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/createParamVersion.js b/parametermanager/createParamVersion.js
index 62a74e26be..9585745077 100644
--- a/parametermanager/createParamVersion.js
+++ b/parametermanager/createParamVersion.js
@@ -22,12 +22,7 @@
  * @param {string} parameterVersionId - The ID of the parameter version to be created.
  * @param {string} payload - The unformatted string payload to be stored in the new parameter version.
  */
-async function main(
-  projectId = 'my-project',
-  parameterId = 'my-parameter',
-  parameterVersionId = 'v1',
-  payload = 'This is unstructured data'
-) {
+async function main(projectId, parameterId, parameterVersionId, payload) {
   // [START parametermanager_create_param_version]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/createParamVersionWithSecret.js b/parametermanager/createParamVersionWithSecret.js
index 91da150d7c..2761adf353 100644
--- a/parametermanager/createParamVersionWithSecret.js
+++ b/parametermanager/createParamVersionWithSecret.js
@@ -24,12 +24,7 @@
  * @param {string} parameterVersionId - The ID of the parameter version to be created.
  * @param {string} secretId - The ID of the secret to be referenced.
  */
-async function main(
-  projectId = 'my-project',
-  parameterId = 'my-parameter',
-  parameterVersionId = 'v1',
-  secretId = 'projects/my-project/secrets/application-secret/version/latest'
-) {
+async function main(projectId, parameterId, parameterVersionId, secretId) {
   // [START parametermanager_create_param_version_with_secret]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/createStructuredParam.js b/parametermanager/createStructuredParam.js
index 86a9e8abab..cc349964f7 100644
--- a/parametermanager/createStructuredParam.js
+++ b/parametermanager/createStructuredParam.js
@@ -14,8 +14,6 @@
 
 'use strict';
 
-const {protos} = require('@google-cloud/parametermanager');
-
 /**
  * Creates a parameter in the global location of the specified
  * project with specified format using the Google Cloud Parameter Manager SDK.
@@ -24,11 +22,7 @@ const {protos} = require('@google-cloud/parametermanager');
  * @param {string} parameterId - The ID of the parameter to create. This ID must be unique within the project.
  * @param {string} formatType - The format type of the parameter (UNFORMATTED, YAML, JSON).
  */
-async function main(
-  projectId = 'my-project',
-  parameterId = 'my-json-parameter',
-  formatType = protos.google.cloud.parametermanager.v1.ParameterFormat.JSON
-) {
+async function main(projectId, parameterId, formatType) {
   // [START parametermanager_create_structured_param]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/createStructuredParamVersion.js b/parametermanager/createStructuredParamVersion.js
index f8d65b7e7e..79bc2809c4 100644
--- a/parametermanager/createStructuredParamVersion.js
+++ b/parametermanager/createStructuredParamVersion.js
@@ -24,12 +24,7 @@
  * @param {string} parameterVersionId - The ID of the parameter version to be created.
  * @param {Object} payload - The JSON payload data to be stored in the parameter version.
  */
-async function main(
-  projectId = 'my-project',
-  parameterId = 'my-parameter',
-  parameterVersionId = 'v1',
-  payload = {username: 'test-user', host: 'localhost'}
-) {
+async function main(projectId, parameterId, parameterVersionId, payload) {
   // [START parametermanager_create_structured_param_version]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/getParam.js b/parametermanager/getParam.js
index 35385c8e77..b2ff816104 100644
--- a/parametermanager/getParam.js
+++ b/parametermanager/getParam.js
@@ -21,7 +21,7 @@
  * @param {string} projectId - The Google Cloud project ID where the parameter is located.
  * @param {string} parameterId - The ID of the parameter to retrieve.
  */
-async function main(projectId = 'my-project', parameterId = 'my-parameter') {
+async function main(projectId, parameterId) {
   // [START parametermanager_get_param]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/getParamVersion.js b/parametermanager/getParamVersion.js
index 4f343e8087..7771e6086f 100644
--- a/parametermanager/getParamVersion.js
+++ b/parametermanager/getParamVersion.js
@@ -22,11 +22,7 @@
  * @param {string} parameterId - The ID of the parameter for which the version details are to be retrieved.
  * @param {string} versionId - The version ID of the parameter to retrieve.
  */
-async function main(
-  projectId = 'my-project',
-  parameterId = 'my-parameter',
-  versionId = 'v1'
-) {
+async function main(projectId, parameterId, versionId) {
   // [START parametermanager_get_param_version]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/listParamVersions.js b/parametermanager/listParamVersions.js
index 9a2c1cda40..7e8cf5116e 100644
--- a/parametermanager/listParamVersions.js
+++ b/parametermanager/listParamVersions.js
@@ -22,7 +22,7 @@
  * @param {string} projectId - The Google Cloud project ID where parameter is located.
  * @param {string} parameterId - The parameter ID for which versions are to be listed.
  */
-async function main(projectId = 'my-project', parameterId = 'my-parameter') {
+async function main(projectId, parameterId) {
   // [START parametermanager_list_param_versions]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/listParams.js b/parametermanager/listParams.js
index 9af78d499c..1970f1078c 100644
--- a/parametermanager/listParams.js
+++ b/parametermanager/listParams.js
@@ -20,7 +20,7 @@
  *
  * @param {string} projectId - The Google Cloud project ID where the parameters are located.
  */
-async function main(projectId = 'my-project') {
+async function main(projectId) {
   // [START parametermanager_list_params]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/renderParamVersion.js b/parametermanager/renderParamVersion.js
index 8e94cdd845..6e0095ef77 100644
--- a/parametermanager/renderParamVersion.js
+++ b/parametermanager/renderParamVersion.js
@@ -23,11 +23,7 @@
  * @param {string} parameterId - The ID of the parameter for which version details are to be rendered.
  * @param {string} parameterVersionId - The ID of the parameter version to be rendered.
  */
-async function main(
-  projectId = 'my-project',
-  parameterId = 'my-parameter',
-  parameterVersionId = 'v1'
-) {
+async function main(projectId, parameterId, parameterVersionId) {
   // [START parametermanager_render_param_version]
   /**
    * TODO(developer): Uncomment these variables before running the sample.
diff --git a/parametermanager/test/parametermanager.test.js b/parametermanager/test/parametermanager.test.js
index 25d939f18c..a951354e89 100644
--- a/parametermanager/test/parametermanager.test.js
+++ b/parametermanager/test/parametermanager.test.js
@@ -33,7 +33,10 @@ secretOptions.apiEndpoint = `secretmanager.${locationId}.rep.googleapis.com`;
 
 const secretId = `test-secret-${uuidv4()}`;
 const parameterId = `test-parameter-${uuidv4()}`;
-const parameterVersionId = 'v1';
+const parameterVersionId = `test-version-${uuidv4()}`;
+
+const jsonPayload = '{username: "test-user", host: "localhost"}';
+const payload = 'This is unstructured data';
 
 let parameter;
 let secret;
@@ -41,6 +44,7 @@ let secretVersion;
 
 describe('Parameter Manager samples', () => {
   const parametersToDelete = [];
+  const parameterVersionsToDelete = [];
 
   before(async () => {
     projectId = await client.getProjectId();
@@ -76,21 +80,45 @@ describe('Parameter Manager samples', () => {
   });
 
   after(async () => {
-    // Clean up
-    parametersToDelete.forEach(async parameterName => {
-      await client.deleteParameterVersion({
-        name: `${parameterName}/versions/v1`,
+    // Delete all parameter versions first
+    try {
+      await Promise.all(
+        parameterVersionsToDelete.map(async parameterVersionName => {
+          await client.deleteParameterVersion({
+            name: parameterVersionName,
+          });
+        })
+      );
+    } catch (err) {
+      if (!err.message.includes('NOT_FOUND')) {
+        throw err;
+      }
+    }
+
+    // Delete all parameters
+    try {
+      await Promise.all(
+        parametersToDelete.map(async parameterName => {
+          await client.deleteParameter({
+            name: parameterName,
+          });
+        })
+      );
+    } catch (err) {
+      if (!err.message.includes('NOT_FOUND')) {
+        throw err;
+      }
+    }
+
+    try {
+      await secretClient.deleteSecret({
+        name: secret.name,
       });
-      if (parameterName === parameter.name) {
-        await client.deleteParameterVersion({
-          name: `${parameterName}/versions/v12`,
-        });
+    } catch (err) {
+      if (!err.message.includes('NOT_FOUND')) {
+        throw err;
       }
-      await client.deleteParameter({name: parameterName});
-    });
-    await secretClient.deleteSecret({
-      name: secret.name,
-    });
+    }
   });
 
   it('should create parameter version with secret references', async () => {
@@ -98,39 +126,36 @@ describe('Parameter Manager samples', () => {
     const parameterVersion = await sample.main(
       projectId,
       parameterId,
-      parameterVersionId + '2',
+      parameterVersionId + '-1',
       secretVersion.name
     );
+    parameterVersionsToDelete.push(parameterVersion.name);
     assert.exists(parameterVersion);
     assert.equal(
       parameterVersion.name,
-      `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}2`
+      `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}-1`
     );
   });
 
   it('should create a structured parameter', async () => {
     const sample = require('../createStructuredParam');
-    const parameter = await sample.main(projectId, parameterId + '-2');
-    parametersToDelete.push(
-      client.parameterPath(projectId, 'global', `${parameterId}-2`)
-    );
+    const parameter = await sample.main(projectId, parameterId + '-1');
+    parametersToDelete.push(parameter.name);
     assert.exists(parameter);
     assert.equal(
       parameter.name,
-      `projects/${projectId}/locations/global/parameters/${parameterId}-2`
+      `projects/${projectId}/locations/global/parameters/${parameterId}-1`
     );
   });
 
   it('should create a unstructured parameter', async () => {
     const sample = require('../createParam');
-    const parameter = await sample.main(projectId, parameterId + '-3');
-    parametersToDelete.push(
-      client.parameterPath(projectId, 'global', `${parameterId}-3`)
-    );
+    const parameter = await sample.main(projectId, parameterId + '-2');
+    parametersToDelete.push(parameter.name);
     assert.exists(parameter);
     assert.equal(
       parameter.name,
-      `projects/${projectId}/locations/global/parameters/${parameterId}-3`
+      `projects/${projectId}/locations/global/parameters/${parameterId}-2`
     );
   });
 
@@ -138,13 +163,15 @@ describe('Parameter Manager samples', () => {
     const sample = require('../createStructuredParamVersion');
     const parameterVersion = await sample.main(
       projectId,
-      parameterId + '-2',
-      parameterVersionId
+      parameterId + '-1',
+      parameterVersionId + '-2',
+      jsonPayload
     );
+    parameterVersionsToDelete.push(parameterVersion.name);
     assert.exists(parameterVersion);
     assert.equal(
       parameterVersion.name,
-      `projects/${projectId}/locations/global/parameters/${parameterId}-2/versions/${parameterVersionId}`
+      `projects/${projectId}/locations/global/parameters/${parameterId}-1/versions/${parameterVersionId}-2`
     );
   });
 
@@ -152,10 +179,16 @@ describe('Parameter Manager samples', () => {
     const sample = require('../createParamVersion');
     const parameterVersion = await sample.main(
       projectId,
-      parameterId + '-3',
-      parameterVersionId
+      parameterId + '-2',
+      parameterVersionId + '-3',
+      payload
     );
+    parameterVersionsToDelete.push(parameterVersion.name);
     assert.exists(parameterVersion);
+    assert.equal(
+      parameterVersion.name,
+      `projects/${projectId}/locations/global/parameters/${parameterId}-2/versions/${parameterVersionId}-3`
+    );
   });
 
   it('should list parameters', async () => {
@@ -185,12 +218,12 @@ describe('Parameter Manager samples', () => {
     const parameterVersion = await sample.main(
       projectId,
       parameterId,
-      parameterVersionId + '2'
+      parameterVersionId + '-1'
     );
     assert.exists(parameterVersion);
     assert.equal(
       parameterVersion.name,
-      `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}2`
+      `projects/${projectId}/locations/global/parameters/${parameterId}/versions/${parameterVersionId}-1`
     );
   });
 
@@ -216,7 +249,7 @@ describe('Parameter Manager samples', () => {
     const parameterVersion = await sample.main(
       projectId,
       parameterId,
-      parameterVersionId + '2'
+      parameterVersionId + '-1'
     );
     assert.exists(parameterVersion);
   });

From 4bb25785f96b1002a26b567a015fa5e03b93b840 Mon Sep 17 00:00:00 2001
From: durgesh-ninave-crest <durgesh.ninave@crestdata.ai>
Date: Fri, 2 May 2025 11:34:58 +0530
Subject: [PATCH 6/7] fix(parametermanager): fix lint issue

---
 parametermanager/test/.eslintrc.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/parametermanager/test/.eslintrc.yml b/parametermanager/test/.eslintrc.yml
index 9351c489b5..74add4846e 100644
--- a/parametermanager/test/.eslintrc.yml
+++ b/parametermanager/test/.eslintrc.yml
@@ -14,4 +14,4 @@
 
 ---
 env:
-  mocha: true
\ No newline at end of file
+  mocha: true

From f6bb600586641ec49c38c667772ddedbc8a02f86 Mon Sep 17 00:00:00 2001
From: durgesh-ninave-crest <durgesh.ninave@crestdata.ai>
Date: Fri, 2 May 2025 15:47:45 +0530
Subject: [PATCH 7/7] fix(parametermanager): update testcase

---
 .../test/parametermanager.test.js             | 40 +++++++++----------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/parametermanager/test/parametermanager.test.js b/parametermanager/test/parametermanager.test.js
index a951354e89..01d3661e98 100644
--- a/parametermanager/test/parametermanager.test.js
+++ b/parametermanager/test/parametermanager.test.js
@@ -81,34 +81,34 @@ describe('Parameter Manager samples', () => {
 
   after(async () => {
     // Delete all parameter versions first
-    try {
-      await Promise.all(
-        parameterVersionsToDelete.map(async parameterVersionName => {
+    await Promise.all(
+      parameterVersionsToDelete.map(async parameterVersionName => {
+        try {
           await client.deleteParameterVersion({
             name: parameterVersionName,
           });
-        })
-      );
-    } catch (err) {
-      if (!err.message.includes('NOT_FOUND')) {
-        throw err;
-      }
-    }
+        } catch (err) {
+          if (!err.message.includes('NOT_FOUND')) {
+            throw err;
+          }
+        }
+      })
+    );
 
     // Delete all parameters
-    try {
-      await Promise.all(
-        parametersToDelete.map(async parameterName => {
+    await Promise.all(
+      parametersToDelete.map(async parameterName => {
+        try {
           await client.deleteParameter({
             name: parameterName,
           });
-        })
-      );
-    } catch (err) {
-      if (!err.message.includes('NOT_FOUND')) {
-        throw err;
-      }
-    }
+        } catch (err) {
+          if (!err.message.includes('NOT_FOUND')) {
+            throw err;
+          }
+        }
+      })
+    );
 
     try {
       await secretClient.deleteSecret({