Example #1
0
    def test_list(self):
        SequenceAssetFactory()
        SequenceAssetFactory()

        r = self.client.get(reverse('sequenceasset-list'), format='json')
        self.assertEqual(r.status_code, 200)
        self.assertEqual(len(r.data), 2)
Example #2
0
    def test_update_someone_elses_sequence_asset(self):
        someone_else = UserFactory()
        sa = SequenceAssetFactory(author=someone_else)
        psa = ProjectSequenceAssetFactory(sequence_asset=sa)
        note = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'project': psa.project.pk,
                'spine': note.pk,
                'spine_volume': 100,
                'media_elements': [],
                'text_elements': [
                    {
                        'text': 'My text',
                        'start_time': Decimal('0'),
                        'end_time': Decimal('10'),
                    }
                ],
            }, format='json')

        self.assertEqual(r.status_code, 403)

        sa.refresh_from_db()
        self.assertEqual(sa.course, sa.course)
        self.assertEqual(sa.author, someone_else)
        self.assertEqual(sa.spine, None)
        self.assertEqual(sa.spine_volume, 80)
        self.assertEqual(SequenceAsset.objects.count(), 1)
        self.assertEqual(ProjectSequenceAsset.objects.count(), 1)
        self.assertEqual(SequenceTextElement.objects.count(), 0)
Example #3
0
    def test_update_someone_elses_sequence_asset(self):
        someone_else = UserFactory()
        sa = SequenceAssetFactory(author=someone_else)
        psa = ProjectSequenceAssetFactory(sequence_asset=sa)
        note = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'project': psa.project.pk,
                'spine': note.pk,
                'media_elements': [],
                'text_elements': [
                    {
                        'text': 'My text',
                        'start_time': 0,
                        'end_time': 10,
                    }
                ],
            }, format='json')

        self.assertEqual(r.status_code, 403)

        sa.refresh_from_db()
        self.assertEqual(sa.course, sa.course)
        self.assertEqual(sa.author, someone_else)
        self.assertEqual(sa.spine, None)
        self.assertEqual(SequenceAsset.objects.count(), 1)
        self.assertEqual(ProjectSequenceAsset.objects.count(), 1)
        self.assertEqual(SequenceTextElement.objects.count(), 0)
Example #4
0
    def test_list(self):
        ProjectSequenceAssetFactory(sequence_asset=SequenceAssetFactory(
            author=self.u))
        ProjectSequenceAssetFactory(sequence_asset=SequenceAssetFactory(
            author=self.u))
        ProjectSequenceAssetFactory(sequence_asset=SequenceAssetFactory(
            author=self.u))
        ProjectSequenceAssetFactory()

        r = self.client.get(reverse('projectsequenceasset-list'))
        self.assertEqual(r.status_code, 200)
        self.assertEqual(len(r.data), 3)
Example #5
0
    def test_sequence(self):
        sa = SequenceAssetFactory(spine=self.note)
        ProjectSequenceAssetFactory(project=self.project, sequence_asset=sa)
        SequenceMediaElementFactory(sequence_asset=sa, media=self.note2)

        self.update_references()

        indicies = DiscussionIndex.objects.all()
        self.assertEquals(indicies.count(), 2)

        index = indicies[0]
        self.assertIsNone(index.participant)
        self.assertIsNone(index.comment)
        self.assertEquals(index.collaboration, self.collaboration)
        self.assertEquals(index.asset, self.asset)

        self.assertEquals(index.get_type_label(), 'project')
        self.assertEquals(index.content_object, self.asset)
        self.assertEquals(index.clump_parent(), self.project)
        self.assertIsNone(index.get_parent_url())
        self.assertEquals(index.body, '')

        index = indicies[1]
        self.assertIsNone(index.participant)
        self.assertIsNone(index.comment)
        self.assertEquals(index.collaboration, self.collaboration)
        self.assertEquals(index.asset, self.asset2)

        self.assertEquals(index.get_type_label(), 'project')
        self.assertEquals(index.content_object, self.asset2)
        self.assertEquals(index.clump_parent(), self.project)
        self.assertIsNone(index.get_parent_url())
        self.assertEquals(index.body, '')
Example #6
0
    def test_retrieve(self):
        asset = SequenceAssetFactory()
        r = self.client.get(
            reverse('sequenceasset-detail', args=(asset.pk,)), format='json'
        )
        self.assertEqual(r.status_code, 200)
        self.assertIsNone(r.data.get('spine'))
        self.assertEqual(r.data.get('id'), asset.pk)

        note = SherdNoteFactory()
        asset = SequenceAssetFactory(spine=note)
        r = self.client.get(
            reverse('sequenceasset-detail', args=(asset.pk,)), format='json'
        )
        self.assertEqual(r.status_code, 200)
        self.assertEqual(r.data.get('spine')['id'], note.pk)
Example #7
0
    def test_retrieve(self):
        asset = SequenceAssetFactory(author=self.u)
        r = self.client.get(
            reverse('sequenceasset-detail', args=(asset.pk,)), format='json'
        )
        self.assertEqual(r.status_code, 200)
        self.assertIsNone(r.data.get('spine'))
        self.assertEqual(r.data.get('id'), asset.pk)

        note = SherdNoteFactory()
        asset = SequenceAssetFactory(author=self.u, spine=note)
        r = self.client.get(
            reverse('sequenceasset-detail', args=(asset.pk,)), format='json'
        )
        self.assertEqual(r.status_code, 200)
        the_json = loads(r.content)
        self.assertEqual(the_json['spine']['id'], note.pk)
        self.assertEqual(the_json['spine_asset'], note.asset.pk)
Example #8
0
class SequenceAssetTest(TestCase):
    def setUp(self):
        self.asset = SequenceAssetFactory()

    def test_is_valid_from_factory(self):
        self.asset.full_clean()

    def test_update_track_elements(self):
        self.asset.update_track_elements([], [])
        self.assertEqual(SequenceMediaElement.objects.count(), 0)
        self.assertEqual(SequenceTextElement.objects.count(), 0)

        media_track = []
        for i in range(3):
            e = SequenceMediaElementFactory(sequence_asset=self.asset)
            media_track.append({"start_time": i, "end_time": i + 0.5, "media": e.media})

        text_track = []
        for i in range(4):
            e = SequenceTextElementFactory(sequence_asset=self.asset)
            text_track.append({"start_time": i, "end_time": i + 0.5, "text": "text {}".format(i)})

        self.asset.update_track_elements(media_track, text_track)
        self.assertEqual(SequenceMediaElement.objects.count(), 3)
        self.assertEqual(SequenceTextElement.objects.count(), 4)

        el0 = SequenceTextElement.objects.filter(text="text 0").first()
        self.assertEqual(el0.start_time, 0)
        self.assertEqual(el0.end_time, 0.5)
        self.assertEqual(el0.sequence_asset, self.asset)
Example #9
0
    def test_update(self):
        sa = SequenceAssetFactory(author=self.u)
        psa = ProjectSequenceAssetFactory(sequence_asset=sa)
        note = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'project': psa.project.pk,
                'spine': note.pk,
                'media_elements': [],
                'text_elements': [],
            }, format='json')

        self.assertEqual(r.status_code, 200)

        sa.refresh_from_db()
        self.assertEqual(sa.course, sa.course)
        self.assertEqual(sa.author, self.u)
        self.assertEqual(sa.spine, note)
        self.assertEqual(SequenceAsset.objects.count(), 1)
        self.assertEqual(ProjectSequenceAsset.objects.count(), 1)
Example #10
0
    def test_update(self):
        sa = SequenceAssetFactory(author=self.u)
        psa = ProjectSequenceAssetFactory(sequence_asset=sa)
        note = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'project': psa.project.pk,
                'spine': note.pk,
                'media_elements': [],
                'text_elements': [],
            }, format='json')

        self.assertEqual(r.status_code, 200)

        sa.refresh_from_db()
        self.assertEqual(sa.course, sa.course)
        self.assertEqual(sa.author, self.u)
        self.assertEqual(sa.spine, note)
        self.assertEqual(SequenceAsset.objects.count(), 1)
        self.assertEqual(ProjectSequenceAsset.objects.count(), 1)
Example #11
0
    def test_update(self):
        author = UserFactory()
        sa = SequenceAssetFactory(author=author)
        note = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'author': sa.author.pk,
                'spine': note.pk,
                'media_elements': [],
                'text_elements': [],
            }, format='json')

        self.assertEqual(r.status_code, 403)
Example #12
0
 def test_retrieve_with_text_elements(self):
     note = SherdNoteFactory()
     asset = SequenceAssetFactory(author=self.u, spine=note)
     e1 = SequenceTextElementFactory(sequence_asset=asset)
     e2 = SequenceTextElementFactory(sequence_asset=asset)
     e3 = SequenceTextElementFactory(sequence_asset=asset)
     r = self.client.get(
         reverse('sequenceasset-detail', args=(asset.pk,)), format='json'
     )
     self.assertEqual(r.status_code, 200)
     the_json = loads(r.content)
     self.assertEqual(the_json['spine']['id'], note.pk)
     textelements = the_json['text_elements']
     self.assertEqual(textelements[0]['text'], e1.text)
     self.assertEqual(textelements[1]['text'], e2.text)
     self.assertEqual(textelements[2]['text'], e3.text)
Example #13
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)
Example #14
0
class SequenceAssetTest(TestCase):
    def setUp(self):
        self.asset = SequenceAssetFactory()

    def test_is_valid_from_factory(self):
        self.asset.full_clean()

    def test_update_track_elements(self):
        self.asset.update_track_elements([], [])
        self.assertEqual(SequenceMediaElement.objects.count(), 0)
        self.assertEqual(SequenceTextElement.objects.count(), 0)

        media_track = []
        for i in range(3):
            e = SequenceMediaElementFactory(sequence_asset=self.asset)
            media_track.append({
                'start_time': i,
                'end_time': i + 0.5,
                'media': e.media,
            })

        text_track = []
        for i in range(4):
            e = SequenceTextElementFactory(sequence_asset=self.asset)
            text_track.append({
                'start_time': i,
                'end_time': i + 0.5,
                'text': 'text {}'.format(i),
            })

        self.asset.update_track_elements(media_track, text_track)
        self.assertEqual(SequenceMediaElement.objects.count(), 3)
        self.assertEqual(SequenceTextElement.objects.count(), 4)

        el0 = SequenceTextElement.objects.filter(text='text 0').first()
        self.assertEqual(el0.start_time, 0)
        self.assertEqual(el0.end_time, 0.5)
        self.assertEqual(el0.sequence_asset, self.asset)
Example #15
0
 def setUp(self):
     self.asset = SequenceAssetFactory()
Example #16
0
    def test_update_with_track_elements(self):
        sa = SequenceAssetFactory(author=self.u)
        psa = ProjectSequenceAssetFactory(sequence_asset=sa)
        note = SherdNoteFactory()
        element_note = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'project': psa.project.pk,
                'spine': note.pk,
                'media_elements': [
                    {
                        'media': element_note.pk,
                        'start_time': 0,
                        'end_time': 10,
                    }
                ],
                'text_elements': [
                    {
                        'text': 'My text',
                        'start_time': 0,
                        'end_time': 10,
                    }
                ]
            }, format='json')

        self.assertEqual(r.status_code, 200)

        sa.refresh_from_db()
        self.assertEqual(sa.course, sa.course)
        self.assertEqual(sa.author, self.u)
        self.assertEqual(sa.spine, note)

        self.assertEqual(SequenceMediaElement.objects.count(), 1)
        self.assertEqual(SequenceTextElement.objects.count(), 1)

        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'spine': note.pk,
                'media_elements': [
                    {
                        'media': element_note.pk,
                        'start_time': 0,
                        'end_time': 10,
                    }
                ],
                'text_elements': [
                    {
                        'text': 'My text',
                        'start_time': 0,
                        'end_time': 10,
                    }
                ]
            }, format='json')

        self.assertEqual(r.status_code, 200)

        sa.refresh_from_db()
        self.assertEqual(sa.course, sa.course)
        self.assertEqual(sa.author, self.u)
        self.assertEqual(sa.spine, note)

        self.assertEqual(SequenceMediaElement.objects.count(), 1)
        self.assertEqual(SequenceTextElement.objects.count(), 1)
Example #17
0
 def setUp(self):
     self.asset = SequenceAssetFactory()
Example #18
0
    def test_update_with_track_elements(self):
        sa = SequenceAssetFactory(author=self.u)
        psa = ProjectSequenceAssetFactory(sequence_asset=sa)
        note = SherdNoteFactory()
        element_note = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'project': psa.project.pk,
                'spine': note.pk,
                'spine_volume': 0,
                'media_elements': [
                    {
                        'media': element_note.pk,
                        'start_time': Decimal('0'),
                        'end_time': Decimal('10'),
                        'volume': 0,
                    }
                ],
                'text_elements': [
                    {
                        'text': 'My text',
                        'start_time': Decimal('0'),
                        'end_time': Decimal('10'),
                    }
                ]
            }, format='json')

        self.assertEqual(r.status_code, 200)

        sa.refresh_from_db()
        self.assertEqual(sa.course, sa.course)
        self.assertEqual(sa.author, self.u)
        self.assertEqual(sa.spine, note)
        self.assertEqual(sa.spine_volume, 0)

        self.assertEqual(SequenceMediaElement.objects.count(), 1)
        element = SequenceMediaElement.objects.first()
        self.assertEqual(element.volume, 0)
        self.assertEqual(SequenceTextElement.objects.count(), 1)

        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'spine': note.pk,
                'spine_volume': 65,
                'media_elements': [
                    {
                        'media': element_note.pk,
                        'start_time': Decimal('0'),
                        'end_time': Decimal('10'),
                        'volume': 30,
                    }
                ],
                'text_elements': [
                    {
                        'text': 'My text',
                        'start_time': Decimal('0'),
                        'end_time': Decimal('10'),
                    },
                    {
                        'text': 'My text',
                        'start_time': Decimal('10'),
                        'end_time': Decimal('12'),
                    }
                ]
            }, format='json')

        self.assertEqual(r.status_code, 200)

        sa.refresh_from_db()
        self.assertEqual(sa.course, sa.course)
        self.assertEqual(sa.author, self.u)
        self.assertEqual(sa.spine, note)
        self.assertEqual(sa.spine_volume, 65)

        self.assertEqual(SequenceMediaElement.objects.count(), 1)
        element = SequenceMediaElement.objects.first()
        self.assertEqual(element.volume, 30)
        self.assertEqual(SequenceTextElement.objects.count(), 2)
Example #19
0
    def test_update_with_overlapping_elements(self):
        sa = SequenceAssetFactory(author=self.u)
        note = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'spine': note.pk,
                'media_elements': [
                ],
                'text_elements': [
                    {
                        'text': 'My text',
                        'start_time': Decimal('0'),
                        'end_time': Decimal('0.3'),
                    },
                    {
                        'text': 'My text',
                        'start_time': Decimal('0.35'),
                        'end_time': Decimal('0.5'),
                    },
                    {
                        'text': 'My text',
                        'start_time': Decimal('0.55'),
                        'end_time': Decimal('0.9'),
                    },
                    {
                        'text': 'My text',
                        'start_time': Decimal('1'),
                        'end_time': Decimal('11'),
                    },
                    {
                        'text': 'Overlapping!',
                        'start_time': Decimal('2'),
                        'end_time': Decimal('12'),
                    }
                ]
            }, format='json')

        self.assertEqual(r.status_code, 400)
        self.assertEqual(SequenceTextElement.objects.count(), 0)

        note = SherdNoteFactory()
        media_note1 = SherdNoteFactory()
        media_note2 = SherdNoteFactory()
        r = self.client.put(
            reverse('sequenceasset-detail', args=(sa.pk,)),
            {
                'course': sa.course.pk,
                'spine': note.pk,
                'media_elements': [
                    {
                        'media': media_note1.pk,
                        'start_time': Decimal('0'),
                        'end_time': Decimal('10'),
                    },
                    {
                        'media': media_note2.pk,
                        'start_time': Decimal('1'),
                        'end_time': Decimal('11'),
                    }
                ],
                'text_elements': [
                ]
            }, format='json')

        self.assertEqual(r.status_code, 400)
        self.assertEqual(SequenceMediaElement.objects.count(), 0)