dashboard-shell-shell 3.0.2-test.20250913 → 3.0.5-logTest.1

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__/kontainer.test.ts

@@ -17,6 +17,25 @@ describe('fx: diffUpstreamSpec', () => {
     expect(diffUpstreamSpec(upstream, local)).toStrictEqual(diff);
   });
 
+  it.each([
+    [{
+      a: { one: 'a' },
+      b: ['1', 'b'],
+      c: 'c'
+    }, {
+      a: {},
+      b: [],
+      c: ''
+    }, {
+      a: {},
+      b: [],
+      c: ''
+    }],
+    [{ a: 'a' }, { b: null }, { }],
+  ])('should include fields that are empty objects, arrays or strings on the local object regardless of upstream definition', (upstream, local, diff) => {
+    expect(diffUpstreamSpec(upstream, local)).toStrictEqual(diff);
+  });
+
   it.each([
     [{ a: null }, { a: {} }, {}],
     [{ a: null }, { a: [] }, {}],

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);
+  });
+});