def main():
ui = UI()
# login default_superuser default_password
print("Welcome. Please login (login <username> <password>")
user_input = ''
while user_input != "exit":
user_input = input("> ")
if user_input != "exit":
print(ui.command(user_input))
if ui.get_current_user() != '':
ui.command('logout')
class TestLogin(ut.TestCase):
def setUp(self):
self.uio = UI()
self.uio.command("create_account Bob bobspw Supervisor")
def tearDown(self):
self.uio.command("delete Bob")
# Successful login of user in database
def test_login1(self):
response = self.uio.command("login Bob bobspw")
self.assertEqual(response, "Logged in as Bob.")
self.assertEqual(self.uio.currentUser, "Bob")
# Failed login, user not in data base
def test_login2(self):
response = self.uio.command("login Alice alicespw")
self.assertEqual(response, "Login failed! Invalid username or password.")
self.assertNotEqual(self.uio.currentUser, "Alice")
# Failed login, password is incorrect
def test_login3(self):
response = self.uio.command("login Bob notbobspw")
self.assertEqual(response, "Login failed! Invalid username or password.")
self.assertNotEqual(self.uio.currentUser, "Bob")
class TestDeleteAccount(ut.TestCase):
def setUp(self):
self.ui = UI()
self.ui.command(
"create_account defaultuser defaultpassword Supervisor")
# test correctly deleting an account
def testDeleteAccount(self):
result1 = self.ui.command("delete_account defaultuser")
self.assertEqual(result1, "defaultuser has been removed")
# test deleting an account that does not exist
def testDeleteAccount2(self):
result2 = self.ui.command("delete_account cabbage")
self.assertEqual(result2, "cabbage does not exist")
# test deleting an account when that account is assigned to a course
def testDeleteAccount3(self):
pass
class TestLogout(ut.TestCase):
def setUp(self):
self.uio = UI()
self.uio.command("create_account Bob bobspw Supervisor")
# Successful logout of current user
def test_logout1(self):
self.uio.command("login Bob bobspw")
response = self.uio.command("logout")
self.assertEqual(response, "Bob has been logged out.")
self.assertNotEqual(self.uio.currentUser, "Bob")
# Make sure current user isn't changed if no one is logged in
def test_logout2(self):
self.assertEqual(self.uio.currentUser, "")
self.uio.command("logout")
self.assertEqual(self.uio.currentUser, "")
class Test_account_edit(ut.TestCase):
def setUp(self):
self.ui = UI()
# test if username exist when not yet created
def test_notExist(self):
self.ui.command("login user1 user1pass")
self.ui.command("edit_account user2")
self.assertEqual(self.ui.command("edit_account user2"),
"user2 doesn't exist")
# test 2 different permissions
def test_permissions(self):
self.ui.command("create_account user1 user1pass instructor")
self.ui.command("create_account user2 user2pass ta")
self.ui.command("login user2 user2pass")
self.assertEqual(self.ui.command("edit_account user1"),
"you don't have permissions to edit this user")
# test the view of the permissions based on login user
def test_viewPermission(self):
permissionList = "create_course\n" \
"create_account\n" \
"delete_account\n" \
"edit_account\n" \
"send_notification\n" \
"access_data\n" \
"assign_instructor\n" \
"assign_TA\n" \
"assign_lab\n"
self.ui.command("create_account user1 user1pass supervisor")
self.ui.command("create_account user2 user2pass ta")
self.ui.command("login user1 user1pass")
self.assertEqual(permissionList, self.ui.command("edit_account user2"))
self.assertEqual(
"please specify what field you would like to change "
"and it's new value", self.ui.command("edit_account user2"))
# test the correct type is entered after selection of field
def test_type(self):
self.ui.command("create_account user1 user1pass supervisor")
self.ui.command("create_account user2 user2pass ta")
self.ui.command("login user1 user1pass")
self.ui.command("edit_account user2")
self.assertEqual(self.ui.command("<password> .....,.,.,,..,`````"),
"Entered value is not valid for <password>")
# test that the field is correct to begin with
def test_type2(self):
self.ui.command("create_account user1 user1pass supervisor")
self.ui.command("create_account user2 user2pass ta")
self.ui.command("login user1 user1pass")
self.ui.command("edit_account user2")
self.ui.command("<gibberish> ......,,,......")
self.assertEqual(self.ui.command("<gibberish>"),
"Entered field <gibberish> is not valid field")
class Test_assign_instructor(ut.TestCase):
def setUp(self):
self.ui = UI()
def test_AddCourse(self):
self.ui.command("create_account user1 user1pass instructor")
self.ui.command("create_account user2 user2pass supervisor")
self.ui.command("login user2 user2pass")
self.assertEqual(self.ui.command("assign_instructor user1 cs101"),
"user1 has been added to cs101")
def test_Overlap(self):
self.ui.command("create_account user1 user1pass instructor")
self.ui.command("create_account user2 user2pass supervisor")
self.ui.command("login user2 user2pass")
self.ui.command("assign_instructor user1 cs101")
self.assertEqual(self.ui.command("assign_instructor user1 cs102"),
"user1 has a timing conflict with cs102")
def test_NoPermissions(self):
self.ui.command("create_account user1 user1pass instructor")
self.ui.command("create_account user2 user2pass supervisor")
self.ui.command("login user1 user1pass")
self.assertEqual(self.ui.command("assign_instructor cs101"), "Current user has insufficient permissions")
class TestReadContactInfo(ut.TestCase):
def setUp(self):
self.ui = UI()
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account Prof0 pass0 Instructor")
self.ui.command("create_account ta0 pass1 TA")
self.ui.command("create_account ta1 pass2 TA")
self.ui.command("logout")
self.ui.command("login Prof0 pass0")
self.ui.command("edit_contact_info")
self.ui.command("phonenumber 414-388-4500")
self.ui.command("email [email protected]")
self.ui.command("address 3523 S Howell Ave Milwaukee WI 53221")
self.ui.command("logout")
self.ui.command("login ta0 pass1")
self.ui.command("edit_contact_info")
self.ui.command("phonenumber 414-545-3661")
self.ui.command("email [email protected]")
self.ui.command("logout")
self.expectedResult = "Prof 414-388-4500 [email protected] 3523 S Howell Ave Milwaukee WI 53221\n" \
"ta0 414-545-3661 [email protected]"
def tearDown(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("delete_account Prof")
self.ui.command("delete_account ta0")
self.ui.command("delete_account ta1")
self.ui.command("logout")
def testViewAsInstructor(self):
self.ui.command("login Prof0 pass0")
actualResult = self.ui.command("read_contact_info")
self.assertEqual(self.expectedResult, actualResult)
self.ui.command("logout")
def testViewAsTA(self):
self.ui.command("login ta0 pass1")
actualResult = self.ui.command("read_contact_info")
self.assertEqual(self.expectedResult, actualResult)
self.ui.command("logout")
class TestUiCommand(ut.TestCase):
def setUp(self):
self.uio = UI()
# check that "help" is being called with no parameters
def test_UiCommand1(self):
patcher = mock.patch.object(self, "help")
patched = patcher.start()
self.uio.command("help")
assert patched.call_count == 1
patched.assert_called_with()
# check that "connect_db" is being called by ui.command("connect_db")
def test_UiCommand2(self):
pass
# check that "disconnect_db" is being called by ui.command("disconnect_db")
def test_UiCommand3(self):
pass
# check that "login" is being called with parameters "username" "password"
def test_UiCommand4(self):
patcher = mock.patch.object(self, "login")
patched = patcher.start()
self.uio.command("login username password")
assert patched.call_count == 1
patched.assert_called_with("username", "password")
# check that "logout" is called with no parameters
def test_UiCommand5(self):
patcher = mock.patch.object(self, "logout")
patched = patcher.start()
self.uio.command("logout")
assert patched.call_count == 1
patched.assert_called_with()
# check that "create_course" is called with "coursename" "section" daysofweek" "time" "labsec"
def test_UiCommand6(self):
patcher = mock.patch.object(self, "create_course")
patched = patcher.start()
self.uio.command(
"create_course coursename section daysofweek time labsec")
assert patched.call_count == 1
patched.assert_called_with("coursename", "section", "daysofweek",
"time", "labsec")
# check that "create_account" is called with "username" "password" "role"
def test_UiCommand7(self):
patcher = mock.patch.object(self, "create_account")
patched = patcher.start()
self.uio.command("create_account username password role")
assert patched.call_count == 1
patched.assert_called_with("username", "password", "role")
# check that "delete_account" is called with "username"
def test_UiCommand8(self):
patcher = mock.patch.object(self, "delete_account")
patched = patcher.start()
self.uio.command("delete_account username")
assert patched.call_count == 1
patched.assert_called_with("username")
# check that "edit_account" is called with "username"
def test_UiCommand9(self):
patcher = mock.patch.object(self, "edit_account")
patched = patcher.start()
self.uio.command("edit_account username")
assert patched.call_count == 1
patched.assert_called_with("username")
# check that "assign_instructor" is called with "username" "coursename"
def test_UiCommand10(self):
patcher = mock.patch.object(self, "assign_instructor")
patched = patcher.start()
self.uio.command("assign_instructor username coursename")
assert patched.call_count == 1
patched.assert_called_with("username", "coursename")
# check that "assign_ta_to_course" is called with "username" "coursename"
def test_UiCommand11(self):
patcher = mock.patch.object(self, "assign_ta_to_course")
patched = patcher.start()
self.uio.command("assign_ta_to_course username coursename")
assert patched.call_count == 1
patched.assert_called_with("username", "coursename")
# check that "assign_ta_to_lab" is called with "username" "coursename" "labsec"
def test_UiCommand12(self):
patcher = mock.patch.object(self, "assign_ta_to_lab")
patched = patcher.start()
self.uio.command("assign_ta_to_lab username coursename labsec")
assert patched.call_count == 1
patched.assert_called_with("username", "coursename", "labsec")
# check that "edit_contact_info" is called with no parameters
def test_UiCommand13(self):
patcher = mock.patch.object(self, "edit_contact_info")
patched = patcher.start()
self.uio.command("edit_contact_info")
assert patched.call_count == 1
patched.assert_called_with()
# check that "view_course_assignments" is called with no parameters
def test_UiCommand14(self):
patcher = mock.patch.object(self, "view_course_assignments")
patched = patcher.start()
self.uio.command("view_course_assignments")
assert patched.call_count == 1
patched.assert_called_with()
# check that "view_ta_assignments" is called with no parameters
def test_UiCommand15(self):
patcher = mock.patch.object(self, "view_ta_assignments")
patched = patcher.start()
self.uio.command("view_ta_assignments")
assert patched.call_count == 1
patched.assert_called_with()
# check that "read_contact_info" is called with no parameters
def test_UiCommand16(self):
patcher = mock.patch.object(self, "read_contact_info")
patched = patcher.start()
self.uio.command("read_contact_info")
assert patched.call_count == 1
patched.assert_called_with()
# check that Error is thrown when invalid parameters are passed
def test_UiCommand17(self):
response = self.uio.command("notacommand")
self.assertEqual(response, "ERROR: this is not an available command")
# check that not passing the proper parameters still passes to the method
def test_UiCommand18(self):
patcher = mock.patch.object(self, "login")
patched = patcher.start()
self.uio.command("login username")
assert patched.call_count == 1
patched.assert_called_with("username")
# check that passing extra parameters still calls "login"
def test_UiCommand19(self):
patcher = mock.patch.object(self, "login")
patched = patcher.start()
self.uio.command("login username password role")
assert patched.call_count == 1
patched.assert_called_with("username", "password", "role")
class TestEditContactInfo(ut.TestCase):
def setUp(self):
self.ui = UI()
def testValidEditPhoneNumber(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
output = self.ui.command("edit_account_info user1")
self.assertEqual(output, "user1 "" "" """)
output = self.ui.command("phonenumber (555)423-5980")
self.assertEqual(output, "user1 (555)423-5980 "" """)
self.ui.command("delete_account user1")
self.ui.command("logout")
def testInvalidEditPhoneNumber(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
output = self.ui.command("edit_account_info user1")
self.assertEqual(output, "user1 "" "" """)
output = self.ui.command("phonenumber (5")
self.assertEqual(output, "That is not a valid input for phonenumber")
self.ui.command("delete_account user1")
self.ui.command("logout")
def testValidEditEmail(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
output = self.ui.command("edit_account_info user1")
self.assertEqual(output, "user1 "" "" """)
output = self.ui.command("email [email protected]")
self.assertEqual(output, "user1 "" [email protected] """)
self.assertTrue(output)
self.ui.command("delete_account user1")
self.ui.command("logout")
def testInvalidEditEmail(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
output = self.ui.command("edit_account_info user1")
self.assertEqual(output, "user1 "" "" """)
output = self.ui.command("email user1&uwm.edu")
self.assertEqual(output, "That is not a valid input for email")
self.assertTrue(output)
self.ui.command("delete_account user1")
self.ui.command("logout")
def testValidEditAddress(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
output = self.ui.command("edit_account_info user1")
self.assertEqual(output, "user1 "" "" """)
output = self.ui.command("address 123 Drive Milwaukee, WI 53211")
self.assertEqual(output, "user1 "" "" 123 Drive Milwaukee, WI 53211")
self.ui.command("delete_account user1")
self.ui.command("logout")
def testInvalidEditAddress(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
output = self.ui.command("edit_account_info user1")
self.assertEqual(output, "user1 "" "" """)
output = self.ui.command("address 123")
self.assertEqual(output, "That is not a valid input for address")
self.ui.command("delete_account user1")
self.ui.command("logout")
def testInvalidField(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
output = self.ui.command("edit_account_info user1")
self.assertEqual(output, "user1 "" "" """)
output = self.ui.command("grades 123")
self.assertEqual(output, "That is not a valid field")
self.ui.command("delete_account user1")
self.ui.command("logout")
class TestViewCourseAssignments(ut.TestCase):
def setUp(self):
self.ui = UI()
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account Prof0 pass0 Instructor")
self.ui.command("create_account Prof1 pass1 Instructor")
self.ui.command("create_account ta0 pass2 TA")
self.ui.command("create_course CS361 401 TH 1100-1200 801")
self.ui.command("create_course CS337 401 MWF 0900-1000 801")
self.ui.command("create_course CS317 401 MW 1300-1415")
self.ui.command("assign_instructor Prof0 CS361")
self.ui.command("assign_instructor Prof0 CS337")
self.ui.command("assign_instructor Prof1 CS317")
self.ui.command("logout")
def tearDown(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("delete_account Prof0")
self.ui.command("delete_account Prof1")
self.ui.command("delete_account ta0")
self.ui.command("logout")
def testViewAsInstructor1(self):
self.ui.command("login Prof0 pass0")
expectedResult = "CS361 401 TH 1100-1200 801\n" \
"CS337 401 MWF 0900-1000 801"
actualResult = self.ui.command("view_course_assignments")
self.assertEqual(expectedResult, actualResult)
self.ui.command("logout")
def testViewAsInstructor2(self):
self.ui.command("login Prof1 pass1")
expectedResult = "CS317 401 MW 1300-1415"
actualResult = self.ui.command("view_course_assignments")
self.assertEqual(expectedResult, actualResult)
self.ui.command("logout")
def testViewAsTA(self):
self.ui.command("login ta0 pass2")
expectedResult = "Insufficient permissions"
actualResult = self.ui.command("view_course_assignments")
self.assertEqual(expectedResult, actualResult)
self.ui.command("logout")
class TestViewTaAssignments(ut.TestCase):
def setUp(self):
self.ui = UI()
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account Prof0 pass0 Instructor")
self.ui.command("create_account ta0 pass1 TA")
self.ui.command("create_account ta1 pass2 TA")
self.ui.command("create_course CS361 401 TH 1100-1200 801/802")
self.ui.command("assign_ta_to_course ta0 CS361")
self.ui.command("assign_ta_to_course ta1 CS361")
self.ui.command("assign_ta_to_lab ta0 CS361 801")
self.ui.command("assign_ta_to_lab ta1 CS361 802")
self.expectedResult = "ta0 CS361 801\n" \
"ta1 CS361 802"
self.ui.command("logout")
def tearDown(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("delete_account Prof0")
self.ui.command("delete_account ta0")
self.ui.command("delete_account ta1")
self.ui.command("logout")
def testViewAsInstructor(self):
self.ui.command("login Prof0 pass0")
actualResult = self.ui.command("view_ta_assignments")
self.assertEqual(self.expectedResult, actualResult)
self.ui.command("logout")
def testViewAsTA(self):
self.ui.command("login ta0 pass1")
actualResult = self.ui.command("view_ta_assignments")
self.assertEqual(self.expectedResult, actualResult)
self.ui.command("logout")
class TestHelp(ut.TestCase):
def setUp(self):
self.uio = UI()
self.uio.command("create_account Bob bobspw Supervisor")
self.uio.command("create_account Alice alicespw Administrator")
self.uio.command("create_account Eve evespw Instructor")
self.uio.command("Create_account Adam adamspw TA")
# Test help with no current user
def test_help1(self):
self.assertEqual(self.uio.currentUser, "")
response = self.uio.command("help")
self.assertEqual(response, "Please login.")
# Test help with Supervisor permissions
def test_help2(self):
supervisorhelpstring = "create_course <name> <section> <days_of_week> <times> (<lab sections>)\n" \
"create_account <username> <password> <role>\n" \
"delete_account <username>\n" \
"edit_account <username>\n" \
"assign_instructor <username> <course>\n" \
"assign_ta_to_course <username> <course>\n" \
"assign_ta_to_lab <username> <course> <labsection>\n" \
"send_notification <username>\n" \
"access_system_data"
self.uio.command("login Bob bobspw")
response = self.uio.command("help")
self.assertEqual(response, supervisorhelpstring)
# Test help with Administrator permissions
def test_help3(self):
administratorhelpstring = "create_course <name> <section> <days_of_week> <times> (<lab sections>)\n" \
"create_account <username> <password> <role>\n" \
"delete_account <username>\n" \
"edit_account <username>\n" \
"send_notification <username>\n" \
"access_system_data"
self.uio.command("login Alice alicespw")
response = self.uio.command("help")
self.assertEqual(response, administratorhelpstring)
# Test help with Instructor permissions
def test_help4(self):
instructorhelpstring = "edit_contact_info\n" \
"view_course_assignments\n" \
"view_ta_assignments\n" \
"assign_ta_to_lab <username> <course> <labsection>\n" \
"send_notification <username>\n" \
"read_contact_info"
self.uio.command("login Eve evespw")
response = self.uio.command("help")
self.assertEqual(response, instructorhelpstring)
# Test help with Instructor permissions
def test_help5(self):
tahelpstring = "edit_contact_info\n" \
"view_course_assignments\n" \
"view_ta_assignments\n" \
"read_contact_info"
self.uio.command("login Adam adamspw")
response = self.uio.command("help")
self.assertEqual(response, tahelpstring)
class TestAssignTaToCourse(ut.TestCase):
def setUp(self):
self.ui = UI()
def testSuccessfulAssign(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
self.ui.command("create_course BS101 420 M/W/F 9:00AM-9:50AM 906")
output = self.ui.command("assign_ta_to_course user1 BS101")
self.assertEqual(output, "user1 has been added to BS101")
self.ui.command("delete_account user1")
self.ui.command("logout")
def testConflictingAssignment(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
self.ui.command("create_course BS101 420 M/W/F 9:00AM-9:50AM 906")
self.ui.command("create_course BS102 421 T/H 4:00PM-4:50PM 909")
output = self.ui.command("assign_ta_to_course user1 BS102")
self.assertEqual(output, "user1 is already assigned to a course")
self.ui.command("delete_user user1")
self.ui.command("logout")
def testPermissionToAssign(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
self.ui.command("create_account user2 pass2 TA")
self.ui.command("create_course BS101 420 M/W/F 9:00AM-9:50AM 906")
self.ui.command("logout")
self.ui.command("login user2 pass2")
output = self.ui.command("assign_ta_to_course user1 BS102")
self.assertEqual(
output, "You do not have permissions to assign TAs to courses")
self.ui.command("logout")
self.ui.command("login defaultuser defaultpassword")
self.ui.command("delete_user user1")
self.ui.command("delete_user user2")
self.ui.command("logout")
class TestCreateCourse(ut.TestCase):
def setUp(self):
self.ui = UI()
# tests if a course with valid parameters is correctly created
def testCreateCourse1(self):
self.ui.command("login defaultuser defaultpassword")
result0 = self.ui.command(
"create_course defaultName 001 M/W/F 9:00AM-9:50AM 801")
self.assertEquals(
result0,
"course: defaultName, section: 001, meeting: M/W/F 9:00AM-9:50AM, section: 801, has been created"
)
self.ui.command("logout")
# tests that a course created with incorrect parameters returns an error
def testCreateCourse2(self):
self.ui.command("login defaultuser defaultpassword")
result1 = self.ui.command(
"create_course beans broccoli spinach cabbage celery")
self.assertEquals(
result1,
"Please input valid arguments for all fields to create a course")
self.ui.command("logout")
# tests that a course created with blank/missing parameters returns an error
def testCreateCourse3(self):
self.ui.command("login defaultuser defaultpassword")
result2 = self.ui.command("create_course defaultName1 001 M/W/F")
self.assertEquals(
result2,
"Please input valid arguments for all fields to create a course")
self.ui.command("logout")
# tests that a course that already exists cannot be created again
def testCreateCourse4(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command(
"create_course defaultName3 003 T/R 10:00AM-10:50AM 803")
result3 = self.ui.command(
"create_course defaultName3 001 M/W/F 9:00AM-9:50AM 801")
self.assertEquals(result3, "Course already exists in the database")
self.ui.command("logout")
class TestAssignTaToLab(ut.TestCase):
def setUp(self):
self.ui = UI()
def testSuccessfulAssign(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_user user1 pass1 TA")
self.ui.command("create_course BS101 420 M/W/F 9:00AM-9:50AM 906")
output = self.ui.command("assign_ta_to_lab user1 BS101 906")
self.assertEqual(output, "user1 has been added to 906")
self.ui.command("delete_user user1")
self.ui.command("logout")
def testSuccessfulDoubleAssign(
self): #do we allow TAs multiple lab sections?
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_user user1 pass1 TA")
self.ui.command("create_course BS101 420 M/W/F 9:00AM-9:50AM 906")
self.ui.command("create_course BS102 421 R 4:00PM-4:50PM 909")
output = self.ui.command("assign_ta_to_lab user1 BS101 906")
self.assertEqual(output, "user1 has been added to 906")
output = self.ui.command("assign_ta_to_lab user1 BS102 909")
self.assertEqual(output, "user1 has been added to 909")
self.ui.command("delete_user user1")
self.ui.command("logout")
def testConflictingAssign(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_user user1 pass1 TA")
self.ui.command("create_course BS101 420 M/W/F 9:00AM-9:50AM 906")
self.ui.command("create_course ED233 421 M/W/F 9:00AM-9:50PM 909")
self.ui.command("assign_ta_to_lab user1 BS101 906")
output = self.ui.command("assign_ta_to_lab user1 ED233 909")
self.assertEqual(output,
"user1 has a timing conflict with this assignment")
def testPermissionToAssign(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("create_account user1 pass1 TA")
self.ui.command("create_account user2 pass2 TA")
self.ui.command("create_course BS101 420 M/W/F 9:00AM-9:50AM 906")
self.ui.command("logout")
self.ui.command("login user2 pass2")
output = self.ui.command("assign_ta_to_lab user1 BS102 906")
self.assertEqual(
output,
"You do not have permissions to assign TAs to lab sections")
self.ui.command("logout")
self.ui.command("login defaultuser defaultpassword")
self.ui.command("delete_user user1")
self.ui.command("delete_user user2")
self.ui.command("logout")
class TestSuperuserLogin(ut.TestCase):
# set up default username, password, role
# sets up a basic account with superuser defaults
def setUp(self):
self.super = Superuser()
self.user = Account()
self.ui = UI()
self.user.set_user = "******"
self.user.set_password = "******"
self.user.set_role = "default_superuser"
# check login with default username/password
def test_defaultLogin(self):
response = "logged in as default_superuser"
self.ui.command("login default_superuser default_password")
self.assertEqual(response, self.super.superuser_authentication("default_superuser", "default_password"))
# check login with right username, wrong password
def test_wrongLogin(self):
response = "login failed. Invalid username or password"
self.ui.command("login default_superuser wrong_password")
self.assertEqual(response, self.super.superuser_authentication("default_superuser", "new_password"))
# check login with wrong username, right password
def test_wrongLogin2(self):
response = "login failed. Invalid username or password"
self.ui.command("login wrong_superuser default_password")
self.assertEqual(response, self.super.superuser_authentication("new_superuser", "default_password"))
# check login when nothing entered
def test_enterNothing(self):
response = "login failed. Invalid username or password"
self.assertEqual(response, self.super.superuser_authentication("", ""))
# check login when role of superuser for any reason is not 'superuser'
# makes call to Superuser check_role, checks wrong condition
def test_wrongRole(self):
self.assertFalse(self.super.check_role("supervisor"))
# check login when role of superuser is superuser
# makes call to Superuser check_role, checks right condition
def test_rightRole(self):
self.assertTrue(self.super.check_role("default_superuser"))
# check login when username entered is wrong
# makes call to Superuser check_name, checks wrong condition
def test_wrongName(self):
self.user.set_role = "new_superuser"
self.assertFalse(self.super.check_name("new_superuser"))
# check login when username entered is correct
# makes call to Superuser check_name, checks right condition
def test_rightName(self):
self.assertTrue(self.super.check_name("default_superuser"))
# check login when password is entered wrong
# makes call to Superuser check_password, checks wrong condition
def test_wrongPass(self):
self.user.set_password = "******"
self.assertFalse(self.super.check_password("new_password"))
# check login when password is entered correct
# makes call to Superuser check_password, checks right condition
def test_rightPass(self):
self.assertTrue(self.super.check_password("default_password"))
class TestCreateAccount(ut.TestCase):
def setUp(self):
self.ui = UI()
# tests creating a new account with correct values
def testCreateAccount1(self):
self.ui.command("login defaultuser defaultpassword")
result0 = self.ui.command("user0 password0 Supervisor")
self.assertEquals(result0, "User user0 has been added")
self.ui.command("logout")
# tests creating an account that already exists
def testCreateAccount2(self):
self.ui.command("login defaultuser defaultpassword")
self.ui.command("user1 password1 Supervisor")
result1 = self.ui.command("user1 passwordBanana Administrator")
self.assertEquals(result1, "user1 already exists")
self.ui.command("logout")
# tests creating an account when the current user has insufficient permissions
def testCreateAccount3(self):
self.ui.command("login defaultuser defaultpassword")
result2 = self.ui.command("userTA passwordTA Administrator")
self.assertEquals(
result2, "You have insufficient permissions to create an account")
self.ui.command("logout")
# tests creating an account with invalid parameters
def testCreateAccount4(self):
self.ui.command("login defaultuser defaultpassword")
result3 = self.ui.command("%$@!& .,.,.,. pumpkin")
self.assertEquals(result3,
"Account cannot be created: invalid parameter(s)")
self.ui.command("logout")
# tests creating an account while leaving a parameter blank
def testCreateAccount5(self):
self.ui.command("login defaultuser defaultpassword")
result4 = self.ui.command("user3 password3")
self.assertEquals(result4,
"Account cannot be created: missing parameter(s)")
self.ui.command("logout")
