@rancher/shell 3.0.12-rc.1 → 3.0.12-rc.2

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);
+      });
+    });
+  });
+});

package/utils/__tests__/object.test.ts

@@ -210,6 +210,83 @@ describe('fx: diff', () => {
 
     expect(result).toStrictEqual(expected);
   });
+  it('should preserve nested object values when transitioning from empty object to populated object', () => {
+    const from = { parent: { child: { config: {} } } };
+    const to = {
+      parent: {
+        child: {
+          config: {
+            annotations: { hello: 'world' },
+            labels:      { key: 'value' }
+          }
+        }
+      }
+    };
+
+    const result = diff(from, to);
+    const expected = {
+      parent: {
+        child: {
+          config: {
+            annotations: { hello: 'world' },
+            labels:      { key: 'value' }
+          }
+        }
+      }
+    };
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should preserve explicit empty object when clearing nested object values', () => {
+    const from = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+    const to = { parent: { child: { config: {} } } };
+
+    const result = diff(from, to);
+    const expected = { parent: { child: { config: {} } } };
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should not emit nested empty objects when there are no differences', () => {
+    const from = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+    const to = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+
+    const result = diff(from, to);
+    const expected = {};
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should correctly nullify nested keys when removed', () => {
+    const from = {
+      parent: {
+        child: {
+          config: {
+            annotations: { hello: 'world' },
+            labels:      { key: 'value' }
+          }
+        }
+      }
+    };
+    const to = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+
+    const result = diff(from, to);
+    const expected = { parent: { child: { config: { labels: { key: null } } } } };
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should not nullify child keys when parent object is updated', () => {
+    const from = { parent: { child: { config: {} } } };
+    const to = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+
+    const result = diff(from, to);
+    const expected = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+
+    expect(result).toStrictEqual(expected);
+    expect(result.parent.child.config).not.toHaveProperty('annotations', null);
+  });
 });
 
 describe('fx: definedKeys', () => {

package/utils/__tests__/time.test.ts

@@ -1,6 +1,19 @@
 import { DATE_FORMAT, TIME_FORMAT } from '@shell/store/prefs';
-import { dateTimeFormat } from '@shell/utils/time';
+import { dateTimeFormat, isMissingDate } from '@shell/utils/time';
 import { type Store } from 'vuex';
+import { ZERO_TIME } from '@shell/config/types';
+
+describe('function: isMissingDate', () => {
+  it.each([
+    [undefined, true],
+    [null, true],
+    ['', true],
+    [ZERO_TIME, true],
+    ['2010-10-21T04:29:00Z', false],
+  ])('given %p, returns %p', (date, expected) => {
+    expect(isMissingDate(date)).toBe(expected);
+  });
+});
 
 describe('function: dateTimeFormat', () => {
   jest.useFakeTimers()

package/utils/__tests__/url.test.ts

@@ -0,0 +1,246 @@
+import {
+  addParam, addParams, removeParam, parseLinkHeader, isMaybeSecure, portMatch, parse, stringify
+} from '@shell/utils/url';
+
+describe('fx: addParam', () => {
+  it('should add a query parameter to a URL without existing params', () => {
+    expect(addParam('https://example.com/path', 'foo', 'bar')).toStrictEqual('https://example.com/path?foo=bar');
+  });
+
+  it('should append a query parameter to a URL with existing params', () => {
+    expect(addParam('https://example.com/path?a=1', 'b', '2')).toStrictEqual('https://example.com/path?a=1&b=2');
+  });
+
+  it('should encode special characters in key and value', () => {
+    expect(addParam('https://example.com', 'my key', 'hello world')).toStrictEqual('https://example.com?my%20key=hello%20world');
+  });
+
+  it('should add multiple values from an array', () => {
+    expect(addParam('https://example.com', 'tag', ['a', 'b'])).toStrictEqual('https://example.com?tag=a&tag=b');
+  });
+
+  it('should add a key-only param when value is null', () => {
+    expect(addParam('https://example.com', 'flag', null)).toStrictEqual('https://example.com?flag');
+  });
+
+  it('should handle an array with a null value', () => {
+    expect(addParam('https://example.com', 'flag', [null])).toStrictEqual('https://example.com?flag');
+  });
+
+  it('should add a param with an empty string value', () => {
+    expect(addParam('https://example.com', 'key', '')).toStrictEqual('https://example.com?key=');
+  });
+
+  it('should add a duplicate key as an additional param', () => {
+    expect(addParam('https://example.com?a=1', 'a', '2')).toStrictEqual('https://example.com?a=1&a=2');
+  });
+});
+
+describe('fx: addParams', () => {
+  it('should add multiple parameters to a URL', () => {
+    expect(addParams('https://example.com', { a: '1', b: '2' })).toStrictEqual('https://example.com?a=1&b=2');
+  });
+
+  it('should return the URL unchanged if params is empty', () => {
+    expect(addParams('https://example.com', {})).toStrictEqual('https://example.com');
+  });
+
+  it('should return the URL unchanged if params is null', () => {
+    expect(addParams('https://example.com', null)).toStrictEqual('https://example.com');
+  });
+
+  it('should return the URL unchanged if params is a non-object value', () => {
+    expect(addParams('https://example.com', 'not-an-object')).toStrictEqual('https://example.com');
+  });
+});
+
+describe('fx: removeParam', () => {
+  it('should remove a query parameter from a URL', () => {
+    expect(removeParam('https://example.com?foo=bar&baz=qux', 'foo')).toStrictEqual('https://example.com/?baz=qux');
+  });
+
+  it('should return a normalized URL if the param does not exist', () => {
+    expect(removeParam('https://example.com?a=1', 'nonexistent')).toStrictEqual('https://example.com/?a=1');
+  });
+
+  it('should remove the only query parameter', () => {
+    expect(removeParam('https://example.com?only=param', 'only')).toStrictEqual('https://example.com/');
+  });
+
+  it('should normalize a key-only query parameter to key= (parser treats it as empty value)', () => {
+    expect(removeParam('https://example.com?flag', 'flag')).toStrictEqual('https://example.com/?flag=');
+  });
+});
+
+describe('fx: parseLinkHeader', () => {
+  it('should parse a single link header entry', () => {
+    expect(parseLinkHeader('<https://example.com/page2>; rel="next"')).toStrictEqual({ next: 'https://example.com/page2' });
+  });
+
+  it('should parse multiple link header entries', () => {
+    const header = '<https://example.com/page2>; rel="next", <https://example.com/page1>; rel="prev"';
+
+    expect(parseLinkHeader(header)).toStrictEqual({
+      next: 'https://example.com/page2',
+      prev: 'https://example.com/page1',
+    });
+  });
+
+  it('should return an empty object for an empty string', () => {
+    expect(parseLinkHeader('')).toStrictEqual({});
+  });
+
+  it('should return an empty object for a malformed header', () => {
+    expect(parseLinkHeader('not a valid link header')).toStrictEqual({});
+  });
+
+  it('should lowercase the rel value', () => {
+    expect(parseLinkHeader('<https://example.com>; rel="Next"')).toStrictEqual({ next: 'https://example.com' });
+  });
+});
+
+describe('fx: portMatch', () => {
+  it.each([
+    {
+      ports: [443], equals: [443, 8443], endsWith: [], expected: true, desc: 'port is in the equals list'
+    },
+    {
+      ports: [8080], equals: [443, 8443], endsWith: ['443'], expected: false, desc: 'port is not in equals or endsWith lists'
+    },
+    {
+      ports: [8443], equals: [], endsWith: ['443'], expected: true, desc: 'port string ends with the given suffix'
+    },
+    {
+      ports: [443], equals: [], endsWith: ['443'], expected: false, desc: 'port equals the suffix exactly (endsWith excludes exact match)'
+    },
+    {
+      ports: [], equals: [443], endsWith: ['443'], expected: false, desc: 'ports array is empty'
+    },
+    {
+      ports: [80, 443], equals: [443], endsWith: [], expected: true, desc: 'any port in the array matches equals'
+    },
+    {
+      ports: [18443], equals: [], endsWith: ['443'], expected: true, desc: 'multi-digit port ending with suffix'
+    },
+  ])('should return $expected when $desc', ({
+    ports, equals, endsWith, expected
+  }) => {
+    expect(portMatch(ports, equals, endsWith)).toBe(expected);
+  });
+});
+
+describe('fx: isMaybeSecure', () => {
+  it.each([
+    {
+      port: 80, proto: 'https', expected: true, desc: 'https protocol'
+    },
+    {
+      port: 80, proto: 'HTTPS', expected: true, desc: 'HTTPS protocol (case-insensitive)'
+    },
+    {
+      port: 443, proto: 'http', expected: true, desc: 'port 443'
+    },
+    {
+      port: 8443, proto: 'http', expected: true, desc: 'port 8443'
+    },
+    {
+      port: 18443, proto: 'http', expected: true, desc: 'port 18443 (endsWith 443)'
+    },
+    {
+      port: 80, proto: 'http', expected: false, desc: 'http on non-secure port'
+    },
+  ])('should return $expected for $desc', ({ port, proto, expected }) => {
+    expect(isMaybeSecure(port, proto)).toBe(expected);
+  });
+});
+
+describe('fx: parse', () => {
+  it('should parse a simple URL', () => {
+    const result = parse('https://example.com/path?foo=bar');
+
+    expect(result.protocol).toStrictEqual('https');
+    expect(result.host).toStrictEqual('example.com');
+    expect(result.path).toStrictEqual('/path');
+    expect(result.query).toStrictEqual({ foo: 'bar' });
+  });
+
+  it('should parse a URL with port', () => {
+    const result = parse('https://example.com:8080/');
+
+    expect(result.host).toStrictEqual('example.com');
+    expect(result.port).toStrictEqual('8080');
+  });
+
+  it('should parse a URL with user credentials', () => {
+    const result = parse('https://user:pass@example.com/');
+
+    expect(result.user).toStrictEqual('user');
+    expect(result.password).toStrictEqual('pass');
+  });
+
+  it('should parse a URL with anchor', () => {
+    const result = parse('https://example.com/page#section1');
+
+    expect(result.anchor).toStrictEqual('section1');
+  });
+
+  it('should parse a URL with multiple query params', () => {
+    expect(parse('https://example.com?a=1&b=2').query).toStrictEqual({ a: '1', b: '2' });
+  });
+
+  it('should parse a URL with user only (no password)', () => {
+    const result = parse('https://admin@example.com/');
+
+    expect(result.user).toStrictEqual('admin');
+    expect(result.password).toStrictEqual('');
+  });
+
+  it('should set empty strings for missing optional fields', () => {
+    const result = parse('https://example.com/path');
+
+    expect(result.port).toStrictEqual('');
+    expect(result.anchor).toStrictEqual('');
+    expect(result.user).toStrictEqual('');
+    expect(result.password).toStrictEqual('');
+  });
+});
+
+describe('fx: stringify', () => {
+  it('should reconstruct a simple URL', () => {
+    expect(stringify(parse('https://example.com/path'))).toStrictEqual('https://example.com/path');
+  });
+
+  it('should include user and password when both present', () => {
+    expect(stringify(parse('https://user:pass@example.com/'))).toStrictEqual('https://user:pass@example.com/');
+  });
+
+  it('should include user only when password is absent', () => {
+    expect(stringify(parse('https://admin@example.com/'))).toStrictEqual('https://admin@example.com/');
+  });
+
+  it('should include port when present', () => {
+    expect(stringify(parse('https://example.com:9090/'))).toStrictEqual('https://example.com:9090/');
+  });
+
+  it('should include anchor when present', () => {
+    expect(stringify(parse('https://example.com/page#section'))).toStrictEqual('https://example.com/page#section');
+  });
+
+  it('should default path to / when path is empty', () => {
+    const parsed = parse('https://example.com');
+
+    parsed.path = '';
+
+    expect(stringify(parsed)).toStrictEqual('https://example.com/');
+  });
+
+  it('should include query parameters', () => {
+    expect(stringify(parse('https://example.com/path?a=1&b=2'))).toStrictEqual('https://example.com/path?a=1&b=2');
+  });
+
+  it('should round-trip a complex URL', () => {
+    const url = 'https://user:pass@example.com:8080/some/path?key=value&other=test#anchor';
+
+    expect(stringify(parse(url))).toStrictEqual(url);
+  });
+});