def test_retriving_courses_ordered_by_title(self):
course1 = Course(title='B A C',
slug='first_course',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
course1.save()
course1.instructors.add(self.user)
course1.students.add(self.user)
course2 = Course(title='A B C',
slug='second_course',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
course2.save()
course2.instructors.add(self.user)
course2.students.add(self.user)
courses = Course.objects.all()
f_course = courses[0]
s_course = courses[1]
self.assertEqual(f_course, course2)
self.assertEqual(s_course, course1)
def test_saving_and_retrieving_courses(self):
course1 = Course(title='First Course',
slug='first_course',
overview='overview',
creator=self.user,
subject=self.subject,
grade=50)
course1.save()
course1.instructors.add(self.user)
course1.students.add(self.user)
self.assertIsNotNone(course1)
f_course = Course.objects.first()
self.assertEqual(f_course, course1)
course2 = Course(title='Second Course',
slug='second_course',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
course2.save()
course2.instructors.add(self.user)
course2.students.add(self.user)
s_course = Course.objects.all()[1]
courses = Course.objects.all()
self.assertEqual(courses.count(), 2)
self.assertEqual(f_course.slug, course1.slug)
self.assertEqual(s_course.title, course2.title)
def get_courses():
org = Org.objects.create(
name="Peiking University",
located=Location.objects.create(name="Beijing"),
)
python_intro = Course(
name="Introduction to Python",
desc="A introduction and tutorial to Python language.",
detail="A brief introduction didn't dive into the language details.",
degree="junior",
duration_mins=100,
enrolled_nums=1200,
favorite_nums=8000,
image="media/courses/2018/04",
hits=35889,
org=org,
add_time=timezone.now(),
)
algorithms = Course(
name="Algorithms",
desc="The fundamental of computer science",
detail="Step by step, taught yourself the essential of the algorithms.",
degree="senior",
duration_mins=300,
enrolled_nums=800,
favorite_nums=9000,
image="media/courses/2018/04",
hits=22000,
org=org,
add_time=timezone.now(),
)
python_intro.save()
algorithms.save()
return python_intro, algorithms
def setUp(self):
self.user1 = User.objects.create_user('bertie', '*****@*****.**', 'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('Van Gogh', '*****@*****.**', 'vancode')
self.user2.is_active = True
self.user2.save()
self.user3 = User.objects.create_user('Chuck Norris', '*****@*****.**', 'dontask')
self.user3.is_active = True
self.user3.save()
self.user4 = User.objects.create_user('James Maxwell', 'em@c', 'pdq')
self.user4.is_active = True
self.user4.save()
self.course1 = Course(**course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.course2 = Course(**course2_data)
self.course2.organiser = self.user2
self.course2.instructor = self.user2
self.course2.save()
self.uc = UserCourse(course=self.course1, user=self.user2)
self.uc.save()
self.lesson1 = Lesson(name="Test Lesson 1", course = self.course1)
self.lesson1.save()
self.ul = UserLesson(user=self.user2, lesson=self.lesson1)
self.ul.save()
def test_listing(self):
semester = Semester(name='Spring',
year='2012',
start=datetime.date(2012, 1, 1),
end=datetime.date(2012, 5, 15))
semester.save()
course = Course(title='Test Course',
number='101',
section='001',
description='Test description of a course',
semester=semester)
course.save()
course = Course(title='Test Course2',
number='101',
section='002',
description='Test description of a course',
semester=semester)
course.save()
course = Course(title='Test Course3',
number='102',
section='001',
description='Test description of a course',
semester=semester)
course.save()
response = self.c.get(
reverse('courses:by_semester', args=[semester.id]))
courses = Course.objects.filter(semester=semester)
self.assertEquals(
[course.id for course in response.context['courses']],
[course.id for course in courses])
def test_number_of_sql_queries_all_courses(client, django_assert_num_queries):
fake = Faker()
author_name = fake.name()
author = Author(name=author_name)
author.save()
course_title = fake.sentence(nb_words=4)
course = Course(title=course_title, author=author)
course.save()
with django_assert_num_queries(1):
res = client.get("/courses/")
data = json.loads(res.content)
assert res.status_code == 200
assert len(data) == 1
author_name = fake.name()
author = Author(name=author_name)
author.save()
course_title = fake.sentence(nb_words=4)
course = Course(title=course_title, author=author)
course.save()
res = client.get("/courses/")
data = json.loads(res.content)
assert res.status_code == 200
assert len(data) == 2
def import_data():
"""使用Django ORM导入数据"""
# 讲师数据 create()
Teacher.objects.create(nickname="Jack", introduction="Python工程师", fans=666)
Teacher.objects.create(nickname="Allen", introduction="Java工程师", fans=123)
Teacher.objects.create(nickname="Henry", introduction="Golang工程师", fans=818)
# 课程数据 bulk_create()
Course.objects.bulk_create([Course(title=f"Python系列教程{i}", teacher=Teacher.objects.get(nickname="Jack"),
type=random.choice((0, 1, 2)),
price=random.randint(200, 300), volume=random.randint(100, 10000),
online=date(2018, 10, 1))
for i in range(1, 5)])
Course.objects.bulk_create([Course(title=f"Java系列教程{i}", teacher=Teacher.objects.get(nickname="Allen"),
type=random.choice((0, 1, 2)),
price=random.randint(200, 300), volume=random.randint(100, 10000),
online=date(2018, 6, 4))
for i in range(1, 4)])
Course.objects.bulk_create([Course(title=f"Golang系列教程{i}", teacher=Teacher.objects.get(nickname="Henry"),
type=random.choice((0, 1, 2)),
price=random.randint(200, 300), volume=random.randint(100, 10000),
online=date(2018, 1, 1))
for i in range(1, 3)])
# 学生数据 update_or_create()
Student.objects.update_or_create(nickname="A同学", defaults={"age": random.randint(18, 58),
"gender": random.choice((0, 1, 2)),
"study_time": random.randint(9, 999)})
Student.objects.update_or_create(nickname="B同学", defaults={"age": random.randint(18, 58),
"gender": random.choice((0, 1, 2)),
"study_time": random.randint(9, 999)})
Student.objects.update_or_create(nickname="C同学", defaults={"age": random.randint(18, 58),
"gender": random.choice((0, 1, 2)),
"study_time": random.randint(9, 999)})
Student.objects.update_or_create(nickname="D同学", defaults={"age": random.randint(18, 58),
"gender": random.choice((0, 1, 2)),
"study_time": random.randint(9, 999)})
# 正向添加
# 销量大于等于1000的课程
Student.objects.get(nickname="A同学").course.add(*Course.objects.filter(volume__gte=1000))
# 销量大于5000的课程
Student.objects.get(nickname="B同学").course.add(*Course.objects.filter(volume__gt=5000))
# 反向添加
# 学习时间大于等于500小时的同学
Course.objects.get(title="Python系列教程1").student_set.add(*Student.objects.filter(study_time__gte=500))
# 学习时间小于等于500小时的同学
Course.objects.get(title="Python系列教程2").student_set.add(*Student.objects.filter(study_time__lte=500))
# 助教数据 get_or_create()
TeacherAssistant.objects.get_or_create(nickname="助教1", defaults={"hobby": "慕课网学习", "teacher":
Teacher.objects.get(nickname="Jack")})
TeacherAssistant.objects.get_or_create(nickname="助教2", defaults={"hobby": "追慕女神", "teacher":
Teacher.objects.get(nickname="Allen")})
TeacherAssistant.objects.get_or_create(nickname="助教3", defaults={"hobby": "减肥减肥", "teacher":
Teacher.objects.get(nickname="Henry")})
return True
def create_dont_save(course_code, semester, iter_num):
dept_code = course_code.split("-")[0]
if iter_num == 0:
if dept_code not in department_obs:
dept = Department(code=dept_code, name=dept_code)
department_obs[dept_code] = dept
departments_to_save.append(dept)
elif iter_num == 1:
dept_id = department_obs[dept_code]
course = Course(
code=course_code.split("-")[1],
semester=semester,
full_code=course_code,
description=test_descriptions[course_code],
)
course.department_id = dept_id
courses_to_save.append(course)
elif iter_num == 2:
course_id = course_obs[course_code, semester]
section = Section(
code="001",
full_code=course_code + "-001",
credits=1,
status="O",
activity="LEC",
)
section.course_id = course_id
sections_to_save.append(section)
def setUp(self):
self.user1 = User.objects.create_user(
'bertie', '*****@*****.**', 'bertword')
self.user1.is_active = True
self.user1.save()
self.user2 = User.objects.create_user('dave', '*****@*****.**', 'dave')
self.user2.is_active = True
self.user2.save()
self.user3 = User.objects.create_user(
'Chuck Norris', '*****@*****.**', 'dontask')
self.user3.is_active = True
self.user3.save()
self.course1 = Course(**course1_data)
self.course1.organiser = self.user1
self.course1.instructor = self.user1
self.course1.save()
self.uc = UserCourse(course=self.course1, user=self.user2)
self.uc.save()
self.lesson1 = Lesson(name="Test Lesson 1", course = self.course1)
self.lesson1.save()
#att1 attached to course
self.att1 = Attachment(course=self.course1, **self.att1_data)
self.att1.save()
#att2 attached to lesson
self.att2 = Attachment(lesson=self.lesson1, **self.att1_data)
self.att2.save()
with open('media/attachments/empty_attachment_test.txt', 'w') as f:
f.write('test')
def new_course(request):
if request.method == 'POST':
params = request.POST
course_code = params.get('course_code', '')
name = params.get('name', '')
unit = params.get('unit', '')
dept_id = params.get('department', '')
semester = params.get('semester', '')
level = params.get('level', '')
lecturers = params.getlist('lecturer', '')
department = Department.objects.get(pk=dept_id)
try:
pay_load = {
'course_code': course_code,
'name': name,
'unit': unit,
'department': department,
'level': level,
'semester': semester,
}
course = Course(**pay_load)
course.added_by = request.user
course.save()
for i in lecturers:
lecturer = Lecturer.objects.get(pk=int(i))
course.lecturers.add(lecturer)
course.save()
import pdb
pdb.set_trace()
messages.success(request, "The course: '%s: %s', has been successfully created" %(course.course_code, course.name))
except Exception as e:
messages.error(request, e)
return HttpResponseRedirect(reverse('courses:course-list'))
def create_course(self):
course = Course()
course.title= "just_created"
course.description = "course_desc"
course.instructor_id = 1
course.save()
return course
def test_lecture_cant_have_not_youtube_url(self):
course = Course()
course.title = "Yet another title"
course.save()
week = Week()
week.number = 1
week.course = course
week.save()
data = {"title": "My lecture", "week": week, "order_id": 1,
"embed_video_url": "https://www.youtube.com/embed/lXn7XKLA6Vg", }
# For easy use
_assert_true = self.assertTrue
_assert_false = self.assertFalse
urls = (
("http://habrahabr.ru", _assert_false), ("https://www.google.com.ua/", _assert_false),
("https://www.youtube.com/watch?v=lXn7XKLA6Vg", _assert_true)
)
for url, suggested_func in urls:
data["video_url"] = url
lecture = NewLectureForm(data=data)
suggested_func(lecture.is_valid())
def test_get_quiz_feedback_with_only_subjects_and_linked_resource(self):
# fill database
course = Course(pk=159,
name="Test_course1",
courseId=1,
version_time=datetime.datetime(2020, 1, 28))
course.save()
quiz = Quiz.objects.create(course_id=159,
name="Test_quiz1",
external_id=18,
subjects_id=1,
version_time=datetime.datetime(2020, 1, 28))
quiz.save()
resource = Resource(
course_id=159,
name="Book 1",
target="http://localhost:4000/mod/book/view.php?id=12",
type="book",
external=False,
external_id=12,
version_time=datetime.datetime(2020, 1, 28))
resource.save()
subject = Subject(course=course, name="Test_subject1")
subject.save()
# add the link between subjects and resources
subject.resources.add(resource)
message = '\r\n- <a href="http://localhost:4000/mod/book/view.php?id=12">Book 1</a>'
self.assertEqual(feedback_manager.get_quiz_feedback_link(18), message)
def handle(self, *args, **options):
lec = db_to_list(2)
stud = db_to_list(3)
for i in COURSE_NUM:
# random names:
# c.name = rand_word(12)
# some real course names
# c.name = random.sample(course_names, 1)[0]
# c.save()
c = Course(name=rand_word(11),
start_date=calc_start_date(),
end_date=calc_end_date())
try:
c.lecturer = Lecturer.objects.get(id=random.sample(lec, 1)[0])
c.save()
list_student_ids = rand_num_students(stud)
for j in range(0, len(list_student_ids)):
c.student.add(Student.objects.get(id=list_student_ids[j]))
c.save()
except BaseException:
raise CommandError('Could not create course')
self.stdout.write(
self.style.SUCCESS(
'Successfully created testcourse with name {}'.format(
c.name)))
def course_page(request):
if request.method == 'POST':
urlstring = request.build_absolute_uri()
# I'm not positive how to do a correct ternary statement here in python so I'm taking the long route
course_id_test = 0
if request.POST['course_id']:
course_id_test = request.POST['course_id']
print(course_id_test)
if Course.objects.filter(course_id=course_id_test).exists():
Course.objects.filter(course_id=course_id_test).update(
course_number=request.POST['course_number'],
course_name=request.POST['course_name'],
semester=request.POST['semester'],
instructor=request.POST['instructor'])
else:
Course.objects.create(
course_id = random.randint(10000,99999),
course_number=request.POST['course_number'],
course_name=request.POST['course_name'],
semester=request.POST['semester'],
instructor=request.POST['instructor'])
return redirect('/')
course = Course()
courses = Course.objects.all()
course_id_edit = 0
if request.method == 'GET':
if request.GET.get('id') is not None:
course_id_edit = request.GET.get('id')
course = Course.objects.filter(course_id=course_id_edit).first()
return render(request, 'course.html', {'courses': courses, 'course': course})
def course_add(request):
if request.method != 'POST':
return JsonResponse({'status': 402, 'msg': 'Wrong method'})
title = request.POST.get('title')
date_of_start = request.POST.get('date_of_start')
date_of_finish = request.POST.get('date_of_finish')
number_of_lectures = request.POST.get('number_of_lectures')
if date_of_finish < date_of_start:
return JsonResponse({'Warning': 'Finish must be later than Start!'})
try:
number_of_lectures = int(number_of_lectures)
except ValueError:
return JsonResponse({'status': 403, 'msg': 'Number must be a digit'})
if number_of_lectures <= 0:
return JsonResponse({
'status': 403,
'msg': 'Number must be a positive'
})
if not title or not date_of_start or not date_of_finish or not number_of_lectures:
return JsonResponse({'status': 403, 'msg': 'Wrong data'})
course = Course(title=title,
date_of_start=date_of_start,
date_of_finish=date_of_finish,
number_of_lectures=number_of_lectures)
try:
course.save()
except ValidationError:
return JsonResponse({'status': 403, 'msg': 'Wrong data'})
return JsonResponse({'status': 200, 'msg': 'OK'})
def post(cls, request):
course_form = CreateCourseForm(request.POST, request.FILES)
if course_form.is_valid():
name = course_form.cleaned_data['name']
image = course_form.cleaned_data['image']
teacher = Teacher.objects.get(userprofile=request.user)
course = Course()
course.name = name
course.image = image
course.college_org = teacher.college_org
course.teacher = teacher
course.save()
courses = Course.objects.filter(teacher=teacher)
lessons = []
for course in courses:
lessons.extend(Lesson.objects.filter(course=course))
return render(request, 'user_lecturer_course.html', {
'courses': courses,
'lessons': lessons,
})
else:
return HttpResponse('{"status":"fail"}',
content_type='application/json')
def test_get_quiz_feedback_with_only_subjects_and_no_linked_resource(self):
# fill database
course = Course(pk=159,
name="Test_course1",
courseId=1,
version_time=datetime.datetime(2020, 1, 28))
course.save()
Quiz.objects.create(course_id=159,
name="Test_quiz1",
external_id=18,
subjects_id=1,
version_time=datetime.datetime(2020, 1, 28))
resource = Resource(
course_id=159,
name="Book 1",
target="http://localhost:4000/mod/book/view.php?id=12",
type="book",
external=False,
external_id=12,
version_time=datetime.datetime(2020, 1, 28))
resource.save()
subject = Subject(course=course, name="Test_subject1")
subject.save()
self.assertEqual(feedback_manager.get_quiz_feedback_link(18),
"the course resource")
def setUp(self):
call_command('migrate')
call_command('loadperms', 'groups.yml')
self.my_admin = User.objects.create_superuser('admin',
'*****@*****.**',
'admin123')
self.client.force_login(self.my_admin)
# create users to do stuff with in the tests
lecturer_form = {
'username': '******',
'first_name': 'Test_fe_lecturer',
'last_name': 'Test_fe_lecturer',
'email': '*****@*****.**',
'password': '******',
}
response = self.client.post(reverse('createlecturer_admin_iframe'),
lecturer_form)
self.assertTrue(response.status_code, HTTPStatus.OK)
self.assertTrue(
Lecturer.objects.filter(username='******').exists())
student_form = {
'username': '******',
'first_name': 'Test_fe_student',
'last_name': 'Test_fe_student',
'email': '*****@*****.**',
'matr_nr': '42069',
'password': '******'
}
response = self.client.post(reverse('createstudent_admin_iframe'),
student_form)
self.assertTrue(response.status_code, HTTPStatus.OK)
self.assertTrue(
Student.objects.filter(username='******').exists())
# create a course to do stuff with in the test
c = Course(name='test_course_fe',
start_date='2021-08-08',
end_date='2021-10-10')
c.lecturer = Lecturer.objects.get(username='******')
c.save()
c.student.add(Student.objects.get(username='******'))
c.save()
self.assertTrue(Course.objects.filter(name='test_course_fe').exists())
# create an exercise to do stuff with in the tests
e = Exercise(
description='420 lodern Sie es!',
start_time='2021-08-08 14:00:00',
work_time_duration=parse_duration('0 days 00:10:00'),
submission_deadline='2021-08-08 15:15:00',
)
e.course = Course.objects.get(name='test_course_fe')
e.save()
self.assertTrue(
Exercise.objects.filter(description='420 lodern Sie es!').exists())
class TestCourse(unittest.TestCase):
course = Course()
def test_add(self):
course = Course()
actual_result = course.add(5, 7)
expected_result = 12
self.assertEqual(actual_result, expected_result)
def test_auto_save_for_course_slug(self):
course = Course(title='B A C',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
course.save()
self.assertEqual(course.slug, 'b-a-c')
def test_fill_database(self):
Course.objects.bulk_create([
Course(pk=159,
name="Testing course",
courseId=1,
version_time=datetime.datetime(2020, 1, 28)),
Course(pk=161,
name="Testing course",
courseId=2,
version_time=datetime.datetime(2020, 1, 28))
])
fill_database(test_data.test_grouped_dict,
test_parse_quiz_question_data)
self.assertEqual(Assignment.objects.count(), 3)
self.assertEqual(Quiz.objects.count(), 1)
self.assertEqual(Choice.objects.count(), 3)
self.assertEqual(Resource.objects.count(), 13)
self.assertEqual(Question.objects.count(), 2)
def setUp(self):
self.c = Course(
department=Department.objects.get_or_create(code="PSCI")[0],
code="131",
semester=TEST_SEMESTER,
title="American Foreign Policy",
)
self.c.save()
self.s = Section(code="001", course=self.c)
self.s.save()
def __init__(self, number=1):
Course.objects.bulk_create([
Course(name=f'My avesome course #{_}',
description='no description',
start_date=timezone.now() - datetime.timedelta(days=2),
end_date=timezone.now() + datetime.timedelta(days=2))
for _ in range(number)
])
self.courses = Course.objects.all()
def testFetch(self):
"""
Test fetching of correct values from the course entry
"""
course = Course(name="TestCourse", courseId=2, inactivity=False, deadline=True, hours_before=10, inactivity_time=20, version_time=datetime.datetime(2020, 1, 28))
course.save()
validationTuple = (False, 20)
returnTuple = fetchInactivityParams(2)
self.assertEqual(returnTuple, validationTuple)
def setUp(self):
self.user = User.objects.create_user(username='******',
password='******')
self.subject = Subject.objects.create(title='first subject')
self.course = Course(title='B A C',
overview='overview',
creator=self.user,
subject=self.subject,
grade=200)
self.course.save()
def post(self, request):
ID = request.POST.get("id", "")
type = request.POST.get("type", "")
if int(type) > 0:
#添加课程
#此处类似于 读者－写者 模型
#添加行级锁，防止改动课程时用户进入读取错误信息
with transaction.atomic():
if ID:
lesson = Lesson.objects.select_for_update().get(id=ID)
else:
lesson = Lesson()
lesson.course_id = request.POST.get("cId", "")
lesson.name = request.POST.get("name", "")
lesson.save()
video = Video()
video.lesson_id = lesson.id
video.name = lesson.name
video.url = request.POST.get("url", "")
video.save()
else:
#进行事务处理,保证课程发布可以通知到每个关注者
with transaction.atomic():
if ID:
course = Course.objects.select_for_update().get(id=ID)
else:
course = Course()
teacher = Teacher.objects.get(id=request.user.teacher_id)
course.name = request.POST.get("name", "")
course.tag = request.POST.get("tag", "")
course.desc = request.POST.get("desc", "")
course.detail = request.POST.get("detail", "")
course.degree = request.POST.get("degree", "")
course.learn_times = request.POST.get("learn_times", "")
course.teacher = teacher
course.save()
teacher_id = teacher.id
users = UserFavorite.objects.filter(fav_id=teacher_id, fav_type=1)
if ID:
for user in users:
sendMsg(user.user_id,
teacher.name + "修改了课程:" + course.name, teacher.id)
else:
for user in users:
sendMsg(user.user_id,
teacher.name + "发布了新课程:" + course.name, teacher.id)
return render(request, 'usercenter-publish-course.html', {})
def api_create_course_view(request):
account = request.user
course = Course(author=account)
if request.method == "POST":
serializer = CourseSerializer(course, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def testUpdate(self):
"""
Test updating deadline settings
"""
course = Course(name="TestCourse", courseId=2, inactivity=False, deadline=True, hours_before=10, inactivity_time=20, version_time=datetime.datetime(2020, 1, 28))
course.save()
updateDeadlineParams(2, False, 30)
course = Course.objects.get(courseId=2)
self.assertEqual(course.deadline, False)
self.assertEqual(course.hours_before, 30)
def handle(self, *args, **kwargs):
file_name = kwargs['file_name']
with open(f'{file_name}.txt') as file:
for row in file:
title = row
gen_short_content = generate_short_content()
gen_category_name = generate_category_name()
gen_course_date = generate_course_date()
gen_duration = generate_duration()
gen_price = generate_price()
gen_title = generate_about()
gen_content = generate_about()
gen_requirements = generate_requirements()
gen_apply = generate_apply()
gen_fees_and_funding = generate_fees_and_funding()
gen_teacher = generate_teacher_name()
gen_discount_price = generate_discount_price()
category = Category.objects.get_or_create(
category_name=gen_category_name)
course = Course(title=title,
short_content=gen_short_content,
category=Category.objects.get(
category_name=gen_category_name),
course_date=gen_course_date,
duration=gen_duration,
price=gen_price,
about_title=gen_title,
content=gen_content,
discount_price=gen_discount_price)
course.save()
requirements = Requirements.objects.get_or_create(
requirement=gen_requirements)
course.requirements.add(
Requirements.objects.get(requirement=gen_requirements))
apply = Apply.objects.get_or_create(apply=gen_apply)
course.apply.add(Apply.objects.get(apply=gen_apply))
fees_and_funding = FeesAndFunding.objects.get_or_create(
fees_and_funding=gen_fees_and_funding)
course.fees_and_funding.add(
FeesAndFunding.objects.get(
fees_and_funding=gen_fees_and_funding))
course.teacher.add(UserProfile.objects.get(name=gen_teacher))
self.stdout.write(
self.style.SUCCESS('Courses Data imported successfully'))
