invert.js invert.test.js committed

Author: carlosyabreu

Sprint-2/interpret/invert.js

@@ -1,3 +1,4 @@
+/**
 // Let's define how invert should work
 
 // Given an object
@@ -15,15 +16,48 @@ function invert(obj) {
 
   return invertedObj;
 }
+*/
 
 // a) What is the current return value when invert is called with { a : 1 }
+/**
+ * { key: 1 }
+ * Because invertedObj.key = value sets a property literally named "key" to the value.
+ */
 
 // b) What is the current return value when invert is called with { a: 1, b: 2 }
+/**
+ * { key: 2 }
+ * The loop runs twice, but each time it overwrites the "key" property. However, the last value (2) remains.
+ */
 
 // c) What is the target return value when invert is called with {a : 1, b: 2}
+/**
+ * { "1": "a", "2": "b" }
+ */
 
-// c) What does Object.entries return? Why is it needed in this program?
+// d) What does Object.entries return? Why is it needed in this program?
+/**
+ * Object.entries() returns an array of a given object's enumerable string-keyed property [key, value] pairs. For example:
+ * Object.entries({ a: 1, b: 2 }) // returns [['a', 1], ['b', 2]]
+ */
 
 // d) Explain why the current return value is different from the target output
+/**
+ * The current implementation uses invertedObj.key = value which creates a property with the literal string "key" rather than using the variable key as the property name. To use the variable's value as the property name, we need bracket notation: invertedObj[value] = key.
+ */
 
 // e) Fix the implementation of invert (and write tests to prove it's fixed!)
+
+function invert(obj) {
+  const invertedObj = {};
+
+  for (const [key, value] of Object.entries(obj)) {
+    // Use bracket notation to set the property name to the value
+    // and the property value to the original key
+    invertedObj[value] = key;
+  }
+
+  return invertedObj;
+}
+
+module.exports = invert;

Sprint-2/interpret/invert.test.js

@@ -0,0 +1,50 @@
+const invert = require("./invert.js");
+
+describe("invert function", () => {
+  test("inverts a simple object with one key-value pair", () => {
+    expect(invert({ a: 1 })).toEqual({ "1": "a" });
+  });
+
+  test("inverts an object with multiple key-value pairs", () => {
+    expect(invert({ a: 1, b: 2 })).toEqual({ "1": "a", "2": "b" });
+  });
+
+  test("inverts an object with string values", () => {
+    expect(invert({ name: "John", city: "New York" })).toEqual({ 
+      "John": "name", 
+      "New York": "city" 
+    });
+  });
+
+  test("inverts an object with mixed value types", () => {
+    expect(invert({ x: 10, y: "hello", z: true })).toEqual({
+      "10": "x",
+      "hello": "y",
+      "true": "z"
+    });
+  });
+
+  test("handles empty object", () => {
+    expect(invert({})).toEqual({});
+  });
+
+  test("handles object with duplicate values (later ones overwrite)", () => {
+    expect(invert({ a: 1, b: 1 })).toEqual({ "1": "b" });
+  });
+
+  test("handles object with numeric keys", () => {
+    const result = invert({ 1: "one", 2: "two" });
+    expect(result).toEqual({ one: "1", two: "2" });
+  });
+
+  test("preserves all properties", () => {
+    const original = { color: "red", size: "large", price: 100 };
+    const inverted = invert(original);
+    
+    // Check that all original values become keys in the inverted object
+    // Sort the arrays to compare regardless of order (numeric keys are sorted differently)
+    expect(Object.keys(inverted).sort()).toEqual(["red", "large", "100"].sort());
+    // Check that inverted values are the original keys
+    expect(Object.values(inverted).sort()).toEqual(["color", "size", "price"].sort());
+  });
+});