@rancher/shell 3.0.12-rc.2 → 3.0.12-rc.4

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

@@ -1,8 +1,9 @@
 import { nextTick } from 'vue';
 /* eslint-disable jest/no-hooks */
-import { mount } from '@vue/test-utils';
+import { mount, flushPromises } from '@vue/test-utils';
 import AzureAD from '@shell/edit/auth/azuread.vue';
 import { _EDIT } from '@shell/config/query-params';
+import { SLO_OPTION_VALUES } from '@shell/mixins/auth-config';
 
 jest.mock('@shell/utils/clipboard', () => {
   return { copyTextToClipboard: jest.fn(() => Promise.resolve({})) };
@@ -28,46 +29,72 @@ const mockModel = {
   type:     'azureADConfig',
 };
 
-describe('edit: azureAD should', () => {
-  let wrapper: any;
-  const requiredSetup = () => ({
-    data() {
-      return {
-        isEnabling:     true,
-        editConfig:     false,
-        model:          { ...mockModel },
-        serverSetting:  null,
-        errors:         [],
-        originalModel:  null,
-        principals:     [],
-        authConfigName: 'azuread',
-      };
-    },
-    global: {
-      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()
+const requiredSetup = (modelOverrides = {}) => ({
+  data() {
+    return {
+      isEnabling:     true,
+      editConfig:     false,
+      model:          { ...mockModel, ...modelOverrides },
+      serverSetting:  null,
+      errors:         [],
+      originalModel:  null,
+      principals:     [],
+      authConfigName: 'azuread',
+    };
+  },
+  global: {
+    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(),
         },
-        $route:  { query: { AS: '' }, params: { id: 'azure' } },
-        $router: { applyQuery: jest.fn() },
+        dispatch: jest.fn()
       },
+      $route:  { query: { AS: '' }, params: { id: 'azure' } },
+      $router: { applyQuery: jest.fn() },
     },
-    propsData: {
-      value: { applicationSecret: '' },
-      mode:  _EDIT,
-    },
+  },
+  propsData: {
+    value: { applicationSecret: '' },
+    mode:  _EDIT,
+  },
+});
+
+describe('edit: azureAD accessMode default', () => {
+  let wrapper: any;
+
+  afterEach(() => {
+    wrapper.unmount();
+  });
+
+  it('should default accessMode to required when not set', async() => {
+    wrapper = mount(AzureAD, { ...requiredSetup({ accessMode: '' }) });
+    wrapper.setData({ model: { tenantId: 'trigger-watcher' } });
+    await nextTick();
+
+    expect(wrapper.vm.model.accessMode).toStrictEqual('unrestricted');
   });
 
-  beforeEach(() => {
+  it('should not override accessMode when already set', async() => {
+    wrapper = mount(AzureAD, { ...requiredSetup({ accessMode: 'required' }) });
+    wrapper.setData({ model: { tenantId: 'trigger-watcher' } });
+    await nextTick();
+
+    expect(wrapper.vm.model.accessMode).toStrictEqual('required');
+  });
+});
+
+describe('edit: azureAD should', () => {
+  let wrapper: any;
+
+  beforeEach(async() => {
     wrapper = mount(AzureAD, { ...requiredSetup() });
+    await flushPromises();
   });
   afterEach(() => {
     wrapper.unmount();
@@ -119,7 +146,7 @@ describe('edit: azureAD should', () => {
     tenantIdInputField.setValue(testCase.tenantId);
     applicationIdInputField.setValue(testCase.applicationId);
     applicationSecretInputField.setValue(testCase.applicationSecret);
-    await nextTick();
+    await flushPromises();
 
     expect(saveButton.disabled).toBe(testCase.result);
   });
@@ -215,11 +242,11 @@ describe('edit: azureAD should', () => {
     tenantIdInputField.setValue(validTenantId);
     applicationIdInputField.setValue(validApplicationId);
     applicationSecretInputField.setValue(validAppSecret);
-    await nextTick();
+    await flushPromises();
 
     expect(saveButton.disabled).toBe(false);
     customButton.trigger('click');
-    await nextTick();
+    await flushPromises();
     expect(saveButton.disabled).toBe(true);
 
     const endpointInputField = wrapper.find('[data-testid="input-azureAD-endpoint"]');
@@ -231,8 +258,189 @@ describe('edit: azureAD should', () => {
     graphEndpointInputField.setValue(testCase.graphEndpoint);
     tokenEndpointInputField.setValue(testCase.tokenEndpoint);
     authEndpointInputField.setValue(testCase.authEndpoint);
-    await nextTick();
+    await flushPromises();
 
     expect(saveButton.disabled).toBe(testCase.result);
   });
 });
+
+describe('edit: azureAD SSO logout should', () => {
+  let wrapper: any;
+
+  afterEach(() => {
+    wrapper.unmount();
+  });
+
+  it('not render SLO section when logoutAllSupported is false', () => {
+    wrapper = mount(AzureAD, { ...requiredSetup({ logoutAllSupported: false }) });
+    const sloSection = wrapper.find('[data-testid="azuread-sloType"]');
+
+    expect(sloSection.exists()).toBe(false);
+  });
+
+  it('render SLO section when logoutAllSupported is true', async() => {
+    wrapper = mount(AzureAD, { ...requiredSetup({ logoutAllSupported: true }) });
+    await nextTick();
+    const sloSection = wrapper.find('[data-testid="azuread-sloType"]');
+
+    expect(sloSection.exists()).toBe(true);
+  });
+
+  it('not render endSessionEndpoint field when sloType is rancher', async() => {
+    wrapper = mount(AzureAD, {
+      ...requiredSetup({ logoutAllSupported: true }),
+      data() {
+        return {
+          ...requiredSetup({ logoutAllSupported: true }).data(),
+          sloType: SLO_OPTION_VALUES.rancher,
+        };
+      },
+    });
+    await nextTick();
+    const endSessionEndpointField = wrapper.find('[data-testid="azuread-endSessionEndpoint"]');
+
+    expect(endSessionEndpointField.exists()).toBe(false);
+  });
+
+  it('render endSessionEndpoint field when sloType is all', async() => {
+    wrapper = mount(AzureAD, {
+      ...requiredSetup({ logoutAllSupported: true }),
+      data() {
+        return {
+          ...requiredSetup({ logoutAllSupported: true }).data(),
+          sloType: SLO_OPTION_VALUES.all,
+        };
+      },
+    });
+    await flushPromises();
+    const endSessionEndpointField = wrapper.find('[data-testid="azuread-endSessionEndpoint"]');
+
+    expect(endSessionEndpointField.exists()).toBe(true);
+  });
+
+  it('render endSessionEndpoint field when sloType is both', async() => {
+    wrapper = mount(AzureAD, {
+      ...requiredSetup({ logoutAllSupported: true }),
+      data() {
+        return {
+          ...requiredSetup({ logoutAllSupported: true }).data(),
+          sloType: SLO_OPTION_VALUES.both,
+        };
+      },
+    });
+    await flushPromises();
+    const endSessionEndpointField = wrapper.find('[data-testid="azuread-endSessionEndpoint"]');
+
+    expect(endSessionEndpointField.exists()).toBe(true);
+  });
+
+  it.each([
+    {
+      sloType: SLO_OPTION_VALUES.all, endSessionEndpoint: '', disabled: true
+    },
+    {
+      sloType: SLO_OPTION_VALUES.all, endSessionEndpoint: 'not-a-url', disabled: true
+    },
+    {
+      sloType: SLO_OPTION_VALUES.all, endSessionEndpoint: 'https://login.microsoftonline.com/tenant/oauth2/v2.0/logout', disabled: false
+    },
+    {
+      sloType: SLO_OPTION_VALUES.both, endSessionEndpoint: '', disabled: true
+    },
+    {
+      sloType: SLO_OPTION_VALUES.both, endSessionEndpoint: 'https://login.microsoftonline.com/tenant/oauth2/v2.0/logout', disabled: false
+    },
+  ])('has save button disabled=$disabled when sloType=$sloType and endSessionEndpoint=$endSessionEndpoint', async(testCase) => {
+    wrapper = mount(AzureAD, {
+      ...requiredSetup({
+        logoutAllSupported: true,
+        tenantId:           validTenantId,
+        applicationId:      validApplicationId,
+        applicationSecret:  validAppSecret,
+        endSessionEndpoint: testCase.endSessionEndpoint,
+      }),
+      data() {
+        return {
+          isEnabling: true,
+          editConfig: false,
+          model:      {
+            ...mockModel,
+            logoutAllSupported: true,
+            tenantId:           validTenantId,
+            applicationId:      validApplicationId,
+            applicationSecret:  validAppSecret,
+            graphEndpoint:      validGraphEndpoint,
+            tokenEndpoint:      validTokenEndpoint,
+            authEndpoint:       validAuthEndpoint,
+            endSessionEndpoint: testCase.endSessionEndpoint,
+          },
+          sloType:        testCase.sloType,
+          serverSetting:  null,
+          errors:         [],
+          originalModel:  null,
+          principals:     [],
+          authConfigName: 'azuread',
+        };
+      },
+    });
+    await flushPromises();
+    const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+    expect(saveButton.disabled).toBe(testCase.disabled);
+  });
+
+  it('sets logoutAllEnabled=false and logoutAllForced=false when sloType changes to rancher', async() => {
+    wrapper = mount(AzureAD, {
+      ...requiredSetup({ logoutAllSupported: true }),
+      data() {
+        return {
+          ...requiredSetup({ logoutAllSupported: true }).data(),
+          sloType: SLO_OPTION_VALUES.all,
+        };
+      },
+    });
+    await nextTick();
+    wrapper.vm.sloType = SLO_OPTION_VALUES.rancher;
+    await nextTick();
+
+    expect(wrapper.vm.model.logoutAllEnabled).toBe(false);
+    expect(wrapper.vm.model.logoutAllForced).toBe(false);
+    expect(wrapper.vm.model.endSessionEndpoint).toBe('');
+  });
+
+  it('sets logoutAllEnabled=true and logoutAllForced=true when sloType changes to all', async() => {
+    wrapper = mount(AzureAD, {
+      ...requiredSetup({ logoutAllSupported: true }),
+      data() {
+        return {
+          ...requiredSetup({ logoutAllSupported: true }).data(),
+          sloType: SLO_OPTION_VALUES.rancher,
+        };
+      },
+    });
+    await nextTick();
+    wrapper.vm.sloType = SLO_OPTION_VALUES.all;
+    await nextTick();
+
+    expect(wrapper.vm.model.logoutAllEnabled).toBe(true);
+    expect(wrapper.vm.model.logoutAllForced).toBe(true);
+  });
+
+  it('sets logoutAllEnabled=true and logoutAllForced=false when sloType changes to both', async() => {
+    wrapper = mount(AzureAD, {
+      ...requiredSetup({ logoutAllSupported: true }),
+      data() {
+        return {
+          ...requiredSetup({ logoutAllSupported: true }).data(),
+          sloType: SLO_OPTION_VALUES.rancher,
+        };
+      },
+    });
+    await nextTick();
+    wrapper.vm.sloType = SLO_OPTION_VALUES.both;
+    await nextTick();
+
+    expect(wrapper.vm.model.logoutAllEnabled).toBe(true);
+    expect(wrapper.vm.model.logoutAllForced).toBe(false);
+  });
+});

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

@@ -0,0 +1,234 @@
+import { nextTick } from 'vue';
+import { mount, type VueWrapper, flushPromises } from '@vue/test-utils';
+import { _EDIT } from '@shell/config/query-params';
+
+import GitHub from '@shell/edit/auth/github.vue';
+
+jest.mock('@shell/utils/clipboard', () => {
+  return { copyTextToClipboard: jest.fn(() => Promise.resolve({})) };
+});
+
+const validClientId = 'github-client-id';
+const validClientSecret = 'github-client-secret';
+const validAppId = '12345';
+const validPrivateKey = '-----BEGIN RSA PRIVATE KEY-----\ntest\n-----END RSA PRIVATE KEY-----';
+const validTargetUrl = 'https://github.mycompany.com';
+
+const mockGitHubModel = {
+  enabled:      false,
+  id:           'github',
+  clientId:     validClientId,
+  clientSecret: validClientSecret,
+  hostname:     'github.com',
+  tls:          true,
+};
+
+const mockGitHubAppModel = {
+  ...mockGitHubModel,
+  id:         'githubapp',
+  appId:      validAppId,
+  privateKey: validPrivateKey,
+};
+
+const requiredSetup = (modelOverrides = {}, dataOverrides = {}) => ({
+  data() {
+    return {
+      isEnabling:     false,
+      editConfig:     false,
+      model:          { ...mockGitHubModel, ...modelOverrides },
+      serverSetting:  null,
+      errors:         [],
+      originalModel:  null,
+      principals:     [],
+      authConfigName: 'github',
+      targetType:     'public',
+      targetUrl:      '',
+      ...dataOverrides,
+    } as any;
+  },
+  global: {
+    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: 'github' } },
+      $router: { applyQuery: jest.fn() },
+    },
+  },
+  props: {
+    value: {},
+    mode:  _EDIT,
+  },
+});
+
+describe('github.vue', () => {
+  describe('GitHub provider', () => {
+    let wrapper: VueWrapper<any, any>;
+
+    beforeEach(() => {
+      wrapper = mount(GitHub, { ...requiredSetup() });
+    });
+
+    afterEach(() => {
+      wrapper.unmount();
+    });
+
+    describe('save button disabled', () => {
+      it('when clientId is empty', async() => {
+        wrapper.setData({ model: { clientId: '' } });
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
+
+        const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+        expect(saveButton.disabled).toBe(true);
+      });
+
+      it('when clientSecret is empty', async() => {
+        wrapper.setData({ model: { clientSecret: '' } });
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
+
+        const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+        expect(saveButton.disabled).toBe(true);
+      });
+
+      it('when both clientId and clientSecret are empty', async() => {
+        wrapper.setData({ model: { clientId: '' } });
+        wrapper.setData({ model: { clientSecret: '' } });
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
+
+        const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+        expect(saveButton.disabled).toBe(true);
+      });
+    });
+
+    describe('save button enabled', () => {
+      it('when clientId and clientSecret are filled', async() => {
+        await nextTick();
+
+        const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+        expect(saveButton.disabled).toBe(false);
+      });
+
+      it('when provider is already enabled and not editing config', async() => {
+        wrapper.setData({ model: { ...mockGitHubModel, enabled: true }, editConfig: false });
+        await nextTick();
+
+        const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+        expect(saveButton.disabled).toBe(false);
+      });
+    });
+  });
+
+  describe('GitHub App provider', () => {
+    let wrapper: VueWrapper<any, any>;
+
+    beforeEach(() => {
+      wrapper = mount(GitHub, { ...requiredSetup(mockGitHubAppModel) });
+    });
+
+    afterEach(() => {
+      wrapper.unmount();
+    });
+
+    describe('save button disabled', () => {
+      it('when appId is empty', async() => {
+        wrapper.setData({ model: { appId: '' } });
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
+
+        const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+        expect(saveButton.disabled).toBe(true);
+      });
+
+      it('when privateKey is empty', async() => {
+        wrapper.vm.model.privateKey = '';
+        wrapper.setData({ model: { privateKey: '' } });
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
+
+        const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+        expect(saveButton.disabled).toBe(true);
+      });
+    });
+
+    describe('save button enabled', () => {
+      it('when all required fields are filled', async() => {
+        await nextTick();
+
+        const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+        expect(saveButton.disabled).toBe(false);
+      });
+    });
+  });
+
+  describe('GitHub App fields not required for GitHub provider', () => {
+    let wrapper: VueWrapper<any, any>;
+
+    beforeEach(() => {
+      wrapper = mount(GitHub, { ...requiredSetup() });
+    });
+
+    afterEach(() => {
+      wrapper.unmount();
+    });
+
+    it('save button is enabled even when appId and privateKey are absent', async() => {
+      await nextTick();
+
+      const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+      expect(saveButton.disabled).toBe(false);
+    });
+  });
+
+  describe('private GitHub Enterprise target', () => {
+    let wrapper: VueWrapper<any, any>;
+
+    beforeEach(() => {
+      wrapper = mount(
+        GitHub,
+        { ...requiredSetup({}, { targetType: 'private', targetUrl: validTargetUrl }) }
+      );
+    });
+
+    afterEach(() => {
+      wrapper.unmount();
+    });
+
+    it('save button is disabled when targetUrl is empty', async() => {
+      wrapper.setData({ targetType: 'private', targetUrl: '' });
+      await wrapper.vm.validateAllFields();
+      await flushPromises();
+
+      const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+      expect(saveButton.disabled).toBe(true);
+    });
+
+    it('save button is enabled when targetUrl is filled', async() => {
+      await nextTick();
+
+      const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
+
+      expect(saveButton.disabled).toBe(false);
+    });
+  });
+});

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

@@ -1,6 +1,6 @@
 import { nextTick } from 'vue';
 /* eslint-disable jest/no-hooks */
-import { mount, type VueWrapper } from '@vue/test-utils';
+import { mount, type VueWrapper, flushPromises } from '@vue/test-utils';
 import { _EDIT } from '@shell/config/query-params';
 
 import oidc from '@shell/edit/auth/oidc.vue';
@@ -9,6 +9,18 @@ jest.mock('@shell/utils/clipboard', () => {
   return { copyTextToClipboard: jest.fn(() => Promise.resolve({})) };
 });
 
+const mockStore = {
+  getters: {
+    'i18n/t':      (key: string) => key,
+    'i18n/exists': () => false,
+  },
+};
+
+jest.mock('vuex', () => ({
+  ...jest.requireActual('vuex'),
+  useStore: () => mockStore,
+}));
+
 const validClientId = 'rancheroidc';
 const validClientSecret = 'TOkUxg0P67m1UXWNkJLHDPkUZFIKOWSq';
 const validUrl = 'https://localhost:8080';
@@ -79,20 +91,26 @@ describe('oidc.vue', () => {
     });
 
     describe('have "Create" button disabled', () => {
-      it('given missing Auth endpoint URL', () => {
+      // validateAllFields() replicates what happens on blur in a real browser: it runs
+      // the toTypedSchema validators for every registered field and flushes async errors.
+      it('given missing Auth endpoint URL', async() => {
         wrapper.vm.model.authEndpoint = '';
         wrapper.vm.model.scopes = 'openid profile email'; // set scope to be sure
         wrapper.vm.oidcScope = ['openid', 'profile', 'email']; // TODO #13457: this is duplicated due wrong format of scopes
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
 
         const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
 
         expect(saveButton.disabled).toBe(true);
       });
 
-      it('given missing required basic scopes', () => {
-        wrapper.vm.model.authEndpoint = 'whatever'; // set auth endpoint to be sure
+      it('given missing required basic scopes', async() => {
+        wrapper.vm.model.authEndpoint = validAuthEndpoint; // set auth endpoint to be sure
         wrapper.vm.model.scopes = 'something else'; // set wrong scope
         wrapper.vm.oidcScope = ['something', 'else']; // TODO #13457: this is duplicated due wrong format of scopes
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
 
         const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
 
@@ -101,7 +119,8 @@ describe('oidc.vue', () => {
 
       it('when provider is disabled and editing config before fields are filled in', async() => {
         wrapper.setData({ model: {}, editConfig: true });
-        await nextTick();
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
 
         const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;
 
@@ -110,7 +129,8 @@ describe('oidc.vue', () => {
 
       it('when provider is disabled and editing config after required fields and scope is missing openid', async() => {
         wrapper.setData({ oidcUrls: { url: validUrl, realm: validRealm } });
-        await nextTick();
+        await wrapper.vm.validateAllFields();
+        await flushPromises();
 
         const saveButton = wrapper.find('[data-testid="form-save"]').element as HTMLInputElement;