feat: implement contains, createLookup, parseQueryString, and tally functions with corresponding tests

Author: Baba05206

Sprint-2/implement/contains.js

@@ -1,3 +1,8 @@
-function contains() {}
+function contains(object, propertyName) {
+  if (typeof object === "object" && object !== null) {
+    return propertyName in object;
+  }
+  return false;
+}
 
 module.exports = contains;

Sprint-2/implement/contains.test.js

@@ -16,20 +16,39 @@ as the object doesn't contains a key of 'c'
 // Given a contains function
 // When passed an object and a property name
 // Then it should return true if the object contains the property, false otherwise
+test("returns true if the object contains the property, false otherwise", () => {
+  const obj = { a: 1, b: 2 };
+
+  expect(contains(obj, "a")).toBe(true); // property exists
+  expect(contains(obj, "b")).toBe(true); // property exists
+  expect(contains(obj, "c")).toBe(false); // property does not exist
+});
 
 // Given an empty object
 // When passed to contains
 // Then it should return false
-test.todo("contains on empty object returns false");
+test("contains on empty object returns false", () => {
+  expect(contains({}, "a")).toBe(false);
+});
 
 // Given an object with properties
 // When passed to contains with an existing property name
 // Then it should return true
-
+test("returns true for existing property", () => {
+  expect(contains({ a: 1, b: 2 }, "a")).toBe(true);
+});
 // Given an object with properties
 // When passed to contains with a non-existent property name
 // Then it should return false
-
+test("returns false for missing property", () => {
+  expect(contains({ a: 1, b: 2 }, "c")).toBe(false);
+});
 // Given invalid parameters like an array
 // When passed to contains
 // Then it should return false or throw an error
+test("returns false for invalid inputs like arrays", () => {
+  expect(contains([], "a")).toBe(false);
+  expect(contains(null, "a")).toBe(false);
+  expect(contains(123, "a")).toBe(false);
+  expect(contains("hello", "a")).toBe(false);
+});

Sprint-2/implement/lookup.js

@@ -1,5 +1,12 @@
-function createLookup() {
+function createLookup(pairs) {
   // implementation here
+  const lookup = {};
+
+  for (const [country, currency] of pairs) {
+    lookup[country] = currency;
+  }
+
+  return lookup;
 }
 
 module.exports = createLookup;

Sprint-2/implement/lookup.test.js

@@ -1,6 +1,18 @@
 const createLookup = require("./lookup.js");
 
-test.todo("creates a country currency code lookup for multiple codes");
+test("creates a country currency code lookup for multiple codes", () => {
+  const input = [
+    ["US", "USD"],
+    ["CA", "CAD"],
+  ];
+
+  const expected = {
+    US: "USD",
+    CA: "CAD",
+  };
+
+  expect(createLookup(input)).toEqual(expected);
+});
 
 /*
 

Sprint-2/implement/querystring.js

@@ -1,13 +1,52 @@
 function parseQueryString(queryString) {
   const queryParams = {};
-  if (queryString.length === 0) {
+
+  // 1. Input Validation: Return empty object for non-string, null, or empty input.
+  if (typeof queryString !== "string" || !queryString) {
     return queryParams;
   }
-  const keyValuePairs = queryString.split("&");
+
+  // Remove leading '?' if it exists (e.g., if passed directly from window.location.search)
+  const cleanedString = queryString.startsWith("?")
+    ? queryString.substring(1)
+    : queryString;
+
+  const keyValuePairs = cleanedString.split("&");
 
   for (const pair of keyValuePairs) {
-    const [key, value] = pair.split("=");
-    queryParams[key] = value;
+    if (pair.length === 0) continue; // Skip empty pairs
+
+    const separatorIndex = pair.indexOf("=");
+    let key;
+    let value;
+
+    if (separatorIndex === -1) {
+      // Case 1: Key with no equals sign (e.g., "key")
+      key = pair;
+      value = "";
+    } else {
+      // Case 2: Key/value pair with or without extra '=' in value (e.g., "eq=a=b")
+      key = pair.substring(0, separatorIndex);
+      // Value is everything after the first '='
+      value = pair.substring(separatorIndex + 1);
+    }
+
+    // Decode the key and value
+    const decodedKey = decodeURIComponent(key);
+    const decodedValue = decodeURIComponent(value);
+
+    // Handle Duplicate Keys: If the key already exists, convert the value to an array.
+    if (queryParams.hasOwnProperty(decodedKey)) {
+      if (Array.isArray(queryParams[decodedKey])) {
+        queryParams[decodedKey].push(decodedValue);
+      } else {
+        // Convert existing value and new value to an array
+        queryParams[decodedKey] = [queryParams[decodedKey], decodedValue];
+      }
+    } else {
+      // Assign the value for the first time
+      queryParams[decodedKey] = decodedValue;
+    }
   }
 
   return queryParams;

Sprint-2/implement/querystring.test.js

@@ -3,10 +3,35 @@
 // Below is one test case for an edge case the implementation doesn't handle well.
 // Fix the implementation for this test, and try to think of as many other edge cases as possible - write tests and fix those too.
 
-const parseQueryString = require("./querystring.js")
+const parseQueryString = require("./querystring.js");
 
 test("parses querystring values containing =", () => {
   expect(parseQueryString("equation=x=y+1")).toEqual({
-    "equation": "x=y+1",
+    equation: "x=y+1",
   });
 });
+test("handles URL encoding in keys and values", () => {
+  expect(parseQueryString("search=hello%20world&sort=d%26a")).toEqual({
+    search: "hello world",
+    sort: "d&a",
+  });
+});
+test("handles duplicate keys by creating an array of values", () => {
+  expect(parseQueryString("color=red&color=blue&size=m")).toEqual({
+    color: ["red", "blue"],
+    size: "m",
+  });
+});
+test("handles keys with empty or missing values", () => {
+  expect(parseQueryString("key1=&key2=value&key3&key4=")).toEqual({
+    key1: "",
+    key2: "value",
+    key3: "",
+    key4: "",
+  });
+});
+test("handles empty string, leading question mark, and malformed input", () => {
+  expect(parseQueryString("")).toEqual({});
+  expect(parseQueryString("?a=1")).toEqual({ a: "1" });
+  expect(parseQueryString("a=1&&b=2")).toEqual({ a: "1", b: "2" });
+});

Sprint-2/implement/tally.js

@@ -1,3 +1,17 @@
-function tally() {}
+function tally(list) {
+  // 1. Input Validation: Throw an error if the input is not a proper array.
+  if (!Array.isArray(list)) {
+    throw new Error("Input must be an array.");
+  }
+
+  // 2. Tally Frequencies using reduce()
+  return list.reduce((counts, item) => {
+    // If the item exists in the object, increment its count.
+    // Otherwise, initialize its count to 1.
+    counts[item] = (counts[item] || 0) + 1;
+
+    return counts;
+  }, {}); // Start with an empty object {}
+}
 
 module.exports = tally;

Sprint-2/implement/tally.test.js

@@ -15,20 +15,41 @@ const tally = require("./tally.js");
  */
 
 // Acceptance criteria:
+describe("tally", () => {
+  // Given a function called tally
+  // When passed an array of items
+  // Then it should return an object containing the count for each unique item
+  test("returns correct counts for mixed data types", () => {
+    const input = [1, "a", 2, true, 1, "a", 2, true];
+    const expectedOutput = { 1: 2, a: 2, 2: 2, true: 2 };
+    expect(tally(input)).toEqual(expectedOutput);
+  });
+  // Given an empty array
+  // When passed to tally
+  // Then it should return an empty object
+  test("tally on an empty array returns an empty object", () => {
+    expect(tally([])).toEqual({});
+  });
+  // Given an array with duplicate items
+  // When passed to tally
+  // Then it should return counts for each unique item
+  test("returns correct counts for an array with duplicates", () => {
+    const input = ["banana", "apple", "banana", "cherry", "apple", "banana"];
+    const expectedOutput = {
+      banana: 3,
+      apple: 2,
+      cherry: 1,
+    };
+    expect(tally(input)).toEqual(expectedOutput);
+  });
+  // Given an invalid input like a string
+  // When passed to tally
+  // Then it should throw an error
 
-// Given a function called tally
-// When passed an array of items
-// Then it should return an object containing the count for each unique item
-
-// Given an empty array
-// When passed to tally
-// Then it should return an empty object
-test.todo("tally on an empty array returns an empty object");
-
-// Given an array with duplicate items
-// When passed to tally
-// Then it should return counts for each unique item
-
-// Given an invalid input like a string
-// When passed to tally
-// Then it should throw an error
+  test.each(["not an array", 123, null, undefined, { key: "value" }])(
+    "throws an error for invalid input type: %p",
+    (invalidInput) => {
+      expect(() => tally(invalidInput)).toThrow("Input must be an array.");
+    }
+  );
+});