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

package/components/formatter/__tests__/InternalExternalIP.test.ts

@@ -113,6 +113,39 @@ describe('component: InternalExternalIP', () => {
     });
   });
 
+  describe('fallback to singular IPs', () => {
+    it('should use singular externalIp and internalIp when arrays are not present', () => {
+      const wrapper = mountComponent({ row: { externalIp: '1.1.1.1', internalIp: '2.2.2.2' } });
+
+      expect(wrapper.vm.filteredExternalIps).toStrictEqual(['1.1.1.1']);
+      expect(wrapper.vm.filteredInternalIps).toStrictEqual(['2.2.2.2']);
+      expect(wrapper.find('[data-testid="external-ip"]').text()).toStrictEqual('1.1.1.1');
+      expect(wrapper.find('[data-testid="internal-ip"]').text()).toStrictEqual('2.2.2.2');
+    });
+
+    it('should ignore generic.none value for externalIp', () => {
+      // Assuming the mock translation for 'generic.none' returns 'generic.none'
+      const wrapper = mountComponent({ row: { externalIp: 'generic.none', internalIp: '2.2.2.2' } });
+
+      expect(wrapper.vm.filteredExternalIps).toStrictEqual([]);
+      expect(wrapper.vm.filteredInternalIps).toStrictEqual(['2.2.2.2']);
+    });
+
+    it('should prioritize array properties over singular strings', () => {
+      const wrapper = mountComponent({
+        row: {
+          externalIps: ['3.3.3.3'],
+          externalIp:  '1.1.1.1',
+          internalIps: ['4.4.4.4'],
+          internalIp:  '2.2.2.2'
+        }
+      });
+
+      expect(wrapper.vm.filteredExternalIps).toStrictEqual(['3.3.3.3']);
+      expect(wrapper.vm.filteredInternalIps).toStrictEqual(['4.4.4.4']);
+    });
+  });
+
   describe('invalid IPs', () => {
     it('should filter invalid IPs', () => {
       const wrapper = mountComponent({ row: { externalIps: ['1.1.1.1', 'not-an-ip'], internalIps: ['2.2.2.2'] } });
@@ -122,6 +155,105 @@ describe('component: InternalExternalIP', () => {
     });
   });
 
+  describe('isIp validation', () => {
+    describe('valid IPv4 addresses', () => {
+      it.each([
+        ['0.0.0.0'],
+        ['1.1.1.1'],
+        ['127.0.0.1'],
+        ['192.168.1.1'],
+        ['10.0.0.1'],
+        ['255.255.255.255'],
+        ['172.16.0.1'],
+      ])('should accept %s as a valid IP', (ip) => {
+        const wrapper = mountComponent({ row: { externalIps: [ip], internalIps: [] } });
+
+        expect(wrapper.vm.filteredExternalIps).toStrictEqual([ip]);
+        expect(wrapper.find('[data-testid="external-ip"]').text()).toStrictEqual(ip);
+      });
+    });
+
+    describe('valid IPv6 addresses', () => {
+      it.each([
+        ['::1'],
+        ['::'],
+        ['fe80::1'],
+        ['2001:0db8:85a3:0000:0000:8a2e:0370:7334'],
+        ['2001:db8::1'],
+        ['::ffff:192.168.1.1'],
+      ])('should accept %s as a valid IP', (ip) => {
+        const wrapper = mountComponent({ row: { externalIps: [ip], internalIps: [] } });
+
+        expect(wrapper.vm.filteredExternalIps).toStrictEqual([ip]);
+        expect(wrapper.find('[data-testid="external-ip"]').text()).toStrictEqual(ip);
+      });
+    });
+
+    describe('invalid values', () => {
+      it.each([
+        ['not-an-ip'],
+        ['abc.def.ghi.jkl'],
+        ['999.999.999.999'],
+        ['1.2.3'],
+        ['1.2.3.4.5'],
+        [''],
+        ['hello'],
+        ['192.168.1'],
+        ['192.168.1.1.1'],
+        ['1.2.3.4/24'],
+      ])('should reject %s as an invalid IP', (ip) => {
+        const wrapper = mountComponent({ row: { externalIps: [ip], internalIps: [] } });
+
+        expect(wrapper.vm.filteredExternalIps).toStrictEqual([]);
+        expect(wrapper.find('[data-testid="external-ip"]').exists()).toBe(false);
+      });
+    });
+
+    it('should filter invalid IPs from internal IPs list', () => {
+      const wrapper = mountComponent({ row: { externalIps: [], internalIps: ['10.0.0.1', 'bad-ip', '192.168.1.1'] } });
+
+      expect(wrapper.vm.filteredInternalIps).toStrictEqual(['10.0.0.1', '192.168.1.1']);
+      expect(wrapper.find('[data-testid="internal-ip"]').text()).toStrictEqual('10.0.0.1');
+      expect(wrapper.vm.remainingIpCount).toStrictEqual(1);
+    });
+
+    it('should filter all invalid IPs leaving no results', () => {
+      const wrapper = mountComponent({ row: { externalIps: ['not-valid', 'also-bad'], internalIps: ['nope'] } });
+
+      expect(wrapper.vm.filteredExternalIps).toStrictEqual([]);
+      expect(wrapper.vm.filteredInternalIps).toStrictEqual([]);
+      expect(wrapper.find('[data-testid="external-ip"]').exists()).toBe(false);
+      expect(wrapper.find('[data-testid="internal-ip"]').exists()).toBe(false);
+    });
+
+    it('should handle mixed valid and invalid IPs preserving only valid ones', () => {
+      const wrapper = mountComponent({
+        row: {
+          externalIps: ['1.1.1.1', 'garbage', '8.8.8.8', '999.0.0.1'],
+          internalIps: ['10.0.0.1', '', '172.16.0.1', 'abc']
+        }
+      });
+
+      expect(wrapper.vm.filteredExternalIps).toStrictEqual(['1.1.1.1', '8.8.8.8']);
+      expect(wrapper.vm.filteredInternalIps).toStrictEqual(['10.0.0.1', '172.16.0.1']);
+      expect(wrapper.find('[data-testid="external-ip"]').text()).toStrictEqual('1.1.1.1');
+      expect(wrapper.find('[data-testid="internal-ip"]').text()).toStrictEqual('10.0.0.1');
+      expect(wrapper.vm.remainingIpCount).toStrictEqual(2);
+    });
+
+    it('should handle undefined externalIps gracefully', () => {
+      const wrapper = mountComponent({ row: { internalIps: ['1.1.1.1'] } });
+
+      expect(wrapper.vm.filteredExternalIps).toStrictEqual([]);
+    });
+
+    it('should handle undefined internalIps gracefully', () => {
+      const wrapper = mountComponent({ row: { externalIps: ['1.1.1.1'] } });
+
+      expect(wrapper.vm.filteredInternalIps).toStrictEqual([]);
+    });
+  });
+
   describe('tooltip', () => {
     it('should display the correct tooltip text', () => {
       const wrapper = mountComponent({ row: { externalIps: ['1.1.1.1', '3.3.3.3'], internalIps: ['2.2.2.2', '4.4.4.4'] } });

package/components/formatter/__tests__/PodsUsage.test.ts

@@ -7,11 +7,9 @@ describe('component: PodsUsage', () => {
       props: {
         row: {
           isReady: true,
-          mgmt:    {
-            status: {
-              requested:   { pods: 10 },
-              allocatable: { pods: 20 }
-            }
+          status:  {
+            requested:   { pods: 10 },
+            allocatable: { pods: 20 }
           }
         }
       },
@@ -28,11 +26,9 @@ describe('component: PodsUsage', () => {
       props: {
         row: {
           isReady: true,
-          mgmt:    {
-            status: {
-              requested:   { pods: 10 },
-              allocatable: { pods: 0 }
-            }
+          status:  {
+            requested:   { pods: 10 },
+            allocatable: { pods: 0 }
           }
         }
       },

package/components/formatter/__tests__/ServiceTargets.test.ts

@@ -0,0 +1,412 @@
+import { shallowMount } from '@vue/test-utils';
+import ServiceTargets from '@shell/components/formatter/ServiceTargets.vue';
+
+describe('component: ServiceTargets', () => {
+  const proxyUrl = (scheme: string, port: number) => `https://rancher.test/k8s/clusters/local/api/v1/namespaces/default/services/${ scheme }:test-service:${ port }/proxy`;
+
+  function createRow(overrides: Record<string, any> = {}) {
+    return {
+      metadata: { annotations: {}, ...overrides.metadata },
+      spec:     {
+        clusterIP: '10.43.0.100',
+        ports:     [],
+        type:      'ClusterIP',
+        ...overrides.spec,
+      },
+      proxyUrl,
+    };
+  }
+
+  function mountComponent(row: Record<string, any>) {
+    return shallowMount(ServiceTargets, {
+      props: {
+        value: null,
+        row,
+        col:   {},
+      },
+      global: { directives: { 'clean-html': () => {} } },
+    });
+  }
+
+  describe('default port handling', () => {
+    it.each([
+      ['80', 80],
+      ['443', 443],
+      ['8080', 8080],
+      ['8443', 8443],
+    ])('should generate a clickable link for TCP port %s', (_label, port) => {
+      const row = createRow({
+        spec: {
+          ports: [{
+            port, protocol: 'TCP', targetPort: port
+          }]
+        }
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toContain('<a href=');
+      expect(parsed[0].label).toContain(`proxy`);
+    });
+
+    it.each([
+      ['3000', 3000],
+      ['9090', 9090],
+      ['5000', 5000],
+    ])('should NOT generate a clickable link for TCP port %s without annotation', (_label, port) => {
+      const row = createRow({
+        spec: {
+          ports: [{
+            port, protocol: 'TCP', targetPort: port
+          }]
+        }
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).not.toContain('<a href=');
+    });
+
+    it('should NOT generate a clickable link for non-TCP protocol', () => {
+      const row = createRow({
+        spec: {
+          ports: [{
+            port: 80, protocol: 'UDP', targetPort: 80
+          }]
+        }
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).not.toContain('<a href=');
+    });
+  });
+
+  describe('service-links annotation', () => {
+    it('should generate a clickable link for a port listed in the annotation', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000' } },
+        spec:     {
+          ports: [{
+            port: 3000, protocol: 'TCP', targetPort: 3000
+          }]
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toContain('<a href=');
+      expect(parsed[0].label).toContain('http:test-service:3000');
+    });
+
+    it('should generate clickable links for multiple ports in the annotation', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000,9090' } },
+        spec:     {
+          ports: [
+            {
+              port: 3000, protocol: 'TCP', targetPort: 3000
+            },
+            {
+              port: 9090, protocol: 'TCP', targetPort: 9090
+            },
+            {
+              port: 5000, protocol: 'TCP', targetPort: 5000
+            },
+          ],
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(3);
+      expect(parsed[0].label).toContain('<a href=');
+      expect(parsed[1].label).toContain('<a href=');
+      expect(parsed[2].label).not.toContain('<a href=');
+    });
+
+    it('should still generate links for default ports (80, 443) even without annotation', () => {
+      const row = createRow({
+        spec: {
+          ports: [
+            {
+              port: 80, protocol: 'TCP', targetPort: 80
+            },
+            {
+              port: 443, protocol: 'TCP', targetPort: 443
+            },
+          ],
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(2);
+      expect(parsed[0].label).toContain('<a href=');
+      expect(parsed[1].label).toContain('<a href=');
+    });
+
+    it('should handle whitespace in the annotation value', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': ' 3000 , 9090 ' } },
+        spec:     {
+          ports: [
+            {
+              port: 3000, protocol: 'TCP', targetPort: 3000
+            },
+            {
+              port: 9090, protocol: 'TCP', targetPort: 9090
+            },
+          ],
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(2);
+      expect(parsed[0].label).toContain('<a href=');
+      expect(parsed[1].label).toContain('<a href=');
+    });
+
+    it('should handle an empty annotation value gracefully', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '' } },
+        spec:     {
+          ports: [{
+            port: 3000, protocol: 'TCP', targetPort: 3000
+          }]
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).not.toContain('<a href=');
+    });
+
+    it('should ignore non-numeric values in the annotation', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000,abc,9090' } },
+        spec:     {
+          ports: [
+            {
+              port: 3000, protocol: 'TCP', targetPort: 3000
+            },
+            {
+              port: 9090, protocol: 'TCP', targetPort: 9090
+            },
+          ],
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(2);
+      expect(parsed[0].label).toContain('<a href=');
+      expect(parsed[1].label).toContain('<a href=');
+    });
+
+    it('should not generate a link for annotated port with non-TCP protocol', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000' } },
+        spec:     {
+          ports: [{
+            port: 3000, protocol: 'UDP', targetPort: 3000
+          }]
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).not.toContain('<a href=');
+    });
+
+    it('should use https scheme for annotated port that isMaybeSecure considers secure', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '8443' } },
+        spec:     {
+          ports: [{
+            port: 8443, protocol: 'TCP', targetPort: 8443
+          }]
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toContain('https:test-service:8443');
+    });
+
+    it('should use http scheme for annotated port that is not secure', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000' } },
+        spec:     {
+          ports: [{
+            port: 3000, protocol: 'TCP', targetPort: 3000
+          }]
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toContain('http:test-service:3000');
+    });
+
+    it('should use explicit https scheme from annotation even for non-secure port', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000/https' } },
+        spec:     {
+          ports: [{
+            port: 3000, protocol: 'TCP', targetPort: 3000
+          }]
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toContain('https:test-service:3000');
+    });
+
+    it('should use explicit http scheme from annotation even for secure port', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '8443/http' } },
+        spec:     {
+          ports: [{
+            port: 8443, protocol: 'TCP', targetPort: 8443
+          }]
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toContain('http:test-service:8443');
+    });
+
+    it('should not add port 0 from trailing comma in annotation', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000,' } },
+        spec:     {
+          ports: [
+            {
+              port: 3000, protocol: 'TCP', targetPort: 3000
+            },
+            {
+              port: 0, protocol: 'TCP', targetPort: 0
+            },
+          ],
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(2);
+      expect(parsed[0].label).toContain('<a href=');
+      expect(parsed[1].label).not.toContain('<a href=');
+    });
+
+    it('should fall back to isMaybeSecure for invalid scheme values', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000/ftp' } },
+        spec:     {
+          ports: [{
+            port: 3000, protocol: 'TCP', targetPort: 3000
+          }]
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toContain('http:test-service:3000');
+    });
+
+    it('should handle mixed format with and without explicit scheme', () => {
+      const row = createRow({
+        metadata: { annotations: { 'ui.rancher/service-links': '3000/https,9090' } },
+        spec:     {
+          ports: [
+            {
+              port: 3000, protocol: 'TCP', targetPort: 3000
+            },
+            {
+              port: 9090, protocol: 'TCP', targetPort: 9090
+            },
+          ],
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(2);
+      expect(parsed[0].label).toContain('https:test-service:3000');
+      expect(parsed[1].label).toContain('http:test-service:9090');
+    });
+  });
+
+  describe('empty ports', () => {
+    it('should show clusterIP when ports are empty', () => {
+      const row = createRow({ spec: { clusterIP: '10.43.0.100', ports: [] } });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toBe('10.43.0.100:');
+    });
+
+    it('should show externalName for ExternalName service type', () => {
+      const row = createRow({
+        spec: {
+          clusterIP:    '',
+          ports:        [],
+          type:         'ExternalName',
+          externalName: 'my.external.service',
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed).toHaveLength(1);
+      expect(parsed[0].label).toBe('my.external.service');
+    });
+  });
+
+  describe('port label formatting', () => {
+    it('should use port name when available in clickable link', () => {
+      const row = createRow({
+        spec: {
+          ports: [{
+            port: 80, protocol: 'TCP', targetPort: 80, name: 'http-web',
+          }],
+        },
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed[0].label).toContain('>http-web</a>');
+    });
+
+    it('should include target port and protocol in label', () => {
+      const row = createRow({
+        spec: {
+          ports: [{
+            port: 3000, protocol: 'TCP', targetPort: 8080
+          }]
+        }
+      });
+      const wrapper = mountComponent(row);
+      const parsed = (wrapper.vm as any).parsed;
+
+      expect(parsed[0].label).toContain('10.43.0.100:3000');
+      expect(parsed[0].label).toContain('8080');
+      expect(parsed[0].label).toContain('/TCP');
+    });
+  });
+});

package/components/nav/Header.vue

@@ -210,6 +210,10 @@ export default {
         return true;
       }
 
+      if (this.$route?.meta?.disableWorkspaceSwitcher) {
+        return true;
+      }
+
       return false;
     },
 

package/components/nav/NamespaceFilter.vue

@@ -1005,8 +1005,8 @@ export default {
     .ns-filter-clear {
       cursor: pointer;
       position: absolute;
-      right: 10px;
-      top: 10px;
+      right: 12px;
+      top: 5px;
       line-height: 24px;
       text-align: center;
       width: 14px;

package/components/nav/TopLevelMenu.helper.ts

@@ -35,7 +35,18 @@ interface UpdateArgs {
 }
 
 type MgmtCluster = {
-  [key: string]: any
+  [key: string]: any,
+  id: string,
+  nameDisplay: string,
+  canExplore: boolean,
+  providerMenuLogo: string,
+  badge: string,
+  iconColor: string,
+  isLocal: boolean,
+  pinned: boolean,
+  description: string,
+  pin: () => void
+  unpin: () => void
 }
 
 type ProvCluster = {
@@ -148,7 +159,8 @@ export abstract class BaseTopLevelMenuHelper {
     return {
       id:              mgmtCluster.id,
       label:           mgmtCluster.nameDisplay,
-      ready:           mgmtCluster.isReady,
+      // Align side nav cluster, home page name link and cluster management cluster explore buttons on canExplore
+      ready:           mgmtCluster.canExplore,
       providerNavLogo: mgmtCluster.providerMenuLogo,
       badge:           mgmtCluster.badge,
       iconColor:       mgmtCluster.iconColor,
@@ -488,7 +500,7 @@ export class TopLevelMenuHelperLegacy extends BaseTopLevelMenuHelper implements
     const maxClustersToShow = args.unPinnedMax || 10;
 
     const search = (clusterFilter || '').toLowerCase();
-    let localCluster: MgmtCluster | null = null;
+    let localCluster: TopLevelMenuCluster | null = null;
 
     const filtered = clusters.filter((c) => {
       // If we're searching we don't care if pinned or not