finished staff program and course tests

App/controllers/courses.py

@@ -3,35 +3,48 @@
 from App.database import db
 import json, csv
 
-def create_course(file_path):
+def createPrerequistes(prereqs, courseName):
+    for prereq_code in prereqs:
+        prereq_course = Course.query.filter_by(courseCode=prereq_code).first()
+
+        if prereq_course:
+            create_prereq(prereq_code,courseName) 
+
+def create_course(code, name, rating, credits, prereqs):
+    already = get_course_by_courseCode(code)
+    if already is None:
+        course = Course(code, name, rating, credits)
+
+        if prereqs:
+            createPrerequistes(prereqs, name)
+
+        db.session.add(course)
+        db.session.commit()
+        return course
+    else:
+        return None
+
+
+def createCoursesfromFile(file_path):
     try:
         with open(file_path, 'r') as file:
             csv_reader = csv.DictReader(file)
             for row in csv_reader:
-                course = Course()
-                course.courseCode = row["courseCode"]
-                course.courseName = row["courseName"]
-                course.credits = int(row["numCredits"])
-                course.rating = int(row["rating"])
+                courseCode = row["courseCode"]
+                courseName = row["courseName"]
+                credits = int(row["numCredits"])
+                rating = int(row["rating"])
                 prerequisites_codes = row["preReqs"].split(',')
-
-                if prerequisites_codes[0]:
-                    prerequisites = []
-                    for prereq_code in prerequisites_codes:
-                        prereq_course = Course.query.filter_by(courseCode=prereq_code).first()
-
-                        if prereq_course:
-                            create_prereq(prereq_code, course.courseName) 
-                db.session.add(course)
+
+                create_course(courseCode, courseName, rating, credits, prerequisites_codes)
 
     except FileNotFoundError:
         print("File not found.")
 
     except Exception as e:
         print(f"An error occurred: {e}")
         return False
-
-    db.session.commit()
+
     print("Courses added successfully.")
 
 def get_course_by_courseCode(code):
@@ -46,6 +59,10 @@ def courses_Sorted_byRating():
 
     return codes
 
+def courses_Sorted_byRating_Objects():
+    return Course.query.order_by(Course.rating.asc()).all()
+
+
 def get_prerequisites(code):
     course = get_course_by_courseCode(code)
     prereqs = get_all_prerequisites(course.courseName)

App/controllers/staff.py

@@ -15,6 +15,10 @@ def verify_staff(username):
         return True
     return False
 
+def get_staff_by_id(ID):
+    return Staff.query.filter_by(id=ID).first()
+
+
 # def add_program(self, program_name, description):
 #     try:
 #         new_program = Program(name=program_name, description=description)

App/controllers/student.py

@@ -42,32 +42,10 @@ def enroll_in_programme(student_id, programme_id):
             db.session.add(student)
             db.session.commit()
 
-def add_course_to_plan(student, course_id):
-    addCourse(student,course_id)
-    return
-
-def remove_course_from_plan(student, course_id):
-    removeCourse(student,course_id)
-    return
-
-def view_course_plan(student):
-    plan=getCoursePlan(student.id)
-    return plan
-
 def verify_student(username):
     student=Student.query.filter_by(id=username).first()
     if student:
         return True
     return False
 
-# def add_courses_from_file(student, file_path):
-#     try:
-#         with open(file_path, 'r') as file:
-#             course_ids = [line.strip() for line in file.readlines()]
-#             for course_id in course_ids:
-#                 add_course_to_plan(student, course_id)
-#         db.session.commit()  # Commit the changes after adding courses
-#     except FileNotFoundError:
-#         return "File not found."
-#     except Exception as e:
-#         return str(e)
+

App/models/courses.py

@@ -16,14 +16,16 @@ class Course(db.Model):
     # planIds = db.relationship('CoursePlanCourses', backref='courses', lazy=True)
 
 
-    def __init__(self):
-        pass
+    def __init__(self, code, name, rating, credits):
+        self.courseCode = code
+        self.courseName = name
+        self.rating = rating
+        self.credits = credits
 
     def get_json(self):
         return{
             'Course Code:': self.courseCode,
             'Course Name: ': self.courseName,
             'Course Rating: ': self.rating,
             'No. of Credits: ': self.credits,
-            'Prerequistes: ': self.prerequisites
         }

App/tests/__init__.py

@@ -1 +1,4 @@
-from .test_app import *
+from .test_app import *
+from .courses import *
+from .program import *
+from .staff import *

App/tests/courses.py

@@ -0,0 +1,68 @@
+import pytest, unittest
+from App.models import Course
+from App.controllers import create_course, courses_Sorted_byRating_Objects, get_course_by_courseCode
+from App.main import create_app
+from App.database import db, create_db
+
+class CourseUnitTests(unittest.TestCase):
+
+    def test_new_course(self):
+        courseCode = "INFO2605"
+        courseName = "Professional Ethics and Law"
+        credits = 3
+        rating = 4 
+
+        course = Course(courseCode, courseName, rating, credits)
+
+        self.assertEqual(course.courseCode, courseCode)
+        self.assertEqual(course.courseName, courseName)
+        self.assertEqual(course.credits, credits)
+        self.assertEqual(course.rating, rating)
+
+    def test_course_json(self):
+        courseCode = "INFO2605"
+        courseName = "Professional Ethics and Law"
+        credits = 3
+        rating = 4 
+
+        course = Course(courseCode, courseName, rating, credits)
+        course_json = course.get_json()
+
+        self.assertDictEqual(course_json, {
+            'Course Code:': courseCode,
+            'Course Name: ': courseName,
+            'Course Rating: ': rating,
+            'No. of Credits: ': credits
+            })
+
+@pytest.fixture(autouse=True, scope="module")
+def empty_db():
+    app = create_app({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///test.db'})
+    create_db()
+    yield app.test_client()
+    db.drop_all()
+
+def test_create_course():
+    courseCode = "INFO2605"
+    courseName = "Professional Ethics and Law"
+    credits = 3
+    rating = 4 
+    prereqs=[]
+
+    course = create_course(courseCode, courseName, rating, credits, prereqs)
+
+    assert get_course_by_courseCode("INFO2605") != None
+
+
+class CourseIntegrationTests(unittest.TestCase):    
+    def test_courses_sorted_by_rating(self):
+        prereqs=[]
+
+        create_course("COMP6000", "DNS", 3, 3, prereqs)
+        create_course("COMP6001", "DSN", 1, 3, prereqs)
+        sortedCourses = courses_Sorted_byRating_Objects()
+
+        self.assertTrue(sortedCourses)
+
+        for i in range(len(sortedCourses) - 1):
+            self.assertLessEqual(sortedCourses[i].rating, sortedCourses[i + 1].rating)

App/tests/program.py

@@ -0,0 +1,47 @@
+import unittest, pytest
+from App.models import Program
+from App.main import create_app
+from App.database import db, create_db
+from App.controllers import create_program, get_program_by_name
+
+class ProgramUnitTests(unittest.TestCase):
+
+    def test_new_program(self):
+        programname = "Information Technology Special"
+        core_credits = 69
+        elective_credits = 15
+        foun_credits = 9
+        program = Program(programname, core_credits, elective_credits, foun_credits)
+        self.assertEqual(program.name, programname)
+        self.assertEqual(program.core_credits, core_credits)
+        self.assertEqual(program.elective_credits, elective_credits)
+        self.assertEqual(program.foun_credits, foun_credits)
+
+    def test_program_toJSON(self):
+        programname = "Information Technology Special"
+        core_credits = 69
+        elective_credits = 15
+        foun_credits = 9
+
+        program = Program(programname, core_credits, elective_credits, foun_credits)
+        program_json = program.get_json()
+
+        self.assertDictEqual(program_json, {
+            'Program ID:': None,
+            'Program Name: ': programname,
+            'Core Credits: ': core_credits,
+            'Elective Credits ': elective_credits,
+            'Foundation Credits: ': foun_credits,
+        })
+
+@pytest.fixture(autouse=True, scope="module")
+def empty_db():
+    app = create_app({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///test.db'})
+    create_db()
+    yield app.test_client()
+    db.drop_all()
+
+class ProgramIntegrationTests(unittest.TestCase):
+    def test_create_program(self):
+        program = create_program("IT", 69, 15, 9)
+        assert get_program_by_name("IT") != None

App/tests/staff.py

@@ -0,0 +1,59 @@
+import unittest, pytest
+from App.main import create_app
+from App.database import db, create_db
+from App.models import Staff
+from App.controllers import create_staff, get_staff_by_id, login
+from werkzeug.security import generate_password_hash
+
+class StaffUnitTests(unittest.TestCase):
+
+    def test_new_staff(self):
+        staffid = 999
+        staffName = "Jane Doe"
+        staffpass = "janepass"
+        staff = Staff(staffpass, staffid, staffName)
+        self.assertEqual(staff.name, staffName)
+        self.assertEqual(staff.id, staffid)
+
+    def test_staff_toJSON(self):
+        staffid = 999
+        staffName = "Jane Doe"
+        staffpass = "janepass"
+
+        staff = Staff(staffpass, staffid, staffName)
+        staff_json = staff.get_json()
+
+        self.assertDictEqual(staff_json, {
+            'staff_id': staffid,
+            'name': staffName,
+            })
+
+    def test_set_password(self):
+        password = "mypass"
+        staff = Staff(password, 999, "Jane Doe")
+        assert staff.password != password
+
+    def test_check_password(self):
+        password = "mypass"
+        staff = Staff(password, 999, "Jane Doe")
+        assert staff.check_password(password)
+
+@pytest.fixture(autouse=True, scope="module")
+def empty_db():
+    app = create_app({'TESTING': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite:///test.db'})
+    create_db()
+    yield app.test_client()
+    db.drop_all()
+
+class StaffIntegrationTests(unittest.TestCase):
+    def test_create_staff(self):
+        staffid = 9
+        staffName = "Jane Doe"
+        staffpass = "janepass"
+        staff = create_staff(staffpass, staffid, staffName)
+
+        assert staff is not None
+        assert get_staff_by_id(9) != None
+
+
+