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"
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 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")
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 TestUiCreateCourse(ut.TestCase):
def setUp(self):
self.uio = UI()
# test that create_course calls Course constructor with proper parameters
def test_UiCreateCourse1(self):
patcher = mock.patch.object(Course, "__init__")
patched = patcher.start()
self.uio.create_course("CS-337", "004", "M/W/F", "11:00-11:50",
"001/002/003")
assert patched.call_count == 1
patched.assert_called_with("CS-337", "004", ["M", "W", "F"], "11:00",
"11:50", ["001", "002", "003"])
# test that create_course raises an error if all required parameters are not passed in
def test_UiCreateCourse2(self):
with self.assertRaises(ValueError) as ctx:
self.uio.create_course("CS-337")
self.assertEqual(
"Please fill in all required fields to create a course",
str(ctx.exception))
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 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 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 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")
def setUp(self):
self.ui = UI()
self.ui.sCurrentUser = '******'
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 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")
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")
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")
def setUp(self):
self.uio = UI()
self.uio.command("create_account Bob bobspw Supervisor")
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")
def setUp(self):
self.ui = UI()
self.ui.command(
"create_account defaultuser defaultpassword Supervisor")
class TestUI(ut.TestCase):
def setUp(self):
self.ui = UI()
self.ui.sCurrentUser = '******'
def test_connect_db_failed(self):
empty_path = ''
invalid_path = 'C:/invalidpath.csv'
result1 = self.ui.connect_db(empty_path)
result2 = self.ui.connect_db(invalid_path)
self.assertFalse(result1.is_connected)
self.assertFalse(result2.is_connected)
def test_connect_db_successful(self):
result_connect_accounts = self.ui.connect_db(
'C:/Users/user/PycharmProjects/ta_app/DB_Files/accounts.csv')
result_connect_courses = self.ui.connect_db(
'C:/Users/user/PycharmProjects/ta_app/DB_Files/courses.csv')
self.assertTrue(result_connect_accounts.is_connected)
self.assertTrue(result_connect_courses.is_connected)
# test is for super user only as of now
def test_login_success(self):
result = self.ui.login('default_superuser', 'default_password')
self.assertEqual(result, 'login successful...')
self.assertEqual(self.ui.sCurrentUser, 'default_superuser')
def test_login_badUser(self):
self.ui.sCurrentUser = ''
result = self.ui.login('badUser', 'default_password')
self.assertEqual(result, 'login failed! bad username/ password')
self.assertEqual(self.ui.sCurrentUser, '')
def test_login_badPassword(self):
self.ui.sCurrentUser = ''
result = self.ui.login('default_superuser', 'badPassword')
self.assertEqual(result, 'login failed! bad username/ password')
self.assertEqual(self.ui.sCurrentUser, '')
def test_logout(self):
self.ui.sCurrentUser = '******'
result = self.ui.logout()
self.assertEqual(result, 'logout successful...')
self.assertEqual(self.ui.sCurrentUser, '')
def test_create_account_success(self):
self.ui.sCurrentUser = '******'
result = self.ui.create_account('user', 'pass', 'TA')
self.assertEqual(result, 'Successfully created account')
def test_create_account_failed_bad_arg(self):
self.ui.sCurrentUser = '******'
result_no_pass = self.ui.create_account('user', '', 'role')
result_no_user = self.ui.create_account('', 'password', 'role')
result_no_role = self.ui.create_account('user', 'password', '')
self.assertEqual(
result_no_pass,
'Failed to create account. Invalid or missing argument')
self.assertEqual(
result_no_user,
'Failed to create account. Invalid or missing argument')
self.assertEqual(
result_no_role,
'Failed to create account. Invalid or missing argument')
def test_create_account_failed_insufficient_permissions(self):
self.ui.sCurrentUser = '******'
result = self.ui.create_account('user', 'pass', 'role')
self.assertEqual(result,
'Failed to create account. Insufficient permissions')
def test_create_course_failed_insufficient_permissions(self):
self.ui.sCurrentUser = '******'
result = self.ui.create_course("CS-337", "004", "M/W/F", "11:00-11:50",
"001/002/003")
self.assertEqual(result,
'Failed to create course. Insufficient permissions')
def test_create_course_failed_missing_arguments(self):
self.ui.sCurrentUser = '******'
result1 = self.ui.create_course("", "004", "M/W/F", "11:00-11:50",
"001/002/003")
result2 = self.ui.create_course("CS-337", "", "M/W/F", "11:00-11:50",
"001/002/003")
result3 = self.ui.create_course("CS-337", "004", "", "11:00-11:50",
"001/002/003")
result4 = self.ui.create_course("CS-337", "004", "M/W/F", "",
"001/002/003")
result5 = self.ui.create_course("CS-337", "004", "M/W/F",
"11:00-11:50", "")
self.assertEqual(result1, 'Failed to create course. Invalid arguments')
self.assertEqual(result2, 'Failed to create course. Invalid arguments')
self.assertEqual(result3, 'Failed to create course. Invalid arguments')
self.assertEqual(result4, 'Failed to create course. Invalid arguments')
self.assertEqual(result5, 'Failed to create course. Invalid arguments')
def test_create_course_success(self):
self.ui.sCurrentUser = '******'
result = self.ui.create_course("CS-337", "004", "M/W/F", "11:00-11:50",
"001/002/003")
self.assertEqual(result, 'Course created successfully')
def test_delete_account_successful(self):
self.ui.sCurrentUser = '******'
self.ui.create_account('user', 'pass', 'TA')
result = self.ui.delete_account('user', 'pass', 'TA')
self.assertEqual(result, 'Successfully deleted account')
def test_delete_account_failed_missing_argument(self):
self.ui.sCurrentUser = '******'
result = self.ui.delete_account('')
self.assertEqual(
result, 'Failed to delete account. Invalid or missing argument')
def test_delete_account_failed_insufficient_permissions(self):
self.ui.sCurrentUser = '******'
self.ui.create_account('user1', 'pass', 'TA')
result = self.ui.delete_account('user', 'pass', 'TA')
self.assertEqual(result,
'Failed to delete account. Insufficient permissions')
def test_delete_account_failed_UserNotExist(self):
self.ui.sCurrentUser = '******'
result = self.ui.delete_account('UserNotExist', 'pass', 'TA')
self.assertEqual(result, 'Failed to delete account. User not found')
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 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")
def setUp(self):
self.ui = UI()
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 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 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")
