copy pds into new target data set enhancement

packages/zosfiles/CHANGELOG.md

@@ -2,8 +2,11 @@
 
 All notable changes to the Zowe z/OS files SDK package will be documented in this file.
 
-## `8.10.3`
 
+## Recent Changes
+- Enhancement: The `Copy.dataset` method now creates a new data set if the inputted target data set does not exist. [#2386](https://github.com/zowe/zowe-cli/pull/2386)
+
+## `8.10.3`
 - BugFix: The `Copy.dataset` method no longer copies all partitioned data set members if a member is passed to the function. [#2402](https://github.com/zowe/zowe-cli/pull/2402)
 
 ## `8.10.0`

packages/zosfiles/__tests__/__system__/methods/copy/Copy.system.test.ts

@@ -61,6 +61,14 @@ describe("Copy", () => {
             }
         });
         describe("Success Scenarios", () => {
+            afterEach(async () => {
+                try {
+                    await Delete.dataSet(REAL_SESSION, fromDataSetName);
+                    await Delete.dataSet(REAL_SESSION, toDataSetName);
+                } catch (err) {
+                    Imperative.console.info(`Error: ${inspect(err)}`);
+                }
+            });
             describe("Sequential > Sequential", () => {
                 beforeEach(async () => {
                     try {

packages/zosfiles/__tests__/__unit__/methods/copy/Copy.unit.test.ts

@@ -35,14 +35,17 @@ describe("Copy", () => {
         const toDataSetName = "USER.DATA.TO";
         const toMemberName = "mem2";
         const isPDSSpy = jest.spyOn(Copy as any, "isPDS");
+        let dataSetExistsSpy: jest.SpyInstance;
 
         beforeEach(() => {
             copyPDSSpy.mockClear();
             copyExpectStringSpy.mockClear().mockImplementation(async () => { return ""; });
             isPDSSpy.mockClear().mockResolvedValue(false);
+            dataSetExistsSpy = jest.spyOn(Copy, "dataSetExists").mockResolvedValue(true);
         });
         afterAll(() => {
             isPDSSpy.mockRestore();
+            dataSetExistsSpy.mockRestore();
         });
         describe("Success Scenarios", () => {
             describe("Sequential > Sequential", () => {
@@ -456,13 +459,24 @@ describe("Copy", () => {
                 });
             });
             describe("Partitioned > Partitioned", () => {
+                let createSpy: jest.SpyInstance;
+                let dataSetExistsSpy: jest.SpyInstance;
                 beforeEach(() => {
                     isPDSSpy.mockClear().mockResolvedValue(true);
                     copyPDSSpy.mockClear().mockResolvedValue({success: true, commandResponse: ZosFilesMessages.datasetCopiedSuccessfully.message});
+                    createSpy = jest.spyOn(Create, "dataSetLike").mockResolvedValue({
+                        success: true,
+                        commandResponse: ZosFilesMessages.dataSetCreatedSuccessfully.message
+                    });
+                    dataSetExistsSpy = jest.spyOn(Copy, "dataSetExists");
                 });
                 afterAll(() => {
                     copyPDSSpy.mockRestore();
                 });
+                afterEach(() => {
+                    createSpy.mockRestore();
+                    dataSetExistsSpy.mockRestore();
+                });
                 it("should call copyPDS to copy members of source PDS to target PDS", async () => {
                     const response = await Copy.dataSet(
                         dummySession,
@@ -471,11 +485,12 @@ describe("Copy", () => {
                             dsn:fromDataSetName
                         }}
                     );
+                    const newDataSet = false;
                     expect(isPDSSpy).toHaveBeenNthCalledWith(1, dummySession, fromDataSetName);
                     expect(isPDSSpy).toHaveBeenNthCalledWith(2, dummySession, toDataSetName);
 
                     expect(copyPDSSpy).toHaveBeenCalledTimes(1);
-                    expect(copyPDSSpy).toHaveBeenCalledWith(dummySession, fromDataSetName, toDataSetName);
+                    expect(copyPDSSpy).toHaveBeenCalledWith(dummySession, fromDataSetName, toDataSetName, newDataSet);
 
                     expect(response).toEqual({
                         success: true,
@@ -524,6 +539,36 @@ describe("Copy", () => {
                         expectedPayload
                     );
                 });
+                it("should call Create.dataSetLike and create a new data set if the target data set inputted does not exist", async() => {
+                    dataSetExistsSpy.mockResolvedValue(false);
+                    const response = await Copy.dataSet(
+                        dummySession,
+                        {dsn: toDataSetName},
+                        {"from-dataset": {
+                            dsn:fromDataSetName
+                        }}
+                    );
+                    expect(createSpy).toHaveBeenCalled();
+                    expect(response).toEqual({
+                        success: true,
+                        commandResponse: ZosFilesMessages.datasetCopiedSuccessfully.message
+                    });
+                });
+                it("should not create a new data set if the target data set inputted exists", async() => {
+                    dataSetExistsSpy.mockResolvedValue(true);
+                    const response = await Copy.dataSet(
+                        dummySession,
+                        {dsn: toDataSetName},
+                        {"from-dataset": {
+                            dsn:fromDataSetName
+                        }}
+                    );
+                    expect(createSpy).not.toHaveBeenCalled();
+                    expect(response).toEqual({
+                        success: true,
+                        commandResponse: ZosFilesMessages.datasetCopiedSuccessfully.message
+                    });
+                });
             });
         });
         describe("Failure Scenarios", () => {
@@ -662,7 +707,47 @@ describe("Copy", () => {
             expect(response).toEqual(false);
             expect(listDatasetSpy).toHaveBeenCalledWith(dummySession, dsPS.dsname, { attributes: true });
         });
+        it("should return true if the data set exists", async () => {
+            let caughtError;
+            let response;
+            listDatasetSpy.mockImplementation(async (): Promise<any>  => {
+                return {
+                    apiResponse: {
+                        returnedRows: 1,
+                        items: [dsPO]
+                    }
+                };
+            });
+            try {
+                response = await Copy.dataSetExists(dummySession, dsPO.dsname);
+            }
+            catch(e) {
+                caughtError = e;
+            }
+            expect(response).toEqual(true);
+            expect(listDatasetSpy).toHaveBeenCalledWith(dummySession, dsPO.dsname, { attributes: true , start: dsPO.dsname});
+        });
 
+        it("should return false if the data set does not exist", async () => {
+            let caughtError;
+            let response;
+            listDatasetSpy.mockImplementation(async (): Promise<any>  => {
+                return {
+                    apiResponse: {
+                        returnedRows: 0,
+                        items: []
+                    }
+                };
+            });
+            try {
+                response = await Copy.dataSetExists(dummySession, dsPO.dsname);
+            }
+            catch(e) {
+                caughtError = e;
+            }
+            expect(response).toEqual(false);
+            expect(listDatasetSpy).toHaveBeenCalledWith(dummySession, dsPO.dsname, { attributes: true , start: dsPO.dsname});
+        });
         it("should successfully copy members from source to target PDS", async () => {
             let caughtError;
             let response;
@@ -675,7 +760,7 @@ describe("Copy", () => {
                 }
             };
             const fileList = ["mem1", "mem2"];
-
+            const newDataSet = false;
             listAllMembersSpy.mockImplementation(async (): Promise<any>  => sourceResponse);
             downloadAllMembersSpy.mockImplementation(async (): Promise<any> => undefined);
             fileListPathSpy.mockReturnValue(fileList);
@@ -686,7 +771,7 @@ describe("Copy", () => {
 
 
             try{
-                response = await Copy.copyPDS(dummySession, fromDataSetName, toDataSetName);
+                response = await Copy.copyPDS(dummySession, fromDataSetName, toDataSetName, newDataSet);
             }
             catch(e) {
                 caughtError = e;

packages/zosfiles/__tests__/__unit__/utils/__snapshots__/ZosFilesUtils.unit.test.ts.snap

@@ -269,6 +269,9 @@ Destination: %s",
   "missingZfsOption": Object {
     "message": "To create a z/OS file system, the following option must be supplied: ",
   },
+  "newDataSetCreated": Object {
+    "message": "New data set created",
+  },
   "noDataSetsInList": Object {
     "message": "No data sets left after excluded pattern(s) were filtered out.",
   },

packages/zosfiles/src/constants/ZosFiles.messages.ts

@@ -135,6 +135,14 @@ export const ZosFilesMessages: { [key: string]: IMessageDefinition } = {
         message: "Specify the input directory path."
     },
 
+    /**
+     * Message indicating that a new target data set was created and copied into
+     * @type {IMessageDefinition}
+     */
+    newDataSetCreated: {
+        message: "New data set created"
+    },
+
     /**
      * Message indicating that the data set was created successfully
      * @type {IMessageDefinition}

packages/zosfiles/src/methods/copy/Copy.ts

@@ -57,14 +57,20 @@
         ImperativeExpect.toBeDefinedAndNonBlank(options["from-dataset"].dsn, "fromDataSetName");
         ImperativeExpect.toBeDefinedAndNonBlank(toDataSetName, "toDataSetName");
 
+        const targetDataSetExists = await this.dataSetExists(session, toDataSetName);
+
+        let newDataSet = false;
+        if(!targetDataSetExists) {
+            newDataSet = true;
+            await Create.dataSetLike(session, toDataSetName, options["from-dataset"].dsn);
+        }
         if(!toMemberName && !options["from-dataset"].member) {
             const sourceIsPds = await this.isPDS(session, options["from-dataset"].dsn);
             const targetIsPds = await this.isPDS(session, toDataSetName);
             if (sourceIsPds && targetIsPds) {
-                return await this.copyPDS(session, options["from-dataset"].dsn, toDataSetName);
+                return await this.copyPDS(session, options["from-dataset"].dsn, toDataSetName, newDataSet);
             }
         }
-
         const endpoint: string = posix.join(
             ZosFilesConstants.RESOURCE,
             ZosFilesConstants.RES_DS_FILES,
@@ -106,7 +112,7 @@
     }
 
     /**
-     * Private function that checks if a dataset is type PDS
+     * Function that checks if a dataset is type PDS
     **/
     public static async isPDS(
         session: AbstractSession,
@@ -123,6 +129,22 @@
         }
     }
 
+    /**
+     * Function that checks if the data set exists
+    **/
+    public static async dataSetExists(
+        session: AbstractSession,
+        dataSetName: string
+    ): Promise<boolean> {
+        let dsnameIndex;
+        const dataSetList = await List.dataSet(session, dataSetName, {attributes: true, start: dataSetName});
+        if(dataSetList.apiResponse != null && dataSetList.apiResponse.returnedRows != null && dataSetList.apiResponse.items != null) {
+            dsnameIndex = dataSetList.apiResponse.returnedRows === 0 ? -1 :
+                dataSetList.apiResponse.items.findIndex((ds: any) => ds.dsname.toUpperCase() === dataSetName.toUpperCase());
+        }
+        return dsnameIndex !== -1;
+    }
+
     /**
      * Copy the members of a Partitioned dataset into another Partitioned dataset
      *
@@ -139,10 +161,7 @@
      */
 
     public static async copyPDS (
-        session: AbstractSession,
-        fromPds: string,
-        toPds: string
-    ): Promise<IZosFilesResponse> {
+        session: AbstractSession, fromPds: string, toPds: string, newDataSet: boolean): Promise<IZosFilesResponse> {
         try {
             const sourceResponse = await List.allMembers(session, fromPds);
             const sourceMemberList: Array<{ member: string }> = sourceResponse.apiResponse.items;
@@ -166,7 +185,9 @@
             fs.rmSync(downloadDir, {recursive: true});
             return {
                 success:true,
-                commandResponse: ZosFilesMessages.datasetCopiedSuccessfully.message
+                commandResponse: newDataSet
+                    ? ZosFilesMessages.newDataSetCreated.message + ` - "${toPds}"`
+                    : ZosFilesMessages.datasetCopiedSuccessfully.message
             };
         }
         catch (error) {