@rancher/shell 1.2.3 → 2.0.1

package/edit/__tests__/nodeDriver.test.ts

@@ -0,0 +1,107 @@
+/* eslint-disable jest/no-hooks */
+import { mount } from '@vue/test-utils';
+import NodeDriverEdit from '@shell/edit/nodeDriver.vue';
+import { _CREATE } from '@shell/config/query-params';
+
+describe('view: nodedriver should', () => {
+  const url = 'http://test.com';
+  let wrapper: any;
+  const requiredSetup = () => ({
+    mocks: {
+      $store: {
+        getters: {
+          currentStore:              () => 'current_store',
+          'current_store/schemaFor': jest.fn(),
+          'current_store/all':       jest.fn(),
+          'i18n/t':                  (val: string) => val,
+          'i18n/exists':             jest.fn(),
+        },
+        dispatch: jest.fn()
+      },
+      $route:  { query: { AS: '' } },
+      $router: { applyQuery: jest.fn() },
+    },
+    propsData: {
+      value: {
+        spec: {
+          active:           true,
+          checksum:         '',
+          url:              '',
+          uiUrl:            '',
+          whitelistDomains: []
+        }
+      },
+      mode: _CREATE,
+    },
+  });
+
+  beforeEach(() => {
+    wrapper = mount(NodeDriverEdit, { ...requiredSetup() });
+  });
+
+  afterEach(() => {
+    wrapper.destroy();
+  });
+
+  it('have "Create" button disabled before fields are filled in', () => {
+    const saveButton = wrapper.find('[data-testid="node-driver-edit-save"]').element as HTMLInputElement;
+
+    expect(saveButton.disabled).toBe(true);
+  });
+
+  it('have "Create" button enabled when required fields are filled in', async() => {
+    const urlField = wrapper.find('[data-testid="driver-create-url-field"]').find('input');
+    const saveButton = wrapper.find('[data-testid="node-driver-edit-save"]').element as HTMLInputElement;
+
+    urlField.setValue(url);
+
+    await wrapper.vm.$nextTick();
+
+    expect(saveButton.disabled).toBe(false);
+  });
+
+  it('have "Create" button enabled and disabled depending on validation results', async() => {
+    const urlField = wrapper.find('[data-testid="driver-create-url-field"]').find('input');
+    const uiurlField = wrapper.find('[data-testid="driver-create-uiurl-field"]').find('input');
+    const checksumField = wrapper.find('[data-testid="driver-create-checksum-field"]').find('input');
+    const saveButton = wrapper.find('[data-testid="node-driver-edit-save"]').element as HTMLInputElement;
+
+    const testCases = [
+      {
+        url:      '1111',
+        uiurl:    'http://test.com',
+        checksum: 'aaaaaBBBBdddd',
+        result:   true
+      },
+      {
+        url:      'http://test.com',
+        uiurl:    '1111',
+        checksum: 'aaaaaBBBBdddd',
+        result:   true
+      },
+      {
+        url:      'http://test.com',
+        uiurl:    'http://test.com',
+        checksum: '!!!',
+        result:   true
+      },
+      {
+        url:      'http://test.com',
+        uiurl:    'http://test.com',
+        checksum: 'aaaaaBBBBdddd',
+        result:   false
+      }
+    ];
+
+    for (const testCase of testCases) {
+      urlField.setValue(testCase.url);
+      await wrapper.vm.$nextTick();
+      uiurlField.setValue(testCase.uiurl);
+      await wrapper.vm.$nextTick();
+      checksumField.setValue(testCase.checksum);
+      await wrapper.vm.$nextTick();
+
+      expect(saveButton.disabled).toBe(testCase.result);
+    }
+  });
+});

package/edit/__tests__/service.test.ts

@@ -0,0 +1,85 @@
+import { shallowMount, Wrapper } from '@vue/test-utils';
+import { _CLONE } from '@shell/config/query-params';
+import ServicePage from '@shell/edit/service.vue';
+
+const createEditViewMock = {
+  data() {
+    return { errors: [] };
+  },
+  computed: {
+    isCreate:     () => false,
+    isEdit:       () => true,
+    isView:       () => false,
+    schema:       () => ({}),
+    isNamespaced: () => false,
+    labels:       {
+      get: jest.fn(() => ({})),
+      set: jest.fn(),
+    },
+    annotations: {
+      get: jest.fn(() => ({})),
+      set: jest.fn(),
+    },
+    doneRoute:  () => 'mockedRoute',
+    doneParams: () => ({}),
+  },
+  methods: {
+    done:         jest.fn(),
+    conflict:     jest.fn(() => Promise.resolve([])),
+    save:         jest.fn(() => Promise.resolve()),
+    actuallySave: jest.fn(() => Promise.resolve()),
+    setErrors:    jest.fn()
+  }
+};
+
+const formValidationMock = {};
+
+describe('service edit', () => {
+  let wrapper: Wrapper<InstanceType<typeof ServicePage>>;
+
+  const createComponent = (propsData: any) => {
+    wrapper = shallowMount(ServicePage,
+      {
+        propsData,
+        mixins: [createEditViewMock, formValidationMock],
+        mocks:  {
+          $store: {
+            getters: {
+              'management/all': jest.fn(),
+              'i18n/t':         jest.fn()
+            }
+          }
+        },
+        computed: { provisioningCluster: jest.fn() },
+      }
+    );
+  };
+
+  it('sets clusterIP to an empty string and deletes clusterIPs when in clone mode', () => {
+    const value = {
+      spec: {
+        clusterIP:  '10.43.1.1',
+        clusterIPs: ['10.43.1.1', '10.43.1.2'],
+      }
+    };
+
+    createComponent({ realMode: _CLONE, value });
+
+    expect(wrapper.vm.value.spec.clusterIP).toBe('');
+    expect(wrapper.vm.value.spec.clusterIPs).toBeUndefined();
+  });
+
+  it('does not change clusterIP and clusterIPs when not in clone mode', () => {
+    const value = {
+      spec: {
+        clusterIP:  '10.43.1.1',
+        clusterIPs: ['10.43.1.1', '10.43.1.2'],
+      }
+    };
+
+    createComponent({ realMode: 'someOtherMode', value });
+
+    expect(wrapper.vm.value.spec.clusterIP).toBe('10.43.1.1');
+    expect(wrapper.vm.value.spec.clusterIPs).toStrictEqual(['10.43.1.1', '10.43.1.2']);
+  });
+});

package/edit/__tests__/ui.cattle.io.navlink.test.ts

@@ -13,12 +13,14 @@ describe('view: ui.cattle.io.navlink should', () => {
     // Remove all these mocks after migration to Vue 2.7/3 due mixin logic
     mocks: {
       $store: {
-        getters: {
+        dispatch: jest.fn(),
+        getters:  {
           currentStore:              () => 'current_store',
           'current_store/schemaFor': jest.fn(),
           'current_store/all':       jest.fn(),
           'i18n/t':                  (val) => val,
           'i18n/exists':             jest.fn(),
+          'store/customisation/':    jest.fn()
         }
       },
       $route:  { query: { AS: '' } },

package/edit/auth/AuthProviderWarningBanners.vue

@@ -0,0 +1,34 @@
+<script lang="ts">
+import { defineComponent } from 'vue';
+import { Banner } from '@components/Banner';
+
+export default defineComponent({
+  name: 'AuthProviderWarningBanners',
+
+  components: { Banner },
+
+  props: {
+    tArgs: {
+      type:     Object,
+      required: true,
+      default:  () => { },
+    }
+  }
+});
+</script>
+
+<template>
+  <div>
+    <Banner
+      :label="t('authConfig.stateBanner.disabled', tArgs)"
+      color="warning"
+      data-testid="auth-provider-disabled-warning-banner"
+    />
+    <Banner
+      color="warning"
+      data-testid="auth-provider-admin-permissions-warning-banner"
+    >
+      <span v-clean-html="t('authConfig.associatedWarning', tArgs, true)" />
+    </Banner>
+  </div>
+</template>

package/edit/auth/__tests__/AuthProviderWarningBanners.test.ts

@@ -0,0 +1,19 @@
+import AuthProviderWarningBanners from '@shell/edit/auth/AuthProviderWarningBanners.vue';
+import { mount } from '@vue/test-utils';
+
+describe('component: AuthProviderWarningBanners.vue', () => {
+  const wrapper = mount(AuthProviderWarningBanners, {
+    mocks:     { $store: { getters: { 'i18n/t': (text: string) => text } } },
+    propsData: { tArgs: { provider: 'Any Provider', username: 'username' } }
+  });
+
+  it('should render properly', () => {
+    const providerDisabledWarningBanner = wrapper.find('[data-testid="auth-provider-disabled-warning-banner"]');
+    const adminPermissionsWarningBanner = wrapper.find('[data-testid="auth-provider-admin-permissions-warning-banner"]');
+
+    expect(providerDisabledWarningBanner.element).toBeDefined();
+    expect(providerDisabledWarningBanner.isVisible()).toBe(true);
+    expect(adminPermissionsWarningBanner.element).toBeDefined();
+    expect(adminPermissionsWarningBanner.isVisible()).toBe(true);
+  });
+});

package/edit/auth/__tests__/azuread.test.ts

@@ -0,0 +1,241 @@
+/* eslint-disable jest/no-hooks */
+import { mount } from '@vue/test-utils';
+import AzureAD from '@shell/edit/auth/azuread.vue';
+import { _EDIT } from '@shell/config/query-params';
+
+jest.mock('@shell/utils/clipboard', () => {
+  return { copyTextToClipboard: jest.fn(() => Promise.resolve({})) };
+});
+
+const validTenantId = '564b6f53-ebf4-43c3-8077-44c56a44990a';
+const validApplicationId = '18cca356-170e-4bd9-a4a4-2e349855f96b';
+const validAppSecret = 'test';
+const validEndpoint = 'https://login.microsoftonline.com/';
+const validAuthEndpoint = 'https://login.microsoftonline.com/564b6f53-ebf4-43c3-8077-44c56a44990a/oauth2/v2.0/authorize';
+const validTokenEndpoint = 'https://login.microsoftonline.com/564b6f53-ebf4-43c3-8077-44c56a44990a/oauth2/v2.0/token';
+const validGraphEndpoint = 'https://graph.microsoft.com';
+
+const invalidEndpoint = 'aaaaBBBBaaaa';
+const invalidAuthEndpoint = 'aaa';
+const invalidTokenEndpoint = 'aaaaBBBBaaaa';
+const invalidGraphEndpoint = 'aaaaBBBBaaaa';
+
+const mockModel = {
+  enabled:  true,
+  id:       'azuread',
+  endpoint: 'https://login.microsoftonline.com/',
+  type:     'azureADConfig',
+};
+
+const mockedAuthConfigMixin = {
+  data() {
+    return {
+      sEnabling:      false,
+      editConfig:     false,
+      model:          { mockModel },
+      serverSetting:  null,
+      errors:         [],
+      originalModel:  null,
+      principals:     [],
+      authConfigName: 'azuread',
+    };
+  },
+  computed: {},
+  methods:  {}
+};
+
+describe('edit: azureAD should', () => {
+  let wrapper: any;
+  const requiredSetup = () => ({
+    mixins: [mockedAuthConfigMixin],
+    mocks:  {
+      $fetchState: { pending: false },
+      $store:      {
+        getters: {
+          currentStore:              () => 'current_store',
+          'current_store/schemaFor': jest.fn(),
+          'current_store/all':       jest.fn(),
+          'i18n/t':                  (val: string) => val,
+          'i18n/exists':             jest.fn(),
+        },
+        dispatch: jest.fn()
+      },
+      $route:  { query: { AS: '' }, params: { id: 'azure' } },
+      $router: { applyQuery: jest.fn() },
+    },
+    propsData: {
+      value: { applicationSecret: '' },
+      mode:  _EDIT,
+    },
+  });
+
+  beforeEach(() => {
+    wrapper = mount(AzureAD, { ...requiredSetup() });
+  });
+  afterEach(() => {
+    wrapper.destroy();
+  });
+
+  it('have "Create" button disabled before fields are filled in', () => {
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    expect(saveButton.disabled).toBe(true);
+  });
+
+  it.each([
+    {
+      tenantId:          '',
+      applicationId:     '',
+      applicationSecret: '',
+      result:            true
+    },
+    {
+      tenantId:          '',
+      applicationId:     validApplicationId,
+      applicationSecret: validAppSecret,
+      result:            true
+    },
+    {
+      tenantId:          validTenantId,
+      applicationId:     '',
+      applicationSecret: validAppSecret,
+      result:            true
+    },
+    {
+      tenantId:          validTenantId,
+      applicationId:     validApplicationId,
+      applicationSecret: '',
+      result:            true
+    },
+    {
+      tenantId:          validTenantId,
+      applicationId:     validApplicationId,
+      applicationSecret: validAppSecret,
+      result:            false
+    },
+  ])('has "Create" button enabled and disabled depending on validation results when endpoint is standard', async(testCase) => {
+    const tenantIdInputField = wrapper.find('[data-testid="input-azureAD-tenantId"]').find('input');
+    const applicationIdInputField = wrapper.find('[data-testid="input-azureAD-applcationId"]').find('input');
+    const applicationSecretInputField = wrapper.find('[data-testid="input-azureAD-applicationSecret"]').find('input');
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    tenantIdInputField.setValue(testCase.tenantId);
+    applicationIdInputField.setValue(testCase.applicationId);
+    applicationSecretInputField.setValue(testCase.applicationSecret);
+    await wrapper.vm.$nextTick();
+
+    expect(saveButton.disabled).toBe(testCase.result);
+  });
+
+  it.each([
+    {
+      endpoint:      '',
+      graphEndpoint: '',
+      tokenEndpoint: '',
+      authEndpoint:  '',
+      result:        true
+    },
+    {
+      endpoint:      invalidEndpoint,
+      graphEndpoint: invalidGraphEndpoint,
+      tokenEndpoint: invalidTokenEndpoint,
+      authEndpoint:  invalidAuthEndpoint,
+      result:        true
+    },
+    {
+      endpoint:      '',
+      graphEndpoint: validGraphEndpoint,
+      tokenEndpoint: validTokenEndpoint,
+      authEndpoint:  validAuthEndpoint,
+      result:        true
+    },
+    {
+      endpoint:      invalidEndpoint,
+      graphEndpoint: validGraphEndpoint,
+      tokenEndpoint: validTokenEndpoint,
+      authEndpoint:  validAuthEndpoint,
+      result:        true
+    },
+    {
+      endpoint:      validEndpoint,
+      graphEndpoint: '',
+      tokenEndpoint: validTokenEndpoint,
+      authEndpoint:  validAuthEndpoint,
+      result:        true
+    },
+    {
+      endpoint:      validEndpoint,
+      graphEndpoint: invalidGraphEndpoint,
+      tokenEndpoint: validTokenEndpoint,
+      authEndpoint:  validAuthEndpoint,
+      result:        true
+    },
+    {
+      endpoint:      validEndpoint,
+      graphEndpoint: validGraphEndpoint,
+      tokenEndpoint: '',
+      authEndpoint:  validAuthEndpoint,
+      result:        true
+    },
+    {
+      endpoint:      validEndpoint,
+      graphEndpoint: validGraphEndpoint,
+      tokenEndpoint: invalidTokenEndpoint,
+      authEndpoint:  validAuthEndpoint,
+      result:        true
+    },
+    {
+      endpoint:      validEndpoint,
+      graphEndpoint: validGraphEndpoint,
+      tokenEndpoint: validTokenEndpoint,
+      authEndpoint:  '',
+      result:        true
+    },
+    {
+      endpoint:      validEndpoint,
+      graphEndpoint: validGraphEndpoint,
+      tokenEndpoint: validTokenEndpoint,
+      authEndpoint:  invalidAuthEndpoint,
+      result:        true
+    },
+    {
+      endpoint:      validEndpoint,
+      graphEndpoint: validGraphEndpoint,
+      tokenEndpoint: validTokenEndpoint,
+      authEndpoint:  validAuthEndpoint,
+      result:        false
+    }
+  ])('has "Create" button enabled and disabled depending on validation results when endpoint is custom', async(testCase) => {
+    const tenantIdInputField = wrapper.find('[data-testid="input-azureAD-tenantId"]').find('input');
+    const applicationIdInputField = wrapper.find('[data-testid="input-azureAD-applcationId"]').find('input');
+    const applicationSecretInputField = wrapper.find('[data-testid="input-azureAD-applicationSecret"]').find('input');
+
+    const endpointsRG = wrapper.find('[data-testid="endpoints-radio-input"]');
+    const customButton = endpointsRG.findAll('.radio-label').at(2);
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    // populate fields tested in previous test first
+    tenantIdInputField.setValue(validTenantId);
+    applicationIdInputField.setValue(validApplicationId);
+    applicationSecretInputField.setValue(validAppSecret);
+    await wrapper.vm.$nextTick();
+
+    expect(saveButton.disabled).toBe(false);
+    customButton.trigger('click');
+    await wrapper.vm.$nextTick();
+    expect(saveButton.disabled).toBe(true);
+
+    const endpointInputField = wrapper.find('[data-testid="input-azureAD-endpoint"]').find('input');
+    const graphEndpointInputField = wrapper.find('[data-testid="input-azureAD-graphEndpoint"]').find('input');
+    const tokenEndpointInputField = wrapper.find('[data-testid="input-azureAD-tokenEndpoint"]').find('input');
+    const authEndpointInputField = wrapper.find('[data-testid="input-azureAD-authEndpoint"]').find('input');
+
+    endpointInputField.setValue(testCase.endpoint);
+    graphEndpointInputField.setValue(testCase.graphEndpoint);
+    tokenEndpointInputField.setValue(testCase.tokenEndpoint);
+    authEndpointInputField.setValue(testCase.authEndpoint);
+    await wrapper.vm.$nextTick();
+
+    expect(saveButton.disabled).toBe(testCase.result);
+  });
+});

package/edit/auth/__tests__/oidc.test.ts

@@ -0,0 +1,137 @@
+/* eslint-disable jest/no-hooks */
+import { mount } from '@vue/test-utils';
+import { _EDIT } from '@shell/config/query-params';
+
+import oidc from '@shell/edit/auth/oidc.vue';
+
+jest.mock('@shell/utils/clipboard', () => {
+  return { copyTextToClipboard: jest.fn(() => Promise.resolve({})) };
+});
+
+const validClientId = 'rancheroidc';
+const validClientSecret = 'TOkUxg0P67m1UXWNkJLHDPkUZFIKOWSq';
+const validUrl = 'https://localhost:8080';
+const validRealm = 'rancherrealm';
+const validRancherUrl = 'https://localhost/verify-auth';
+const validIssuer = 'http://localhost:8080/realms/rancherrealm';
+const validAuthEndpoint = 'http://localhost:8080/realms/rancherrealm/protocol/openid-connect/auth';
+const validScope = 'openid profile email';
+
+const mockModel = {
+  enabled:      false,
+  id:           'genericoidc',
+  rancherUrl:   validRancherUrl,
+  issuer:       validIssuer,
+  authEndpoint: validAuthEndpoint,
+  scope:        validScope,
+  clientId:     validClientId,
+  clientSecret: validClientSecret,
+  type:         'genericOIDCConfig',
+};
+
+const mockedAuthConfigMixin = {
+  data() {
+    return {
+      isEnabling:     false,
+      editConfig:     false,
+      model:          { ...mockModel },
+      serverSetting:  null,
+      errors:         [],
+      originalModel:  null,
+      principals:     [],
+      authConfigName: 'oidc',
+    };
+  },
+  computed: {},
+  methods:  {}
+};
+
+describe('oidc.vue', () => {
+  let wrapper: any;
+  const requiredSetup = () => ({
+    mixins: [mockedAuthConfigMixin],
+    mocks:  {
+      $fetchState: { pending: false },
+      $store:      {
+        getters: {
+          currentStore:              () => 'current_store',
+          'current_store/schemaFor': jest.fn(),
+          'current_store/all':       jest.fn(),
+          'i18n/t':                  (val: string) => val,
+          'i18n/exists':             jest.fn(),
+        },
+        dispatch: jest.fn()
+      },
+      $route:  { query: { AS: '' }, params: { id: 'oicd' } },
+      $router: { applyQuery: jest.fn() },
+    },
+    propsData: {
+      value: { applicationSecret: '' },
+      mode:  _EDIT,
+    },
+  });
+
+  beforeEach(() => {
+    wrapper = mount(oidc, { ...requiredSetup() });
+  });
+  afterEach(() => {
+    wrapper.destroy();
+  });
+
+  it('have "Create" button enabled when provider is enabled and not editing config', async() => {
+    wrapper.setData({ model: { enabled: true }, editConfig: false });
+    await wrapper.vm.$nextTick();
+
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    expect(saveButton.disabled).toBe(false);
+  });
+
+  it('have "Create" button disabled when provider is disabled and editing config before fields are filled in', async() => {
+    wrapper.setData({ model: {}, editConfig: true });
+    await wrapper.vm.$nextTick();
+
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    expect(saveButton.disabled).toBe(true);
+  });
+
+  it('have "Create" button disabled when provider is disabled and editing config after required fields and scope is missing openid', async() => {
+    wrapper.setData({ oidcUrls: { url: validUrl, realm: validRealm } });
+    await wrapper.vm.$nextTick();
+
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    expect(saveButton.disabled).toBe(true);
+  });
+
+  it('have "Create" button enabled when customEndpoint is disabled and required fields are filled in', async() => {
+    wrapper.setData({ oidcUrls: { url: validUrl, realm: validRealm }, oidcScope: validScope.split(' ') });
+    await wrapper.vm.$nextTick();
+
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    expect(saveButton.disabled).toBe(false);
+  });
+
+  it('have "Create" button enabled when customEndpoint is enabled and required fields are filled in', async() => {
+    wrapper.setData({ customEndpoint: { value: true }, oidcScope: validScope.split(' ') });
+    await wrapper.vm.$nextTick();
+
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    expect(saveButton.disabled).toBe(false);
+  });
+
+  it('updates issuer endpoint when oidcUrls.url and oidcUrls.realm changes', async() => {
+    wrapper.setData({ oidcUrls: { url: validUrl } });
+    await wrapper.vm.$nextTick();
+
+    expect(wrapper.vm.model.issuer).toBe(`${ validUrl }/realms/`);
+
+    wrapper.setData({ oidcUrls: { realm: validRealm } });
+    await wrapper.vm.$nextTick();
+
+    expect(wrapper.vm.model.issuer).toBe(`${ validUrl }/realms/${ validRealm }`);
+  });
+});