dashboard-shell-shell 3.0.2-rc.105 → 3.0.5-logTest.1

package/pages/support/index.vue

@@ -2,13 +2,13 @@
 import BannerGraphic from '@shell/components/BannerGraphic';
 import IndentedPanel from '@shell/components/IndentedPanel';
 import CommunityLinks from '@shell/components/CommunityLinks';
-import { CATALOG, MANAGEMENT } from '@shell/config/types';
+import { MANAGEMENT } from '@shell/config/types';
 import { getVendor } from '@shell/config/private-label';
 import { SETTING } from '@shell/config/settings';
 import { addParam } from '@shell/utils/url';
 import { isRancherPrime } from '@shell/config/version';
-import { hasCspAdapter } from '@shell/mixins/brand';
 import TabTitle from '@shell/components/TabTitle';
+import CspAdapterUtils from '@shell/utils/cspAdaptor';
 
 export default {
 
@@ -42,9 +42,7 @@ export default {
       return setting;
     };
 
-    if ( this.$store.getters['management/canList'](CATALOG.APP) ) {
-      this.apps = await this.$store.dispatch('management/findAll', { type: CATALOG.APP });
-    }
+    this.apps = await CspAdapterUtils.fetchCspAdaptorApp(this.$store);
     this.brandSetting = await fetchOrCreateSetting(SETTING.BRAND, '');
     this.serverUrlSetting = await fetchOrCreateSetting(SETTING.SERVER_URL, '');
     this.uiIssuesSetting = await this.$store.dispatch('management/find', { type: MANAGEMENT.SETTING, id: SETTING.ISSUES });
@@ -75,7 +73,7 @@ export default {
 
   computed: {
     cspAdapter() {
-      return hasCspAdapter(this.apps);
+      return CspAdapterUtils.hasCspAdapter({ $store: this.$store, apps: this.apps });
     },
 
     hasSupport() {

package/pkg/tsconfig.json

@@ -27,25 +27,25 @@
     ],
     "paths": {
       "@shell/core/*": [
-        "../../node_modules/@rancher/shell/core/*"
+        "../../node_modules/dashboard-shell-shell/core/*"
       ],
       "@shell/config/*": [
-        "../../node_modules/@rancher/shell/config/*"
+        "../../node_modules/dashboard-shell-shell/config/*"
       ],
       "@shell/store/*": [
-        "../../node_modules/@rancher/shell/store/*"
+        "../../node_modules/dashboard-shell-shell/store/*"
       ],
       "@shell/plugins/*": [
-        "../../node_modules/@rancher/shell/plugins/*"
+        "../../node_modules/dashboard-shell-shell/plugins/*"
       ],
       "@shell/utils/*": [
-        "../../node_modules/@rancher/shell/utils/*"
+        "../../node_modules/dashboard-shell-shell/utils/*"
       ],
       "@shell/models/*": [
-        "../../node_modules/@rancher/shell/models/*"
+        "../../node_modules/dashboard-shell-shell/models/*"
       ],
       "@shell/mixins/*": [
-        "../../node_modules/@rancher/shell/mixins/*"
+        "../../node_modules/dashboard-shell-shell/mixins/*"
       ],
       "@pkg/*": [
         "./*"
@@ -56,8 +56,8 @@
     "**/*.ts",
     "**/*.tsx",
     "**/*.vue",
-    "../../node_modules/@rancher/shell/types/*.d.ts",
-    "../../node_modules/@rancher/shell/core/types.ts"
+    "../../node_modules/dashboard-shell-shell/types/*.d.ts",
+    "../../node_modules/dashboard-shell-shell/core/types.ts"
   ],
   "exclude": [
     "node_modules"

package/pkg/vue.config.js

@@ -117,7 +117,7 @@ module.exports = function(dir) {
         if (p.use) {
           p.use.forEach((u) => {
             if (u.loader.includes('babel-loader')) {
-              p.exclude = /node_modules\/(?!@rancher\/shell\/).*/;
+              p.exclude = /node_modules\/(?!dashboard-shell-shell\/).*/;
             }
           });
         }

package/plugins/clean-html.js

@@ -2,6 +2,7 @@ import DOMPurify from 'dompurify';
 import { uniq } from '@shell/utils/array';
 
 const ALLOWED_TAGS = [
+  'center',
   'code',
   'li',
   'a',
@@ -13,6 +14,7 @@ const ALLOWED_TAGS = [
   'span',
   'div',
   'i',
+  'img',
   'em',
   'strong',
   'h1',

package/plugins/dashboard-store/__tests__/actions.test.ts

@@ -175,7 +175,9 @@ describe('dashboard-store: actions', () => {
         haveSelector:   jest.fn(() => false),
         matching:       jest.fn(() => 'getters.all'),
         urlFor:         jest.fn(() => 'getters.urlFor'),
-        urlOptions:     jest.fn(() => 'getters.urlOptions')
+        urlOptions:     jest.fn(() => 'getters.urlOptions'),
+        haveAll:        jest.fn(() => false),
+        all:            jest.fn(() => []),
       };
       const rootGetters = { 'type-map/optionsFor': jest.fn() };
 
@@ -207,6 +209,7 @@ describe('dashboard-store: actions', () => {
             null,
             {
               ...genericOpt,
+              isCollection:  true,
               depaginate:    undefined,
               labelSelector: genericSelector,
               url:           'getters.urlFor',

package/plugins/dashboard-store/__tests__/normalize.test.ts

@@ -0,0 +1,223 @@
+import { handleConflict } from '@shell/plugins/dashboard-store/normalize';
+import { handleConflictUseCases } from '@shell/plugins/dashboard-store/__tests__/utils/normalize-usecases';
+import actions from '@shell/plugins/steve/actions.js';
+import cloneDeep from 'lodash/cloneDeep';
+
+describe('fn: handleConflict', () => {
+  let mockStore: any;
+  let mockToJSON: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockStore = {
+      dispatch: jest.fn((action, payload) => Promise.resolve(payload)),
+      getters:  { 'i18n/t': jest.fn((key, params) => `${ key } - ${ JSON.stringify(params) }`) },
+    };
+
+    mockToJSON = jest.fn((x) => x);
+  });
+
+  it('should resolve conflict and return false if no actual conflicts (integration)', async() => {
+    const initialValue = {
+      metadata: { resourceVersion: '1' },
+      spec:     {
+        replicas:   1,
+        containers: [{
+          name:  'app',
+          image: 'image1'
+        }]
+      }
+    };
+    // User modifies 'replicas'
+    const value = {
+      metadata: { resourceVersion: '1' },
+      spec:     {
+        replicas:   2,
+        containers: [{
+          name:  'app',
+          image: 'image1'
+        }]
+      }
+    };
+    // Server did not modify 'replicas', but changed something else (e.g., added a label)
+    const liveValue = {
+      metadata: {
+        resourceVersion: '2',
+        labels:          { env: 'prod' }
+      },
+      spec: {
+        replicas:   1, // Same replicas as initialValue, so no conflict with userChange on replicas
+        containers: [{
+          name:  'app',
+          image: 'image1'
+        }]
+      }
+    };
+
+    const result = await handleConflict(initialValue, value, liveValue, mockStore, 'namespace', mockToJSON);
+
+    // resourceVersion should be updated from liveValue
+    expect(value.metadata.resourceVersion).toStrictEqual('2');
+    // Background changes (labels added) should have been applied to 'value'
+    expect((value.metadata as any).labels).toStrictEqual({ env: 'prod' });
+    // User's change (replicas) should have remained, as there was no conflict
+    expect(value.spec.replicas).toStrictEqual(2);
+
+    expect(result).toStrictEqual(false); // No conflict, save can continue
+  });
+
+  it('should return conflict errors if actual conflicts exist (integration)', async() => {
+    const initialValue = {
+      metadata: { resourceVersion: '1' },
+      spec:     {
+        replicas:   1,
+        containers: [{
+          name:  'app',
+          image: 'image1'
+        }]
+      }
+    };
+    // User modifies 'replicas' to 2
+    const value = {
+      metadata: { resourceVersion: '1' },
+      spec:     {
+        replicas:   2,
+        containers: [{
+          name:  'app',
+          image: 'image1'
+        }]
+      }
+    };
+    // Server modified 'replicas' to 3
+    const liveValue = {
+      metadata: { resourceVersion: '2' },
+      spec:     {
+        replicas:   3, // Conflict with user's modification
+        containers: [{
+          name:  'app',
+          image: 'image1'
+        }]
+      }
+    };
+
+    const result = await handleConflict(initialValue, value, liveValue, mockStore, 'namespace', mockToJSON);
+
+    // resourceVersion should be updated
+    expect(value.metadata.resourceVersion).toStrictEqual('2');
+    expect(value.spec.replicas).toStrictEqual(3);
+
+    // We expect an error message due to the conflict on 'spec.replicas'
+    expect(result).toStrictEqual([
+      'validation.conflict - {"fields":"spec.replicas","fieldCount":1}'
+    ]);
+    expect(mockStore.getters['i18n/t']).toHaveBeenCalledWith('validation.conflict', {
+      fields:     'spec.replicas',
+      fieldCount: 1
+    });
+  });
+
+  it('should handle nested object changes and conflicts', async() => {
+    const initialValue = {
+      metadata: { resourceVersion: '1' },
+      spec:     {
+        selector: {
+          matchLabels: {
+            app: 'nginx',
+            env: 'dev'
+          }
+        }
+      }
+    };
+    // User modifies 'env' to 'prod'
+    const value = {
+      metadata: { resourceVersion: '1' },
+      spec:     {
+        selector: {
+          matchLabels: {
+            app: 'nginx',
+            env: 'prod'
+          }
+        }
+      }
+    };
+    // Live modifies 'app' to 'httpd'
+    const liveValue = {
+      metadata: { resourceVersion: '2' },
+      spec:     {
+        selector: {
+          matchLabels: {
+            app: 'httpd',
+            env: 'dev'
+          }
+        }
+      }
+    };
+
+    const result = await handleConflict(initialValue, value, liveValue, mockStore, 'namespace', mockToJSON);
+
+    expect(mockStore.dispatch).toHaveBeenCalledTimes(3);
+
+    // Should apply newest resource version
+    expect(value.metadata.resourceVersion).toStrictEqual('2');
+
+    // Background change on 'app' should be applied
+    expect(value.spec.selector.matchLabels.app).toStrictEqual('httpd');
+    // User's change on 'env' should have remained
+    expect(value.spec.selector.matchLabels.env).toStrictEqual('prod');
+
+    expect(result).toStrictEqual(false); // No direct conflict on a single field
+  });
+
+  it('should detect add/remove conflicts (integration)', async() => {
+    const initialValue = {
+      metadata: { resourceVersion: '1' },
+      spec:     { ports: [{ port: 80 }, { port: 90 }] }
+    };
+    // Remove port 90 and add 443
+    const value = {
+      metadata: { resourceVersion: '1' },
+      spec:     { ports: [{ port: 80 }, { port: 443 }] }
+    };
+    // Remove port 80
+    const liveValue = {
+      metadata: { resourceVersion: '2' },
+      spec:     { ports: [{ port: 80 }, { port: 90 }] }
+    };
+
+    await handleConflict(initialValue, value, liveValue, mockStore, 'myNamespace', mockToJSON);
+
+    expect(mockStore.dispatch).toHaveBeenCalledTimes(3);
+    expect(value.metadata.resourceVersion).toStrictEqual('2');
+
+    expect(value.spec.ports).toStrictEqual([{ port: 80 }, { port: 443 }]);
+  });
+
+  const testArr = handleConflictUseCases.map((usecase: any) => [usecase.description, usecase.data, usecase.result, usecase.outputValidation]);
+
+  it.each(testArr)('should handleConflict correctly for usecase ::: %s', async(_, usecaseData, res, validationData) => {
+    const storeName = 'management';
+
+    const mocks = {
+      storeName,
+      dispatch: async(arg1: any, arg2: any) => {
+        return Promise.resolve(actions.cleanForDiff({}, arg2));
+      },
+      rootGetters: { 'i18n/t': () => jest.fn().mockReturnValue('some-conflicts') }
+    };
+
+    const initialValue = cloneDeep(usecaseData.initialConfig as any);
+    const currUserValue = cloneDeep(usecaseData.currentConfig as any);
+    const serverValue = cloneDeep(usecaseData.latestConfig as any);
+
+    initialValue.toJSON = () => Object.assign({}, initialValue);
+    currUserValue.toJSON = () => Object.assign({}, currUserValue);
+    serverValue.toJSON = () => Object.assign({}, serverValue);
+
+    // export async function handleConflict(initialValueJSON, value, liveValue, rootGetters, store, storeNamespace) {
+    const result: any = await handleConflict(initialValue, currUserValue, serverValue, { dispatch: mocks.dispatch, getters: mocks.rootGetters }, storeName);
+
+    expect(typeof res !== 'boolean' ? result?.length : result).toStrictEqual(res);
+    expect(currUserValue).toStrictEqual(expect.objectContaining(validationData));
+  });
+});

package/plugins/dashboard-store/__tests__/resource-class.test.ts

@@ -1,3 +1,4 @@
+import jsyaml from 'js-yaml';
 import Resource from '@shell/plugins/dashboard-store/resource-class.js';
 import { resourceClassJunkObject } from '@shell/plugins/dashboard-store/__tests__/utils/store-mocks';
 
@@ -46,4 +47,194 @@ describe('class: Resource', () => {
       });
     });
   });
+
+  describe('method: _saveYaml', () => {
+    let mockStore: any;
+    let resourceInstance: any;
+
+    beforeEach(() => {
+      mockStore = {
+        dispatch: jest.fn((action, payload) => {
+          if (action.endsWith('/cleanForDiff')) {
+            return Promise.resolve(payload);
+          }
+
+          return Promise.resolve();
+        }),
+        rootGetters: {
+          currentStore:     jest.fn(() => 'testStore'),
+          'testStore/byId': jest.fn((type, id) => {
+            if (type === 'testType' && id === 'test-id-conflict-unresolved') {
+              return {
+                id:       'test-id-conflict-unresolved',
+                type:     'testType',
+                metadata: {
+                  namespace: 'aaa', resourceVersion: 2, name: 'test-id-conflict-unresolved'
+                },
+                spec: { replicas: 5 },
+              };
+            }
+            if (type === 'testType' && id === 'test-id-auto-resolve') {
+              return {
+                id:       'test-id-auto-resolve',
+                type:     'testType',
+                metadata: {
+                  namespace: 'aaa', resourceVersion: 2, name: 'test-id-auto-resolve', owner: 'admin'
+                },
+                spec: { replicas: 3, labels: { env: 'dev' } },
+              };
+            }
+            if (id) {
+              return {
+                id,
+                type,
+                metadata: {
+                  namespace: 'aaa', resourceVersion: '5', name: id
+                },
+              };
+            }
+
+            return null;
+          }),
+        },
+        getters: {
+          'i18n/t':         jest.fn((key, params) => ` ${ key } - ${ JSON.stringify(params) }`),
+          currentStore:     jest.fn(() => 'testStore'),
+          'testStore/byId': jest.fn((type, id) => {
+            if (id) {
+              return {
+                id,
+                type,
+              };
+            }
+
+            return null;
+          }),
+          schemaFor: jest.fn((type) => {
+            if (type === 'testType' || type === 'namespaced-type') {
+              return { attributes: { namespaced: true } };
+            }
+
+            return null;
+          }),
+        },
+      };
+
+      resourceInstance = new Resource({
+        id:   'default-id',
+        type: 'default-type',
+      }, mockStore);
+
+      jest.spyOn(resourceInstance, 'followLink').mockImplementation();
+    });
+
+    it('should successfully perform a PUT operation and dispatch load', async() => {
+      const initialYaml = jsyaml.dump({
+        metadata: {
+          namespace: 'aaa', name: 'my-resource', resourceVersion: 1
+        },
+        spec: { replicas: 3 }
+      });
+      const updatedYaml = jsyaml.dump({
+        metadata: {
+          namespace: 'aaa', name: 'my-resource', resourceVersion: 1
+        },
+      });
+      const expectedResponseData = {
+        id:       'test-id',
+        type:     'testType',
+        metadata: {
+          namespace: 'aaa', name: 'my-resource', resourceVersion: 3
+        },
+      };
+
+      resourceInstance.followLink.mockResolvedValueOnce(expectedResponseData);
+
+      await resourceInstance._saveYaml(updatedYaml, initialYaml);
+
+      expect(resourceInstance.followLink).toHaveBeenCalledTimes(1);
+      expect(resourceInstance.followLink).toHaveBeenCalledWith('update', {
+        method:  'PUT',
+        headers: {
+          'content-type': 'application/yaml',
+          accept:         'application/json',
+        },
+        data: updatedYaml
+      });
+
+      expect(mockStore.dispatch).toHaveBeenCalledWith('load', {
+        data:     expectedResponseData,
+        existing: undefined
+      });
+    });
+
+    it('should resolve 409 conflict automatically and re-save if no actual conflicts', async() => {
+      resourceInstance.id = 'test-id-auto-resolve';
+      resourceInstance.type = 'testType';
+
+      const initialYamlAutoResolve = jsyaml.dump({ metadata: { name: 'test-id-auto-resolve', resourceVersion: 1 } });
+      const userYamlAutoResolve = jsyaml.dump({
+        metadata: {
+          namespace: 'aaa', name: 'test-id-auto-resolve', resourceVersion: 1
+        },
+      });
+
+      resourceInstance.followLink.mockRejectedValueOnce({
+        status:   409,
+        response: { text: () => Promise.resolve('Conflict: Resource changed in background') }
+      });
+
+      const finalExpectedResponseAutoResolve = {
+        id:       'test-id-auto-resolve',
+        type:     'testType',
+        metadata: {
+          namespace: 'aaa', name: 'test-id-auto-resolve', resourceVersion: 'final-v3', owner: 'admin'
+        },
+      };
+
+      resourceInstance.followLink.mockResolvedValueOnce(finalExpectedResponseAutoResolve);
+
+      await resourceInstance._saveYaml(userYamlAutoResolve, initialYamlAutoResolve);
+
+      expect(resourceInstance.followLink).toHaveBeenCalledTimes(2);
+
+      expect(resourceInstance.followLink).toHaveBeenCalledWith('update', {
+        method:  'PUT',
+        headers: expect.any(Object),
+        data:    userYamlAutoResolve
+      });
+
+      expect(mockStore.dispatch).toHaveBeenCalledWith('load', {
+        data:     finalExpectedResponseAutoResolve,
+        existing: undefined
+      });
+    });
+
+    it('should throw error on 409 conflict if handleConflict returns errors', async() => {
+      resourceInstance.id = 'test-id-conflict-unresolved';
+      resourceInstance.type = 'testType';
+
+      const initialYaml = jsyaml.dump({
+        metadata: {
+          namespace: 'aaa', name: 'test-id-conflict-unresolved', resourceVersion: 1
+        },
+      });
+      const userYaml = jsyaml.dump({
+        metadata: {
+          namespace: 'aaa', name: 'test-id-conflict-unresolved', resourceVersion: 1
+        },
+        spec: { replicas: 4 }
+      });
+
+      resourceInstance.followLink.mockRejectedValueOnce({
+        _status:  409,
+        response: { text: () => Promise.resolve('Conflict: Replicas changed') }
+      });
+
+      await expect(resourceInstance._saveYaml(userYaml, initialYaml)).rejects.toBeDefined();
+
+      expect(resourceInstance.followLink).toHaveBeenCalledTimes(1);
+      expect(mockStore.dispatch).not.toHaveBeenCalledWith('load', expect.any(Object));
+    });
+  });
 });