Fix update metadata (#3560)

src/utils/handlers/metadataUpdateHandler.test.ts

@@ -0,0 +1,235 @@
+import { MetadataFormData } from "@dashboard/components/Metadata";
+
+import createMetadataUpdateHandler, {
+  ObjectWithMetadata,
+} from "./metadataUpdateHandler";
+
+describe("createMetadataUpdateHandler", () => {
+  it("should return array of errors when update function return errors", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [],
+      privateMetadata: [],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve(["error1", "error2"]));
+    const metadataUpdateFun = jest.fn();
+    const privateMetadataUpdateFun = jest.fn();
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(result).toEqual(["error1", "error2"]);
+  });
+
+  it("should call only updateMetadata mutation", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      privateMetadata: [],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve([])) as any;
+    const metadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    ) as any;
+    const privateMetadataUpdateFun = jest.fn();
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(result).toEqual([]);
+    expect(metadataUpdateFun).toHaveBeenLastCalledWith({
+      id: intialData.id,
+      input: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      keysToDelete: [],
+    });
+    expect(privateMetadataUpdateFun).not.toHaveBeenCalled();
+  });
+
+  it("should call only updatePrivateMetadata mutation", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [],
+      privateMetadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve([])) as any;
+    const metadataUpdateFun = jest.fn();
+    const privateMetadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    ) as any;
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(result).toEqual([]);
+    expect(privateMetadataUpdateFun).toHaveBeenLastCalledWith({
+      id: intialData.id,
+      input: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      keysToDelete: [],
+    });
+    expect(metadataUpdateFun).not.toHaveBeenCalled();
+  });
+
+  it("should return updateMetadata errors if exists", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      privateMetadata: [
+        {
+          key: "privateTestKey",
+          value: "privateTestValue",
+        },
+      ],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve([])) as any;
+    const metadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {
+          deleteMetadata: {
+            errors: ["error1", "error2"],
+          },
+        },
+      }),
+    ) as any;
+    const privateMetadataUpdateFun = jest.fn();
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(result).toEqual(["error1", "error2"]);
+    expect(privateMetadataUpdateFun).not.toHaveBeenCalled();
+  });
+
+  it("should return updatePrivateMetadata errors if exists", async () => {
+    // Arrange
+    const intialData: ObjectWithMetadata = {
+      id: "testId",
+      metadata: [],
+      privateMetadata: [],
+    };
+    const data: MetadataFormData = {
+      metadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+      privateMetadata: [
+        {
+          key: "testKey",
+          value: "testValue",
+        },
+      ],
+    };
+
+    const updateFun = jest.fn(() => Promise.resolve([])) as any;
+    const metadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {},
+      }),
+    ) as any;
+
+    const privateMetadataUpdateFun = jest.fn(() =>
+      Promise.resolve({
+        data: {
+          deletePrivateMetadata: {
+            errors: ["privateError1", "privateError2"],
+          },
+        },
+      }),
+    ) as any;
+
+    // Act
+    const handleUpdate = await createMetadataUpdateHandler(
+      intialData,
+      updateFun,
+      metadataUpdateFun,
+      privateMetadataUpdateFun,
+    );
+    const result = await handleUpdate(data);
+
+    // Assert
+    expect(metadataUpdateFun).toHaveBeenCalled();
+    expect(result).toEqual(["privateError1", "privateError2"]);
+  });
+});

src/utils/handlers/metadataUpdateHandler.ts

@@ -14,7 +14,7 @@ import { arrayDiff } from "@dashboard/utils/arrays";
 import { filterMetadataArray } from "./filterMetadataArray";
 import { areMetadataArraysEqual } from "./metadataUpdateHelpers";
 
-interface ObjectWithMetadata {
+export interface ObjectWithMetadata {
   id: string;
   metadata: MetadataInput[];
   privateMetadata: MetadataInput[];
@@ -54,10 +54,12 @@ function createMetadataUpdateHandler<TData extends MetadataFormData, TError>(
         const modifiedKeys = data.metadata.map(m => m.key);
 
         const keyDiff = arrayDiff(initialKeys, modifiedKeys);
+        const metadataInput = filterMetadataArray(data.metadata);
 
+        if (metadataInput.length) {
           const updateMetaResult = await updateMetadata({
             id: initial.id,
-          input: filterMetadataArray(data.metadata),
+            input: metadataInput,
             keysToDelete: keyDiff.removed,
           });
 
@@ -70,16 +72,19 @@ function createMetadataUpdateHandler<TData extends MetadataFormData, TError>(
             return updateMetaErrors;
           }
         }
+      }
 
       if (data.privateMetadata && hasPrivateMetadataChanged) {
         const initialKeys = initial.privateMetadata.map(m => m.key);
         const modifiedKeys = data.privateMetadata.map(m => m.key);
 
         const keyDiff = arrayDiff(initialKeys, modifiedKeys);
+        const privateMetadataInput = filterMetadataArray(data.privateMetadata);
 
+        if (privateMetadataInput.length) {
           const updatePrivateMetaResult = await updatePrivateMetadata({
             id: initial.id,
-          input: filterMetadataArray(data.privateMetadata),
+            input: privateMetadataInput,
             keysToDelete: keyDiff.removed,
           });
 
@@ -95,6 +100,7 @@ function createMetadataUpdateHandler<TData extends MetadataFormData, TError>(
           }
         }
       }
+    }
 
     return [];
   };