mirror of https://github.com/rancher/dashboard.git
1225 lines
39 KiB
TypeScript
1225 lines
39 KiB
TypeScript
import { mount } from '@vue/test-utils';
|
|
import flushPromises from 'flush-promises';
|
|
import FleetClusterTargets from '@shell/components/fleet/FleetClusterTargets/index.vue';
|
|
import { _CREATE, _EDIT } from '@shell/config/query-params';
|
|
import { Selector } from '@shell/types/fleet';
|
|
|
|
describe('component: FleetClusterTargets', () => {
|
|
describe('mode: edit', () => {
|
|
const mode = _EDIT;
|
|
|
|
describe('decode spec.targets and set form data', () => {
|
|
it('should build form source data from target with clusterName and clusterSelector', () => {
|
|
const target1 = {
|
|
clusterName: 'fleet-5-france',
|
|
clusterSelector: { matchLabels: { foo: 'true' } }
|
|
};
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual([target1.clusterName]);
|
|
expect(clusterSelectors[0].matchLabels).toStrictEqual(target1.clusterSelector.matchLabels);
|
|
expect(clusterSelectors[0].matchExpressions).toBeUndefined();
|
|
});
|
|
|
|
it('should set targetMode to "all" and correctly filter clusterSelector for harvester rule', () => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}]
|
|
}
|
|
};
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('all');
|
|
expect(clusterSelectors).toStrictEqual([]); // Harvester rule should be filtered out
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
});
|
|
|
|
it('should set targetMode to "clusters" and populate selectedClusters and clusterSelectors', () => {
|
|
const target1 = { clusterName: 'fleet-5-france' };
|
|
|
|
const target2 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual(['fleet-5-france']);
|
|
expect(clusterSelectors).toStrictEqual([{
|
|
key: 0,
|
|
matchLabels: { foo: 'true' },
|
|
matchExpressions: undefined
|
|
}]);
|
|
});
|
|
|
|
it('should set targetMode to "clusters" and populate clusterSelectors with multiple entries', () => {
|
|
const target1 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
const target2 = { clusterSelector: { matchLabels: { hci: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([{
|
|
key: 0,
|
|
matchLabels: { foo: 'true' },
|
|
matchExpressions: undefined
|
|
}, {
|
|
key: 1,
|
|
matchLabels: { hci: 'true' },
|
|
matchExpressions: undefined
|
|
}]);
|
|
});
|
|
|
|
it('should set targetMode to "advanced" and return early if clusterGroupSelector is present', () => {
|
|
const target1 = { clusterGroupSelector: {} };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('advanced');
|
|
// Expect no further processing for selectedClusters or clusterSelectors due to early return
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should set targetMode to "advanced" and return early if clusterGroup is present', () => {
|
|
const target1 = {
|
|
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',
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('advanced');
|
|
// Expect no further processing for selectedClusters or clusterSelectors due to early return
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should return early and not modify state if targets is empty', () => {
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [],
|
|
namespace: 'fleet-default',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('none');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should return targetMode local if namespace is fleet-local', () => {
|
|
const target1 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-local',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
|
|
expect(targetMode).toBe('local');
|
|
});
|
|
|
|
it('should handle targets with multiple clusterName', () => {
|
|
const target1 = { clusterName: 'prod-cluster' };
|
|
const target2 = { clusterName: 'test-cluster' };
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual(['prod-cluster', 'test-cluster']);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should filter out harvester rule and leave others', () => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}, {
|
|
key: 'foo',
|
|
operator: 'In',
|
|
values: ['bar']
|
|
}]
|
|
}
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([{
|
|
key: 0,
|
|
matchLabels: undefined,
|
|
matchExpressions: [{
|
|
key: 'foo',
|
|
operator: 'In',
|
|
values: ['bar']
|
|
}]
|
|
}]);
|
|
});
|
|
|
|
it('should correctly process targets when targetMode is "all" and no clusterName or clusterSelector is present', () => {
|
|
const target1 = { name: 'simple-target' };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('all');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should correctly process targets when targetMode is "all", name is defined and harvester rule is present', () => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}]
|
|
},
|
|
name: 'simple-target'
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('all');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]); // Harvester rule should be filtered out
|
|
});
|
|
});
|
|
|
|
describe('decode form data and emit to spec.targets', () => {
|
|
it('should emit target with clusterName and clusterSelector', async() => {
|
|
const target1 = {
|
|
clusterName: 'fleet-5-france',
|
|
clusterSelector: { matchLabels: { foo: 'true' } }
|
|
};
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{ clusterName: 'fleet-5-france' }, { clusterSelector: { matchLabels: { foo: 'true' } } }]);
|
|
});
|
|
|
|
it('should emit harvester exclude rule', async() => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}]
|
|
}
|
|
};
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io', operator: 'NotIn', values: ['harvester']
|
|
}]
|
|
}
|
|
}]);
|
|
});
|
|
|
|
it('should emit multiple targets with clusterName and clusterSelector', async() => {
|
|
const target1 = { clusterName: 'fleet-5-france' };
|
|
|
|
const target2 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{ clusterName: 'fleet-5-france' }, { clusterSelector: { matchLabels: { foo: 'true' } } }]);
|
|
});
|
|
|
|
it('should emit multiple targets containing both clusterSelector fields', async() => {
|
|
const target1 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
const target2 = { clusterSelector: { matchLabels: { hci: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{ clusterSelector: { matchLabels: { foo: 'true' } } }, { clusterSelector: { matchLabels: { hci: 'true' } } }]);
|
|
});
|
|
|
|
it('should emit advanced cases untouched', async() => {
|
|
const target1 = { clusterGroupSelector: {} };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{ clusterGroupSelector: {} }]);
|
|
});
|
|
|
|
it('should emit full target definition', async() => {
|
|
const target1 = {
|
|
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',
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{
|
|
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'
|
|
}]);
|
|
});
|
|
|
|
it('should emit harvester rule from empty targets source', async() => {
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [], // targetMode === 'none'
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toBeUndefined();
|
|
});
|
|
|
|
it('should emit untouched targets from source when operating in fleet-local workspace', async() => {
|
|
const target1 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-local',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{ clusterSelector: { matchLabels: { foo: 'true' } } }]);
|
|
});
|
|
|
|
it('should emit custom targets filtering out harvester rule', async() => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}, {
|
|
key: 'foo',
|
|
operator: 'In',
|
|
values: ['bar']
|
|
}]
|
|
}
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'foo', operator: 'In', values: ['bar']
|
|
}]
|
|
}
|
|
}]);
|
|
});
|
|
|
|
it('should emit targets excluding target names and adding harvester rule', async() => {
|
|
const target1 = { name: 'simple-target' };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io', operator: 'NotIn', values: ['harvester']
|
|
}]
|
|
}
|
|
}]);
|
|
});
|
|
|
|
it('should emit targets excluding target names and harvester rule if present in source targets', async() => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}]
|
|
},
|
|
name: 'simple-target'
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io', operator: 'NotIn', values: ['harvester']
|
|
}]
|
|
}
|
|
}]);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('mode: create', () => {
|
|
const mode = _CREATE;
|
|
|
|
describe('decode spec.targets and set form data', () => {
|
|
it('should build form source data from target with clusterName and clusterSelector', () => {
|
|
const target1 = {
|
|
clusterName: 'fleet-5-france',
|
|
clusterSelector: { matchLabels: { foo: 'true' } }
|
|
};
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
created: 'clusters'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual([target1.clusterName]);
|
|
expect(clusterSelectors[0].matchLabels).toStrictEqual(target1.clusterSelector.matchLabels);
|
|
expect(clusterSelectors[0].matchExpressions).toBeUndefined();
|
|
});
|
|
|
|
it('should set targetMode to "all" and correctly filter clusterSelector for harvester rule', () => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}]
|
|
}
|
|
};
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('all');
|
|
expect(clusterSelectors).toStrictEqual([]); // Harvester rule should be filtered out
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
});
|
|
|
|
it('should set targetMode to "clusters" and populate selectedClusters and clusterSelectors', () => {
|
|
const target1 = { clusterName: 'fleet-5-france' };
|
|
|
|
const target2 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
created: 'clusters'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual(['fleet-5-france']);
|
|
expect(clusterSelectors).toStrictEqual([{
|
|
key: 0,
|
|
matchLabels: { foo: 'true' },
|
|
matchExpressions: undefined
|
|
}]);
|
|
});
|
|
|
|
it('should set targetMode to "clusters" and populate clusterSelectors with multiple entries', () => {
|
|
const target1 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
const target2 = { clusterSelector: { matchLabels: { hci: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
created: 'clusters'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([{
|
|
key: 0,
|
|
matchLabels: { foo: 'true' },
|
|
matchExpressions: undefined
|
|
}, {
|
|
key: 1,
|
|
matchLabels: { hci: 'true' },
|
|
matchExpressions: undefined
|
|
}]);
|
|
});
|
|
|
|
it('should set targetMode to "advanced" and return early if clusterGroupSelector is present', () => {
|
|
const target1 = { clusterGroupSelector: {} };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
created: 'advanced'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('advanced');
|
|
// Expect no further processing for selectedClusters or clusterSelectors due to early return
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should set targetMode to "advanced" and return early if clusterGroup is present', () => {
|
|
const target1 = {
|
|
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',
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
created: 'advanced'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('advanced');
|
|
// Expect no further processing for selectedClusters or clusterSelectors due to early return
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should return early and not modify state if targets is empty', () => {
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
created: 'none'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('none');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should return targetMode local if namespace is fleet-local', () => {
|
|
const target1 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-local',
|
|
mode,
|
|
created: 'local'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
|
|
expect(targetMode).toBe('local');
|
|
});
|
|
|
|
it('should handle targets with multiple clusterName', () => {
|
|
const target1 = { clusterName: 'prod-cluster' };
|
|
const target2 = { clusterName: 'test-cluster' };
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
created: 'clusters'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual(['prod-cluster', 'test-cluster']);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should filter out harvester rule and leave others', () => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}, {
|
|
key: 'foo',
|
|
operator: 'In',
|
|
values: ['bar']
|
|
}]
|
|
}
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
created: 'clusters'
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('clusters');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([{
|
|
key: 0,
|
|
matchLabels: undefined,
|
|
matchExpressions: [{
|
|
key: 'foo',
|
|
operator: 'In',
|
|
values: ['bar']
|
|
}]
|
|
}]);
|
|
});
|
|
|
|
it('should correctly process targets when targetMode is "all" and no clusterName or clusterSelector is present', () => {
|
|
const target1 = { name: 'simple-target' };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('all');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]);
|
|
});
|
|
|
|
it('should correctly process targets when targetMode is "all", name is defined and harvester rule is present', () => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}]
|
|
},
|
|
name: 'simple-target'
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
const targetMode = wrapper.vm.targetMode;
|
|
const selectedClusters = wrapper.vm.selectedClusters;
|
|
const clusterSelectors = wrapper.vm.clusterSelectors as Selector[];
|
|
|
|
expect(targetMode).toBe('all');
|
|
expect(selectedClusters).toStrictEqual([]);
|
|
expect(clusterSelectors).toStrictEqual([]); // Harvester rule should be filtered out
|
|
});
|
|
});
|
|
|
|
describe('decode form data and emit to spec.targets', () => {
|
|
it('should emit target with clusterName and clusterSelector', async() => {
|
|
const target1 = {
|
|
clusterName: 'fleet-5-france',
|
|
clusterSelector: { matchLabels: { foo: 'true' } }
|
|
};
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.setData({ targetMode: 'clusters' });
|
|
|
|
wrapper.vm.update();
|
|
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[1][0]).toStrictEqual([{ clusterName: 'fleet-5-france' }, { clusterSelector: { matchLabels: { foo: 'true' } } }]);
|
|
});
|
|
|
|
it('should emit harvester exclude rule', async() => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}]
|
|
}
|
|
};
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io', operator: 'NotIn', values: ['harvester']
|
|
}]
|
|
}
|
|
}]);
|
|
});
|
|
|
|
it('should emit multiple targets with clusterName and clusterSelector', async() => {
|
|
const target1 = { clusterName: 'fleet-5-france' };
|
|
|
|
const target2 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.setData({ targetMode: 'clusters' });
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[1][0]).toStrictEqual([{ clusterName: 'fleet-5-france' }, { clusterSelector: { matchLabels: { foo: 'true' } } }]);
|
|
});
|
|
|
|
it('should emit multiple targets containing both clusterSelector fields', async() => {
|
|
const target1 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
const target2 = { clusterSelector: { matchLabels: { hci: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1, target2],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.setData({ targetMode: 'clusters' });
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[1][0]).toStrictEqual([{ clusterSelector: { matchLabels: { foo: 'true' } } }, { clusterSelector: { matchLabels: { hci: 'true' } } }]);
|
|
});
|
|
|
|
it('should emit advanced cases untouched', async() => {
|
|
const target1 = { clusterGroupSelector: {} };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.setData({ targetMode: 'advanced' });
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[1][0]).toStrictEqual([{ clusterGroupSelector: {} }]);
|
|
});
|
|
|
|
it('should emit full target definition', async() => {
|
|
const target1 = {
|
|
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',
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.setData({ targetMode: 'advanced' });
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[1][0]).toStrictEqual([{
|
|
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'
|
|
}]);
|
|
});
|
|
|
|
it('should emit harvester rule from empty targets source', async() => {
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [], // targetMode === 'none'
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.setData({ targetMode: 'none' });
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[1][0]).toBeUndefined();
|
|
});
|
|
|
|
it('should emit untouched targets from source when operating in fleet-local workspace', async() => {
|
|
const target1 = { clusterSelector: { matchLabels: { foo: 'true' } } };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-local',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.setData({ targetMode: 'clusters' });
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[1][0]).toStrictEqual([{ clusterSelector: { matchLabels: { foo: 'true' } } }]);
|
|
});
|
|
|
|
it('should emit custom targets filtering out harvester rule', async() => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}, {
|
|
key: 'foo',
|
|
operator: 'In',
|
|
values: ['bar']
|
|
}]
|
|
}
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.setData({ targetMode: 'clusters' });
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[1][0]).toStrictEqual([{
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'foo', operator: 'In', values: ['bar']
|
|
}]
|
|
}
|
|
}]);
|
|
});
|
|
|
|
it('should emit targets excluding target names and adding harvester rule', async() => {
|
|
const target1 = { name: 'simple-target' };
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io', operator: 'NotIn', values: ['harvester']
|
|
}]
|
|
}
|
|
}]);
|
|
});
|
|
|
|
it('should emit targets excluding target names and harvester rule if present in source targets', async() => {
|
|
const target1 = {
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io',
|
|
operator: 'NotIn',
|
|
values: ['harvester']
|
|
}]
|
|
},
|
|
name: 'simple-target'
|
|
};
|
|
|
|
const wrapper = mount(FleetClusterTargets, {
|
|
props: {
|
|
targets: [target1],
|
|
namespace: 'fleet-default',
|
|
mode,
|
|
},
|
|
});
|
|
|
|
wrapper.vm.update();
|
|
await flushPromises();
|
|
|
|
expect(wrapper.emitted('update:value')?.[0][0]).toStrictEqual([{
|
|
clusterSelector: {
|
|
matchExpressions: [{
|
|
key: 'provider.cattle.io', operator: 'NotIn', values: ['harvester']
|
|
}]
|
|
}
|
|
}]);
|
|
});
|
|
});
|
|
});
|
|
});
|