made up tests and then created functions to pass the required tests in implement folder

Author: asaniDev

Sprint-2/implement/contains.js

@@ -1,3 +1,34 @@
-function contains() {}
+function contains(checkObj, checkProp) {
+  if (
+    typeof checkObj === "object" &&
+    checkObj !== null &&
+    !Array.isArray(checkObj)
+  ) {
+    const checkKeys = Object.keys(checkObj);
+    let isProperty = false;
+
+    if (checkKeys.length === 0) {
+      return false;
+    }
+
+    if (Object.hasOwn(checkObj, checkProp)) {
+      return true;
+    } else {
+      for (let key of checkKeys) {
+        if (key === checkProp) {
+          isProperty = true;
+        }
+      }
+
+      if (isProperty === false) {
+        return false;
+      }
+    }
+  } else {
+    throw new Error("error invalid parameter please provide an object");
+  }
+}
+
+contains({ d: "me" }, 4);
 
 module.exports = contains;

Sprint-2/implement/contains.test.js

@@ -20,16 +20,25 @@ as the object doesn't contains a key of 'c'
 // 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 when an object contains a property that matches the one passed to contains", () =>
+  expect(contains({ area: "Manchester" }, "area")).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 when an object with properties is passed to contains with a non-existent property name", () =>
+  expect(contains({ area: "Manchester" }, "town")).toBe(false));
 
 // Given invalid parameters like an array
 // When passed to contains
 // Then it should return false or throw an error
+test("should throw an error when when an invalid parameter like an array is passed to contains", () =>
+  expect(() => contains([1, 4], 4)).toThrow(
+    "error invalid parameter please provide an object"
+  ));

Sprint-2/implement/lookup.js

@@ -1,5 +1,20 @@
-function createLookup() {
+function createLookup(inputArray) {
   // implementation here
+  const returnObject = {};
+
+  if (Array.isArray(inputArray)) {
+    if (inputArray.length === 0) {
+      return "passed array was empty, no values to display";
+    }
+
+    for (let item of inputArray) {
+      returnObject[item[0]] = item[1];
+    }
+
+    return returnObject;
+  } else {
+    throw new Error("error incorrect parameter passed please provide an array");
+  }
 }
 
 module.exports = createLookup;

Sprint-2/implement/lookup.test.js

@@ -1,6 +1,25 @@
 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", () => {
+  expect(
+    createLookup([
+      ["US", "USD"],
+      ["CA", "CAD"],
+      ["MW", "MWK"],
+      ["ZW", "ZWD"],
+    ])
+  ).toEqual({ US: "USD", CA: "CAD", MW: "MWK", ZW: "ZWD" });
+});
+
+test("if passed an empty array , should print a message telling user array is empty", () => {
+  expect(createLookup([])).toBe("passed array was empty, no values to display");
+});
+
+test("if passed parameter which is not an array throw an error", () => {
+  expect(() => createLookup("US, USD")).toThrow(
+    "error incorrect parameter passed please provide an array"
+  );
+});
 
 /*
 

Sprint-2/implement/querystring.js

@@ -3,14 +3,42 @@ function parseQueryString(queryString) {
   if (queryString.length === 0) {
     return queryParams;
   }
-  const keyValuePairs = queryString.split("&");
 
-  for (const pair of keyValuePairs) {
-    const [key, value] = pair.split("=");
-    queryParams[key] = value;
+  if (queryString.includes("&")) {
+    const keyValuePairs = queryString.split("&");
+
+    for (const pair of keyValuePairs) {
+      let countMatch = 0;
+
+      if (pair.includes("=")) {
+        const equalSignIndex = pair.indexOf("=");
+
+        queryParams[pair.slice(0, equalSignIndex)] = pair.slice(
+          equalSignIndex + 1
+        );
+      } else {
+        throw new Error(
+          "error invalid format string, no = to separate key value pairs"
+        );
+      }
+    }
+  }
+
+  if (queryString.includes("=")) {
+    const equalSignIndex = queryString.indexOf("=");
+
+    queryParams[queryString.slice(0, equalSignIndex)] = queryString.slice(
+      equalSignIndex + 1
+    );
+  } else {
+    throw new Error(
+      "error invalid format string, no = to separate key value pairs"
+    );
   }
 
   return queryParams;
 }
 
+console.log(`with ${parseQueryString("equation=x=y+1")}`);
+
 module.exports = parseQueryString;

Sprint-2/implement/querystring.test.js

@@ -3,10 +3,30 @@
 // 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("parseQueryString receives an empty string", () => {
+  expect(parseQueryString("")).toEqual({});
+});
 
 test("parses querystring values containing =", () => {
   expect(parseQueryString("equation=x=y+1")).toEqual({
-    "equation": "x=y+1",
+    equation: "x=y+1",
   });
 });
+
+test("if our function is passed only one key - value pair", () => {
+  expect(parseQueryString("color=brown")).toEqual({ color: "brown" });
+});
+
+test("parses querystring without an =, it should throw an error", () => {
+  expect(() => parseQueryString("colorisequaltobrown")).toThrow(
+    "error invalid format string, no = to separate key value pairs"
+  );
+});
+
+test("if our function is passed only one string but there is no =", () => {
+  expect(parseQueryString("color,brown")).toEqual(
+    "error invalid format string, no = to separate key value pair"
+  );
+});

Sprint-2/implement/tally.js

@@ -1,3 +1,39 @@
-function tally() {}
+function tally(inputArray) {
+  if (Array.isArray(inputArray)) {
+    if (inputArray.length === 0) {
+      return {};
+    }
+
+    let itemCount = 0;
+    const tallyObject = {};
+    let n = 0;
+
+    while (inputArray.length > 0) {
+      const tempArray = [];
+      let i = 0;
+      let currentArrayItem = inputArray[0];
+
+      while (i < inputArray.length) {
+        if (currentArrayItem === inputArray[i]) {
+          itemCount++;
+          tempArray.push(inputArray.splice(i, 1));
+          i--;
+        }
+
+        i++;
+      }
+
+      if (tempArray.length > 0) {
+        tallyObject[tempArray[0]] = tempArray.length;
+      }
+    }
+    console.log(`the new array and the new object ${tallyObject}`);
+    return tallyObject;
+  } else {
+    throw new Error("error invalid input passed, please provide an array");
+  }
+}
+
+console.log(`new object is ${tally(["a", "a", "b", "c", "c", "d", "a"])}`);
 
 module.exports = tally;

Sprint-2/implement/tally.test.js

@@ -23,12 +23,27 @@ const tally = require("./tally.js");
 // 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");
+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("given an array with duplicate items it should return counts for each unique item ", () => {
+  expect(tally(["a", "a", "b", "c", "c", "d", "a"])).toEqual({
+    a: 3,
+    b: 1,
+    c: 2,
+    d: 1,
+  });
+});
 
 // Given an invalid input like a string
 // When passed to tally
 // Then it should throw an error
+test("should throw an error when tally is passed an invalid input like a string", () => {
+  expect(() => tally("b,b,c,d,e,e,f")).toThrow(
+    "error invalid input passed, please provide an array"
+  );
+});