@rancher/shell 3.0.8-rc.1 → 3.0.8-rc.10

package/machine-config/components/__tests__/utils/vpcSubnetMockData.js

@@ -0,0 +1,294 @@
+export const vpcInfo = {
+  $metadata: {
+    httpStatusCode:  200,
+    requestId:       '12345',
+    attempts:        1,
+    totalRetryDelay: 0
+  },
+  Vpcs: [
+    {
+      CidrBlock:               '192.168.0.0/16',
+      DhcpOptionsId:           'dopt-1234',
+      State:                   'available',
+      VpcId:                   'vpc-123',
+      OwnerId:                 '54321',
+      InstanceTenancy:         'default',
+      CidrBlockAssociationSet: [
+        {
+          AssociationId:  'vpc-cidr-assoc-123',
+          CidrBlock:      '192.168.0.0/16',
+          CidrBlockState: { State: 'associated' }
+        }
+      ],
+      IsDefault: false,
+      Tags:      [
+        {
+          Key:   'displayName',
+          Value: 'test'
+        },
+        {
+          Key:   'Name',
+          Value: 'test-eks-vpc-VPC'
+        }
+      ]
+    },
+    {
+      CidrBlock:               '172.31.0.0/16',
+      DhcpOptionsId:           'dopt-12345',
+      State:                   'available',
+      VpcId:                   'vpc-1234',
+      OwnerId:                 '54321',
+      InstanceTenancy:         'default',
+      CidrBlockAssociationSet: [
+        {
+          AssociationId:  'vpc-cidr-assoc-12345',
+          CidrBlock:      '172.31.0.0/16',
+          CidrBlockState: { State: 'associated' }
+        }
+      ],
+      IsDefault: false,
+      Tags:      [
+        {
+          Key:   'Name',
+          Value: 'aws-controltower-VPC'
+        }
+      ]
+    },
+    {
+      CidrBlock:                   '192.168.0.0/16',
+      DhcpOptionsId:               'dopt-123456',
+      State:                       'available',
+      VpcId:                       'vpc-12345',
+      OwnerId:                     '54321',
+      InstanceTenancy:             'default',
+      Ipv6CidrBlockAssociationSet: ['1234'],
+      CidrBlockAssociationSet:     [
+        {
+          AssociationId:  'vpc-cidr-assoc-123456',
+          CidrBlock:      '192.168.0.0/16',
+          CidrBlockState: { State: 'associated' }
+        }
+      ],
+      IsDefault: false,
+      Tags:      [
+
+        {
+          Key:   'Name',
+          Value: 'mo-eks-eks-vpc-VPC'
+        },
+        {
+          Key:   'displayName',
+          Value: 'mo-eks'
+        }
+      ]
+    }
+  ]
+};
+
+export const subnetInfo = {
+  $metadata: {
+    httpStatusCode:  200,
+    requestId:       '123456',
+    attempts:        1,
+    totalRetryDelay: 0
+  },
+  Subnets: [
+    {
+      AvailabilityZone:            'us-west-2b',
+      AvailabilityZoneId:          'usw2-az1',
+      AvailableIpAddressCount:     4091,
+      CidrBlock:                   '172.31.32.0/20',
+      DefaultForAz:                false,
+      MapPublicIpOnLaunch:         false,
+      MapCustomerOwnedIpOnLaunch:  false,
+      State:                       'available',
+      SubnetId:                    'subnet-1234',
+      VpcId:                       'vpc-1234',
+      OwnerId:                     '1234',
+      AssignIpv6AddressOnCreation: false,
+      Tags:                        [
+        {
+          Key:   'Name',
+          Value: 'aws-controltower-PrivateSubnet2A'
+        },
+
+        {
+          Key:   'Network',
+          Value: 'Private'
+        },
+
+        {
+          Key:   'aws:cloudformation:logical-id',
+          Value: 'PrivateSubnet2A'
+        }
+      ],
+      SubnetArn: 'arn:aws:ec2:us-west-2:821532311898:subnet/subnet-1234'
+    },
+    {
+      AvailabilityZone:            'us-west-2c',
+      AvailabilityZoneId:          'usw2-az3',
+      AvailableIpAddressCount:     4091,
+      CidrBlock:                   '172.31.80.0/20',
+      DefaultForAz:                false,
+      MapPublicIpOnLaunch:         false,
+      MapCustomerOwnedIpOnLaunch:  false,
+      State:                       'available',
+      SubnetId:                    'subnet-321',
+      VpcId:                       'vpc-1234',
+      OwnerId:                     '1234',
+      AssignIpv6AddressOnCreation: false,
+      Tags:                        [
+        {
+          Key:   'Name',
+          Value: 'aws-controltower-PrivateSubnet3A'
+        },
+        {
+          Key:   'aws:cloudformation:logical-id',
+          Value: 'PrivateSubnet3A'
+        },
+        {
+          Key:   'Network',
+          Value: 'Private'
+        },
+      ],
+      SubnetArn: 'arn:aws:ec2:us-west-2:821532311898:subnet/subnet-321'
+    },
+    {
+      AvailabilityZone:            'us-west-2a',
+      AvailabilityZoneId:          'usw2-az2',
+      AvailableIpAddressCount:     16379,
+      CidrBlock:                   '192.168.64.0/18',
+      DefaultForAz:                false,
+      MapPublicIpOnLaunch:         true,
+      MapCustomerOwnedIpOnLaunch:  false,
+      State:                       'available',
+      SubnetId:                    'subnet-4321',
+      VpcId:                       'vpc-12345',
+      OwnerId:                     '1234',
+      AssignIpv6AddressOnCreation: false,
+      Ipv6CidrBlockAssociationSet: ['1234'],
+      Tags:                        [
+        {
+          Key:   'Name',
+          Value: 'test-eks-vpc-Subnet01'
+        },
+        {
+          Key:   'displayName',
+          Value: 'test'
+        },
+        {
+          Key:   'aws:cloudformation:stack-name',
+          Value: 'test-eks-vpc'
+        },
+        {
+          Key:   'aws:cloudformation:logical-id',
+          Value: 'Subnet01'
+        },
+        {
+          Key:   'kubernetes.io/role/elb',
+          Value: '1'
+        }
+      ],
+      SubnetArn: 'arn:aws:ec2:us-west-2:821532311898:subnet/subnet-4321'
+    },
+    {
+      AvailabilityZone:            'us-west-2b',
+      AvailabilityZoneId:          'usw2-az1',
+      AvailableIpAddressCount:     16379,
+      CidrBlock:                   '192.168.128.0/18',
+      DefaultForAz:                false,
+      MapPublicIpOnLaunch:         true,
+      MapCustomerOwnedIpOnLaunch:  false,
+      State:                       'available',
+      SubnetId:                    'subnet-21',
+      VpcId:                       'vpc-12345',
+      OwnerId:                     '1234',
+      AssignIpv6AddressOnCreation: false,
+      Ipv6CidrBlockAssociationSet: ['1234'],
+      Tags:                        [
+        {
+          Key:   'aws:cloudformation:logical-id',
+          Value: 'Subnet02'
+        },
+        {
+          Key:   'displayName',
+          Value: 'test'
+        },
+        {
+          Key:   'aws:cloudformation:stack-name',
+          Value: 'test-eks-vpc'
+        },
+        {
+          Key:   'kubernetes.io/role/elb',
+          Value: '1'
+        },
+        {
+          Key:   'Name',
+          Value: 'test-eks-vpc-Subnet02'
+        }
+      ],
+      SubnetArn: 'arn:aws:ec2:us-west-2:821532311898:subnet/subnet-21'
+    },
+    {
+      AvailabilityZone:            'us-west-2c',
+      AvailabilityZoneId:          'usw2-az3',
+      AvailableIpAddressCount:     16379,
+      CidrBlock:                   '192.168.192.0/18',
+      DefaultForAz:                false,
+      MapPublicIpOnLaunch:         true,
+      MapCustomerOwnedIpOnLaunch:  false,
+      State:                       'available',
+      SubnetId:                    'subnet-123',
+      VpcId:                       'vpc-12345',
+      OwnerId:                     '1234',
+      AssignIpv6AddressOnCreation: false,
+      Ipv6CidrBlockAssociationSet: ['1234'],
+      Tags:                        [
+
+        {
+          Key:   'aws:cloudformation:stack-name',
+          Value: 'test-eks-vpc'
+        },
+        {
+          Key:   'displayName',
+          Value: 'test'
+        },
+        {
+          Key:   'kubernetes.io/role/elb',
+          Value: '1'
+        },
+        {
+          Key:   'Name',
+          Value: 'test-eks-vpc-Subnet03'
+        }
+      ],
+      SubnetArn: 'arn:aws:ec2:us-west-2:821532311898:subnet/subnet-123'
+    },
+    {
+      AvailabilityZone:            'us-west-2a',
+      AvailabilityZoneId:          'usw2-az2',
+      AvailableIpAddressCount:     4091,
+      CidrBlock:                   '172.31.64.0/20',
+      DefaultForAz:                false,
+      MapPublicIpOnLaunch:         false,
+      MapCustomerOwnedIpOnLaunch:  false,
+      State:                       'available',
+      SubnetId:                    'subnet-12',
+      VpcId:                       'vpc-12',
+      OwnerId:                     '1234',
+      AssignIpv6AddressOnCreation: false,
+      Tags:                        [
+        {
+          Key:   'Name',
+          Value: 'aws-controltower-PrivateSubnet1A'
+        },
+
+        {
+          Key:   'Network',
+          Value: 'Private'
+        }
+      ],
+      SubnetArn: 'arn:aws:ec2:us-west-2:821532311898:subnet/subnet-12'
+    }
+  ]
+};

package/machine-config/digitalocean.vue

@@ -16,6 +16,8 @@ export default {
 
   mixins: [CreateEditView],
 
+  emits: ['update:hasIpv6'],
+
   props: {
     credentialId: {
       type:     String,
@@ -26,6 +28,11 @@ export default {
       type:    Boolean,
       default: false
     },
+
+    hasIpv6: {
+      type:    Boolean,
+      default: false
+    },
   },
 
   async fetch() {
@@ -110,6 +117,10 @@ export default {
     },
 
     'value.image': 'updateUsername',
+
+    'value.ipv6'(neu) {
+      this.$emit('update:hasIpv6', neu);
+    }
   },
 
   computed: {

package/machine-config/google.vue

@@ -515,7 +515,7 @@ export default {
           :options="subnetworkOptions"
           :disabled="!poolCreateMode"
           option-key="name"
-          option-label="name"
+          option-label="label"
           :loading="loadingNetworks"
           data-testid="gce-subnetwork-select"
         />

package/mixins/__tests__/brand.spec.ts

@@ -99,9 +99,9 @@ describe('brandMixin', () => {
             filters: [{
               equals: true,
               fields: [{
-                equals: true, exact: true, exists: false, field: 'metadata.name', value: 'rancher-csp-adapter'
+                equality: '=', equals: true, exact: true, exists: false, field: 'metadata.name', value: 'rancher-csp-adapter'
               }, {
-                equals: true, exact: true, exists: false, field: 'metadata.name', value: 'rancher-csp-billing-adapter'
+                equality: '=', equals: true, exact: true, exists: false, field: 'metadata.name', value: 'rancher-csp-billing-adapter'
               }],
               param: 'filter'
             }],

package/mixins/__tests__/chart.test.ts

@@ -238,5 +238,26 @@ describe('chartMixin', () => {
         icon: 'icon-downgrade-alt',
       });
     });
+
+    it('should return "upgrade" action when upgrading from a pre-release to a stable version', () => {
+      const wrapper = mount(DummyComponent, {
+        data: () => ({
+          existing: { spec: { chart: { metadata: { version: '1.0.0-rc1' } } } },
+          version:  { version: '1.0.0' }
+        }),
+        global: {
+          mocks: {
+            $store: mockStore,
+            $route: { query: {} }
+          }
+        }
+      });
+
+      expect(wrapper.vm.action).toStrictEqual({
+        name: 'upgrade',
+        tKey: 'upgrade',
+        icon: 'icon-upgrade-alt',
+      });
+    });
   });
 });

package/mixins/brand.js

@@ -36,7 +36,7 @@ export default {
   },
 
   computed: {
-    ...mapGetters({ loggedIn: 'auth/loggedIn' }),
+    ...mapGetters({ loggedIn: 'auth/loggedIn', brand: 'management/brand' }),
 
     // added to fix https://github.com/rancher/dashboard/issues/10788
     // because on logout the brand mixin is mounted, but then a management store reset happens
@@ -46,12 +46,6 @@ export default {
       return this.$store.getters['management/all'](MANAGEMENT.SETTING);
     },
 
-    brand() {
-      const setting = this.globalSettings?.find((gs) => gs.id === SETTING.BRAND);
-
-      return setting?.value;
-    },
-
     color() {
       const setting = this.globalSettings?.find((gs) => gs.id === SETTING.PRIMARY_COLOR);
 

package/mixins/chart.js

@@ -10,7 +10,7 @@ import { NAME as MANAGER } from '@shell/config/product/manager';
 import { OPA_GATE_KEEPER_ID } from '@shell/pages/c/_cluster/gatekeeper/index.vue';
 import { formatSi, parseSi } from '@shell/utils/units';
 import { CAPI, CATALOG } from '@shell/config/types';
-import { isPrerelease, compare } from '@shell/utils/version';
+import { isPrerelease, compare, isUpgradeFromPreToStable } from '@shell/utils/version';
 import difference from 'lodash/difference';
 import { LINUX, APP_UPGRADE_STATUS } from '@shell/store/catalog';
 import { clone } from '@shell/utils/object';
@@ -240,6 +240,12 @@ export default {
         };
       }
 
+      if (isUpgradeFromPreToStable(this.currentVersion, this.targetVersion)) {
+        return {
+          name: 'upgrade', tKey: 'upgrade', icon: 'icon-upgrade-alt'
+        };
+      }
+
       if (compare(this.currentVersion, this.targetVersion) < 0) {
         return {
           name: 'upgrade', tKey: 'upgrade', icon: 'icon-upgrade-alt'

package/mixins/create-edit-view/index.js

@@ -48,6 +48,11 @@ export default defineComponent({
     useTabbedHash: {
       type:    Boolean,
       default: undefined
+    },
+
+    defaultTab: {
+      type:    String,
+      default: undefined
     }
   },
 });

package/models/__tests__/chart.test.ts

@@ -2,11 +2,16 @@ import Chart from '@shell/models/chart';
 import { APP_UPGRADE_STATUS } from '@shell/store/catalog';
 import { CATALOG as CATALOG_ANNOTATIONS } from '@shell/config/labels-annotations';
 import { ZERO_TIME } from '@shell/config/types';
+import { getLatestCompatibleVersion } from '@shell/utils/chart';
+
+jest.mock('@shell/utils/chart', () => ({ getLatestCompatibleVersion: jest.fn() }));
 
 type MockChartContext = {
   rootGetters: {
     'cluster/all': () => any[];
     'i18n/t': (key: string) => string;
+    currentCluster: { workerOSs: string[] };
+    'prefs/get': (key: string) => boolean;
   };
   dispatch?: jest.Mock;
 };
@@ -58,11 +63,32 @@ describe('class Chart', () => {
   beforeEach(() => {
     ctx = {
       rootGetters: {
-        'cluster/all': () => [],
-        'i18n/t':      t
+        'cluster/all':  () => [],
+        'i18n/t':       t,
+        currentCluster: { workerOSs: [] },
+        'prefs/get':    () => false,
       },
       dispatch
     };
+    (getLatestCompatibleVersion as jest.Mock).mockImplementation((chart) => chart.versions[0]);
+  });
+
+  describe('queryParams', () => {
+    it('should return query params with the latest compatible version', () => {
+      const chart = new Chart(base, ctx);
+      const query = chart.queryParams();
+
+      expect(getLatestCompatibleVersion).toHaveBeenCalledWith(chart, [], false);
+      expect(query).toHaveProperty('version', '1.3.0');
+    });
+
+    it('should reflect a different latest version from the mock', () => {
+      (getLatestCompatibleVersion as jest.Mock).mockImplementation((chart) => chart.versions[1]);
+      const chart = new Chart(base, ctx);
+      const query = chart.queryParams();
+
+      expect(query).toHaveProperty('version', '1.2.3');
+    });
   });
 
   describe('matchingInstalledApps', () => {
@@ -188,6 +214,7 @@ describe('class Chart', () => {
 
       const result = chart.cardContent as CardContent;
 
+      expect(getLatestCompatibleVersion).toHaveBeenCalledWith(chart, [], false);
       expect(result.subHeaderItems).toHaveLength(2);
       expect(result.subHeaderItems[0].label).toBe('1.3.0');
       expect(result.subHeaderItems[1].label).toBe('Mar 10, 2024');
@@ -297,8 +324,10 @@ describe('class Chart', () => {
       };
       const chart = new Chart(chartWithZeroTime, {
         rootGetters: {
-          'cluster/all': () => [],
-          'i18n/t':      (key: string) => key
+          'cluster/all':  () => [],
+          'i18n/t':       (key: string) => key,
+          currentCluster: { workerOSs: [] },
+          'prefs/get':    () => false,
         },
       });
 

package/models/__tests__/provisioning.cattle.io.cluster.test.ts

@@ -1,24 +1,28 @@
 import ProvCluster from '@shell/models/provisioning.cattle.io.cluster';
-
+jest.mock('@shell/utils/provider', () => ({
+  isHostedProvider: jest.fn().mockImplementation((context, provider) => {
+    return ['GKE', 'EKS', 'AKS'].includes(provider);
+  })
+}));
 describe('class ProvCluster', () => {
   const gkeClusterWithPrivateEndpoint = {
     clusterName: 'test',
     provisioner: 'GKE',
-    spec:        { rkeConfig: {} },
+    spec:        { },
     mgmt:        { spec: { gkeConfig: { privateClusterConfig: { enablePrivateEndpoint: true } } } }
   };
 
   const eksClusterWithPrivateEndpoint = {
     clusterName: 'test',
     provisioner: 'EKS',
-    spec:        { rkeConfig: {} },
+    spec:        { },
     mgmt:        { spec: { eksConfig: { privateAccess: true } } }
   };
 
   const aksClusterWithPrivateEndpoint = {
     clusterName: 'test',
     provisioner: 'AKS',
-    spec:        { rkeConfig: {} },
+    spec:        { },
     mgmt:        { spec: { aksConfig: { privateCluster: true } } }
   };
 
@@ -44,12 +48,115 @@ describe('class ProvCluster', () => {
         clusterData.provisioner
       );
 
-      expect(cluster.isRke2).toBe(expected);
+      expect(cluster.isRke2).toBe(false);
       expect(cluster.isHostedKubernetesProvider).toBe(expected);
       expect(cluster.isPrivateHostedProvider).toBe(expected);
       resetMocks();
     });
   });
+  describe('isImported', () => {
+    const testCases = [
+      {
+        description: 'should return false for a local cluster',
+        clusterData: { isLocal: true },
+        expected:    false
+      },
+      {
+        description: 'should return true for an imported k3s cluster',
+        clusterData: {
+          isLocal: false,
+          mgmt:    { status: { provider: 'k3s', driver: 'k3s' } }
+        },
+        expected: true
+      },
+      {
+        description: 'should return false for a provisioned k3s cluster',
+        clusterData: {
+          isLocal: false,
+          mgmt:    { status: { provider: 'k3s', driver: 'imported' } }
+        },
+        expected: false
+      },
+      {
+        description: 'should return true for an imported rke2 cluster',
+        clusterData: {
+          isLocal: false,
+          mgmt:    { status: { provider: 'rke2', driver: 'rke2' } }
+        },
+        expected: true
+      },
+      {
+        description: 'should return false for a provisioned rke2 cluster',
+        clusterData: {
+          isLocal: false,
+          mgmt:    { status: { provider: 'rke2', driver: 'imported' } }
+        },
+        expected: false
+      },
+      {
+        description: 'should return true for an imported hosted cluster',
+        clusterData: {
+          isLocal:                    false,
+          isHostedKubernetesProvider: true,
+          providerConfig:             { imported: true }
+        },
+        expected: true
+      },
+      {
+        description: 'should return false for a provisioned hosted cluster',
+        clusterData: {
+          isLocal:                    false,
+          isHostedKubernetesProvider: true,
+          providerConfig:             { imported: false }
+        },
+        expected: false
+      },
+      {
+        description: 'should return true for a generic imported cluster',
+        clusterData: {
+          isLocal:     false,
+          provisioner: 'imported'
+        },
+        expected: true
+      },
+      {
+        description: 'should return false for a generic provisioned cluster',
+        clusterData: {
+          isLocal:     false,
+          provisioner: 'rke2'
+        },
+        expected: false
+      }
+    ];
+    const resetMocks = () => {
+      // Clear all mock function calls:
+      jest.clearAllMocks();
+    };
+
+    it.each(testCases)('$description', ({ clusterData, expected }) => {
+      const cluster = new ProvCluster({});
+
+      // Mock getters
+      jest.spyOn(cluster, 'mgmt', 'get').mockReturnValue(
+        clusterData.mgmt
+      );
+      if (clusterData.isLocal !== undefined) {
+        jest.spyOn(cluster, 'isLocal', 'get').mockReturnValue(clusterData.isLocal);
+      }
+      if (clusterData.isHostedKubernetesProvider !== undefined) {
+        jest.spyOn(cluster, 'isHostedKubernetesProvider', 'get').mockReturnValue(clusterData.isHostedKubernetesProvider);
+      }
+      if (clusterData.providerConfig !== undefined) {
+        jest.spyOn(cluster, 'providerConfig', 'get').mockReturnValue(clusterData.providerConfig);
+      }
+      if (clusterData.provisioner !== undefined) {
+        jest.spyOn(cluster, 'provisioner', 'get').mockReturnValue(clusterData.provisioner);
+      }
+
+      expect(cluster.isImported).toBe(expected);
+      resetMocks();
+    });
+  });
 
   describe('hasError', () => {
     const conditionsWithoutError = [