@rancher/shell 3.0.8-rc.8 → 3.0.8

package/plugins/dashboard-store/getters.js

@@ -1,5 +1,8 @@
 
-import { SCHEMA, COUNT, POD } from '@shell/config/types';
+import {
+  SCHEMA, COUNT, POD, MANAGEMENT, BRAND
+} from '@shell/config/types';
+import { SETTING } from '@shell/config/settings';
 
 import { matches } from '@shell/utils/selector';
 import { typeMunge, typeRef, SIMPLE_TYPES } from '@shell/utils/create-yaml';
@@ -204,6 +207,20 @@ export default {
     }
   },
 
+  brand: (state, getters) => {
+    const brand = getters['byId'](MANAGEMENT.SETTING, SETTING.BRAND);
+
+    if (!brand?.value) {
+      return undefined;
+    }
+
+    if ([BRAND.CSP, BRAND.FEDERAL, BRAND.RGS].includes(brand.value)) {
+      return BRAND.SUSE;
+    }
+
+    return brand.value;
+  },
+
   /**
    * Checks a schema for the given path
    *
@@ -526,7 +543,7 @@ export default {
     const store = state.config.namespace;
     const resource = id || context ? { id, context } : null;
 
-    return paginationUtils.isEnabled({ rootGetters, $plugin: rootState.$plugin }, { store, resource });
+    return paginationUtils.isEnabled({ rootGetters, $extension: rootState.$extension }, { store, resource });
   },
 
   /**

package/plugins/dashboard-store/model-loader.js

@@ -13,7 +13,7 @@ function find(cache, type, rootState) {
   }
 
   try {
-    const pluginModel = rootState.$plugin.getDynamic('models', type);
+    const pluginModel = rootState.$extension.getDynamic('models', type);
     let base;
 
     if (!pluginModel) {

package/plugins/dashboard-store/mutations.js

@@ -515,8 +515,29 @@ export default {
     cache.generation++;
 
     // Update list
-    clear(cache.list);
-    addObjects(cache.list, proxies);
+    // We want to update the old page with the new page
+    // We need to keep the cache.list object reference the same
+    // We need to keep objects that represent the same resource the same (don't remove the old object and add a new object for the same resource)
+    // - this helps anywhere that works with object references (sortable table selection is maintained by object reference)
+
+    // Create a map of the current references in cache.list
+    const currentPageMap = new Map(cache.list.map((i) => [i[keyField], i]));
+
+    // Create an array containing the new page, but using the same object for resources that exist in old and new page
+    const newPage = proxies.map((p) => {
+      const existing = currentPageMap.get(p[keyField]);
+
+      if (existing) {
+        replaceResource(existing, p, ctx.getters);
+
+        return existing;
+      }
+
+      return p;
+    });
+
+    // Replace the old cache.list entries with the new page
+    cache.list.splice(0, cache.list.length, ...newPage);
 
     // Update Map (remove stale)
     cache.map.forEach((value, key) => {

package/plugins/dashboard-store/resource-class.js

@@ -610,7 +610,11 @@ export default class Resource {
   }
 
   get '$plugin'() {
-    return this.$ctx.rootState?.$plugin;
+    return this.$ctx.rootState?.$extension;
+  }
+
+  get '$extension'() {
+    return this.$ctx.rootState?.$extension;
   }
 
   get customValidationRules() {
@@ -905,7 +909,7 @@ export default class Resource {
     return out;
   }
 
-  showConfiguration(returnFocusSelector) {
+  showConfiguration(returnFocusSelector, defaultTab) {
     const onClose = () => this.$ctx.commit('slideInPanel/close', undefined, { root: true });
 
     this.$ctx.commit('slideInPanel/open', {
@@ -920,7 +924,8 @@ export default class Resource {
         'z-index':          101, // We want this to be above the main side menu
         closeOnRouteChange: ['name', 'params', 'query'], // We want to ignore hash changes, tables in extensions can trigger the drawer to close while opening
         triggerFocusTrap:   true,
-        returnFocusSelector
+        returnFocusSelector,
+        defaultTab
       }
     }, { root: true });
   }
@@ -1358,6 +1363,7 @@ export default class Resource {
 
   get _detailLocation() {
     const schema = this.$getters['schemaFor'](this.type);
+    const isNamespaced = schema?.attributes?.namespaced;
 
     const id = this.id?.replace(/.*\//, '');
 
@@ -1367,7 +1373,7 @@ export default class Resource {
         product:   this.$rootGetters['productId'],
         cluster:   this.$rootGetters['clusterId'],
         resource:  this.type,
-        namespace: this.metadata?.namespace,
+        namespace: isNamespaced && this.metadata?.namespace ? this.metadata.namespace : undefined,
         id,
       }
     };
@@ -1776,7 +1782,7 @@ export default class Resource {
             CustomValidators[validatorName](pathValue, this.$rootGetters, errors, validatorArgs, displayKey, data);
           } else if (!isEmpty(validatorName) && !validatorExists) {
             // Check if validator is imported from plugin
-            const pluginValidator = this.$rootState.$plugin?.getValidator(validatorName);
+            const pluginValidator = this.$rootState.$extension?.getValidator(validatorName);
 
             if (pluginValidator) {
               pluginValidator(pathValue, this.$rootGetters, errors, validatorArgs, displayKey, data);

package/plugins/i18n.js

@@ -3,6 +3,14 @@ import { escapeHtml } from '../utils/string';
 import { watchEffect, ref, h } from 'vue';
 import { useStore } from 'vuex';
 
+/**
+ * @param {import('vuex').Store<any>} store
+ * @param {string} key
+ * @param {Record<string, any>} [args]
+ * @param {boolean} [raw]
+ * @param {boolean} [escapehtml]
+ * @returns {string}
+ */
 export function stringFor(store, key, args, raw = false, escapehtml = true) {
   const translation = store.getters['i18n/t'](key, args);
 

package/plugins/plugin.js

@@ -44,7 +44,7 @@ export default async function(context) {
     const res = await allHashSettled(fetches);
 
     // Initialize the built-in extensions now - this is now done here so that built-in extensions get the same, correct environment data (version etc)
-    context.$plugin.loadBuiltinExtensions();
+    context.$extension.loadBuiltinExtensions();
 
     if (res.plugins?.status === 'rejected') {
       throw new Error(res.reason);
@@ -60,7 +60,7 @@ export default async function(context) {
       const shouldNotLoad = shouldNotLoadPlugin(plugin, { rancherVersion, kubeVersion }, context.store.getters['uiplugins/plugins'] || []); // Error key string or boolean
 
       if (!shouldNotLoad) {
-        hash[plugin.name] = context.$plugin.loadPluginAsync(plugin);
+        hash[plugin.name] = context.$extension.loadPluginAsync(plugin);
       } else {
         context.store.dispatch('uiplugins/setError', { name: plugin.name, error: shouldNotLoad });
       }

package/plugins/steve/__tests__/steve-pagination-utils.test.ts

@@ -0,0 +1,506 @@
+
+import { PaginationFilterEquality, PaginationFilterField, PaginationParamFilter, PaginationParamProjectOrNamespace } from '@shell/types/store/pagination.types';
+import { NAMESPACE_FILTER_ALL_SYSTEM, NAMESPACE_FILTER_ALL_USER, NAMESPACE_FILTER_P_FULL_PREFIX } from '@shell/utils/namespace-filter';
+import stevePaginationUtils from '../steve-pagination-utils';
+import Schema from '@shell/models/schema';
+
+/**
+ * The `NamespaceProjectFilters` class is a protected class within `steve-pagination-utils.ts`.
+ * To test its protected methods, we extend it with a test class that exposes them.
+ */
+class TestNamespaceProjectFilters {
+  public handlePrefAndSettingFilter(args: any) {
+    return stevePaginationUtils.handlePrefAndSettingFilter(args);
+  }
+
+  public handleSystemOrUserFilter(args: any) {
+    return stevePaginationUtils.handleSystemOrUserFilter(args);
+  }
+
+  public handleSelectionFilter(neu: string[], isLocalCluster: boolean) {
+    return stevePaginationUtils.handleSelectionFilter(neu, isLocalCluster);
+  }
+
+  public combineNsProjectFilterResults(a: any, b: any) {
+    return stevePaginationUtils.combineNsProjectFilterResults(a, b);
+  }
+
+  public createFiltersFromNamespaceProjectFilterResult(filterResult: any) {
+    return stevePaginationUtils.createFiltersFromNamespaceProjectFilterResult(filterResult);
+  }
+}
+
+describe('class: NamespaceProjectFilters', () => {
+  const testNamespaceProjectFilters = new TestNamespaceProjectFilters();
+
+  const normalNs = {
+    id: 'normal', name: 'normal', isObscure: false, isSystem: false
+  };
+  const obscureNs = {
+    id: 'obscure', name: 'obscure', isObscure: true, isSystem: false
+  };
+  const systemNs = {
+    id: 'system', name: 'system', isObscure: false, isSystem: true
+  };
+  const obscureAndSystemNs = {
+    id: 'obscure-system', name: 'obscure-system', isObscure: true, isSystem: true
+  };
+
+  const allNamespaces = [normalNs, obscureNs, systemNs, obscureAndSystemNs];
+
+  describe('method: handlePrefAndSettingFilter', () => {
+    it('should return no filters if all namespaces are shown', () => {
+      const result = testNamespaceProjectFilters.handlePrefAndSettingFilter({
+        allNamespaces,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result).toStrictEqual({});
+    });
+
+    it('should filter obscure namespaces if showReservedRancherNamespaces is false', () => {
+      const result = testNamespaceProjectFilters.handlePrefAndSettingFilter({
+        allNamespaces,
+        showReservedRancherNamespaces: false,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result).toStrictEqual({
+        obscure:          false,
+        'obscure-system': false
+      });
+    });
+
+    it('should filter system namespaces if productHidesSystemNamespaces is true', () => {
+      const result = testNamespaceProjectFilters.handlePrefAndSettingFilter({
+        allNamespaces,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  true,
+      });
+
+      expect(result).toStrictEqual({
+        system:           false,
+        'obscure-system': false
+      });
+    });
+
+    it('should filter both obscure and system namespaces when both settings are active', () => {
+      const result = testNamespaceProjectFilters.handlePrefAndSettingFilter({
+        allNamespaces,
+        showReservedRancherNamespaces: false,
+        productHidesSystemNamespaces:  true,
+      });
+
+      expect(result).toStrictEqual({
+        obscure:          false,
+        system:           false,
+        'obscure-system': false
+      });
+    });
+  });
+
+  describe('method: handleSystemOrUserFilter', () => {
+    it('should create an OR filter for system namespaces when isAllSystem is true', () => {
+      const result = testNamespaceProjectFilters.handleSystemOrUserFilter({
+        allNamespaces,
+        isAllSystem: true,
+        isAllUser:   false,
+      });
+
+      expect(result).toStrictEqual({
+        system:           true,
+        'obscure-system': true
+      });
+    });
+
+    it('should create AND filters to exclude system namespaces when isAllUser is true', () => {
+      const result = testNamespaceProjectFilters.handleSystemOrUserFilter({
+        allNamespaces,
+        isAllSystem: false,
+        isAllUser:   true,
+      });
+
+      expect(result).toStrictEqual({
+        system:           false,
+        'obscure-system': false
+      });
+    });
+  });
+
+  describe('method: combineNsProjectFilterResults', () => {
+    it('should merge two results, prioritizing the first', () => {
+      const a = { ns1: true, ns2: false };
+      const b = { ns2: true, ns3: true };
+      const result = testNamespaceProjectFilters.combineNsProjectFilterResults(a, b);
+
+      expect(result).toStrictEqual({
+        ns1: true,
+        ns2: false, // kept from a
+        ns3: true // added from b
+      });
+    });
+  });
+
+  describe('method: createFiltersFromNamespaceProjectFilterResult', () => {
+    it('should create IN filter if there are included namespaces', () => {
+      const input = {
+        ns1: true, ns2: true, ns3: false
+      };
+      const result = testNamespaceProjectFilters.createFiltersFromNamespaceProjectFilterResult(input);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].fields[0]).toMatchObject({
+        field:    'metadata.namespace',
+        equality: PaginationFilterEquality.IN,
+        value:    'ns1,ns2'
+      });
+    });
+
+    it('should create NOT_IN filter if there are only excluded namespaces', () => {
+      const input = { ns1: false, ns2: false };
+      const result = testNamespaceProjectFilters.createFiltersFromNamespaceProjectFilterResult(input);
+
+      expect(result).toHaveLength(1);
+      expect(result[0].fields[0]).toMatchObject({
+        field:    'metadata.namespace',
+        equality: PaginationFilterEquality.NOT_IN,
+        value:    'ns1,ns2'
+      });
+    });
+
+    it('should return empty array if input is empty', () => {
+      const input = {};
+      const result = testNamespaceProjectFilters.createFiltersFromNamespaceProjectFilterResult(input);
+
+      expect(result).toHaveLength(0);
+    });
+  });
+
+  describe('method: handleSelectionFilter', () => {
+    const selection = ['ns-1', `${ NAMESPACE_FILTER_P_FULL_PREFIX }p-1`];
+
+    it('should create projectsOrNamespaces filter for a selection in a non-local cluster', () => {
+      const result = testNamespaceProjectFilters.handleSelectionFilter(selection, false);
+
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      const pnsFilter = result.projectsOrNamespaces[0] as PaginationParamProjectOrNamespace;
+
+      expect(pnsFilter.param).toBe('projectsornamespaces');
+      expect(pnsFilter.fields).toHaveLength(2);
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'ns-1' }));
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'p-1' }));
+      expect(result.filters).toStrictEqual([]);
+    });
+
+    it('should create projectsOrNamespaces and an exclusion filter for a selection in a local cluster', () => {
+      const result = testNamespaceProjectFilters.handleSelectionFilter(selection, true);
+
+      // projectsOrNamespaces part
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      const pnsFilter = result.projectsOrNamespaces[0] as PaginationParamProjectOrNamespace;
+
+      expect(pnsFilter.param).toBe('projectsornamespaces');
+      expect(pnsFilter.fields).toHaveLength(2);
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'ns-1' }));
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'p-1' }));
+
+      // filters part
+      expect(result.filters).toHaveLength(1);
+      const filter = result.filters[0] as PaginationParamFilter;
+
+      expect(filter.fields).toHaveLength(1);
+      expect(filter.fields).toContainEqual(expect.objectContaining({
+        field:    'metadata.namespace',
+        equality: '!=',
+        value:    'p-1',
+      }));
+    });
+
+    it('should handle selections with only namespaces in a local cluster', () => {
+      const nsSelection = ['ns-1', 'ns-2'];
+      const result = testNamespaceProjectFilters.handleSelectionFilter(nsSelection, true);
+
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      const pnsFilter = result.projectsOrNamespaces[0] as PaginationParamProjectOrNamespace;
+
+      expect(pnsFilter.fields).toHaveLength(2);
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'ns-1' }));
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'ns-2' }));
+      expect(result.filters).toStrictEqual([]);
+    });
+
+    it('should handle selections with only projects in a local cluster', () => {
+      const projectSelection = [`${ NAMESPACE_FILTER_P_FULL_PREFIX }p-1`, `${ NAMESPACE_FILTER_P_FULL_PREFIX }p-2`];
+      const result = testNamespaceProjectFilters.handleSelectionFilter(projectSelection, true);
+
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      const pnsFilter = result.projectsOrNamespaces[0] as PaginationParamProjectOrNamespace;
+
+      expect(pnsFilter.fields).toHaveLength(2);
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'p-1' }));
+      expect(pnsFilter.fields).toContainEqual(expect.objectContaining({ value: 'p-2' }));
+
+      expect(result.filters).toHaveLength(2);
+      expect(result.filters).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          field:    'metadata.namespace',
+          equality: '!=',
+          value:    'p-1'
+        })],
+      }));
+      expect(result.filters).toContainEqual(expect.objectContaining({
+        fields: [expect.objectContaining({
+          field:    'metadata.namespace',
+          equality: '!=',
+          value:    'p-2'
+        })],
+      }));
+    });
+  });
+});
+
+class TestStevePaginationUtils {
+  public convertPaginationParams(args: any) {
+    return stevePaginationUtils.convertPaginationParams(args);
+  }
+}
+
+describe('class StevePaginationUtils', () => {
+  const testStevePaginationUtils = new TestStevePaginationUtils();
+  const schema = { id: 'pod' } as unknown as Schema;
+
+  describe('method: createParamsFromNsFilter', () => {
+    const normalNs = {
+      id: 'normal', name: 'normal', isObscure: false, isSystem: false
+    } as any;
+    const obscureNs = {
+      id: 'obscure', name: 'obscure', isObscure: true, isSystem: false
+    } as any;
+    const systemNs = {
+      id: 'system', name: 'system', isObscure: false, isSystem: true
+    } as any;
+    const allNamespaces = [normalNs, obscureNs, systemNs];
+
+    it('should return empty filters if all namespaces requested and settings allow all', () => {
+      const result = stevePaginationUtils.createParamsFromNsFilter({
+        allNamespaces,
+        selection:                     [],
+        isAllNamespaces:               true,
+        isLocalCluster:                false,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result.projectsOrNamespaces).toHaveLength(0);
+      expect(result.filters).toHaveLength(0);
+    });
+
+    it('should filter obscure namespaces if showReservedRancherNamespaces is false', () => {
+      const result = stevePaginationUtils.createParamsFromNsFilter({
+        allNamespaces,
+        selection:                     [],
+        isAllNamespaces:               true,
+        isLocalCluster:                false,
+        showReservedRancherNamespaces: false,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result.filters).toHaveLength(1);
+      expect(result.filters[0].fields[0]).toMatchObject({
+        field:    'metadata.namespace',
+        equality: PaginationFilterEquality.NOT_IN,
+        value:    'obscure'
+      });
+    });
+
+    it('should filter system namespaces if productHidesSystemNamespaces is true', () => {
+      const result = stevePaginationUtils.createParamsFromNsFilter({
+        allNamespaces,
+        selection:                     [],
+        isAllNamespaces:               true,
+        isLocalCluster:                false,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  true,
+      });
+
+      expect(result.filters).toHaveLength(1);
+      expect(result.filters[0].fields[0]).toMatchObject({
+        field:    'metadata.namespace',
+        equality: PaginationFilterEquality.NOT_IN,
+        value:    'system'
+      });
+    });
+
+    it('should filter both obscure and system namespaces when both settings are active', () => {
+      const result = stevePaginationUtils.createParamsFromNsFilter({
+        allNamespaces,
+        selection:                     [],
+        isAllNamespaces:               true,
+        isLocalCluster:                false,
+        showReservedRancherNamespaces: false,
+        productHidesSystemNamespaces:  true,
+      });
+
+      expect(result.filters).toHaveLength(1);
+      expect(result.filters[0].fields[0]).toMatchObject({
+        field:    'metadata.namespace',
+        equality: PaginationFilterEquality.NOT_IN,
+        value:    'obscure,system'
+      });
+    });
+
+    it('should handle ALL_SYSTEM selection', () => {
+      const result = stevePaginationUtils.createParamsFromNsFilter({
+        allNamespaces,
+        selection:                     [NAMESPACE_FILTER_ALL_SYSTEM],
+        isAllNamespaces:               false,
+        isLocalCluster:                false,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result.filters).toHaveLength(1);
+      expect(result.filters[0].fields[0]).toMatchObject({
+        field:    'metadata.namespace',
+        equality: PaginationFilterEquality.IN,
+        value:    'system'
+      });
+    });
+
+    it('should handle ALL_USER selection', () => {
+      const result = stevePaginationUtils.createParamsFromNsFilter({
+        allNamespaces,
+        selection:                     [NAMESPACE_FILTER_ALL_USER],
+        isAllNamespaces:               false,
+        isLocalCluster:                false,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result.filters).toHaveLength(1);
+      expect(result.filters[0].fields[0]).toMatchObject({
+        field:    'metadata.namespace',
+        equality: PaginationFilterEquality.NOT_IN,
+        value:    'system'
+      });
+    });
+
+    it('should handle specific project/namespace selection', () => {
+      const selection = ['ns-1'];
+      const result = stevePaginationUtils.createParamsFromNsFilter({
+        allNamespaces,
+        selection,
+        isAllNamespaces:               false,
+        isLocalCluster:                false,
+        showReservedRancherNamespaces: true,
+        productHidesSystemNamespaces:  false,
+      });
+
+      expect(result.projectsOrNamespaces).toHaveLength(1);
+      expect(result.projectsOrNamespaces[0].fields[0].value).toBe('ns-1');
+    });
+  });
+
+  describe('method: convertPaginationParams', () => {
+    it('should return an empty string for no filters', () => {
+      const result = testStevePaginationUtils.convertPaginationParams({ schema, filters: [] });
+
+      expect(result).toBe('');
+    });
+
+    it('should handle a single filter with a single field', () => {
+      const filters = [
+        new PaginationParamFilter({ fields: [new PaginationFilterField({ field: 'metadata.name', value: 'test' })] }),
+      ];
+      const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+      expect(result).toBe('filter=metadata.name=test');
+    });
+
+    it('should handle a single filter with a single field with encoded char', () => {
+      const filters = [
+        new PaginationParamFilter({ fields: [new PaginationFilterField({ field: 'metadata.name', value: 'te/st' })] }),
+      ];
+      const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+      expect(result).toBe('filter=metadata.name="te%2Fst"');
+    });
+
+    it('should handle a single filter with multiple fields (OR)', () => {
+      const filters = [
+        new PaginationParamFilter({
+          fields: [
+            new PaginationFilterField({ field: 'metadata.name', value: 'test1' }),
+            new PaginationFilterField({ field: 'metadata.namespace', value: 'ns1' }),
+          ],
+        }),
+      ];
+      const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+      expect(result).toBe('filter=metadata.name=test1,metadata.namespace=ns1');
+    });
+
+    it('should handle multiple filters (AND)', () => {
+      const filters = [
+        new PaginationParamFilter({ fields: [new PaginationFilterField({ field: 'metadata.name', value: 'test1' })] }),
+        new PaginationParamFilter({ fields: [new PaginationFilterField({ field: 'metadata.namespace', value: 'ns1' })] }),
+      ];
+      const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+      expect(result).toBe('filter=metadata.name=test1&filter=metadata.namespace=ns1');
+    });
+
+    it('should handle different equality operators', () => {
+      const filters = [
+        new PaginationParamFilter({
+          fields: [
+            new PaginationFilterField({
+              field:    'spec.containers.image',
+              value:    'nginx',
+              equality: PaginationFilterEquality.CONTAINS,
+            }),
+          ],
+        }),
+        new PaginationParamFilter({
+          fields: [
+            new PaginationFilterField({
+              field:    'metadata.name',
+              value:    'test',
+              equality: PaginationFilterEquality.NOT_EQUALS,
+            }),
+          ],
+        }),
+      ];
+      const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+      expect(result).toBe('filter=spec.containers.image~nginx&filter=metadata.name!=test');
+    });
+
+    it('should handle IN and NOT_IN operators', () => {
+      const filters = [
+        new PaginationParamFilter({
+          fields: [
+            new PaginationFilterField({
+              field:    'metadata.name',
+              value:    'test1,test2',
+              equality: PaginationFilterEquality.IN,
+            }),
+          ],
+        }),
+        new PaginationParamFilter({
+          fields: [
+            new PaginationFilterField({
+              field:    'metadata.namespace',
+              value:    'ns1,ns2',
+              equality: PaginationFilterEquality.NOT_IN,
+            }),
+          ],
+        }),
+      ];
+      const result = testStevePaginationUtils.convertPaginationParams({ schema, filters });
+
+      expect(result).toBe('filter=metadata.name IN (test1,test2)&filter=metadata.namespace NOTIN (ns1,ns2)');
+    });
+  });
+});

package/plugins/steve/steve-class.js

@@ -47,7 +47,7 @@ export default class SteveModel extends HybridModel {
    * Get all model extensions for this model
    */
   get modelExtensions() {
-    return this.$plugin.getDynamic(EXT_IDS.MODEL_EXTENSION, this.type) || [];
+    return this.$extension.getDynamic(EXT_IDS.MODEL_EXTENSION, this.type) || [];
   }
 
   cleanForSave(data, forNew) {