fix(ds/sort): Fallback to sorting by name when values are equal

packages/zowe-explorer/__tests__/__unit__/dataset/DatasetTree.unit.test.ts

@@ -15,7 +15,15 @@ import * as fs from "fs";
 import * as zowe from "@zowe/cli";
 import { DatasetTree } from "../../../src/dataset/DatasetTree";
 import { ZoweDatasetNode } from "../../../src/dataset/ZoweDatasetNode";
-import { DatasetFilterOpts, Gui, IZoweDatasetTreeNode, ProfilesCache, ValidProfileEnum } from "@zowe/zowe-explorer-api";
+import {
+    DatasetFilterOpts,
+    DatasetSortOpts,
+    Gui,
+    IZoweDatasetTreeNode,
+    ProfilesCache,
+    SortDirection,
+    ValidProfileEnum,
+} from "@zowe/zowe-explorer-api";
 import { ZoweExplorerApiRegister } from "../../../src/ZoweExplorerApiRegister";
 import { Profiles } from "../../../src/Profiles";
 import * as utils from "../../../src/utils/ProfilesUtils";
@@ -2716,6 +2724,10 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
         const nodeC = new ZoweDatasetNode("C", vscode.TreeItemCollapsibleState.Collapsed, pds, createISession());
         nodeC.stats = { user: "someUser", modifiedDate: new Date("2022-03-15T16:30:00") };
         pds.children = [nodeA, nodeB, nodeC];
+        pds.sort = {
+            method: DatasetSortOpts.Name,
+            direction: SortDirection.Ascending,
+        };
         session.children = [pds];
 
         return {
@@ -2785,6 +2797,22 @@ describe("Dataset Tree Unit Tests - Sorting and Filtering operations", () => {
             expect(nodes.pds.children?.map((c: IZoweDatasetTreeNode) => c.label)).toStrictEqual(["B", "C", "A"]);
         });
 
+        it("sorts by last modified date: handling 2 nodes with same date", async () => {
+            const mocks = getBlockMocks();
+            const nodes = nodesForSuite();
+            mocks.showQuickPick.mockResolvedValueOnce({ label: "$(fold) Sort Direction" });
+            mocks.showQuickPick.mockResolvedValueOnce({ label: "Descending" });
+            mocks.showQuickPick.mockResolvedValueOnce({ label: "$(calendar) Date Modified" });
+            // insert node with same date modified
+            const nodeD = new ZoweDatasetNode("D", vscode.TreeItemCollapsibleState.Collapsed, nodes.pds, createISession());
+            nodeD.stats = { user: "someUser", modifiedDate: new Date("2022-03-15T16:30:00") };
+            nodes.pds.children = [...(nodes.pds.children ?? []), nodeD];
+            await tree.sortPdsMembersDialog(nodes.pds);
+            expect(mocks.nodeDataChanged).toHaveBeenCalled();
+            expect(mocks.refreshElement).not.toHaveBeenCalled();
+            expect(nodes.pds.children?.map((c: IZoweDatasetTreeNode) => c.label)).toStrictEqual(["A", "D", "C", "B"]);
+        });
+
         it("sorts by user ID", async () => {
             const mocks = getBlockMocks();
             const nodes = nodesForSuite();

packages/zowe-explorer/src/dataset/ZoweDatasetNode.ts

@@ -123,7 +123,7 @@
      *
      * @returns {Promise<ZoweDatasetNode[]>}
      */
     public async getChildren(): Promise<ZoweDatasetNode[]> {
         ZoweLogger.trace("ZoweDatasetNode.getChildren called.");
         if (!this.pattern && contextually.isSessionNotFav(this)) {
             return [
@@ -332,22 +332,38 @@
             const sortLessThan = sort.direction == SortDirection.Ascending ? -1 : 1;
             const sortGreaterThan = sortLessThan * -1;
 
+            const sortByName = (nodeA: IZoweDatasetTreeNode, nodeB: IZoweDatasetTreeNode): number =>
+                (nodeA.label as string) < (nodeB.label as string) ? sortLessThan : sortGreaterThan;
+
             if (!a.stats && !b.stats) {
-                return (a.label as string) < (b.label as string) ? sortLessThan : sortGreaterThan;
+                return sortByName(a, b);
             }
 
-            switch (sort.method) {
-                case DatasetSortOpts.LastModified:
-                    a.description = dayjs(a.stats?.modifiedDate).format("YYYY/MM/DD HH:mm:ss");
-                    b.description = dayjs(b.stats?.modifiedDate).format("YYYY/MM/DD HH:mm:ss");
-                    return a.stats?.modifiedDate < b.stats?.modifiedDate ? sortLessThan : sortGreaterThan;
-                case DatasetSortOpts.UserId:
-                    a.description = a.stats?.user;
-                    b.description = b.stats?.user;
-                    return a.stats?.user < b.stats?.user ? sortLessThan : sortGreaterThan;
-                case DatasetSortOpts.Name:
-                    return (a.label as string) < (b.label as string) ? sortLessThan : sortGreaterThan;
+            if (sort.method === DatasetSortOpts.LastModified) {
+                const dateA = dayjs(a.stats?.modifiedDate);
+                const dateB = dayjs(b.stats?.modifiedDate);
+
+                a.description = dateA.format("YYYY/MM/DD HH:mm:ss");
+                b.description = dateB.format("YYYY/MM/DD HH:mm:ss");
+
+                // for dates that are equal down to the second, fallback to sorting by name
+                if (dateA.isSame(dateB, "second")) {
+                    return sortByName(a, b);
+                }
+
+                return dateA.isBefore(dateB, "second") ? sortLessThan : sortGreaterThan;
+            } else if (sort.method === DatasetSortOpts.UserId) {
+                a.description = a.stats?.user;
+                b.description = b.stats?.user;
+
+                if (a.stats?.user === b.stats?.user) {
+                    return sortByName(a, b);
+                }
+
+                return a.stats?.user < b.stats?.user ? sortLessThan : sortGreaterThan;
             }
+
+            return sortByName(a, b);
         };
     }