@rancher/shell 3.0.6 → 3.0.8-rc.1

package/utils/pagination-wrapper.ts

@@ -2,10 +2,9 @@ import paginationUtils from '@shell/utils/pagination-utils';
 import { PaginationArgs, PaginationResourceContext } from '@shell/types/store/pagination.types';
 import { VuexStore } from '@shell/types/store/vuex';
 import { ActionFindPageArgs, ActionFindPageTransientResult } from '@shell/types/store/dashboard-store.types';
-import {
-  STEVE_WATCH_EVENT_LISTENER_CALLBACK, STEVE_UNWATCH_EVENT_PARAMS, STEVE_WATCH_EVENT, STEVE_WATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_PARAMS_COMMON, STEVE_WATCH_MODE
-} from '@shell/types/store/subscribe.types';
+import { STEVE_WATCH_EVENT_TYPES, STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 import { Reactive, reactive } from 'vue';
+import { STEVE_UNWATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_LISTENER_CALLBACK, STEVE_WATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_PARAMS_COMMON } from '@shell/types/store/subscribe-events.types';
 
 interface Args {
   $store: VuexStore,
@@ -70,7 +69,7 @@ class PaginationWrapper<T extends object> {
     this.classify = formatResponse?.classify || false;
     this.reactive = formatResponse?.reactive || false;
 
-    this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters }, enabledFor);
+    this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters, $plugin: this.$store.$plugin }, enabledFor);
   }
 
   async request(args: {
@@ -92,7 +91,7 @@ class PaginationWrapper<T extends object> {
     // Watch
     if (this.onChange && !this.steveWatchParams) {
       this.steveWatchParams = {
-        event:  STEVE_WATCH_EVENT.CHANGES,
+        event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
         id:     this.id,
         params: {
           type: this.enabledFor.resource?.id as string,
@@ -126,7 +125,7 @@ class PaginationWrapper<T extends object> {
     }
     const watchParams: STEVE_WATCH_EVENT_PARAMS = {
       ...this.steveWatchParams,
-      callback: this.onChange as STEVE_WATCH_EVENT_LISTENER_CALLBACK, // we must have it by now
+      callback: this.onChange as STEVE_WATCH_EVENT_LISTENER_CALLBACK, // we must have onChange by now
     };
 
     await this.$store.dispatch(`${ this.enabledFor.store }/watchEvent`, watchParams);
@@ -134,8 +133,7 @@ class PaginationWrapper<T extends object> {
 
   private async unWatch() {
     if (!this.steveWatchParams) {
-      console.error('Calling unWatch but no watch params created'); // eslint-disable-line no-console
-
+      // We're unwatching before we've made the initial request
       return;
     }
 

package/utils/release-notes.ts

@@ -20,7 +20,7 @@ export async function addReleaseNotesNotification(dispatch: any, getters: any) {
       if (notification.id === id) {
         found = true;
       } else {
-        await dispatch('notifications/delete', notification.id);
+        await dispatch('notifications/remove', notification.id);
       }
     }
   }

package/utils/sort.js

@@ -169,6 +169,11 @@ export function compare(a, b) {
   return 0;
 }
 
+/**
+ * Should the logic of this sort field be flipped?
+ *
+ * For instance show descending but sort by ascending
+ */
 export function parseField(str) {
   const parts = str.split(/:/);
 

package/utils/unit-tests/pagination-utils.spec.ts

@@ -0,0 +1,283 @@
+import { STEVE_CACHE } from '@shell/store/features';
+import { SETTING } from '@shell/config/settings';
+import { EXT_IDS } from '@shell/core/plugin';
+import { PaginationResourceContext } from '@shell/types/store/pagination.types';
+import { PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
+import paginationUtils from '@shell/utils/pagination-utils';
+
+describe('pagination-utils', () => {
+  describe('isEnabledInStore', () => {
+    const mockRootGetters = {
+      'type-map/configuredHeaders':           jest.fn(),
+      'type-map/configuredPaginationHeaders': jest.fn(),
+      'type-map/hasCustomList':               jest.fn(),
+    };
+
+    beforeEach(() => {
+      jest.resetAllMocks();
+    });
+
+    it('should return false if no store settings are provided', () => {
+      const result = paginationUtils.isEnabledInStore({
+        ctx:           { rootGetters: mockRootGetters },
+        storeSettings: undefined as unknown as PaginationSettingsStore,
+        enabledFor:    { store: 'cluster' }
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true if no specific resource is being checked', () => {
+      const storeSettings: PaginationSettingsStore = { resources: {} };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster' }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true if enableAll is true for the store', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableAll: true } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if a resource is checked but has no id', () => {
+      const storeSettings: PaginationSettingsStore = { resources: {} };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: undefined as unknown as string } }
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true for a generic resource when generic is enabled', () => {
+      mockRootGetters['type-map/configuredHeaders'].mockReturnValue(false);
+      mockRootGetters['type-map/configuredPaginationHeaders'].mockReturnValue(false);
+      mockRootGetters['type-map/hasCustomList'].mockReturnValue(false);
+
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { generic: true } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for a non-generic resource when only generic is enabled', () => {
+      mockRootGetters['type-map/hasCustomList'].mockReturnValue(true);
+
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { generic: true } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true if resource id is in enabled list as a string', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: ['pod'] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return true if resource id is in enabled list as an object without context', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: [{ resource: 'pod' }] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if resource id is in enabled list as an object with empty context', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: [{ resource: 'pod', context: [] }] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod' } }
+      });
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true if resource id and context match an enabled setting', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: [{ resource: 'pod', context: ['list'] }] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod', context: 'list' } }
+      });
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if resource context does not match enabled setting', () => {
+      const storeSettings: PaginationSettingsStore = { resources: { enableSome: { enabled: [{ resource: 'pod', context: ['detail'] }] } } };
+      const result = paginationUtils.isEnabledInStore({
+        ctx:        { rootGetters: mockRootGetters },
+        storeSettings,
+        enabledFor: { store: 'cluster', resource: { id: 'pod', context: 'list' } }
+      });
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('isEnabled', () => {
+    let mockRootGetters: any;
+    let mockPlugin: any;
+    let enabledFor: PaginationResourceContext;
+
+    beforeEach(() => {
+      enabledFor = { store: 'cluster', resource: { id: 'pod' } };
+      mockPlugin = { getAll: jest.fn().mockReturnValue({}) };
+      mockRootGetters = {
+        'features/get':                         jest.fn(),
+        'management/byId':                      jest.fn(),
+        'type-map/configuredHeaders':           jest.fn().mockReturnValue(false),
+        'type-map/configuredPaginationHeaders': jest.fn().mockReturnValue(false),
+        'type-map/hasCustomList':               jest.fn().mockReturnValue(false),
+      };
+    });
+
+    it('should return false if steve cache is disabled', () => {
+      mockRootGetters['features/get'].mockImplementation((feature: string) => feature === STEVE_CACHE ? false : undefined);
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return false if pagination settings are not defined', () => {
+      jest.spyOn(paginationUtils, 'getSettings').mockReturnValue(undefined);
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(false);
+
+      jest.clearAllMocks();
+    });
+
+    it('should return false if enabledFor is not provided', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const settings: PaginationSettings = { useDefaultStores: true };
+
+      mockRootGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (type === 'management.cattle.io.setting' && id === SETTING.UI_PERFORMANCE) {
+          return { value: JSON.stringify({ serverPagination: settings }) };
+        }
+
+        return null;
+      });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, undefined as unknown as PaginationResourceContext);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true if an extension enables the resource', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const extensionSettings = { cluster: { resources: { enableAll: true } } };
+
+      mockPlugin.getAll.mockReturnValue({ [EXT_IDS.SERVER_SIDE_PAGINATION_RESOURCES]: { 'my-ext': () => extensionSettings } });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(true);
+    });
+
+    it('should still return true if an extension enables the resource but core store does not', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const extensionSettings = { cluster: { resources: { enableAll: true } } };
+      const defaultSettings = { cluster: { resources: { enableAll: false, enableSome: { enabled: [] } } } };
+
+      mockPlugin.getAll.mockReturnValue({ [EXT_IDS.SERVER_SIDE_PAGINATION_RESOURCES]: { 'my-ext': () => extensionSettings } });
+
+      // Mocking PAGINATION_SETTINGS_STORE_DEFAULTS behavior
+      jest.spyOn(paginationUtils, 'getStoreDefault').mockReturnValue(defaultSettings);
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(true);
+    });
+
+    it('should use default store settings and enable the resource', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const settings: PaginationSettings = { useDefaultStores: true };
+
+      mockRootGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (type === 'management.cattle.io.setting' && id === SETTING.UI_PERFORMANCE) {
+          return { value: JSON.stringify({ serverPagination: settings }) };
+        }
+
+        return null;
+      });
+
+      // Mocking PAGINATION_SETTINGS_STORE_DEFAULTS behavior
+      jest.spyOn(paginationUtils, 'getStoreDefault').mockReturnValue({ cluster: { resources: { enableAll: true } } });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(true);
+    });
+
+    it('should use custom store settings and enable the resource', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const settings: PaginationSettings = {
+        useDefaultStores: false,
+        stores:           { cluster: { resources: { enableSome: { enabled: ['pod'] } } } }
+      };
+
+      mockRootGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (type === 'management.cattle.io.setting' && id === SETTING.UI_PERFORMANCE) {
+          return { value: JSON.stringify({ serverPagination: settings }) };
+        }
+
+        return null;
+      });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false if neither extension nor main settings enable the resource', () => {
+      mockRootGetters['features/get'].mockReturnValue(true);
+      const settings: PaginationSettings = {
+        useDefaultStores: false,
+        stores:           { cluster: { resources: { enableSome: { enabled: ['service'] } } } }
+      };
+
+      mockRootGetters['management/byId'].mockImplementation((type: string, id: string) => {
+        if (type === 'management.cattle.io.setting' && id === SETTING.UI_PERFORMANCE) {
+          return { value: JSON.stringify({ serverPagination: settings }) };
+        }
+
+        return null;
+      });
+
+      const result = paginationUtils.isEnabled({ rootGetters: mockRootGetters, $plugin: mockPlugin }, enabledFor);
+
+      expect(result).toBe(false);
+    });
+  });
+});

package/utils/validators/formRules/__tests__/index.test.ts

@@ -116,6 +116,10 @@ describe('formRules', () => {
       ['git@github.com:rancher/dashboard/%20', undefined],
       ['git@git.apps.local:fleet/fleet-local.git', undefined],
       ['git@git.apps.local:33333/fleet/fleet-local.git', undefined],
+      ['ssh://git@github.com:rancher/dashboard', undefined],
+      ['ssh://git@github.com:rancher/dashboard/', undefined],
+      ['ssh://git@git.apps.local:fleet/fleet-local.git', undefined],
+      ['ssh://git@git.apps.local:33333/fleet/fleet-local.git', undefined],
 
       // Not valid HTTP(s)
       ['https://github.com/rancher/  dashboard.git', message],
@@ -145,6 +149,9 @@ describe('formRules', () => {
       ['git@git.apps.local:/fleet/fleet-local.git', message],
       ['git@.git', message],
       ['git@', message],
+      ['ssh://git@github.com:/rancher/dashboard.git ', message],
+      ['ssh://git@github.com/rancher/ dashboard.git', message],
+      ['ssh://git@github.com/rancher/ dashboard', message],
 
       [undefined, message],
       ['', message]

package/utils/validators/formRules/index.ts

@@ -200,8 +200,8 @@ export default function(
       return message;
     }
 
-    // Test http(s) protocol
-    if (protocol && (!/^(http|http(s))/gm.test(protocol) || (!url.startsWith('https://') && !url.startsWith('http://')))) {
+    // Test http(s)/ssh protocol
+    if (protocol && (!/^(http|https|ssh)$/gm.test(protocol) || (!url.startsWith('https://') && !url.startsWith('http://') && !url.startsWith('ssh://')))) {
       return message;
     }