diff --git a/backend/.env b/backend/.env
index b2f01e3406153054bfcc7c1e0220cd0bb718f0c2..ce7e7979ff8246c8edc80fa269254ae8e6c597e8 100644
--- a/backend/.env
+++ b/backend/.env
@@ -5,4 +5,4 @@ DB_PASSWORD=corps_db_password
DB_NAME=corps_directory_db
PORT=3000
-FRONTEND_URL=localhost:8080
\ No newline at end of file
+FRONTEND_URL=http://localhost:8080
\ No newline at end of file
diff --git a/backend/config/auth/auth.login.js b/backend/config/auth/auth.login.js
index 022d88258ae198edfff4d580387041738acf2626..ebf5d6eaba54608c32e4e9c7706f429d03c832e0 100644
--- a/backend/config/auth/auth.login.js
+++ b/backend/config/auth/auth.login.js
@@ -9,6 +9,28 @@ const casLogin = function (req, res, next) {
// hard-coded for now.
const JWT_SECRET = "secret_key";
+ // if on localhost, accept the authentication and give a key
+ console.log("user: ", process.env.DB_USER);
+
+ if (process.env.DB_USER === "corps_directory_dev") {
+ // payload for the JWT token
+ const payload = {
+ id: 1,
+ role: "admin",
+ username: "localhostuser",
+ };
+
+ // sign the token with secret key
+ const token = jwt.sign(payload, JWT_SECRET, { expiresIn: "1h" });
+
+ console.log("sending token for use in localhost");
+
+ console.log("Frontend: ", process.env.FRONTEND_URL);
+
+ res.redirect(`${process.env.FRONTEND_URL}/home?token=${token}`);
+ return;
+ }
+
// call the authenticate function with CAS
passport.authenticate("cas", function (err, user, info) {
if (err) {
diff --git a/backend/package.json b/backend/package.json
index fe08ad0c36c758c7ebfb6c7291ff3740e6ed3105..4d6b96b1dd4bb6fb4310cfbbf9e0969c4ba31169 100644
--- a/backend/package.json
+++ b/backend/package.json
@@ -5,7 +5,7 @@
"main": "index.js",
"scripts": {
"start": "nodemon index.js",
- "test": "echo \"Error: no test specified\" && exit 1"
+ "test": "jest"
},
"author": "",
"license": "ISC",
@@ -21,5 +21,9 @@
"passport": "^0.7.0",
"passport-cas": "^0.1.1",
"sequelize": "^6.37.4"
+ },
+ "devDependencies": {
+ "jest": "^29.7.0",
+ "jest-mock": "^29.7.0"
}
}
diff --git a/backend/repository/addressRepository.js b/backend/repository/addressRepository.js
index d2deaef6b4638dfcddfa2dc11fa134b9d66565d4..06da1ce87d9ea8966dea421bf50243733e54feb9 100644
--- a/backend/repository/addressRepository.js
+++ b/backend/repository/addressRepository.js
@@ -1,5 +1,8 @@
const { pool } = require("../config/database/database.config");
+/*
+Add address info into address table and peopleXaddress table
+*/
async function addAddress(address, peopleId) {
// get all the parts of the address
let { address1, address2, city, state, country, zipCode, preferredAddress } =
@@ -43,7 +46,6 @@ async function addAddress(address, peopleId) {
INSERT INTO peopleXAddress (peopleId, addressId, preferredAddress)
VALUES (?, ?, ?)
`;
-
const [peopleAddressResult] = await pool.query(peopleAddressQuery, [
peopleId,
addressId,
@@ -54,7 +56,9 @@ async function addAddress(address, peopleId) {
return peopleAddressResult;
} catch (error) {
+ // return null if error
console.error(error);
+ return null;
}
}
diff --git a/backend/repository/contactRepository.js b/backend/repository/contactRepository.js
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0a091e928f1acd8ce88d4086d3d3303580685cae 100644
--- a/backend/repository/contactRepository.js
+++ b/backend/repository/contactRepository.js
@@ -0,0 +1,35 @@
+const { pool } = require("../config/database/database.config");
+
+/*
+Function to add a row into the peopleContact
+table with the contact info given
+*/
+async function addContact(contact, peopleId) {
+ // extract the parts of the contact
+ let { contactNumber, contactType, preferredContact } = contact;
+
+ console.log("adding contact....");
+
+ try {
+ // query for adding the contact
+ const query = `
+ INSERT INTO peopleContact (peopleId, contactNumber, contactType, preferredContact)
+ VALUES (?,?,?,?)
+ `;
+
+ // insert data into db
+ const [results] = await pool.query(query, [
+ peopleId,
+ contactNumber,
+ contactType,
+ preferredContact,
+ ]);
+
+ return results;
+ } catch (error) {
+ console.log(error);
+ return null;
+ }
+}
+
+module.exports = { addContact };
diff --git a/backend/repository/degreeRepository.js b/backend/repository/degreeRepository.js
index d36e65f0cee7a1c9a114f1fcf92abc46d858f488..9e7835f6df78a84ca076cbe753c0fabfcf5efb23 100644
--- a/backend/repository/degreeRepository.js
+++ b/backend/repository/degreeRepository.js
@@ -1,5 +1,8 @@
const { pool } = require("../config/database/database.config");
+/*
+Add degree information into the database.
+*/
async function addDegree(degree, peopleId) {
// get all the parts of the degree
let {
@@ -14,8 +17,9 @@ async function addDegree(degree, peopleId) {
try {
// Use the helper function to determine the degreeTypeId
- degreeTypeId = await _lookupDegreeTypeId(degreeType);
+ let degreeTypeId = await _lookupDegreeTypeId(degreeType);
+ // query to insert degree info
const query = `
INSERT INTO peopleDegree (peopleId, degreeTypeId, degreeDepartment, degreeCollege, degreeYear, degreeDescription)
VALUES (?,?,?,?,?,?)
@@ -33,7 +37,9 @@ async function addDegree(degree, peopleId) {
return results;
} catch (error) {
+ // return null if there is an error
console.error(error);
+ return null;
}
}
@@ -61,4 +67,4 @@ async function _lookupDegreeTypeId(degreeType) {
}
}
-module.exports = { addDegree };
+module.exports = { addDegree, _lookupDegreeTypeId };
diff --git a/backend/repository/peopleRepository.js b/backend/repository/peopleRepository.js
index 680b8fb3ae862c46fa5440d81323766a83d43480..5191ddcaf92af031524019f98f246ea9823a9d81 100644
--- a/backend/repository/peopleRepository.js
+++ b/backend/repository/peopleRepository.js
@@ -47,7 +47,12 @@ async function addPerson(person) {
return results.insertId;
} catch (error) {
console.error(error);
+ return null;
}
}
+async function getPersonById() {}
+
+async function deletePersonById() {}
+
module.exports = { addPerson };
diff --git a/backend/routes/peopleRoutes.js b/backend/routes/peopleRoutes.js
index 3e707a6bddd3f55bb42afcdbf7c1afbda991cf8c..fe7ff6ba64ae75ce24f8a2be476c79e823e96e5a 100644
--- a/backend/routes/peopleRoutes.js
+++ b/backend/routes/peopleRoutes.js
@@ -122,13 +122,13 @@ peopleRouter.post("/create", validateCreatePerson, async (req, res) => {
const person = await createPerson(req.body);
console.log("In people routes after add: ", person);
- return res.status(201).json({ message: "person added successfully" });
+ return res
+ .status(201)
+ .json({ message: "person added successfully", personId: person });
} catch (error) {
console.log("error");
return res.status(500).json({ message: error });
}
- // no logic for now, return 200
- return res.status(200).json({ message: "No errors" });
});
module.exports = peopleRouter;
diff --git a/backend/service/peopleService.js b/backend/service/peopleService.js
index 0c610db40e1e53609038f1ba4ca8bd493474073f..e196f5c1cba4583fde3cd9e8ec24d44cb338ece1 100644
--- a/backend/service/peopleService.js
+++ b/backend/service/peopleService.js
@@ -1,4 +1,5 @@
const { addAddress } = require("../repository/addressRepository");
+const { addContact } = require("../repository/contactRepository");
const { addDegree } = require("../repository/degreeRepository");
const { addPerson } = require("../repository/peopleRepository");
@@ -25,12 +26,17 @@ async function createPerson(person) {
// insert the contact information into the database
for (const contact of contacts) {
+ const addedContact = await addContact(contact, newPersonID);
+ console.log("added contact: ", contact);
}
// insert the involvment information into the database
for (const involvment of involvements) {
+ console.log("not adding involvements yet.");
}
+ // TODO: log database change here
+
return newPersonID;
}
diff --git a/backend/test/repository/addressRepository.test.js b/backend/test/repository/addressRepository.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..835e7a888e5c31958397dd813efd80c74686efd0
--- /dev/null
+++ b/backend/test/repository/addressRepository.test.js
@@ -0,0 +1,114 @@
+// Mock the database's pool and query function
+jest.mock("../../config/database/database.config", () => {
+ const queryMock = jest.fn(); // Mock query function
+ return { pool: { query: queryMock } }; // Return the mocked pool directly
+});
+
+const { pool } = require("../../config/database/database.config");
+const { addAddress } = require("../../repository/addressRepository");
+
+/*
+Test methods for addressRepository
+*/
+describe("Testing addressRepository.js", () => {
+ const mockAddress1 = {
+ address1: "123 Main St",
+ address2: "Apt 4",
+ city: "Springfield",
+ state: "VA",
+ country: "United States",
+ zipCode: "22150",
+ preferredAddress: true,
+ };
+
+ const mockAddress2 = {
+ address1: "12 Center St",
+ address2: "Apt 14",
+ city: "Centerville",
+ state: "VA",
+ country: "United States",
+ zipCode: "23456",
+ preferredAddress: true,
+ };
+
+ const mockPeopleId = 1;
+
+ describe("addAddress tests", () => {
+ it("Insert 1 address with no errors", async () => {
+ const mockAddressId = 2;
+ const mockPeopleXAddressResult = { affectedRows: 1 };
+
+ // Mock database query for inserting address and peopleXAddress
+ pool.query
+ .mockResolvedValueOnce([{ insertId: mockAddressId }]) // First query for address insertion
+ .mockResolvedValueOnce([mockPeopleXAddressResult]); // Second query for peopleXAddress insertion
+
+ const result = await addAddress(mockAddress1, mockPeopleId);
+
+ // Verify first query was called for address table
+ expect(pool.query).toHaveBeenCalledWith(expect.any(String), [
+ "123 Main St",
+ "Apt 4",
+ "Springfield",
+ 1, // Hardcoded for now
+ 1, // Hardcoded fow now
+ "22150",
+ ]);
+
+ // Verify second query was called for peopleXAddress table
+ expect(pool.query).toHaveBeenCalledWith(expect.any(String), [
+ mockPeopleId,
+ mockAddressId, // ensure the correct addressID was used
+ true,
+ ]);
+
+ // Expect the function to return the result of the second query
+ expect(result).toBe(mockPeopleXAddressResult);
+ });
+
+ it("should handle errors during address insertion", async () => {
+ // Mock database query to throw an error during address insertion
+ const mockError = new Error("Database query failed");
+ pool.query.mockRejectedValueOnce(mockError);
+
+ // Call addAddress and expect it to handle the error
+ const result = await addAddress(mockAddress1, mockPeopleId);
+
+ expect(result).toBe(null);
+ });
+
+ it("Insert 1 address with no errors", async () => {
+ const mockAddressId = 2;
+ const mockPeopleXAddressResult = { affectedRows: 1 };
+
+ // Mock database query for inserting address and peopleXAddress
+ pool.query.mockResolvedValueOnce([{ insertId: mockAddressId }]); // First query for address insertion
+
+ // Mock second query to throw an error during peopleXAddress insertion
+ const mockError = new Error("Failed to insert into peopleXAddress");
+ pool.query.mockRejectedValueOnce(mockError);
+
+ const result = await addAddress(mockAddress1, mockPeopleId);
+
+ // Verify first query was called for address table
+ expect(pool.query).toHaveBeenCalledWith(expect.any(String), [
+ "123 Main St",
+ "Apt 4",
+ "Springfield",
+ 1, // Hardcoded for now
+ 1, // Hardcoded fow now
+ "22150",
+ ]);
+
+ // Verify second query was called for peopleXAddress table
+ expect(pool.query).toHaveBeenCalledWith(expect.any(String), [
+ mockPeopleId,
+ mockAddressId, // ensure the correct addressID was used
+ true,
+ ]);
+
+ // expect a null return after the call
+ expect(result).toBe(null);
+ });
+ });
+});
diff --git a/backend/test/repository/contactRepository.test.js b/backend/test/repository/contactRepository.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..1dfadfb5ca4d4070bda6b392bf180fb9a28b438e
--- /dev/null
+++ b/backend/test/repository/contactRepository.test.js
@@ -0,0 +1,56 @@
+// Mock the database's pool and query function
+jest.mock("../../config/database/database.config", () => {
+ const queryMock = jest.fn(); // Mock query function
+ return { pool: { query: queryMock } }; // Return the mocked pool directly
+});
+
+const { pool } = require("../../config/database/database.config");
+const { addContact } = require("../../repository/contactRepository");
+
+/*
+Test methods for peopleRepository
+*/
+describe("Testing peopleRepository.js", () => {
+ // mock contact value to use while testing
+ const mockContact = {
+ contactNumber: "1234567890",
+ contactType: "mobile",
+ preferredContact: true,
+ };
+ const mockPeopleId = 1;
+
+ /*
+ Tests for the addContact method
+ */
+ describe("addContact Tests", () => {
+ it("insert a contact with no errors", async () => {
+ // Mock the database to return a success response
+ const mockResults = { affectedRows: 1 };
+ pool.query.mockResolvedValueOnce([mockResults]);
+
+ // Call addContact
+ const result = await addContact(mockContact, mockPeopleId);
+
+ // Verify the SQL query and parameters
+ expect(pool.query).toHaveBeenCalledWith(expect.any(String), [
+ 1,
+ "1234567890",
+ "mobile",
+ true,
+ ]);
+
+ // Expect function to return the database result
+ expect(result).toBe(mockResults);
+ });
+
+ it("handle errors if the query fails", async () => {
+ // Mock the database to throw an error
+ const mockError = new Error("Database query failed");
+ pool.query.mockRejectedValueOnce(mockError);
+
+ // Call addContact and expect it to handle the error
+ const result = await addContact(mockContact, mockPeopleId);
+ expect(result).toBe(null);
+ });
+ });
+});
diff --git a/backend/test/repository/degreeRepository.test.js b/backend/test/repository/degreeRepository.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..c0ee99f29b8f9a0dff7049d9d7c8acfd8d60d510
--- /dev/null
+++ b/backend/test/repository/degreeRepository.test.js
@@ -0,0 +1,108 @@
+// Mock the database's pool and query function
+jest.mock("../../config/database/database.config", () => {
+ const queryMock = jest.fn(); // Mock query function
+ return { pool: { query: queryMock } }; // Return the mocked pool directly
+});
+
+const { pool } = require("../../config/database/database.config.js");
+const { addDegree } = require("../../repository/degreeRepository.js");
+
+/*
+Test methods for degreeRepository
+*/
+describe("Testing degreeRepository.js", () => {
+ const mockDegree = {
+ degreeType: "BS",
+ degreeDepartment: "Computer Science",
+ degreeCollege: "Engineering",
+ degreeYear: "2024",
+ degreeDescription: "Bachelor of Science in Computer Science",
+ };
+
+ const mockPeopleId = 1;
+
+ /*
+ Tests for the addDegree method
+ */
+ describe("addDegree tests", () => {
+ it("Insert a degree with no errors", async () => {
+ const mockDegreeTypeId = 1;
+ const mockResult = { affectedRows: 1 };
+
+ // Mock the helper function _lookupDegreeTypeId to return 1
+ const lookupDegreeTypeIdSpy = jest
+ .spyOn(
+ require("../../repository/degreeRepository"),
+ "_lookupDegreeTypeId"
+ )
+ .mockResolvedValueOnce(mockDegreeTypeId);
+
+ // Mock the database query for inserting the degree
+ pool.query.mockResolvedValueOnce([mockResult]);
+
+ // Call addDegree
+ const result = await addDegree(mockDegree, mockPeopleId);
+
+ // Verify the SQL query for inserting the degree
+ expect(pool.query).toHaveBeenCalledWith(expect.any(String), [
+ mockPeopleId,
+ null, // null for now
+ "Computer Science",
+ "Engineering",
+ "2024",
+ "Bachelor of Science in Computer Science",
+ ]);
+
+ // Expect the function to return the result from the database
+ expect(result).toBe(mockResult);
+
+ // Clean up spy
+ lookupDegreeTypeIdSpy.mockRestore();
+ });
+
+ it("error thrown during degree insertion", async () => {
+ const mockError = new Error("Database query failed");
+
+ // Mock the helper function _lookupDegreeTypeId to return 1
+ const lookupDegreeTypeIdSpy = jest
+ .spyOn(
+ require("../../repository/degreeRepository"),
+ "_lookupDegreeTypeId"
+ )
+ .mockResolvedValueOnce(1);
+
+ // Mock the database query to throw an error during degree insertion
+ pool.query.mockRejectedValueOnce(mockError);
+
+ // Call addDegree and expect it to handle the error
+ const result = await addDegree(mockDegree, mockPeopleId);
+
+ // Expect the function to return null on error
+ expect(result).toBeNull();
+
+ // Clean up the spy
+ lookupDegreeTypeIdSpy.mockRestore();
+ });
+
+ it("handle errors during degree type lookup", async () => {
+ const mockError = new Error("Degree type lookup failed");
+
+ // Mock the helper function _lookupDegreeTypeId to throw an error
+ const lookupDegreeTypeIdSpy = jest
+ .spyOn(
+ require("../../repository/degreeRepository"),
+ "_lookupDegreeTypeId"
+ )
+ .mockRejectedValueOnce(mockError);
+
+ // Call addDegree and expect it to handle the error
+ const result = await addDegree(mockDegree, mockPeopleId);
+
+ // Expect the function to return null on error
+ expect(result).toBeNull();
+
+ // Clean up the spy
+ lookupDegreeTypeIdSpy.mockRestore();
+ });
+ });
+});
diff --git a/backend/test/repository/peopleRepository.test.js b/backend/test/repository/peopleRepository.test.js
new file mode 100644
index 0000000000000000000000000000000000000000..1408825cd328dc706d4428fc3523880520b2862d
--- /dev/null
+++ b/backend/test/repository/peopleRepository.test.js
@@ -0,0 +1,70 @@
+// Mock the database's pool and query function
+jest.mock("../../config/database/database.config", () => {
+ const queryMock = jest.fn(); // Mock query function
+ return { pool: { query: queryMock } }; // Return the mocked pool directly
+});
+
+const { pool } = require("../../config/database/database.config");
+const { addPerson } = require("../../repository/peopleRepository");
+
+/*
+Test methods for peopleRepository
+*/
+describe("Testing peopleRepository.js", () => {
+ // mock person for testing
+ const mockPerson = {
+ firstName: "John",
+ lastName: "Doe",
+ middleName: "A",
+ maidenName: null,
+ suffix: null,
+ nickName: "Johnny",
+ techAlumniChapter: "Tidewater AC",
+ classYear: "2024",
+ gradYear: "2024",
+ gradSemester: "spring",
+ gender: "male",
+ };
+
+ /*
+ Tests for the addPerson method
+ */
+ describe("addPerson Tests", () => {
+ it("Insert works with no errors", async () => {
+ // Mock the database to return the new insert ID as 1
+ const mockInsertId = 1;
+ pool.query.mockResolvedValueOnce([{ insertId: mockInsertId }]);
+
+ // call add person
+ const result = await addPerson(mockPerson);
+
+ // Verify the SQL query and parameters
+ expect(pool.query).toHaveBeenCalledWith(expect.any(String), [
+ "John",
+ "Doe",
+ "A",
+ null,
+ null,
+ "Johnny",
+ 2, // hardcoded for now
+ "2024",
+ "2024",
+ "spring",
+ "male",
+ ]);
+
+ // expect function to return the new insert id
+ expect(result).toBe(mockInsertId);
+ });
+
+ it("insert throws an error if query fails", async () => {
+ // Mock the database to throw an error
+ const mockError = new Error("Database query failed");
+ pool.query.mockRejectedValueOnce(mockError);
+
+ // call addPerson and expect it to handle the error
+ const result = await addPerson(mockPerson);
+ expect(result).toBe(null);
+ });
+ });
+});