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

This reverts commit b63c6de.

Author: asaniDev

Sprint-2/implement/contains.js

@@ -1,34 +1,3 @@
-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);
+function contains() {}
 
 module.exports = contains;

Sprint-2/implement/contains.test.js

@@ -20,25 +20,16 @@ as the object doesn't contains a key of 'c'
 // Given an empty object
 // When passed to contains
 // Then it should return false
-test("contains on empty object returns false", () =>
-  expect(contains({}, "a")).toBe(false));
+test.todo("contains on empty object returns 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,20 +1,5 @@
-function createLookup(inputArray) {
+function createLookup() {
   // 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,25 +1,6 @@
 const createLookup = require("./lookup.js");
 
-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"
-  );
-});
+test.todo("creates a country currency code lookup for multiple codes");
 
 /*
 

Sprint-2/implement/querystring.js

@@ -3,42 +3,14 @@ function parseQueryString(queryString) {
   if (queryString.length === 0) {
     return queryParams;
   }
+  const keyValuePairs = queryString.split("&");
 
-  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"
-    );
+  for (const pair of keyValuePairs) {
+    const [key, value] = pair.split("=");
+    queryParams[key] = value;
   }
 
   return queryParams;
 }
 
-console.log(`with ${parseQueryString("equation=x=y+1")}`);
-
 module.exports = parseQueryString;

Sprint-2/implement/querystring.test.js

@@ -3,30 +3,10 @@
 // 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");
-
-test("parseQueryString receives an empty string", () => {
-  expect(parseQueryString("")).toEqual({});
-});
+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("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,39 +1,3 @@
-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"])}`);
+function tally() {}
 
 module.exports = tally;

Sprint-2/implement/tally.test.js

@@ -23,27 +23,12 @@ const tally = require("./tally.js");
 // 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({});
-});
+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
-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"
-  );
-});