def test_CommandsCreateCourse1(self):
co = Commands()
co.current_user = self.Account1
response = co.create_course("CS-458", "001", "T/R", "03:00-04:15")
self.assertEqual(
response,
"Please input valid arguments for all fields to create a course")
def test_CommandsCreateCourse2(self):
co = Commands()
co.current_user = self.Account1
response = co.create_course("CS-337", "004", "M/W/F", "11:00-11:50",
"001/002/003")
self.assertEqual(
response, "Course CS-337 - 004 already exists in the data base")
def test_CommandsCreateCourse3(self):
co = Commands()
co.current_user = self.Account1
response = co.create_course("CS-520", "004", "Z/x", "11:00-11:50",
"001/002/003")
self.assertEqual(response,
"Days of week are noted as M, T, W, R, F, S, U, O")
def test_CommandsCreateCourse6(self):
co = Commands()
co.current_user = self.Account1
response = co.create_course("CS-520", "004", "M/W/F", "11:00-10:00",
"001/002/003")
self.assertEqual(response,
"end time can not be earlier than start time")
class TestReadContactInfo(TestCase):
def setUp(self):
self.ui = Commands()
self.tst_supervisor = Account(
user='******',
password='******',
role='Supervisor',
street_address='3200 N Newport Ave Milwaukee WI 53211',
email_address='*****@*****.**',
phone_number='414-736-9565')
self.tst_administrator = Account(
user='******',
password='******',
role='Administrator',
street_address='1026 S 27th St Milwaukee WI 53221',
email_address='*****@*****.**',
phone_number='920-223-5166')
self.tst_instructor = Account(
user='******',
password='******',
role='Instructor',
street_address='2466 N 13th St Milwaukee WI 53201',
email_address='*****@*****.**',
phone_number='262-115-1107')
self.tst_ta = Account(
user='******',
password='******',
role='TA',
street_address='2466A N 13th St Milwaukee WI 53201',
email_address='*****@*****.**',
phone_number='262-115-1109')
self.tst_supervisor.save()
self.tst_administrator.save()
self.tst_instructor.save()
self.tst_ta.save()
# TODO: Create a string that is the expected output of read_contact_info()
# Will probably have some html formatting in it
self.expected_output = 'nothingYet'
def test_supervisor_read_contact_info(self):
self.ui.current_user = self.tst_supervisor
actual_output = self.ui.read_contact_info()
self.assertEqual(actual_output, self.expected_output)
def test_administrator_read_contact_info(self):
self.ui.current_user = self.tst_administrator
actual_output = self.ui.read_contact_info()
self.assertEqual(actual_output, self.expected_output)
def test_instructor_read_contact_info(self):
self.ui.current_user = self.tst_instructor
actual_output = self.ui.read_contact_info()
self.assertEqual(actual_output, self.expected_output)
def test_ta_read_contact_info(self):
self.ui.current_user = self.tst_ta
actual_output = self.ui.read_contact_info()
self.assertEqual(actual_output, self.expected_output)
def test_CommandsCreateCourse9(self):
co = Commands()
co.current_user = self.Account1
co.create_course("CS-520", "004", "M/W/F", "09:00-10:00",
"001/002/003")
courseo = Course.objects.get(name="CS-520")
response = Lab.objects.filter(course=courseo).count()
self.assertEqual(response, 3)
def post(self, request):
co = Commands()
name = request.POST["user_name"]
password = request.POST["password"]
out = co.login(name, password)
request.session["user"] = co.current_user.user
if co.current_user.user == name and "redirect_to" in request.session:
return HttpResponseRedirect(request.session["redirect_to"])
return render(request, "website/login.html", {"return_statement": out})
def setUp(self):
self.ui = Commands()
self.tst_supervisor = Account(user='******', password='******', role='Supervisor')
self.tst_administrator = Account(user='******', password='******', role='Administrator')
self.tst_instructor = Account(user='******', password='******', role='Instructor')
self.tst_ta = Account(user='******', password='******', role='TA')
self.tst_supervisor.save()
self.tst_administrator.save()
self.tst_instructor.save()
self.tst_ta.save()
def test_CommandsCreateCourse8(self):
co = Commands()
co.current_user = self.Account1
response = co.create_course("CS-520", "004", "M/W/F", "09:00-10:00",
"001/002/003")
self.assertEqual(
response,
"Course CS-520 has been added to the data base with lab sections 001/002/003"
)
count = Course.objects.filter(name="CS-520").count()
self.assertEqual(count, 1)
class CreateCourse(View):
co = Commands()
create_course_header = "Create A Course"
def get(self, request):
if "user" in request.session and "user" in request.session:
ao = Account.objects.get(user=request.session["user"])
self.co.current_user = ao
return render(request, "website/create_course.html",
{"header": self.create_course_header})
def post(self, request):
if "user" in request.session and request.session["user"] is not None:
ao = Account.objects.get(user=request.session["user"])
self.co.current_user = ao
name = request.POST['course_name']
section = request.POST['course_section']
days_of_week = request.POST['course_days']
time = request.POST['course_time']
labs = request.POST['lab_sections']
out = self.co.create_course(name, section, days_of_week, time,
labs)
return render(request, "website/create_course.html", {
"header": self.create_course_header,
"return_statement": out
})
else:
out = "Please log in to create a course"
return render(request, "website/create_course.html", {
"header": self.create_course_header,
"return_statement": out
})
class ViewContactInfo(View):
co = Commands()
view_contact_header = "Contact Information"
def get(self, request):
if "user" in request.session:
ao = Account.objects.get(user=request.session["user"])
self.co.current_user = ao
return render(request, "website/view_contact_info.html",
{"header": self.view_contact_header})
def post(self, request):
if "user" in request.session and "user" in request.session and request.session[
"user"] is not None:
ao = Account.objects.get(user=request.session["user"])
self.co.current_user = ao
out = self.co.read_contact_info()
return render(request, "website/view_contact_info.html", {
"header": self.view_contact_header,
"return_statement": out
})
else:
out = "Please log in to assign an instructor to a course"
return render(request, "website/view_contact_info.html", {
"header": self.view_contact_header,
"return_statement": out
})
class Home(View):
ui = Commands()
def get(self, request):
return render(request, "website/index.html")
def post(self, request):
out = self.ui.call_command(request.POST["command"])
return render(request, "website/index.html", {"out": out})
def setUp(self):
self.Course1 = Course.objects.create(name="CS-337",
section="001",
days_of_week="M/W",
start_time="11:00",
end_time="11:50")
self.Course1.save()
self.Course2 = Course.objects.create(name="CS-361",
section="003",
days_of_week="T/R",
start_time="14:00",
end_time="14:50")
self.Course2.save()
self.Lab1 = Lab.objects.create(course=self.Course1,
section="002",
days_of_week="T",
start_time="14:00",
end_time="15:50")
self.Lab1.save()
self.Lab2 = Lab.objects.create(course=self.Course1,
section="003",
days_of_week="F",
start_time="12:00",
end_time="13:50")
self.Lab2.save()
self.Account1 = Account.objects.create(user="******",
password="******",
role="Supervisor")
self.Account1.save()
self.Account2 = Account.objects.create(user="******",
password="******",
role="TA")
self.Account2.save()
self.Account3 = Account.objects.create(user="******",
password="******",
role="TA")
self.Account3.save()
self.Course1.tas.add(self.Account3)
self.Course1.save()
self.co = Commands()
self.co.current_user = self.Account1
def setUp(self):
self.Course1 = Course.objects.create(name="CS-337",
section="004",
days_of_week="M/W/F",
start_time="11:00",
end_time="11:50")
self.Course1.save()
self.Course2 = Course.objects.create(name="CS-361",
section="003",
days_of_week="M/W",
start_time="11:00",
end_time="13:15")
self.Course2.save()
self.Account1 = Account.objects.create(user="******",
password="******",
role="Supervisor")
self.Account1.save()
self.Account2 = Account.objects.create(user="******",
password="******",
role="Instructor")
self.Account2.save()
self.co = Commands()
self.co.current_user = self.Account1
def setUp(self):
self.ui = Commands()
self.tst_supervisor = Account(user='******',
password='******',
role='Supervisor')
self.tst_administrator = Account(user='******',
password='******',
role='Administrator')
self.tst_instructor = Account(user='******',
password='******',
role='Instructor')
self.tst_ta = Account(user='******', password='******', role='TA')
self.tst_supervisor.save()
self.tst_administrator.save()
self.tst_instructor.save()
self.tst_ta.save()
self.tst_course = Course(name="EE-554",
section="004",
days_of_week="M/W/F",
start_time="11:00",
end_time="11:50")
self.tst_course.save()
class TestEditAccount(TestCase):
def setUp(self):
self.ui = Commands()
self.tst_supervisor = Account(user='******',
password='******',
role='Supervisor')
self.tst_administrator = Account(user='******',
password='******',
role='Administrator')
self.tst_instructor = Account(user='******',
password='******',
role='Instructor')
self.tst_ta = Account(user='******', password='******', role='TA')
self.tst_supervisor.save()
self.tst_administrator.save()
self.tst_instructor.save()
self.tst_ta.save()
def test_edit_account_insufficient_permissions(self):
self.ui.login('usrSupervisor', 'password')
newPhone = '414-368-6425'
expected_output = 'Failed to edit account. Insufficient permissions'
actual_output = self.ui.edit_account(self.tst_ta.user,
phone_number=newPhone)
self.assertNotEqual(expected_output, actual_output)
def test_edit_account_address(self):
self.ui.login('usrSupervisor', 'password')
newAddress = '1026 Lake Dr Milwaukee WI'
expected_output = 'Account information successfully changed'
actual_output = self.ui.edit_account(self.tst_ta.user,
street_address=newAddress)
self.assertEqual(expected_output, actual_output)
def test_edit_account_phone(self):
self.ui.login('usrSupervisor', 'password')
newPhone = '414-368-6425'
expected_output = 'Account information successfully changed'
actual_output = self.ui.edit_account(self.tst_ta.user,
phone_number=newPhone)
self.assertEqual(expected_output, actual_output)
class AssignInstructor(View):
co = Commands()
instructor_header = "Assign An Instructor To A Course"
ta_to_lab = False
def get(self, request):
if "user" in request.session:
ao = Account.objects.get(user=request.session["user"])
self.co.current_user = ao
return render(request, "website/assign.html", {
"header": self.instructor_header,
"is_ta_to_lab": self.ta_to_lab
})
def post(self, request):
if "user" in request.session and "user" in request.session and request.session[
"user"] is not None:
ao = Account.objects.get(user=request.session["user"])
self.co.current_user = ao
user = request.POST["user_name"]
course = request.POST["course_name"]
out = self.co.assign_instructor(user, course)
return render(
request, "website/assign.html", {
"header": self.instructor_header,
"is_ta_to_lab": self.ta_to_lab,
"return_statement": out
})
else:
out = "Please log in to assign an instructor to a course"
return render(
request, "website/assign.html", {
"header": self.instructor_header,
"is_ta_to_lab": self.ta_to_lab,
"return_statement": out
})
class TestViewCourseAssignments(TestCase):
def setUp(self):
self.ui = Commands()
self.tst_supervisor = Account(user='******', password='******', role='Supervisor')
self.tst_administrator = Account(user='******', password='******', role='Administrator')
self.tst_instructor = Account(user='******', password='******', role='Instructor')
self.tst_ta = Account(user='******', password='******', role='TA')
self.tst_supervisor.save()
self.tst_administrator.save()
self.tst_instructor.save()
self.tst_ta.save()
def test_view_course_assignments_no_user(self):
expected_output = "Failed to view course assignments. No current user"
actual_output = self.ui.view_course_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_course_assignments_as_ta(self):
self.ui.login('usrTA', 'password')
expected_output = "Failed to view course assignments. Insufficient permissions"
actual_output = self.ui.view_course_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_course_assignments_as_instructor(self):
self.ui.login('usrInstructor', 'password')
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
expected_output = "<p>Course: " + test_course.name + ", Instructor: " + self.tst_instructor.user + "</p><br />"
actual_output = self.ui.view_course_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_course_assignments_as_supervisor(self):
self.ui.login('usrSupervisor', 'password')
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
expected_output = "<p>Course: " + test_course.name + ", Instructor: " + self.tst_instructor.user + "</p><br />"
actual_output = self.ui.view_course_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_course_assignments_as_Administrator(self):
self.ui.login('usrAdministrator', 'password')
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
expected_output = "<p>Course: " + test_course.name + ", Instructor: " + self.tst_instructor.user + "</p><br />"
actual_output = self.ui.view_course_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_course_assignments_multiple_courses_multiple_instructors_as_administrator(self):
self.ui.login('usrAdministrator', 'password')
test_instructor2 = Account(user='******', password='******', role='Instructor')
test_instructor2.save()
test_course1 = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course1.save()
test_course2 = Course(name="CS104",
section="223",
days_of_week="M/W/F",
start_time="14:00",
end_time="15:00",
instructor=test_instructor2,
lab="363")
test_course2.save()
expected_output = "<p>Course: " + test_course1.name + ", Instructor: " + self.tst_instructor.user + "</p><br />" + \
"<p>Course: " + test_course2.name + ", Instructor: " + test_instructor2.user + "</p><br />"
actual_output = self.ui.view_course_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_course_assignments_no_instructor_as_administrator(self):
self.ui.login('usrAdministrator', 'password')
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
lab="333")
test_course.save()
test_course2 = Course(name="CS104",
section="223",
days_of_week="M/W/F",
start_time="14:00",
end_time="15:00",
instructor=self.tst_instructor,
lab="363")
test_course2.save()
expected_output = "<p>Course: " + test_course2.name + ", Instructor: " + self.tst_instructor.user + "</p><br />"
actual_output = self.ui.view_course_assignments()
self.assertEqual(expected_output, actual_output)
# =====================================================================
def test_view_ta_assignments_no_user(self):
expected_output = "Failed to view ta assignments. No current user"
actual_output = self.ui.view_ta_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_ta_assignments_single_ta_single_course_as_ta(self):
self.ui.login("usrTA", "password")
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
test_course.tas.add(self.tst_ta)
expected_output = "<p>Course: " + test_course.name + ", Section: " + test_course.section + ", TA(s): " + self.tst_ta.user + " </p><br />"
actual_output = self.ui.view_ta_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_ta_assignments_single_ta_single_course_as_instructor(self):
self.ui.login("usrInstructor", "password")
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
test_course.tas.add(self.tst_ta)
expected_output = "<p>Course: " + test_course.name + ", Section: " + test_course.section + ", TA(s): " + self.tst_ta.user + " </p><br />"
actual_output = self.ui.view_ta_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_ta_assignments_single_ta_single_course_as_supervisor(self):
self.ui.login("usrSupervisor", "password")
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
test_course.tas.add(self.tst_ta)
expected_output = "<p>Course: " + test_course.name + ", Section: " + test_course.section + ", TA(s): " + self.tst_ta.user + " </p><br />"
actual_output = self.ui.view_ta_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_ta_assignments_single_ta_single_course_as_administrator(self):
self.ui.login("usrAdministrator", "password")
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
test_course.tas.add(self.tst_ta)
expected_output = "<p>Course: " + test_course.name + ", Section: " + test_course.section + ", TA(s): " + self.tst_ta.user + " </p><br />"
actual_output = self.ui.view_ta_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_ta_assignments_multiple_ta_single_course_as_ta(self):
self.ui.login("usrTA", "password")
test_ta2 = Account(user="******", password="******", role="TA")
test_ta2.save()
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
test_course.tas.add(self.tst_ta)
test_course.tas.add(test_ta2)
expected_output = "<p>Course: " + test_course.name + ", Section: " + test_course.section + ", TA(s): " + self.tst_ta.user + " " + test_ta2.user + " </p><br />"
actual_output = self.ui.view_ta_assignments()
self.assertEqual(expected_output, actual_output)
def test_view_ta_assignments_single_ta_multiple_course_as_ta(self):
self.ui.login("usrTA", "password")
test_ta2 = Account(user="******", password="******", role="TA")
test_ta2.save()
test_course = Course(name="CS103",
section="222",
days_of_week="M/W/F",
start_time="12:00",
end_time="13:00",
instructor=self.tst_instructor,
lab="333")
test_course.save()
test_course.tas.add(self.tst_ta)
test_course2 = Course(name="CS104",
section="223",
days_of_week="M/W/F",
start_time="14:00",
end_time="15:00",
instructor=self.tst_instructor,
lab="363")
test_course2.save()
test_course2.tas.add(test_ta2)
expected_output = "<p>Course: " + test_course.name + ", Section: " + test_course.section + \
", TA(s): " + self.tst_ta.user + " </p><br />" + \
"<p>Course: " + test_course2.name + ", Section: " + test_course2.section + \
", TA(s): " + test_ta2.user + " </p><br />"
actual_output = self.ui.view_ta_assignments()
self.assertEqual(expected_output, actual_output)
class TestCommands(TestCase):
def setUp(self):
self.ui = Commands()
self.tst_supervisor = Account(user='******',
password='******',
role='Supervisor')
self.tst_administrator = Account(user='******',
password='******',
role='Administrator')
self.tst_instructor = Account(user='******',
password='******',
role='Instructor')
self.tst_ta = Account(user='******', password='******', role='TA')
self.tst_supervisor.save()
self.tst_administrator.save()
self.tst_instructor.save()
self.tst_ta.save()
self.tst_course = Course(name="EE-554",
section="004",
days_of_week="M/W/F",
start_time="11:00",
end_time="11:50")
self.tst_course.save()
def test_call_command_valid(self):
self.ui.current_user = Account()
self.ui.set_command_list()
output1 = self.ui.call_command('help')
output2 = self.ui.call_command('login usrSupervisor password')
output3 = self.ui.call_command('logout')
self.assertNotEqual(output1, 'You should type something...')
self.assertNotEqual(output2, 'You should type something...')
self.assertNotEqual(output3, 'You should type something...')
self.assertNotEqual(output1, 'Too many arguments entered. Try again!')
self.assertNotEqual(output2, 'Too many arguments entered. Try again!')
self.assertNotEqual(output3, 'Too many arguments entered. Try again!')
self.assertNotEqual(output1, 'ERROR: this is not an available command')
self.assertNotEqual(output2, 'ERROR: this is not an available command')
self.assertNotEqual(output3, 'ERROR: this is not an available command')
def testCallCommandInvalid(self):
expected_output = 'ERROR: this is not an available command'
actual_output = self.ui.call_command('invalidCommand')
self.assertEqual(expected_output, actual_output)
def test_call_command_too_many_args(self):
expected_output = 'Too many arguments entered. Try again!'
actual_output = self.ui.call_command('login user password oops')
self.assertEqual(expected_output, actual_output)
def test_call_command_no_args(self):
expected_output = ''
actual_output = self.ui.call_command()
self.assertEqual(expected_output, actual_output)
def test_help_with_no_current_user(self):
self.ui.current_user = Account()
output = self.ui.help()
self.assertTrue(output.find('login'))
self.assertTrue(output.find('help'))
def test_help_as_supervisor(self):
self.ui.current_user = self.tst_supervisor
output = self.ui.help()
self.assertTrue(output.find('logout'))
self.assertTrue(output.find('create_account'))
self.assertTrue(output.find('delete_account'))
self.assertTrue(output.find('edit_account'))
self.assertTrue(output.find('create_account'))
self.assertTrue(output.find('assign_instructor'))
self.assertTrue(output.find('assign_ta_to_course'))
self.assertTrue(output.find('assign_ta_to_lab'))
self.assertTrue(output.find('view_course_assignments'))
self.assertTrue(output.find('view_ta_assignments'))
self.assertTrue(output.find('edit_contact_info'))
self.assertTrue(output.find('read_contact_info'))
self.assertTrue(output.find('help'))
def test_help_as_administrator(self):
self.ui.current_user = self.tst_administrator
output = self.ui.help()
self.assertTrue(output.find('logout'))
self.assertTrue(output.find('create_account'))
self.assertTrue(output.find('delete_account'))
self.assertTrue(output.find('edit_account'))
self.assertTrue(output.find('create_account'))
self.assertTrue(output.find('view_course_assignments'))
self.assertTrue(output.find('view_ta_assignments'))
self.assertTrue(output.find('edit_contact_info'))
self.assertTrue(output.find('read_contact_info'))
self.assertTrue(output.find('help'))
def test_help_as_instructor(self):
self.ui.current_user = self.tst_instructor
output = self.ui.help()
self.assertTrue(output.find('logout'))
self.assertTrue(output.find('assign_ta_to_lab'))
self.assertTrue(output.find('view_course_assignments'))
self.assertTrue(output.find('view_ta_assignments'))
self.assertTrue(output.find('edit_contact_info'))
self.assertTrue(output.find('read_contact_info'))
self.assertTrue(output.find('help'))
def test_help_as_ta(self):
self.ui.current_user = self.tst_ta
output = self.ui.help()
self.assertTrue(output.find('logout'))
self.assertTrue(output.find('view_ta_assignments'))
self.assertTrue(output.find('edit_contact_info'))
self.assertTrue(output.find('read_contact_info'))
self.assertTrue(output.find('help'))
def test_login_bad_username(self):
self.ui.current_user = Account()
username = '******'
expected_output = 'login failed! bad username/ password'
actual_output = self.ui.login(username, 'password')
self.assertEqual(expected_output, actual_output)
self.assertNotEqual(self.ui.current_user.user, username)
self.assertTrue(self.ui.current_user.id is None)
def test_login_bad_password(self):
self.ui.current_user = Account()
username = '******'
expected_output = 'login failed! bad username/ password'
actual_output = self.ui.login(username, 'badPassword')
self.assertEqual(expected_output, actual_output)
self.assertNotEqual(self.ui.current_user.user, username)
self.assertTrue(self.ui.current_user.id is None)
def test_login_supervisor(self):
self.ui.current_user = Account()
username = '******'
expected_output = 'login successful...'
actual_output = self.ui.login(username, 'password')
self.assertEqual(expected_output, actual_output)
self.assertEqual(self.ui.get_current_user(), self.tst_supervisor)
commands = self.ui.command_list
expected_num_commands = 13
self.assertEqual(expected_num_commands, len(commands))
self.assertTrue(commands.__contains__('logout'))
self.assertTrue(commands.__contains__('create_account'))
self.assertTrue(commands.__contains__('delete_account'))
self.assertTrue(commands.__contains__('edit_account'))
self.assertTrue(commands.__contains__('create_account'))
self.assertTrue(commands.__contains__('assign_instructor'))
self.assertTrue(commands.__contains__('assign_ta_to_course'))
self.assertTrue(commands.__contains__('assign_ta_to_lab'))
self.assertTrue(commands.__contains__('view_course_assignments'))
self.assertTrue(commands.__contains__('view_ta_assignments'))
self.assertTrue(commands.__contains__('edit_contact_info'))
self.assertTrue(commands.__contains__('read_contact_info'))
self.assertTrue(commands.__contains__('help'))
def test_login_administrator(self):
self.ui.current_user = Account()
username = '******'
expected_output = 'login successful...'
actual_output = self.ui.login(username, 'password')
self.assertEqual(expected_output, actual_output)
self.assertEqual(self.ui.get_current_user(), self.tst_administrator)
commands = self.ui.command_list
expected_num_commands = 10
self.assertEqual(expected_num_commands, len(commands))
self.assertTrue(commands.__contains__('logout'))
self.assertTrue(commands.__contains__('create_account'))
self.assertTrue(commands.__contains__('delete_account'))
self.assertTrue(commands.__contains__('edit_account'))
self.assertTrue(commands.__contains__('create_account'))
self.assertTrue(commands.__contains__('view_course_assignments'))
self.assertTrue(commands.__contains__('view_ta_assignments'))
self.assertTrue(commands.__contains__('edit_contact_info'))
self.assertTrue(commands.__contains__('read_contact_info'))
self.assertTrue(commands.__contains__('help'))
def test_login_instructor(self):
self.ui.current_user = Account()
username = '******'
expected_output = 'login successful...'
actual_output = self.ui.login(username, 'password')
self.assertEqual(expected_output, actual_output)
self.assertEqual(self.ui.get_current_user(), self.tst_instructor)
commands = self.ui.command_list
expected_num_commands = 7
self.assertEqual(expected_num_commands, len(commands))
self.assertTrue(commands.__contains__('logout'))
self.assertTrue(commands.__contains__('assign_ta_to_lab'))
self.assertTrue(commands.__contains__('view_course_assignments'))
self.assertTrue(commands.__contains__('view_ta_assignments'))
self.assertTrue(commands.__contains__('edit_contact_info'))
self.assertTrue(commands.__contains__('read_contact_info'))
self.assertTrue(commands.__contains__('help'))
def test_login_ta(self):
self.ui.current_user = Account()
username = '******'
expected_output = 'login successful...'
actual_output = self.ui.login(username, 'password')
self.assertEqual(expected_output, actual_output)
self.assertEqual(self.ui.get_current_user(), self.tst_ta)
commands = self.ui.command_list
expected_num_commands = 5
self.assertEqual(expected_num_commands, len(commands))
self.assertTrue(commands.__contains__('logout'))
self.assertTrue(commands.__contains__('view_ta_assignments'))
self.assertTrue(commands.__contains__('edit_contact_info'))
self.assertTrue(commands.__contains__('read_contact_info'))
self.assertTrue(commands.__contains__('help'))
def test_logout(self):
self.ui.login('usrSupervisor', 'password')
expected_output = 'logout successful...'
actual_output = self.ui.logout()
self.assertEqual(expected_output, actual_output)
self.assertIsNone(self.ui.get_current_user().id)
commands = self.ui.command_list
expected_num_commands = 2
self.assertEqual(expected_num_commands, len(commands))
self.assertTrue(commands.__contains__('login'))
self.assertTrue(commands.__contains__('help'))
def test_create_account_as_supervisor(self):
self.ui.login('usrSupervisor', 'password')
username = '******'
password = '******'
role = 'Supervisor'
expected_output = 'Successfully created account'
actual_output = self.ui.create_account(username, password, role)
self.assertEqual(expected_output, actual_output)
created_account = self.ui.get_account(username)
self.assertIsNotNone(created_account.id)
self.assertEqual(created_account.user, username)
self.assertEqual(created_account.password, password)
self.assertEqual(created_account.role, role)
def test_create_account_as_administrator(self):
self.ui.login('usrAdministrator', 'password')
username = '******'
password = '******'
role = 'TA'
expected_output = 'Successfully created account'
actual_output = self.ui.create_account(username, password, role)
self.assertEqual(expected_output, actual_output)
created_account = self.ui.get_account(username)
self.assertIsNotNone(created_account.id)
self.assertEqual(created_account.user, username)
self.assertEqual(created_account.password, password)
self.assertEqual(created_account.role, role)
def test_create_supervisor_account_as_administrator(self):
self.ui.login('usrAdministrator', 'password')
username = '******'
password = '******'
role = 'Supervisor'
expected_output = 'Failed to create account. Insufficient permissions'
actual_output = self.ui.create_account(username, password, role)
self.assertEqual(expected_output, actual_output)
created_account = self.ui.get_account(username)
self.assertIsNone(created_account.id)
def test_create_account_as_instructor(self):
self.ui.login('usrInstructor', 'password')
username = '******'
password = '******'
role = 'TA'
expected_output = 'Failed to create account. Insufficient permissions'
actual_output = self.ui.create_account(username, password, role)
self.assertEqual(expected_output, actual_output)
created_account = self.ui.get_account(username)
self.assertIsNone(created_account.id)
def test_create_account_as_ta(self):
self.ui.login('usrTA', 'password')
username = '******'
password = '******'
role = 'TA'
initial_count = Account.objects.count()
expected_output = 'Failed to create account. Insufficient permissions'
actual_output = self.ui.create_account(username, password, role)
final_count = Account.objects.count()
created_account = self.ui.get_account(username)
self.assertEqual(expected_output, actual_output)
self.assertEqual(initial_count, final_count)
self.assertIsNone(created_account.id)
def test_create_account_existing_user(self):
self.ui.login('usrSupervisor', 'password')
username = '******'
password = '******'
role = 'TA'
expected_output = 'Failed to create account. User already exists'
initial_count = Account.objects.count()
actual_output = self.ui.create_account(username, password, role)
final_count = Account.objects.count()
self.assertEqual(expected_output, actual_output)
self.assertEqual(initial_count, final_count)
def test_delete_account_as_supervisor(self):
self.ui.login('usrSupervisor', 'password')
self.ui.create_account('tstDeleteAcc', 'password', 'TA')
expected_output = 'Successfully deleted account'
initial_count = Account.objects.count()
expected_count = initial_count - 1
actual_output = self.ui.delete_account('tstDeleteAcc')
final_count = Account.objects.count()
self.assertEqual(expected_output, actual_output)
self.assertEqual(expected_count, final_count)
def test_delete_account_as_administrator(self):
self.ui.login('usrAdministrator', 'password')
self.ui.create_account('tstDeleteAcc', 'password', 'TA')
initial_count = Account.objects.count()
expected_count = initial_count - 1
expected_output = 'Successfully deleted account'
actual_output = self.ui.delete_account('tstDeleteAcc')
final_count = Account.objects.count()
self.assertEqual(expected_output, actual_output)
self.assertEqual(expected_count, final_count)
def test_delete_account_not_exist(self):
self.ui.login('usrSupervisor', 'password')
expected_output = 'Failed to delete account. User not found'
initial_count = Account.objects.count()
actual_output = self.ui.delete_account('notExist')
final_count = Account.objects.count()
self.assertEqual(expected_output, actual_output)
self.assertEqual(initial_count, final_count)
def test_delete_supervisor_as_administrator(self):
self.ui.login('usrAdministrator', 'password')
expected_output = 'Failed to delete account. Insufficient permissions'
initial_count = Account.objects.count()
actual_output = self.ui.delete_account('usrSupervisor')
final_count = Account.objects.count()
self.assertEqual(expected_output, actual_output)
self.assertEqual(initial_count, final_count)
def test_delete_account_as_Instructor(self):
self.ui.login('usrInstructor', 'password')
expected_output = 'Failed to delete account. Insufficient permissions'
initial_count = Account.objects.count()
actual_output = self.ui.delete_account('usrTA')
final_count = Account.objects.count()
self.assertEqual(expected_output, actual_output)
self.assertEqual(initial_count, final_count)
def test_delete_account_as_TA(self):
self.ui.login('usrTA', 'password')
expected_output = 'Failed to delete account. Insufficient permissions'
initial_count = Account.objects.count()
actual_output = self.ui.delete_account('usrTA')
final_count = Account.objects.count()
self.assertEqual(expected_output, actual_output)
self.assertEqual(initial_count, final_count)
def test_delete_account_assigned_to_course(self):
self.ui.login('usrSupervisor', 'password')
self.tst_course.instructor = self.tst_instructor
self.tst_course.save()
self.assertEqual(self.tst_course.instructor, self.tst_instructor)
num_courses_initial = Course.objects.count()
num_accounts_initial = Account.objects.count()
expected_output = 'Failed to delete account. User is assigned to a course'
actual_output = self.ui.delete_account(self.tst_instructor.user)
self.assertEqual(self.tst_course.instructor, self.tst_instructor)
num_courses_final = Course.objects.count()
num_accounts_final = Account.objects.count()
self.assertEqual(expected_output, actual_output)
self.assertEqual(num_accounts_initial, num_accounts_final)
self.assertEqual(num_courses_initial, num_courses_final)
class TestCommandsAssignTaToLab(TestCase):
def setUp(self):
self.Course1 = Course.objects.create(name="CS-337",
section="001",
days_of_week="M/W",
start_time="11:00",
end_time="11:50")
self.Course1.save()
self.Course2 = Course.objects.create(name="CS-361",
section="003",
days_of_week="T/R",
start_time="14:00",
end_time="14:50")
self.Course2.save()
self.Lab1 = Lab.objects.create(course=self.Course1,
section="002",
days_of_week="T",
start_time="14:00",
end_time="15:50")
self.Lab1.save()
self.Lab2 = Lab.objects.create(course=self.Course1,
section="003",
days_of_week="F",
start_time="12:00",
end_time="13:50")
self.Lab2.save()
self.Account1 = Account.objects.create(user="******",
password="******",
role="Supervisor")
self.Account1.save()
self.Account2 = Account.objects.create(user="******",
password="******",
role="TA")
self.Account2.save()
self.Account3 = Account.objects.create(user="******",
password="******",
role="TA")
self.Account3.save()
self.Course1.tas.add(self.Account3)
self.Course1.save()
self.co = Commands()
self.co.current_user = self.Account1
# test roles other than supervisor or Instructor can not assign tas to courses
def test_CommandsAssignTaToLab1(self):
self.co.current_user = self.Account3
response = self.co.assign_ta_to_lab('Joe', 'CS-337', "002")
self.assertEqual("You do not have permissions to assign TAs to labs",
response)
# test assigning a TA to lab without proper arguments
def test_CommandsAssignTaToLab2(self):
response = self.co.assign_ta_to_lab()
self.assertEqual(
"Please input valid arguments for all fields to assign a TA to a lab section",
response)
# test assigning a user to a lab that's not in the data base
def test_CommandsAssignTaToLab3(self):
response = self.co.assign_ta_to_lab('Gus', '337', '003')
self.assertEqual("This user is not present in the data base", response)
# test assigning an TA to a lab of a course not in the data base
def test_CommandsAssignTaToLab4(self):
response = self.co.assign_ta_to_lab('Joe', 'CS-999', '001')
self.assertEqual("This course is not present in the data base",
response)
# test assigning a TA to a lab that does not exist for the given course
def test_CommandsAssignTaToLab5(self):
response = self.co.assign_ta_to_lab('Joe', 'CS-337', '999')
self.assertEqual(
"Course CS-337 does not have lab section 999 present in the data base",
response)
# test assigning a TA to a lab section that is not already assigned to its course
def test_CommandsAssignTaToLab6(self):
response = self.co.assign_ta_to_lab('Matt', 'CS-337', '002')
self.assertEqual("This user is not assigned as a TA to this course",
response)
# test assigning TA to lab that conflicts with their schedule
def test_CommandsAssignTaToLab7(self):
self.co.assign_ta_to_course('Joe', 'CS-361')
response = self.co.assign_ta_to_lab('Joe', 'CS-337', '002')
self.assertEqual("This lab conflicts with the TA's current schedule",
response)
# test that TA is assigned to lab with proper conditions
def test_CommandsAssignTaToLab8(self):
response = self.co.assign_ta_to_lab('Joe', 'CS-337', '002')
self.assertEqual("Joe has been assigned as the TA to CS-337 002",
response)
class TestCommandsAssignInstructor(TestCase):
def setUp(self):
self.Course1 = Course.objects.create(name="CS-337",
section="004",
days_of_week="M/W/F",
start_time="11:00",
end_time="11:50")
self.Course1.save()
self.Course2 = Course.objects.create(name="CS-361",
section="003",
days_of_week="M/W",
start_time="11:00",
end_time="13:15")
self.Course2.save()
self.Account1 = Account.objects.create(user="******",
password="******",
role="Supervisor")
self.Account1.save()
self.Account2 = Account.objects.create(user="******",
password="******",
role="Instructor")
self.Account2.save()
self.co = Commands()
self.co.current_user = self.Account1
# test roles other than supervisor can not assign instructors
def test_CommandsAssignInstructor1(self):
self.co.current_user = Account()
response = self.co.assign_instructor('Joe', 'CS-361')
self.assertEqual(
response,
"You do not have permissions to assign instructors to courses")
# test assigning a user not in the data base
def test_CommandsAssignInstructor2(self):
response = self.co.assign_instructor('Gus', 'CS-361')
self.assertEqual(response, "This user is not present in the data base")
# test assigning an instructor to course not in the data base
def test_CommandsAssignInstructor3(self):
response = self.co.assign_instructor('Joe', 'CS-999')
self.assertEqual(response,
"This course is not present in the data base")
# test assigning instructor to course that conflicts with their schedule
def test_CommandsAssignInstructor4(self):
self.co.assign_instructor('Joe', 'CS-337')
response = self.co.assign_instructor('Joe', 'CS-361')
self.assertEqual(
response,
"This course conflicts with the instructor's current schedule")
# test calling method without all valid parameters
def test_CommandsAssignInstructor5(self):
response = self.co.assign_instructor('Joe')
self.assertEqual(
response,
"Please input valid arguments for both fields to create assign an instructor to a "
"course")
# test that instructor is added to course wit proper conditions
def test_CommandsAssignInstructor6(self):
response = self.co.assign_instructor('Joe', 'CS-361')
self.assertEqual(response,
'Joe has been added to as CS-361s instructor')
assigned = Course.objects.filter(name='CS-361',
instructor=self.Account2).exists()
self.assertEqual(True, assigned)
def test_CommandsCreateCourse7(self):
co = Commands()
co.current_user = self.Account1
response = co.create_course("CS-520", "004", "M/W/F", "09:00-10:00",
"001/0x2/003")
self.assertEqual(response, "Lab sections must be a three digit number")
def test_CommandsCreateCourse5(self):
co = Commands()
co.current_user = self.Account1
response = co.create_course("CS-520", "004", "M/W/F", "11:00-24:00",
"001/002/003")
self.assertEqual(response, "valid end time is 00:00 to 23:59")
