@rancher/shell 3.0.5-rc.5 → 3.0.5-rc.7

package/types/store/dashboard-store.types.ts

@@ -1,3 +1,4 @@
+import { KubeLabelSelector } from '@shell/types/kube/kube-api';
 import { PaginationArgs, StorePagination } from '@shell/types/store/pagination.types';
 
 /**
@@ -81,3 +82,18 @@ export interface ActionFindPageArgs extends ActionCoreFindArgs {
    */
   transient?: boolean,
 }
+
+export type ActionFindPageResponse<T = any> = {
+  data: T[],
+  pagination?: StorePagination
+} | T[];
+
+export interface ActionFindMatchingArgs extends ActionCoreFindArgs {
+  labelSelector: KubeLabelSelector,
+  namespaced?: string,
+  depaginate?: boolean
+}
+
+export type ActionFindMatchingResponse<T = any> = ActionFindPageResponse<T>
+
+export type ActionFindLabelSelectorArgs = ActionFindPageArgs | ActionFindMatchingArgs;

package/types/store/pagination.types.ts

@@ -64,12 +64,14 @@ export class PaginationFilterField {
   field?: string;
   /**
    * Value of field within the object to filter by for example the y of x=y
+   *
+   * This can be empty if `exists` is true
    */
-  value: string;
+  value?: string;
   /**
    * Equality field within the object to filter by for example the `=` or `!=` of x=y
    */
-  equals: boolean;
+  equals?: boolean;
   /**
    * Match the field exactly. False for partial matches
    *
@@ -77,18 +79,26 @@ export class PaginationFilterField {
    * Exact: true. "p" no, "pod", no, "pod1" yes
    * Exact: false. "p" yes, "pod", yes, "pod1" yes
    */
-  exact: boolean;
+  exact?: boolean;
+
+  /**
+   * Check if the field/property exists, regardless of value
+   *
+   * If this is false it does not flip the expectation, just doesn't add the field
+   */
+  exists?: boolean;
 
   constructor(
     {
-      field, value, equals = true, exact = true
+      field, value = '', equals = true, exact = true, exists = false
     }:
-    { field?: string; value: string; equals?: boolean; exact?: boolean;}
+    { field?: string; value?: string; equals?: boolean; exact?: boolean; exists?:boolean;}
   ) {
     this.field = field;
     this.value = value;
     this.equals = equals;
     this.exact = exact;
+    this.exists = exists;
   }
 }
 
@@ -228,7 +238,7 @@ export class PaginationParamFilter extends PaginationParam {
   /**
    * Convenience method when you just want an instance of {@link PaginationParamFilter} with a simple `filter=x=y` param
    */
-  static createSingleField(field: { field?: string; value: string; equals?: boolean; exact?: boolean }): PaginationParam {
+  static createSingleField(field: { field?: string; value?: string; equals?: boolean; exact?: boolean, exists?: boolean }): PaginationParam {
     return new PaginationParamFilter({ fields: [new PaginationFilterField(field)] });
   }
 

package/utils/__tests__/create-yaml.test.ts

@@ -488,3 +488,238 @@ __clone: true
     expect(actual).toStrictEqual(expected);
   });
 });
+
+describe('fx: createYaml', () => {
+  interface CommentFieldsOption {
+    path: string;
+    key: string;
+  }
+
+  const schemas = [
+    {
+      id:             'provisioning.cattle.io.cluster',
+      resourceFields: {
+        apiVersion: {
+          type:   'string',
+          create: false,
+          update: false
+        },
+        kind: {
+          type:   'string',
+          create: false,
+          update: false
+        },
+        metadata: {
+          type:   'io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta',
+          create: true,
+          update: true
+        },
+        spec: {
+          type:     'provisioning.cattle.io.v1.cluster.spec',
+          nullable: true,
+          create:   true,
+          update:   true
+        }
+      }
+    },
+    {
+      id:             'io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta',
+      resourceFields: {
+        annotations: {
+          type:   'map[string]',
+          create: true,
+          update: true
+        },
+        labels: {
+          type:   'map[string]',
+          create: true,
+          update: true
+        },
+        namespace: {
+          type:   'string',
+          create: true,
+          update: true
+        }
+      }
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec',
+      resourceFields: {
+        localClusterAuthEndpoint: {
+          type:     'provisioning.cattle.io.v1.cluster.spec.localClusterAuthEndpoint',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        rkeConfig: {
+          type:     'provisioning.cattle.io.v1.cluster.spec.rkeConfig',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        foo: {
+          type:     'array[string]',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+      }
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec.localClusterAuthEndpoint',
+      resourceFields: {
+        caCerts: {
+          type:     'string',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        enabled: {
+          type:     'boolean',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        fqdn: {
+          type:     'string',
+          nullable: true,
+          create:   true,
+          update:   true
+        }
+      }
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec.rkeConfig',
+      resourceFields: {
+        additionalManifest: {
+          type:     'string',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        chartValues: {
+          type:     'provisioning.cattle.io.v1.cluster.spec.rkeConfig.chartValues',
+          nullable: true,
+          create:   true,
+          update:   true
+        },
+        machineGlobalConfig: {
+          type:     'provisioning.cattle.io.v1.cluster.spec.rkeConfig.machineGlobalConfig',
+          nullable: true,
+          create:   true,
+          update:   true
+        }
+      }
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec.rkeConfig.chartValues',
+      resourceFields: {}
+    },
+    {
+      id:             'provisioning.cattle.io.v1.cluster.spec.rkeConfig.machineGlobalConfig',
+      resourceFields: {}
+    }
+  ];
+
+  it('should comment out fields when specific properties are defined on the model with commentFieldsOptions', () => {
+    const obj = {
+      type:     'provisioning.cattle.io.cluster',
+      metadata: {
+        namespace:   'fleet-default',
+        annotations: { someannotation: 'test' },
+        labels:      {}
+      },
+      __clone: true,
+      spec:    {
+        localClusterAuthEndpoint: {
+          caCerts: '',
+          enabled: false,
+          fqdn:    ''
+        },
+        rkeConfig: {
+          machineGlobalConfig: {
+            cni:                   'calico',
+            'disable-kube-proxy':  false,
+            'etcd-expose-metrics': false,
+            profile:               null
+          },
+          chartValues: {}
+        },
+        foo: [
+          'bar',
+          'bar2'
+        ],
+      },
+      apiVersion: 'provisioning.cattle.io/v1',
+      kind:       'Cluster'
+    };
+
+    const objResult = {
+      metadata: {
+        namespace:   'fleet-default',
+        annotations: { someannotation: 'test' },
+        labels:      {}
+      },
+      __clone: true,
+      spec:    {
+        rkeConfig: {
+          machineGlobalConfig: {
+            cni:                   'calico',
+            'disable-kube-proxy':  false,
+            'etcd-expose-metrics': false,
+          },
+          chartValues: {}
+        },
+      },
+      apiVersion: 'provisioning.cattle.io/v1',
+      kind:       'Cluster'
+    };
+
+    const type = 'provisioning.cattle.io.cluster';
+    const commentFieldsOptions: CommentFieldsOption[] = [
+      { path: 'spec.rkeConfig.machineGlobalConfig', key: 'profile' },
+      { path: 'spec', key: 'localClusterAuthEndpoint' },
+      { path: 'spec', key: 'foo' },
+    ];
+
+    // Define the expected YAML output as a string, adjusted for correct spacing
+    const expectedYaml = `
+apiVersion: provisioning.cattle.io/v1
+kind: Cluster
+metadata:
+  annotations:
+    someannotation: test
+    #  key: string
+  labels:
+    {}
+    #  key: string
+  namespace: fleet-default
+spec:
+#  localClusterAuthEndpoint:
+#    caCerts: ''
+#    enabled: false
+#    fqdn: ''
+  rkeConfig:
+    chartValues:
+      {}
+    machineGlobalConfig:
+      cni: calico
+      disable-kube-proxy: false
+      etcd-expose-metrics: false
+#       profile: null
+#    additionalManifest: string
+#  foo:
+#    - bar
+#    - bar2
+#    - string
+__clone: true`.trim();
+
+    const result = createYaml(schemas, type, obj, true, 0, '', null, {}, commentFieldsOptions as any);
+
+    // Check if result is a valid YAML
+    expect(jsyaml.load(result.trim())).toStrictEqual(objResult);
+
+    // Check if properties are commented out
+    expect(result.trim()).toStrictEqual(expectedYaml);
+  });
+});

package/utils/__tests__/fleet.test.ts

@@ -0,0 +1,148 @@
+import { Target } from '@shell/types/fleet';
+import FleetUtils from '@shell/utils/fleet';
+
+describe('fx: util.getTargetMode', () => {
+  const util = FleetUtils.Application;
+
+  it('should return "all" when targets contain excludeHarvesterRule and namespace is not fleet-local', () => {
+    const targets = [{
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'provider.cattle.io',
+          operator: 'NotIn',
+          values:   ['harvester'],
+        }],
+      },
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+
+  it('should return "clusters" when targets include clusterName and clusterSelector', () => {
+    const targets = [{ clusterName: 'fleet-5-france' }, { clusterSelector: { matchLabels: { foo: 'true' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "clusters" when targets only include multiple clusterSelectors', () => {
+    const targets: Target[] = [{ clusterSelector: { matchLabels: { foo: 'true' } } }, { clusterSelector: { matchLabels: { hci: 'true' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "advanced" when a target contains clusterGroupSelector', () => {
+    const targets = [{ clusterGroupSelector: {} }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "advanced" when any target contains clusterGroup or clusterGroupSelector', () => {
+    const targets = [{
+      clusterGroup:         'cg1',
+      clusterGroupSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['string']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      clusterName:     'pippo',
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['vvv']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      name: 'tt1',
+    }, {
+      clusterGroup:         'cg2',
+      clusterGroupSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['string']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      clusterName:     'pippo',
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'string',
+          operator: 'string',
+          values:   ['vvv']
+        }],
+        matchLabels: { foo: 'bar' }
+      },
+      name: 'tt1',
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "none" when targets is an empty array', () => {
+    const targets: Target[] = [];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('none');
+  });
+
+  it('should return "local" when namespace is "fleet-local" regardless of targets', () => {
+    const targets: Target[] = [{ clusterSelector: { matchLabels: { foo: 'true' } } }, { clusterSelector: { matchLabels: { hci: 'true' } } }];
+    const namespace = 'fleet-local';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('local');
+  });
+
+  it('should return "all" if no specific target type (clusterName, clusterSelector, clusterGroup, clusterGroupSelector) is present', () => {
+    const targets = [{ name: 'target1' }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+
+  it('should return "clusters" if multiple targets include only clusterName', () => {
+    const targets = [{ clusterName: 'cluster-a' }, { clusterName: 'cluster-b' }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "clusters" if a mix of clusterName and empty clusterSelector is present', () => {
+    const targets = [{ clusterName: 'cluster-c' }, { clusterSelector: {} },
+    ];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('clusters');
+  });
+
+  it('should return "advanced" if one target has clusterGroup but others have clusterName or clusterSelector', () => {
+    const targets = [{ clusterName: 'cluster-x' }, { clusterGroup: 'my-group' }, { clusterSelector: { matchLabels: { env: 'prod' } } }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('advanced');
+  });
+
+  it('should return "all" when targets contain excludeHarvesterRule along with other irrelevant properties', () => {
+    const targets = [{
+      clusterSelector: {
+        matchExpressions: [{
+          key:      'provider.cattle.io',
+          operator: 'NotIn',
+          values:   ['harvester'],
+        }],
+      },
+      name: 'some-other-name'
+    }];
+    const namespace = 'ws1';
+
+    expect(util.getTargetMode(targets, namespace)).toBe('all');
+  });
+});

package/utils/__tests__/object.test.ts

@@ -1,6 +1,6 @@
 import { reactive, isReactive } from 'vue';
 import {
-  clone, get, getter, isEmpty, toDictionary, remove, diff, definedKeys, deepToRaw, mergeWithReplace
+  clone, get, getter, isEmpty, toDictionary, remove, diff, definedKeys, deepToRaw, mergeWithReplace, convertKVToString, convertStringToKV
 } from '@shell/utils/object';
 
 describe('fx: get', () => {
@@ -441,3 +441,56 @@ describe('fx: mergeWithReplace', () => {
     expect(result).toStrictEqual(expected);
   });
 });
+
+describe('fx: convertKVToString', () => {
+  it.each([
+    [{}, ''],
+    [{ foo: 'bar' }, 'foo,bar'],
+    [{ foo: 'bar', baz: 'bang' }, 'foo,bar,baz,bang'],
+    [{ foo: 'bar', baz: null }, 'foo,bar,baz,null'],
+    [{ ' spaced ': ' value ' }, ' spaced , value '], // preserves raw keys/values
+    [{ 0: 42, truthy: true }, '0,42,truthy,true'],
+  ])('should convert %p -> "%s"', (input, expected) => {
+    const result = convertKVToString(input);
+
+    expect(result).toBe(expected);
+  });
+
+  it('should produce a string with an even number of comma-separated parts', () => {
+    const str = convertKVToString({
+      a: 1, b: 2, c: 3
+    });
+    const parts = str.split(',');
+
+    expect(parts.length % 2).toBe(0);
+  });
+});
+
+describe('fx: convertStringToKV', () => {
+  it.each([
+    ['', {}],
+    ['foo,bar', { foo: 'bar' }],
+    ['foo,bar,baz,bang', { foo: 'bar', baz: 'bang' }],
+    ['  foo  ,  bar  ', { foo: 'bar' }], // trims whitespace
+    ['foo,bar,baz', { foo: 'bar' }], // dangling key ignored
+    ['foo,bar,,bang', { foo: 'bar', '': 'bang' }], // empty key retained when present
+  ])('should convert "%s" -> %p', (input, expected) => {
+    const result = convertStringToKV(input);
+
+    expect(result).toStrictEqual(expected);
+  });
+});
+
+describe('fx: convertStringToKV to convertKVToString and back (round-trip)', () => {
+  it.each([
+    '',
+    'foo,bar',
+    'foo,bar,baz,bang',
+    'answer,42,truthy,true,falsy,false',
+  ])('should round-trip %p without loss', (input) => {
+    const asObj = convertStringToKV(input);
+    const backToString = convertKVToString(asObj);
+
+    expect(backToString).toStrictEqual(input);
+  });
+});