b353ed2ea2
The existing pattern of using `override_settings(MODULESTORE=...)` prevented
us from having more than one layer of subclassing in modulestore tests.
In a structure like:
@override_settings(MODULESTORE=store_a)
class BaseTestCase(ModuleStoreTestCase):
def setUp(self):
# use store
@override_settings(MODULESTORE=store_b)
class ChildTestCase(BaseTestCase):
def setUp(self):
# use store
In this case, the store actions performed in `BaseTestCase` on behalf of
`ChildTestCase` would still use `store_a`, even though the `ChildTestCase`
had specified to use `store_b`. This is because the `override_settings`
decorator would be the innermost wrapper around the `BaseTestCase.setUp` method,
no matter what `ChildTestCase` does.
To remedy this, we move the call to `override_settings` into the
`ModuleStoreTestCase.setUp` method, and use a cleanup to remove the override.
Subclasses can just defined the `MODULESTORE` class attribute to specify which
modulestore to use _for the entire `setUp` chain_.
[PLAT-419]
274 lines
10 KiB
Python
274 lines
10 KiB
Python
"""
|
|
Test the lms/staticbook views.
|
|
"""
|
|
|
|
import textwrap
|
|
|
|
import mock
|
|
import requests
|
|
|
|
from django.test.utils import override_settings
|
|
from django.core.urlresolvers import reverse, NoReverseMatch
|
|
|
|
from xmodule.modulestore.tests.django_utils import TEST_DATA_MOCK_MODULESTORE
|
|
from student.tests.factories import UserFactory, CourseEnrollmentFactory
|
|
from xmodule.modulestore.tests.factories import CourseFactory
|
|
from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
|
|
|
|
|
|
IMAGE_BOOK = ("An Image Textbook", "http://example.com/the_book/")
|
|
|
|
PDF_BOOK = {
|
|
"tab_title": "Textbook",
|
|
"title": "A PDF Textbook",
|
|
"chapters": [
|
|
{"title": "Chapter 1 for PDF", "url": "https://somehost.com/the_book/chap1.pdf"},
|
|
{"title": "Chapter 2 for PDF", "url": "https://somehost.com/the_book/chap2.pdf"},
|
|
],
|
|
}
|
|
|
|
PORTABLE_PDF_BOOK = {
|
|
"tab_title": "Textbook",
|
|
"title": "A PDF Textbook",
|
|
"chapters": [
|
|
{"title": "Chapter 1 for PDF", "url": "/static/chap1.pdf"},
|
|
{"title": "Chapter 2 for PDF", "url": "/static/chap2.pdf"},
|
|
],
|
|
}
|
|
|
|
HTML_BOOK = {
|
|
"tab_title": "Textbook",
|
|
"title": "An HTML Textbook",
|
|
"chapters": [
|
|
{"title": "Chapter 1 for HTML", "url": "https://somehost.com/the_book/chap1.html"},
|
|
{"title": "Chapter 2 for HTML", "url": "https://somehost.com/the_book/chap2.html"},
|
|
],
|
|
}
|
|
|
|
|
|
class StaticBookTest(ModuleStoreTestCase):
|
|
"""
|
|
Helpers for the static book tests.
|
|
"""
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super(StaticBookTest, self).__init__(*args, **kwargs)
|
|
self.course = None
|
|
|
|
def make_course(self, **kwargs):
|
|
"""
|
|
Make a course with an enrolled logged-in student.
|
|
"""
|
|
self.course = CourseFactory.create(**kwargs)
|
|
user = UserFactory.create()
|
|
CourseEnrollmentFactory.create(user=user, course_id=self.course.id)
|
|
self.client.login(username=user.username, password='test')
|
|
|
|
def make_url(self, url_name, **kwargs):
|
|
"""
|
|
Make a URL for a `url_name` using keyword args for url slots.
|
|
|
|
Automatically provides the course id.
|
|
|
|
"""
|
|
kwargs['course_id'] = self.course.id.to_deprecated_string()
|
|
url = reverse(url_name, kwargs=kwargs)
|
|
return url
|
|
|
|
|
|
class StaticImageBookTest(StaticBookTest):
|
|
"""
|
|
Test the image-based static book view.
|
|
"""
|
|
|
|
def test_book(self):
|
|
# We can access a book.
|
|
with mock.patch.object(requests, 'get') as mock_get:
|
|
mock_get.return_value.text = textwrap.dedent('''\
|
|
<?xml version="1.0"?>
|
|
<table_of_contents>
|
|
<entry page="9" page_label="ix" name="Contents!?"/>
|
|
<entry page="1" page_label="i" name="Preamble">
|
|
<entry page="4" page_label="iv" name="About the Elephants"/>
|
|
</entry>
|
|
</table_of_contents>
|
|
''')
|
|
|
|
self.make_course(textbooks=[IMAGE_BOOK])
|
|
url = self.make_url('book', book_index=0)
|
|
response = self.client.get(url)
|
|
|
|
self.assertContains(response, "Contents!?")
|
|
self.assertContains(response, "About the Elephants")
|
|
|
|
def test_bad_book_id(self):
|
|
# A bad book id will be a 404.
|
|
self.make_course(textbooks=[IMAGE_BOOK])
|
|
with self.assertRaises(NoReverseMatch):
|
|
self.make_url('book', book_index='fooey')
|
|
|
|
def test_out_of_range_book_id(self):
|
|
self.make_course()
|
|
url = self.make_url('book', book_index=0)
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, 404)
|
|
|
|
def test_bad_page_id(self):
|
|
# A bad page id will cause a 404.
|
|
self.make_course(textbooks=[IMAGE_BOOK])
|
|
with self.assertRaises(NoReverseMatch):
|
|
self.make_url('book', book_index=0, page='xyzzy')
|
|
|
|
|
|
class StaticPdfBookTest(StaticBookTest):
|
|
"""
|
|
Test the PDF static book view.
|
|
"""
|
|
|
|
def test_book(self):
|
|
# We can access a book.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
url = self.make_url('pdf_book', book_index=0)
|
|
response = self.client.get(url)
|
|
self.assertContains(response, "Chapter 1 for PDF")
|
|
self.assertNotContains(response, "options.chapterNum =")
|
|
self.assertNotContains(response, "page=")
|
|
|
|
def test_book_chapter(self):
|
|
# We can access a book at a particular chapter.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
url = self.make_url('pdf_book', book_index=0, chapter=2)
|
|
response = self.client.get(url)
|
|
self.assertContains(response, "Chapter 2 for PDF")
|
|
self.assertContains(response, "file={}".format(PDF_BOOK['chapters'][1]['url']))
|
|
self.assertNotContains(response, "page=")
|
|
|
|
def test_book_page(self):
|
|
# We can access a book at a particular page.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
url = self.make_url('pdf_book', book_index=0, page=17)
|
|
response = self.client.get(url)
|
|
self.assertContains(response, "Chapter 1 for PDF")
|
|
self.assertNotContains(response, "options.chapterNum =")
|
|
self.assertContains(response, "page=17")
|
|
|
|
def test_book_chapter_page(self):
|
|
# We can access a book at a particular chapter and page.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
url = self.make_url('pdf_book', book_index=0, chapter=2, page=17)
|
|
response = self.client.get(url)
|
|
self.assertContains(response, "Chapter 2 for PDF")
|
|
self.assertContains(response, "file={}".format(PDF_BOOK['chapters'][1]['url']))
|
|
self.assertContains(response, "page=17")
|
|
|
|
def test_bad_book_id(self):
|
|
# If the book id isn't an int, we'll get a 404.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
with self.assertRaises(NoReverseMatch):
|
|
self.make_url('pdf_book', book_index='fooey', chapter=1)
|
|
|
|
def test_out_of_range_book_id(self):
|
|
# If we have one book, asking for the second book will fail with a 404.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
url = self.make_url('pdf_book', book_index=1, chapter=1)
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, 404)
|
|
|
|
def test_no_book(self):
|
|
# If we have no books, asking for the first book will fail with a 404.
|
|
self.make_course()
|
|
url = self.make_url('pdf_book', book_index=0, chapter=1)
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, 404)
|
|
|
|
def test_chapter_xss(self):
|
|
# The chapter in the URL used to go right on the page.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
# It's no longer possible to use a non-integer chapter.
|
|
with self.assertRaises(NoReverseMatch):
|
|
self.make_url('pdf_book', book_index=0, chapter='xyzzy')
|
|
|
|
def test_page_xss(self):
|
|
# The page in the URL used to go right on the page.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
# It's no longer possible to use a non-integer page.
|
|
with self.assertRaises(NoReverseMatch):
|
|
self.make_url('pdf_book', book_index=0, page='xyzzy')
|
|
|
|
def test_chapter_page_xss(self):
|
|
# The page in the URL used to go right on the page.
|
|
self.make_course(pdf_textbooks=[PDF_BOOK])
|
|
# It's no longer possible to use a non-integer page and a non-integer chapter.
|
|
with self.assertRaises(NoReverseMatch):
|
|
self.make_url('pdf_book', book_index=0, chapter='fooey', page='xyzzy')
|
|
|
|
def test_static_url_map_contentstore(self):
|
|
"""
|
|
This ensure static URL mapping is happening properly for
|
|
a course that uses the contentstore
|
|
"""
|
|
self.make_course(pdf_textbooks=[PORTABLE_PDF_BOOK])
|
|
url = self.make_url('pdf_book', book_index=0, chapter=1)
|
|
response = self.client.get(url)
|
|
self.assertNotContains(response, 'file={}'.format(PORTABLE_PDF_BOOK['chapters'][0]['url']))
|
|
self.assertContains(response, 'file=/c4x/{0.org}/{0.course}/asset/{1}'.format(
|
|
self.course.location,
|
|
PORTABLE_PDF_BOOK['chapters'][0]['url'].replace('/static/', '')))
|
|
|
|
def test_static_url_map_static_asset_path(self):
|
|
"""
|
|
Like above, but used when the course has set a static_asset_path
|
|
"""
|
|
self.make_course(pdf_textbooks=[PORTABLE_PDF_BOOK], static_asset_path='awesomesauce')
|
|
url = self.make_url('pdf_book', book_index=0, chapter=1)
|
|
response = self.client.get(url)
|
|
self.assertNotContains(response, 'file={}'.format(PORTABLE_PDF_BOOK['chapters'][0]['url']))
|
|
self.assertNotContains(response, 'file=/c4x/{0.org}/{0.course}/asset/{1}'.format(
|
|
self.course.location,
|
|
PORTABLE_PDF_BOOK['chapters'][0]['url'].replace('/static/', '')))
|
|
self.assertContains(response, 'file=/static/awesomesauce/{}'.format(
|
|
PORTABLE_PDF_BOOK['chapters'][0]['url'].replace('/static/', '')))
|
|
|
|
|
|
class StaticHtmlBookTest(StaticBookTest):
|
|
"""
|
|
Test the HTML static book view.
|
|
"""
|
|
|
|
def test_book(self):
|
|
# We can access a book.
|
|
self.make_course(html_textbooks=[HTML_BOOK])
|
|
url = self.make_url('html_book', book_index=0)
|
|
response = self.client.get(url)
|
|
self.assertContains(response, "Chapter 1 for HTML")
|
|
self.assertNotContains(response, "options.chapterNum =")
|
|
|
|
def test_book_chapter(self):
|
|
# We can access a book at a particular chapter.
|
|
self.make_course(html_textbooks=[HTML_BOOK])
|
|
url = self.make_url('html_book', book_index=0, chapter=2)
|
|
response = self.client.get(url)
|
|
self.assertContains(response, "Chapter 2 for HTML")
|
|
self.assertContains(response, "options.chapterNum = 2;")
|
|
|
|
def test_bad_book_id(self):
|
|
# If we have one book, asking for the second book will fail with a 404.
|
|
self.make_course(html_textbooks=[HTML_BOOK])
|
|
url = self.make_url('html_book', book_index=1, chapter=1)
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, 404)
|
|
|
|
def test_no_book(self):
|
|
# If we have no books, asking for the first book will fail with a 404.
|
|
self.make_course()
|
|
url = self.make_url('html_book', book_index=0, chapter=1)
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, 404)
|
|
|
|
def test_chapter_xss(self):
|
|
# The chapter in the URL used to go right on the page.
|
|
self.make_course(pdf_textbooks=[HTML_BOOK])
|
|
# It's no longer possible to use a non-integer chapter.
|
|
with self.assertRaises(NoReverseMatch):
|
|
self.make_url('html_book', book_index=0, chapter='xyzzy')
|