@rancher/shell 3.0.5-rc.6 → 3.0.5-rc.8

package/edit/networking.k8s.io.ingress/Certificate.vue

@@ -25,21 +25,27 @@ export default {
     }
   },
   data() {
-    const defaultCert = {
-      label: this.t('ingress.certificates.defaultCertLabel'),
-      value: DEFAULT_CERT_VALUE,
-    };
-    const { hosts = [''], secretName = defaultCert.value } = this.value;
-
     return {
-      defaultCert,
-      hosts,
-      secretName,
+      hosts:      this.value?.hosts ?? [''],
+      secretName: this.value?.secretName === undefined ? DEFAULT_CERT_VALUE : this.value?.secretName,
+      secretVal:  this.value?.secretName ?? DEFAULT_CERT_VALUE,
     };
   },
+  watch: {
+    value(newVal) {
+      this.hosts = newVal.hosts;
+      this.secretName = newVal.secretName;
+      this.secretVal = this.secretName === null ? DEFAULT_CERT_VALUE : this.secretName;
+    },
+  },
   computed: {
     certsWithDefault() {
-      return [this.defaultCert, ...this.certs.map((c) => ({ label: c, value: c }))];
+      const defaultCert = {
+        label: this.t('ingress.certificates.defaultCertLabel'),
+        value: DEFAULT_CERT_VALUE,
+      };
+
+      return [defaultCert, ...this.certs.map((c) => ({ label: c, value: c }))];
     },
     certificateStatus() {
       const isValueAnOption = !this.secretName || this.certsWithDefault.find((cert) => this.secretName === cert.value);
@@ -51,15 +57,10 @@ export default {
     },
   },
   methods: {
-    addHost(ev) {
-      ev.preventDefault();
-      this.hosts.push('');
-      this.update();
-    },
     update() {
       const out = { hosts: this.hosts };
 
-      out.secretName = this.secretName;
+      out.secretName = this.secretVal;
 
       if (out.secretName === DEFAULT_CERT_VALUE) {
         out.secretName = null;
@@ -68,7 +69,7 @@ export default {
       this.$emit('update:value', out);
     },
     onSecretInput(e) {
-      this.secretName = e && typeof e === 'object' ? e.label : e;
+      this.secretVal = e && typeof e === 'object' ? e.label : e;
       this.update();
     },
     onHostsInput(e) {
@@ -80,13 +81,10 @@ export default {
 </script>
 
 <template>
-  <div
-    class="cert row"
-    @update:value="update"
-  >
+  <div class="cert row">
     <div class="col span-6">
       <LabeledSelect
-        v-model:value="secretName"
+        v-model:value="secretVal"
         class="secret-name"
         :options="certsWithDefault"
         :label="t('ingress.certificates.certificate.label')"

package/edit/networking.k8s.io.ingress/DefaultBackend.vue

@@ -34,11 +34,16 @@ export default {
     }
   },
   data() {
+    return {
+      serviceName: '',
+      servicePort: '',
+    };
+  },
+  created() {
     const backend = get(this.value.spec, this.value.defaultBackendPath);
-    const serviceName = get(backend, this.value.serviceNamePath) || '';
-    const servicePort = get(backend, this.value.servicePortPath) || '';
 
-    return { serviceName, servicePort };
+    this.serviceName = get(backend, this.value.serviceNamePath) || '';
+    this.servicePort = get(backend, this.value.servicePortPath) || '';
   },
   computed: {
     isView() {

package/edit/networking.k8s.io.ingress/Rule.vue

@@ -32,12 +32,9 @@ export default {
     }
   },
   data() {
-    const { host = '', http = {} } = this.value;
-    const { paths = [{ id: random32(1) }] } = http;
-
     return {
-      host,
-      paths,
+      host:     this.value?.host ?? '',
+      paths:    this.value?.http?.paths ?? [{ id: random32(1) }],
       ruleMode: this.value.asDefault ? 'asDefault' : 'setHost',
     };
   },

package/edit/networking.k8s.io.ingress/RulePath.vue

@@ -34,24 +34,21 @@ export default {
       type: Object,
     }
   },
-  data() {
+  setup() {
     const pathTypes = [
       'Prefix',
       'Exact',
       'ImplementationSpecific'
     ];
 
-    set(this.value, 'backend', this.value.backend || {});
-    set(this.value, 'path', this.value.path || '');
-    set(this.value, 'pathType', this.value.pathType || pathTypes[0]);
-    set(this.value.backend, this.ingress.serviceNamePath, get(this.value.backend, this.ingress.serviceNamePath) || '');
-    set(this.value.backend, this.ingress.servicePortPath, get(this.value.backend, this.ingress.servicePortPath) || '');
-
-    const serviceName = get(this.value.backend, this.ingress.serviceNamePath);
-    const servicePort = get(this.value.backend, this.ingress.servicePortPath);
-
+    return { pathTypes };
+  },
+  data() {
     return {
-      pathTypes, serviceName, servicePort, pathType: this.value.pathType, path: this.value.path
+      serviceName: undefined,
+      servicePort: undefined,
+      pathType:    this.value.pathType,
+      path:        this.value.path,
     };
   },
   computed: {
@@ -77,6 +74,15 @@ export default {
   created() {
     this.queueUpdate = debounce(this.update, 500);
     this.queueUpdatePathTypeAndPath = debounce(this.updatePathTypeAndPath, 500);
+
+    set(this.value, 'backend', this.value.backend || {});
+    set(this.value, 'path', this.value.path || '');
+    set(this.value, 'pathType', this.value.pathType || this.pathTypes[0]);
+    set(this.value.backend, this.ingress.serviceNamePath, get(this.value.backend, this.ingress.serviceNamePath) || '');
+    set(this.value.backend, this.ingress.servicePortPath, get(this.value.backend, this.ingress.servicePortPath) || '');
+
+    this.serviceName = get(this.value.backend, this.ingress.serviceNamePath);
+    this.servicePort = get(this.value.backend, this.ingress.servicePortPath);
   },
   methods: {
     update() {

package/edit/networking.k8s.io.ingress/__tests__/Certificate.test.ts

@@ -0,0 +1,165 @@
+import { shallowMount } from '@vue/test-utils';
+import Certificate from '../Certificate.vue';
+
+const DEFAULT_CERT_VALUE = '__[[DEFAULT_CERT]]__';
+
+const createWrapper = (propsData = {}) => {
+  return shallowMount(Certificate, { propsData });
+};
+
+describe('networking.k8s.io.ingress/Certificate.vue', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('initializes with default values', () => {
+    const wrapper = createWrapper();
+
+    expect(wrapper.vm.hosts).toStrictEqual(['']);
+    expect(wrapper.vm.secretVal).toStrictEqual(DEFAULT_CERT_VALUE);
+    expect(wrapper.vm.secretName).toStrictEqual(DEFAULT_CERT_VALUE);
+  });
+
+  it('initializes with provided props', () => {
+    const value = { hosts: ['host1', 'host2'], secretName: 'some-secret' };
+    const certs = ['cert1', 'cert2'];
+    const rules = { host: ['rule1'] };
+    const wrapper = createWrapper({
+      value, certs, rules
+    });
+
+    expect(wrapper.vm.hosts).toStrictEqual(['host1', 'host2']);
+    expect(wrapper.vm.secretVal).toStrictEqual('some-secret');
+    expect(wrapper.vm.secretName).toStrictEqual('some-secret');
+    expect(wrapper.vm.certs).toStrictEqual(certs);
+    expect(wrapper.vm.rules).toStrictEqual(rules);
+  });
+
+  it('emits update:value when update is called', async() => {
+    const wrapper = createWrapper();
+
+    wrapper.vm.hosts = ['host1'];
+    wrapper.vm.secretVal = 'cert1';
+    wrapper.vm.update();
+    await wrapper.vm.$nextTick();
+    expect(wrapper.emitted('update:value')).toBeTruthy();
+    expect(wrapper.emitted('update:value')[0][0]).toStrictEqual({
+      hosts:      ['host1'],
+      secretName: 'cert1',
+    });
+  });
+
+  it('sets secretName to null when secretVal is DEFAULT_CERT_VALUE', async() => {
+    const wrapper = createWrapper();
+
+    wrapper.vm.hosts = ['host1'];
+    wrapper.vm.secretVal = DEFAULT_CERT_VALUE;
+    wrapper.vm.update();
+    await wrapper.vm.$nextTick();
+    expect(wrapper.emitted('update:value')[0][0].secretName).toBeNull();
+  });
+
+  it('updates secretVal when onSecretInput is called with an object', async() => {
+    const wrapper = createWrapper();
+    const newCert = { label: 'cert1', value: 'cert1' };
+
+    wrapper.vm.onSecretInput(newCert);
+    await wrapper.vm.$nextTick();
+    expect(wrapper.vm.secretVal).toStrictEqual('cert1');
+    expect(wrapper.emitted('update:value')).toBeTruthy();
+    expect(wrapper.emitted('update:value')[0][0].secretName).toStrictEqual('cert1');
+  });
+
+  it('updates secretVal when onSecretInput is called with a string', async() => {
+    const wrapper = createWrapper();
+
+    wrapper.vm.onSecretInput('cert1');
+    await wrapper.vm.$nextTick();
+    expect(wrapper.vm.secretVal).toStrictEqual('cert1');
+    expect(wrapper.emitted('update:value')).toBeTruthy();
+    expect(wrapper.emitted('update:value')[0][0].secretName).toStrictEqual('cert1');
+  });
+
+  it('updates hosts when onHostsInput is called', async() => {
+    const wrapper = createWrapper();
+
+    wrapper.vm.onHostsInput(['host1', 'host2']);
+    await wrapper.vm.$nextTick();
+    expect(wrapper.vm.hosts).toStrictEqual(['host1', 'host2']);
+    expect(wrapper.emitted('update:value')).toBeTruthy();
+    expect(wrapper.emitted('update:value')[0][0].hosts).toStrictEqual(['host1', 'host2']);
+  });
+
+  it('computes certsWithDefault correctly', () => {
+    const certs = ['cert1', 'cert2'];
+    const wrapper = createWrapper({ certs });
+    const expectedCerts = [
+      { label: '%ingress.certificates.defaultCertLabel%', value: DEFAULT_CERT_VALUE },
+      { label: 'cert1', value: 'cert1' },
+      { label: 'cert2', value: 'cert2' },
+    ];
+
+    expect(wrapper.vm.certsWithDefault).toStrictEqual(expectedCerts);
+  });
+
+  it('returns warning status for non-existent certificate', () => {
+    const wrapper = createWrapper({
+      certs: ['cert1', 'cert2'],
+      value: { hosts: [''], secretName: 'non-existent-cert' },
+    });
+
+    expect(wrapper.vm.certificateStatus).toStrictEqual('warning');
+  });
+
+  it('returns null status for existing certificate', () => {
+    const wrapper = createWrapper({
+      certs: ['cert1', 'cert2'],
+      value: { hosts: [''], secretName: 'cert1' },
+    });
+
+    expect(wrapper.vm.certificateStatus).toBeNull();
+  });
+
+  it('returns null status for default certificate', () => {
+    const wrapper = createWrapper({
+      certs: ['cert1', 'cert2'],
+      value: { hosts: [''], secretName: null },
+    });
+
+    expect(wrapper.vm.certificateStatus).toBeNull();
+  });
+
+  it('returns correct tooltip for non-existent certificate', () => {
+    const wrapper = createWrapper({
+      certs: ['cert1', 'cert2'],
+      value: { hosts: [''], secretName: 'non-existent-cert' },
+    });
+
+    expect(wrapper.vm.certificateTooltip).toStrictEqual('%ingress.certificates.certificate.doesntExist%');
+  });
+
+  it('returns null tooltip for existing certificate', () => {
+    const wrapper = createWrapper({
+      certs: ['cert1', 'cert2'],
+      value: { hosts: [''], secretName: 'cert1' },
+    });
+
+    expect(wrapper.vm.certificateTooltip).toBeNull();
+  });
+
+  it('watches value prop changes', async() => {
+    const wrapper = createWrapper({ value: { hosts: ['host1'], secretName: 'cert1' } });
+
+    await wrapper.setProps({ value: { hosts: ['host2'], secretName: 'cert2' } });
+    expect(wrapper.vm.hosts).toStrictEqual(['host2']);
+    expect(wrapper.vm.secretVal).toStrictEqual('cert2');
+    expect(wrapper.vm.secretName).toStrictEqual('cert2');
+  });
+
+  it('handles null secretName in value prop', async() => {
+    const wrapper = createWrapper({ value: { hosts: ['host1'], secretName: null } });
+
+    expect(wrapper.vm.secretVal).toStrictEqual(DEFAULT_CERT_VALUE);
+    expect(wrapper.vm.secretName).toBeNull();
+  });
+});

package/edit/networking.k8s.io.networkpolicy/PolicyRuleTarget.vue

@@ -47,16 +47,6 @@ export default {
     },
   },
   data() {
-    if (!this.value[TARGET_OPTIONS.IP_BLOCK] &&
-      !this.value[TARGET_OPTIONS.POD_SELECTOR] &&
-      !this.value[TARGET_OPTIONS.NAMESPACE_SELECTOR] &&
-      !this.value[TARGET_OPTIONS.NAMESPACE_AND_POD_SELECTOR]
-    ) {
-      this.$nextTick(() => {
-        this.value[TARGET_OPTIONS.IP_BLOCK] = {};
-      });
-    }
-
     return {
       portOptions:  ['TCP', 'UDP'],
       matchingPods: {
@@ -74,6 +64,17 @@ export default {
       debouncedUpdateMatches: debounce(this.updateMatches, 500)
     };
   },
+  created() {
+    if (!this.value[TARGET_OPTIONS.IP_BLOCK] &&
+      !this.value[TARGET_OPTIONS.POD_SELECTOR] &&
+      !this.value[TARGET_OPTIONS.NAMESPACE_SELECTOR] &&
+      !this.value[TARGET_OPTIONS.NAMESPACE_AND_POD_SELECTOR]
+    ) {
+      this.$nextTick(() => {
+        this.value[TARGET_OPTIONS.IP_BLOCK] = {};
+      });
+    }
+  },
   computed: {
     /**
      * of type matchExpression aka `KubeLabelSelectorExpression[]`

package/edit/networking.k8s.io.networkpolicy/PolicyRules.vue

@@ -32,12 +32,10 @@ export default {
       default: undefined
     }
   },
-  data() {
+  created() {
     if (!this.value.spec[this.type]) {
       this.value.spec[this.type] = [];
     }
-
-    return {};
   },
   methods: {
     addPolicyRule() {

package/edit/networking.k8s.io.networkpolicy/index.vue

@@ -47,6 +47,23 @@ export default {
   },
 
   data() {
+    return {
+      POD,
+      matchingPods: {
+        matched: 0,
+        matches: [],
+        none:    true,
+        sample:  null,
+        total:   0,
+      },
+      podTableHeaders: this.$store.getters['type-map/headersFor'](
+        this.$store.getters['cluster/schemaFor'](POD)
+      ),
+      inStore: this.$store.getters['currentProduct'].inStore,
+    };
+  },
+
+  created() {
     if ( !this.value.spec ) {
       this.value['spec'] = {
         policyTypes: [],
@@ -56,23 +73,6 @@ export default {
         }
       };
     }
-
-    const matchingPods = {
-      matched: 0,
-      matches: [],
-      none:    true,
-      sample:  null,
-      total:   0,
-    };
-
-    return {
-      POD,
-      matchingPods,
-      podTableHeaders: this.$store.getters['type-map/headersFor'](
-        this.$store.getters['cluster/schemaFor'](POD)
-      ),
-      inStore: this.$store.getters['currentProduct'].inStore,
-    };
   },
 
   computed: {

package/edit/provisioning.cattle.io.cluster/__tests__/rke2.test.ts

@@ -240,11 +240,12 @@ describe('component: rke2', () => {
 
     // we need to mock the "save" method from the create-edit-view-mixin
     // otherwise we get console errors
-    jest.spyOn(wrapper.vm, 'save').mockImplementation();
+    // jest.spyOn(wrapper.vm, 'save').mockImplementation();
 
     await wrapper.vm._doSaveOverride(jest.fn());
+    const chartKey = wrapper.vm.chartVersionKey(HARVESTER_CLOUD_PROVIDER);
 
-    const cloudConfigPath = get(wrapper.vm.chartValues, `${ HARVESTER_CLOUD_PROVIDER }.cloudConfigPath`);
+    const cloudConfigPath = get(wrapper.vm.userChartValues, `${ chartKey }.cloudConfigPath`);
 
     expect(cloudConfigPath).toStrictEqual('my-k8s-distro-path/etc/config-files/cloud-provider-config');
   });