def test_set_up(self): self.assertEqual(User.objects.all().count(), 1, "After setup, must contain one user!") self.assertEqual(Section.objects.all().count(), 0) self.assertEqual(Course.objects.all().count(), 0) self.assertEqual(User.objects.filter(username="******").count(), 1) u = User.objects.get(username="******") self.assertIsNotNone(u) self.assertEqual(u.password, "123") self.assertEqual(u.role, dict(User.ROLES)["S"]) # Testing database flushing (Overwrite = True newuser = User(username="******", password="******", role="") newuser.save() newcourse = Course(dept="CS", cnum="351") newcourse.save() newsection = Section(snum="801", course=newcourse) newsection.save() u = User.objects.get(username="******") c = Course.objects.get(dept="CS", cnum="351") s = Section.objects.get(snum="801", course__dept="CS", course__cnum="351") self.assertIsNotNone(u) self.assertIsNotNone(c) self.assertIsNotNone(s) # Should rebuild database, with none of the following models we had created: DjangoStorageManager.set_up(overwrite=True) self.assertEqual(User.objects.all().count(), 1, "After rebuild (overwrite), must contain one user!") self.assertEqual(Section.objects.all().count(), 0) self.assertEqual(Course.objects.all().count(), 0)
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))
def test_get_course(self): c = Course(dept="CS", cnum="351", name="Data Structures and Algorithms") c.save() retval = DjangoStorageManager.get_course(dept="CS", cnum="351") self.assertIsNotNone(retval) self.assertIsInstance(retval, Course) self.assertEqual(retval.name, "Data Structures and Algorithms")
def test_get_section(self): c = Course(dept="CS", cnum="351", name="Data Structures and Algorithms") c.save() s = Section(snum="801", course=c, time="11:00AM") s.save() retval = DjangoStorageManager.get_section(snum="801", dept="CS", cnum="351") self.assertIsNotNone(retval) self.assertIsInstance(retval, Section) self.assertEqual(retval.time, "11:00AM") self.assertEqual(retval.course.cnum, "351") self.assertEqual(retval.course.dept, "CS")
def test_insert_course(self): c = Course(dept="CS", cnum="351") self.assertFalse(DjangoStorageManager.insert_course(c), "Should return false, not overwriting!") retval = Course.objects.get(dept="CS", cnum="351") self.assertIsNotNone(retval) c.name = "Data Structures and Algorithms" self.assertTrue(DjangoStorageManager.insert_course(c), "Should return true, overwriting!") retval = Course.objects.get(dept="CS", cnum="351") self.assertIsNotNone(retval) self.assertEqual( Course.objects.all().count(), 1, "Should only be 1 course in Courses during this test!") self.assertEqual(retval.name, "Data Structures and Algorithms", "Insert didn't properly update the db!")
def insert_course(course: Course) -> bool: existingcourse = DjangoStorageManager.get_course(dept=course.dept, cnum=course.cnum) overwritten = False # Checking if course already exists if existingcourse != None: # overwrite case, just setting new course's id to the old one we found, then overwriting course.id = existingcourse.id course.save() overwritten = True else: # new course, just save it course.save() overwritten = False return overwritten
def test_insert_section(self): c = Course(dept="CS", cnum="351") c.save() s = Section(snum="801", course=c) self.assertFalse(DjangoStorageManager.insert_section(s), "Should return false, not overwriting!") retval = Section.objects.get(snum="801", course__dept="CS", course__cnum="351") self.assertIsNotNone(retval) s.time = "11:00AM" self.assertTrue(DjangoStorageManager.insert_section(s), "Should return true, overwriting!") retval = Section.objects.get(snum="801", course__dept="CS", course__cnum="351") self.assertIsNotNone(retval) self.assertEqual( len(Section.objects.all()), 1, "Should only be 1 section in Sections during this test!") self.assertEqual(retval.time, "11:00AM", "Insert didn't properly update the db!")
def test_delete(self): c = Course(dept="CS", cnum="351") s = Section(snum="801", course=c) u = User(username="******", password="******") # None of these objects are in the database, so nothing should be deleted self.assertFalse(DjangoStorageManager.delete(c)) self.assertFalse(DjangoStorageManager.delete(s)) self.assertFalse(DjangoStorageManager.delete(u)) c.save() s.save() u.save() self.assertEqual(Course.objects.all().count(), 1) self.assertEqual(Section.objects.all().count(), 1) self.assertEqual(User.objects.all().count(), 2) # Deleting objects here self.assertTrue(DjangoStorageManager.delete(s)) self.assertTrue(DjangoStorageManager.delete(c)) self.assertTrue(DjangoStorageManager.delete(u)) self.assertEqual(Course.objects.all().count(), 0) self.assertEqual(Section.objects.all().count(), 0) self.assertEqual(User.objects.all().count(), 1) c = Course(dept="CS", cnum="351") s = Section(snum="801", course=c) u = User(username="******", password="******") c.save() s.save() u.save() self.assertEqual(Course.objects.all().count(), 1) self.assertEqual(Section.objects.all().count(), 1) self.assertEqual(User.objects.all().count(), 2)
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!"
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")
def test_get_sections_by(self): c1 = Course(dept="CS", cnum="351") c2 = Course(dept="CS", cnum="337") c1.save() c2.save() s1 = Section(snum="801", course=c1) s2 = Section(snum="801", course=c2) s3 = Section(snum="802", course=c1) s1.save() s2.save() s3.save() # Testing getting sections by providing snum, dept, and cnum (should be unique - 1 section!) retval = DjangoStorageManager.get_sections_by(dept="CS", cnum="351", snum="801") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 1) self.assertTrue(retval.__contains__(s1)) # Testing getting sections by providing dept retval = DjangoStorageManager.get_sections_by(dept="CS") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 3) self.assertTrue(retval.__contains__(s1)) self.assertTrue(retval.__contains__(s2)) self.assertTrue(retval.__contains__(s3)) # Testing getting sections by providing cnum retval = DjangoStorageManager.get_sections_by(cnum="351") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 2) self.assertTrue(retval.__contains__(s1)) self.assertTrue(retval.__contains__(s3)) # Testing getting section by providing dept and cnum retval = DjangoStorageManager.get_sections_by(dept="CS", cnum="351") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 2) self.assertTrue(retval.__contains__(s1)) self.assertTrue(retval.__contains__(s3)) # Testing getting sections by providing dept and snum retval = DjangoStorageManager.get_sections_by(dept="CS", snum="801") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 2) self.assertTrue(retval.__contains__(s1)) self.assertTrue(retval.__contains__(s2)) # Testing getting sections by providing cnum and snum retval = DjangoStorageManager.get_sections_by(cnum="351", snum="801") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 1) self.assertTrue(retval.__contains__(s1)) # Testing getting sections by providing nothing (all) retval = DjangoStorageManager.get_sections_by() self.assertIsInstance(retval, list) self.assertEqual(len(retval), 3) self.assertTrue(retval.__contains__(s1)) self.assertTrue(retval.__contains__(s2)) self.assertTrue(retval.__contains__(s3))
def test_get_courses_by(self): c1 = Course(dept="CS", cnum="351") c2 = Course(dept="CS", cnum="240") c3 = Course(dept="MATH", cnum="240") c1.save() c2.save() c3.save() # Testing getting course by providing dept and cnum (should be unique - 1 course!) retval = DjangoStorageManager.get_courses_by(dept="MATH", cnum="240") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 1) self.assertTrue(retval.__contains__(c3)) # Testing getting course by providing dept retval = DjangoStorageManager.get_courses_by(dept="CS") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 2) self.assertTrue(retval.__contains__(c1)) self.assertTrue(retval.__contains__(c2)) # Testing getting course by providing cnum retval = DjangoStorageManager.get_courses_by(cnum="240") self.assertIsInstance(retval, list) self.assertEqual(len(retval), 2) self.assertTrue(retval.__contains__(c2)) self.assertTrue(retval.__contains__(c3)) # Testing getting course by providing nothing (all) retval = DjangoStorageManager.get_courses_by() self.assertIsInstance(retval, list) self.assertEqual(len(retval), 3) self.assertTrue(retval.__contains__(c1)) self.assertTrue(retval.__contains__(c2)) self.assertTrue(retval.__contains__(c3))