fix: sort persistence overriding sort direction (#4048)

JWaters02 · JillieBeanSim · web-flow · commit 76b0d8e9cb29 · 2026-02-25T08:31:55.000-05:00
* fix: sort persistence overriding sort direction

Signed-off-by: JWaters02 &lt;watersjoshua2002@gmail.com&gt;

* chore: changelog

Signed-off-by: JWaters02 &lt;watersjoshua2002@gmail.com&gt;

* tests: fix that one test had incorrect assertion

Signed-off-by: JWaters02 &lt;watersjoshua2002@gmail.com&gt;

* fix: tree not updating on sort change

Signed-off-by: JWaters02 &lt;watersjoshua2002@gmail.com&gt;

---------

Signed-off-by: JWaters02 &lt;watersjoshua2002@gmail.com&gt;
Signed-off-by: Joshua Waters &lt;watersjoshua2002@gmail.com&gt;
Co-authored-by: Billie Simmons &lt;BillieJean.Simmons@ibm.com&gt;
diff --git a/packages/zowe-explorer/CHANGELOG.md b/packages/zowe-explorer/CHANGELOG.md
@@ -20,6 +20,7 @@ All notable changes to the "vscode-extension-for-zowe" extension will be documen
 - Fixed an issue where an error appeared when moving an empty PDS across LPARs. [#4001](https://github.com/zowe/zowe-explorer-vscode/pull/4001)
 - Fixed an issue where logical record length truncation detection failed for extenders. [#4002](https://github.com/zowe/zowe-explorer-vscode/pull/4002)
 - Fixed an issue with the "Create New Data Set" feature where a data set attribute's original value was deleted after the user dismissed the input box. Now, the attribute's value is preserved when the user cancels their input. [#4003](https://github.com/zowe/zowe-explorer-vscode/issues/4003)
+- Fixed an issue where the data set sort persistence was overriding the selected sort direction. [#4048](https://github.com/zowe/zowe-explorer-vscode/pull/4048)
 - Updated Zowe SDKs to `8.30.1` for technical currency. [#4079](https://github.com/zowe/zowe-explorer-vscode/pull/4079)
 
 ## `3.4.0`
diff --git a/packages/zowe-explorer/__tests__/__unit__/trees/dataset/DatasetTree.unit.test.ts b/packages/zowe-explorer/__tests__/__unit__/trees/dataset/DatasetTree.unit.test.ts
@@ -4253,6 +4253,8 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
             const mocks = getBlockMocks();
             const nodes = nodesForSuite();
 
+            nodes.pds.sort = undefined;
+
             const persistedSort = {
                 method: Sorting.DatasetSortOpts.DateCreated,
                 direction: Sorting.SortDirection.Descending,
@@ -4264,8 +4266,8 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
 
             expect(mocks.nodeDataChanged).toHaveBeenCalled();
             expect(mocks.refreshElement).not.toHaveBeenCalled();
-            expect(nodes.pds.sort?.method).toBe(Sorting.DatasetSortOpts.Name);
-            expect(nodes.pds.sort?.direction).toBe(Sorting.SortDirection.Descending);
+            expect((nodes.pds.sort as any)?.method).toBe(Sorting.DatasetSortOpts.Name);
+            expect((nodes.pds.sort as any)?.direction).toBe(Sorting.SortDirection.Descending);
         });
 
         it("falls back to default sort options when no persistence available", async () => {
@@ -4281,8 +4283,8 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
 
             expect(mocks.nodeDataChanged).toHaveBeenCalled();
             expect(mocks.refreshElement).not.toHaveBeenCalled();
-            expect(nodes.pds.sort?.method).toBe(Sorting.DatasetSortOpts.DateCreated);
-            expect(nodes.pds.sort?.direction).toBe(Sorting.SortDirection.Ascending);
+            expect((nodes.pds.sort as any)?.method).toBe(Sorting.DatasetSortOpts.DateCreated);
+            expect((nodes.pds.sort as any)?.direction).toBe(Sorting.SortDirection.Ascending);
         });
 
         it("saves sort settings to persistence after sorting", async () => {
@@ -4347,6 +4349,8 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
             const mocks = getBlockMocks();
             const nodes = nodesForSuite();
 
+            nodes.session.sort = undefined;
+
             const persistedSessionSort = {
                 method: Sorting.DatasetSortOpts.LastModified,
                 direction: Sorting.SortDirection.Descending,
@@ -4358,8 +4362,8 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
 
             expect(mocks.nodeDataChanged).toHaveBeenCalled();
             expect(mocks.refreshElement).not.toHaveBeenCalled();
-            expect(nodes.session.sort?.method).toBe(Sorting.DatasetSortOpts.UserId);
-            expect(nodes.session.sort?.direction).toBe(Sorting.SortDirection.Descending);
+            expect((nodes.session.sort as any)?.method).toBe(Sorting.DatasetSortOpts.UserId);
+            expect((nodes.session.sort as any)?.direction).toBe(Sorting.SortDirection.Descending);
         });
 
         it("does not interfere with sort when getSortSetting returns undefined", async () => {
@@ -4413,8 +4417,8 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
             mocks.showQuickPick.mockResolvedValueOnce({ label: "$(account) User ID" });
             await tree.sortPdsMembersDialog(nodes.pds);
 
-            expect(nodes.pds.sort?.method).toBe(Sorting.DatasetSortOpts.UserId);
-            expect(nodes.pds.sort?.direction).toBe(Sorting.SortDirection.Descending);
+            expect((nodes.pds.sort as any)?.method).toBe(Sorting.DatasetSortOpts.UserId);
+            expect((nodes.pds.sort as any)?.direction).toBe(Sorting.SortDirection.Descending);
             expect(mocks.nodeDataChanged).toHaveBeenCalled();
         });
 
@@ -4487,6 +4491,67 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
 
             expect(favPdsNode.children?.map((c: IZoweDatasetTreeNode) => c.label)).toStrictEqual(["C", "B", "A"]);
         });
+
+        it("allows changing sort direction when node already has sort set and persistence exists", async () => {
+            const mocks = getBlockMocks();
+            const nodes = nodesForSuite();
+
+            nodes.pds.sort = {
+                method: Sorting.DatasetSortOpts.Name,
+                direction: Sorting.SortDirection.Descending,
+            };
+
+            const persistedSort = {
+                method: Sorting.DatasetSortOpts.Name,
+                direction: Sorting.SortDirection.Descending,
+            };
+            const getSortSettingSpy = jest.spyOn(DatasetTree.prototype, "getSortSetting").mockReturnValue(persistedSort);
+
+            mocks.showQuickPick.mockResolvedValueOnce({ label: "$(fold) Sort Direction" });
+            mocks.showQuickPick.mockResolvedValueOnce("Ascending");
+            mocks.showQuickPick.mockResolvedValueOnce({ label: "$(case-sensitive) Name" });
+
+            await tree.sortPdsMembersDialog(nodes.pds);
+
+            expect(nodes.pds.sort?.direction).toBe(Sorting.SortDirection.Ascending);
+            expect(nodes.pds.sort?.method).toBe(Sorting.DatasetSortOpts.Name);
+            expect(mocks.nodeDataChanged).toHaveBeenCalled();
+
+            getSortSettingSpy.mockRestore();
+        });
+
+        it("does not let persistence override sort direction changes by user", async () => {
+            const mocks = getBlockMocks();
+            const nodes = nodesForSuite();
+
+            nodes.pds.sort = {
+                method: Sorting.DatasetSortOpts.Name,
+                direction: Sorting.SortDirection.Ascending,
+            };
+
+            const persistedSort = {
+                method: Sorting.DatasetSortOpts.Name,
+                direction: Sorting.SortDirection.Ascending,
+            };
+            jest.spyOn(DatasetTree.prototype, "getSortSetting").mockReturnValue(persistedSort);
+            const addSortSettingSpy = jest.spyOn(DatasetTree.prototype, "addSortSetting");
+
+            mocks.showQuickPick.mockResolvedValueOnce({ label: "$(fold) Sort Direction" });
+            mocks.showQuickPick.mockResolvedValueOnce("Descending");
+            mocks.showQuickPick.mockResolvedValueOnce({ label: "$(case-sensitive) Name" });
+
+            await tree.sortPdsMembersDialog(nodes.pds);
+
+            expect(nodes.pds.sort?.direction).toBe(Sorting.SortDirection.Descending);
+
+            expect(addSortSettingSpy).toHaveBeenCalledWith(
+                nodes.pds,
+                expect.objectContaining({
+                    method: Sorting.DatasetSortOpts.Name,
+                    direction: Sorting.SortDirection.Descending,
+                })
+            );
+        });
     });
 
     describe("filterBy & filterPdsMembersDialog", () => {
diff --git a/packages/zowe-explorer/src/trees/dataset/DatasetTree.ts b/packages/zowe-explorer/src/trees/dataset/DatasetTree.ts
@@ -1795,9 +1795,12 @@ Would you like to do this now?`,
             SharedUtils.getDefaultSortOptions(DatasetUtils.DATASET_SORT_OPTS, Constants.SETTINGS_DS_DEFAULT_SORT, Sorting.DatasetSortOpts);
 
         // Override the default sort method if the node already has sort setting in persistence
-        const sortSetting = this.getSortSetting(node);
-        if (sortSetting) {
-            sortOpts = sortSetting;
+        // But only do this if the user hasn't already selected a sort method for this node in the current session
+        if (node.sort == null) {
+            const sortSetting = this.getSortSetting(node);
+            if (sortSetting) {
+                sortOpts = sortSetting;
+            }
         }
 
         // Adapt menus to user based on the node that was interacted with
diff --git a/packages/zowe-explorer/src/trees/dataset/ZoweDatasetNode.ts b/packages/zowe-explorer/src/trees/dataset/ZoweDatasetNode.ts
@@ -470,8 +470,8 @@ export class ZoweDatasetNode extends ZoweTreeNode implements IZoweDatasetTreeNod
                 .filter((label) => this.children.find((c) => (c.label as string) === label) == null)
                 .map((label) => elementChildren[label]);
 
-            // Determine sort options: persistence > node > session
-            const sortOpts = this.persistence.getSortSetting(this) ?? this.sort ?? this.getSessionNode().sort;
+            // Determine sort options: node > persistence > session
+            const sortOpts = this.sort ?? this.persistence.getSortSetting(this) ?? this.getSessionNode().sort;
 
             // use the PDS filter if one is set, otherwise try using the session filter
             const sessionFilter = SharedContext.isSession(this) ? this.filter : this.getSessionNode().filter;
