Example #1
0
    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()
Example #2
0
    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()
Example #3
0
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()
Example #4
0
    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()}
Example #5
0
    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()}
Example #6
0
    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()
Example #7
0
    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()
Example #8
0
    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
Example #9
0
    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
Example #10
0
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)
Example #11
0
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>
            &amp;
            &rdquo;
            <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>
            &amp;
            \u201d
            <a target='_blank' rel='nofollow'>This stuff</a>
            <a href="http://google.com" target="_blank" rel="nofollow">That guy</a>
        """)
Example #12
0
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")
Example #13
0
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>
            &amp;
            &rdquo;
            <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>
            &amp;
            \u201d
            <a target='_blank' rel='nofollow'>This stuff</a>
            <a href="http://google.com" target="_blank" rel="nofollow">That guy</a>
        """)