implemented the key, value conversion and written jest tests all passed

Author: Yonatanteklemariam

Sprint-2/interpret/invert.js

@@ -7,23 +7,50 @@
 // E.g. invert({x : 10, y : 20}), target output: {"10": "x", "20": "y"}
 
 function invert(obj) {
-  const invertedObj = {};
-
-  for (const [key, value] of Object.entries(obj)) {
-    invertedObj.key = value;
+  // Validate input type
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    throw new Error("Input must be an object");
   }
 
-  return invertedObj;
-}
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return {};
 
-// a) What is the current return value when invert is called with { a : 1 }
+  // take only the values
+  const values = entries.map(([_, v]) => v);
 
-// b) What is the current return value when invert is called with { a: 1, b: 2 }
+  // Detect duplicate values
+  const hasDuplicate = new Set(values).size !== values.length;
+  if (hasDuplicate) {
+    throw new Error("Values cannot be duplicated");
+  }
 
-// c) What is the target return value when invert is called with {a : 1, b: 2}
+  const inverted = {};
 
-// c) What does Object.entries return? Why is it needed in this program?
+  for (const [key, value] of entries) {
+    // Validate key and value types
+    if (
+      (typeof key !== "string" && typeof key !== "number") ||
+      (typeof value !== "string" && typeof value !== "number")
+    ) {
+      throw new Error("Keys and values must be a string or a number");
+    }
 
-// d) Explain why the current return value is different from the target output
+    inverted[value] = key;
+  }
+
+  return inverted;
+}
+module.exports = invert;
 
-// e) Fix the implementation of invert (and write tests to prove it's fixed!)
+// a) What is the current return value when invert is called with { a : 1 }
+// the current value is 1
+// b) What is the current return value when invert is called with { a: 1, b: 2 }
+// the current return value at this call is 2
+// c) What is the target return value when invert is called with {a : 1, b: 2}
+// the target return value at this call is to supposed to be 'b'
+// d) What does Object.entries return? Why is it needed in this program?
+// Object.entries is used because both key and value are needed to be returned from the loop
+// e) Explain why the current return value is different from the target output
+// it's because the code in the line 13 is only returning single literal property named "key" on every loop iteration, so each assignment overwrites the previous one and the final object ends up with { key: 2 } but the intended inverted output requires using the loop variables as property names (dynamic keys) so each iteration creates a distinct property (for example invertedObj[value] = key), producing separate entries like { 1: 'a', 2: 'b' } instead of repeatedly writing to the same "key" property which the current function is doing
+// f) Fix the implementation of invert (and write tests to prove it's fixed!)
+// Above is the fixed function

Sprint-2/interpret/invert.test.js

@@ -0,0 +1,59 @@
+const invert = require("./invert");
+
+test("inverts a simple object", () => {
+  const input = { a: "x", b: "y" };
+  const expected = { x: "a", y: "b" };
+  expect(invert(input)).toEqual(expected);
+});
+
+test("inverts an object with number values", () => {
+  const input = { a: 1, b: 2 };
+  const expected = { 1: "a", 2: "b" };
+  expect(invert(input)).toEqual(expected);
+});
+
+test("accepts empty string as a key", () => {
+  const input = { "": "x" };
+  const expected = { x: "" };
+  expect(invert(input)).toEqual(expected);
+});
+
+test("returns an empty object when input is empty", () => {
+  expect(invert({})).toEqual({});
+});
+
+test("throws when input is null", () => {
+  expect(() => invert(null)).toThrow("Input must be an object");
+});
+
+test("throws when input is not an object", () => {
+  expect(() => invert("hello")).toThrow("Input must be an object");
+  expect(() => invert(123)).toThrow("Input must be an object");
+  expect(() => invert(true)).toThrow("Input must be an object");
+});
+
+test("throws when input is an array", () => {
+  expect(() => invert(["a", "b"])).toThrow("Input must be an object");
+});
+
+test("throws when a value is not a string or number", () => {
+  const obj = { a: {} };
+  expect(() => invert(obj)).toThrow(
+    "Keys and values must be a string or a number"
+  );
+});
+
+test("throws when values are duplicated (string)", () => {
+  const obj = { a: "x", b: "y", c: "x" };
+  expect(() => invert(obj)).toThrow("Values cannot be duplicated");
+});
+
+test("throws when numeric values are duplicated", () => {
+  const obj = { a: 1, b: 2, c: 1 };
+  expect(() => invert(obj)).toThrow("Values cannot be duplicated");
+});
+
+test("duplicate keys are overwritten by JavaScript before reaching invert()", () => {
+  const obj = { a: "x", a: "y" }; // JS overwrites first 'a'
+  expect(invert(obj)).toEqual({ y: "a" });
+});