@rancher/shell 3.0.5-rc.3 → 3.0.5-rc.6

package/types/store/dashboard-store.types.ts

@@ -1,4 +1,5 @@
-import { PaginationArgs } from '@shell/types/store/pagination.types';
+import { KubeLabelSelector } from '@shell/types/kube/kube-api';
+import { PaginationArgs, StorePagination } from '@shell/types/store/pagination.types';
 
 /**
  * Properties on all findX actions
@@ -47,6 +48,11 @@ export interface ActionFindAllArgs extends ActionCoreFindArgs {
   depaginate?: boolean,
 }
 
+export interface ActionFindPageTransientResult<T> {
+  pagination: StorePagination,
+  data: T[],
+}
+
 /**
  * Args used for findPage action
  */
@@ -62,8 +68,32 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
    */
   namespaced?: string,
   /**
-   * Result of request is transient and not persisted to store
+   * Watch for changes
+   *
+   * false = no, all other values = yes
+   */
+  watch?: boolean,
+  /**
+   * Does this request stem from a list with manual refresh?
    */
-  transient?: boolean,
   hasManualRefresh?: boolean,
+  /**
+   * If true don't persist the http response to the store, just pass it back
+   */
+  transient?: boolean,
+}
+
+export type ActionFindPageResponse<T = any> = {
+  data: T[],
+  pagination?: StorePagination
+} | T[];
+
+export interface ActionFindMatchingArgs extends ActionCoreFindArgs {
+  labelSelector: KubeLabelSelector,
+  namespaced?: string,
+  depaginate?: boolean
 }
+
+export type ActionFindMatchingResponse<T = any> = ActionFindPageResponse<T>
+
+export type ActionFindLabelSelectorArgs = ActionFindPageArgs | ActionFindMatchingArgs;

package/types/store/pagination.types.ts

@@ -451,7 +451,12 @@ export interface StorePaginationRequest {
   /**
    * The set of pagination args used to create the request
    */
-  pagination: PaginationArgs
+  pagination: PaginationArgs,
+
+  /**
+   * Does this request stem from a list with manual refresh?
+   */
+  hasManualRefresh?: boolean,
 }
 
 /**

package/types/store/subscribe.types.ts

@@ -0,0 +1,50 @@
+/* eslint-disable no-unused-vars */
+export enum STEVE_WATCH_MODE {
+  DEFAULT = '',
+  RESOURCE_CHANGES = 'resource.changes'
+}
+/* eslint-enable no-unused-vars */
+
+/* eslint-disable no-unused-vars */
+export enum STEVE_WATCH_EVENT {
+  START = 'resource.start',
+  CREATE = 'resource.create',
+  CHANGE = 'resource.change',
+  CHANGES = 'resource.changes',
+  REMOVE = 'resource.resource.remove',
+  ERROR = 'resource.error',
+  STOP = 'resource.stop',
+}
+/* eslint-enable no-unused-vars */
+
+export interface STEVE_WATCH_PARAMS {
+  type: string,
+  selector?: string,
+  id?: string,
+  revision?: string,
+  namespace?: string,
+  stop?: boolean,
+  force?: boolean,
+  mode?: STEVE_WATCH_MODE
+}
+
+export type STEVE_WATCH_EVENT_LISTENER_CALLBACK = () => void
+export interface STEVE_WATCH_EVENT_LISTENER {
+  params: STEVE_WATCH_PARAMS,
+  callbacks: { [id: string]: STEVE_WATCH_EVENT_LISTENER_CALLBACK},
+}
+
+export interface STEVE_WATCH_EVENT_PARAMS_COMMON {
+  event: STEVE_WATCH_EVENT,
+  id: string,
+  /**
+   * of type @STEVE_WATCH_PARAMS
+   */
+  params: STEVE_WATCH_PARAMS,
+}
+
+export interface STEVE_WATCH_EVENT_PARAMS extends STEVE_WATCH_EVENT_PARAMS_COMMON {
+  callback: STEVE_WATCH_EVENT_LISTENER_CALLBACK,
+}
+
+export type STEVE_UNWATCH_EVENT_PARAMS = STEVE_WATCH_EVENT_PARAMS_COMMON

package/utils/__tests__/fleet.test.ts

@@ -0,0 +1,148 @@
+import { Target } from '@shell/types/fleet';
+import FleetUtils from '@shell/utils/fleet';
+
+describe('fx: util.getTargetMode', () => {
+  const util = FleetUtils.Application;
+
+  it('should return "all" when targets contain excludeHarvesterRule and namespace is not fleet-local', () => {
+    const targets = [{
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'provider.cattle.io',
+          operator: 'NotIn',
+          values:   ['harvester'],
+        }],
+      },
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+
+  it('should return "clusters" when targets include clusterName and clusterSelector', () => {
+    const targets = [{ clusterName: 'fleet-5-france' }, { clusterSelector: { matchLabels: { foo: 'true' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "clusters" when targets only include multiple clusterSelectors', () => {
+    const targets: Target[] = [{ clusterSelector: { matchLabels: { foo: 'true' } } }, { clusterSelector: { matchLabels: { hci: 'true' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "advanced" when a target contains clusterGroupSelector', () => {
+    const targets = [{ clusterGroupSelector: {} }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "advanced" when any target contains clusterGroup or clusterGroupSelector', () => {
+    const targets = [{
+      clusterGroup:         'cg1',
+      clusterGroupSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['string']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      clusterName:     'pippo',
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['vvv']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      name: 'tt1',
+    }, {
+      clusterGroup:         'cg2',
+      clusterGroupSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['string']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      clusterName:     'pippo',
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['vvv']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      name: 'tt1',
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "none" when targets is an empty array', () => {
+    const targets: Target[] = [];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('none');
+  });
+
+  it('should return "local" when namespace is "fleet-local" regardless of targets', () => {
+    const targets: Target[] = [{ clusterSelector: { matchLabels: { foo: 'true' } } }, { clusterSelector: { matchLabels: { hci: 'true' } } }];
+    const namespace = 'fleet-local';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('local');
+  });
+
+  it('should return "all" if no specific target type (clusterName, clusterSelector, clusterGroup, clusterGroupSelector) is present', () => {
+    const targets = [{ name: 'target1' }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+
+  it('should return "clusters" if multiple targets include only clusterName', () => {
+    const targets = [{ clusterName: 'cluster-a' }, { clusterName: 'cluster-b' }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "clusters" if a mix of clusterName and empty clusterSelector is present', () => {
+    const targets = [{ clusterName: 'cluster-c' }, { clusterSelector: {} },
+    ];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "advanced" if one target has clusterGroup but others have clusterName or clusterSelector', () => {
+    const targets = [{ clusterName: 'cluster-x' }, { clusterGroup: 'my-group' }, { clusterSelector: { matchLabels: { env: 'prod' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "all" when targets contain excludeHarvesterRule along with other irrelevant properties', () => {
+    const targets = [{
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'provider.cattle.io',
+          operator: 'NotIn',
+          values:   ['harvester'],
+        }],
+      },
+      name: 'some-other-name'
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+});

package/utils/__tests__/object.test.ts

@@ -1,6 +1,6 @@
 import { reactive, isReactive } from 'vue';
 import {
-  clone, get, getter, isEmpty, toDictionary, remove, diff, definedKeys, deepToRaw, mergeWithReplace
+  clone, get, getter, isEmpty, toDictionary, remove, diff, definedKeys, deepToRaw, mergeWithReplace, convertKVToString, convertStringToKV
 } from '@shell/utils/object';
 
 describe('fx: get', () => {
@@ -441,3 +441,56 @@ describe('fx: mergeWithReplace', () => {
     expect(result).toStrictEqual(expected);
   });
 });
+
+describe('fx: convertKVToString', () => {
+  it.each([
+    [{}, ''],
+    [{ foo: 'bar' }, 'foo,bar'],
+    [{ foo: 'bar', baz: 'bang' }, 'foo,bar,baz,bang'],
+    [{ foo: 'bar', baz: null }, 'foo,bar,baz,null'],
+    [{ ' spaced ': ' value ' }, ' spaced , value '], // preserves raw keys/values
+    [{ 0: 42, truthy: true }, '0,42,truthy,true'],
+  ])('should convert %p -> "%s"', (input, expected) => {
+    const result = convertKVToString(input);
+
+    expect(result).toBe(expected);
+  });
+
+  it('should produce a string with an even number of comma-separated parts', () => {
+    const str = convertKVToString({
+      a: 1, b: 2, c: 3
+    });
+    const parts = str.split(',');
+
+    expect(parts.length % 2).toBe(0);
+  });
+});
+
+describe('fx: convertStringToKV', () => {
+  it.each([
+    ['', {}],
+    ['foo,bar', { foo: 'bar' }],
+    ['foo,bar,baz,bang', { foo: 'bar', baz: 'bang' }],
+    ['  foo  ,  bar  ', { foo: 'bar' }], // trims whitespace
+    ['foo,bar,baz', { foo: 'bar' }], // dangling key ignored
+    ['foo,bar,,bang', { foo: 'bar', '': 'bang' }], // empty key retained when present
+  ])('should convert "%s" -> %p', (input, expected) => {
+    const result = convertStringToKV(input);
+
+    expect(result).toStrictEqual(expected);
+  });
+});
+
+describe('fx: convertStringToKV to convertKVToString and back (round-trip)', () => {
+  it.each([
+    '',
+    'foo,bar',
+    'foo,bar,baz,bang',
+    'answer,42,truthy,true,falsy,false',
+  ])('should round-trip %p without loss', (input) => {
+    const asObj = convertStringToKV(input);
+    const backToString = convertKVToString(asObj);
+
+    expect(backToString).toStrictEqual(input);
+  });
+});

package/utils/__tests__/string.test.ts

@@ -1,4 +1,4 @@
-import { decodeHtml, resourceNames } from '@shell/utils/string';
+import { decodeHtml, resourceNames, pathArrayToTree } from '@shell/utils/string';
 
 describe('fx: decodeHtml', () => {
   it('should decode HTML values from escaped string into valid markup', () => {
@@ -89,3 +89,275 @@ describe('fx: resourceNames', () => {
     });
   });
 });
+
+describe('fx: pathArrayToTree', () => {
+  interface TreeNode {
+    name: string;
+    children: TreeNode[];
+  }
+
+  function sortTree(nodes: TreeNode[]): void {
+    if (!nodes) return;
+    nodes.sort((a, b) => a.name.localeCompare(b.name));
+    nodes.forEach((node) => {
+      if (node.children && node.children.length > 0) {
+        sortTree(node.children);
+      }
+    });
+  }
+
+  it('should return an empty array for an empty input array', () => {
+    const paths: string[] = [];
+
+    expect(pathArrayToTree(paths)).toStrictEqual([]);
+  });
+
+  it('should convert simple single-level paths correctly', () => {
+    const paths: string[] = [
+      'file1.txt',
+      'folderA',
+      'itemB'
+    ];
+    const expected: TreeNode[] = [
+      { name: 'file1.txt', children: [] },
+      { name: 'folderA', children: [] },
+      { name: 'itemB', children: [] },
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual); // Sort the actual output for deterministic comparison
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should convert two-level nested paths correctly', () => {
+    const paths: string[] = [
+      'folderA/file1.txt',
+      'folderC/file3.txt'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     'folderA',
+        children: [
+          { name: 'file1.txt', children: [] },
+        ]
+      },
+      {
+        name:     'folderC',
+        children: [
+          { name: 'file3.txt', children: [] }
+        ]
+      },
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should handle deep nesting and common prefixes correctly', () => {
+    const paths: string[] = [
+      'root/level1/level2/file.doc',
+      'root/level1/another_file.txt',
+      'root/diff_level1/config.json'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     'root',
+        children: [
+          {
+            name:     'diff_level1',
+            children: [
+              { name: 'config.json', children: [] }
+            ]
+          },
+          {
+            name:     'level1',
+            children: [
+              { name: 'another_file.txt', children: [] },
+              {
+                name:     'level2',
+                children: [
+                  { name: 'file.doc', children: [] }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should handle leading/trailing/multiple slashes by treating them as path segments', () => {
+    const paths: string[] = [
+      '/path/to/file.txt', // Starts with a slash
+      'path/to/another.txt/', // Ends with a slash (adds an empty segment)
+      '//root/item//subitem//', // Multiple slashes (adds empty segments)
+      'root/item/another_subitem'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     '',
+        children: [
+          {
+            name:     '',
+            children: [
+              {
+                name:     'root',
+                children: [
+                  {
+                    name:     'item',
+                    children: [
+                      {
+                        name:     '',
+                        children: [
+                          {
+                            name:     'subitem',
+                            children: [
+                              {
+                                name:     '',
+                                children: [
+                                  {
+                                    name:     '',
+                                    children: [
+                                    ],
+                                  },
+                                ],
+                              },
+                            ],
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            name:     'path',
+            children: [
+              {
+                name:     'to',
+                children: [
+                  {
+                    name:     'file.txt',
+                    children: [
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name:     'path',
+        children: [
+          {
+            name:     'to',
+            children: [
+              {
+                name:     'another.txt',
+                children: [
+                  {
+                    name:     '',
+                    children: [
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name:     'root',
+        children: [
+          {
+            name:     'item',
+            children: [
+              {
+                name:     'another_subitem',
+                children: [
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should produce the same structure regardless of input order', () => {
+    const paths1: string[] = ['a/b', 'a/c'];
+    const paths2: string[] = ['a/c', 'a/b'];
+
+    const actual1 = pathArrayToTree(paths1);
+
+    sortTree(actual1);
+    const actual2 = pathArrayToTree(paths2);
+
+    sortTree(actual2);
+
+    expect(actual1).toStrictEqual(actual2);
+  });
+
+  it('should handle names with special characters (not slashes) correctly', () => {
+    const paths: string[] = [
+      'my-folder/file_name.1.txt',
+      'another folder/item with spaces'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     'another folder',
+        children: [
+          { name: 'item with spaces', children: [] }
+        ]
+      },
+      {
+        name:     'my-folder',
+        children: [
+          { name: 'file_name.1.txt', children: [] }
+        ]
+      }
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('should handle duplicate paths correctly, only adding unique structure', () => {
+    const paths: string[] = [
+      'folder/file.txt',
+      'folder/file.txt', // Duplicate
+      'other_folder/another_file.txt'
+    ];
+    const expected: TreeNode[] = [
+      {
+        name:     'folder',
+        children: [
+          { name: 'file.txt', children: [] }
+        ]
+      },
+      {
+        name:     'other_folder',
+        children: [
+          { name: 'another_file.txt', children: [] }
+        ]
+      }
+    ];
+    const actual = pathArrayToTree(paths);
+
+    sortTree(actual);
+    expect(actual).toStrictEqual(expected);
+  });
+});

package/utils/__tests__/time.test.ts

@@ -0,0 +1,31 @@
+import { DATE_FORMAT, TIME_FORMAT } from '@shell/store/prefs';
+import { dateTimeFormat } from '@shell/utils/time';
+import { type Store } from 'vuex';
+
+describe('function: dateTimeFormat', () => {
+  jest.useFakeTimers()
+    .setSystemTime(new Date('21-10-2010 4:29:00'));
+  const store = {
+    getters: {
+      'prefs/get': (key: string) => {
+        return {
+          [DATE_FORMAT]: 'ddd, MMM D YYYY',
+          [TIME_FORMAT]: 'h:mm:ss a',
+        }[key];
+      },
+    },
+  } as Store<any>;
+
+  it('should format date and time correctly', () => {
+    const date = new Date('2010-10-21T04:29:00Z');
+    const formattedDate = dateTimeFormat(date.toISOString(), store);
+
+    expect(formattedDate).toBe('Thu, Oct 21 2010 4:29:00 am');
+  });
+
+  it('should return empty string for undefined value', () => {
+    const formattedDate = dateTimeFormat(undefined, store);
+
+    expect(formattedDate).toBe('');
+  });
+});