@rancher/shell 3.0.12-rc.3 → 3.0.12-rc.5

package/components/form/__tests__/SelectOrCreateAuthSecret.test.ts

@@ -66,4 +66,126 @@ describe('component: SelectOrCreateAuthSecret', () => {
 
     expect(passwordLabeledInput!.props('labelKey')).toBe(expectedLabelKey);
   });
+
+  describe('GitHub App auth', () => {
+    const githubAppSetup = () => mount(SelectOrCreateAuthSecret, {
+      ...requiredSetup(),
+      props: {
+        mode:               _EDIT,
+        namespace:          'default',
+        value:              {},
+        allowGithubApp:     true,
+        registerBeforeHook: () => {},
+      },
+      data() {
+        return { selected: AUTH_TYPE._GITHUB_APP } as any;
+      }
+    });
+
+    it('should render the three GitHub App fields when selected', () => {
+      const wrapper = githubAppSetup();
+
+      expect(wrapper.find('[data-testid="auth-secret-github-app-id"]').exists()).toBe(true);
+      expect(wrapper.find('[data-testid="auth-secret-github-app-installation-id"]').exists()).toBe(true);
+      expect(wrapper.find('[data-testid="auth-secret-github-app-private-key"]').exists()).toBe(true);
+      expect(wrapper.find('[data-testid="auth-secret-github-app-private-key-file"]').exists()).toBe(true);
+    });
+
+    it('should not narrow the select column for GitHub App (keeps span-6)', () => {
+      const wrapper = githubAppSetup();
+
+      expect((wrapper.vm as any).firstCol).toBe('col span-6');
+    });
+
+    it('should emit inputauthval with the GitHub App field values', async() => {
+      const wrapper = githubAppSetup();
+
+      await wrapper.setData({
+        githubAppId:             'app-id',
+        githubAppInstallationId: 'installation-id',
+        githubAppPrivateKey:     'private-key',
+      });
+
+      const emitted = wrapper.emitted('inputauthval') as any[];
+      const last = emitted[emitted.length - 1][0];
+
+      expect(last).toStrictEqual({
+        selected:                AUTH_TYPE._GITHUB_APP,
+        publicKey:               '',
+        privateKey:              '',
+        githubAppId:             'app-id',
+        githubAppInstallationId: 'installation-id',
+        githubAppPrivateKey:     'private-key',
+      });
+    });
+
+    it('should populate the private key when a file is read', async() => {
+      const wrapper = githubAppSetup();
+
+      const fileSelector = wrapper.findComponent({ name: 'FileSelector' });
+
+      await fileSelector.vm.$emit('selected', 'key-from-file');
+
+      expect((wrapper.vm as any).githubAppPrivateKey).toBe('key-from-file');
+    });
+
+    it.each([
+      ['offer', true],
+      ['not offer', false],
+    ])('should %s the GitHub App create option when allowGithubApp is %p', (_, allowGithubApp) => {
+      const wrapper = mount(SelectOrCreateAuthSecret, {
+        ...requiredSetup(),
+        props: {
+          mode:               _EDIT,
+          namespace:          'default',
+          value:              {},
+          allowGithubApp,
+          registerBeforeHook: () => {},
+        },
+      });
+
+      const hasGithubAppOption = (wrapper.vm as any).options
+        .some((o: any) => o.value === AUTH_TYPE._GITHUB_APP);
+
+      expect(hasGithubAppOption).toBe(allowGithubApp);
+    });
+
+    it('should list existing GitHub App secrets but exclude plain Opaque secrets', () => {
+      const githubAppSecret = {
+        _type:          'Opaque',
+        isGithubApp:    true,
+        id:             'default/gh-app',
+        dataPreview:    '3 keys',
+        subTypeDisplay: 'Opaque',
+        metadata:       { name: 'gh-app', namespace: 'default' },
+      };
+      const plainOpaqueSecret = {
+        _type:          'Opaque',
+        isGithubApp:    false,
+        id:             'default/plain',
+        dataPreview:    '1 key',
+        subTypeDisplay: 'Opaque',
+        metadata:       { name: 'plain', namespace: 'default' },
+      };
+
+      const wrapper = mount(SelectOrCreateAuthSecret, {
+        ...requiredSetup(),
+        props: {
+          mode:               _EDIT,
+          namespace:          'default',
+          value:              {},
+          allowGithubApp:     true,
+          registerBeforeHook: () => {},
+        },
+        data() {
+          return { allSecrets: [githubAppSecret, plainOpaqueSecret] } as any;
+        }
+      });
+
+      const optionValues = (wrapper.vm as any).options.map((o: any) => o.value);
+
+      expect(optionValues).toContain('default/gh-app');
+      expect(optionValues).not.toContain('default/plain');
+    });
+  });
 });

package/components/formatter/EtcdSnapshotName.vue

@@ -0,0 +1,73 @@
+<script>
+import { get } from '@shell/utils/object';
+
+export default {
+  props: {
+    value: {
+      type:    String,
+      default: ''
+    },
+    row: {
+      type:     Object,
+      required: true
+    },
+    col: {
+      type:    Object,
+      default: () => ({})
+    },
+    reference: {
+      type:    String,
+      default: null,
+    },
+    getCustomDetailLink: {
+      type:    Function,
+      default: null
+    }
+  },
+
+  computed: {
+    to() {
+      if (this.getCustomDetailLink) {
+        return this.getCustomDetailLink(this.row);
+      }
+      if ( this.row && this.reference ) {
+        return get(this.row, this.reference);
+      }
+
+      return this.row?.detailLocation;
+    },
+
+    showPredatesImportIcon() {
+      return !!this.row?.isSnapshotTooOld;
+    },
+
+    predatesImportMessage() {
+      return this.t('cluster.snapshot.predatesImportTooltip');
+    },
+  }
+};
+</script>
+
+<template>
+  <span>
+    <router-link
+      v-if="to"
+      :to="to"
+    >
+      {{ value }}
+    </router-link>
+    <span v-else>
+      {{ value }}
+      <template v-if="!value && col.dashIfEmpty">
+        <span class="text-muted">&mdash;</span>
+      </template>
+    </span>
+    <i
+      v-if="showPredatesImportIcon"
+      v-clean-tooltip="{ content: predatesImportMessage, triggers: ['hover', 'touch', 'focus'] }"
+      v-stripped-aria-label="predatesImportMessage"
+      tabindex="0"
+      class="icon icon-error text-error ml-5"
+    />
+  </span>
+</template>

package/components/formatter/InternalExternalIP.vue

@@ -1,5 +1,5 @@
 <script>
-import { isV4Format, isV6Format } from 'ip';
+import ipaddr from 'ipaddr.js';
 import CopyToClipboard from '@shell/components/CopyToClipboard';
 import { mapGetters } from 'vuex';
 import RcStatusBadge from '@components/Pill/RcStatusBadge/RcStatusBadge';
@@ -15,10 +15,16 @@ export default {
   computed: {
     ...mapGetters({ t: 'i18n/t' }),
     filteredExternalIps() {
-      return this.row.externalIps?.filter((ip) => this.isIp(ip)) || [];
+      const ips = this.row.externalIps ||
+        (this.row.externalIp && this.row.externalIp !== this.t('generic.none') ? [this.row.externalIp] : []);
+
+      return ips.filter((ip) => this.isIp(ip));
     },
     filteredInternalIps() {
-      return this.row.internalIps?.filter((ip) => this.isIp(ip)) || [];
+      const ips = this.row.internalIps ||
+        (this.row.internalIp ? [this.row.internalIp] : []);
+
+      return ips.filter((ip) => this.isIp(ip));
     },
     internalSameAsExternal() {
       return this.externalIp && this.internalIp && this.externalIp === this.internalIp;
@@ -59,7 +65,7 @@ export default {
   },
   methods: {
     isIp(ip) {
-      return ip && (isV4Format(ip) || isV6Format(ip));
+      return ip && (ipaddr.IPv4.isValidFourPartDecimal(ip) || ipaddr.IPv6.isValid(ip));
     }
   }
 };

package/components/formatter/ServiceTargets.vue

@@ -1,6 +1,6 @@
 <script>
 import isEmpty from 'lodash/isEmpty';
-import { CATTLE_PUBLIC_ENDPOINTS } from '@shell/config/labels-annotations';
+import { CATTLE_PUBLIC_ENDPOINTS, SERVICE_LINKS } from '@shell/config/labels-annotations';
 import Endpoints from '@shell/components/formatter/Endpoints';
 import has from 'lodash/has';
 import { isMaybeSecure } from '@shell/utils/url';
@@ -52,6 +52,23 @@ export default {
         return annotations[CATTLE_PUBLIC_ENDPOINTS];
       }
 
+      const serviceLinksAnnotation = annotations[SERVICE_LINKS];
+      const serviceLinksMap = new Map();
+
+      if (serviceLinksAnnotation) {
+        serviceLinksAnnotation.split(',').forEach((entry) => {
+          const [portStr, scheme] = entry.trim().split('/');
+          const port = Number(portStr);
+
+          const validSchemes = ['http', 'https'];
+          const normalizedScheme = scheme?.toLowerCase();
+
+          if (port > 0 && !isNaN(port)) {
+            serviceLinksMap.set(port, validSchemes.includes(normalizedScheme) ? normalizedScheme : null);
+          }
+        });
+      }
+
       // <CLUSTER_IP>:<PORT>/<PROTOCOL> > <TARGET PORT>
       if (isEmpty(ports)) {
         if (!isEmpty(parsedClusterIp)) {
@@ -70,12 +87,14 @@ export default {
 
           const stringPort = p.port.toString();
 
-          if (p?.protocol === 'TCP' && (stringPort.endsWith('80') || stringPort.endsWith('443'))) {
-            if (isMaybeSecure(p.port, p?.protocol)) {
-              proxyUrl = row.proxyUrl('https', p.port);
-            } else {
-              proxyUrl = row.proxyUrl('http', p.port);
-            }
+          const isDefaultPort = stringPort.endsWith('80') || stringPort.endsWith('443');
+          const hasServiceLink = serviceLinksMap.has(p.port);
+
+          if (p?.protocol === 'TCP' && (isDefaultPort || hasServiceLink)) {
+            const explicitScheme = hasServiceLink ? serviceLinksMap.get(p.port) : null;
+            const scheme = explicitScheme || (isMaybeSecure(p.port, p?.protocol) ? 'https' : 'http');
+
+            proxyUrl = row.proxyUrl(scheme, p.port);
           }
 
           const clusterIpAndPort = proxyUrl ? `<a href="${ proxyUrl }" target="_blank" rel="noopener noreferrer nofollow">${ p?.name ? p.name : `${ parsedClusterIp }${ p.port }` }</a>` : `${ parsedClusterIp }${ p.port }`;

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'] } });