dashboard-shell-shell 3.0.2-test.20250913 → 3.0.5-test.2

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));
+    });
+  });
 });