Example #1
0
    def test_clone(self):
        g = GraphFactory(topic=self.topic)

        self.assertEqual(Graph.objects.count(), 1)

        r = self.client.get(
            reverse('cohort_graph_clone',
                    kwargs={
                        'cohort_pk': self.cohort.pk,
                        'pk': g.pk
                    }))
        self.assertEqual(r.status_code, 200)
        self.assertContains(r, 'Cloning <strong>{}</strong>'.format(g.title))

        # Clone it to this cohort.
        r = self.client.post(reverse('cohort_graph_clone',
                                     kwargs={
                                         'cohort_pk': self.cohort.pk,
                                         'pk': g.pk,
                                     }), {'course': self.cohort.pk},
                             follow=True)
        self.assertEqual(r.status_code, 200)
        self.assertContains(r, g.title)
        self.assertContains(r, 'copied to')
        self.assertContains(r, self.cohort.title)

        new_graph = Graph.objects.filter(topic=self.topic,
                                         title='{} (clone)'.format(
                                             g.title)).first()

        self.assertEqual(new_graph.title, g.title + ' (clone)')
        self.assertEqual(new_graph.topic, self.topic)
        self.assertEqual(new_graph.author, self.u)

        self.assertEqual(Graph.objects.count(), 2)

        # Clone it to a new cohort.
        new_cohort = CohortFactory()
        new_cohort.instructors.add(self.u)
        new_topic = new_cohort.get_general_topic()

        r = self.client.post(reverse('cohort_graph_clone',
                                     kwargs={
                                         'cohort_pk': new_cohort.pk,
                                         'pk': g.pk,
                                     }), {'course': new_cohort.pk},
                             follow=True)
        self.assertEqual(r.status_code, 200)
        self.assertContains(r, g.title)
        self.assertContains(r, 'copied to')
        self.assertContains(r, new_cohort.title)

        self.assertEqual(Graph.objects.count(), 3)

        new_graph = Graph.objects.filter(topic=new_topic,
                                         title=g.title).first()

        self.assertEqual(new_graph.title, g.title)
        self.assertEqual(new_graph.topic, new_topic)
        self.assertEqual(new_graph.author, self.u)
Example #2
0
class CohortTest(TestCase):
    def setUp(self):
        self.instructor = InstructorFactory()
        self.x = CohortFactory(instructors=(self.instructor, ))

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

    def test_clone(self):
        GraphFactory(topic=self.x.get_general_topic())
        GraphFactory(topic=self.x.get_general_topic())

        self.assertEqual(Graph.objects.count(), 2)
        self.assertEqual(Topic.objects.count(), 2)
        self.assertEqual(Cohort.objects.count(), 2)
        self.assertEqual(self.x.graph_count(), 2)
        cloned = self.x.clone()
        self.assertNotEqual(cloned.pk, self.x.pk)
        self.assertEqual(cloned.graph_count(), 2)
        self.assertEqual(Graph.objects.count(), 4)
        self.assertEqual(Topic.objects.count(), 3)
        self.assertEqual(Cohort.objects.count(), 3)

        # Test that cloning the sample course works too.
        sample = CohortFactory(is_sample=True)
        cloned = sample.clone()
        self.assertNotEqual(cloned.pk, sample.pk)
        self.assertFalse(cloned.is_sample)
        self.assertEqual(cloned.graph_count(), 0)
        self.assertEqual(Graph.objects.count(), 4)
        self.assertEqual(Topic.objects.count(), 5)
        self.assertEqual(Cohort.objects.count(), 5)