@rancher/shell 3.0.2-rc.4 → 3.0.2-rc.6

package/store/auth.js

@@ -1,7 +1,7 @@
 import { GITHUB_NONCE, GITHUB_REDIRECT, GITHUB_SCOPE } from '@shell/config/query-params';
 import { NORMAN } from '@shell/config/types';
 import { _MULTI } from '@shell/plugins/dashboard-store/actions';
-import { addObjects, findBy } from '@shell/utils/array';
+import { addObjects, findBy, joinStringList } from '@shell/utils/array';
 import { openAuthPopup, returnTo } from '@shell/utils/auth';
 import { base64Encode } from '@shell/utils/crypto';
 import { removeEmberPage } from '@shell/utils/ember-page';
@@ -18,12 +18,12 @@ export const BASE_SCOPES = {
 
 const KEY = 'rc_nonce';
 
-const ERR_NONCE = 'nonce';
-
 export const LOGIN_ERRORS = {
   CLIENT:              'client',
   CLIENT_UNAUTHORIZED: 'client_unauthorized',
-  SERVER:              'server'
+  SERVER:              'server',
+  NONCE:               'nonce',
+  USER_UNAUTHORIZED:   'user_unauthorized',
 };
 
 export const state = function() {
@@ -230,18 +230,22 @@ export const actions = {
     const encodedNonce = await dispatch('encodeNonce', baseNonce);
 
     const fromQuery = unescape(parseUrl(redirectUrl).query?.[GITHUB_SCOPE] || '');
-    const scopes = fromQuery.split(/[, ]+/).filter((x) => !!x);
+    let scopes = fromQuery.split(/[, ]+/).filter((x) => !!x);
 
     if (BASE_SCOPES[provider]) {
       addObjects(scopes, BASE_SCOPES[provider]);
     }
 
-    if ( opt.scopes ) {
-      addObjects(scopes, opt.scopes);
+    // Need to merge these 2 formats preventing duplicates between code and UI, e.g.
+    // [ 'openid profile email' ] from BASE_SCOPES
+    // 'openid profile email customScope' from the UI
+    if (opt.scopes) {
+      scopes = [joinStringList(scopes[0], opt.scopes)];
     }
 
     let url = removeParam(redirectUrl, GITHUB_SCOPE);
 
+    // TODO: #13457 - Verify use case of scopesJoinChar anywhere outside this repository
     const params = {
       [GITHUB_SCOPE]: scopes.join(opt.scopesJoinChar || ','), // Some providers won't accept comma separated scopes
       [GITHUB_NONCE]: encodedNonce
@@ -267,13 +271,13 @@ export const actions = {
     try {
       parsed = JSON.parse(expectJSON);
     } catch {
-      return ERR_NONCE;
+      return LOGIN_ERRORS.NONCE;
     }
 
     const expect = parsed.nonce;
 
     if ( !expect || expect !== nonce ) {
-      return ERR_NONCE;
+      return LOGIN_ERRORS.NONCE;
     }
 
     const body = { code };
@@ -310,6 +314,7 @@ export const actions = {
         const url = await dispatch('redirectTo', {
           provider,
           redirectUrl,
+          scopes:   body.scope,
           test:     true,
           redirect: false
         });

package/store/catalog.js

@@ -31,6 +31,13 @@ const CERTIFIED_SORTS = {
   other:                               3,
 };
 
+export const APP_UPGRADE_STATUS = {
+  NOT_APPLICABLE:    'not_applicable', // managed by fleet
+  NO_UPGRADE:        'no_upgrade', // no upgrade found
+  SINGLE_UPGRADE:    'single_upgrade', // a version available to upgrade to
+  MULTIPLE_UPGRADES: 'multiple_upgrades' // more than one match found
+};
+
 export const WINDOWS = 'windows';
 export const LINUX = 'linux';
 
@@ -101,7 +108,7 @@ export const getters = {
 
   chart(state, getters) {
     return ({
-      key, repoType, repoName, chartName, preferRepoType, preferRepoName, includeHidden, showDeprecated
+      key, repoType, repoName, chartName, includeHidden, showDeprecated, multiple
     }) => {
       if ( key && !repoType && !repoName && !chartName) {
         const parsed = parseKey(key);
@@ -111,7 +118,7 @@ export const getters = {
         chartName = parsed.chartName;
       }
 
-      let matching = filterBy(getters.charts, {
+      let matchingCharts = filterBy(getters.charts, {
         repoType,
         repoName,
         chartName,
@@ -119,18 +126,18 @@ export const getters = {
       });
 
       if ( includeHidden === false ) {
-        matching = matching.filter((x) => !x.hidden);
+        matchingCharts = matchingCharts.filter((x) => !x.hidden);
       }
 
-      if ( !matching.length ) {
+      if ( !matchingCharts.length ) {
         return;
       }
 
-      if ( preferRepoType && preferRepoName ) {
-        preferSameRepo(matching, preferRepoType, preferRepoName);
+      if (multiple) {
+        return matchingCharts;
       }
 
-      return matching[0];
+      return matchingCharts[0];
     };
   },
 

package/store/features.js

@@ -36,6 +36,7 @@ export const FLEET_WORKSPACE_BACK = create('provisioningv2-fleet-workspace-back-
 export const STEVE_CACHE = create('ui-sql-cache', false);
 export const UIEXTENSION = create('uiextension', true);
 export const PROVISIONING_PRE_BOOTSTRAP = create('provisioningprebootstrap', false);
+export const SCHEDULING_CUSTOMIZATION = create('cluster-agent-scheduling-customization', false);
 
 // Not currently used.. no point defining ones we don't use
 // export const EMBEDDED_CLUSTER_API = create('embedded-cluster-api', true);

package/store/prefs.js

@@ -130,6 +130,7 @@ export const state = function() {
     cookiesLoaded: false,
     data:          {},
     definitions,
+    authRedirect:  null
   };
 };
 
@@ -215,6 +216,9 @@ export const getters = {
     case (afterLoginRoutePref === 'home'):
       return { name: 'home' };
     case (afterLoginRoutePref === 'last-visited'): {
+      if (state.authRedirect) {
+        return state.authRedirect;
+      }
       const lastVisitedPref = getters['get'](LAST_VISITED);
 
       if (lastVisitedPref) {
@@ -265,6 +269,10 @@ export const mutations = {
   setDefinition(state, { name, definition = {} }) {
     state.definitions[name] = definition;
   },
+
+  setAuthRedirect(state, route) {
+    state.authRedirect = route;
+  }
 };
 
 export const actions = {
@@ -491,9 +499,7 @@ export const actions = {
       return;
     }
 
-    const toSave = getLoginRoute(route);
-
-    return dispatch('set', { key: LAST_VISITED, value: toSave });
+    return dispatch('set', { key: LAST_VISITED, value: route });
   },
 
   toggleTheme({ getters, dispatch }) {
@@ -523,28 +529,3 @@ export const actions = {
     }
   }
 };
-
-function getLoginRoute(route) {
-  let parts = route.name?.split('-') || [];
-  const params = {};
-  const routeParams = route.params || {};
-
-  // Find the 'resource' part of the route, if it is there
-  const index = parts.findIndex((p) => p === 'resource');
-
-  if (index >= 0) {
-    parts = parts.slice(0, index);
-  }
-
-  // Just keep the params that are needed
-  parts.forEach((param) => {
-    if (routeParams[param]) {
-      params[param] = routeParams[param];
-    }
-  });
-
-  return {
-    name: parts.join('-'),
-    params
-  };
-}

package/store/type-map.utils.ts

@@ -123,6 +123,10 @@ export function createHeaders(
  * Given a schema's attribute.column value create a header
  */
 export function headerFromSchemaColString(colName: string, schema: Schema, rootGetters: VuexStoreGetters, pagination: boolean, ageColumn: TableColumn): TableColumn {
+  if (!schema) {
+    throw new Error(`Unable to create header for column '${ colName }' from schema: schema is missing`);
+  }
+
   const col = schema.attributes.columns.find((c) => c.name === colName);
 
   if (!col) {

package/types/resources/settings.d.ts

@@ -1,3 +1,25 @@
+
+export interface PaginationSettingsStore {
+  [name: string]: {
+    resources: {
+      /**
+       * Enable for all resources in this store
+       */
+      enableAll: boolean,
+      enableSome: {
+        /**
+         * Specific resource type to enable
+         */
+        enabled: (string | { resource: string, context: string[]})[],
+        /**
+         * There's no hardcoded headers or custom list for the resource type, headers will be generated from schema attributes.columns
+         */
+        generic: boolean,
+      },
+    }
+  }
+}
+
 /**
  * Settings to handle server side pagination
  */
@@ -6,29 +28,14 @@ export interface PaginationSettings {
    * Global setting to enable or disable
    */
   enabled: boolean,
+  /**
+   * Override `stores` and apply pagination to a set of default resource types that can change between versions
+   */
+  useDefaultStores: boolean,
   /**
    * Should pagination be enabled for resources in a store
    */
-  stores: {
-    [name: string]: {
-      resources: {
-        /**
-         * Enable for all resources in this store
-         */
-        enableAll: boolean,
-        enableSome: {
-          /**
-           * Specific resource type to enable
-           */
-          enabled: (string | { resource: string, context: string[]})[],
-          /**
-           * There's no hardcoded headers or custom list for the resource type, headers will be generated from schema attributes.columns
-           */
-          generic: boolean,
-        },
-      }
-    }
-  }
+  stores: PaginationSettingsStore | undefined
 }
 
 type Links = {

package/types/shell/index.d.ts

@@ -42,6 +42,7 @@ export const RESOURCE_QUOTA: "field.cattle.io/resourceQuota";
 export const AZURE_MIGRATED: "auth.cattle.io/azuread-endpoint-migrated";
 export const WORKSPACE_ANNOTATION: "objectset.rio.cattle.io/id";
 export const NODE_ARCHITECTURE: "kubernetes.io/arch";
+export const IMPORTED_CLUSTER_VERSION_MANAGEMENT: "rancher.io/imported-cluster-version-management";
 export namespace KUBERNETES {
     let SERVICE_ACCOUNT_UID: string;
     let SERVICE_ACCOUNT_NAME: string;
@@ -81,6 +82,7 @@ export namespace CAPI {
     let MACHINE_NAME: string;
     let DELETE_MACHINE: string;
     let PROVIDER: string;
+    let HUMAN_NAME: string;
     let SECRET_AUTH: string;
     let SECRET_WILL_DELETE: string;
     let UI_CUSTOM_PROVIDER: string;
@@ -122,6 +124,7 @@ export namespace CATALOG {
     let HIDDEN_REPO: string;
 }
 export namespace FLEET {
+    export let REPO_NAME: string;
     export let CLUSTER_DISPLAY_NAME: string;
     export let CLUSTER_NAME: string;
     export let BUNDLE_ID: string;
@@ -132,6 +135,8 @@ export namespace FLEET {
     let CLUSTER_NAMESPACE_1: string;
     export { CLUSTER_NAMESPACE_1 as CLUSTER_NAMESPACE };
     export let CLUSTER: string;
+    export let CREATED_BY_USER_ID: string;
+    export let CREATED_BY_USER_NAME: string;
 }
 export namespace RBAC {
     let PRODUCT: string;
@@ -2220,7 +2225,7 @@ export function getVersionData(): {
 export function setVersionData(v: any): void;
 export function getKubeVersionData(): {};
 export function setKubeVersionData(v: any): void;
-export const CURRENT_RANCHER_VERSION: "2.10";
+export const CURRENT_RANCHER_VERSION: "2.11";
 }
 
 // @shell/mixins/create-edit-view/impl
@@ -3172,6 +3177,7 @@ export const FLEET_WORKSPACE_BACK: any;
 export const STEVE_CACHE: any;
 export const UIEXTENSION: any;
 export const PROVISIONING_PRE_BOOTSTRAP: any;
+export const SCHEDULING_CUSTOMIZATION: any;
 export namespace getters {
     function get(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
 }
@@ -3260,6 +3266,7 @@ export function state(): {
     cookiesLoaded: boolean;
     data: {};
     definitions: {};
+    authRedirect: any;
 };
 export namespace getters {
     function get(state: any): (key: any) => any;
@@ -3280,6 +3287,7 @@ export namespace mutations {
         name: any;
         definition?: {};
     }): void;
+    function setAuthRedirect(state: any, route: any): void;
 }
 export namespace actions {
     function set({ dispatch, commit, rootGetters, state }: {
@@ -3785,6 +3793,13 @@ export function generateZip(files: any): any;
 export function downloadUrl(url: any, id?: string): void;
 }
 
+// @shell/utils/duration
+
+declare module '@shell/utils/duration' {
+export function toMilliseconds(input: any): number;
+export function toSeconds(input: any): number;
+}
+
 // @shell/utils/dynamic-importer
 
 declare module '@shell/utils/dynamic-importer' {
@@ -4356,7 +4371,7 @@ export function random32(count: any): number | number[];
 export function randomStr(length?: number, chars?: string): any;
 export function formatPercent(value: any, maxPrecision?: number): string;
 export function pluralize(str: any): any;
-export function resourceNames(names: any, plusMore: any, t: any): any;
+export function resourceNames(names: any, t: any, options?: {}): any;
 export function indent(lines: any, count?: number, token?: string, afterRegex?: any): any;
 export function decamelize(str: any): any;
 export function dasherize(str: any): any;
@@ -4379,6 +4394,7 @@ export function sanitizeIP(v: any): any;
  */
 export function xOfy(x: any, y: any): string;
 export function isBase64(value: any): boolean;
+export function generateRandomAlphaString(length: any): string;
 export namespace CHARSET {
     export { num as NUMERIC };
     export let NO_VOWELS: string;

package/utils/__tests__/array.test.ts

@@ -1,5 +1,5 @@
 import {
-  addObject, addObjects, clear, filterBy, findBy, getUniqueLabelKeys, insertAt, isArray, removeAt, removeObject, removeObjects, replaceWith, sameContents, uniq
+  addObject, addObjects, clear, filterBy, findBy, getUniqueLabelKeys, insertAt, isArray, joinStringList, removeAt, removeObject, removeObjects, replaceWith, sameContents, uniq
 } from '@shell/utils/array';
 
 interface Obj {
@@ -500,3 +500,15 @@ describe('fx: getUniqueLabelKeys', () => {
     expect(result).toStrictEqual(expected);
   });
 });
+
+describe('fx: joinStringList', () => {
+  it('should join two lists of strings', () => {
+    const a = 'a b c';
+    const b = 'b c d';
+    const separator = ' ';
+
+    const result = joinStringList(a, b, separator);
+
+    expect(result).toBe('a b c d');
+  });
+});

package/utils/__tests__/string.test.ts

@@ -1,4 +1,4 @@
-import { decodeHtml } from '@shell/utils/string';
+import { decodeHtml, resourceNames } from '@shell/utils/string';
 
 describe('fx: decodeHtml', () => {
   it('should decode HTML values from escaped string into valid markup', () => {
@@ -10,3 +10,82 @@ describe('fx: decodeHtml', () => {
     expect(result).toStrictEqual(expectation);
   });
 });
+
+describe('fx: resourceNames', () => {
+  // default plusMore function
+  const t = (key: string, options: { count: number }) => {
+    switch (key) {
+    case 'generic.and':
+      return ' and ';
+    case 'generic.comma':
+      return ', ';
+    case 'promptRemove.andOthers': {
+      if (options.count === 0) {
+        return '.';
+      }
+      if (options.count === 1) {
+        return 'and <b>one other</b>.';
+      }
+
+      return `and <b>${ options.count } others</b>.`;
+    }
+    }
+  };
+
+  describe.each([
+    ['no options',
+      [
+        [[], '', {}],
+        [['item1'], '<b>item1</b>.', {}],
+        [['item1', 'item2'], '<b>item1</b> and <b>item2</b>.', {}],
+        [['item1', 'item2', 'item3'], '<b>item1</b>, <b>item2</b> and <b>item3</b>.', {}],
+        [['item1', 'item2', 'item3', 'item4', 'item5'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b> and <b>item5</b>.', {}],
+        [['item1', 'item2', 'item3', 'item4', 'item5', 'item6'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b>, <b>item5</b>and <b>one other</b>.', {}],
+        [['item1', 'item2', 'item3', 'item4', 'item5', 'item6', 'item7'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b>, <b>item5</b>and <b>2 others</b>.', {}],
+      ]
+    ],
+    ['plusMore option',
+      [
+        [[], '', { plusMore: 'foo' }],
+        [['item1'], '<b>item1</b>.', { plusMore: 'foo' }],
+        [['item1', 'item2'], '<b>item1</b> and <b>item2</b>.', { plusMore: 'foo' }],
+        [['item1', 'item2', 'item3'], '<b>item1</b>, <b>item2</b> and <b>item3</b>.', { plusMore: 'foo' }],
+        [['item1', 'item2', 'item3', 'item4', 'item5'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b> and <b>item5</b>.', { plusMore: 'foo' }],
+        [['item1', 'item2', 'item3', 'item4', 'item5', 'item6'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b>, <b>item5</b>foo', { plusMore: 'foo' }],
+        [['item1', 'item2', 'item3', 'item4', 'item5', 'item6', 'item7'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b>, <b>item5</b>foo', { plusMore: 'foo' }],
+      ]
+    ],
+    ['endString option',
+      [
+        [[], '', { endString: false }],
+        [['item1'], '<b>item1</b> ', { endString: false }],
+        [['item1', 'item2'], '<b>item1</b> and <b>item2</b> ', { endString: false }],
+        [['item1', 'item2'], '<b>item1</b> and <b>item2</b>.', { endString: '' }],
+        [['item1', 'item2'], '<b>item1</b> and <b>item2</b>foo', { endString: 'foo' }],
+      ]
+    ],
+    [
+      'plusMore & endString options', [
+        [[], '', { plusMore: '', endString: false }],
+        [[], '', { plusMore: 'foo', endString: 'foo' }],
+        [['item1'], '<b>item1</b>foo', { plusMore: 'foo', endString: 'foo' }],
+        [['item1', 'item2'], '<b>item1</b> and <b>item2</b>foo', { plusMore: 'foo', endString: 'foo' }],
+        [['item1', 'item2'], '<b>item1</b> and <b>item2</b> ', { plusMore: 'foo', endString: false }],
+        [['item1', 'item2', 'item3', 'item4', 'item5', 'item6'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b>, <b>item5</b>foo', { plusMore: 'foo', endString: 'foo' }],
+        [['item1', 'item2', 'item3', 'item4', 'item5', 'item6', 'item7'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b>, <b>item5</b>foo', { plusMore: 'foo', endString: 'foo' }],
+        [['item1', 'item2', 'item3', 'item4', 'item5', 'item6'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b>, <b>item5</b>foo', { plusMore: 'foo', endString: false }],
+        [['item1', 'item2', 'item3', 'item4', 'item5', 'item6', 'item7'], '<b>item1</b>, <b>item2</b>, <b>item3</b>, <b>item4</b>, <b>item5</b>foo', { plusMore: 'foo', endString: false }],
+      ]
+    ]
+  ])('should build a single message from a list of names, with: %p', (_, args) => {
+    it.each(args)(`having: %p`, (
+      names,
+      expectation,
+      options,
+    ) => {
+      const result = resourceNames(names, t, options);
+
+      expect(result).toStrictEqual(expectation);
+    });
+  });
+});

package/utils/array.ts

@@ -241,3 +241,16 @@ export function getUniqueLabelKeys<T extends KubeResource>(aryResources: T[]): s
 
   return Object.keys(uniqueObj).sort();
 }
+
+/**
+ * Join list as string into a new string without duplicates
+ * @param {string} a 'a b c'
+ * @param {string} b 'b c d'
+ * @param {string} [separator=' ']
+ * @return {string} 'a b c d'
+ */
+export const joinStringList = (a: string, b: string, separator = ' '): string => {
+  const all = a.split(separator).concat(b.split(separator));
+
+  return [...new Set(all)].join(separator);
+};

package/utils/auth.js

@@ -315,6 +315,10 @@ export function isLoggedIn(store, me) {
 export function notLoggedIn(store, redirect, route) {
   store.commit('auth/hasAuth', true);
 
+  if (!route.name.includes('auth')) {
+    store.commit('prefs/setAuthRedirect', route);
+  }
+
   if ( route.name === 'index' ) {
     return redirect('/auth/login');
   } else {

package/utils/cluster.js

@@ -81,7 +81,7 @@ export function paginationFilterOnlyKubernetesClusters(store) {
 
   return PaginationParamFilter.createMultipleFields([
     new PaginationFilterField({
-      field:  `metadata.labels."${ CAPI.PROVIDER }"`,
+      field:  `metadata.labels[${ CAPI.PROVIDER }]`,
       equals: false,
       value:  VIRTUAL_HARVESTER_PROVIDER,
       exact:  true

package/{edit/monitoring.coreos.com.prometheusrule → utils}/duration.js

@@ -8,9 +8,7 @@ const UNIT_TO_MS =
     w:  7 * 24 * 60 * 60 * 1000,
     y:  365 * 24 * 60 * 60 * 1000
   };
-// see:
-// https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/#rule
-// https://prometheus.io/docs/prometheus/latest/configuration/configuration/#duration
+
 const DURATION_REGEX = /^(?:([0-9]+)y)?(?:([0-9]+)w)?(?:([0-9]+)d)?(?:([0-9]+)h)?(?:([0-9]+)m)?(?:([0-9]+)s)?(?:([0-9]+)ms)?$/;
 
 export function toMilliseconds(input) {
@@ -39,3 +37,7 @@ export function toMilliseconds(input) {
 
   return 0;
 }
+
+export function toSeconds(input) {
+  return Math.floor(toMilliseconds(input) / 1000);
+}

package/utils/pagination-utils.ts

@@ -1,4 +1,4 @@
-import { PaginationSettings } from '@shell/types/resources/settings';
+import { PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
 import {
   NAMESPACE_FILTER_ALL_USER as ALL_USER,
   NAMESPACE_FILTER_ALL as ALL,
@@ -14,6 +14,7 @@ import { sameArrayObjects } from '@shell/utils/array';
 import { isEqual } from '@shell/utils/object';
 import { STEVE_CACHE } from '@shell/store/features';
 import { getPerformanceSetting } from '@shell/utils/settings';
+import { PAGINATION_SETTINGS_STORE_DEFAULTS } from '@shell/plugins/steve/steve-pagination-utils';
 
 /**
  * Helper functions for server side pagination
@@ -32,6 +33,18 @@ class PaginationUtils {
     return perf.serverPagination;
   }
 
+  public getStoreSettings(ctx: any): PaginationSettingsStore
+  public getStoreSettings(serverPagination: PaginationSettings): PaginationSettingsStore
+  public getStoreSettings(arg: any | PaginationSettings): PaginationSettingsStore {
+    const serverPagination: PaginationSettings = arg?.rootGetters !== undefined ? this.getSettings(arg) : arg;
+
+    return serverPagination?.useDefaultStores ? this.getStoreDefault() : serverPagination?.stores || this.getStoreDefault();
+  }
+
+  public getStoreDefault(): PaginationSettingsStore {
+    return PAGINATION_SETTINGS_STORE_DEFAULTS;
+  }
+
   isSteveCacheEnabled({ rootGetters }: any): boolean {
     // We always get Feature flags as part of start up (see `dispatch('features/loadServer')` in loadManagement)
     return rootGetters['features/get']?.(STEVE_CACHE);
@@ -58,7 +71,7 @@ class PaginationUtils {
       return false;
     }
 
-    const storeSettings = settings.stores?.[enabledFor.store];
+    const storeSettings = this.getStoreSettings(settings)?.[enabledFor.store];
 
     // No pagination setting for target store, not enabled
     if (!storeSettings) {

package/utils/string.js

@@ -151,16 +151,36 @@ export function pluralize(str) {
   }
 }
 
-export function resourceNames(names, plusMore, t) {
+export function resourceNames(names, t, options = {}) {
+  const MAX_NAMES_COUNT = 5;
+
+  let { plusMore, endString } = options;
+
+  // plusMore default value
+  if (!plusMore) {
+    plusMore = t('promptRemove.andOthers', { count: names.length > MAX_NAMES_COUNT ? names.length - MAX_NAMES_COUNT : 0 });
+  }
+
+  // endString default value
+  if (!endString) {
+    endString = endString === false ? ' ' : '.';
+  }
+
   return names.reduce((res, name, i) => {
-    if (i >= 5) {
-      return res;
+    if (i < MAX_NAMES_COUNT) {
+      res += `<b>${ escapeHtml( name ) }</b>`;
+
+      if (i === names.length - 1) {
+        res += endString;
+      } else if (i === names.length - 2) {
+        res += names.length <= 5 ? t('generic.and') : '';
+      } else {
+        res += i < MAX_NAMES_COUNT - 1 ? t('generic.comma') : '';
+      }
     }
-    res += `<b>${ escapeHtml( name ) }</b>`;
-    if (i === names.length - 1) {
+
+    if (i === MAX_NAMES_COUNT) {
       res += plusMore;
-    } else {
-      res += i === names.length - 2 ? t('generic.and') : t('generic.comma');
     }
 
     return res;
@@ -336,3 +356,7 @@ export function isBase64(value) {
 
   return base64regex.test(value);
 }
+
+export function generateRandomAlphaString(length) {
+  return Array.from({ length }, () => String.fromCharCode(97 + Math.random() * 26 | 0)).join('');
+}

package/utils/validators/formRules/__tests__/index.test.ts

@@ -244,6 +244,33 @@ describe('formRules', () => {
     expect(formRuleResult).toStrictEqual(expectedResult);
   });
 
+  describe('"registryUrl": has the expected output for each input', () => {
+    const expectedTranslation = JSON.stringify({ message: 'cluster.privateRegistry.privateRegistryUrlError' });
+    const testCases = [
+      // Empty
+      [undefined, undefined],
+
+      // Word
+      ['registry', expectedTranslation],
+
+      // Without schema
+      ['registry.io', undefined],
+
+      // With schemas
+      ['http://registry.io', undefined],
+      ['https://registry.io', undefined],
+    ];
+
+    it.each(testCases)(
+      'should return undefined or correct message based on the provided url',
+      (url, expected) => {
+        const formRuleResult = formRules.registryUrl(url);
+
+        expect(formRuleResult).toStrictEqual(expected);
+      }
+    );
+  });
+
   it('"ruleGroups" : returns undefined when rulegroups are supplied', () => {
     const testValue = { groups: ['group1'] };
     const formRuleResult = formRules.ruleGroups(testValue);