System tests should cleanup after themselves

__tests__/__packages__/cli-test-utils/src/TestUtils.ts

@@ -10,9 +10,53 @@
 */
 
 import * as fs from "fs";
-import { spawnSync, SpawnSyncReturns, ExecFileException } from "child_process";
+import { spawnSync, SpawnSyncReturns, ExecFileException, execSync } from "child_process";
 import { ITestEnvironment } from "./environment/doc/response/ITestEnvironment";
-import { CommandProfiles, ICommandDefinition, IHandlerParameters } from "@zowe/imperative";
+import { AbstractSession, CommandProfiles, ICommandDefinition, IHandlerParameters } from "@zowe/imperative";
+import { DeleteJobs, IDeleteJobParms, IJob } from "@zowe/zos-jobs-for-zowe-sdk";
+
+/**
+ * Delete a uss file from the mainframe
+ * @param {string} filePath - The USS path to the file
+ */
+export function deleteFiles(filePath: string): void {
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+    execSync(`zowe zos-files delete uss-file "${filePath}" -f`);
+
+}
+
+/**
+ * Delete a job from the mainframe using Zowe SDKs - IJob
+ * @param {AbstractSession} session - z/OSMF connection info
+ * @param {IJob} job - the job that you want to delete
+ */
+export function deleteJob(session: AbstractSession, job: IJob): void {
+    DeleteJobs.deleteJobForJob(session, job);
+}
+
+/**
+ * Delete a job from the mainframe using Zowe SDKs - jobid, jobname
+ * @param {AbstractSession} session - z/OSMF connection info
+ * @param {jobName} string - jobname for job to delete
+ * @param {jobId} string - jobid for job to delete
+ */
+export function deleteJobCommon(session: AbstractSession, job: IJob): void {
+    const parms: IDeleteJobParms = {
+        jobid: job.jobid,  // job ID
+        jobname: job.jobname,  // job name
+    };
+    DeleteJobs.deleteJobCommon(session, parms);
+}
+
+/**
+ * Delete a dataset by name
+ * @param {string} datasetName - The name of the dataset
+ */
+export function deleteDataset(datasetName: string): void {
+    execSync(`zowe zos-files delete data-set "${datasetName}" -f`);
+}
 
 /**
  * Execute a CLI script

__tests__/__packages__/cli-test-utils/src/environment/TestEnvironment.ts

@@ -11,16 +11,14 @@
 
 import * as fs from "fs";
 import * as nodePath from "path";
-
 import * as yaml from "js-yaml";
 import { v4 as uuidv4 } from "uuid";
-import { ImperativeError, ImperativeExpect, IO, Logger, LoggingConfigurer, TextUtils } from "@zowe/imperative";
-
+import { AbstractSession, ImperativeError, ImperativeExpect, IO, Logger, LoggingConfigurer, ProfileInfo, Session, TextUtils } from "@zowe/imperative";
 import { ISetupEnvironmentParms } from "./doc/parms/ISetupEnvironmentParms";
 import { ITestEnvironment } from "./doc/response/ITestEnvironment";
 import { TempTestProfiles } from "./TempTestProfiles";
 import { PROJECT_ROOT_DIR, TEST_RESOURCE_DIR, TEST_RESULT_DATA_DIR, TEST_USING_WORKSPACE } from "../TestConstants";
-import { runCliScript } from "../TestUtils";
+import { runCliScript, deleteFiles, deleteJob, deleteDataset } from "../TestUtils";
 
 /**
  * Use the utility methods here to setup the test environment for running APIs
@@ -43,7 +41,7 @@
      * @returns {Promise<ITestEnvironment>}
      * @memberof TestEnvironment
      */
-    public static async setUp(params: ISetupEnvironmentParms): Promise<ITestEnvironment<any>> {
+    public static async setUp(params: ISetupEnvironmentParms, session?: AbstractSession): Promise<ITestEnvironment<any>> {
         // Validate the input parameters
         ImperativeExpect.toNotBeNullOrUndefined(params,
             `${TestEnvironment.ERROR_TAG} createTestEnv(): No parameters supplied.`);
@@ -66,7 +64,13 @@
         const result: ITestEnvironment<any> = {
             workingDir: testDirectory,
             systemTestProperties: systemProps,
-            env
+            env,
+            resources: {
+                files: [],
+                jobs: [],
+                datasets: [],
+                ...(session && { session })  // Only include session if it is passed in
+            }
         };
 
         if (params.installPlugin) {
@@ -85,6 +89,24 @@
         return result;
     }
 
+    /**
+     * Create a session using the default z/OSMF profile (if a session has not been added to test)
+     * @returns {Promise<ISession>} - A promise that resolves to the created session object
+     * @throws Will throw an error if reading profiles or creating the session fails
+     * @memberof TestEnvironment
+     */
+    public static async createSession(): Promise<AbstractSession> {
+        // Load connection info from default z/OSMF profile
+        const profInfo = new ProfileInfo("zowe");
+        await profInfo.readProfilesFromDisk();
+        const zosmfProfAttrs = profInfo.getDefaultProfile("zosmf");
+        if (!zosmfProfAttrs) {
+            throw new Error("Default z/OSMF profile not found.");
+        }
+        const zosmfMergedArgs = profInfo.mergeArgsForProfile(zosmfProfAttrs, { getSecureVals: true });
+        return ProfileInfo.createSession(zosmfMergedArgs.knownArgs);
+    }
+
     /**
      * Clean up your test environment.
      * Deletes any temporary profiles that have been created
@@ -102,6 +124,20 @@
             const pluginDir = testEnvironment.workingDir + "/plugins";
             require("rimraf").sync(pluginDir);
         }
+
+        // Clean up resources
+        // Check if session exists; if not, create one
+        const session = testEnvironment.resources.session || await TestEnvironment.createSession();
+
+        for (const file of testEnvironment.resources.files) {
+            deleteFiles(file);
+        }
+        for (const job of testEnvironment.resources.jobs) {
+            deleteJob(session, job);
+        }
+        for (const dataset of testEnvironment.resources.datasets) {
+            deleteDataset(dataset);
+        }
     }
 
     /**

__tests__/__packages__/cli-test-utils/src/environment/doc/response/ITestEnvironment.ts

@@ -9,12 +9,21 @@
 *
 */
 
+import { AbstractSession } from "@zowe/imperative";
+import { IJob } from "@zowe/zos-jobs-for-zowe-sdk";
+
 /**
  * The test environment for your test.
  * @export
  * @interface ITestEnvironment
  */
 export interface ITestEnvironment<TestPropertiesSchema> {
+    resources: {
+        files: string[];
+        jobs: IJob[];
+        datasets: string[];
+        session?: AbstractSession;
+    };
     /**
      * The working directory for your test environment. It is a unique (uuid) area where your tests can create
      * their home folders (for imperative, etc.) and you can use the area as scratch for any files, etc. that

packages/cli/__tests__/zosjobs/__system__/search/__scripts__/job/search_string_spool_content.sh

@@ -1,21 +1,27 @@
 #!/bin/bash
-# TODO - delete the job from spool
+
 # Submit the job and ensure the RC is 0
 JOBID="$(zowe jobs submit ds "$1" --wfo true --rff jobid --rft string)"
 CMDRC=$?
-if [ $CMDRC -gt 0 ]
-then
-    echo $JOBID 1>&2
-    echo "Submit returned a non-zero return code" 1>&2
+echo "Job ID: $JOBID"
+if [ $CMDRC -gt 0 ]; then
+    echo "Job submission failed with return code $CMDRC" 1>&2
     exit $CMDRC
 fi
 
-zowe jobs search job "$2" --search-string "$3"
+# Ensure the job ID is valid
+if [ -z "$JOBID" ]; then
+    echo "Job ID is empty, cannot proceed with the search." 1>&2
+    exit 1
+fi
+
+# Wait for a few seconds to ensure job output is available
+sleep 5
+
+# Search the job's spool files
+zowe jobs search job "$JOBID" --search-string "$3"
 RC=$?
-if [ $RC -gt 0 ]
-then
-    echo $STATUS 1>&2
+if [ $RC -gt 0 ]; then
     echo "The search spool job command returned a non-zero rc: $RC" 1>&2
     exit $RC
-fi
-
+fi

packages/zosjobs/__tests__/__system__/CancelJobs.system.test.ts

@@ -11,10 +11,9 @@
 
 import { ImperativeError, Session, RestClientError } from "@zowe/imperative";
 import { CancelJobs, SubmitJobs, IJob } from "../../src";
-import { ITestEnvironment } from "@zowe/cli-test-utils";
-import { TestEnvironment } from "../../../../__tests__/__src__/environment/TestEnvironment";
 import { ITestPropertiesSchema } from "../../../../__tests__/__src__/properties/ITestPropertiesSchema";
 import { JobTestsUtils } from "./JobTestsUtils";
+import { ITestEnvironment, TestEnvironment } from "@zowe/cli-test-utils";
 
 let REAL_SESSION: Session;
 let sleepJCL: string;
@@ -28,23 +27,26 @@ describe("CancelJobs System tests", () => {
     beforeAll(async () => {
         testEnvironment = await TestEnvironment.setUp({
             testName: "zos_cancel_jobs"
-        });
+        }, REAL_SESSION = await TestEnvironment.createSession());
         systemProps = testEnvironment.systemTestProperties;
 
-        REAL_SESSION = TestEnvironment.createZosmfSession(testEnvironment);
-
         const ACCOUNT = systemProps.tso.account;
         const maxStepNum = 6;  // Use lots of steps to make the job stay in INPUT status longer
 
         sleepJCL = JobTestsUtils.getSleepJCL(REAL_SESSION.ISession.user, ACCOUNT, systemProps.zosjobs.jobclass, maxStepNum);
     });
 
+    afterAll(async () => {
+        await TestEnvironment.cleanUp(testEnvironment);
+    });
+
     describe("Positive tests", () => {
         it("should be able to cancel a job using cancelJob (modify version 1)", async () => {
             const job = await SubmitJobs.submitJclNotifyCommon(REAL_SESSION, {jcl: sleepJCL, status: "INPUT"});
             expect(job.retcode).toBeNull(); // job is not complete, no CC
             const response = await CancelJobs.cancelJob(REAL_SESSION, job.jobname, job.jobid, "1.0");
             expect(response).toBeUndefined();
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJob (modify version 2)", async () => {
@@ -53,6 +55,7 @@ describe("CancelJobs System tests", () => {
             const response = await CancelJobs.cancelJob(REAL_SESSION, job.jobname, job.jobid, "2.0");
             expect(response).not.toBeUndefined();
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJob (modify version default)", async () => {
@@ -61,13 +64,15 @@ describe("CancelJobs System tests", () => {
             const response = await CancelJobs.cancelJob(REAL_SESSION, job.jobname, job.jobid);
             expect(response).not.toBeUndefined();
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobForJob (modify version 1)", async () => {
             const job = await SubmitJobs.submitJclNotifyCommon(REAL_SESSION, {jcl: sleepJCL, status: "INPUT"});
             expect(job.retcode).toBeNull(); // job is not complete, no CC
             const response = await CancelJobs.cancelJobForJob(REAL_SESSION, job, "1.0");
             expect(response).toBeUndefined();
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobForJob (modify version 2)", async () => {
@@ -76,6 +81,7 @@ describe("CancelJobs System tests", () => {
             const response = await CancelJobs.cancelJobForJob(REAL_SESSION, job, "2.0");
             expect(response).not.toBeUndefined();
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobForJob (modify version default)", async () => {
@@ -84,13 +90,15 @@ describe("CancelJobs System tests", () => {
             const response = await CancelJobs.cancelJobForJob(REAL_SESSION, job);
             expect(response).not.toBeUndefined();
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobCommon (job version 1)", async () => {
             const job = await SubmitJobs.submitJclNotifyCommon(REAL_SESSION, {jcl: sleepJCL, status: "INPUT"});
             expect(job.retcode).toBeNull(); // job is not complete, no CC
             const response = await CancelJobs.cancelJobCommon(REAL_SESSION, {jobname: job.jobname, jobid: job.jobid, version: "1.0"});
             expect(response).toBeUndefined();
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobCommon (job version 2.0 - synchronous)", async () => {
@@ -99,13 +107,15 @@ describe("CancelJobs System tests", () => {
             const response = await CancelJobs.cancelJobCommon(REAL_SESSION, {jobname: job.jobname, jobid: job.jobid, version: "2.0"});
             expect(response).toBeDefined();
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobCommon (job version default)", async () => {
             const job = await SubmitJobs.submitJclNotifyCommon(REAL_SESSION, {jcl: sleepJCL, status: "INPUT"});
             expect(job.retcode).toBeNull(); // job is not complete, no CC
             const response = await CancelJobs.cancelJobCommon(REAL_SESSION, {jobname: job.jobname, jobid: job.jobid});
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobCommon (job version 2.0 - synchronous) and return an error feedback object", async () => {
@@ -115,6 +125,7 @@ describe("CancelJobs System tests", () => {
             expect(response?.status).toEqual("0");
             response = await CancelJobs.cancelJobCommon(REAL_SESSION, {jobname: job.jobname, jobid: job.jobid, version: "2.0"});
             expect(response?.status).toEqual("156");
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
     });
 
@@ -177,24 +188,27 @@ describe("CancelJobs System tests - encoded", () => {
     beforeAll(async () => {
         testEnvironment = await TestEnvironment.setUp({
             testName: "zos_cancel_jobs_encoded"
-        });
+            }, REAL_SESSION = await TestEnvironment.createSession());
         systemProps = testEnvironment.systemTestProperties;
 
-        REAL_SESSION = TestEnvironment.createZosmfSession(testEnvironment);
-
         const ACCOUNT = systemProps.tso.account;
         const maxStepNum = 6;  // Use lots of steps to make the job stay in INPUT status longer
 
         sleepJCL = JobTestsUtils.getSleepJCL(REAL_SESSION.ISession.user, ACCOUNT, systemProps.zosjobs.jobclass, maxStepNum, true);
     });
 
+    afterAll(async () => {
+        await TestEnvironment.cleanUp(testEnvironment);
+    });
+
     describe("Positive tests", () => {
         it("should be able to cancel a job using cancelJob (modify version default)", async () => {
             const job = await SubmitJobs.submitJclNotifyCommon(REAL_SESSION, {jcl: sleepJCL, status: "INPUT"});
             expect(job.retcode).toBeNull(); // job is not complete, no CC
             const response = await CancelJobs.cancelJob(REAL_SESSION, job.jobname, job.jobid);
             expect(response).not.toBeUndefined();
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobForJob (modify version default)", async () => {
@@ -203,13 +217,15 @@ describe("CancelJobs System tests - encoded", () => {
             const response = await CancelJobs.cancelJobForJob(REAL_SESSION, job);
             expect(response).not.toBeUndefined();
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobCommon (job version default)", async () => {
             const job = await SubmitJobs.submitJclNotifyCommon(REAL_SESSION, {jcl: sleepJCL, status: "INPUT"});
             expect(job.retcode).toBeNull(); // job is not complete, no CC
             const response = await CancelJobs.cancelJobCommon(REAL_SESSION, {jobname: job.jobname, jobid: job.jobid});
             expect(response?.status).toEqual("0"); // intermittent failure
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
 
         it("should be able to cancel a job using cancelJobCommon (job version 2.0 - synchronous) and return an error feedback object", async () => {
@@ -219,6 +235,7 @@ describe("CancelJobs System tests - encoded", () => {
             expect(response?.status).toEqual("0");
             response = await CancelJobs.cancelJobCommon(REAL_SESSION, {jobname: job.jobname, jobid: job.jobid, version: "2.0"});
             expect(response?.status).toEqual("156");
+            testEnvironment.resources.jobs.push(job);
         }, LONG_TIMEOUT);
     });
 });