@rancher/shell 3.0.12-rc.3 → 3.0.12-rc.5

package/pkg/require-asset.lib.js

@@ -0,0 +1,25 @@
+// Stub for extension library builds — prevents require.context() from bundling
+// all shell images into every extension. At runtime, delegates to the host
+// dashboard's asset resolver (exposed on window by the real require-asset.ts).
+
+export function toContextKey(path) {
+  return `./${ path.replace(/^[~@]shell\/assets\//, '') }`;
+}
+
+export function requireAsset(path) {
+  if (typeof window !== 'undefined' && window.__shell_requireAsset) {
+    return window.__shell_requireAsset(path);
+  }
+
+  throw new Error(`Asset context not available for: ${ path }`);
+}
+
+export function requireJson(path) {
+  if (typeof window !== 'undefined' && window.__shell_requireJson) {
+    return window.__shell_requireJson(path);
+  }
+
+  throw new Error(`JSON context not available for: ${ path }`);
+}
+
+export function _setContexts() {}

package/pkg/vue.config.js

@@ -72,11 +72,18 @@ module.exports = function(dir) {
         resource.request = fs.existsSync(pkgModelLoaderRequire) ? pkgModelLoaderRequire : path.join(__dirname, fileName);
       });
 
+      // Prevent require.context('@shell/assets') from bundling all shell images into extensions.
+      // The stub delegates to the host dashboard's asset resolver at runtime via window.__shell_requireAsset.
+      const requireAssetOverride = new webpack.NormalModuleReplacementPlugin(/require-asset$/, (resource) => {
+        resource.request = path.join(__dirname, 'require-asset.lib.js');
+      });
+
       // Auto-generate module to import the types (model, detail, edit etc)
       const autoImportPlugin = new VirtualModulesPlugin({ 'node_modules/@rancher/auto-import': generateTypeImport('@pkg', dir) });
 
       config.plugins.unshift(dynamicImporterOverride);
       config.plugins.unshift(modelLoaderImporterOverride);
+      config.plugins.unshift(requireAssetOverride);
       config.plugins.unshift(autoImportPlugin);
       config.plugins.unshift(new NodePolyfillPlugin()); // required from Webpack 5 to polyfill node modules
       // config.plugins.unshift(debug);

package/plugins/clean-html.d.ts

@@ -0,0 +1,9 @@
+import { Config } from 'dompurify';
+
+export function purifyHTML(value: string, options?: Config): string;
+
+export function addLinkInterceptor(fn: (link: string) => string | undefined | void, name?: string): void;
+
+export function removeLinkInterceptor(fn: (link: string) => string | undefined | void): void;
+
+export function processLink(link: string): string;

package/plugins/dashboard-store/__tests__/resource-class.test.ts

@@ -403,6 +403,99 @@ describe('class: Resource', () => {
 
       expect(cards).toHaveLength(0);
     });
+
+    it('should include the resources card when relationships exist', () => {
+      const resource = new Resource({
+        type:     'test',
+        metadata: {
+          relationships: [
+            {
+              rel: 'uses', toType: 'svc', toId: 'a'
+            },
+            {
+              rel: 'uses', fromType: 'pod', fromId: 'b'
+            },
+          ]
+        }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: {
+          'i18n/t':      (key: string) => key,
+          'cluster/all': () => []
+        },
+      });
+
+      const cards = resource.cards;
+
+      expect(cards).toHaveLength(1);
+      expect(cards[0].props.title).toBe('component.resource.detail.card.resourcesCard.title');
+    });
+  });
+
+  describe('getter: resourcesCard', () => {
+    it('should return null when there are no relationships', () => {
+      const resource = new Resource({ type: 'test' }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      expect(resource.resourcesCard).toBeNull();
+    });
+
+    it('should return rows for both referredToBy and refersTo when relationships exist in both directions', () => {
+      const resource = new Resource({
+        type:     'test',
+        metadata: {
+          relationships: [
+            {
+              rel: 'owner', fromType: 'rs', fromId: 'r-1'
+            },
+            {
+              rel: 'uses', toType: 'svc', toId: 's-1'
+            },
+            {
+              rel: 'uses', toType: 'svc', toId: 's-2'
+            },
+          ]
+        }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      const rows = resource.resourcesCardRows;
+
+      expect(rows).toHaveLength(2);
+      expect(rows[0].label).toBe('component.resource.detail.card.resourcesCard.rows.referredToBy');
+      expect(rows[0].counts[0].count).toBe(1);
+      expect(rows[1].label).toBe('component.resource.detail.card.resourcesCard.rows.refersTo');
+      expect(rows[1].counts[0].count).toBe(2);
+    });
+
+    it('should omit a direction with no relationships', () => {
+      const resource = new Resource({
+        type:     'test',
+        metadata: {
+          relationships: [
+            {
+              rel: 'uses', toType: 'svc', toId: 's-1'
+            },
+          ]
+        }
+      }, {
+        getters:     { schemaFor: () => ({ linkFor: jest.fn() }) },
+        dispatch:    jest.fn(),
+        rootGetters: { 'i18n/t': (key: string) => key },
+      });
+
+      const rows = resource.resourcesCardRows;
+
+      expect(rows).toHaveLength(1);
+      expect(rows[0].label).toBe('component.resource.detail.card.resourcesCard.rows.refersTo');
+    });
   });
 
   describe('getter: insightCardProps', () => {
@@ -585,4 +678,88 @@ describe('class: Resource', () => {
       expect(viewYaml.enabled).toBe(true);
     });
   });
+
+  describe('method: dryRunCreate', () => {
+    const collectionUrl = '/v1/test.resources';
+
+    it('should dispatch a request with dryRun=All query param', async() => {
+      const dispatch = jest.fn().mockResolvedValue({});
+      const resource = new Resource({
+        type:     'test.resource',
+        metadata: {
+          name:      'my-resource',
+          namespace: 'my-ns',
+        },
+      }, {
+        getters: {
+          schemaFor: () => ({
+            linkFor:    (link: string) => (link === 'collection' ? collectionUrl : ''),
+            attributes: { namespaced: true },
+          })
+        },
+        dispatch,
+        rootGetters: { 'i18n/t': jest.fn() },
+      });
+
+      await resource.dryRunCreate();
+
+      expect(dispatch).toHaveBeenCalledWith('request', {
+        opt: expect.objectContaining({
+          method: 'post',
+          url:    `${ collectionUrl }/my-ns?dryRun=All`,
+        }),
+        type: 'test.resource'
+      });
+    });
+
+    it('should use provided data instead of resource state when given', async() => {
+      const dispatch = jest.fn().mockResolvedValue({});
+      const resource = new Resource({
+        type:     'test.resource',
+        metadata: { name: 'original', namespace: 'ns' },
+      }, {
+        getters: {
+          schemaFor: () => ({
+            linkFor:    () => collectionUrl,
+            attributes: { namespaced: true },
+          })
+        },
+        dispatch,
+        rootGetters: { 'i18n/t': jest.fn() },
+      });
+
+      const customData = {
+        type:     'test.resource',
+        metadata: { name: 'custom' },
+        spec:     {}
+      };
+
+      await resource.dryRunCreate(customData);
+
+      expect(dispatch).toHaveBeenCalledWith('request', {
+        opt:  expect.objectContaining({ data: customData }),
+        type: 'test.resource'
+      });
+    });
+
+    it('should propagate API errors', async() => {
+      const apiError = { _status: 409, message: 'already exists' };
+      const dispatch = jest.fn().mockRejectedValue(apiError);
+      const resource = new Resource({
+        type:     'test.resource',
+        metadata: { name: 'dup', namespace: 'ns' },
+      }, {
+        getters: {
+          schemaFor: () => ({
+            linkFor:    () => collectionUrl,
+            attributes: { namespaced: true },
+          })
+        },
+        dispatch,
+        rootGetters: { 'i18n/t': jest.fn() },
+      });
+
+      await expect(resource.dryRunCreate()).rejects.toStrictEqual(apiError);
+    });
+  });
 });

package/plugins/dashboard-store/getters.js

@@ -278,7 +278,6 @@ export default {
     const schemas = state.types[SCHEMA];
 
     type = getters.normalizeType(type);
-
     if ( !schemas ) {
       if ( allowThrow ) {
         throw new Error("Schemas aren't loaded yet");

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

@@ -12,6 +12,7 @@ import {
   AS,
   MODE
 } from '@shell/config/query-params';
+import { EVENT } from '@shell/config/types';
 import { VIEW_IN_API, DEV } from '@shell/store/prefs';
 import { addObject, addObjects, findBy, removeAt } from '@shell/utils/array';
 import CustomValidators from '@shell/utils/custom-validators';
@@ -39,8 +40,7 @@ import { handleConflict } from '@shell/plugins/dashboard-store/normalize';
 import { ExtensionPoint, ActionLocation } from '@shell/core/types';
 import { getApplicableExtensionEnhancements } from '@shell/core/plugin-helpers';
 import { parse } from '@shell/utils/selector';
-import { EVENT } from '@shell/config/types';
-import { useResourceCardRow } from '@shell/components/Resource/Detail/Card/StateCard/composables';
+import { useResourceCardRow, useResourceCardRowFromRelationships } from '@shell/components/Resource/Detail/Card/StateCard/composables';
 
 export const DNS_LIKE_TYPES = ['dnsLabel', 'dnsLabelRestricted', 'hostname'];
 
@@ -79,6 +79,7 @@ export const STATES_ENUM = {
   BUILDING:         'building',
   COMPLETED:        'completed',
   CORDONED:         'cordoned',
+  CANCELLED:        'cancelled',
   COUNT:            'count',
   CREATED:          'created',
   CREATING:         'creating',
@@ -207,6 +208,9 @@ export const STATES = {
   [STATES_ENUM.CORDONED]: {
     color: 'info', icon: 'tag', label: 'Cordoned', compoundIcon: 'info'
   },
+  [STATES_ENUM.CANCELLED]: {
+    color: 'warning', icon: 'error', label: 'Cancelled', compoundIcon: 'warning'
+  },
   [STATES_ENUM.COUNT]: {
     color: 'success', icon: 'dot-open', label: 'Count', compoundIcon: 'checkmark'
   },
@@ -507,7 +511,11 @@ export function colorForState(state, isError, isTransitioning) {
   return `text-${ color }`;
 }
 
-export function stateDisplay(state) {
+export function simpleColorForState(state, isError = false, isTransitioning = false) {
+  return colorForState(state, isError, isTransitioning).replace('text-', '') || 'disabled';
+}
+
+export function stateDisplay(state, preserveOriginal = false) {
   // @TODO use translations
   const key = (state || 'active').toLowerCase();
 
@@ -515,6 +523,11 @@ export function stateDisplay(state) {
     return REMAP_STATE[key];
   }
 
+  // Preserves the original state name returned by the
+  if ( preserveOriginal ) {
+    return ucFirst(state);
+  }
+
   return key.split(/-/).map(ucFirst).join('-');
 }
 
@@ -754,7 +767,7 @@ export default class Resource {
   }
 
   get stateSimpleColor() {
-    return this.stateColor.replace('text-', '');
+    return simpleColorForState(this.state, this.stateObj?.error, this.stateObj?.transitioning);
   }
 
   get stateBackground() {
@@ -1182,6 +1195,46 @@ export default class Resource {
     return this._save(...arguments);
   }
 
+  _collectionUrl() {
+    const schema = this.$getters['schemaFor'](this.type);
+
+    if ( !schema ) {
+      // Schema not found - likely due to lack of permissions to view this resource type
+      throw new Error(`${ this.type }: ${ this.t('validation.createResourceFailed', { type: this.typeDisplay }, true) }`);
+    }
+
+    let url = schema.linkFor('collection');
+
+    if ( schema.attributes && schema.attributes.namespaced && this.metadata && this.metadata.namespace ) {
+      url += `/${ this.metadata.namespace }`;
+    }
+
+    return url;
+  }
+
+  async dryRunCreate(data) {
+    try {
+      const url = this._collectionUrl();
+      const separator = url.includes('?') ? '&' : '?';
+      const body = data || this.cleanForSave(this.toSave() || JSON.parse(JSON.stringify(this)), true);
+
+      return this.$dispatch('request', {
+        opt: {
+          method:  'post',
+          url:     `${ url }${ separator }dryRun=All`,
+          data:    body,
+          headers: {
+            'content-type': 'application/json',
+            accept:         'application/json'
+          }
+        },
+        type: this.type
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+
   /**
    * Remove any unwanted properties from the object that will be saved
    */
@@ -1210,20 +1263,16 @@ export default class Resource {
     if ( this.metadata?.resourceVersion ) {
       this.metadata.resourceVersion = `${ this.metadata.resourceVersion }`;
     }
-
-    if ( !opt.url ) {
-      if ( forNew ) {
-        const schema = this.$getters['schemaFor'](this.type);
-        let url = schema.linkFor('collection');
-
-        if ( schema.attributes && schema.attributes.namespaced && this.metadata && this.metadata.namespace ) {
-          url += `/${ this.metadata.namespace }`;
+    try {
+      if ( !opt.url ) {
+        if ( forNew ) {
+          opt.url = this._collectionUrl();
+        } else {
+          opt.url = this.linkFor('update') || this.linkFor('self');
         }
-
-        opt.url = url;
-      } else {
-        opt.url = this.linkFor('update') || this.linkFor('self');
       }
+    } catch (e) {
+      return Promise.reject(e);
     }
 
     if ( !opt.method ) {
@@ -2073,7 +2122,7 @@ export default class Resource {
 
       if ( r.selector ) {
         // A selector is a stringified version of a matchLabel (https://github.com/kubernetes/apimachinery/blob/master/pkg/labels/selector.go#L1010)
-        addObjects(out.selectors, {
+        addObject(out.selectors, {
           type:      r.toType,
           namespace: r.toNamespace,
           selector:  r.selector
@@ -2083,7 +2132,7 @@ export default class Resource {
         let namespace = r[`${ direction }Namespace`];
         let name = r[`${ direction }Id`];
 
-        if ( !namespace && name.includes('/') ) {
+        if ( !namespace && name?.includes('/') ) {
           const idx = name.indexOf('/');
 
           namespace = name.substr(0, idx);
@@ -2245,12 +2294,58 @@ export default class Resource {
     };
   }
 
+  get _resourcesCardRows() {
+    const rows = [];
+    const relationships = this.metadata?.relationships || [];
+
+    const referredToByRels = relationships.filter((r) => r.fromType && r.fromId && !r.selector);
+    const refersToRels = relationships.filter((r) => r.toType && r.toId && !r.selector && !r.fromType);
+
+    if (referredToByRels.length) {
+      rows.push(useResourceCardRowFromRelationships(
+        this.t('component.resource.detail.card.resourcesCard.rows.referredToBy'),
+        referredToByRels,
+        { hash: '#related' }
+      ));
+    }
+
+    if (refersToRels.length) {
+      rows.push(useResourceCardRowFromRelationships(
+        this.t('component.resource.detail.card.resourcesCard.rows.refersTo'),
+        refersToRels,
+        { hash: '#related' }
+      ));
+    }
+
+    return rows;
+  }
+
+  get resourcesCardRows() {
+    return this._resourcesCardRows;
+  }
+
+  get resourcesCard() {
+    const rows = this.resourcesCardRows;
+
+    if (!rows.length) {
+      return null;
+    }
+
+    return {
+      component: markRaw(defineAsyncComponent(() => import('@shell/components/Resource/Detail/Card/StateCard/index.vue'))),
+      props:     {
+        title: this.t('component.resource.detail.card.resourcesCard.title'),
+        rows
+      }
+    };
+  }
+
   get _cards() {
     // All cards are opt in, we're leaving the insights card as part of the base resource since it should proliferate to most resources
     return [];
   }
 
   get cards() {
-    return this._cards;
+    return [this.resourcesCard, ...this._cards].filter((c) => c);
   }
 }

package/plugins/steve/__tests__/actions.test.ts

@@ -0,0 +1,212 @@
+import actions from '@shell/plugins/steve/actions';
+import paginationUtils from '@shell/utils/pagination-utils';
+import stevePaginationUtils from '@shell/plugins/steve/steve-pagination-utils';
+import { PaginationParamFilter } from '@shell/types/store/pagination.types';
+
+const { fetchResourceSummary } = actions;
+
+describe('steve: actions:', () => {
+  describe('fetchResourceSummary', () => {
+    const schema = {
+      id:         'pod',
+      links:      { collection: '/v1/pods' },
+      attributes: { namespaced: true },
+    };
+
+    const baseCtx = () => ({
+      getters: {
+        normalizeType: (type: string) => type,
+        schemaFor:     (type: string) => (type === 'pod' ? schema : undefined),
+      },
+      dispatch:    jest.fn(),
+      rootGetters: {},
+    });
+
+    let warnSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      jest.spyOn(paginationUtils, 'isSteveCacheEnabled').mockReturnValue(true);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should return undefined and warn when schema is not found', async() => {
+      const ctx = baseCtx();
+      const result = await fetchResourceSummary.call({}, ctx, { type: 'nonexistent', opt: { summaryField: 'metadata.state.name' } });
+
+      expect(result).toBeUndefined();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('no schema found'));
+    });
+
+    it('should return undefined and warn when VAI is not enabled', async() => {
+      jest.spyOn(paginationUtils, 'isSteveCacheEnabled').mockReturnValue(false);
+      const ctx = baseCtx();
+      const result = await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name' } });
+
+      expect(result).toBeUndefined();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('VAI is not enabled'));
+    });
+
+    it('should return undefined and warn when summaryField is missing', async() => {
+      const ctx = baseCtx();
+      const result = await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: {} });
+
+      expect(result).toBeUndefined();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('summaryField is required'));
+    });
+
+    it('should construct the correct URL with summary and summaryonly params', async() => {
+      const ctx = baseCtx();
+
+      ctx.dispatch.mockResolvedValue({ count: 5, summary: [{ property: 'metadata.state.name', counts: { running: { total: 5 } } }] });
+
+      await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name' } });
+
+      const requestUrl = ctx.dispatch.mock.calls[0][1].opt.url;
+
+      expect(requestUrl).toContain('summary=metadata.state.name');
+      expect(requestUrl).toContain('summaryonly=');
+      expect(requestUrl).not.toContain('summarynamespaced');
+    });
+
+    it('should not include summaryonly when summaryOnly is false', async() => {
+      const ctx = baseCtx();
+
+      ctx.dispatch.mockResolvedValue({ count: 5, summary: [{ property: 'metadata.state.name', counts: { running: { total: 5 } } }] });
+
+      await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name', summaryOnly: false } });
+
+      const requestUrl = ctx.dispatch.mock.calls[0][1].opt.url;
+
+      expect(requestUrl).not.toContain('summaryonly');
+    });
+
+    it('should include summarynamespaced param when namespaceCounts is true', async() => {
+      const ctx = baseCtx();
+
+      ctx.dispatch.mockResolvedValue({ count: 5, summary: [{ property: 'metadata.state.name', counts: { running: { total: 5 } } }] });
+
+      await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name', namespaceCounts: true } });
+
+      const requestUrl = ctx.dispatch.mock.calls[0][1].opt.url;
+
+      expect(requestUrl).toContain('summarynamespaced=');
+    });
+
+    it('should append namespace to path for namespaced resources', async() => {
+      const ctx = baseCtx();
+
+      ctx.dispatch.mockResolvedValue({ count: 2, summary: null });
+
+      await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name', namespace: 'cattle-system' } });
+
+      const requestUrl = ctx.dispatch.mock.calls[0][1].opt.url;
+
+      expect(requestUrl).toMatch(/\/v1\/pods\/cattle-system\?/);
+    });
+
+    it('should not append namespace when schema is not namespaced', async() => {
+      const nonNsSchema = { ...schema, attributes: { namespaced: false } };
+      const ctx = baseCtx();
+
+      ctx.getters.schemaFor = () => nonNsSchema;
+      ctx.dispatch.mockResolvedValue({ count: 1, summary: null });
+
+      await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name', namespace: 'default' } });
+
+      const requestUrl = ctx.dispatch.mock.calls[0][1].opt.url;
+
+      expect(requestUrl).not.toContain('/default');
+    });
+
+    it('should append filter params when filters are provided', async() => {
+      const ctx = baseCtx();
+      const filters = [PaginationParamFilter.createSingleField({ field: 'metadata.namespace', value: 'default' })];
+
+      jest.spyOn(stevePaginationUtils, 'convertPaginationParams').mockReturnValue('filter=metadata.namespace%3Ddefault');
+      ctx.dispatch.mockResolvedValue({ count: 3, summary: null });
+
+      await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name', filters } });
+
+      const requestUrl = ctx.dispatch.mock.calls[0][1].opt.url;
+
+      expect(requestUrl).toContain('filter=');
+      expect(stevePaginationUtils.convertPaginationParams).toHaveBeenCalledWith(expect.objectContaining({ filters }));
+    });
+
+    it('should return count and summary from the response', async() => {
+      const ctx = baseCtx();
+      const apiResponse = {
+        count:   10,
+        summary: [{ property: 'metadata.state.name', counts: { running: { total: 7 }, error: { total: 3 } } }]
+      };
+
+      ctx.dispatch.mockResolvedValue(apiResponse);
+
+      const result = await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name' } });
+
+      expect(result).toStrictEqual(apiResponse);
+    });
+
+    it('should pass through object-style counts as-is', async() => {
+      const ctx = baseCtx();
+      const counts = { running: { total: 7 }, error: { total: 3 } };
+      const apiResponse = {
+        count:   10,
+        summary: [{ property: 'metadata.state.name', counts }]
+      };
+
+      ctx.dispatch.mockResolvedValue(apiResponse);
+
+      const result = await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name' } });
+
+      expect(result).toStrictEqual({
+        count:   10,
+        summary: [{ property: 'metadata.state.name', counts }]
+      });
+    });
+
+    it('should default count to 0 and summary to null when response is empty', async() => {
+      const ctx = baseCtx();
+
+      ctx.dispatch.mockResolvedValue({});
+
+      const result = await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name' } });
+
+      expect(result).toStrictEqual({ count: 0, summary: null });
+    });
+
+    it('should append label selector params when labelSelector is provided', async() => {
+      const ctx = baseCtx();
+      const labelSelector = {
+        matchExpressions: [{
+          key: 'app', operator: 'In', values: ['nginx']
+        }]
+      };
+
+      jest.spyOn(stevePaginationUtils, 'convertLabelSelectorPaginationParams').mockReturnValue('filter=metadata.labels[app] IN (nginx)');
+      ctx.dispatch.mockResolvedValue({ count: 2, summary: null });
+
+      await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name', labelSelector } });
+
+      const requestUrl = ctx.dispatch.mock.calls[0][1].opt.url;
+
+      expect(requestUrl).toContain('filter=');
+      expect(stevePaginationUtils.convertLabelSelectorPaginationParams).toHaveBeenCalledWith({ labelSelector });
+    });
+
+    it('should return undefined and warn when the request fails', async() => {
+      const ctx = baseCtx();
+
+      ctx.dispatch.mockRejectedValue(new Error('network error'));
+
+      const result = await fetchResourceSummary.call({}, ctx, { type: 'pod', opt: { summaryField: 'metadata.state.name' } });
+
+      expect(result).toBeUndefined();
+      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('summary API request failed'), expect.any(Error));
+    });
+  });
+});