Beispiel #1
0
class TimelogTest(TestCase):
    @classmethod
    def setUpTestData(cls):
        # NOTE: if you modify those element they need to be created in setUp, instead of here
        cls.user = get_user_model().objects.create_user(
            'test', '*****@*****.**', 'test1234')
        cls.user2 = get_user_model().objects.create_user(
            'test2', '*****@*****.**', 'test1234')
        cls.user.save()
        cls.user2.save()

    def setUp(self):
        self.client.force_login(self.user)
        # NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
        self.project = Project(creator=self.user, name_short='PRJ')
        self.project.save()
        self.project.developer.add(self.user)
        self.project.developer.add(self.user2)
        # NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
        self.kanbancol = KanbanColumn(project=self.project,
                                      position=4,
                                      name='test')
        self.kanbancol.save()
        # NOTE: this element gets modified by some of those tests, so this shall NOT be created in setUpTestData()
        self.issue = Issue(
            title='a very very very very very very very long issue title',
            project=self.project,
            due_date='2016-12-16',
            kanbancol=self.kanbancol,
            storypoints='3')
        self.issue.save()
        self.issue2 = Issue(title='issue title',
                            project=self.project,
                            due_date='2016-12-16',
                            kanbancol=self.kanbancol,
                            storypoints='3')
        self.issue2.save()
        self.issue.assignee.add(self.user)

    def test_punch_in_out_0(self):
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(
            Timelog.objects.filter(user=self.user, issue=self.issue).exists(),
            False)
        self.assertEqual(
            Punch.objects.filter(user=self.user, issue=self.issue).exists(),
            True)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(
            Timelog.objects.filter(user=self.user, issue=self.issue).exists(),
            True)
        self.assertEqual(
            Punch.objects.filter(user=self.user, issue=self.issue).exists(),
            False)

    def test_punch_in_out_multiple_users_0(self):
        # mulitple users punch same issue
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.client.force_login(self.user2)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(Punch.objects.filter(issue=self.issue).count(), 2)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(Punch.objects.filter(issue=self.issue).count(), 1)
        self.client.force_login(self.user)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(Punch.objects.filter(issue=self.issue).count(), 0)
        self.assertEqual(Timelog.objects.filter(issue=self.issue).count(), 2)

        self.issue.assignee.add(self.user)

    def test_punch_in_out(self):
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(
            Timelog.objects.filter(user=self.user, issue=self.issue).exists(),
            False)
        self.assertEqual(
            Punch.objects.filter(user=self.user, issue=self.issue).exists(),
            True)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertContains(response, self.issue.get_ticket_identifier())
        self.assertEqual(
            Timelog.objects.filter(user=self.user, issue=self.issue).exists(),
            True)
        self.assertEqual(
            Punch.objects.filter(user=self.user, issue=self.issue).exists(),
            False)

    def test_punch_in_out_multiple_users(self):
        # mulitple users punch same issue
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.client.force_login(self.user2)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(Punch.objects.filter(issue=self.issue).count(), 2)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(Punch.objects.filter(issue=self.issue).count(), 1)
        self.client.force_login(self.user)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        self.assertEqual(Punch.objects.filter(issue=self.issue).count(), 0)
        self.assertEqual(Timelog.objects.filter(issue=self.issue).count(), 2)

    def test_punch_in_on_multiple_issues_not_possible(self):
        # mulitple users punch same issue
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue.project.name_short,
                                                "sqn_i": self.issue.number
                                            }),
                                    follow=True)
        response = self.client.post(reverse('issue:punch',
                                            kwargs={
                                                "project":
                                                self.issue2.project.name_short,
                                                "sqn_i": self.issue2.number
                                            }),
                                    follow=True)
        self.assertContains(response, self.issue.get_ticket_identifier())