step 9 test

status-20X · May 15, 2024 · 8e97294 · 8e97294
1 parent 66877a7
commit 8e97294
Show file tree

Hide file tree

Showing 6 changed files with 140 additions and 127 deletions.
diff --git a/tests/step-02/index.test.js b/tests/step-02/index.test.js
@@ -5,7 +5,7 @@ const readCSV = require("../../src/csvReader");
 test("Read CSV File", async () => {
   const data = await readCSV("./student.csv");
   expect(data.length).toBeGreaterThan(0);
-  expect(data.length).toBe(3);
+  expect(data.length).toBe(4);
   expect(data[0].name).toBe("John");
   expect(data[0].age).toBe("30");
 });
diff --git a/tests/step-03/index.test.js b/tests/step-03/index.test.js
@@ -4,7 +4,7 @@ const parseQuery = require("../../src/queryParser");
 test("Read CSV File", async () => {
   const data = await readCSV("./student.csv");
   expect(data.length).toBeGreaterThan(0);
-  expect(data.length).toBe(3);
+  expect(data.length).toBe(4);
   expect(data[0].name).toBe("John");
   expect(data[0].age).toBe("30"); //ignore the string type here, we will fix this later
 });

diff --git a/tests/step-05/index.test.js b/tests/step-05/index.test.js
@@ -5,7 +5,7 @@ const executeSELECTQuery = require("../../src/index");
 test("Read CSV File", async () => {
   const data = await readCSV("./student.csv");
   expect(data.length).toBeGreaterThan(0);
-  expect(data.length).toBe(3);
+  expect(data.length).toBe(4);
   expect(data[0].name).toBe("John");
   expect(data[0].age).toBe("30"); //ignore the string type here, we will fix this later
 });

diff --git a/tests/step-06/index.test.js b/tests/step-06/index.test.js
@@ -5,7 +5,7 @@ const executeSELECTQuery = require("../../src/index");
 test("Read CSV File", async () => {
   const data = await readCSV("./student.csv");
   expect(data.length).toBeGreaterThan(0);
-  expect(data.length).toBe(3);
+  expect(data.length).toBe(4);
   expect(data[0].name).toBe("John");
   expect(data[0].age).toBe("30"); //ignore the string type here, we will fix this later
 });

diff --git a/tests/step-07/index.test.js b/tests/step-07/index.test.js
@@ -5,7 +5,7 @@ const executeSELECTQuery = require("../../src/index");
 test("Read CSV File", async () => {
   const data = await readCSV("./student.csv");
   expect(data.length).toBeGreaterThan(0);
-  expect(data.length).toBe(3);
+  expect(data.length).toBe(4);
   expect(data[0].name).toBe("John");
   expect(data[0].age).toBe("30"); //ignore the string type here, we will fix this later
 });

diff --git a/tests/step-08/index.test.js b/tests/step-08/index.test.js
@@ -1,150 +1,161 @@
-const readCSV = require('../../src/csvReader');
-const parseQuery = require('../../src/queryParser');
-const executeSELECTQuery = require('../../src/index');
+const readCSV = require("../../src/csvReader");
+const parseQuery = require("../../src/queryParser");
+const executeSELECTQuery = require("../../src/index");
 
-test('Read CSV File', async () => {
-    const data = await readCSV('./student.csv');
-    expect(data.length).toBeGreaterThan(0);
-    expect(data.length).toBe(3);
-    expect(data[0].name).toBe('John');
-    expect(data[0].age).toBe('30'); //ignore the string type here, we will fix this later
+test("Read CSV File", async () => {
+  const data = await readCSV("./student.csv");
+  expect(data.length).toBeGreaterThan(0);
+  expect(data.length).toBe(4);
+  expect(data[0].name).toBe("John");
+  expect(data[0].age).toBe("30"); //ignore the string type here, we will fix this later
 });
 
-test('Parse SQL Query', () => {
-    const query = 'SELECT id, name FROM student';
-    const parsed = parseQuery(query);
-    expect(parsed).toEqual({
-        fields: ['id', 'name'],
-        table: 'student',
-        whereClauses: [],
-        joinCondition: null,
-        joinTable: null
-    });
+test("Parse SQL Query", () => {
+  const query = "SELECT id, name FROM student";
+  const parsed = parseQuery(query);
+  expect(parsed).toEqual({
+    fields: ["id", "name"],
+    table: "student",
+    whereClauses: [],
+    joinCondition: null,
+    joinTable: null,
+  });
 });
 
-test('Execute SQL Query', async () => {
-    const query = 'SELECT id, name FROM student';
-    const result = await executeSELECTQuery(query);
-    expect(result.length).toBeGreaterThan(0);
-    expect(result[0]).toHaveProperty('id');
-    expect(result[0]).toHaveProperty('name');
-    expect(result[0]).not.toHaveProperty('age');
-    expect(result[0]).toEqual({ id: '1', name: 'John' });
+test("Execute SQL Query", async () => {
+  const query = "SELECT id, name FROM student";
+  const result = await executeSELECTQuery(query);
+  expect(result.length).toBeGreaterThan(0);
+  expect(result[0]).toHaveProperty("id");
+  expect(result[0]).toHaveProperty("name");
+  expect(result[0]).not.toHaveProperty("age");
+  expect(result[0]).toEqual({ id: "1", name: "John" });
 });
 
-test('Parse SQL Query with WHERE Clause', () => {
-    const query = 'SELECT id, name FROM student WHERE age = 25';
-    const parsed = parseQuery(query);
-    expect(parsed).toEqual({
-        fields: ['id', 'name'],
-        table: 'student',
-        whereClauses: [{
-            "field": "age",
-            "operator": "=",
-            "value": "25",
-        }],
-        joinCondition: null,
-        joinTable: null
-    });
+test("Parse SQL Query with WHERE Clause", () => {
+  const query = "SELECT id, name FROM student WHERE age = 25";
+  const parsed = parseQuery(query);
+  expect(parsed).toEqual({
+    fields: ["id", "name"],
+    table: "student",
+    whereClauses: [
+      {
+        field: "age",
+        operator: "=",
+        value: "25",
+      },
+    ],
+    joinCondition: null,
+    joinTable: null,
+  });
 });
 
-test('Execute SQL Query with WHERE Clause', async () => {
-    const query = 'SELECT id, name FROM student WHERE age = 25';
-    const result = await executeSELECTQuery(query);
-    expect(result.length).toBe(1);
-    expect(result[0]).toHaveProperty('id');
-    expect(result[0]).toHaveProperty('name');
-    expect(result[0].id).toBe('2');
+test("Execute SQL Query with WHERE Clause", async () => {
+  const query = "SELECT id, name FROM student WHERE age = 25";
+  const result = await executeSELECTQuery(query);
+  expect(result.length).toBe(1);
+  expect(result[0]).toHaveProperty("id");
+  expect(result[0]).toHaveProperty("name");
+  expect(result[0].id).toBe("2");
 });
 
-test('Parse SQL Query with Multiple WHERE Clauses', () => {
-    const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const parsed = parseQuery(query);
-    expect(parsed).toEqual({
-        fields: ['id', 'name'],
-        table: 'student',
-        whereClauses: [{
-            "field": "age",
-            "operator": "=",
-            "value": "30",
-        }, {
-            "field": "name",
-            "operator": "=",
-            "value": "John",
-        }],
-        joinCondition: null,
-        joinTable: null
-    });
+test("Parse SQL Query with Multiple WHERE Clauses", () => {
+  const query = "SELECT id, name FROM student WHERE age = 30 AND name = John";
+  const parsed = parseQuery(query);
+  expect(parsed).toEqual({
+    fields: ["id", "name"],
+    table: "student",
+    whereClauses: [
+      {
+        field: "age",
+        operator: "=",
+        value: "30",
+      },
+      {
+        field: "name",
+        operator: "=",
+        value: "John",
+      },
+    ],
+    joinCondition: null,
+    joinTable: null,
+  });
 });
 
-test('Execute SQL Query with Complex WHERE Clause', async () => {
-    const query = 'SELECT id, name FROM student WHERE age = 30 AND name = John';
-    const result = await executeSELECTQuery(query);
-    expect(result.length).toBe(1);
-    expect(result[0]).toEqual({ id: '1', name: 'John' });
+test("Execute SQL Query with Complex WHERE Clause", async () => {
+  const query = "SELECT id, name FROM student WHERE age = 30 AND name = John";
+  const result = await executeSELECTQuery(query);
+  expect(result.length).toBe(1);
+  expect(result[0]).toEqual({ id: "1", name: "John" });
 });
 
-test('Execute SQL Query with Greater Than', async () => {
-    const queryWithGT = 'SELECT id FROM student WHERE age > 22';
-    const result = await executeSELECTQuery(queryWithGT);
-    expect(result.length).toEqual(2);
-    expect(result[0]).toHaveProperty('id');
+test("Execute SQL Query with Greater Than", async () => {
+  const queryWithGT = "SELECT id FROM student WHERE age > 22";
+  const result = await executeSELECTQuery(queryWithGT);
+  expect(result.length).toEqual(2);
+  expect(result[0]).toHaveProperty("id");
 });
 
-test('Execute SQL Query with Not Equal to', async () => {
-    const queryWithGT = 'SELECT name FROM student WHERE age != 25';
-    const result = await executeSELECTQuery(queryWithGT);
-    expect(result.length).toEqual(2);
-    expect(result[0]).toHaveProperty('name');
+test("Execute SQL Query with Not Equal to", async () => {
+  const queryWithGT = "SELECT name FROM student WHERE age != 25";
+  const result = await executeSELECTQuery(queryWithGT);
+  expect(result.length).toEqual(2);
+  expect(result[0]).toHaveProperty("name");
 });
 
-test('Parse SQL Query with INNER JOIN', async () => {
-    const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await parseQuery(query);
-    expect(result).toEqual({
-        fields: ['student.name', 'enrollment.course'],
-        table: 'student',
-        whereClauses: [],
-        joinTable: 'enrollment',
-        joinCondition: { left: 'student.id', right: 'enrollment.student_id' }
-    })
+test("Parse SQL Query with INNER JOIN", async () => {
+  const query =
+    "SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id";
+  const result = await parseQuery(query);
+  expect(result).toEqual({
+    fields: ["student.name", "enrollment.course"],
+    table: "student",
+    whereClauses: [],
+    joinTable: "enrollment",
+    joinCondition: { left: "student.id", right: "enrollment.student_id" },
+  });
 });
 
-test('Parse SQL Query with INNER JOIN and WHERE Clause', async () => {
-    const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20';
-    const result = await parseQuery(query);
-    expect(result).toEqual({
-        fields: ['student.name', 'enrollment.course'],
-        table: 'student',
-        whereClauses: [{ field: 'student.age', operator: '>', value: '20' }],
-        joinTable: 'enrollment',
-        joinCondition: { left: 'student.id', right: 'enrollment.student_id' }
-    })
+test("Parse SQL Query with INNER JOIN and WHERE Clause", async () => {
+  const query =
+    "SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 20";
+  const result = await parseQuery(query);
+  expect(result).toEqual({
+    fields: ["student.name", "enrollment.course"],
+    table: "student",
+    whereClauses: [{ field: "student.age", operator: ">", value: "20" }],
+    joinTable: "enrollment",
+    joinCondition: { left: "student.id", right: "enrollment.student_id" },
+  });
 });
 
-test('Execute SQL Query with INNER JOIN', async () => {
-    const query = 'SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id';
-    const result = await executeSELECTQuery(query);
-    /*
+test("Execute SQL Query with INNER JOIN", async () => {
+  const query =
+    "SELECT student.name, enrollment.course FROM student INNER JOIN enrollment ON student.id=enrollment.student_id";
+  const result = await executeSELECTQuery(query);
+  /*
     result = [
       { 'student.name': 'John', 'enrollment.course': 'Mathematics' },
       { 'student.name': 'John', 'enrollment.course': 'Physics' },
       { 'student.name': 'Jane', 'enrollment.course': 'Chemistry' },
       { 'student.name': 'Bob', 'enrollment.course': 'Mathematics' }
     ]
     */
-    expect(result.length).toEqual(4);
-    // toHaveProperty is not working here due to dot in the property name
-    expect(result[0]).toEqual(expect.objectContaining({
-        "enrollment.course": "Mathematics",
-        "student.name": "John"
-    }));
+  expect(result.length).toEqual(4);
+  // toHaveProperty is not working here due to dot in the property name
+  expect(result[0]).toEqual(
+    expect.objectContaining({
+      "enrollment.course": "Mathematics",
+      "student.name": "John",
+    })
+  );
 });
 
-test('Execute SQL Query with INNER JOIN and a WHERE Clause', async () => {
-    const query = 'SELECT student.name, enrollment.course, student.age FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 25';
-    const result = await executeSELECTQuery(query);
-    /*
+test("Execute SQL Query with INNER JOIN and a WHERE Clause", async () => {
+  const query =
+    "SELECT student.name, enrollment.course, student.age FROM student INNER JOIN enrollment ON student.id = enrollment.student_id WHERE student.age > 25";
+  const result = await executeSELECTQuery(query);
+  /*
     result =  [
       {
         'student.name': 'John',
@@ -158,10 +169,12 @@ test('Execute SQL Query with INNER JOIN and a WHERE Clause', async () => {
       }
     ]
     */
-    expect(result.length).toEqual(2);
-    // toHaveProperty is not working here due to dot in the property name
-    expect(result[0]).toEqual(expect.objectContaining({
-        "enrollment.course": "Mathematics",
-        "student.name": "John"
-    }));
-});
+  expect(result.length).toEqual(2);
+  // toHaveProperty is not working here due to dot in the property name
+  expect(result[0]).toEqual(
+    expect.objectContaining({
+      "enrollment.course": "Mathematics",
+      "student.name": "John",
+    })
+  );
+});