@rancher/shell 3.0.11 → 3.0.12-rc.2

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

@@ -83,6 +83,11 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
 
   saveCountAs?: string,
 
+  /**
+   * When making a supporting HTTP request include associated resource data
+   */
+  includeAssociatedData?: boolean,
+
   /**
    * The target minimum revision for the resource.
    *

package/types/store/pagination.types.ts

@@ -607,6 +607,7 @@ export interface StorePaginationRequest {
    * The single namespace to filter results by (as part of url path, not pagination params)
    */
   namespace?: string,
+
   /**
    * The set of pagination args used to create the request
    */
@@ -616,6 +617,11 @@ export interface StorePaginationRequest {
    * Does this request stem from a list with manual refresh?
    */
   hasManualRefresh?: boolean,
+
+  /**
+   * When making a supporting HTTP request include associated resource data
+   */
+  includeAssociatedData?: boolean,
 }
 
 /**

package/utils/__tests__/git.test.ts

@@ -0,0 +1,270 @@
+import { GitUtils, Commit } from '@shell/utils/git';
+
+describe('git utils', () => {
+  describe('gitUtils.github.normalize.repo', () => {
+    it('maps owner fields from GitHub API response', () => {
+      const data = {
+        owner: {
+          login:      'octocat',
+          html_url:   'https://github.com/octocat',
+          avatar_url: 'https://avatars.githubusercontent.com/u/1?v=4'
+        },
+        description: 'Hello World',
+        created_at:  '2021-01-01T00:00:00Z',
+        updated_at:  '2021-06-01T00:00:00Z',
+        html_url:    'https://github.com/octocat/hello-world',
+        name:        'hello-world'
+      };
+
+      const result = GitUtils.github.normalize.repo(data);
+
+      expect(result.owner).toStrictEqual({
+        name:      'octocat',
+        htmlUrl:   'https://github.com/octocat',
+        avatarUrl: 'https://avatars.githubusercontent.com/u/1?v=4'
+      });
+    });
+
+    it('maps repo-level fields from GitHub API response', () => {
+      const data = {
+        owner: {
+          login: 'octocat', html_url: '', avatar_url: ''
+        },
+        description: 'A repository description',
+        created_at:  '2021-01-01T00:00:00Z',
+        updated_at:  '2022-03-15T12:00:00Z',
+        html_url:    'https://github.com/octocat/repo',
+        name:        'my-repo'
+      };
+
+      const result = GitUtils.github.normalize.repo(data);
+
+      expect(result.description).toStrictEqual('A repository description');
+      expect(result.created_at).toStrictEqual('2021-01-01T00:00:00Z');
+      expect(result.updated_at).toStrictEqual('2022-03-15T12:00:00Z');
+      expect(result.htmlUrl).toStrictEqual('https://github.com/octocat/repo');
+      expect(result.name).toStrictEqual('my-repo');
+    });
+
+    it('handles missing owner gracefully', () => {
+      const data = {
+        owner:       undefined,
+        description: 'No owner',
+        created_at:  '2021-01-01T00:00:00Z',
+        updated_at:  '2021-01-01T00:00:00Z',
+        html_url:    'https://github.com/no/owner',
+        name:        'no-owner'
+      };
+
+      const result = GitUtils.github.normalize.repo(data);
+
+      expect(result.owner).toStrictEqual({
+        name:      undefined,
+        htmlUrl:   undefined,
+        avatarUrl: undefined
+      });
+    });
+  });
+
+  describe('gitUtils.github.normalize.commit', () => {
+    it('maps commit fields from GitHub API response', () => {
+      const data = {
+        commit: {
+          message:   'fix: resolve issue',
+          committer: { date: '2022-01-15T10:30:00Z' }
+        },
+        html_url: 'https://github.com/octocat/repo/commit/abc1234567890',
+        sha:      'abc1234567890abcdef',
+        author:   {
+          login:      'octocat',
+          avatar_url: 'https://avatars.githubusercontent.com/u/1?v=4',
+          htmlUrl:    'https://github.com/octocat'
+        }
+      };
+
+      const result = GitUtils.github.normalize.commit(data);
+
+      expect(result.message).toStrictEqual('fix: resolve issue');
+      expect(result.htmlUrl).toStrictEqual('https://github.com/octocat/repo/commit/abc1234567890');
+      expect(result.sha).toStrictEqual('abc1234');
+      expect(result.commitId).toStrictEqual('abc1234567890abcdef');
+      expect(result.date).toStrictEqual('2022-01-15T10:30:00Z');
+      expect(result.isChecked).toStrictEqual(false);
+    });
+
+    it('truncates sha to 7 characters', () => {
+      const data = {
+        commit:   { message: 'chore: update deps', committer: { date: '2022-01-01T00:00:00Z' } },
+        html_url: 'https://github.com/octocat/repo/commit/1234567890',
+        sha:      '1234567890abcdef1234',
+        author:   {
+          login: 'user', avatar_url: '', htmlUrl: ''
+        }
+      };
+
+      const result = GitUtils.github.normalize.commit(data);
+
+      expect(result.sha).toStrictEqual('1234567');
+    });
+
+    it('returns undefined sha when sha is empty string', () => {
+      const data = {
+        commit:   { message: 'fix: bug', committer: { date: '2022-01-01T00:00:00Z' } },
+        html_url: 'https://github.com/octocat/repo/commit/x',
+        sha:      '',
+        author:   {
+          login: 'user', avatar_url: '', htmlUrl: ''
+        }
+      };
+
+      const result: Commit = GitUtils.github.normalize.commit(data);
+
+      expect(result.sha).toBeUndefined();
+    });
+
+    it('maps author fields from GitHub API response', () => {
+      const data = {
+        commit:   { message: 'feat: new feature', committer: { date: '2022-01-01T00:00:00Z' } },
+        html_url: 'https://github.com/octocat/repo/commit/abc',
+        sha:      'abcdef1234567890',
+        author:   {
+          login:      'contributor',
+          avatar_url: 'https://avatars.githubusercontent.com/u/2?v=4',
+          htmlUrl:    'https://github.com/contributor'
+        }
+      };
+
+      const result = GitUtils.github.normalize.commit(data);
+
+      expect(result.author).toStrictEqual({
+        name:      'contributor',
+        avatarUrl: 'https://avatars.githubusercontent.com/u/2?v=4',
+        htmlUrl:   'https://github.com/contributor'
+      });
+    });
+  });
+
+  describe('gitUtils.gitlab.normalize.repo', () => {
+    it('maps owner fields from GitLab API response', () => {
+      const data = {
+        namespace: {
+          name:       'my-group',
+          web_url:    'https://gitlab.com/my-group',
+          avatar_url: 'https://gitlab.com/uploads/group.png'
+        },
+        description:      'GitLab repo description',
+        created_at:       '2021-02-01T00:00:00Z',
+        last_activity_at: '2022-07-20T00:00:00Z',
+        web_url:          'https://gitlab.com/my-group/project',
+        name:             'project'
+      };
+
+      const result = GitUtils.gitlab.normalize.repo(data);
+
+      expect(result.owner).toStrictEqual({
+        name:      'my-group',
+        htmlUrl:   'https://gitlab.com/my-group',
+        avatarUrl: 'https://gitlab.com/uploads/group.png'
+      });
+    });
+
+    it('maps repo-level fields from GitLab API response', () => {
+      const data = {
+        namespace: {
+          name: 'ns', web_url: '', avatar_url: ''
+        },
+        description:      'My GitLab project',
+        created_at:       '2020-05-01T00:00:00Z',
+        last_activity_at: '2023-01-10T00:00:00Z',
+        web_url:          'https://gitlab.com/ns/myproject',
+        name:             'myproject'
+      };
+
+      const result = GitUtils.gitlab.normalize.repo(data);
+
+      expect(result.description).toStrictEqual('My GitLab project');
+      expect(result.created_at).toStrictEqual('2020-05-01T00:00:00Z');
+      expect(result.updated_at).toStrictEqual('2023-01-10T00:00:00Z');
+      expect(result.htmlUrl).toStrictEqual('https://gitlab.com/ns/myproject');
+      expect(result.name).toStrictEqual('myproject');
+    });
+
+    it('maps updated_at from last_activity_at (not updated_at)', () => {
+      const data = {
+        namespace: {
+          name: 'ns', web_url: '', avatar_url: ''
+        },
+        description:      '',
+        created_at:       '2020-01-01T00:00:00Z',
+        last_activity_at: '2023-06-15T08:00:00Z',
+        updated_at:       'should-be-ignored',
+        web_url:          'https://gitlab.com/ns/proj',
+        name:             'proj'
+      };
+
+      const result = GitUtils.gitlab.normalize.repo(data);
+
+      expect(result.updated_at).toStrictEqual('2023-06-15T08:00:00Z');
+    });
+  });
+
+  describe('gitUtils.gitlab.normalize.commit', () => {
+    it('maps commit fields from GitLab API response', () => {
+      const data = {
+        message:        'refactor: clean up code',
+        web_url:        'https://gitlab.com/ns/proj/-/commit/abc1234',
+        short_id:       'abc1234',
+        id:             'abc1234567890abcdef',
+        author_name:    'Jane Doe',
+        avatar_url:     'https://gitlab.com/uploads/jane.png',
+        committed_date: '2022-03-10T14:00:00Z'
+      };
+
+      const result = GitUtils.gitlab.normalize.commit(data);
+
+      expect(result.message).toStrictEqual('refactor: clean up code');
+      expect(result.htmlUrl).toStrictEqual('https://gitlab.com/ns/proj/-/commit/abc1234');
+      expect(result.sha).toStrictEqual('abc1234');
+      expect(result.commitId).toStrictEqual('abc1234567890abcdef');
+      expect(result.date).toStrictEqual('2022-03-10T14:00:00Z');
+      expect(result.isChecked).toStrictEqual(false);
+    });
+
+    it('maps author fields from GitLab API response', () => {
+      const data = {
+        message:        'feat: add feature',
+        web_url:        'https://gitlab.com/ns/proj/-/commit/xyz',
+        short_id:       'xyz',
+        id:             'xyzabcdef',
+        author_name:    'John Smith',
+        avatar_url:     'https://gitlab.com/uploads/john.png',
+        committed_date: '2022-04-01T00:00:00Z'
+      };
+
+      const result = GitUtils.gitlab.normalize.commit(data);
+
+      expect(result.author).toStrictEqual({
+        name:      'John Smith',
+        avatarUrl: 'https://gitlab.com/uploads/john.png',
+        htmlUrl:   'https://gitlab.com/ns/proj/-/commit/xyz'
+      });
+    });
+
+    it('uses web_url for both htmlUrl and author.htmlUrl', () => {
+      const data = {
+        message:        'fix: something',
+        web_url:        'https://gitlab.com/ns/proj/-/commit/def456',
+        short_id:       'def456',
+        id:             'def456abc',
+        author_name:    'Dev',
+        avatar_url:     '',
+        committed_date: '2022-01-01T00:00:00Z'
+      };
+
+      const result = GitUtils.gitlab.normalize.commit(data);
+
+      expect(result.htmlUrl).toStrictEqual('https://gitlab.com/ns/proj/-/commit/def456');
+      expect((result.author as any).htmlUrl).toStrictEqual('https://gitlab.com/ns/proj/-/commit/def456');
+    });
+  });
+});

package/utils/__tests__/inactivity.test.ts

@@ -0,0 +1,316 @@
+import { Inactivity } from '@shell/utils/inactivity';
+
+describe('inactivity', () => {
+  describe('inactivity class', () => {
+    let inactivity: Inactivity;
+
+    beforeEach(() => {
+      inactivity = new Inactivity();
+    });
+
+    describe('getSessionTokenName', () => {
+      it('returns undefined by default', () => {
+        expect(inactivity.getSessionTokenName()).toBeUndefined();
+      });
+
+      it('returns the token name after setSessionTokenName', () => {
+        inactivity.setSessionTokenName('my-token');
+        expect(inactivity.getSessionTokenName()).toStrictEqual('my-token');
+      });
+    });
+
+    describe('setSessionTokenName', () => {
+      it('sets the session token name', () => {
+        inactivity.setSessionTokenName('token-abc');
+        expect(inactivity.getSessionTokenName()).toStrictEqual('token-abc');
+      });
+
+      it('overwrites a previously set token name', () => {
+        inactivity.setSessionTokenName('first');
+        inactivity.setSessionTokenName('second');
+        expect(inactivity.getSessionTokenName()).toStrictEqual('second');
+      });
+    });
+
+    describe('getUserActivity', () => {
+      it('dispatches management/find with correct parameters', async() => {
+        const mockResult = { status: { expiresAt: '2026-01-01T00:00:00Z' } };
+        const mockStore = { dispatch: jest.fn().mockResolvedValue(mockResult) };
+
+        const result = await inactivity.getUserActivity(mockStore, 'my-token');
+
+        expect(mockStore.dispatch).toHaveBeenCalledWith('management/find', {
+          type: 'ext.cattle.io.useractivity',
+          id:   'my-token',
+          opt:  {
+            force: true, watch: false, logoutOnError: false
+          }
+        });
+        expect(result).toStrictEqual(mockResult);
+      });
+
+      it('passes force=false when specified', async() => {
+        const mockResult = { status: { expiresAt: '2026-01-01T00:00:00Z' } };
+        const mockStore = { dispatch: jest.fn().mockResolvedValue(mockResult) };
+
+        await inactivity.getUserActivity(mockStore, 'my-token', false);
+
+        expect(mockStore.dispatch).toHaveBeenCalledWith('management/find', {
+          type: 'ext.cattle.io.useractivity',
+          id:   'my-token',
+          opt:  {
+            force: false, watch: false, logoutOnError: false
+          }
+        });
+      });
+
+      it('dispatches auth/logout with sessionIdle=true on 401 error', async() => {
+        const mockStore = {
+          dispatch: jest.fn()
+            .mockRejectedValueOnce({ _status: 401 })
+            .mockResolvedValue('logged out')
+        };
+
+        const result = await inactivity.getUserActivity(mockStore, 'my-token');
+
+        expect(mockStore.dispatch).toHaveBeenCalledWith('auth/logout', { sessionIdle: true });
+        expect(result).toStrictEqual('logged out');
+      });
+
+      it('re-throws non-401 errors', async() => {
+        const mockStore = { dispatch: jest.fn().mockRejectedValue({ _status: 500, message: 'Server Error' }) };
+
+        await expect(inactivity.getUserActivity(mockStore, 'my-token')).rejects.toThrow(Error);
+      });
+    });
+
+    describe('updateUserActivity', () => {
+      it('sets spec with tokenId and seenAt and calls save', async() => {
+        const mockSaved = { status: { expiresAt: '2026-01-01T00:00:00Z' } };
+        const mockResource: any = { save: jest.fn().mockResolvedValue(mockSaved) };
+
+        const result = await inactivity.updateUserActivity(mockResource, 'my-token', '2026-01-01T00:00:00Z');
+
+        expect(mockResource.spec).toStrictEqual({
+          tokenId: 'my-token',
+          seenAt:  '2026-01-01T00:00:00Z'
+        });
+        expect(mockResource.save).toHaveBeenCalledWith({ force: true });
+        expect(result).toStrictEqual(mockSaved);
+      });
+
+      it('omits seenAt from spec when empty string', async() => {
+        const mockSaved = { status: { expiresAt: '2026-01-01T00:00:00Z' } };
+        const mockResource: any = { save: jest.fn().mockResolvedValue(mockSaved) };
+
+        await inactivity.updateUserActivity(mockResource, 'my-token', '');
+
+        expect(mockResource.spec).toStrictEqual({ tokenId: 'my-token' });
+      });
+
+      it('re-throws errors from save', async() => {
+        const mockResource: any = { save: jest.fn().mockRejectedValue(new Error('save failed')) };
+
+        await expect(inactivity.updateUserActivity(mockResource, 'my-token', '2026-01-01T00:00:00Z')).rejects.toThrow(Error);
+      });
+    });
+
+    describe('parseTTLData', () => {
+      afterEach(() => {
+        jest.restoreAllMocks();
+      });
+
+      it('returns expiresAt from userActivityData.status', () => {
+        const expiresAt = '2030-01-01T01:00:00.000Z';
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.expiresAt).toStrictEqual(expiresAt);
+      });
+
+      it('returns sessionTokenName from userActivityData.metadata.name', () => {
+        const expiresAt = '2030-01-01T01:00:00.000Z';
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-abc' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.sessionTokenName).toStrictEqual('token-abc');
+      });
+
+      it('calculates courtesyTimer as 20% of threshold, capped at 300s', () => {
+        // 1 hour = 3600 seconds; threshold = 3600 - 3 = 3597s
+        // courtesyTimerVal = floor(3597 * 0.2) = floor(719.4) = 719
+        // courtesyTimer = min(719, 300) = 300
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+        const expiresAt = new Date(now + 3600 * 1000).toISOString(); // 1 hour later
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.courtesyTimer).toStrictEqual(300);
+      });
+
+      it('calculates courtesyTimer as 20% when under 300s cap', () => {
+        // 100 seconds until expiry; threshold = 100 - 3 = 97s
+        // courtesyTimerVal = floor(97 * 0.2) = floor(19.4) = 19
+        // courtesyTimer = min(19, 300) = 19
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+        const expiresAt = new Date(now + 100 * 1000).toISOString();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.courtesyTimer).toStrictEqual(19);
+      });
+
+      it('courtesyCountdown equals courtesyTimer', () => {
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+        const expiresAt = new Date(now + 100 * 1000).toISOString();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.courtesyCountdown).toStrictEqual(result.courtesyTimer);
+      });
+
+      it('calculates showModalAfter = thresholdSeconds - courtesyTimer', () => {
+        // 100s; threshold = 97s; courtesyTimer = 19s; showModalAfter = 97 - 19 = 78
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+        const expiresAt = new Date(now + 100 * 1000).toISOString();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.showModalAfter).toStrictEqual(78);
+      });
+
+      it('calculates showModalAfter correctly with large TTL (1 hour)', () => {
+        // 3600s; threshold = 3597s; courtesyTimer = 300s (capped); showModalAfter = 3597 - 300 = 3297
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+        const expiresAt = new Date(now + 3600 * 1000).toISOString();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.showModalAfter).toStrictEqual(3297);
+      });
+
+      it('handles expired session (negative thresholdSeconds)', () => {
+        // Already expired by 10 seconds; threshold = -10 - 3 = -13s
+        // courtesyTimerVal = floor(-13 * 0.2) = floor(-2.6) = -3
+        // courtesyTimer = min(-3, 300) = -3
+        // showModalAfter = -13 - (-3) = -10
+        const now = new Date('2030-01-01T00:00:10.000Z').getTime();
+        const expiresAt = new Date('2030-01-01T00:00:00.000Z').toISOString();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.courtesyTimer).toStrictEqual(-3);
+        expect(result.showModalAfter).toStrictEqual(-10);
+      });
+
+      it('returns undefined for expiresAt when status.expiresAt is absent', () => {
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   {},
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.expiresAt).toBeUndefined();
+      });
+
+      it('returns undefined for sessionTokenName when metadata.name is absent', () => {
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+        const expiresAt = new Date(now + 100 * 1000).toISOString();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: {}
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.sessionTokenName).toBeUndefined();
+      });
+
+      it('handles exactly 5 minute threshold (boundary: courtesyTimer not capped)', () => {
+        // 300s; threshold = 300 - 3 = 297s
+        // courtesyTimerVal = floor(297 * 0.2) = floor(59.4) = 59
+        // courtesyTimer = min(59, 300) = 59
+        const now = new Date('2030-01-01T00:00:00.000Z').getTime();
+        const expiresAt = new Date(now + 300 * 1000).toISOString();
+
+        jest.spyOn(Date, 'now').mockReturnValue(now);
+
+        const data: any = {
+          status:   { expiresAt },
+          metadata: { name: 'token-1' }
+        };
+
+        const result = inactivity.parseTTLData(data);
+
+        expect(result.courtesyTimer).toStrictEqual(59);
+        expect(result.showModalAfter).toStrictEqual(238);
+      });
+    });
+  });
+});