@rancher/shell 3.0.8 → 3.0.9-rc.2

package/utils/__tests__/error.test.ts

@@ -0,0 +1,44 @@
+import { formatAWSError } from '@shell/utils/error';
+const SOME_ERROR = 'Some error';
+
+describe('formatAWSError', () => {
+  it('should return the extracted reason when error is a TypeError and message includes "Deserialization error:"', () => {
+    const error = Object.assign(new TypeError("Cannot read property of undefined (reading 'Error'): Deserialization error:"), { $response: { reason: SOME_ERROR } });
+
+    const result = formatAWSError(error);
+
+    expect(result).toBe(SOME_ERROR);
+  });
+
+  it('should return the original error if it is not an instance of TypeError', () => {
+    const error = Object.assign(new Error('...Deserialization error:'), { $response: { reason: SOME_ERROR } });
+
+    const result = formatAWSError(error);
+
+    expect(result).toBe(error);
+  });
+
+  it('should return the original error if the message does not contain "Deserialization error:"', () => {
+    const error = Object.assign(new TypeError('Some other type error occurred'), { $response: { reason: SOME_ERROR } });
+
+    const result = formatAWSError(error);
+
+    expect(result).toBe(error);
+  });
+
+  it('should return the original input if it is a plain object (not an Error instance)', () => {
+    const error = {
+      message:   'Deserialization error:',
+      $response: { reason: 'Should not be returned' }
+    };
+
+    const result = formatAWSError(error);
+
+    expect(result).toBe(error);
+  });
+
+  it('should return null or undefined as-is without crashing', () => {
+    expect(formatAWSError(null)).toBeNull();
+    expect(formatAWSError(undefined)).toBeUndefined();
+  });
+});

package/utils/__tests__/fleet.test.ts

@@ -123,10 +123,17 @@ describe('fx: util.getTargetMode', () => {
     expect(util.getTargetMode(targets, namespace)).toBe('clusters');
   });
 
-  it('should return "advanced" if one target has clusterGroup but others have clusterName or clusterSelector', () => {
+  it('should return "clusters" 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('clusters');
+  });
+
+  it('should return "advanced" if one target has clusterGroupSelector but others have clusterName or clusterSelector', () => {
+    const targets = [{ clusterName: 'cluster-x' }, { clusterGroupSelector: {} }, { clusterSelector: { matchLabels: { env: 'prod' } } }];
+    const namespace = 'ws1';
+
     expect(util.getTargetMode(targets, namespace)).toBe('advanced');
   });
 

package/utils/__tests__/pagination-wrapper.test.ts

@@ -0,0 +1,167 @@
+import PaginationWrapper from '@shell/utils/pagination-wrapper';
+import paginationUtils from '@shell/utils/pagination-utils';
+import backOff from '@shell/utils/back-off';
+import { STEVE_RESPONSE_CODE } from '@shell/types/rancher/steve.api';
+
+jest.mock('@shell/utils/pagination-utils');
+jest.mock('@shell/utils/back-off');
+
+describe('paginationWrapper', () => {
+  let store: any;
+  let args: any;
+
+  beforeEach(() => {
+    store = {
+      getters:    {},
+      dispatch:   jest.fn(),
+      $extension: {}
+    };
+    args = {
+      $store:     store,
+      id:         'test-id',
+      enabledFor: {
+        store:    'management',
+        resource: {
+          id:      'cluster',
+          context: 'side-bar'
+        }
+      },
+      onChange: jest.fn(),
+    };
+
+    (paginationUtils.isEnabled as jest.Mock).mockReturnValue(true);
+    (backOff.getBackOff as jest.Mock).mockReturnValue(undefined);
+    (backOff.recurse as jest.Mock).mockImplementation(async({ delayedFn }) => {
+      return await delayedFn();
+    });
+    (backOff.reset as jest.Mock).mockImplementation();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should initialize correctly', () => {
+    const wrapper = new PaginationWrapper(args);
+
+    expect(wrapper.isEnabled).toBe(true);
+    expect(paginationUtils.isEnabled).toHaveBeenCalledWith({ rootGetters: store.getters, $extension: store.$extension }, args.enabledFor);
+  });
+
+  it('request should throw if not enabled', async() => {
+    (paginationUtils.isEnabled as jest.Mock).mockReturnValue(false);
+    const wrapper = new PaginationWrapper(args);
+
+    await expect(wrapper.request({ pagination: {} as any })).rejects.toThrow('not supported');
+  });
+
+  it('request should handle HA scenario 1,2 case 1: active revision newer than target', async() => {
+    (backOff.getBackOff as jest.Mock).mockReturnValue({ metadata: { revision: '10' } });
+    const wrapper = new PaginationWrapper(args);
+
+    await expect(wrapper.request({ pagination: {} as any, revision: '5' })).rejects.toThrow('Ignoring current request');
+  });
+
+  it('request should handle HA scenario 1,2 case 2: cached revision newer than target', async() => {
+    const wrapper = new PaginationWrapper(args);
+
+    // Mock internal state if possible or simulate a previous request
+    // Since cachedRevision is private, we can simulate it by making a request first
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '10' } }, data: [] });
+    await wrapper.request({ pagination: {} as any, revision: '10' }); // Sets cachedRevision to 10
+
+    await expect(wrapper.request({ pagination: {} as any, revision: '5' })).resolves.toBeDefined(); // Should return cached result
+    // Note: The implementation warns but returns cachedResult if available.
+  });
+
+  it('request should handle HA scenario 1,2 case 3: target revision newer than current', async() => {
+    (backOff.getBackOff as jest.Mock).mockReturnValue({ metadata: { revision: '5' } });
+    const wrapper = new PaginationWrapper(args);
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '10' } }, data: [] });
+    await wrapper.request({ pagination: {} as any, revision: '10' });
+
+    expect(backOff.reset).toHaveBeenCalledWith('test-id');
+  });
+
+  it('request should call backOff.recurse and dispatch findPage', async() => {
+    const wrapper = new PaginationWrapper(args);
+    const pagination = { page: 1 } as any;
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '1' } }, data: [] });
+
+    await wrapper.request({ pagination });
+
+    expect(backOff.recurse).toHaveBeenCalledWith(expect.objectContaining({
+      id:       'test-id',
+      metadata: { revision: undefined }
+    }));
+    expect(store.dispatch).toHaveBeenCalledWith('management/findPage', expect.objectContaining({
+      opt:  expect.objectContaining({ pagination }),
+      type: 'cluster'
+    }));
+  });
+
+  it('request should setup watch on first call if onChange provided', async() => {
+    const wrapper = new PaginationWrapper(args);
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '1' } }, data: [] });
+
+    await wrapper.request({ pagination: {} as any });
+
+    expect(store.dispatch).toHaveBeenCalledWith('management/watchEvent', expect.objectContaining({
+      id:     'test-id',
+      params: expect.objectContaining({ type: 'cluster' })
+    }));
+  });
+
+  it('request should classify data if requested', async() => {
+    args.formatResponse = { classify: true };
+    const wrapper = new PaginationWrapper(args);
+    const rawData = [{ id: '1' }];
+    const classifiedData = [{ id: '1', _classified: true }];
+
+    store.dispatch.mockImplementation((action: string) => {
+      if (action === 'management/findPage') {
+        return { pagination: { result: { revision: '1' } }, data: rawData };
+      }
+      if (action === 'management/createMany') {
+        return classifiedData;
+      }
+    });
+
+    const res = await wrapper.request({ pagination: {} as any });
+
+    expect(res.data).toStrictEqual(classifiedData);
+    expect(store.dispatch).toHaveBeenCalledWith('management/createMany', rawData);
+  });
+
+  it('onDestroy should unwatch', async() => {
+    const wrapper = new PaginationWrapper(args);
+
+    store.dispatch.mockResolvedValue({ pagination: { result: { revision: '1' } }, data: [] });
+
+    await wrapper.request({ pagination: {} as any }); // Setup watch
+    await wrapper.onDestroy();
+
+    expect(store.dispatch).toHaveBeenCalledWith('management/unwatchEvent', expect.objectContaining({ id: 'test-id' }));
+  });
+
+  describe('backOff configuration', () => {
+    it('continueOnError should return true for UNKNOWN_REVISION', async() => {
+      const wrapper = new PaginationWrapper(args);
+
+      store.dispatch.mockResolvedValue({ pagination: { result: { revision: '1' } }, data: [] });
+
+      await wrapper.request({ pagination: {} as any });
+
+      const recurseCall = (backOff.recurse as jest.Mock).mock.calls[0][0];
+      const continueOnError = recurseCall.continueOnError;
+
+      expect(await continueOnError({ status: 200 })).toBe(false);
+      expect(await continueOnError({ status: 400, code: STEVE_RESPONSE_CODE.UNKNOWN_REVISION })).toBe(true);
+      expect(await continueOnError({ status: 500 })).toBe(false);
+    });
+  });
+});

package/utils/__tests__/version.test.ts

@@ -1,4 +1,4 @@
-import { isDevBuild, isUpgradeFromPreToStable } from '@shell/utils/version';
+import { isDevBuild, isUpgradeFromPreToStable, getReleaseNotesURL } from '@shell/utils/version';
 
 describe('fx: isDevBuild', () => {
   it.each([
@@ -34,3 +34,57 @@ describe('fx: isUpgradeFromPreToStable', () => {
     expect(isUpgradeFromPreToStable('1.0.0-rc1', '1.0.0-rc2')).toBe(false);
   });
 });
+
+describe('fx: getReleaseNotesURL', () => {
+  describe('when version is not provided', () => {
+    it('should return the community dev URL', () => {
+      expect(getReleaseNotesURL(false, undefined)).toBe('https://github.com/rancher/rancher/releases/latest');
+      expect(getReleaseNotesURL(false, '')).toBe('https://github.com/rancher/rancher/releases/latest');
+      expect(getReleaseNotesURL(true, undefined)).toBe('https://github.com/rancher/rancher/releases/latest');
+    });
+  });
+
+  describe('community (non-prime) URLs', () => {
+    it('should return dev URL for dev builds', () => {
+      expect(getReleaseNotesURL(false, 'dev')).toBe('https://github.com/rancher/rancher/releases/latest');
+      expect(getReleaseNotesURL(false, 'master')).toBe('https://github.com/rancher/rancher/releases/latest');
+      expect(getReleaseNotesURL(false, 'head')).toBe('https://github.com/rancher/rancher/releases/latest');
+      expect(getReleaseNotesURL(false, '2.8.0-head')).toBe('https://github.com/rancher/rancher/releases/latest');
+      expect(getReleaseNotesURL(false, '2.8.0-rc1')).toBe('https://github.com/rancher/rancher/releases/latest');
+      expect(getReleaseNotesURL(false, '2.8.0-alpha1')).toBe('https://github.com/rancher/rancher/releases/latest');
+    });
+
+    it('should return release URL with version for stable releases', () => {
+      expect(getReleaseNotesURL(false, '2.8.0')).toBe('https://github.com/rancher/rancher/releases/tag/v2.8.0');
+      expect(getReleaseNotesURL(false, '2.8.1')).toBe('https://github.com/rancher/rancher/releases/tag/v2.8.1');
+      expect(getReleaseNotesURL(false, '2.10.3')).toBe('https://github.com/rancher/rancher/releases/tag/v2.10.3');
+    });
+
+    it('should handle version with v prefix', () => {
+      expect(getReleaseNotesURL(false, 'v2.8.0')).toBe('https://github.com/rancher/rancher/releases/tag/v2.8.0');
+      expect(getReleaseNotesURL(false, 'v2.10.3')).toBe('https://github.com/rancher/rancher/releases/tag/v2.10.3');
+    });
+  });
+
+  describe('prime URLs', () => {
+    it('should return dev URL for dev builds', () => {
+      expect(getReleaseNotesURL(true, 'dev')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/latest/en/release-notes.html');
+      expect(getReleaseNotesURL(true, 'master')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/latest/en/release-notes.html');
+      expect(getReleaseNotesURL(true, 'head')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/latest/en/release-notes.html');
+      expect(getReleaseNotesURL(true, '2.8.0-head')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/latest/en/release-notes.html');
+      expect(getReleaseNotesURL(true, '2.8.0-rc1')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/latest/en/release-notes.html');
+      expect(getReleaseNotesURL(true, '2.8.0-alpha1')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/latest/en/release-notes.html');
+    });
+
+    it('should return release URL with version and major.minor for stable releases', () => {
+      expect(getReleaseNotesURL(true, '2.8.0')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/v2.8/en/release-notes/v2.8.0.html');
+      expect(getReleaseNotesURL(true, '2.8.1')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/v2.8/en/release-notes/v2.8.1.html');
+      expect(getReleaseNotesURL(true, '2.10.3')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/v2.10/en/release-notes/v2.10.3.html');
+    });
+
+    it('should handle version with v prefix', () => {
+      expect(getReleaseNotesURL(true, 'v2.8.0')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/v2.8/en/release-notes/v2.8.0.html');
+      expect(getReleaseNotesURL(true, 'v2.10.3')).toBe('https://documentation.suse.com/cloudnative/rancher-manager/v2.10/en/release-notes/v2.10.3.html');
+    });
+  });
+});

package/utils/azure.js

@@ -1,5 +1,6 @@
 const AZURE_ERROR_MSG_REGEX = /^.*Message=\"(.*)\"$/;
 const AZURE_ERROR_JSON_REGEX = /^.*Response body: ({.*})/;
+const AZURE_ERROR_JSON_REGEX_MULTILINE = /({[\s\S]*"error":[\s\S]*})/;
 
 export const parseAzureError = (err) => {
   // Try and parse the response from Azure a couple of ways
@@ -17,6 +18,17 @@ export const parseAzureError = (err) => {
         return errorObj.error_description;
       } catch (e) {}
     }
+    const jsonMatchMultiline = err.match(AZURE_ERROR_JSON_REGEX_MULTILINE);
+
+    if (jsonMatchMultiline?.length === 2) {
+      try {
+        const errorObj = JSON.parse(jsonMatchMultiline[1]);
+
+        if (errorObj?.error?.message) {
+          return errorObj.error.message;
+        }
+      } catch (e) {}
+    }
   }
 
   // Can't parse error