def setUp(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
self.note.category = Note.LECTURE_NOTES
self.note.uploaded_at = self.now
self.note.text = "This is the plaintext version of a note. It's pretty cool. Alpaca."
self.note.save()
def setup(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
#self.note.slug := do not set for test_remake_slug() behavior
self.note.file_type = 'doc'
self.note.uploaded_at = self.now
self.note.save()
class BaseNote(object):
def setup(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
#self.note.slug := do not set for test_remake_slug() behavior
self.note.file_type = 'doc'
self.note.uploaded_at = self.now
self.note.save()
def teardown(self):
""" erase anything we created """
print "generating a note teardown"
self.note.delete()
def upload_complete(self, request, filename, upload):
path = settings.MEDIA_URL + "/" + filename
self._dest.close()
self._dir = settings.MEDIA_ROOT
# Avoid File.objects.create, as this will try to make
# Another file copy at FileField's 'upload_to' dir
print "creating note"
note = Note()
note.name = filename
note.note_file = os.path.join(self._dir, filename)
note.course_id = request.GET['course_id']
note.draft = True # Pending approval from user
print "saving note"
note.save()
# FIXME: Make get or create
print "setting up session vars"
#import ipdb; ipdb.set_trace()
if 'uploaded_files' in request.session:
request.session['uploaded_files'].append(note.pk)
else:
request.session['uploaded_files'] = [note.pk]
# Asynchronously process document with Google Documents API
print "upload_complete, firing task"
tasks.process_document.delay(note)
return {'note_url': note.get_absolute_url()}
def upload_complete(self, request, filename, upload):
path = settings.MEDIA_URL + "/" + filename
self._dest.close()
self._dir = settings.MEDIA_ROOT
# Avoid File.objects.create, as this will try to make
# Another file copy at FileField's 'upload_to' dir
print "creating note"
note = Note()
note.name = filename
note.note_file = os.path.join(self._dir, filename)
note.course_id = request.GET['course_id']
note.draft = True # Pending approval from user
print "saving note"
note.save()
# FIXME: Make get or create
print "setting up session vars"
#import ipdb; ipdb.set_trace()
if 'uploaded_files' in request.session:
request.session['uploaded_files'].append(note.pk)
else:
request.session['uploaded_files'] = [note.pk]
# Asynchronously process document with Google Documents API
print "upload_complete, firing task"
tasks.process_document.delay(note)
return {'note_url': note.get_absolute_url()}
def setUp(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
self.note.uploaded_at = self.now
self.note.text = "This is the plaintext version of a note. It's pretty cool. Alpaca."
self.note.save()
def setUp(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
self.user1 = User(username='******')
self.user1.save()
self.user2 = User(username='******')
self.user2.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
self.note.text = "This is the plaintext version of a note. It's pretty cool."
self.note.user = self.user1
self.note.save()
self.request1 = HttpRequest()
self.request1.user = self.user1
self.request1.method = 'POST'
self.request1.META = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
self.request1.session = SessionStore()
self.request2 = HttpRequest()
self.request2.user = self.user2
self.request2.method = 'POST'
self.request2.META = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
self.request2.session = SessionStore()
def convert_to_note(self):
""" polymorph this object into a note.models.Note object """
# TODO move this to Note. superclasses should not care about subclasses,
# but subclasses should care about parents.
# Note inherits all fields of Document as does RawDocument.
# Dynamically refer to all fields of RawDocument found within Document
# and also Note.
initdict = {}
for field in Document._meta.get_all_field_names():
if field in ('tags',):
# TaggableManager does not play well with init()
continue
initdict[field] = getattr(self,field)
# Create a new Note using all fields from the Document
note = Note(**initdict)
note.save()
for tag in self.tags.all():
note.tags.add(tag)
return note
def convert_to_note(self):
""" polymorph this object into a note.models.Note object """
# TODO move this to Note. superclasses should not care about subclasses,
# but subclasses should care about parents.
# Note inherits all fields of Document as does RawDocument.
# Dynamically refer to all fields of RawDocument found within Document
# and also Note.
initdict = {}
for field in Document._meta.get_all_field_names():
if field in ('tags', ):
# TaggableManager does not play well with init()
continue
initdict[field] = getattr(self, field)
# Create a new Note using all fields from the Document
note = Note(**initdict)
note.save()
for tag in self.tags.all():
note.tags.add(tag)
return note
class TestNotes(TestCase):
def setUp(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
self.note.uploaded_at = self.now
self.note.text = "This is the plaintext version of a note. It's pretty cool. Alpaca."
self.note.save()
def test_course_fkey(self):
self.assertEqual(self.course, self.note.course)
def test_slug_natural(self):
""" Test that the slug field is slugifying unicode Note.names """
expected = u"lecture-notes-concerning-the-use-of-therefore"
self.assertEqual(self.note.slug, expected)
def test_remake_slug(self):
""" Test the generation of a Note.slug field based on Note.
Name collision is expected, so see if slug handles this."""
expected = u"lecture-notes-concerning-the-use-of-therefore-{0}-{1}-{2}".format(
self.note.uploaded_at.month,
self.note.uploaded_at.day, self.note.uploaded_at.microsecond)
self.note.slug = None
self.note.save()
self.assertEqual(self.note.slug, expected)
expected_url_prefix = u'/marshall-college/archaeology-101/'
expected_slug = u'lecture-notes-concerning-the-use-of-therefore'
expected = expected_url_prefix + expected_slug
def test_note_get_absolute_url_slug(self):
""" Given a note with a slug, test that an expected url is generated """
# check that Note.get_absolute_url() is generating the right url
self.assertEqual(self.note.get_absolute_url(), self.expected)
def test_note_get_absolute_url_id(self):
self.note.slug = None
url = self.expected_url_prefix + str(self.note.id)
self.assertEqual(self.note.get_absolute_url(), url)
class TestNotes(TestCase):
def setUp(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
self.note.category = Note.LECTURE_NOTES
self.note.uploaded_at = self.now
self.note.text = "This is the plaintext version of a note. It's pretty cool. Alpaca."
self.note.save()
def test_course_fkey(self):
self.assertEqual(self.course, self.note.course)
def test_slug_natural(self):
""" Test that the slug field is slugifying unicode Note.names """
expected = u"lecture-notes-concerning-the-use-of-therefore"
self.assertEqual(self.note.slug, expected)
def test_remake_slug(self):
""" Test the generation of a Note.slug field based on Note.
Name collision is expected, so see if slug handles this."""
expected = u"lecture-notes-concerning-the-use-of-therefore-{0}-{1}-{2}".format(
self.note.uploaded_at.month, self.note.uploaded_at.day,
self.note.uploaded_at.microsecond)
self.note.slug = None
self.note.save()
self.assertEqual(self.note.slug, expected)
expected_url_prefix = u'/note/marshall-college/archaeology-101/'
expected_slug = u'lecture-notes-concerning-the-use-of-therefore'
expected = expected_url_prefix + expected_slug
def test_note_get_absolute_url_slug(self):
""" Given a note with a slug, test that an expected url is generated """
# check that Note.get_absolute_url() is generating the right url
self.assertEqual(self.note.get_absolute_url(), self.expected)
def test_note_get_absolute_url_id(self):
self.note.slug = None
url = self.expected_url_prefix + str(self.note.id)
self.assertEqual(self.note.get_absolute_url(), url)
def test_note_markdown_rendering(self):
rich = NoteMarkdown(
note=self.note,
markdown="""# This is fun\n[oh](http://yeah.com)""")
rich.save()
self.assertHTMLEqual(
rich.html,
"""<h1>This is fun</h1>\n<p><a href="http://yeah.com" rel="nofollow" target="_blank">oh</a></p>"""
)
def test_note_rich_text_sanitization(self):
rich = NoteMarkdown(note=self.note,
html="""
<script>unsafe</script>
<h1 class='obtrusive'>Something</h1>
<h2>OK</h2>
&
”
<a href='javascript:alert("Oh no")'>This stuff</a>
<a href='http://google.com'>That guy</a>
""")
rich.save()
self.assertHTMLEqual(
rich.html, u"""
<h1>Something</h1>
<h2>OK</h2>
&
\u201d
<a target='_blank' rel='nofollow'>This stuff</a>
<a href="http://google.com" target="_blank" rel="nofollow">That guy</a>
""")
class TestUsers(TestCase):
def setUp(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
self.user1 = User(username='******')
self.user1.save()
self.user2 = User(username='******')
self.user2.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
self.note.text = "This is the plaintext version of a note. It's pretty cool."
self.note.user = self.user1
self.note.save()
self.request1 = HttpRequest()
self.request1.user = self.user1
self.request1.method = 'POST'
self.request1.META = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
self.request1.session = SessionStore()
self.request2 = HttpRequest()
self.request2.user = self.user2
self.request2.method = 'POST'
self.request2.META = {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
self.request2.session = SessionStore()
def test_thank_own_note_karma(self):
"""Make sure you don't get karma for thanking your own note"""
thank_note(self.request1, self.note.pk)
try:
NoteKarmaEvent.objects.get(note=self.note)
self.fail("You can't thank your own note")
except ObjectDoesNotExist:
pass
def test_thank_anothers_note_karma(self):
"""Get karma for having your note thanked"""
thank_note(self.request2, self.note.pk)
try:
NoteKarmaEvent.objects.get(note=self.note)
except ObjectDoesNotExist:
self.fail("Karma event not created")
def test_note_deleted_karma(self):
"""Lose karma if your note is deleted"""
thank_note(self.request2, self.note.pk)
self.note.delete()
try:
GenericKarmaEvent.objects.get(event_type=GenericKarmaEvent.NOTE_DELETED)
except ObjectDoesNotExist:
self.fail("Karma event not created")
try:
NoteKarmaEvent.objects.get(note=self.note)
self.fail("Karma event not deleted")
except ObjectDoesNotExist:
pass
def test_note_give_flag_karma(self):
"""Lose karma for flagging a note"""
flag_note(self.request2, self.note.pk)
try:
NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.GIVE_FLAG, user=self.user2)
except ObjectDoesNotExist:
self.fail("Karma event not created")
def test_course_give_flag_karma(self):
"""Lose karma for flagging a course"""
flag_course(self.request2, self.course.pk)
try:
CourseKarmaEvent.objects.get(event_type=CourseKarmaEvent.GIVE_FLAG, user=self.user2)
except ObjectDoesNotExist:
self.fail("Karma event not created")
def test_note_get_flagged_karma(self):
"""Lose karma for having your note flagged many times"""
flag_note(self.request2, self.note.pk)
flag_note(self.request2, self.note.pk)
flag_note(self.request2, self.note.pk)
flag_note(self.request2, self.note.pk)
flag_note(self.request2, self.note.pk)
flag_note(self.request2, self.note.pk)
try:
NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.GET_FLAGGED, user=self.user1)
except ObjectDoesNotExist:
self.fail("Karma event not created")
def test_note_download_karma(self):
"""You lose karma for downloading a note, person who uploaded it gains karma"""
downloaded_note(self.request2, self.note.pk)
try:
NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.DOWNLOADED_NOTE, user=self.user2)
except ObjectDoesNotExist:
self.fail("Karma event not created")
try:
NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.HAD_NOTE_DOWNLOADED, user=self.user1)
except ObjectDoesNotExist:
self.fail("Karma event not created")
def test_download_own_note_karma(self):
"""No karma change for downloading your own note"""
downloaded_note(self.request1, self.note.pk)
try:
NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.DOWNLOADED_NOTE, user=self.user1)
self.fail("Karma debited for downloading own note, but shouldn't have been.")
except ObjectDoesNotExist:
pass
try:
NoteKarmaEvent.objects.get(event_type=NoteKarmaEvent.HAD_NOTE_DOWNLOADED, user=self.user1)
self.fail("Karma given for downloading own note, but shouldn't have been.")
except ObjectDoesNotExist:
pass
def test_email_confirm_karma(self):
class FakeEmailAddress:
user = self.user1
email = self.user1.email
give_email_confirm_karma(None, email_address=FakeEmailAddress())
try:
GenericKarmaEvent.objects.get(event_type=GenericKarmaEvent.EMAIL_CONFIRMED, user=self.user1)
except ObjectDoesNotExist:
self.fail("Karma event not created")
class TestNotes(TestCase):
def setUp(self):
# create base values to test db representations
self.now = datetime.datetime.utcnow()
# create a school to satisfy course requirements
self.school = School()
self.school.name = 'Marshall College'
self.school.save()
# create a course to test relationships
self.course = Course()
self.course.school = self.school
self.course.name = u'Archaeology 101'
self.course.save()
# override Course.save() appending an ID to the slug
self.course.slug = u'archaeology-101'
self.course.save()
# create a note to test against
self.note = Note()
self.note.course = self.course
self.note.name = u"Lecture notes concerning the use of therefore ∴"
self.note.category = Note.LECTURE_NOTES
self.note.uploaded_at = self.now
self.note.text = "This is the plaintext version of a note. It's pretty cool. Alpaca."
self.note.save()
def test_course_fkey(self):
self.assertEqual(self.course, self.note.course)
def test_slug_natural(self):
""" Test that the slug field is slugifying unicode Note.names """
expected = u"lecture-notes-concerning-the-use-of-therefore"
self.assertEqual(self.note.slug, expected)
def test_remake_slug(self):
""" Test the generation of a Note.slug field based on Note.
Name collision is expected, so see if slug handles this."""
expected = u"lecture-notes-concerning-the-use-of-therefore-{0}-{1}-{2}".format(
self.note.uploaded_at.month,
self.note.uploaded_at.day, self.note.uploaded_at.microsecond)
self.note.slug = None
self.note.save()
self.assertEqual(self.note.slug, expected)
expected_url_prefix = u'/note/marshall-college/archaeology-101/'
expected_slug = u'lecture-notes-concerning-the-use-of-therefore'
expected = expected_url_prefix + expected_slug
def test_note_get_absolute_url_slug(self):
""" Given a note with a slug, test that an expected url is generated """
# check that Note.get_absolute_url() is generating the right url
self.assertEqual(self.note.get_absolute_url(), self.expected)
def test_note_get_absolute_url_id(self):
self.note.slug = None
url = self.expected_url_prefix + str(self.note.id)
self.assertEqual(self.note.get_absolute_url(), url)
def test_note_markdown_rendering(self):
rich = NoteMarkdown(note=self.note,
markdown="""# This is fun\n[oh](http://yeah.com)""")
rich.save()
self.assertHTMLEqual(rich.html,
"""<h1>This is fun</h1>\n<p><a href="http://yeah.com" rel="nofollow" target="_blank">oh</a></p>""")
def test_note_rich_text_sanitization(self):
rich = NoteMarkdown(note=self.note, html="""
<script>unsafe</script>
<h1 class='obtrusive'>Something</h1>
<h2>OK</h2>
&
”
<a href='javascript:alert("Oh no")'>This stuff</a>
<a href='http://google.com'>That guy</a>
""")
rich.save()
self.assertHTMLEqual(rich.html, u"""
<h1>Something</h1>
<h2>OK</h2>
&
\u201d
<a target='_blank' rel='nofollow'>This stuff</a>
<a href="http://google.com" target="_blank" rel="nofollow">That guy</a>
""")