Пример #1
0
    def create_cohorts(self):

        self.cohort_lvl_2 = CertificationCohort.objects.create(
            date=string_to_datetime(faker.date()),
            certification=ExOCertification.objects.get(
                level=settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2),
            seats=25,
            price=1500,
            status=settings.EXO_CERTIFICATION_COHORT_STATUS_CH_OPEN,
            invoice_concept=' '.join(faker.words()),
        )
        self.cohort_lvl_2_ft = CertificationCohort.objects.create(
            date=string_to_datetime(faker.date()),
            certification=ExOCertification.objects.get(
                level=settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2A),
            seats=25,
            price=1500,
            status=settings.EXO_CERTIFICATION_COHORT_STATUS_CH_OPEN,
            invoice_concept=' '.join(faker.words()),
        )
        self.cohort_lvl_3 = CertificationCohort.objects.create(
            date=string_to_datetime(faker.date()),
            certification=ExOCertification.objects.get(
                level=settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_3),
            seats=25,
            price=2500,
            first_price_tier=1250,
            status=settings.EXO_CERTIFICATION_COHORT_STATUS_CH_OPEN,
            invoice_concept=' '.join(faker.words()),
        )
Пример #2
0
    def test_circle_feed(self):
        # PREPARE DATA
        team = FakeTeamFactory.create()
        participant = FakeUserFactory.create(password='******', is_active=True)
        self.add_user_to_team(participant, team)
        user = self.consultant.user
        user.is_staff = True
        user.save()

        questions = []
        for i in range(2):
            questions.append(
                Post.objects.create_project_team_post(title=' '.join(
                    faker.words()),
                                                      user_from=participant,
                                                      team=team))

        announcements = []
        for i in range(3):
            announcements.append(
                Post.objects.create_announcement_post(
                    user_from=self.super_user,
                    title=' '.join(faker.words()),
                    description=faker.text()))

        posts = []
        for i in range(4):
            posts.append(
                Post.objects.create_circle_post(
                    circle=Circle.objects.get(slug='ecosystem'),
                    user_from=self.super_user,
                    title=' '.join(faker.words()),
                    description=faker.text()))

        posts.append(
            Post.objects.create_circle_post(
                circle=Circle.objects.get(slug='trainers'),
                user_from=self.consultant.user,
                title=' '.join(faker.words()),
                description=faker.text()))

        posts[0].reply(user_from=self.consultant.user, comment=faker.text())
        announcements[0].reply(user_from=self.consultant.user,
                               comment=faker.text())
        questions[0].reply(user_from=self.consultant.user,
                           comment=faker.text())

        url = reverse('api:forum:feed')

        # DO ACTION
        self.client.login(username=self.consultant.user.username,
                          password='******')
        response = self.client.get(url)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        data = response.json()
        self.assertEqual(data.get('count'), 10)
    def test_get_posts_from_team(self):
        # PREPARE DATA
        team_1 = FakeTeamFactory.create()
        team_2 = FakeTeamFactory.create()
        user_team_1 = self.user
        user_team_2 = FakeUserFactory.create(password='******', is_active=True)
        self.add_user_to_team(user_team_1, team_1)
        self.add_user_to_team(user_team_2, team_2)
        search = 'tosearch'
        post_A_team_1 = Post.objects.create_project_team_post(
            title='{} {}'.format(' '.join(faker.words()), search),
            user_from=user_team_1,
            team=team_1)
        Post.objects.create_project_team_post(title=' '.join(faker.words()),
                                              user_from=user_team_1,
                                              team=team_1)
        post_team_2 = Post.objects.create_project_team_post(
            title=' '.join(faker.words()), user_from=user_team_2, team=team_2)

        url_team_1 = reverse('api:forum:questions-team-list',
                             kwargs={
                                 'project_pk': team_1.project.pk,
                                 'team_pk': team_1.pk
                             })
        url_team_2 = reverse('api:forum:questions-team-list',
                             kwargs={
                                 'project_pk': team_2.project.pk,
                                 'team_pk': team_2.pk
                             })

        # DO ACTION
        self.client.login(username=user_team_1.username, password='******')
        response = self.client.get(url_team_1)
        response_search = self.client.get(url_team_1, data={'search': search})

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        self.assertEqual(response.data.get('count'), 2)
        self.assertTrue(status.is_success(response_search.status_code))
        self.assertEqual(response_search.data.get('count'), 1)
        self.assertEqual(post_A_team_1.pk,
                         response_search.data.get('results')[0].get('pk'))
        self.assertEqual(post_A_team_1.title,
                         response_search.data.get('results')[0].get('title'))
        self.assertEqual(post_A_team_1.description,
                         response.data.get('results')[0].get('description'))

        # DO ACTION
        self.client.login(username=user_team_2.username, password='******')
        response = self.client.get(url_team_2)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        self.assertEqual(response.data.get('count'), 1)
        self.assertEqual(post_team_2.pk,
                         response.data.get('results')[0].get('pk'))
Пример #4
0
    def test_create_post_in_announcements_fail(self):
        # PREPARE DATA
        circle_slug = 'announcements'
        url = reverse('api:circles:circles-create',
                      kwargs={'slug': circle_slug})
        consultant = FakeConsultantFactory.create(user__is_active=True,
                                                  user__password='******')
        keyword = FakeKeywordFactory.create()
        num_files = 2
        payload = {
            'title':
            ' '.join(faker.words()),
            'description':
            faker.text(),
            'tags': [
                {
                    'pk': keyword.pk,
                    'name': keyword.name,
                },
                {
                    'name': faker.word() + faker.numerify(),
                },
            ],
            'uploaded_files':
            self.get_files_example(num_files),
        }

        # DO ACTION
        self.client.login(username=consultant.user.username, password='******')
        response = self.client.post(url, data=payload)

        # ASSERTS
        self.assertTrue(status.is_client_error(response.status_code))
Пример #5
0
    def test_post_list_from_circle_removed(self):
        # PREPARE DATA
        consultant = FakeConsultantFactory.create(user__is_active=True,
                                                  user__password='******')
        circle = Circle.objects.get(name=settings.CIRCLES_ECOSYSTEM_NAME)
        circle.add_user(consultant.user)
        self.client.login(username=consultant.user.username, password='******')

        for i in range(5):
            Post.objects.create_circle_post(user_from=self.super_user,
                                            circle=circle,
                                            title=' '.join(faker.words()),
                                            description=faker.text())

        url = reverse('api:forum:circle-post-list',
                      kwargs={'circle_slug': circle.slug})

        # DO ACTION
        response = self.client.get(url)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))

        # DO ACTION
        circle.mark_as_removed()
        response = self.client.get(url)

        # ASSERTS
        self.assertTrue(status.is_client_error(response.status_code))
        self.assertEqual(response.status_code, status.HTTP_410_GONE)
 def handle(self, *args, **options):
     self.stdout.write('\n Creating Questions/Answers for testing: \n\n')
     consultants = Consultant.objects.all()
     exo_consulting = ExOActivity.objects.get(code=settings.EXO_ACTIVITY_CH_ACTIVITY_CONSULTING)
     for project in Project.objects.filter(teams__isnull=False):
         users = User.objects.filter(teams__project=project)
         if not users:
             continue
         self.stdout.write('\n Creating questions for %s' % str(project))
         for i in range(random.randint(2, 10)):
             user = random.choices(users, k=1)[0]
             try:
                 post = Post.objects.create_project_team_post(
                     user_from=user,
                     team=user.teams.filter(project=project).first(),
                     title=' '.join(faker.words()),
                     description=faker.text(),
                     tags=random.choices(
                         Keyword.objects.all(), k=random.randint(2, 6)),
                 )
             except Exception:
                 continue
             for consultant in set(random.choices(consultants, k=random.randint(2, 10))):
                 exo_activity, _ = consultant.exo_profile.exo_activities.get_or_create(
                     exo_activity=exo_consulting)
                 exo_activity.enable()
                 post.see(consultant.user)
             for consultant in set(random.choices(consultants, k=random.randint(2, 10))):
                 exo_activity, _ = consultant.exo_profile.exo_activities.get_or_create(
                     exo_activity=exo_consulting)
                 exo_activity.enable()
                 post.see(consultant.user)
                 post.reply(consultant.user, faker.text())
     self.stdout.write('\n Finish!! \n\n')
Пример #7
0
    def test_create_post_with_one_mention(self):
        # PREPARE DATA
        self.circle = Circle.objects.first()
        self.user.hubs.create(hub=self.circle.hub)
        user_mentioned = FakeUserFactory.create(is_active=True)
        description = '<a {}="{}" {}="{}">{}</a>'.format(
            DEFAULT_TYPE_PATTERN,
            user_mentioned.__class__.__name__,
            DEFAULT_UUID_PATTERN,
            user_mentioned.pk,
            user_mentioned.short_name,
        )

        post = Post.objects.create_circle_post(user_from=self.user,
                                               circle=self.circle,
                                               title=' '.join(faker.words()),
                                               description=description)
        post_id = post.pk

        # DO ACTIONS
        self.post = Post.objects.get(pk=post_id)

        # ASSERTS
        self.assertTrue(self.user.actor_actions.all().filter(
            verb=settings.MENTION_VERB).exists())
        self.assertEqual(
            self.user.actor_actions.all().filter(
                verb=settings.MENTION_VERB).count(), 1)
Пример #8
0
    def test_create_answer_with_mentions(self):
        # PREPARE DATA
        self.circle = Circle.objects.first()
        self.user.hubs.create(hub=self.circle.hub)
        post = Post.objects.create_circle_post(user_from=self.user,
                                               circle=self.circle,
                                               title=' '.join(faker.words()),
                                               description=faker.text())
        post_id = post.pk
        self.post = Post.objects.get(pk=post_id)

        user = FakeUserFactory.create(is_active=True, password='******')
        self.circle.add_user(user)
        user_mentioned = FakeUserFactory.create(is_active=True)

        reply_comment = 'Hi \
        <a {}="{}" {}="{}">{}</a> \
        '.format(
            DEFAULT_TYPE_PATTERN,
            user_mentioned.__class__.__name__,
            DEFAULT_UUID_PATTERN,
            user_mentioned.pk,
            user_mentioned.short_name,
        )

        # DO ACTIONS
        self.answer = self.post.reply(user, reply_comment)

        # ASSERTS
        self.assertTrue(user.actor_actions.all().filter(
            verb=settings.MENTION_VERB).exists())
Пример #9
0
 def handle(self, *args, **options):
     self.stdout.write('\n Creating Post/Answers for testing: \n\n')
     consultants = Consultant.objects.all()
     for circle in Circle.objects.all():
         users = followers(circle)
         if len(users) < 5:
             for consultant in set(
                     random.choices(consultants, k=random.randint(2, 10))):
                 circle.add_user(consultant.user)
             users = followers(circle)
         for i in range(random.randint(2, 10)):
             user = random.choices(users, k=1)[0]
             post = Post.objects.create_circle_post(
                 user_from=user,
                 circle=circle,
                 title=' '.join(faker.words()),
                 description=faker.text(),
                 tags=random.choices(Keyword.objects.all(),
                                     k=random.randint(2, 6)),
             )
             for consultant in set(
                     random.choices(consultants, k=random.randint(2, 10))):
                 post.see(consultant.user)
             for consultant in set(
                     random.choices(consultants, k=random.randint(2, 10))):
                 post.see(consultant.user)
                 post.reply(consultant.user, faker.text())
     self.stdout.write('\n Finish!! \n\n')
Пример #10
0
 def certificate_consultant(self, email, _type, user_from):
     certificate = create_certificates.Command()
     course_name = faker.word()
     consultant_role_group = certificate.create_consultant_role_group(
         user_from=user_from,
         name=course_name,
         description=' '.join(faker.words()),
         issued_on=datetime.now(),
         _type=_type,
     )
     certificate.create_consultant_roles(
         emails=[email],
         role_code=certificate.get_role_code(_type),
         consultant_role_group=consultant_role_group,
     )
     data = {
         'name': consultant_role_group.name,
         'description': consultant_role_group.description,
         'content_object': consultant_role_group,
         '_type': consultant_role_group._type,
         'created_by': user_from,
         'instructor_name': user_from.get_full_name(),
     }
     data['issued_on'] = consultant_role_group.issued_on
     data['course_name'] = course_name
     CertificationGroup.objects.create_group_and_credentials(
         user_from=user_from,
         related_objects_list=consultant_role_group.consultant_roles.all(),
         **data)
Пример #11
0
    def test_question_create_success(self):
        # PREPARE DATA
        query_params = {
            'project_id': self.qa_session_first.project.pk,
            'team_id': self.team_A.pk,
            'swarm_id': self.qa_session_first.teams.get(team=self.team_A).pk,
        }
        url = reverse('api:swarms:swarms-project-questions-list',
                      kwargs=query_params)

        keyword = FakeKeywordFactory.create()
        new_post = {
            'title': ' '.join(faker.words()),
            'description': faker.text(),
            'tags': [{
                'pk': keyword.pk,
                'name': keyword.name,
            }],
            'uploaded_files': self.get_files_example(2),
        }

        # DO ACTION
        self.client.login(username=self.user.username, password='******')
        response = self.client.post(url, data=new_post)

        # ASSERTS
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        data = response.json()
        self.assertIsNotNone(data.get('pk', None))
        self.assertEqual(data.get('title'), new_post.get('title'))
        self.assertEqual(data.get('description'), new_post.get('description'))
        self.assertEqual(len(data.get('tags', [])),
                         len(new_post.get('tags', [])))
        self.assertEqual(len(data.get('uploadedFiles', [])),
                         len(new_post.get('uploaded_files', [])))
Пример #12
0
    def test_update_answer_team_project(self, answer_emails_task_mock):
        # PREPARE DATA
        sprint = FakeSprintAutomatedFactory.create(
            status=settings.PROJECT_CH_PROJECT_STATUS_WAITING)
        new_team = FakeTeamFactory.create(project=sprint.project_ptr)
        new_team.add_member(
            user_from=self.super_user,
            email=self.user.email,
            name=self.user.short_name,
        )
        post = Post.objects.create_project_team_post(
            user_from=self.super_user,
            team=new_team,
            title=' '.join(faker.words()),
            description=faker.text(),
        )
        answer = post.reply(self.user, faker.text())
        url = reverse('api:forum:answer-detail', kwargs={'pk': answer.pk})
        self.client.login(username=self.user.username, password='******')

        # DO ACTION
        data = {'comment': faker.text()}
        response = self.client.put(url, data=data)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        answer.refresh_from_db()
        self.assertEqual(answer.comment, data['comment'])
        self.assertTrue(answer_emails_task_mock.called)
        self.assertEqual(answer_emails_task_mock.call_count, 1)
        self.assertIsNotNone(
            self.get_mock_kwarg(answer_emails_task_mock, 'eta'))
Пример #13
0
    def test_update_post_several_times_updates_edited_property(self, mock):
        # PREPARE DATA
        post = Post.objects.create_announcement_post(
            user_from=self.user,
            title=' '.join(faker.words()),
            description=faker.text(),
        )

        post.action_update(self.user)
        edit_action = post.action_object_actions.filter(
            verb=settings.FORUM_ACTION_EDIT_POST).first()
        edit_action.timestamp = decrease_date(
            seconds=settings.FORUM_NEW_POST_DELAY * 3)
        edit_action.save()

        # DO ACTION
        post.action_update(self.super_user)
        datetime_updated = decrease_date(
            seconds=settings.FORUM_NEW_POST_DELAY * 2)
        last_edit_action = post.action_object_actions.filter(
            verb=settings.FORUM_ACTION_EDIT_POST).first()
        last_edit_action.timestamp = datetime_updated
        last_edit_action.save()

        # ASSERTS
        self.assertEqual(last_edit_action.timestamp.time(),
                         post.edited.timestamp.time())
Пример #14
0
    def test_retrieve_project_post_success(self):
        # PREPARE DATA
        post = Post.objects.create_project_team_post(
            title=''.join(faker.words()),
            user_from=self.super_user,
            team=FakeTeamFactory.create())

        consultant = FakeConsultantFactory.create()
        self.certificate_consultant(
            email=consultant.user.email,
            _type='consultantrole-foundations',
            user_from=self.super_user,
        )
        user = consultant.user
        user.set_password('123456')
        user.save()

        url = reverse('api:forum:post-slug-detail', kwargs={'slug': post.slug})

        # DO ACTION
        self.client.login(username=user.username, password='******')
        response = self.client.get(url)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
    def create_application(self, consultant=None, level=None):
        certification_level = level or settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2
        cert_request = CertificationRequest.objects.create(
            user=consultant.user,
            requester_email=consultant.user.email,
            requester_name=consultant.user.full_name,
            certification=ExOCertification.objects.get(
                level=certification_level),
        )

        if certification_level == settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2:
            cohort = self.cohort_lvl_2.pk
        elif certification_level == settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_3:
            cohort = self.cohort_lvl_3.pk

        payload = {
            'country': 'NO',
            'recaptcha': faker.word(),
            'billingName': faker.name(),
            'taxId': faker.word(),
            'billingAddress': faker.address(),
            'companyName': faker.name(),
            'cohort': cohort,
            'application_details': {
                'reasons': ' '.join(faker.words()),
                'whereMetUs': faker.word(),
            }
        }
        self.client.put(
            reverse('api:exo-certification:applications-detail',
                    kwargs={'pk': cert_request.pk}),
            data=payload,
        )
Пример #16
0
    def test_create_circle_post(self, post_emails_task_mock):
        # PREPARE DATA
        consultant = FakeConsultantFactory.create(user__is_active=True,
                                                  user__password='******')
        circle = Circle.objects.first()
        circle.add_user(consultant.user)
        keyword = FakeKeywordFactory.create()
        num_files = 4
        data = {
            'title':
            ' '.join(faker.words()),
            'description':
            faker.text(),
            'tags': [
                {
                    'pk': keyword.pk,
                    'name': keyword.name,
                },
                {
                    'name': faker.word() + faker.numerify(),
                },
            ],
            'uploaded_files':
            self.get_files_example(num_files),
        }
        url = reverse('api:circles:circles-create',
                      kwargs={'slug': circle.slug})

        # DO ACTION
        self.client.login(username=consultant.user.username, password='******')
        response = self.client.post(url, data)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        self.assertEqual(len(response.data.get('uploaded_files')), num_files)
Пример #17
0
    def test_get_post_answer_seen(self):
        # PREPARE DATA
        self.circle = Circle.objects.first()
        self.user.hubs.create(hub=self.circle.hub)
        post = Post.objects.create_circle_post(circle=self.circle,
                                               user_from=self.user,
                                               title=' '.join(faker.words()),
                                               description=faker.text())
        user_1 = FakeUserFactory.create()
        user_1.hubs.create(hub=self.circle.hub)
        user_2 = FakeUserFactory.create()
        user_2.hubs.create(hub=self.circle.hub)
        post.reply(user_1, faker.text())
        post.reply(user_2, faker.text())
        post.reply(user_1, faker.text())
        url = reverse('api:forum:post-answers', kwargs={'pk': post.pk})

        # DO ACTION
        self.client.login(username=self.user.username, password='******')
        unseen_response = self.client.get(url)
        seen_response = self.client.get(url)

        # ASSERTS
        self.assertTrue(status.is_success(unseen_response.status_code))
        data = unseen_response.json()
        for item in data.get('results', None):
            self.assertFalse(item.get('seen'))

        self.assertTrue(status.is_success(seen_response.status_code))
        data = seen_response.json()
        for item in data.get('results', None):
            self.assertTrue(item.get('seen'))
Пример #18
0
    def test_announcement_post_list(self):
        # PREPARE DATA
        consultant = FakeConsultantFactory.create(user__is_active=True,
                                                  user__password='******')
        for i in range(5):
            Post.objects.create_announcement_post(user_from=self.super_user,
                                                  title=' '.join(
                                                      faker.words()),
                                                  description=faker.text())

        url = reverse('api:forum:circle-post-list',
                      kwargs={'circle_slug': 'announcements'})
        all_announcements = Post.objects.filter_by__type(
            settings.FORUM_CH_ANNOUNCEMENT)
        search = all_announcements.first().title
        search_announcements = all_announcements.filter_by_search(search)

        # DO ACTIONS
        self.client.login(username=consultant.user.username, password='******')
        response = self.client.get(url)
        response_search = self.client.get(url, data={'search': search})
        self.client.login(username=self.super_user.username, password='******')
        response_su = self.client.get(url)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        self.assertTrue(status.is_success(response_search.status_code))
        self.assertTrue(status.is_success(response_su.status_code))
        data = response.json()
        data_search = response_search.json()
        self.assertEqual(data.get('count'), all_announcements.count())
        self.assertEqual(data_search.get('count'),
                         search_announcements.count())
Пример #19
0
    def test_retrieve_post_answers(self):
        # PREPARE DATA
        self.circle = Circle.objects.first()
        self.user.hubs.create(hub=self.circle.hub)
        post = Post.objects.create_circle_post(circle=self.circle,
                                               user_from=self.user,
                                               title=' '.join(faker.words()),
                                               description=faker.text())
        user_1 = FakeUserFactory.create()
        user_1.hubs.create(hub=self.circle.hub)
        user_2 = FakeUserFactory.create()
        user_2.hubs.create(hub=self.circle.hub)
        post.reply(user_1, faker.text())
        post.reply(user_2, faker.text())
        post.reply(self.user, faker.text())
        post.reply(user_1, faker.text())
        url = reverse('api:forum:post-answers', kwargs={'pk': post.pk})

        # DO ACTION
        self.client.login(username=self.user.username, password='******')
        response = self.client.get(url)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        data = response.json()
        self.assertEqual(data.get('count'), 4)
Пример #20
0
    def test_delete_post(self):
        # PREPARE DATA
        post = Post.objects.create_announcement_post(
            user_from=self.user,
            title=' '.join(faker.words()),
            description=faker.text(),
        )

        url = reverse('api:forum:post-detail', kwargs={'pk': post.pk})
        url_slug = reverse('api:forum:post-slug-detail',
                           kwargs={'slug': post.slug})
        self.client.login(username=self.user.username, password='******')
        keyword = FakeKeywordFactory.create()

        # DO ACTION
        data = {
            'title':
            ' '.join(faker.words()),
            'description':
            faker.text(),
            'tags': [
                {
                    'pk': keyword.pk,
                    'name': keyword.name,
                },
                {
                    'name': faker.word(),
                },
            ]
        }
        response = self.client.delete(url, data=data)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        with self.assertRaises(Post.DoesNotExist):
            post.refresh_from_db()
        self.assertEqual(Post.all_objects.filter(pk=post.pk).count(), 1)
        self.assertTrue(Post.all_objects.filter_by_status_removed().exists())

        # DO ACTION
        response_pk = self.client.get(url)
        response_slug = self.client.get(url_slug)

        # ASSERTS
        self.assertTrue(response_pk.status_code, status.HTTP_410_GONE)
        self.assertTrue(response_slug.status_code, status.HTTP_410_GONE)
Пример #21
0
    def test_update_post_files(self, post_emails_task_mock):
        # PREPARE DATA
        keyword = FakeKeywordFactory.create()
        num_files = 1
        files = self.get_files_example(num_files)
        consultant = FakeConsultantFactory.create(user__is_active=True,
                                                  user__password='******')
        circle_slug = 'consultants'
        circle = Circle.objects.get(slug=circle_slug)
        circle.add_user(consultant.user)
        data = {
            'title':
            ' '.join(faker.words()),
            'description':
            faker.text(),
            'tags': [
                {
                    'pk': keyword.pk,
                    'name': keyword.name,
                },
                {
                    'name': faker.word() + faker.numerify(),
                },
            ],
            'uploaded_files':
            files,
        }
        url = reverse('api:circles:circles-create',
                      kwargs={'slug': circle_slug})
        self.client.login(username=consultant.user.username, password='******')

        # DO ACTION
        response = self.client.post(url, data=data)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        self.assertEqual(len(response.data.get('uploaded_files')), num_files)

        # PREPARE DATA
        num_files_new = 2
        new_files = self.get_files_example(num_files_new)
        data_put = {
            'title': data['title'],
            'description': data['description'],
            'tags': data['tags'],
            'uploaded_files': files + new_files,
        }

        # DO ACTION
        url = reverse('api:forum:post-detail',
                      kwargs={'pk': response.data.get('pk')})
        response = self.client.put(url, data=data_put)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        self.assertEqual(len(response.data.get('uploaded_files')),
                         num_files + num_files_new)
    def test_get_questions_from_participants(self):
        # PREPARE DATA
        consultant = FakeConsultantFactory(
            user__is_active=True,
            user__password='******',
            activities=[settings.EXO_ACTIVITY_CH_ACTIVITY_CONSULTING])
        team_a = FakeTeamFactory.create()
        team_b = FakeTeamFactory.create()
        participant_a = FakeUserFactory.create(password='******',
                                               is_active=True)
        participant_b = FakeUserFactory.create(password='******',
                                               is_active=True)
        self.add_user_to_team(participant_a, team_a)
        self.add_user_to_team(participant_b, team_b)
        for i in range(7):
            post = Post.objects.create_project_team_post(
                user_from=participant_a,
                team=team_a,
                title=' '.join(faker.words()),
                description=faker.text())

        for i in range(12):
            Post.objects.create_project_team_post(user_from=participant_b,
                                                  team=team_b,
                                                  title=' '.join(
                                                      faker.words()),
                                                  description=faker.text())
        url = reverse('api:forum:questions-participants-list')
        search = 'tosearch'
        post.title = '{} {}'.format(post.title, search)
        post.save()

        # DO ACTION
        self.client.login(username=consultant.user.username, password='******')
        response = self.client.get(url)
        response_search = self.client.get(url, data={'search': search})

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        data = response.json()
        self.assertEqual(data.get('count'), 19)
        self.assertTrue(status.is_success(response_search.status_code))
        data = response_search.json()
        self.assertEqual(data.get('count'), 1)
Пример #23
0
 def setUp(self):
     self.circle = Circle.objects.first()
     self.user = FakeUserFactory.create(is_active=True)
     self.user.hubs.create(hub=self.circle.hub)
     post = Post.objects.create_circle_post(
         user_from=self.user,
         circle=self.circle,
         title=' '.join(faker.words()),
         description=faker.text())
     post_id = post.pk
     self.post = Post.objects.get(pk=post_id)
Пример #24
0
 def create_cohort(self,
                   level=settings.EXO_CERTIFICATION_CERTIFICATION_CH_LEVEL_2
                   ):
     certification = ExOCertification.objects.get(level=level)
     return CertificationCohort.objects.create(
         date=string_to_datetime(faker.date()),
         certification=certification,
         seats=25,
         price=2500,
         status=settings.EXO_CERTIFICATION_COHORT_STATUS_CH_OPEN,
         invoice_concept=' '.join(faker.words()),
     )
Пример #25
0
 def setUp(self):
     super().setUp()
     self.create_user()
     self.create_superuser()
     self.circle = Circle.objects.first()
     self.user.hubs.create(hub=self.circle.hub)
     post = Post.objects.create_circle_post(user_from=self.user,
                                            circle=self.circle,
                                            title=' '.join(faker.words()),
                                            description=faker.text())
     post_id = post.pk
     self.post = Post.objects.get(pk=post_id)
Пример #26
0
    def test_update_question_by_user(self):
        # PREPARE DATA
        sprint = FakeSprintAutomatedFactory.create(
            status=settings.PROJECT_CH_PROJECT_STATUS_WAITING)
        new_team = FakeTeamFactory.create(project=sprint.project_ptr)
        new_team.add_member(
            user_from=self.super_user,
            email=self.user.email,
            name=self.user.short_name,
        )
        post = Post.objects.create_project_team_post(
            user_from=self.super_user,
            team=new_team,
            title=' '.join(faker.words()),
            description=faker.text(),
        )
        keyword = FakeKeywordFactory.create()

        # DO ACTION
        self.client.login(username=self.user.username, password='******')
        url = reverse('api:forum:post-detail', kwargs={'pk': post.pk})
        data = {
            'title':
            ' '.join(faker.words()),
            'description':
            faker.text(),
            'tags': [
                {
                    'pk': keyword.pk,
                    'name': keyword.name,
                },
                {
                    'name': faker.word(),
                },
            ]
        }
        response = self.client.put(url, data=data)

        # ASSERTS
        self.assertTrue(status.is_client_error(response.status_code))
Пример #27
0
    def test_update_post_when_have_replies(self):
        # PREPARE DATA
        self.circle = Circle.objects.first()
        self.user.hubs.create(hub=self.circle.hub)
        post = Post.objects.create_circle_post(user_from=self.user,
                                               circle=self.circle,
                                               title=' '.join(faker.words()),
                                               description=faker.text())
        user = FakeUserFactory.create()
        user.hubs.create(hub=self.circle.hub)
        post.reply(user, faker.text())
        url = reverse('api:forum:post-detail', kwargs={'pk': post.pk})
        keyword = FakeKeywordFactory.create()

        # DO ACTION
        data = {
            'title':
            ' '.join(faker.words()),
            'description':
            faker.text(),
            'tags': [
                {
                    'pk': keyword.pk,
                    'name': keyword.name,
                },
                {
                    'name': faker.word(),
                },
            ]
        }
        self.client.login(username=self.user.username, password='******')
        response = self.client.put(url, data=data)

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        post.refresh_from_db()
        self.assertTrue(
            post.can_update_or_remove(self.user, raise_exceptions=False))
        self.assertEqual(post.title, data['title'])
Пример #28
0
    def test_circle_list_success(self):
        # PREPARE DATA
        url = reverse('api:circles:circles-list')

        for circle in Circle.objects.all():
            Post.objects.create_circle_post(user_from=self.super_user,
                                            circle=circle,
                                            title=' '.join(faker.words()),
                                            description=faker.text())
        Post.objects.create_announcement_post(user_from=self.super_user,
                                              title=' '.join(faker.words()),
                                              description=faker.text())
        Post.objects.create_project_team_post(title=''.join(faker.words()),
                                              user_from=self.super_user,
                                              team=FakeTeamFactory.create())
        open_circle = Circle.objects.create(
            name=faker.word(),
            description=faker.text(),
            created_by=self.consultant_1.user,
        )
        open_circle.add_user(self.consultant_1.user)
        consultant_circles = following(self.consultant_2.user, Circle)
        user_circles = following(self.consultant_1.user, Circle)

        # DO ACTION
        self.client.login(username=self.consultant_1.user.username,
                          password='******')
        response_1 = self.client.get(url)
        self.client.login(username=self.consultant_2.user.username,
                          password='******')
        response_2 = self.client.get(url)

        # ASSERTS
        self.assertTrue(status.is_success(response_1.status_code))
        data = response_1.json()
        self.assertEqual(data.get('count'), len(user_circles) + 2)
        self.assertTrue(status.is_success(response_2.status_code))
        data = response_2.json()
        self.assertEqual(data.get('count'), len(consultant_circles) + 1)
Пример #29
0
    def test_circle_post_list(self):
        # PREPARE DATA
        consultant = FakeConsultantFactory.create(user__is_active=True,
                                                  user__password='******')
        self.circle = Circle.objects.first()
        second_circle = Circle.objects.last()
        consultant.user.hubs.create(hub=self.circle.hub)
        consultant.user.hubs.create(hub=second_circle.hub)
        url_params = {'circle_slug': self.circle.slug}
        url = reverse('api:forum:circle-post-list', kwargs=url_params)

        for i in range(6):
            Post.objects.create_circle_post(circle=self.circle,
                                            user_from=consultant.user,
                                            title=' '.join(faker.words()),
                                            description=faker.text())

        for i in range(10):
            Post.objects.create_circle_post(circle=second_circle,
                                            user_from=consultant.user,
                                            title=' '.join(faker.words()),
                                            description=faker.text())

        all_posts = Post.objects.filter_by_circle(self.circle)
        search = all_posts.first().title
        search_posts = all_posts.filter_by_search(search)

        # DO ACTION
        self.client.login(username=consultant.user.username, password='******')
        response = self.client.get(url)
        response_search = self.client.get(url, data={'search': search})

        # ASSERTS
        self.assertTrue(status.is_success(response.status_code))
        self.assertTrue(status.is_success(response_search.status_code))
        data = response.json()
        data_search = response_search.json()
        self.assertEqual(data.get('count'), all_posts.count())
        self.assertEqual(data_search.get('count'), search_posts.count())
Пример #30
0
    def test_parse_urls_with_html_tags(self):
        # PREPARE DATA
        faked_text = faker.text()
        faked_url = faker.url()
        faked_url_text = ' '.join(faker.words())
        text_to_parse = '<p>{}</p><a href="{}" rel="nofollow">{}</a>'.format(
            faked_text, faked_url, faked_url_text)

        # DO ACTION
        parsed_text = parse_urls(text_to_parse)

        # ASSERTIONS
        self.assertEqual(text_to_parse, parsed_text)