def getSectionsAndCoursesByUser(self, username):
# Retval[0] = courses, Retval[1] = sections
from Managers.sectionManager import SectionManager as SM
from Managers.courseManager import CourseManager as CM
tempSectionManager = SM(self.storage)
tempCourseManager = CM(self.storage)
courseList = []
sectionList = []
for section in self.storage.get_sections_by():
if section.instructor is not None and section.instructor.username == username:
sectionList.append(
tempSectionManager.view({
"dept": section.course.dept,
"cnum": section.course.cnum,
"snum": section.snum
})[0])
# if not in courses list already, then add to it
bCourseAddToList = True #temp bool for course logic
for existingCourse in courseList:
# If a course already exists we don't add a new one
if existingCourse["cnum"] == section.course.cnum:
bCourseAddToList = False
if bCourseAddToList:
courseList.append(
tempCourseManager.view({
"dept": section.course.dept,
"cnum": section.course.cnum
})[0])
return courseList, sectionList
def setUp(self):
self.course = CourseManager()
self.course.add(dept="CS", cnum="251")
self.db = StorageManager()
Bob = User("Bob", "123", "Instructor")
self.db.insert_user(Bob)
Rob = User("Rob", "123")
self.db.insert_user(Rob)
Cobb = User("Randall Cobb", "123", "Instructor")
self.db.insert_user(Cobb)
self.course.add(dept="CS", cnum="351", instr="Bob", section="401")
self.course.add(dept="CS", cnum="337")
self.sec = SectionManager()
def __init__(self, dm: dsm, parent=None):
# Right now only CS dept courses can be added with manager.
# Dept list can be changed to support more departments
self.depts = ['CS', 'MATH']
self.storage = dm
if parent is None:
from Managers.sectionManager import SectionManager as SM
self.section_manager = SM(self.storage)
else:
self.section_manager = parent
def setUp(self):
self.u1 = User.objects.create(username="******",
first_name="Gimpy",
last_name="McGoo",
email="*****@*****.**",
password="******",
role="instructor")
self.u1.save()
self.c1 = Course.objects.create(cnum="351",
name="Data Structures and Algorithms",
description="N/A",
dept="CS")
self.c1.save()
self.s1 = Section.objects.create(snum="401",
stype="lecture",
course=self.c1,
room=395,
instructor=self.u1,
days="W",
time="12:30PM-1:30PM")
self.s1.save()
self.u2 = User.objects.create(username="******",
first_name="Jayson",
last_name="Rock",
email="*****@*****.**",
password="******",
role="instructor")
self.u2.save()
self.u3 = User.objects.create(username="******",
first_name="Ron",
last_name="Skimpy",
email="*****@*****.**",
password="******",
role="administrator")
self.u3.save()
temp = storage()
self.sec = SM()
def setUp(self):
self.storage = DjangoStorageManager
self.section_manager = SM(self.storage)
self.course_manager = CM(self.storage)
self.user_manager = UM(self.storage)
class sectionTest(TestCase):
def setUp(self):
self.storage = DjangoStorageManager
self.section_manager = SM(self.storage)
self.course_manager = CM(self.storage)
self.user_manager = UM(self.storage)
def tearDown(self):
pass
# Test correct adding (basic), with courses
def test_add(self):
fields = {"dept": "CS", "cnum": "351", "snum": "401"}
self.assertEqual(len(self.course_manager.view({})), 0,
"Should have no courses to start")
self.assertFalse(
self.section_manager.add(fields)[0],
"Can't add when there is no course!")
self.course_manager.add({"dept": "CS", "cnum": "351"})
self.assertTrue(self.section_manager.add(fields)[0])
self.assertFalse(
self.section_manager.add(fields)[0],
"Shouldn't be able to add anymore")
# Test correct adding and editing (assigning)
def test_add_and_assign_ta(self):
sectionFields = {"dept": "CS", "cnum": "351", "snum": "801"}
userFields = {
"username": "******",
"password": "******",
"role": dict(User.ROLES)['T']
}
self.user_manager.add(userFields)
self.course_manager.add({"dept": "CS", "cnum": "351"})
self.assertTrue(self.section_manager.add(sectionFields)[0])
# Course integration
retVal = self.storage.get_course(dept="CS", cnum="351")
self.assertEqual(retVal.sections.first().snum, "801",
"course should have a working 'sections' field!")
# Assigning TA
sectionFields["instructor"] = "john"
self.assertFalse(
self.section_manager.edit(sectionFields)[0], "john doesn't exist!")
sectionFields["instructor"] = "teach"
self.assertFalse(
self.section_manager.edit(sectionFields)[0],
"shouldn't be able to edit, stype not lab when teach is TA")
sectionFields["stype"] = dict(Section.SEC_TYPE)["lab"]
self.assertTrue(
self.section_manager.edit(sectionFields)[0], "valid assignment")
# User integration, should now have courses and sections assigned
retVal = self.storage.get_user("teach")
self.assertEqual(retVal.sections.first().snum, "801",
"user should have a working 'sections' field")
self.assertEqual(retVal.courses.first().cnum, "351",
"user should have a working 'courses' field")
# The SuperTest Basically
#def test_assign_instructor_TAs_and_check_all_thorough(self):
# pass
# Test adding without requirements (cnum, dept, snum)
def test_add_wrong_fields(self):
secNocnum = {"snum": "401", "dept": "CS"}
secNoSnum = {"cnum": "351", "dept": "CS"}
secNodept = {"snum": "401", "cnum": "351"}
self.assertFalse(
self.section_manager.add(secNocnum)[0],
"Should return false when no course number is specified")
self.assertFalse(
self.section_manager.add(secNoSnum)[0],
"Should return false when no section number is specified")
self.assertFalse(
self.section_manager.add(secNodept)[0],
"Should return false when no department is specified")
# user does not exist and shouldn't be able to be added
def test_userNone(self):
secUserInv = {
"snum": "801",
"instructor": "Bubba",
"cnum": "351",
"dept": "CS"
}
self.assertFalse(
self.section_manager.add(secUserInv)[0],
"User Bubba does not exist in the system")
# test that adding fails when adding a new Section whose time and room conflict with another currently existing one
def test_addRoomTimeConflict(self):
secConflict = {
"snum": "801",
"stype": "lab",
"cnum": "351",
"dept": "CS",
"room": 395,
"instructor": "Gumby",
"days": "W",
"time": "12:30PM-1:00PM"
}
self.assertFalse(
self.section_manager.add(secConflict)[0],
"Section added conflicts with already created section")
# test "section view secNum" command output
def test_view(self):
sectionFields = {
"dept": "CS",
"cnum": "351",
"snum": "401",
"stype": "Lecture",
"instructor": "Rock"
}
userFields = {
"username": "******",
"password": "******",
"role": dict(User.ROLES)['I']
}
self.course_manager.add({"dept": "CS", "cnum": "351"})
self.user_manager.add(userFields)
self.section_manager.add(sectionFields)
retSection = self.section_manager.view({
"dept": "CS",
"cnum": "351",
"snum": "401"
})[0]
self.assertEqual(retSection["dept"], "CS")
self.assertEqual(retSection["cnum"], "351")
self.assertEqual(retSection["snum"], "401")
self.assertEqual(retSection["stype"], "Lecture")
self.assertEqual(retSection["instructor"], "Rock")
self.assertEqual(retSection["course"]["cnum"], "351")
# Important!
self.assertEqual(retSection["course"]["sections"], ["nonrecursive"])
# Test to make sure 3 seperate sections can be viewed. Big test
def test_view_all_comprehensive_integrated(self):
self.course_manager.add({"dept": "CS", "cnum": "351"})
self.course_manager.add({"dept": "CS", "cnum": "337"})
sectionFields1 = {
"dept": "CS",
"cnum": "351",
"snum": "401",
"stype": "Lecture",
"instructor": "Boyland"
}
sectionFields2 = {
"dept": "CS",
"cnum": "351",
"snum": "801",
"stype": "Lab",
"instructor": "Tanawat"
}
sectionFields3 = {
"dept": "CS",
"cnum": "337",
"snum": "401",
"stype": "Lecture",
"instructor": "Sorenson"
}
self.user_manager.add({
"username": "******",
"role": dict(User.ROLES)["I"]
})
self.user_manager.add({
"username": "******",
"role": dict(User.ROLES)["T"]
})
self.user_manager.add({
"username": "******",
"role": dict(User.ROLES)["I"]
})
self.section_manager.add(sectionFields1)
self.section_manager.add(sectionFields2)
self.section_manager.add(sectionFields3)
retList = self.section_manager.view({})
self.assertEqual(len(retList), 3)
retFields1 = retList[0]
retFields2 = retList[1]
retFields3 = retList[2]
# Ordered properly?
self.assertEqual(retFields1["cnum"], "337")
self.assertEqual(retFields2["cnum"], "351")
self.assertEqual(retFields2["snum"], "401")
self.assertEqual(retFields3["cnum"], "351")
self.assertEqual(retFields3["snum"], "801")
def test_delete(self):
toDel = {"snum": "401", "cnum": "351", "dept": "CS"}
self.course_manager.add({"dept": "CS", "cnum": "351"})
self.section_manager.add(toDel)
self.assertTrue(
self.section_manager.delete(toDel)[0], "Delete was not successful")
def test_delete_doesntexist(self):
toDel = {"snum": "401", "cnum": "351", "dept": "CS"}
self.assertFalse(
self.section_manager.delete(toDel)[0],
"Delete shouldn't be successful")
# make sure required information is there to delete
def test_delNoInfo(self):
secNoSnum = {"cnum": "351", "dept": "CS"}
secNocnum = {"snum": "401", "dept": "CS"}
secNodept = {"snum": "401", "cnum": "351"}
self.assertFalse(
self.section_manager.delete(secNocnum)[0],
"Should return false when no course number is specified")
self.assertFalse(
self.section_manager.delete(secNoSnum)[0],
"Should return false when no section number is specified")
self.assertFalse(
self.section_manager.delete(secNodept)[0],
"Should return false when no department is specified")
def test_edit(self):
toEdit = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "1:00PM-2:00PM"
}
self.assertTrue(self.section_manager.edit(toEdit),
"Edit was not successful")
# Test edit without enough info
def test_editNoInfo(self):
secNocnum = {"snum": "401", "dept": "CS"}
secNoSnum = {"cnum": "351", "dept": "CS"}
secNodept = {"snum": "401", "cnum": "351"}
self.assertFalse(
self.section_manager.delete(secNocnum)[0],
"Should return false when no course number is specified")
self.assertFalse(
self.section_manager.delete(secNoSnum)[0],
"Should return false when no section number is specified")
self.assertFalse(
self.section_manager.delete(secNodept)[0],
"Should return false when no department is specified")
# Test edit when given various invalid field inputs
def test_editInvalid(self):
editDays = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "Wrong",
"instructor": "Rock",
"room": 400,
"time": "1:00PM-2:00PM"
}
editIns = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Crunchy",
"room": 400,
"time": "1:00PM-2:00PM"
}
editRoom = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": "Wrong",
"time": "1:00PM-2:00PM"
}
editTime = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "Wrong"
}
self.assertFalse(
self.section_manager.edit(editDays)[0],
"Should return false due to invalid days input")
self.assertFalse(
self.section_manager.edit(editIns)[0],
"Should return false due to invalid instructor")
self.assertFalse(
self.section_manager.edit(editRoom)[0],
"Should return false due to invalid room number")
self.assertFalse(
self.section_manager.edit(editTime)[0],
"Should return false due to invalid time")
# Need to make sure that the "time" field accepts multiple ways of inputting (e.g "01:30 PM", "1:30 PM"
def test_editTimes(self):
timeOne = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "01:30PM-02:30PM",
"stype": "Lecture"
}
timeTwo = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "3:30PM-4:30PM",
"stype": "Lecture"
}
self.course_manager.add({"dept": "CS", "cnum": "351"})
self.user_manager.add({
"username": "******",
"role": dict(User.ROLES)['I']
})
self.assertTrue(
self.section_manager.add(timeOne)[0],
"Adding time was not successful")
self.assertTrue(
self.section_manager.edit(timeTwo)[0],
"Editing time was not successful")
# Test that if, upon editing, the if the new room and time conflict with a previously added section, it fails.
def test_editRoomTimeConflict(self):
newSec = {
"snum": "801",
"stype": "lab",
"cnum": "351",
"dept": "CS",
"room": 901,
"instructor": "Gumby",
"days": "T",
"time": "4:00PM-5:00PM"
}
self.section_manager.add(newSec)
secConflict = {
"snum": "801",
"stype": "lab",
"cnum": "351",
"dept": "CS",
"room": 395,
"instructor": "Gumby",
"days": "W",
"time": "12:30PM-1:00PM"
}
self.assertFalse(
self.section_manager.edit(secConflict)[0],
"Section added conflicts with already created section")
class sectionTest(unittest.TestCase):
def setUp(self):
self.course = CourseManager()
self.course.add(dept="CS", cnum="251")
self.db = StorageManager()
Bob = User("Bob", "123", "Instructor")
self.db.insert_user(Bob)
Rob = User("Rob", "123")
self.db.insert_user(Rob)
Cobb = User("Randall Cobb", "123", "Instructor")
self.db.insert_user(Cobb)
self.course.add(dept="CS", cnum="351", instr="Bob", section="401")
self.course.add(dept="CS", cnum="337")
self.sec = SectionManager()
def tearDown(self):
del self.course
del self.sec
del self.db
def test_add(self):
self.assertEqual(self.sec.add("CS", "251", "401"),
"Section Added: CS-251-401")
self.assertEqual(self.sec.add("CS", "251", "401", "Bob"),
"Section Added: CS-251-401 instructor: Bob")
def test_addNoInfo(self):
self.assertEqual(
"Could not complete addition, section number is needed",
self.sec.add(dept="CS", cnum="251"))
self.assertEqual(
"Could not complete addition, section number is needed",
self.sec.add(dept="CS", cnum="251", ins="Bob"))
self.assertEqual(
"Could not complete addition, course number is needed",
self.sec.add(dept="CS", snum="401", ins="Bob"))
self.assertEqual("Could not complete addition, department is needed",
self.sec.add(cnum="251", snum="401", ins="Bob"))
# user does not exist and shouldn't be able to be added
def test_userNone(self):
self.assertEqual(
"Nobody does not exist in the system",
self.sec.add(dept="CS", cnum="251", snum="401", ins="Nobody"))
def test_notQualified(self):
self.assertEqual(
"User can't instruct the course",
self.sec.add(dept="CS", cnum="337", snum="401", ins="Rob"))
# test "section view secNum" command output
def test_view(self):
self.assertEqual(self.sec.view(dept="CS", cnum="351", snum="401"),
"Course: CS-351\nSection: 401\nInstructor: Bob")
# Test to make sure a course without a section will not be found
def test_viewNot(self):
self.assertEqual("Could not find CS-337-401",
self.sec.view(dept="CS", cnum="337", snum="401"))
def test_viewNoInfo(self):
self.assertEqual("Could not complete view, section number is needed",
self.sec.view(dept="CS", cnum="251"))
self.assertEqual("Could not complete view, section number is needed",
self.sec.view(dept="CS", cnum="251", ins="Bob"))
self.assertEqual("Could not complete view, course number is needed",
self.sec.view(dept="CS", snum="401", ins="Bob"))
self.assertEqual("Could not complete view, department is needed",
self.sec.view(cnum="251", snum="401", ins="Bob"))
class sectionTest(TestCase):
def setUp(self):
self.u1 = User.objects.create(username="******",
first_name="Gimpy",
last_name="McGoo",
email="*****@*****.**",
password="******",
role="instructor")
self.u1.save()
self.c1 = Course.objects.create(cnum="351",
name="Data Structures and Algorithms",
description="N/A",
dept="CS")
self.c1.save()
self.s1 = Section.objects.create(snum="401",
stype="lecture",
course=self.c1,
room=395,
instructor=self.u1,
days="W",
time="12:30PM-1:30PM")
self.s1.save()
self.u2 = User.objects.create(username="******",
first_name="Jayson",
last_name="Rock",
email="*****@*****.**",
password="******",
role="instructor")
self.u2.save()
self.u3 = User.objects.create(username="******",
first_name="Ron",
last_name="Skimpy",
email="*****@*****.**",
password="******",
role="administrator")
self.u3.save()
temp = storage()
self.sec = SM()
def tearDown(self):
pass
# Test correct adding
def test_add(self):
newSec = {
"snum": "801",
"stype": "lab",
"cnum": "351",
"dept": "CS",
"room": 901,
"instructor": "Gumby",
"days": "T",
"time": "4:00PM-5:00PM"
}
self.assertTrue(self.sec.add(newSec), "New section was not added")
# Test add when given various invalid field inputs
def test_addInvalid(self):
addDays = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "Wrong",
"instructor": "Rock",
"room": 400,
"time": "1:00PM-2:00PM",
"snumNew": "402"
}
addIns = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Crunchy",
"room": 400,
"time": "1:00PM-2:00PM",
"snumNew": "402"
}
addRoom = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": "Wrong",
"time": "1:00PM-2:00PM",
"snumNew": "402"
}
addTime = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "Wrong",
"snumNew": "402"
}
addsnum = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "1:00PM-2:00PM",
"snumNew": "Wrong"
}
self.assertFalse(self.sec.add(addDays),
"Should return false due to invalid days input")
self.assertFalse(self.sec.add(addIns),
"Should return false due to invalid instructor")
self.assertFalse(self.sec.add(addRoom),
"Should return false due to invalid room number")
self.assertFalse(self.sec.add(addTime),
"Should return false due to invalid time")
self.assertFalse(self.sec.add(addsnum),
"Should return false due to invalid section number")
# Test adding without requirements (cnum, dept, snum)
def test_addNoInfo(self):
secNocnum = {"snum": "401", "dept": "CS"}
secNoSnum = {"cnum": "351", "dept": "CS"}
secNodept = {"snum": "401", "cnum": "351"}
self.assertFalse(
self.sec.add(secNocnum),
"Should return false when no course number is specified")
self.assertFalse(
self.sec.add(secNoSnum),
"Should return false when no section number is specified")
self.assertFalse(
self.sec.add(secNodept),
"Should return false when no department is specified")
# user does not exist and shouldn't be able to be added
def test_userNone(self):
secUserInv = {
"snum": "801",
"instructor": "Bubba",
"cnum": "351",
"dept": "CS"
}
self.assertFalse(self.sec.add(secUserInv),
"User Bubba does not exist in the system")
# test that adding fails when adding a new Section whose time and room conflict with another currently existing one
def test_addRoomTimeConflict(self):
secConflict = {
"snum": "801",
"stype": "lab",
"cnum": "351",
"dept": "CS",
"room": 395,
"instructor": "Gumby",
"days": "W",
"time": "12:30PM-1:00PM"
}
self.assertFalse(
self.sec.add(secConflict),
"Section added conflicts with already created section")
# test "section view secNum" command output
def test_view(self):
toView = {"snum": "401", "cnum": "351", "dept": "CS"}
self.assertEqual(
self.sec.view(toView),
"Course: CS-351<br>Section: 401<br>Instructor: Gumby<br>Meeting time(s): W 12:30PM-1:30PM"
"<br>Room: 395")
# Test to make sure a course without a section will not be found
def test_viewNot(self):
self.courseT = Course(cnum="337",
name="Systems Programming",
description="N/A",
dept="CS")
self.courseT.save()
toView = {"snum": "401", "dept": "CS", "cnum": "337"}
self.assertEqual("Could not find CS-337-401", self.sec.view(toView))
# Test view without enough information
def test_viewNoInfo(self):
secNocnum = {"snum": "401", "dept": "CS"}
secNoSnum = {"cnum": "351", "dept": "CS"}
secNodept = {"snum": "401", "cnum": "351"}
self.assertEqual(
self.sec.view(secNocnum),
"Could not complete viewing, course number is needed",
"Should not be able to view without course specified")
self.assertEqual(
self.sec.view(secNoSnum),
"Could not complete viewing, section number is needed",
"Should not be able to view without section number specified")
self.assertEqual(
self.sec.view(secNodept),
"Could not complete viewing, department is needed",
"Should not be able to view without department specified")
def test_delete(self):
toDel = {"snum": "401", "cnum": "351", "dept": "CS"}
self.assertTrue(self.sec.delete(toDel), "Delete was not successful")
# make sure required information is there to delete
def test_delNoInfo(self):
secNoSnum = {"cnum": "351", "dept": "CS"}
secNocnum = {"snum": "401", "dept": "CS"}
secNodept = {"snum": "401", "cnum": "351"}
self.assertFalse(
self.sec.delete(secNocnum),
"Should return false when no course number is specified")
self.assertFalse(
self.sec.delete(secNoSnum),
"Should return false when no section number is specified")
self.assertFalse(
self.sec.delete(secNodept),
"Should return false when no department is specified")
def test_edit(self):
toEdit = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "1:00PM-2:00PM"
}
self.assertTrue(self.sec.edit(toEdit), "Edit was not successful")
# Test edit without enough info
def test_editNoInfo(self):
secNocnum = {"snum": "401", "dept": "CS"}
secNoSnum = {"cnum": "351", "dept": "CS"}
secNodept = {"snum": "401", "cnum": "351"}
self.assertFalse(
self.sec.delete(secNocnum),
"Should return false when no course number is specified")
self.assertFalse(
self.sec.delete(secNoSnum),
"Should return false when no section number is specified")
self.assertFalse(
self.sec.delete(secNodept),
"Should return false when no department is specified")
# Test edit when given various invalid field inputs
def test_editInvalid(self):
editDays = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "Wrong",
"instructor": "Rock",
"room": 400,
"time": "1:00PM-2:00PM"
}
editIns = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Crunchy",
"room": 400,
"time": "1:00PM-2:00PM"
}
editRoom = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": "Wrong",
"time": "1:00PM-2:00PM"
}
editTime = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "Wrong"
}
self.assertFalse(self.sec.edit(editDays),
"Should return false due to invalid days input")
self.assertFalse(self.sec.edit(editIns),
"Should return false due to invalid instructor")
self.assertFalse(self.sec.edit(editRoom),
"Should return false due to invalid room number")
self.assertFalse(self.sec.edit(editTime),
"Should return false due to invalid time")
# Need to make sure that the "time" field accepts multiple ways of inputting (e.g "01:30 PM", "1:30 PM"
def test_editTimes(self):
timeOne = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "01:30PM-02:30PM"
}
timeTwo = {
"cnum": "351",
"dept": "CS",
"snum": "401",
"days": "MWF",
"instructor": "Rock",
"room": 400,
"time": "3:30PM-4:30PM"
}
self.assertTrue(self.sec.edit(timeOne),
"Editing time was not successful")
self.assertTrue(self.sec.edit(timeTwo),
"Editing time was not successful")
# Test that if, upon editing, the if the new room and time conflict with a previously added section, it fails.
def test_editRoomTimeConflict(self):
newSec = {
"snum": "801",
"stype": "lab",
"cnum": "351",
"dept": "CS",
"room": 901,
"instructor": "Gumby",
"days": "T",
"time": "4:00PM-5:00PM"
}
self.sec.add(newSec)
secConflict = {
"snum": "801",
"stype": "lab",
"cnum": "351",
"dept": "CS",
"room": 395,
"instructor": "Gumby",
"days": "W",
"time": "12:30PM-1:00PM"
}
self.assertFalse(
self.sec.edit(secConflict),
"Section added conflicts with already created section")
class CourseManager(ManagerInterface):
def __init__(self, dm: dsm, parent=None):
# Right now only CS dept courses can be added with manager.
# Dept list can be changed to support more departments
self.depts = ['CS', 'MATH']
self.storage = dm
if parent is None:
from Managers.sectionManager import SectionManager as SM
self.section_manager = SM(self.storage)
else:
self.section_manager = parent
# Adds a Course to the database, returning True if added, False if not added (Error or already exists).
def add(self, fields: dict):
if not self._check_params(fields):
return False, "Please fill out both dept and cnum"
course = self.storage.get_course(dept=fields['dept'],
cnum=fields['cnum'])
if course is None:
course = Course()
course.dept = fields['dept']
course.cnum = fields['cnum']
# Unvalidated fields
if 'name' in fields.keys() and fields['name'] is not None and len(
fields['name'].strip()) > 0:
course.name = fields['name']
if 'description' in fields.keys(
) and fields['description'] is not None and len(
fields['description'].strip()) > 0:
course.description = fields['description']
self.storage.insert_course(course)
return True, ""
return False, "Course already exists!"
# Returns a list of matching courses.
# ALWAYS returns a list, even if only one course. access by using list[0]
# On multiple view, list of courses is sorted by dept THEN cnum eg CS240 is before MATH105
def view(self, fields: dict) -> [dict]:
dept = None
cnum = None
retVal = []
if 'dept' in fields.keys() and fields['dept'] is not None and len(
fields['dept'].strip()) > 0:
dept = fields['dept']
if 'cnum' in fields.keys() and fields['cnum'] is not None and len(
fields['cnum'].strip()) > 0:
cnum = fields['cnum']
matchingcourses = []
if dept is not None and cnum is not None:
matchingcourses = self.storage.get_courses_by(dept=dept, cnum=cnum)
elif dept is not None:
matchingcourses = self.storage.get_courses_by(dept=dept)
elif cnum is not None:
matchingcourses = self.storage.get_courses_by(cnum=cnum)
else:
matchingcourses = self.storage.get_courses_by()
for course in matchingcourses:
retFields = {}
retFields['dept'] = course.dept
retFields['cnum'] = course.cnum
retFields['name'] = course.name
retFields['description'] = course.description
if 'nonrecursive' not in fields.keys():
retFields['sections'] = self.section_manager.view({
"dept":
course.dept,
"cnum":
course.cnum,
"nonrecursive":
"true"
})
else:
retFields['sections'] = ['nonrecursive']
retVal.append(retFields)
retVal.sort(key=lambda k: k['dept'] + k['cnum'])
return retVal
def delete(self, fields: dict):
"""Delete a specific course from the database"""
# Check if required params are present and error check optional params
if not self._check_params(fields):
return False, "Please fill out both dept and cnum"
# Store dict values into variables
dept = fields.get('dept').upper()
cnum = fields.get('cnum')
# Retrieve courses with dept and cnum
course_list = self.storage.get_courses_by(dept=dept, cnum=cnum)
# Delete all courses retreived from database with given dept and cnum
for c in course_list:
if not self.storage.delete(c):
return False, "Error Deleting Course"
return True, ""
# Edits a Course, returning true if successful
def edit(self, fields: dict):
if not self._check_params(fields):
return False, "Please fill out both dept and cnum"
course = self.storage.get_course(dept=fields['dept'],
cnum=fields['cnum'])
if course is not None:
# Unvalidated fields
if 'name' in fields.keys() and fields['name'] is not None and len(
fields['name'].strip()) > 0:
course.name = fields['name']
if 'description' in fields.keys(
) and fields['description'] is not None and len(
fields['description'].strip()) > 0:
course.description = fields['description']
self.storage.insert_course(course)
return True, ""
return False, "Course doesn't exist!"
# Check for invalid parameters
def _check_params(self, fields: dict):
dept = fields.get('dept')
cnum = fields.get('cnum')
instructor = fields.get('instructor')
if not dept:
return False
if not cnum:
return False
if not cnum.isdigit():
return False
else:
return True
@staticmethod
def reqFields() -> list:
return ['dept', 'cnum']
@staticmethod
def optFields() -> list:
return ['name', 'description', 'snum', 'instructor']
def setUp(self):
self.user_manager = UserManager(dm)
self.course_manager = CourseManager(dm)
self.section_manager = SectionManager(dm)
class UserManagerTests(TestCase):
def setUp(self):
self.user_manager = UserManager(dm)
self.course_manager = CourseManager(dm)
self.section_manager = SectionManager(dm)
def tearDown(self):
del self.user_manager
def test_user_add_basic(self):
# Basic fields case
fields = {'username': '******', 'password': '******'}
# Testing that the returns are the expected behavior:
self.assertTrue(
self.user_manager.add(fields)[0], "Should be a valid user add!")
self.assertFalse(
self.user_manager.add(fields)[0],
"Should no longer be able to add !: User Exists")
def test_user_add_incorrect_fields(self):
# Completely incorrect add, the req fields aren't filled out!
fields = {'un': 'new', 'pass': '******'}
self.assertFalse(
self.user_manager.add(fields)[0],
"Should only add if reqfields are filled out!")
fields = {'username': '******', 'password': '******', 'role': 'student'}
self.assertFalse(
self.user_manager.add(fields)[0],
"Role provided not in ROLES! Should not add!")
def test_user_add_complicated(self):
# A complicated, highest level test, shouldn't fail or throw exceptions:
fields = {
'username': '******',
'password': '******',
'role': dict(User.ROLES)["I"], # Instructor, ins, whatever
'email': '*****@*****.**',
'address': '123 sesame street'
}
# Return val checking for subsequent calls
self.assertTrue(
self.user_manager.add(fields)[0], "Failed on omplicated user add")
self.assertFalse(
self.user_manager.add(fields)[0],
"Shouldn't be able to call again")
def test_view_user_basic(self):
# adding basic user to test with
fields = {'username': '******', 'password': '******'}
self.assertEqual(len(self.user_manager.view({"username": "******"})), 0,
"No users case!")
self.assertTrue(self.user_manager.add(fields)[0])
retVal = self.user_manager.view(fields)[0]
# Testing all values against what they should be
self.assertEqual(retVal['username'], 'test')
self.assertEqual(retVal['password'], '123')
self.assertEqual(retVal['firstname'], '')
self.assertEqual(retVal['lastname'], '')
self.assertEqual(retVal['bio'], '')
self.assertEqual(retVal['email'], '')
self.assertEqual(retVal['role'], dict(User.ROLES)['D'])
self.assertEqual(retVal['phonenum'], '')
self.assertEqual(retVal['address'], '')
def test_view_user_all_basic(self):
# Adding three basic users to test with
fields1 = {'username': '******', 'password': '******'}
fields2 = {
'username': '******',
'password': '******',
'role': dict(User.ROLES)["A"]
}
fields3 = {
'username': '******',
'password': '******',
'role': dict(User.ROLES)["I"]
}
self.assertTrue(
self.user_manager.add(fields1)[0], "Error adding fields1!")
self.assertTrue(
self.user_manager.add(fields2)[0], "Error adding fields2!")
self.assertTrue(
self.user_manager.add(fields3)[0], "Error adding fields3!")
# View all (no username or role provided) must return all users, alphabetically sorted by username
retVal = self.user_manager.view({})
self.assertEqual(len(retVal), 4)
# Because sorted by username
retFields1 = retVal[2]
retFields2 = retVal[0]
retFields3 = retVal[3]
# All retFields should not be None and must all be of type dict
self.assertIsNotNone(retFields1)
self.assertIsNotNone(retFields2)
self.assertIsNotNone(retFields3)
self.assertIsInstance(retFields1, dict)
self.assertIsInstance(retFields2, dict)
self.assertIsInstance(retFields3, dict)
# Testing all values against what they should be
self.assertEqual(retFields1['username'], 'test')
self.assertEqual(retFields1['password'], '123')
self.assertEqual(retFields1['firstname'], '')
self.assertEqual(retFields1['lastname'], '')
self.assertEqual(retFields1['bio'], '')
self.assertEqual(retFields1['email'], '')
self.assertEqual(retFields1['role'], dict(User.ROLES)['D'])
self.assertEqual(retFields1['phonenum'], '')
self.assertEqual(retFields1['address'], '')
self.assertEqual(retFields2['username'], 'scotty')
self.assertEqual(retFields2['password'], '232')
self.assertEqual(retFields2['firstname'], '')
self.assertEqual(retFields2['lastname'], '')
self.assertEqual(retFields2['bio'], '')
self.assertEqual(retFields2['email'], '')
self.assertEqual(retFields2['role'], dict(User.ROLES)['A'])
self.assertEqual(retFields2['phonenum'], '')
self.assertEqual(retFields2['address'], '')
self.assertEqual(retFields3['username'], 'truff')
self.assertEqual(retFields3['password'], 'pass')
self.assertEqual(retFields3['firstname'], '')
self.assertEqual(retFields3['lastname'], '')
self.assertEqual(retFields3['bio'], '')
self.assertEqual(retFields3['email'], '')
self.assertEqual(retFields3['role'], dict(User.ROLES)['I'])
self.assertEqual(retFields3['phonenum'], '')
self.assertEqual(retFields3['address'], '')
def test_edit_user_basic(self):
# Basic fields case
fields = {'username': '******', 'password': '******'}
self.assertFalse(self.user_manager.edit(fields)[0], "No user to edit!")
self.assertTrue(self.user_manager.add(fields)[0], "Add should work")
# Editing nothing should still return true
self.assertTrue(
self.user_manager.edit(fields)[0],
"Edit should return true if user exists! Even if no changes!")
# Basic editing
# Basic fields case
fields = {'username': '******', 'password': '******'}
self.assertTrue(
self.user_manager.edit(fields)[0], "Edit should return true.")
def test_edit_user_roles_and_view_integrated(self):
# Basic fields case
fields = {'username': '******', 'password': '******'}
self.assertTrue(self.user_manager.add(fields)[0])
retVal = self.user_manager.view(fields)[0]
self.assertEqual(retVal['username'], 'test')
self.assertEqual(retVal['password'], '123')
self.assertEqual(retVal['firstname'], '')
self.assertEqual(retVal['lastname'], '')
self.assertEqual(retVal['bio'], '')
self.assertEqual(retVal['email'], '')
self.assertEqual(retVal['role'], dict(User.ROLES)['D'])
self.assertEqual(retVal['phonenum'], '')
self.assertEqual(retVal['address'], '')
# Basic fields case
fields = {
'username': '******',
'password': '******',
'role': dict(User.ROLES)['I']
}
self.assertTrue(self.user_manager.edit(fields)[0])
retVal = self.user_manager.view(fields)[0]
self.assertEqual(retVal['username'], 'test')
self.assertEqual(retVal['password'], '123')
self.assertEqual(retVal['firstname'], '')
self.assertEqual(retVal['lastname'], '')
self.assertEqual(retVal['bio'], '')
self.assertEqual(retVal['email'], '')
self.assertEqual(retVal['role'], dict(User.ROLES)['I'])
self.assertEqual(retVal['phonenum'], '')
self.assertEqual(retVal['address'], '')
def test_delete_user(self):
# Basic fields case
fields = {'username': '******', 'password': '******'}
self.assertTrue(self.user_manager.add(fields)[0])
self.assertEqual(len(self.user_manager.view({"username": "******"})), 1)
self.assertTrue(self.user_manager.delete({"username": "******"})[0])
self.assertEqual(len(self.user_manager.view({"username": "******"})), 0,
"Should have been deleted!")
# Tests that courses and sections lists work properly
def test_view_check_courses_and_sections(self):
rockDict = {"username": "******", "role": dict(User.ROLES)["I"]}
tanawatDict = {"username": "******", "role": dict(User.ROLES)["T"]}
self.user_manager.add(rockDict)
self.user_manager.add(tanawatDict)
self.course_manager.add({"dept": "CS", "cnum": "361"})
self.course_manager.add({"dept": "CS", "cnum": "557"})
sectionFields1 = {
"dept": "CS",
"cnum": "361",
"snum": "401",
"stype": "Lecture",
"instructor": "Rock"
}
sectionFields2 = {
"dept": "CS",
"cnum": "361",
"snum": "801",
"stype": "Lab",
"instructor": "Tanawat"
}
sectionFields3 = {
"dept": "CS",
"cnum": "557",
"snum": "401",
"stype": "Lecture",
"instructor": "Rock"
}
self.assertTrue(self.section_manager.add(sectionFields1))
self.assertTrue(self.section_manager.add(sectionFields2))
self.assertTrue(self.section_manager.add(sectionFields3))
retRock = self.user_manager.view({"username": "******"})[0]
retTan = self.user_manager.view({"username": "******"})[0]
# Rock should have 2 courses and 2 sections
self.assertEqual(len(retRock["courses"]), 2)
self.assertEqual(len(retRock["sections"]), 2)
# Rock's first course should be 361, and the second 557 (sorted)
self.assertEqual(retRock["courses"][0]["cnum"], "361")
self.assertEqual(retRock["courses"][1]["cnum"], "557")
# Rock's first section should be 361-401 then 557-401
self.assertEqual(retRock["sections"][0]["cnum"], "361")
self.assertEqual(retRock["sections"][0]["snum"], "401")
self.assertEqual(retRock["sections"][1]["cnum"], "557")
self.assertEqual(retRock["sections"][1]["snum"], "401")