Add unit tests and stories, fix parseEventData to throw on invalid action

Address review comments:
- parseEventData: throw on unrecognized event action instead of
  silently defaulting to update (refactored to early returns)
- Add unit tests for parseEventData, getDataKey, getMetadataTitle
- Add unit tests for translations/utils (getParsedTranslationInputData,
  getTranslationFields, mapAttributeValuesToTranslationFields,
  getAttributeValueTranslationsInputData)
- Add unit tests for getGiftCardTagsAddRemoveData (exported for testing)
- Add Storybook stories for GiftCardTagInput component

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: lkostrowski

src/components/Metadata/utils.test.ts

@@ -0,0 +1,116 @@
+import { type ChangeEvent } from "@dashboard/hooks/useForm";
+
+import { EventDataAction, EventDataField } from "./types";
+import { getDataKey, getMetadataTitle, parseEventData } from "./utils";
+
+describe("parseEventData", () => {
+  it("parses name field update event", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "name:2", value: "my-key" },
+    };
+
+    // Act
+    const result = parseEventData(event);
+
+    // Assert
+    expect(result).toEqual({
+      action: EventDataAction.update,
+      field: EventDataField.name,
+      fieldIndex: 2,
+      value: "my-key",
+    });
+  });
+
+  it("parses value field update event", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "value:5", value: "my-value" },
+    };
+
+    // Act
+    const result = parseEventData(event);
+
+    // Assert
+    expect(result).toEqual({
+      action: EventDataAction.update,
+      field: EventDataField.value,
+      fieldIndex: 5,
+      value: "my-value",
+    });
+  });
+
+  it("parses add action event", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "add", value: "" },
+    };
+
+    // Act
+    const result = parseEventData(event);
+
+    // Assert
+    expect(result).toEqual({
+      action: EventDataAction.add,
+      field: null,
+      fieldIndex: null,
+      value: "",
+    });
+  });
+
+  it("parses delete action event", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "delete", value: "3" },
+    };
+
+    // Act
+    const result = parseEventData(event);
+
+    // Assert
+    expect(result).toEqual({
+      action: EventDataAction.delete,
+      field: null,
+      fieldIndex: 3,
+      value: "",
+    });
+  });
+
+  it("throws on invalid event action", () => {
+    // Arrange
+    const event: ChangeEvent<string> = {
+      target: { name: "unknown-action", value: "" },
+    };
+
+    // Act & Assert
+    expect(() => parseEventData(event)).toThrow('Invalid metadata event action: "unknown-action"');
+  });
+});
+
+describe("getDataKey", () => {
+  it("returns 'privateMetadata' when isPrivate is true", () => {
+    expect(getDataKey(true)).toBe("privateMetadata");
+  });
+
+  it("returns 'metadata' when isPrivate is false", () => {
+    expect(getDataKey(false)).toBe("metadata");
+  });
+});
+
+describe("getMetadataTitle", () => {
+  it("returns private metadata message descriptor when isPrivate is true", () => {
+    expect(getMetadataTitle(true)).toEqual({
+      id: "ETHnjq",
+      defaultMessage: "Private Metadata",
+      description: "header",
+    });
+  });
+
+  it("returns metadata message descriptor when isPrivate is false", () => {
+    expect(getMetadataTitle(false)).toEqual({
+      id: "VcI+Zh",
+      defaultMessage: "Metadata",
+      description: "header",
+    });
+  });
+});

src/components/Metadata/utils.ts

@@ -7,40 +7,43 @@ export const nameInputPrefix = EventDataField.name;
 export const valueInputPrefix = EventDataField.value;
 
 export function parseEventData(event: ChangeEvent<string>): EventData {
-  let action: EventDataAction = EventDataAction.update;
-  let field: EventDataField | null = null;
-  let fieldIndex: number | null = null;
-  let value: string = "";
-
   if (event.target.name.includes(EventDataField.name)) {
-    action = EventDataAction.update;
-    field = EventDataField.name;
-    fieldIndex = parseInt(event.target.name.split(nameSeparator)[1], 10);
-    value = event.target.value;
+    return {
+      action: EventDataAction.update,
+      field: EventDataField.name,
+      fieldIndex: parseInt(event.target.name.split(nameSeparator)[1], 10),
+      value: event.target.value,
+    };
   }
 
   if (event.target.name.includes(EventDataField.value)) {
-    action = EventDataAction.update;
-    field = EventDataField.value;
-    fieldIndex = parseInt(event.target.name.split(nameSeparator)[1], 10);
-    value = event.target.value;
+    return {
+      action: EventDataAction.update,
+      field: EventDataField.value,
+      fieldIndex: parseInt(event.target.name.split(nameSeparator)[1], 10),
+      value: event.target.value,
+    };
   }
 
   if (event.target.name === EventDataAction.add) {
-    action = EventDataAction.add;
+    return {
+      action: EventDataAction.add,
+      field: null,
+      fieldIndex: null,
+      value: "",
+    };
   }
 
   if (event.target.name === EventDataAction.delete) {
-    action = EventDataAction.delete;
-    fieldIndex = parseInt(event.target.value, 10);
+    return {
+      action: EventDataAction.delete,
+      field: null,
+      fieldIndex: parseInt(event.target.value, 10),
+      value: "",
+    };
   }
 
-  return {
-    action,
-    field,
-    fieldIndex,
-    value,
-  };
+  throw new Error(`Invalid metadata event action: "${event.target.name}"`);
 }
 
 export function getDataKey(isPrivate: boolean) {

src/giftCards/GiftCardUpdate/providers/GiftCardUpdateFormProvider/GiftCardUpdateFormProvider.test.ts

@@ -0,0 +1,54 @@
+import { getGiftCardTagsAddRemoveData } from "./GiftCardUpdateFormProvider";
+
+describe("getGiftCardTagsAddRemoveData", () => {
+  it("returns added and removed tags", () => {
+    // Arrange
+    const initTags = ["vip", "holiday"];
+    const changedTags = ["holiday", "promo"];
+
+    // Act
+    const result = getGiftCardTagsAddRemoveData(initTags, changedTags);
+
+    // Assert
+    expect(result).toEqual({
+      addTags: ["promo"],
+      removeTags: ["vip"],
+    });
+  });
+
+  it("returns empty arrays when no changes", () => {
+    // Arrange
+    const tags = ["vip", "holiday"];
+
+    // Act
+    const result = getGiftCardTagsAddRemoveData(tags, tags);
+
+    // Assert
+    expect(result).toEqual({
+      addTags: [],
+      removeTags: [],
+    });
+  });
+
+  it("returns all as added when init is empty", () => {
+    // Arrange & Act
+    const result = getGiftCardTagsAddRemoveData([], ["vip", "promo"]);
+
+    // Assert
+    expect(result).toEqual({
+      addTags: ["vip", "promo"],
+      removeTags: [],
+    });
+  });
+
+  it("returns all as removed when changed is empty", () => {
+    // Arrange & Act
+    const result = getGiftCardTagsAddRemoveData(["vip", "promo"], []);
+
+    // Assert
+    expect(result).toEqual({
+      addTags: [],
+      removeTags: ["vip", "promo"],
+    });
+  });
+});

src/giftCards/GiftCardUpdate/providers/GiftCardUpdateFormProvider/GiftCardUpdateFormProvider.tsx

@@ -54,7 +54,7 @@ export const GiftCardUpdateFormContext = createContext<GiftCardUpdateFormConsume
   null,
 );
 
-const getGiftCardTagsAddRemoveData = (initTags: string[], changedTags: string[]) => {
+export const getGiftCardTagsAddRemoveData = (initTags: string[], changedTags: string[]) => {
   const removed = difference(initTags, changedTags);
   const added = difference(changedTags, initTags);
 
@@ -63,6 +63,7 @@ const getGiftCardTagsAddRemoveData = (initTags: string[], changedTags: string[])
     removeTags: removed,
   };
 };
+
 const GiftCardUpdateFormProvider = ({ children }: GiftCardUpdateFormProviderProps) => {
   const notify = useNotifier();
   const intl = useIntl();

src/giftCards/components/GiftCardTagInput/GiftCardTagInput.stories.tsx

@@ -0,0 +1,46 @@
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { fn } from "storybook/test";
+
+import GiftCardTagInput from "./GiftCardTagInput";
+
+const meta: Meta<typeof GiftCardTagInput> = {
+  title: "GiftCards/GiftCardTagInput",
+  component: GiftCardTagInput,
+  args: {
+    name: "tags",
+    onChange: fn(),
+    values: [],
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof GiftCardTagInput>;
+
+export const Default: Story = {};
+
+export const WithValues: Story = {
+  args: {
+    values: [
+      { label: "VIP", value: "vip" },
+      { label: "Holiday", value: "holiday" },
+    ],
+  },
+};
+
+export const WithError: Story = {
+  args: {
+    error: { code: "INVALID" as never, field: "tags" },
+  },
+};
+
+export const Required: Story = {
+  args: {
+    optional: false,
+  },
+};
+
+export const Loading: Story = {
+  args: {
+    loading: true,
+  },
+};