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

package/utils/__tests__/operation-cr.test.ts

@@ -0,0 +1,34 @@
+import { createOperationCR } from '@shell/utils/operation-cr';
+
+describe('util: operation-cr', () => {
+  it('should dispatch create and save the operation resource', async() => {
+    const save = jest.fn().mockResolvedValue({ id: 'op-1' });
+    const dispatch = jest.fn().mockResolvedValue({ save });
+    const spec = {
+      clusterRef: {
+        apiVersion: 'management.cattle.io/v3',
+        kind:       'Cluster',
+        name:       'c-m-1',
+      }
+    };
+
+    const out = await createOperationCR(dispatch, 'operation.test', spec, 'c-m-1', 'cluster-name');
+
+    expect(dispatch).toHaveBeenCalledWith('management/create', {
+      type:     'operation.test',
+      metadata: {
+        namespace:    'c-m-1',
+        generateName: 'cluster-name-'
+      },
+      spec,
+    }, { root: true });
+    expect(save).toHaveBeenCalledWith();
+    expect(out).toStrictEqual({ id: 'op-1' });
+  });
+
+  it('should surface create failures', async() => {
+    const dispatch = jest.fn().mockRejectedValue(new Error('forbidden'));
+
+    await expect(createOperationCR(dispatch, 'operation.test', {}, 'c-m-1', 'cluster-name')).rejects.toThrow('forbidden');
+  });
+});

package/utils/operation-cr.js

@@ -0,0 +1,19 @@
+/**
+ * Create a day 2 operation CR for imported clusters.
+ *
+ * @param {Function} dispatch - The Vuex dispatch function
+ * @param {string} type - The operation CRD type
+ * @param {object} spec - The operation spec
+ * @param {string} namespace - The namespace for the operation CR
+ * @param {string} namePrefix - The name prefix for the generated name
+ * @returns {Promise} The saved resource
+ */
+export async function createOperationCR(dispatch, type, spec, namespace, namePrefix) {
+  const resource = await dispatch('management/create', {
+    type,
+    metadata: { namespace, generateName: `${ namePrefix }-` },
+    spec,
+  }, { root: true });
+
+  return resource.save();
+}

package/utils/require-asset.ts

@@ -88,6 +88,13 @@ export function requireJson(path: string): object {
   return mod.default || mod;
 }
 
+// Expose asset resolvers on window so extension builds (which use a stub
+// instead of require.context) can delegate to the host dashboard at runtime.
+if (typeof window !== 'undefined') {
+  (window as any).__shell_requireAsset = requireAsset;
+  (window as any).__shell_requireJson = requireJson;
+}
+
 // Exported for testing — allows injecting mock contexts
 export function _setContexts(img: WebpackRequireContext | null, json: WebpackRequireContext | null): void {
   imgCtx = img;

package/utils/validators/__tests__/private-registry.test.ts

@@ -3,28 +3,22 @@ import { privateRegistryRequired } from '@shell/utils/validators/private-registr
 const makeCtx = (overrides: any = {}) => ({
   t:                      jest.fn((key: string, params?: any) => (params ? `${ key }:${ JSON.stringify(params) }` : key)),
   privateRegistryEnabled: false,
-  normanCluster:          { importedConfig: { privateRegistryURL: null } },
-  isImportedCluster:      true,
+  normanCluster:          { importedConfig: {} },
+  $store:                 { getters: { 'management/byId': () => null } },
   ...overrides,
 });
 
-describe('privateRegistryRequired', () => {
-  it('should return undefined when the cluster is not imported', () => {
-    const ctx = makeCtx({ isImportedCluster: false, privateRegistryEnabled: true });
-    const rule = privateRegistryRequired(ctx);
-
-    expect(rule()).toBeUndefined();
-  });
+const storeWithGlobalRegistry = { getters: { 'management/byId': () => ({ value: 'registry.global.io' }) } };
 
-  it('should default isImportedCluster to true when the property is absent from the context', () => {
-    const ctx: any = {
-      t:                      jest.fn((key: string, params?: any) => (params ? `${ key }:${ JSON.stringify(params) }` : key)),
+describe('privateRegistryRequired', () => {
+  it('should return undefined when a global default registry is configured', () => {
+    const ctx = makeCtx({
       privateRegistryEnabled: true,
-      normanCluster:          { importedConfig: { privateRegistryURL: null } },
-    };
+      $store:                 storeWithGlobalRegistry,
+    });
     const rule = privateRegistryRequired(ctx);
 
-    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+    expect(rule()).toBeUndefined();
   });
 
   it('should return undefined when the registry toggle is off', () => {
@@ -73,4 +67,22 @@ describe('privateRegistryRequired', () => {
 
     expect(rule()).toBeUndefined();
   });
+
+  it('should handle $store getter throwing gracefully', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: {} },
+      $store:                 {
+        getters: {
+          get 'management/byId'() {
+            throw new Error('no store');
+          }
+        }
+      },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    // Falls through to validation since no global default detected
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
 });

package/utils/validators/private-registry.ts

@@ -1,19 +1,30 @@
+import { VuexStore } from 'types/store/vuex';
 import { Translation } from '@shell/types/t';
 import formRulesGenerator from '@shell/utils/validators/formRules';
+import { SETTING } from '@shell/config/settings';
+import { MANAGEMENT } from '@shell/config/types';
 
 interface PrivateRegistryRuleContext {
   t: Translation;
   privateRegistryEnabled: boolean;
   normanCluster: { importedConfig?: { privateRegistryURL?: string | null } } | null;
-  isImportedCluster?: boolean;
+  $store: VuexStore
 }
 
 export function privateRegistryRequired(ctx: PrivateRegistryRuleContext) {
   return () => {
-    // Check existence using `in` rather than direct access to avoid Vue's render-time warning
-    const isImported = 'isImportedCluster' in ctx ? !!ctx.isImportedCluster : true;
+    let hasGlobalDefault = false;
 
-    if (!isImported || !ctx.privateRegistryEnabled) {
+    try {
+      // settings are loaded when the dashboard loads so using a synchronous getter is reliable here
+      const globalRegistrySetting = ctx.$store.getters['management/byId'](MANAGEMENT.SETTING, SETTING.SYSTEM_DEFAULT_REGISTRY);
+
+      hasGlobalDefault = !!globalRegistrySetting?.value;
+    } catch {
+      // if no setting proceed like there's no global default
+    }
+
+    if (!ctx.privateRegistryEnabled || hasGlobalDefault) {
       return undefined;
     }
     const url = ctx.normanCluster?.importedConfig?.privateRegistryURL;