tests: DataSet FSP cases; refactor FileNotFound error

Signed-off-by: Trae Yelovich <trae.yelovich@broadcom.com>
zowe · Aug 8, 2024 · e4ec266 · e4ec266
1 parent e924c9e
commit e4ec266
Show file tree

Hide file tree

Showing 5 changed files with 111 additions and 16 deletions.
diff --git a/packages/zowe-explorer/__tests__/__mocks__/vscode.ts b/packages/zowe-explorer/__tests__/__mocks__/vscode.ts
@@ -1095,7 +1095,9 @@ export class FileSystemError extends Error {
      * @param messageOrUri Message or uri.
      */
     static FileNotFound(messageOrUri?: string | Uri): FileSystemError {
-        return new FileSystemError("file not found");
+        const fse = new FileSystemError();
+        fse.code = "FileNotFound";
+        return fse;
     }
 
     /**
@@ -1155,7 +1157,7 @@ export class FileSystemError extends Error {
      * Possible values are names of errors, like {@linkcode FileSystemError.FileNotFound FileNotFound},
      * or `Unknown` for unspecified errors.
      */
-    readonly code: string;
+    code: string;
 }
 
 /**

diff --git a/packages/zowe-explorer/__tests__/__unit__/trees/dataset/DatasetFSProvider.unit.test.ts b/packages/zowe-explorer/__tests__/__unit__/trees/dataset/DatasetFSProvider.unit.test.ts
@@ -283,7 +283,14 @@ describe("readFile", () => {
             .spyOn(DatasetFSProvider.instance as any, "_lookupAsFile")
             .mockReturnValueOnce({ ...testEntries.ps, metadata: { profile: null } });
 
-        await expect(DatasetFSProvider.instance.readFile(testUris.ps)).rejects.toThrow("file not found");
+        let err;
+        try {
+            await DatasetFSProvider.instance.readFile(testUris.ps);
+        } catch (error) {
+            err = error;
+            expect(err.code).toBe("FileNotFound");
+        }
+        expect(err).toBeDefined();
         expect(_lookupAsFileMock).toHaveBeenCalledWith(testUris.ps);
         _lookupAsFileMock.mockRestore();
     });
@@ -490,9 +497,14 @@ describe("writeFile", () => {
             entries: new Map(),
         };
         const lookupParentDirMock = jest.spyOn(DatasetFSProvider.instance as any, "_lookupParentDirectory").mockReturnValueOnce(session);
-        await expect(DatasetFSProvider.instance.writeFile(testUris.ps, new Uint8Array([]), { create: false, overwrite: true })).rejects.toThrow(
-            "file not found"
-        );
+        let err;
+        try {
+            await DatasetFSProvider.instance.writeFile(testUris.ps, new Uint8Array([]), { create: false, overwrite: true });
+        } catch (error) {
+            err = error;
+            expect(err.code).toBe("FileNotFound");
+        }
+        expect(err).toBeDefined();
         lookupParentDirMock.mockRestore();
     });
 
@@ -595,6 +607,70 @@ describe("stat", () => {
     });
 });
 
+describe("fetchEntriesForDataset", () => {
+    it("calls allMembers to get the PDS members", async () => {
+        const allMembersMock = jest.fn().mockResolvedValue({
+            success: true,
+            apiResponse: {
+                items: ["MEMBER1", "MEMBER2", "MEMBER3"].map((m) => ({ member: m })),
+            },
+            commandResponse: "",
+        });
+        const mvsApiMock = jest.spyOn(ZoweExplorerApiRegister, "getMvsApi").mockReturnValue({
+            allMembers: allMembersMock,
+        } as any);
+        const fakePds = Object.assign(Object.create(Object.getPrototypeOf(testEntries.pds)), testEntries.pds);
+        await (DatasetFSProvider.instance as any).fetchEntriesForDataset(fakePds, testUris.pds, {
+            isRoot: false,
+            slashAfterProfilePos: testUris.pds.path.indexOf("/", 1),
+            profileName: "sestest",
+            profile: testProfile,
+        });
+        expect(allMembersMock).toHaveBeenCalled();
+        mvsApiMock.mockRestore();
+    });
+});
+
+describe("fetchDataset", () => {
+    describe("calls dataSet to verify that the data set exists on the mainframe", () => {
+        it("non-existent URI", async () => {
+            const dataSetMock = jest.fn().mockResolvedValue({
+                success: true,
+                apiResponse: {
+                    items: [{ name: "USER.DATA.PS" }],
+                },
+                commandResponse: "",
+            });
+            const mvsApiMock = jest.spyOn(ZoweExplorerApiRegister, "getMvsApi").mockReturnValue({
+                dataSet: dataSetMock,
+            } as any);
+            await (DatasetFSProvider.instance as any).fetchDataset(testUris.ps, {
+                isRoot: false,
+                slashAfterProfilePos: testUris.pds.path.indexOf("/", 1),
+                profileName: "sestest",
+                profile: testProfile,
+            });
+            expect(dataSetMock).toHaveBeenCalled();
+            mvsApiMock.mockRestore();
+        });
+
+        it("existing URI - PS", async () => {
+            const fakePs = Object.assign(Object.create(Object.getPrototypeOf(testEntries.ps)), testEntries.ps);
+            const lookupMock = jest.spyOn(DatasetFSProvider.instance, "lookup").mockReturnValue(fakePs);
+            const writeFileSpy = jest.spyOn(DatasetFSProvider.instance as any, "writeFile");
+            await (DatasetFSProvider.instance as any).fetchDataset(testUris.ps, {
+                isRoot: false,
+                slashAfterProfilePos: testUris.ps.path.indexOf("/", 1),
+                profileName: "sestest",
+                profile: testProfile,
+            });
+            expect(writeFileSpy).not.toHaveBeenCalled();
+            lookupMock.mockRestore();
+            writeFileSpy.mockRestore();
+        });
+    });
+});
+
 describe("delete", () => {
     it("successfully deletes a PS entry", async () => {
         const fakePs = { ...testEntries.ps };

diff --git a/packages/zowe-explorer/__tests__/__unit__/trees/job/JobFSProvider.unit.test.ts b/packages/zowe-explorer/__tests__/__unit__/trees/job/JobFSProvider.unit.test.ts
@@ -39,7 +39,7 @@ const testEntries = {
         ...new SpoolEntry("JES2.JESMSGLG.2"),
         data: new Uint8Array([1, 2, 3]),
         metadata: {
-            profile: testProfile,
+            profile: testProfile
             path: "/TESTJOB(JOB1234) - ACTIVE/JES2.JESMSGLG.2",
         },
         spool: {
@@ -275,9 +275,14 @@ describe("writeFile", () => {
     });
 
     it("throws an error if entry doesn't exist and 'create' option is false", () => {
-        expect(() => JobFSProvider.instance.writeFile(testUris.spool, new Uint8Array([]), { create: false, overwrite: true })).toThrow(
-            "file not found"
-        );
+        let err;
+        try {
+            JobFSProvider.instance.writeFile(testUris.spool, new Uint8Array([]), { create: false, overwrite: true });
+        } catch (error) {
+            err = error;
+            expect(err.code).toBe("FileNotFound");
+        }
+        expect(err).toBeDefined();
     });
 
     it("throws an error if the entry exists, 'create' opt is true and 'overwrite' opt is false", () => {

diff --git a/packages/zowe-explorer/__tests__/__unit__/trees/uss/UssFSProvider.unit.test.ts b/packages/zowe-explorer/__tests__/__unit__/trees/uss/UssFSProvider.unit.test.ts
@@ -387,7 +387,14 @@ describe("readFile", () => {
             path: "/aFile.txt",
         });
 
-        await expect(UssFSProvider.instance.readFile(testUris.file)).rejects.toThrow("file not found");
+        let err;
+        try {
+            await UssFSProvider.instance.readFile(testUris.file);
+        } catch (error) {
+            err = error;
+            expect(err.code).toBe("FileNotFound");
+        }
+        expect(err).toBeDefined();
     });
 
     it("returns data for a file", async () => {
@@ -581,9 +588,14 @@ describe("writeFile", () => {
     });
 
     it("throws an error if entry doesn't exist and 'create' option is false", async () => {
-        await expect(UssFSProvider.instance.writeFile(testUris.file, new Uint8Array([]), { create: false, overwrite: true })).rejects.toThrow(
-            "file not found"
-        );
+        let err;
+        try {
+            await UssFSProvider.instance.writeFile(testUris.file, new Uint8Array([]), { create: false, overwrite: true });            
+        } catch (error) {
+            err = error;
+            expect(err.code).toBe("FileNotFound");
+        }
+        expect(err).toBeDefined();
     });
 
     it("throws an error if entry exists and 'overwrite' option is false", async () => {

diff --git a/packages/zowe-explorer/src/trees/dataset/DatasetFSProvider.ts b/packages/zowe-explorer/src/trees/dataset/DatasetFSProvider.ts
@@ -203,7 +203,7 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
     private async fetchDataset(uri: vscode.Uri, uriInfo: UriFsInfo): Promise<PdsEntry | DsEntry> {
         let entry: PdsEntry | DsEntry;
         try {
-            entry = this._lookupAsDirectory(uri, false) as PdsEntry;
+            entry = this.lookup(uri, false) as PdsEntry | DsEntry;
         } catch (err) {
             if (!(err instanceof vscode.FileSystemError)) {
                 throw err;
@@ -215,7 +215,7 @@ export class DatasetFSProvider extends BaseProvider implements vscode.FileSystem
         }
 
         const entryExists = entry != null;
-        let entryIsDir = false;
+        let entryIsDir = entry != null ? entry.type === vscode.FileType.Directory : false;
         if (!entryExists) {
             const resp = await ZoweExplorerApiRegister.getMvsApi(uriInfo.profile).dataSet(path.posix.basename(uri.path), { attributes: true });
             if (resp.success) {