@rancher/shell 3.0.12-rc.3 → 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__/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/TopLevelMenu.vue

@@ -12,6 +12,7 @@ import { KEY } from '@shell/utils/platform';
 import { getVersionInfo } from '@shell/utils/version';
 import { SETTING } from '@shell/config/settings';
 import { getProductFromRoute } from '@shell/utils/router';
+import { NAME as EXPLORER } from '@shell/config/product/explorer';
 import { isRancherPrime } from '@shell/config/version';
 import Pinned from '@shell/components/nav/Pinned';
 import sideNavService from '@shell/components/nav/TopLevelMenu.helper';
@@ -99,7 +100,7 @@ export default {
     },
 
     routeComboActive() {
-      if (!this.routeCombo) {
+      if (!this.routeCombo || !this.isCurrRouteClusterExplorer) {
         return false;
       }
 
@@ -237,7 +238,7 @@ export default {
     },
 
     isCurrRouteClusterExplorer() {
-      return this.$route?.name?.startsWith('c-cluster');
+      return this.$route?.name?.startsWith('c-cluster') && this.productFromRoute === EXPLORER;
     },
 
     productFromRoute() {
@@ -393,6 +394,10 @@ export default {
     },
 
     handleKeyComboClick() {
+      if (!this.isCurrRouteClusterExplorer) {
+        return;
+      }
+
       this.routeCombo = !this.routeCombo;
     },
 

package/components/nav/__tests__/Header.test.ts

@@ -157,6 +157,21 @@ describe('component: Header', () => {
 
       expect((wrapper.vm as any).disableWorkspaceSwitcher).toBe(true);
     });
+
+    it.each([
+      ['c-cluster-fleet-application-appco-credentials', '/c/local/fleet/application/suse-app-collection/credentials'],
+      ['c-cluster-fleet-application-appco-charts', '/c/local/fleet/application/suse-app-collection/charts'],
+      ['c-cluster-fleet-application-appco-chart', '/c/local/fleet/application/suse-app-collection/chart'],
+    ])('should disable Workspace Switcher on AppCo page %s (via route meta)', (name, path) => {
+      const wrapper = createWrapper({
+        name,
+        path,
+        params: {},
+        meta:   { disableWorkspaceSwitcher: true },
+      });
+
+      expect((wrapper.vm as any).disableWorkspaceSwitcher).toBe(true);
+    });
   });
 
   describe('showFilter', () => {