Beispiel #1
0
    def test_asset_create_via_bookmarklet(self):
        data = {'title': 'YouTube Asset',
                'youtube': 'http://www.youtube.com/abcdefghi',
                'asset-source': 'bookmarklet'}

        request = RequestFactory().post('/save/', data)
        request.user = self.instructor_one
        request.course = self.sample_course

        view = AssetCreateView()
        view.request = request
        response = view.post(request)

        self.assertEquals(response.status_code, 200)
        Asset.objects.get(title='YouTube Asset')

        data = {
            'title': 'HTML5 video title',
            'asset-source': 'bookmarklet',
            'video': 'http://www.example.com/video.mp4',
            'video-metadata': 'w480h358',
            'metadata-description': 'Video description',
        }
        request = RequestFactory().post('/save/', data)
        request.user = self.instructor_one
        request.course = self.sample_course

        view = AssetCreateView()
        view.request = request
        response = view.post(request)

        self.assertEquals(response.status_code, 200)
        asset = Asset.objects.get(title='HTML5 video title')
        self.assertEquals(asset.metadata()['description'],
                          [data['metadata-description']])
Beispiel #2
0
    def test_redirect_uploader(self):
        # no collection id
        request = RequestFactory().post('/upload/redirect')
        request.user = self.student_one
        request.course = self.sample_course

        view = RedirectToUploaderView()
        view.request = request

        with self.assertRaises(Http404):
            view.post(request, [], **{'collection_id': 123})

        secret_keys = {'http://ccnmtl.columbia.edu': 'a very good secret'}
        with self.settings(SERVER_ADMIN_SECRETKEYS=secret_keys):
            # invalid uploader url
            as_user = '******' % self.student_one.username
            exc = ExternalCollectionFactory(url='http://abc.def.ghi')
            with self.assertRaises(Http404):
                view.post(request, [], **{'collection_id': exc.id})

            # successful redirect
            exc = ExternalCollectionFactory(url='http://ccnmtl.columbia.edu')
            response = view.post(request, [], **{'collection_id': exc.id})
            self.assertEquals(response.status_code, 302)
            self.assertTrue(response.url.startswith(exc.url))
            self.assertTrue('nonce' in response.url)
            self.assertTrue('hmac' in response.url)
            self.assertTrue('redirect_url' in response.url)
            self.assertTrue(as_user in response.url)

            # "as" without permissions + audio
            data = {'as': self.student_two.username, 'audio': 'mp4'}
            request = RequestFactory().post('/upload/redirect', data)
            request.user = self.student_one
            request.course = self.sample_course
            response = view.post(request, [], **{'collection_id': exc.id})
            self.assertEquals(response.status_code, 302)
            self.assertTrue(as_user in response.url)
            self.assertTrue('audio=mp4' in response.url)

            # "as" with permissions
            data = {'as': self.student_one.username}
            request = RequestFactory().post('/upload/redirect', data)
            request.user = UserFactory(is_staff=True)
            request.course = self.sample_course
            self.add_as_faculty(request.course, request.user)

            response = view.post(request, [], **{'collection_id': exc.id})
            self.assertEquals(response.status_code, 302)
            self.assertTrue(as_user in response.url)
Beispiel #3
0
    def test_redirect_uploader(self):
        # no collection id
        request = RequestFactory().post('/upload/redirect')
        request.user = self.student_one
        request.course = self.sample_course

        view = RedirectToUploaderView()
        view.request = request

        with self.assertRaises(Http404):
            view.post(request, [], **{'collection_id': 123})

        secret_keys = {'http://ccnmtl.columbia.edu': 'a very good secret'}
        with self.settings(SERVER_ADMIN_SECRETKEYS=secret_keys):
            # invalid uploader url
            as_user = '******' % self.student_one.username
            exc = ExternalCollectionFactory(url='http://abc.def.ghi')
            with self.assertRaises(Http404):
                view.post(request, [], **{'collection_id': exc.id})

            # successful redirect
            exc = ExternalCollectionFactory(url='http://ccnmtl.columbia.edu')
            response = view.post(request, [], **{'collection_id': exc.id})
            self.assertEquals(response.status_code, 302)
            self.assertTrue(response.url.startswith(exc.url))
            self.assertTrue('nonce' in response.url)
            self.assertTrue('hmac' in response.url)
            self.assertTrue('redirect_url' in response.url)
            self.assertTrue(as_user in response.url)

            # "as" without permissions + audio
            data = {'as': self.student_two.username, 'audio': 'mp4'}
            request = RequestFactory().post('/upload/redirect', data)
            request.user = self.student_one
            request.course = self.sample_course
            response = view.post(request, [], **{'collection_id': exc.id})
            self.assertEquals(response.status_code, 302)
            self.assertTrue(as_user in response.url)
            self.assertTrue('audio=mp4' in response.url)

            # "as" with permissions
            data = {'as': self.student_one.username}
            request = RequestFactory().post('/upload/redirect', data)
            request.user = UserFactory(is_staff=True)
            request.course = self.sample_course
            self.add_as_faculty(request.course, request.user)

            response = view.post(request, [], **{'collection_id': exc.id})
            self.assertEquals(response.status_code, 302)
            self.assertTrue(as_user in response.url)
Beispiel #4
0
    def test_render_tag_list_for_course(self):
        request = RequestFactory().get("")
        request.course = self.sample_course

        notes = SherdNote.objects.filter(author=self.student_one)
        lst = TagResource().render_for_course(request, notes)
        self.assertEquals(len(lst), 6)

        self.assertEquals(lst[0]["count"], 1)
        self.assertEquals(lst[0]["last"], False)
        self.assertEquals(lst[0]["name"], "image")

        self.assertEquals(lst[1]["count"], 0)
        self.assertEquals(lst[1]["last"], False)
        self.assertEquals(lst[1]["name"], "instructor_one_global")

        self.assertEquals(lst[2]["count"], 0)
        self.assertEquals(lst[2]["last"], False)
        self.assertEquals(lst[2]["name"], "instructor_one_selection")

        self.assertEquals(lst[3]["count"], 1)
        self.assertEquals(lst[3]["last"], False)
        self.assertEquals(lst[3]["name"], "student_one_global")

        self.assertEquals(lst[4]["count"], 1)
        self.assertEquals(lst[4]["last"], False)
        self.assertEquals(lst[4]["name"], "student_one_selection")

        self.assertEquals(lst[5]["count"], 0)
        self.assertEquals(lst[5]["last"], True)
        self.assertEquals(lst[5]["name"], "video")
Beispiel #5
0
    def test_get_context_data(self):
        request = RequestFactory().get('/dashboard/migrate/')
        request.user = User.objects.get(username='******')
        request.course = self.sample_course

        view = MigrateCourseView()
        view.request = request

        ctx = view.get_context_data()

        self.assertEquals(len(ctx['current_course_faculty']), 2)
        self.assertEquals(ctx['current_course_faculty'][0].username,
                          'test_instructor')
        self.assertEquals(ctx['current_course_faculty'][1].username,
                          'test_instructor_two')

        self.assertEquals(len(ctx['available_courses']), 2)
        self.assertEquals(ctx['available_courses'][0].title,
                          'Alternate Course')
        self.assertEquals(ctx['available_courses'][1].title,
                          'Sample Course')

        request.user = self.superuser
        ctx = view.get_context_data()
        self.assertEquals(len(ctx['available_courses']), 2)
        self.assertEquals(ctx['available_courses'][0].title,
                          'Alternate Course')
        self.assertEquals(ctx['available_courses'][1].title,
                          'Sample Course')
Beispiel #6
0
    def test_get_context_data(self):
        request = RequestFactory().get('/dashboard/migrate/')
        request.user = self.instructor_three
        request.course = self.sample_course

        view = MigrateCourseView()
        view.request = request

        ctx = view.get_context_data()

        self.assertEquals(len(ctx['current_course_faculty']), 3)
        self.assertEquals(ctx['current_course_faculty'][0].username,
                          'instructor_one')
        self.assertEquals(ctx['current_course_faculty'][1].username,
                          'instructor_three')
        self.assertEquals(ctx['current_course_faculty'][2].username,
                          'instructor_two')

        self.assertEquals(len(ctx['available_courses']), 2)
        self.assertEquals(ctx['available_courses'][0].title,
                          'Alternate Course')
        self.assertEquals(ctx['available_courses'][1].title,
                          'Sample Course')

        request.user = self.superuser
        ctx = view.get_context_data()
        self.assertEquals(len(ctx['available_courses']), 2)
        self.assertEquals(ctx['available_courses'][0].title,
                          'Alternate Course')
        self.assertEquals(ctx['available_courses'][1].title,
                          'Sample Course')
Beispiel #7
0
    def test_render_tag_list_for_course(self):
        request = RequestFactory().get('')
        request.course = self.sample_course

        notes = SherdNote.objects.filter(author=self.student_one)
        lst = TagResource().render_for_course(request, notes)
        self.assertEquals(len(lst), 6)

        self.assertEquals(lst[0]['count'], 1)
        self.assertEquals(lst[0]['last'], False)
        self.assertEquals(lst[0]['name'], 'image')

        self.assertEquals(lst[1]['count'], 0)
        self.assertEquals(lst[1]['last'], False)
        self.assertEquals(lst[1]['name'], 'instructor_one_global')

        self.assertEquals(lst[2]['count'], 0)
        self.assertEquals(lst[2]['last'], False)
        self.assertEquals(lst[2]['name'], 'instructor_one_selection')

        self.assertEquals(lst[3]['count'], 1)
        self.assertEquals(lst[3]['last'], False)
        self.assertEquals(lst[3]['name'], 'student_one_global')

        self.assertEquals(lst[4]['count'], 1)
        self.assertEquals(lst[4]['last'], False)
        self.assertEquals(lst[4]['name'], 'student_one_selection')

        self.assertEquals(lst[5]['count'], 0)
        self.assertEquals(lst[5]['last'], True)
        self.assertEquals(lst[5]['name'], 'video')
Beispiel #8
0
    def test_migrate_tags_and_notes(self):
        data = {
            'fromCourse': self.sample_course.id,
            'asset_ids[]': [self.asset1.id],
            'project_ids[]': [],
            'include_tags': 'true',
            'include_notes': 'true'
        }

        # Migrate assets from SampleCourse into Alternate Course
        # test_instructor_three is a member of both courses
        request = RequestFactory().post('/dashboard/migrate/', data)
        request.user = self.instructor_three
        request.course = self.alt_course

        view = MigrateCourseView()
        view.request = request
        view.post(request)

        new_asset = Asset.objects.get(course=self.alt_course,
                                      title=self.asset1.title)
        self.assertEquals(new_asset.sherdnote_set.count(), 2)

        note = new_asset.sherdnote_set.get(title=self.instructor_note.title)
        self.assertEquals(note.tags, self.instructor_note.tags)
        self.assertEquals(note.body, self.instructor_note.body)

        note = new_asset.global_annotation(self.instructor_three, False)
        self.assertEquals(
            note.tags,
            u',image, instructor_one_global,,instructor_two_global,')
        self.assertEquals(
            note.body,
            u'instructor one global noteinstructor two global note')
Beispiel #9
0
    def create_discussion(self, course, instructor):
        data = {
            'comment_html': '%s Discussion' % course.title,
            'obj_pk': course.id,
            'model': 'course',
            'app_label': 'courseaffils'
        }
        request = RequestFactory().post(
            reverse('discussion-create', args=[course.pk]),
            data,
            # Mock an ajax request because the response is simpler to
            # deal with manually here.
            HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        request.user = instructor
        request.course = course
        request.collaboration_context, created = \
            Collaboration.objects.get_or_create(
                content_type=ContentType.objects.get_for_model(Course),
                object_pk=course.pk)
        view = DiscussionCreateView()
        view.request = request
        response = view.post(request)

        response_data = json.loads(response.content)
        thread_id = response_data.get('context').get('discussion').get('id')

        return ThreadedComment.objects.get(id=thread_id)
Beispiel #10
0
    def test_render_tag_list_for_course(self):
        request = RequestFactory().get('')
        request.course = self.sample_course

        notes = SherdNote.objects.filter(author=self.student_one)
        lst = TagResource().render_for_course(request, notes)
        self.assertEquals(len(lst), 6)

        self.assertEquals(lst[0]['count'], 1)
        self.assertEquals(lst[0]['last'], False)
        self.assertEquals(lst[0]['name'], 'image')

        self.assertEquals(lst[1]['count'], 0)
        self.assertEquals(lst[1]['last'], False)
        self.assertEquals(lst[1]['name'], 'instructor_one_global')

        self.assertEquals(lst[2]['count'], 0)
        self.assertEquals(lst[2]['last'], False)
        self.assertEquals(lst[2]['name'], 'instructor_one_selection')

        self.assertEquals(lst[3]['count'], 1)
        self.assertEquals(lst[3]['last'], False)
        self.assertEquals(lst[3]['name'], 'student_one_global')

        self.assertEquals(lst[4]['count'], 1)
        self.assertEquals(lst[4]['last'], False)
        self.assertEquals(lst[4]['name'], 'student_one_selection')

        self.assertEquals(lst[5]['count'], 0)
        self.assertEquals(lst[5]['last'], True)
        self.assertEquals(lst[5]['name'], 'video')
Beispiel #11
0
    def test_create_instructor_feedback(self):
        self.setup_sample_course()
        project = ProjectFactory.create(
            course=self.sample_course, author=self.student_one,
            policy='InstructorShared')

        data = {
            'publish': 'PrivateStudentAndFaculty',
            'inherit': 'true',
            'app_label': 'projects',
            'model': 'project',
            'obj_pk': project.id,
            'comment_html': 'Instructor Feedback'
        }
        request = RequestFactory().post('/discussion/create/', data)
        request.user = self.instructor_one
        request.course = self.sample_course
        request.collaboration_context, created = \
            Collaboration.objects.get_or_create(
                content_type=ContentType.objects.get_for_model(Course),
                object_pk=str(self.sample_course.pk))
        discussion_create(request)

        discussion = project.feedback_discussion()
        self.assertIsNotNone(discussion)
Beispiel #12
0
    def test_create_instructor_feedback(self):
        self.setup_sample_course()
        project = ProjectFactory.create(course=self.sample_course,
                                        author=self.student_one,
                                        policy='InstructorShared')

        data = {
            'publish': 'PrivateStudentAndFaculty',
            'inherit': 'true',
            'app_label': 'projects',
            'model': 'project',
            'obj_pk': project.id,
            'comment_html': 'Instructor Feedback'
        }
        request = RequestFactory().post('/discussion/create/', data)
        request.user = self.instructor_one
        request.course = self.sample_course
        request.collaboration_context, created = \
            Collaboration.objects.get_or_create(
                content_type=ContentType.objects.get_for_model(Course),
                object_pk=self.sample_course.pk)
        view = DiscussionCreateView()
        view.request = request
        view.post(request)

        discussion = project.feedback_discussion()
        self.assertIsNotNone(discussion)
Beispiel #13
0
    def test_scalar_super_no_redirect(self):
        request = RequestFactory().get('/')
        request.course = self.sample_course
        self.client.login(username=self.superuser.username, password='******')
        self.switch_course(self.client, self.sample_course)

        response = self.client.get("/asset/scalar/")
        self.assertFalse(isinstance(response, HttpResponseRedirect))
Beispiel #14
0
    def test_scalar_super_no_redirect(self):
        request = RequestFactory().get('/')
        request.course = self.sample_course
        self.client.login(username=self.superuser.username,
                          password='******')
        self.switch_course(self.client, self.sample_course)

        response = self.client.get("/asset/scalar/")
        self.assertFalse(isinstance(response, HttpResponseRedirect))
Beispiel #15
0
 def test_upgrade_bookmarklet(self):
     request = RequestFactory().get('/')
     request.course = self.sample_course
     request.user = self.student_one
     with self.settings(DJANGOSHERD_FLICKR_APIKEY='flickr api key'):
         response = upgrade_bookmarklet(request)
         self.assertEquals(response.status_code, 200)
         self.assertEquals(
             response.context_data['bookmarklet_vars']['flickr_apikey'],
             'flickr api key')
Beispiel #16
0
    def test_post_invalidcourse(self):
        data = {'fromCourse': 42}

        request = RequestFactory().post('/dashboard/migrate/', data)
        request.user = self.superuser
        request.course = self.sample_course

        view = MigrateCourseView()
        view.request = request

        self.assertRaises(Http404, view.post, request)
Beispiel #17
0
    def test_redirect_uploader_get_folder(self):
        request = RequestFactory().post('/upload/redirect')
        request.user = self.student_one
        request.course = self.sample_course

        view = RedirectToUploaderView()
        view.request = request
        self.assertEquals(view.get_upload_folder(), '')

        self.sample_course.add_detail(UPLOAD_FOLDER_KEY, 'z')
        self.assertEquals(view.get_upload_folder(), 'z')
Beispiel #18
0
    def test_parse_user(self):
        view = AssetCreateView()
        request = RequestFactory().get('/')
        request.course = self.sample_course

        # regular path
        request.user = self.student_one
        self.assertEquals(view.parse_user(request), self.student_one)

        # "as" without permissions
        request = RequestFactory().get('/', {'as': self.student_two.username})
        request.user = self.student_one
        request.course = self.sample_course
        self.assertEquals(view.parse_user(request), self.student_one)

        # "as" with permissions
        request.user = UserFactory(is_staff=True)
        request.course = self.sample_course
        self.add_as_faculty(request.course, request.user)
        self.assertEquals(view.parse_user(request), self.student_two)
Beispiel #19
0
    def test_parse_user(self):
        view = AssetCreateView()
        request = RequestFactory().get('/')
        request.course = self.sample_course

        # regular path
        request.user = self.student_one
        self.assertEquals(view.parse_user(request), self.student_one)

        # "as" without permissions
        request = RequestFactory().get('/', {'as': self.student_two.username})
        request.user = self.student_one
        request.course = self.sample_course
        self.assertEquals(view.parse_user(request), self.student_one)

        # "as" with permissions
        request.user = UserFactory(is_staff=True)
        request.course = self.sample_course
        self.add_as_faculty(request.course, request.user)
        self.assertEquals(view.parse_user(request), self.student_two)
Beispiel #20
0
    def test_asset_create_noasset(self):
        data = {'title': 'Bad Asset',
                'foobar': 'http://www.youtube.com/abcdefghi'}

        request = RequestFactory().post('/save/', data)
        request.user = self.instructor_one
        request.course = self.sample_course

        with self.assertRaises(AssertionError):
            view = AssetCreateView()
            view.request = request
            view.post(request)
Beispiel #21
0
 def create_discussion(self, course, instructor):
     data = {'comment_html': '%s Discussion' % course.title,
             'obj_pk': course.id,
             'model': 'course', 'app_label': 'courseaffils'}
     request = RequestFactory().post('/discussion/create/', data)
     request.user = instructor
     request.course = course
     request.collaboration_context, created = \
         Collaboration.objects.get_or_create(
             content_type=ContentType.objects.get_for_model(Course),
             object_pk=str(course.pk))
     return discussion_create(request)
Beispiel #22
0
    def test_post_invalidcourse(self):
        data = {
            'fromCourse': 23
        }

        request = RequestFactory().post('/dashboard/migrate/', data)
        request.user = self.superuser
        request.course = self.sample_course

        view = MigrateCourseView()
        view.request = request

        self.assertRaises(Http404, view.post, request)
Beispiel #23
0
    def test_render(self):
        self.setup_sample_course()
        self.create_discussion(self.sample_course, self.instructor_one)

        indicies = DiscussionIndex.objects.all()

        request = RequestFactory().get("/")
        request.course = self.sample_course
        request.user = self.instructor_one
        ctx = DiscussionIndexResource().render_list(request, indicies)
        self.assertTrue("references" in ctx)
        self.assertEquals(ctx["references"][0]["title"], "Sample Course Discussion")
        self.assertEquals(ctx["references"][0]["type"], "discussion")
Beispiel #24
0
    def test_asset_create_noasset(self):
        data = {'title': 'Bad Asset',
                'foobar': 'http://www.youtube.com/abcdefghi'}

        request = RequestFactory().post('/save/', data)
        request.user = User.objects.get(username='******')
        request.course = Course.objects.get(title='Sample Course')

        try:
            asset_create(request)
            self.fail("An assertion error should have been raised")
        except AssertionError:
            pass  # expected
Beispiel #25
0
    def test_asset_create_via_bookmarklet(self):
        data = {'title': 'YouTube Asset',
                'youtube': 'http://www.youtube.com/abcdefghi',
                'asset-source': 'bookmarklet'}

        request = RequestFactory().post('/save/', data)
        request.user = User.objects.get(username='******')
        request.course = Course.objects.get(title='Sample Course')

        response = asset_create(request)
        self.assertEquals(response.status_code, 200)

        Asset.objects.get(title='YouTube Asset')
Beispiel #26
0
    def test_render(self):
        self.setup_sample_course()
        self.create_discussion(self.sample_course, self.instructor_one)

        indicies = DiscussionIndex.objects.all()

        request = RequestFactory().get('/')
        request.course = self.sample_course
        request.user = self.instructor_one
        ctx = DiscussionIndexResource().render_list(request, indicies)
        self.assertTrue('references' in ctx)
        self.assertEquals(ctx['references'][0]['title'],
                          'Sample Course Discussion')
        self.assertEquals(ctx['references'][0]['type'], 'discussion')
Beispiel #27
0
    def test_render(self):
        self.setup_sample_course()
        self.create_discussion(self.sample_course, self.instructor_one)

        indicies = DiscussionIndex.objects.all()

        request = RequestFactory().get('/')
        request.course = self.sample_course
        request.user = self.instructor_one
        ctx = DiscussionIndexResource().render_list(request, indicies)
        self.assertTrue('references' in ctx)
        self.assertEquals(ctx['references'][0]['title'],
                          'Sample Course Discussion')
        self.assertEquals(ctx['references'][0]['type'], 'discussion')
Beispiel #28
0
    def test_get_context(self):
        request = RequestFactory().get('/dashboard/sources/')
        request.user = self.instructor_one
        request.course = self.sample_course

        view = CourseManageSourcesView()
        view.request = request

        ctx = view.get_context_data()
        self.assertEquals(ctx['course'], self.sample_course)
        self.assertEquals(list(ctx['suggested_collections']), [])
        self.assertEquals(ctx['space_viewer'], self.instructor_one)
        self.assertFalse(ctx['is_staff'])
        self.assertIsNotNone(ctx['uploader'])
Beispiel #29
0
    def test_asset_create_via_bookmarklet(self):
        data = {
            'title': 'YouTube Asset',
            'youtube': 'https://www.youtube.com/abcdefghi',
            'asset-source': 'bookmarklet'
        }

        request = RequestFactory().post('/save/', data)
        request.user = self.instructor_one
        request.course = self.sample_course

        view = AssetCreateView()
        view.request = request
        response = view.post(request)

        self.assertEquals(response.status_code, 200)
        Asset.objects.get(title='YouTube Asset')

        data = {
            'title': 'HTML5 video title',
            'asset-source': 'bookmarklet',
            'video': 'http://www.example.com/video.mp4',
            'video-metadata': 'w480h358',
            'metadata-description': 'Video description',
        }
        request = RequestFactory().post('/save/', data)
        request.user = self.instructor_one
        request.course = self.sample_course

        view = AssetCreateView()
        view.request = request
        response = view.post(request)

        self.assertEquals(response.status_code, 200)
        asset = Asset.objects.get(title='HTML5 video title')
        self.assertEquals(asset.metadata()['description'],
                          [data['metadata-description']])
Beispiel #30
0
    def test_migrate_project(self):
        self.project1 = ProjectFactory.create(course=self.sample_course,
                                              author=self.instructor_one,
                                              policy='PublicEditorsAreOwners')

        self.add_citation(self.project1, self.instructor_note)
        self.add_citation(self.project1, self.student_note)
        self.assertEquals(len(self.project1.citations()), 2)

        data = {
            'fromCourse': self.sample_course.id,
            'asset_ids[]': [],
            'project_ids[]': [self.project1.id]
        }

        # Migrate assets from SampleCourse into Alternate Course
        # test_instructor_three is a member of both courses
        request = RequestFactory().post('/dashboard/migrate/', data)
        request.user = self.instructor_three
        request.course = self.alt_course

        view = MigrateCourseView()
        view.request = request
        response = view.post(request)

        the_json = json.loads(response.content)
        self.assertTrue(the_json['success'])
        self.assertEquals(the_json['asset_count'], 1)
        self.assertEquals(the_json['project_count'], 1)
        self.assertEquals(the_json['note_count'], 2)

        new_asset = Asset.objects.get(course=self.alt_course,
                                      title=self.asset1.title)
        self.assertEquals(new_asset.sherdnote_set.count(), 3)

        new_note = new_asset.sherdnote_set.get(title=self.student_note.title)
        self.assertEquals(new_note.author, self.instructor_three)

        new_note = new_asset.sherdnote_set.get(
            title=self.instructor_note.title)
        self.assertEquals(new_note.author, self.instructor_three)

        new_note = new_asset.sherdnote_set.get(title=None)
        self.assertEquals(new_note.author, self.instructor_three)
        self.assertTrue(new_note.is_global_annotation())

        new_project = Project.objects.get(
            course=self.alt_course, title=self.project1.title)
        self.assertEquals(len(new_project.citations()), 2)
Beispiel #31
0
    def test_parse_user(self):
        request = RequestFactory().get('/')
        request.course = self.sample_course

        # regular path
        request.user = self.student_one
        self.assertEquals(_parse_user(request), self.student_one)

        # not a course member
        request.user = self.alt_student
        response = _parse_user(request)
        self.assertEquals(response.status_code, 403)

        # "as" without permissions
        request = RequestFactory().get('/', {'as': self.student_two.username})
        request.user = self.student_one
        request.course = self.sample_course
        self.assertEquals(_parse_user(request), self.student_one)

        # "as" with permissions
        request.user = UserFactory(is_staff=True)
        request.course = self.sample_course
        self.add_as_faculty(request.course, request.user)
        self.assertEquals(_parse_user(request), self.student_two)
Beispiel #32
0
    def test_annotation_delete(self):
        asset = AssetFactory(course=self.sample_course, primary_source='image')
        note = SherdNoteFactory(
            asset=asset, author=self.student_one,
            tags=',student_one_selection', range1=0, range2=1)

        request = RequestFactory().post('/')
        request.user = self.student_one
        request.course = self.sample_course

        response = annotation_delete(request, asset.id, note.id)
        self.assertEquals(response.status_code, 302)

        response = annotation_delete(request, asset.id, note.id)
        self.assertEquals(response.status_code, 404)
Beispiel #33
0
    def test_asset_create_via_bookmarklet(self):
        data = {'title': 'YouTube Asset',
                'youtube': 'http://www.youtube.com/abcdefghi',
                'asset-source': 'bookmarklet'}

        request = RequestFactory().post('/save/', data)
        request.user = self.instructor_one
        request.course = self.sample_course

        view = AssetCreateView()
        view.request = request
        response = view.post(request)

        self.assertEquals(response.status_code, 200)

        Asset.objects.get(title='YouTube Asset')
Beispiel #34
0
    def test_post_on_behalf_of_faculty(self):
        data = {
            'fromCourse': self.alt_course.id,
            'on_behalf_of': self.alt_instructor.id
        }

        request = RequestFactory().post('/dashboard/migrate/', data)
        request.user = self.superuser
        request.course = self.sample_course

        view = MigrateCourseView()
        view.request = request
        response = view.post(request)

        the_json = json.loads(response.content)
        self.assertFalse(the_json['success'])
Beispiel #35
0
    def test_post_on_behalf_of_student(self):
        student = User.objects.get(username='******')
        data = {
            'fromCourse': self.alt_course.id,
            'on_behalf_of': student.id
        }

        request = RequestFactory().post('/dashboard/migrate/', data)
        request.user = self.superuser
        request.course = self.sample_course

        view = MigrateCourseView()
        view.request = request
        response = view.post(request)

        the_json = json.loads(response.content)
        self.assertFalse(the_json['success'])
Beispiel #36
0
    def test_in_selection_assignment_response(self):
        res = SherdNoteResource()
        self.assertFalse(res.in_selection_assignment_response(self.note1))

        pn = ProjectNoteFactory(annotation=self.note1)
        pn.project.date_submitted = datetime.today()
        pn.project.save()
        self.assertTrue(res.in_selection_assignment_response(self.note1))

        request = RequestFactory().get('/?citable=true')
        request.user = self.student_one
        request.course = self.sample_course
        bundle = SherdNoteResource().build_bundle(obj=self.note1,
                                                  request=request)
        res.dehydrate(bundle)
        self.assertEquals(bundle.data['editable'], False)
        self.assertEquals(bundle.data['citable'], True)
Beispiel #37
0
    def test_in_selection_assignment_response(self):
        res = SherdNoteResource()
        self.assertFalse(res.in_selection_assignment_response(self.note1))

        pn = ProjectNoteFactory(annotation=self.note1)
        pn.project.date_submitted = datetime.today()
        pn.project.save()
        self.assertTrue(res.in_selection_assignment_response(self.note1))

        request = RequestFactory().get('/?citable=true')
        request.user = self.student_one
        request.course = self.sample_course
        bundle = SherdNoteResource().build_bundle(
            obj=self.note1, request=request)
        res.dehydrate(bundle)
        self.assertEquals(bundle.data['editable'], False)
        self.assertEquals(bundle.data['citable'], True)
Beispiel #38
0
    def test_post_on_behalf_of_faculty(self):
        teacher = User.objects.get(username='******')
        data = {
            'fromCourse': self.alt_course.id,
            'on_behalf_of': teacher.id
        }

        request = RequestFactory().post('/dashboard/migrate/', data)
        request.user = self.superuser
        request.course = self.sample_course

        view = MigrateCourseView()
        view.request = request
        response = view.post(request)

        the_json = json.loads(response.content)
        self.assertFalse(the_json['success'])
Beispiel #39
0
    def test_view_discussions(self):
        self.setup_sample_course()
        self.create_discussion(self.sample_course, self.instructor_one)
        discussions = get_course_discussions(self.sample_course)
        self.assertEquals(1, len(discussions))

        request = RequestFactory().get('/discussion/delete/', {})
        request.user = self.instructor_one
        request.course = self.sample_course
        request.collaboration_context, created = \
            Collaboration.objects.get_or_create(
                content_type=ContentType.objects.get_for_model(Course),
                object_pk=str(self.sample_course.pk))

        discussions = get_course_discussions(self.sample_course)
        response = discussion_view(request, discussions[0].id)
        self.assertEquals(response.status_code, 200)
Beispiel #40
0
    def test_annotation_delete(self):
        asset = AssetFactory(course=self.sample_course, primary_source='image')
        note = SherdNoteFactory(asset=asset,
                                author=self.student_one,
                                tags=',student_one_selection',
                                range1=0,
                                range2=1)

        request = RequestFactory().post('/')
        request.user = self.student_one
        request.course = self.sample_course

        response = annotation_delete(request, asset.id, note.id)
        self.assertEquals(response.status_code, 302)

        response = annotation_delete(request, asset.id, note.id)
        self.assertEquals(response.status_code, 404)
Beispiel #41
0
    def create_discussion(self, course, instructor):
        data = {
            'comment_html': '%s Discussion' % course.title,
            'obj_pk': course.id,
            'model': 'course',
            'app_label': 'courseaffils'
        }
        request = RequestFactory().post('/discussion/create/', data)
        request.user = instructor
        request.course = course
        request.collaboration_context, created = \
            Collaboration.objects.get_or_create(
                content_type=ContentType.objects.get_for_model(Course),
                object_pk=str(course.pk))
        response = discussion_create(request)

        parent_id = re.search(r'\d+', response.url).group()
        return ThreadedComment.objects.get(id=parent_id)
Beispiel #42
0
    def test_view_discussions(self):
        self.setup_sample_course()
        self.create_discussion(self.sample_course, self.instructor_one)
        discussions = get_course_discussions(self.sample_course)
        self.assertEquals(1, len(discussions))

        request = RequestFactory().get('/discussion/', {})
        request.user = self.instructor_one
        request.course = self.sample_course
        request.collaboration_context, created = \
            Collaboration.objects.get_or_create(
                content_type=ContentType.objects.get_for_model(Course),
                object_pk=self.sample_course.pk)

        view = DiscussionView()
        view.request = request
        response = view.get(request, discussion_id=discussions[0].id)
        self.assertEquals(response.status_code, 200)
Beispiel #43
0
    def test_annotation_create_global(self):
        asset = AssetFactory(course=self.sample_course, primary_source='image')
        request = RequestFactory().post('/', {},
                                        HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        request.user = self.student_one
        request.course = self.sample_course
        response = annotation_create_global(request, asset.id)
        self.assertEquals(response.status_code, 200)

        ga = asset.global_annotation(self.student_one, auto_create=False)
        self.assertIsNotNone(ga)

        the_json = loads(response.content)
        self.assertEquals(the_json['asset']['id'], asset.id)
        self.assertEquals(the_json['annotation']['id'], ga.id)

        # invalid asset
        with self.assertRaises(Http404):
            annotation_create_global(request, 1234)
Beispiel #44
0
    def test_annotation_create_global(self):
        asset = AssetFactory(course=self.sample_course, primary_source='image')
        request = RequestFactory().post('/', {},
                                        HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        request.user = self.student_one
        request.course = self.sample_course
        response = annotation_create_global(request, asset.id)
        self.assertEquals(response.status_code, 200)

        ga = asset.global_annotation(self.student_one, auto_create=False)
        self.assertIsNotNone(ga)

        the_json = loads(response.content)
        self.assertEquals(the_json['asset']['id'], asset.id)
        self.assertEquals(the_json['annotation']['id'], ga.id)

        # invalid asset
        with self.assertRaises(Http404):
            annotation_create_global(request, 1234)
Beispiel #45
0
    def test_get_my_response(self):
        view = SelectionAssignmentView()

        url = reverse('project-workspace', args=[self.assignment.id])
        request = RequestFactory().get(url)
        request.course = self.sample_course
        request.user = self.student_one
        view.request = request

        responses = self.assignment.responses(self.sample_course,
                                              self.student_one)
        self.assertIsNone(view.get_my_response(responses))

        response = ProjectFactory.create(
            course=self.sample_course, author=self.student_one,
            policy='PrivateEditorsAreOwners', parent=self.assignment)
        responses = self.assignment.responses(self.sample_course,
                                              self.student_one)
        self.assertEquals(response, view.get_my_response(responses))
Beispiel #46
0
    def test_vocabulary_validation(self):
        vv = VocabularyValidation()
        request = RequestFactory()
        request.course = self.sample_course

        mock_bundle = Bundle()
        mock_bundle.data['display_name'] = 'Shapes'
        mock_bundle.request = request

        errors = vv.is_valid(mock_bundle)
        self.assertTrue('error_message' in errors)
        self.assertTrue(
            'A Shapes concept exists' in errors['error_message'][0])

        mock_bundle = Bundle()
        mock_bundle.data['display_name'] = 'Patterns'
        mock_bundle.data['object_id'] = self.sample_course.id
        mock_bundle.request = request
        errors = vv.is_valid(mock_bundle)
        self.assertFalse('error_message' in errors)
Beispiel #47
0
    def test_vocabulary_validation(self):
        vv = VocabularyValidation()
        request = RequestFactory()
        request.course = self.sample_course

        mock_bundle = Bundle()
        mock_bundle.data['display_name'] = 'Shapes'
        mock_bundle.request = request

        errors = vv.is_valid(mock_bundle)
        self.assertTrue('error_message' in errors)
        self.assertTrue(
            'A Shapes concept exists' in errors['error_message'][0])

        mock_bundle = Bundle()
        mock_bundle.data['display_name'] = 'Patterns'
        mock_bundle.data['object_id'] = self.sample_course.id
        mock_bundle.request = request
        errors = vv.is_valid(mock_bundle)
        self.assertFalse('error_message' in errors)
Beispiel #48
0
    def test_annotation_create(self):
        data = {'annotation-title': 'Annotation Test',
                'annotation-body': 'notes go here',
                'annotation-annotation_data': '',
                'annotation-range1': -4.5, 'annotation-range2': 23,
                'annotation-tags': 'foo,bar'}
        request = RequestFactory().post('/', data)
        request.user = self.student_one
        request.course = self.sample_course

        with self.assertRaises(Http404):
            annotation_create(request, 1234)

        asset = AssetFactory(course=self.sample_course, primary_source='image')
        response = annotation_create(request, asset.id)
        self.assertEquals(response.status_code, 302)

        note = SherdNote.objects.get(title='Annotation Test', asset=asset)
        self.assertEquals(note.range1, -4.5)
        self.assertEquals(note.range2, 23)
        self.assertEquals(note.tags, 'foo,bar')
Beispiel #49
0
    def test_post(self):
        asset1 = Asset.objects.get(
            course=self.sample_course,
            title="The Armory - Home to CCNMTL'S CUMC Office")
        project1 = Project.objects.get(
            course=self.sample_course, title='Sample Course Assignment')
        data = {
            'fromCourse': self.sample_course.id,
            'asset_ids[]': [asset1.id],
            'project_ids[]': [project1.id]
        }

        # Migrate assets from SampleCourse into Alternate Course
        # test_instructor_two is a member of both courses
        request = RequestFactory().post('/dashboard/migrate/', data)
        request.user = User.objects.get(username='******')
        request.course = self.alt_course

        view = MigrateCourseView()
        view.request = request
        response = view.post(request)

        the_json = json.loads(response.content)
        self.assertTrue(the_json['success'])
        self.assertEquals(the_json['asset_count'], 4)
        self.assertEquals(the_json['project_count'], 1)
        self.assertEquals(the_json['note_count'], 6)

        Asset.objects.get(
            course=self.alt_course,
            title="The Armory - Home to CCNMTL'S CUMC Office")
        Asset.objects.get(
            course=self.alt_course,
            title="Mediathread: Introduction")
        Asset.objects.get(course=self.alt_course, title="MAAP Award Reception")
        Asset.objects.get(course=self.alt_course, title="Project Portfolio")

        project1 = Project.objects.get(
            course=self.alt_course, title='Sample Course Assignment')
        self.assertEquals(len(project1.citations()), 5)
Beispiel #50
0
    def test_view_discussions_ajax(self):
        self.setup_sample_course()
        self.create_discussion(self.sample_course, self.instructor_one)
        discussions = get_course_discussions(self.sample_course)
        self.assertEquals(1, len(discussions))

        request = RequestFactory().get('/discussion/', {},
                                       HTTP_X_REQUESTED_WITH='XMLHttpRequest')
        request.user = self.instructor_one
        request.course = self.sample_course
        request.collaboration_context, created = \
            Collaboration.objects.get_or_create(
                content_type=ContentType.objects.get_for_model(Course),
                object_pk=self.sample_course.pk)

        view = DiscussionView()
        view.request = request
        response = view.get(request, discussion_id=discussions[0].id)
        self.assertEquals(response.status_code, 200)

        the_json = loads(response.content)
        self.assertEquals(the_json['space_owner'],
                          self.instructor_one.username)
Beispiel #51
0
    def test_in_sequence_assignment_response(self):
        res = SherdNoteResource()
        self.assertFalse(res.in_sequence_assignment_response(self.note1))
        self.assertFalse(res.in_sequence_assignment_response(self.note2))

        sa = SequenceAssetFactory(spine=self.note1)
        psa = ProjectSequenceAssetFactory(sequence_asset=sa)
        self.assertFalse(res.in_sequence_assignment_response(self.note1))

        psa.project.date_submitted = datetime.today()
        psa.project.save()
        self.assertTrue(res.in_sequence_assignment_response(self.note1))

        SequenceMediaElementFactory(sequence_asset=sa, media=self.note2)
        self.assertTrue(res.in_sequence_assignment_response(self.note2))

        request = RequestFactory().get('/?citable=true')
        request.user = self.student_one
        request.course = self.sample_course
        bundle = SherdNoteResource().build_bundle(obj=self.note1,
                                                  request=request)
        res.dehydrate(bundle)
        self.assertEquals(bundle.data['editable'], False)
        self.assertEquals(bundle.data['citable'], True)
Beispiel #52
0
    def test_annotation_create(self):
        data = {
            'annotation-title': 'Annotation Test',
            'annotation-body': 'notes go here',
            'annotation-annotation_data': '',
            'annotation-range1': -4.5,
            'annotation-range2': 23,
            'annotation-tags': 'foo,bar'
        }
        request = RequestFactory().post('/', data)
        request.user = self.student_one
        request.course = self.sample_course

        with self.assertRaises(Http404):
            annotation_create(request, 1234)

        asset = AssetFactory(course=self.sample_course, primary_source='image')
        response = annotation_create(request, asset.id)
        self.assertEquals(response.status_code, 302)

        note = SherdNote.objects.get(title='Annotation Test', asset=asset)
        self.assertEquals(note.range1, -4.5)
        self.assertEquals(note.range2, 23)
        self.assertEquals(note.tags, 'foo,bar')
Beispiel #53
0
    def test_scalar_no_super_redirect(self):
        request = RequestFactory().get('/')
        request.course = self.sample_course

        response = self.client.get("/asset/scalar/")
        self.assertTrue(isinstance(response, HttpResponseRedirect))