def test_get_format(self):
"""Test get format."""
course1 = factory.make_course('Portfolio2016', 'PAV', author=self.rein)
course2 = factory.make_course('Portfolio2017', 'PAV', author=self.rein)
course3 = factory.make_course('Portfolio2018', 'PAV')
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment(
'Colloq',
'description1',
format=format,
courses=[course1, course2, course3])
login = test.logging_in(self, self.rein_user, self.rein_pass)
response = test.api_get_call(self,
'/formats/' + str(assignment.pk) + '/',
login)
self.assertEquals(response.json()['format']['templates'][0]['name'],
'template')
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self,
'/formats/' + str(assignment.pk) + '/',
login,
status=403)
test.api_get_call(self,
'/formats/' + str(self.not_found_pk) + '/',
login,
status=404)
test.test_unauthorized_api_get_call(
self, '/formats/' + str(assignment.pk) + '/')
def set_up_courses(name, n, author=None, lti_id=False):
"""Set up some courses.
Arguments:
name -- the base for the incremental names for the courses
n -- number of courses to be made
author -- the user who made the course and it automatically will be teacher
lti_id -- a boolean to determine if to give lti ids
Returns a list of courses.
"""
courses = []
if lti_id:
for i in range(n):
courses.append(
factory.make_course(name + str(i),
name[0] + str(i),
author=author,
lti_id=str(i)))
else:
for i in range(n):
courses.append(
factory.make_course(name + str(i),
name[0] + str(i),
author=author))
return courses
def setUp(self):
self.user = factory.make_user('Username', DEFAULT_PASSWORD, email='*****@*****.**', full_name='Test User')
self.course1 = factory.make_course('Course', 'crs', startdate=datetime.date.today())
self.course2 = factory.make_course('Course2', 'crs2', startdate=datetime.date.today())
self.course_independent = factory.make_course('Independent Course', 'crs3', startdate=datetime.date.today())
self.assignment = factory.make_assignment('Assignment', 'Assignment linked to multiple courses.',
courses=[self.course1, self.course2])
self.assignment_independent = factory.make_assignment('Assignment2', 'Assignment linked to separate course.',
courses=[self.course_independent])
def test_get_lti_params_from_jwt_assignment_student(self):
"""Hopefully returns the lti assignment data."""
factory.make_course('TestCourse', 'aaaa', lti_id='asdf')
login = test.logging_in(self, self.username, self.password)
self.request["user_id"] = "awefd"
self.request["roles"] = settings.ROLES["Student"]
jwt_params = jwt.encode(self.request,
settings.SECRET_KEY,
algorithm='HS256').decode('utf-8')
response = test.api_get_call(
self,
'/get_lti_params_from_jwt/{0}/'.format(jwt_params),
login=login,
status=404)
self.assertIn('assignment', response.content.decode('utf-8'))
def test_get_names(self):
"""Test get names function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course],
is_published=True)
student_user, student_pass, student = test.set_up_user_and_auth(
'student', 'pass', '*****@*****.**', 'first', 'last')
test.set_up_participation(student, course, 'Student')
journal = test.set_up_journal(assignment, template, student, 4)
login = test.logging_in(self, student_user, student_pass)
url = '/names/{}/{}/{}/'.format(course.pk, assignment.pk, journal.pk)
result = test.api_get_call(self, url, login).json()
self.assertEquals(result['names']['course'], 'Portfolio')
self.assertEquals(result['names']['journal'], 'first last')
self.assertEquals(result['names']['assignment'], 'Colloq')
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self, url, login, status=403)
def test_get_comments(self):
"""Test update comment function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
student_user, student_pass, student = test.set_up_user_and_auth(
'student', 'pass', '*****@*****.**')
test.set_up_participation(student, course, 'Student')
journal = factory.make_journal(assignment, student)
entry = factory.make_entry(template)
factory.make_node(journal, entry)
comment = factory.make_comment(entry, self.rein, 'Excellent!', True)
login = test.logging_in(self, self.rein_user, self.rein_pass)
update_dict = {'text': 'Bad!'}
test.api_patch_call(self, '/comments/' + str(comment.pk) + '/',
update_dict, login)
q_comment = Comment.objects.get(pk=comment.pk)
self.assertEquals(q_comment.text, 'Bad!')
def test_update_user_role_course(self):
"""Test user role update in a course."""
login = test.logging_in(self, self.rein_user, self.rein_pass)
course = factory.make_course("Portfolio Academische Vaardigheden",
"PAV",
author=self.rein)
ta_role = Role.objects.get(name='TA', course=course)
student_role = factory.make_role_student(name='SD', course=course)
self.user_role = factory.make_user("test123", "test", "*****@*****.**")
factory.make_participation(self.user_role, course, ta_role)
factory.make_participation(self.user, course, student_role)
user_role = Participation.objects.get(user=self.user_role,
course=course).role.name
self.assertEquals(user_role, 'TA')
test.api_patch_call(self, '/participations/' + str(course.pk) + '/', {
'user_id': self.user_role.pk,
'role': 'SD'
}, login)
user_role = Participation.objects.get(user=self.user_role,
course=course.pk).role.name
self.assertEquals(user_role, 'SD')
def test_update_format(self):
"""Test update format function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
login = test.logging_in(self, self.rein_user, self.rein_pass)
update_dict = {
'assignment_details': {
'name': 'Colloq',
'description': 'description1',
'is_published': True
},
'templates': [
serialize.TemplateSerializer(template).data
for template in format.available_templates.all()
],
'removed_presets': [],
'removed_templates': [],
'presets': [],
'unused_templates': []
}
test.api_patch_call(self, '/formats/' + str(assignment.pk) + '/',
update_dict, login)
def setUp(self):
"""Setup."""
self.u1 = factory.make_user("Zi", "pass", "*****@*****.**")
self.jf1 = factory.make_format()
self.jf2 = factory.make_format()
self.a1 = factory.make_assignment('tcolloq', 'description', format=self.jf1)
self.et1 = factory.make_entry_template('temp1')
self.et2 = factory.make_entry_template('temp2')
self.f1 = factory.make_field(self.et1, "test0", "1")
self.f2 = factory.make_field(self.et1, "test2", "2")
self.f3 = factory.make_field(self.et2, "test1", "1")
self.j1 = factory.make_journal(self.a1, self.u1)
self.e1 = factory.make_entry(self.et1)
self.e2 = factory.make_entry(self.et2)
self.c1 = factory.make_content(self.e1, "testcontent1", self.f1)
self.c2 = factory.make_content(self.e1, "testcontent2", self.f2)
self.c3 = factory.make_content(self.e2, "testcontent3", self.f3)
self.jf1.available_templates.add()
self.jf2.available_templates.add()
self.usr = factory.make_user('teun', '1234', email='*****@*****.**', lti_id='a')
self.crs = factory.make_course('test course please ignore', 'XXXX', startdate=datetime.date.today())
def create(self, request):
"""Create a new course.
Arguments:
request -- request data
name -- name of the course
abbreviation -- abbreviation of the course
startdate -- (optional) date when the course starts
enddate -- (optional) date when the course ends
lti_id -- (optional) lti_id to link the course to
Returns:
On failure:
unauthorized -- when the user is not logged in
forbidden -- when the user has no permission to create new courses
On succes:
success -- with the course data
"""
request.user.check_permission('can_add_course')
name, abbr = utils.required_params(request.data, 'name',
'abbreviation')
startdate, enddate, lti_id = utils.optional_params(
request.data, 'startdate', 'enddate', 'lti_id')
course = factory.make_course(name, abbr, startdate, enddate,
request.user, lti_id)
serializer = self.serializer_class(course, many=False)
return response.created({'course': serializer.data})
def test_create_new_assignment(self):
"""test create new assignment."""
lti_id = '12AB'
course = factory.make_course("BeeldBewerken",
"BB",
enddate=timezone.now())
role = factory.make_role_default_no_perms("teacher",
course,
can_add_assignment=True)
factory.make_participation(user=self.user, course=course, role=role)
login = test.logging_in(self, self.username, self.password)
create_assign_dict = {
'name': 'SIFT',
'description': 'In this assign...',
'course_id': course.pk,
'lti_id': lti_id
}
test.api_post_call(self,
'/assignments/',
params=create_assign_dict,
login=login,
status=201)
self.assertEquals(
Lti_ids.objects.get(lti_id=lti_id).assignment.name, 'SIFT')
def test_create_entry(self):
""""Test create entry."""
_, _, user2 = test.set_up_user_and_auth('testh', 'test123h',
'*****@*****.**')
course = factory.make_course('Portfolio', 'PAV', author=user2)
template = factory.make_entry_template("some_template")
format = factory.make_format([template])
assignment = factory.make_assignment("Assignment",
"Your favorite assignment",
format=format,
courses=[course])
journal = factory.make_journal(assignment, self.user)
field = factory.make_field(template, 'Some field', 0)
login = test.logging_in(self, self.username, self.password)
format.available_templates.add(template)
role = factory.make_role_default_no_perms("student",
course,
can_have_journal=True)
factory.make_participation(user=self.user, course=course, role=role)
create_entry_dict = {
'journal_id': journal.id,
'template_id': template.id,
'content': [{
'id': field.pk,
'data': "This is some data"
}]
}
test.api_post_call(self, '/entries/', create_entry_dict, login, 201)
self.assertTrue(Entry.objects.filter(node__journal=journal).exists())
self.assertEquals(
Content.objects.get(entry=1).data, "This is some data")
def test_get_lti_params_from_jwt_assignment_teacher(self):
"""Hopefully returns the lti assignment data."""
factory.make_course('TestCourse', 'aaaa', lti_id='asdf')
login = test.logging_in(self, self.username, self.password)
self.request["user_id"] = "awefd"
jwt_params = jwt.encode(self.request,
settings.SECRET_KEY,
algorithm='HS256').decode('utf-8')
response = test.api_get_call(
self,
'/get_lti_params_from_jwt/{0}/'.format(jwt_params),
login=login,
status=200)
self.assertIn(
'"state": "{0}"'.format(lti_view.LTI_STATES.NEW_ASSIGN.value),
response.content.decode('utf-8'))
def test_delete_assignment(self):
"""Test delete_assignment."""
login = test.logging_in(self, self.username, self.password)
course1 = factory.make_course("Portfolio Academische Vaardigheden",
"PAV")
course2 = factory.make_course("BeeldBewerken", "BB")
assign1 = factory.make_assignment("Colloq", "In de opdracht...1",
self.user)
assign2 = factory.make_assignment("Logboek", "In de opdracht...2",
self.user)
role = factory.make_role_default_no_perms("teacher",
self.course,
can_delete_assignment=True)
factory.make_participation(user=self.user,
course=self.course,
role=role)
role = factory.make_role_default_no_perms("teacher",
course1,
can_delete_assignment=True)
factory.make_participation(user=self.user, course=course1, role=role)
role = factory.make_role_default_no_perms("teacher",
course2,
can_delete_assignment=True)
factory.make_participation(user=self.user, course=course2, role=role)
assign1.courses.add(course1)
assign1.courses.add(course2)
assign2.courses.add(course1)
# Stupid test to begin with, glad this is replaced soon
test.api_del_call(
self,
'/assignments/{}/?course_id={}'.format(str(assign1.pk),
self.course.pk), login)
assignment = Assignment.objects.get(pk=assign1.pk)
self.assertEquals(assignment.courses.count(), 2)
test.api_del_call(
self,
'/assignments/{}/?course_id={}'.format(self.course.pk,
self.course.pk), login)
self.assertEquals(Assignment.objects.filter(pk=assign1.pk).count(), 1)
def test_check_if_need_VLE_publish_no_journals(self):
"""Hopefully doesnt crash."""
course = factory.make_course('TestCourse', 'aaaa', lti_id='qqsa')
assign = factory.make_assignment("TestAss",
"TestDescr",
lti_id='aasas',
courses=[course])
lti_grade.check_if_need_VLE_publish(assign)
def test_delete_course(self):
"""Test delete_course"""
login = test.logging_in(self, self.username, self.password)
bb = factory.make_course("Beeldbewerken", "BB")
factory.make_course("Portfolio Academische Vaardigheden", "PAV")
role = factory.make_role_default_no_perms("teacher",
bb,
can_delete_course=True)
factory.make_participation(user=self.user, course=bb, role=role)
test.api_del_call(self, '/courses/' + str(bb.pk) + '/', login)
self.assertEquals(
Course.objects.filter(name="Beeldbewerken").count(), 1)
self.assertEquals(
Course.objects.filter(
name="Portfolio Academische Vaardigheden").count(), 1)
def setUp(self):
"""Setup"""
self.username, self.password, self.user = test.set_up_user_and_auth(
'test', 'test123', '*****@*****.**')
self.rein_user, self.rein_pass, self.rein = test.set_up_user_and_auth(
"Rein", "123", '*****@*****.**')
self.no_perm_user, self.no_perm_pass, self.no_permission_user = test.set_up_user_and_auth(
"no_perm", "123", '*****@*****.**')
self.course = factory.make_course("Beeldbewerken",
"BB",
enddate=timezone.now())
def test_assignment_journals(self):
"""Test the get assignment journals function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
students = test.set_up_users('student', 2)
for student in students:
test.set_up_participation(student, course, 'Student')
test.set_up_journal(assignment, template, student, 4)
login = test.logging_in(self, self.rein_user, self.rein_pass)
response = test.api_get_call(self,
'/journals/',
login,
params={
'course_id': course.pk,
'assignment_id': assignment.pk
})
result = response.json()
self.assertEquals(len(result['journals']), 2)
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self,
'/journals/',
login,
status=403,
params={
'course_id': course.pk,
'assignment_id': assignment.pk
})
test.api_get_call(self,
'/journals/',
login,
status=404,
params={
'course_id': course.pk,
'assignment_id': self.not_found_pk
})
test.api_get_call(self, '/journals/', login, status=400, params={})
test.test_unauthorized_api_get_call(self,
'/journals/',
params={
'course_id': course.pk,
'assignment_id':
self.not_found_pk
})
def test_select_course_with_participation(self):
"""Hopefully select a course."""
course = factory.make_course('TestCourse', 'aaaa', lti_id='asdf')
factory.make_participation(
self.user, course, Role.objects.create(name='role', course=course))
selected_course = lti.check_course_lti(
{
'custom_course_id':
Lti_ids.objects.filter(course=course)[0].lti_id,
},
user=self.user,
role=settings.ROLES['Teacher'])
self.assertEquals(selected_course, course)
def setUp(self):
"""Set up the test file."""
self.username, self.password, self.user = test.set_up_user_and_auth(
'test123', 'test123', '*****@*****.**')
self.rein_user, self.rein_pass, self.rein = test.set_up_user_and_auth(
"Rein", "123", '*****@*****.**')
self.no_perm_user, self.no_perm_pass, self.no_permission_user = test.set_up_user_and_auth(
"no_perm", "123", '*****@*****.**')
self.course = factory.make_course("Beeldbewerken", "BB")
self.lars = factory.make_user("Lars", "123", "*****@*****.**")
self.student1 = factory.make_user("Student1", "123", "Student1.com")
self.student2 = factory.make_user("Student2", "123", "Student2.com")
self.not_found_pk = 9999
def setUp(self):
"""Setup."""
self.course = factory.make_course('TestCourse', 'aaaa', lti_id='asdf')
self.user = factory.make_user('TestUser', 'Pass', '*****@*****.**')
factory.make_participation(
self.user, self.course,
Role.objects.get(name='Student', course=self.course))
self.assignment = factory.make_assignment("TestAss",
"TestDescr",
points_possible=100,
courses=[self.course])
self.journal = factory.make_journal(self.assignment, self.user)
self.journal.sourcedid = 'f6d552'
self.journal.grade_url = 'http://127.0.0.1:8000/grade_passback'
def test_get_user_teacher_courses(self):
"""Test get user teacher course function."""
factory.make_course('Portfolio2016', 'PAV', author=self.rein)
factory.make_course('Portfolio2017', 'PAV', author=self.rein)
factory.make_course('Portfolio2018', 'PAV')
login = test.logging_in(self, self.rein_user, self.rein_pass)
response = test.api_get_call(self, '/courses/', login)
self.assertEquals(len(response.json()['courses']), 2)
# permissions and authorization check for the api call.
test.test_unauthorized_api_get_call(self, '/courses/')
def test_get_nodes(self):
"""Test the get nodes function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
student_user, student_pass, student = test.set_up_user_and_auth(
'student', 'pass', '*****@*****.**')
test.set_up_participation(student, course, 'Student')
journal = test.set_up_journal(assignment, template, student, 4)
login = test.logging_in(self, student_user, student_pass)
response = test.api_get_call(self,
'/nodes/',
login,
params={'journal_id': journal.pk})
result = response.json()
self.assertEquals(len(result['nodes']), 5)
login = test.logging_in(self, self.rein_user, self.rein_pass)
response = test.api_get_call(self,
'/nodes/',
login,
params={'journal_id': journal.pk})
result = response.json()
self.assertEquals(len(result['nodes']), 4)
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self,
'/nodes/',
login,
status=403,
params={'journal_id': journal.pk})
test.api_get_call(self,
'/nodes/',
login,
status=404,
params={'journal_id': self.not_found_pk})
test.test_unauthorized_api_get_call(self,
'/nodes/',
params={'journal_id': journal.pk})
def test_create_group(self):
"""test create group."""
login = test.logging_in(self, self.username, self.password)
course = factory.make_course("Portfolio Academische Vaardigheden",
"PAV")
create_group_dict = {'name': 'TestGroup', 'course_id': course.pk}
role = factory.make_role_default_no_perms(
"teacher", course, can_add_course_user_group=True)
factory.make_participation(user=self.user, course=course, role=role)
test.api_post_call(self,
'/groups/',
params=create_group_dict,
login=login,
status=201)
self.assertTrue(
Group.objects.filter(name='TestGroup', course=course).exists())
def test_delete_group(self):
"""test create group."""
login = test.logging_in(self, self.username, self.password)
course = factory.make_course("Portfolio Academische Vaardigheden",
"PAV")
role = factory.make_role_default_no_perms(
"teacher",
course,
can_add_course_user_group=True,
can_delete_course_user_group=True)
factory.make_participation(user=self.user, course=course, role=role)
factory.make_course_group('group1', course)
factory.make_course_group('group2', course)
test.api_del_call(self,
'/groups/' + str(course.pk) + '/?group_name=group1',
login)
def test_get_assignment_data(self):
"""Test the get assignment data function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format1 = factory.make_format([template])
format2 = factory.make_format([template])
assignment1 = factory.make_assignment('Colloq',
'description1',
format=format1,
courses=[course],
is_published=True)
assignment2 = factory.make_assignment('Portfolio',
'description2',
format=format2,
courses=[course],
is_published=True)
test.set_up_participation(self.user, course, 'Student')
login_user = test.logging_in(self, self.username, self.password)
resp = test.api_get_call(self,
'/assignments/' + str(assignment1.pk) + '/',
login_user)
self.assertEquals(resp.json()['assignment']['name'], 'Colloq')
self.assertIn('journal', resp.json()['assignment'])
login_rein = test.logging_in(self, self.rein_user, self.rein_pass)
resp = test.api_get_call(self,
'/assignments/' + str(assignment2.pk) + '/',
login_rein)
self.assertEquals(resp.json()['assignment']['name'], 'Portfolio')
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self,
'/assignments/{}/'.format(assignment1.pk),
login,
status=403)
test.api_get_call(self,
'/assignments/{}/'.format(assignment2.pk),
login,
status=403)
test.test_unauthorized_api_get_call(
self, '/assignments/{}/'.format(assignment1.pk))
def test_foreignkeys(self):
"""Test the foreign keys in the database."""
user_test = factory.make_user('lers', 'lers123', '*****@*****.**', '123456')
course_test = factory.make_course('tname', 'XXXX', datetime.date.today())
factory.make_format()
template = factory.make_entry_template("some_template")
entr_test = factory.make_entry(template)
field = factory.make_field(template, "test1", "1")
factory.make_content(entr_test, "data", field)
course_test.author = user_test
ass_test = factory.make_assignment(name='tcolloq', description='description')
ass_test.courses.add(course_test)
journ_test = factory.make_journal(user=user_test, assignment=ass_test)
self.assertEquals(entr_test.template.pk, template.pk)
self.assertEquals(journ_test.user.pk, user_test.pk)
self.assertEquals(journ_test.assignment.pk, ass_test.pk)
self.assertEquals(course_test.author.pk, user_test.pk)
def test_update_course(self):
"""Test update_course"""
login = test.logging_in(self, self.username, self.password)
course = factory.make_course("Portfolio Academische Vaardigheden",
"PAV",
author=self.user)
test.api_patch_call(
self, '/courses/' + str(course.pk) + '/', {
'name': 'Beeldbewerken',
'abbreviation': 'BB',
'startdate': course.startdate,
'enddate': course.enddate
}, login)
course = Course.objects.get(pk=course.pk)
self.assertEquals(course.name, 'Beeldbewerken')
self.assertEquals(course.abbreviation, 'BB')
def test_get_comments(self):
"""Test get comments function."""
course = factory.make_course('Portfolio', 'PAV', author=self.rein)
template = factory.make_entry_template('template')
format = factory.make_format([template])
assignment = factory.make_assignment('Colloq',
'description1',
format=format,
courses=[course])
student_user, student_pass, student = test.set_up_user_and_auth(
'student', 'pass', '*****@*****.**')
test.set_up_participation(student, course, 'Student')
journal = factory.make_journal(assignment, student)
entry = factory.make_entry(template)
factory.make_node(journal, entry)
factory.make_comment(entry, self.rein, 'Excellent!', True)
login = test.logging_in(self, student_user, student_pass)
result = test.api_get_call(self,
'/comments/',
login,
params={
'entry_id': entry.pk
}).json()
self.assertEquals(result['comments'][0]['text'], 'Excellent!')
# permissions and authorization check for the api call.
login = test.logging_in(self, self.no_perm_user, self.no_perm_pass)
test.api_get_call(self,
'/comments/',
login,
status=403,
params={'entry_id': entry.pk})
test.api_get_call(self,
'/comments/',
login,
status=404,
params={'entry_id': self.not_found_pk})
test.test_unauthorized_api_get_call(self,
'/comments/',
params={'entry_id': entry.pk})
def test_get_lti_params_from_jwt_journal_teacher(self):
"""Hopefully returns the LTI assignment and course."""
course = factory.make_course('TestCourse', 'aaaa', lti_id='asdf')
factory.make_assignment("TestAss",
"TestDescr",
lti_id='bughh',
courses=[course])
login = test.logging_in(self, self.username, self.password)
self.request["user_id"] = "awefd"
jwt_params = jwt.encode(self.request,
settings.SECRET_KEY,
algorithm='HS256').decode('utf-8')
response = test.api_get_call(
self,
'/get_lti_params_from_jwt/{0}/'.format(jwt_params),
login=login,
status=200)
self.assertIn(
'"state": "{0}"'.format(lti_view.LTI_STATES.FINISH_T.value),
response.content.decode('utf-8'))
