Esempio n. 1
0
 def test_add_existed_member_with_invitation(self):
     self.account = AccountFactory()
     self.admin = AdminFactory(accounts=[self.account])
     self.login_admin()
     old_acc = list(self.user.accounts.all().values_list('id', flat=True))
     old_acc.append(get_current_account(self).id)
     url = reverse('member_create',
                   kwargs={'url': get_current_account(self).url})
     data = {
         'first_name': lorem_ipsum.words(1, False).capitalize()[:50],
         'last_name': lorem_ipsum.words(1, False).capitalize()[:50],
         'email': self.user.email,
         'password': User.objects.make_random_password(),
         'date_joined_board': '{:%b. %d, %Y}'.format(timezone.now()),
         'timezone': us_timezones[0],
         'account': get_current_account(self),
         'role': Membership.ROLES.member,
         'invitation': True
     }
     response = self.client.post(url, data, follow=True)
     self.assertEqual(response.status_code, 200)
     self.assertContains(response, _('Member was added successfully.'))
     self.assertItemsEqual(
         list(self.user.accounts.all().values_list('id', flat=True)),
         old_acc)
Esempio n. 2
0
 def test_notifications_pagination(self):
     Notification.objects.all().delete()
     for i in range(0,53):
         notification = {
             'title': words(2, False),
             'description': words(6, False),
             'recipient': User.objects.get(username='******'),
             'app': 'game',
             'key': 'foo%s' % i,
         }
         Notification(**notification).save()
     self.client.login(username='******', password='******')
     response = self.client.get(reverse('notifications_api_list'), format='json')
     self.assertEqual(response.status_code, 200)
     self.assertEqual(len(response.data['results']), 5)
     self.assertEqual(response.data['count'], 53)
     self.assertEqual(response.data['total_pages'], 11)
     self.assertEqual(response.data['current_page'], 1)
     response = self.client.get(reverse('notifications_api_list'), {'page': 5}, format='json')
     self.assertEqual(response.status_code, 200)
     self.assertEqual(len(response.data['results']), 5)
     self.assertEqual(response.data['count'], 53)
     self.assertEqual(response.data['total_pages'], 11)
     self.assertEqual(response.data['current_page'], 5)
     response = self.client.get(reverse('notifications_api_list'), {'page': 11}, format='json')
     self.assertEqual(response.status_code, 200)
     self.assertEqual(len(response.data['results']), 3)
     self.assertEqual(response.data['count'], 53)
     self.assertEqual(response.data['total_pages'], 11)
     self.assertEqual(response.data['current_page'], 11)
Esempio n. 3
0
    def test_member_permission(self):
        self.account = AccountFactory()
        user_member = UserFactory(accounts=[self.account])
        self.login_member(user_member.email)
        data = {
            'role':
            Membership.ROLES.chair,
            'email':
            u'{}_{}@example.com'.format(self.account.id,
                                        lorem_ipsum.words(1, False)),
            'first_name':
            lorem_ipsum.words(1, False).capitalize()[:50],
            'last_name':
            lorem_ipsum.words(1, False).capitalize()[:50],
            'password':
            '******',
            'date_joined_board':
            '{:%b. %d, %Y}'.format(timezone.now()),
            'timezone':
            us_timezones[0],
            'account':
            get_current_account(self),
            'invitation':
            True
        }

        url = reverse('member_create',
                      kwargs={'url': get_current_account(self).url})
        response = self.client.post(url, data, follow=True)
        self.assertEqual(response.status_code, 403)

        url = reverse('profiles:edit', kwargs={'pk': self.user.pk})
        response = self.client.post(url, data, follow=True)
        self.assertEqual(response.status_code, 404)
Esempio n. 4
0
    def test_update(self):
        experiment = ExperimentFactory(lab=self.lab, owners=[self.owner.pk])
        url = reverse('experiments:update', kwargs={'lab_pk': self.lab.pk, 'pk': experiment.pk})
        data = {
            'owners': [self.owner.pk],
            'start': timezone.now().strftime('%m/%d/%Y %H:%M'),
            'end': timezone.now().strftime('%m/%d/%Y %H:%M'),
            'description': lorem_ipsum.words(2),
            'title': lorem_ipsum.words(2),
            'status': Experiment.STATUS[0][0]
        }
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, _('Login'))

        self.client.login(username=self.owner.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(Experiment.objects.count(), 1)
        experiment = Experiment.objects.get(pk=experiment.pk)
        self.assertEqual(experiment.description, data['description'])

        self.client.login(username=self.member.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)

        self.client.login(username=self.guest.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 403)

        self.client.login(username=self.user4.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 403)
Esempio n. 5
0
class MeetingFactory(factory.DjangoModelFactory):
    class Meta:
        model = Meeting

    name = lorem_ipsum.words(4, True)
    description = lorem_ipsum.words(8, True)

    @factory.sequence
    def start(n):
        return timezone.now() + timedelta(days=n)

    @factory.lazy_attribute_sequence
    def end(self, n):
        return self.start + timedelta(hours=n)

    location = lorem_ipsum.words(5, True)

    status = 1

    @factory.lazy_attribute
    def account(self):
        return Account.objects.order_by('?')[0]

    @factory.lazy_attribute
    def committee(self):
        return Committee.objects.filter(
            account_id=self.account.id).order_by('?')[0]
Esempio n. 6
0
def create_blogpost(author):
    data = {
        'title': lorem_ipsum.words(random.randint(5, 10)),
        'content': ''.join(lorem_ipsum.words(random.randint(10, 30)))[:500],
        'publication': now(),
        'author': author,
    }
    return BlogPost.objects.create(**data)
Esempio n. 7
0
def create_room(zosia):
    data = {
        'name': lorem_ipsum.words(1),
        'description': lorem_ipsum.words(3),
        'capacity': random.randint(1, 6),
        'zosia': zosia,
    }
    return Room.objects.create(**data)
 def extra_data(self):
     return {
         'id': lorem_ipsum.words(1, False),
         'team_id': lorem_ipsum.words(1, False),
         'access_token': lorem_ipsum.words(1, False),
         'bot': {
             'bot_user_id': 'test_id',
             'bot_access_token': 'access_token'
         }
     }
Esempio n. 9
0
    def test_chairperson_permission(self):
        self.account = AccountFactory()
        user_chairperson = ChairpersonFactory(accounts=[self.account])
        self.login_member(user_chairperson.email)
        data = {
            'role':
            Membership.ROLES.chair,
            'email':
            u'{}_{}@example.com'.format(self.account.id,
                                        lorem_ipsum.words(1, False)),
            'first_name':
            lorem_ipsum.words(1, False).capitalize()[:50],
            'last_name':
            lorem_ipsum.words(1, False).capitalize()[:50],
            'password':
            '******',
            'date_joined_board':
            '{:%b. %d, %Y}'.format(timezone.now()),
            'timezone':
            us_timezones[0],
            'account':
            get_current_account(self),
            'invitation':
            True
        }

        url = reverse('member_create',
                      kwargs={'url': get_current_account(self).url})
        response = self.client.post(url, data, follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, _('Member was added successfully.'))

        url = reverse('profiles:edit', kwargs={'pk': self.membership.pk})
        data['email'] = u'{}_{}@example.com'.format(
            self.account.id, lorem_ipsum.words(1, False)),
        response = self.client.post(url, data, follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, _('Profile was changed successfully.'))
        self.assertEqual(Membership.ROLES.chair,
                         Membership.objects.get(pk=self.membership.pk).role)

        url = reverse(
            'profiles:edit',
            kwargs={'pk': user_chairperson.get_membership(self.account).pk})
        data['role'] = Membership.ROLES.admin
        data['email'] = u'{}_{}@example.com'.format(
            self.account.id, lorem_ipsum.words(1, False)),
        response = self.client.post(url, data, follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, _('Profile was changed successfully.'))
        self.assertEqual(
            Membership.ROLES.chair,
            Membership.objects.get(
                pk=user_chairperson.get_membership(self.account).pk).role)
Esempio n. 10
0
 def test_create(self):
     url = reverse('news:create',
                   kwargs={'url': get_current_account(self).url})
     data = {
         'title': lorem_ipsum.words(2, False),
         'text': lorem_ipsum.words(5, True),
         'is_publish': True
     }
     response = self.client.post(url, data, follow=True)
     self.assertEqual(response.status_code, 200)
     self.assertContains(response, 'News was added successfully.')
Esempio n. 11
0
 def test_manager(self):
     notification = {
         'title': words(2, False),
         'description': words(6, False),
         'recipient': User.objects.get(username='******'),
         'app': 'game',
         'key': 'bar',
     }
     nb = len(Notification.objects.get_or_create(**notification))
     self.assertEqual(nb, 1)
     nb = len(Notification.objects.get_or_create(**notification))
     self.assertEqual(nb, 0)
Esempio n. 12
0
 def test_manager_recipients_list(self):
     notification = {
         'title': words(2, False),
         'description': words(6, False),
         'recipients': User.objects.all()[:2],
         'app': 'game',
         'key': 'bar',
     }
     nb = len(Notification.objects.get_or_create(**notification))
     self.assertEqual(nb, 2)
     nb = len(Notification.objects.get_or_create(**notification))
     self.assertEqual(nb, 0)
Esempio n. 13
0
def create_lecture(zosia, author):
    data = {
        'zosia': zosia,
        'info': lorem_ipsum.words(60)[:750],
        'title': lorem_ipsum.sentence()[:255],
        'abstract': ' '.join(lorem_ipsum.paragraphs(3))[:1000],
        'duration': '15',
        'lecture_type': random.randint(0, 2),
        'person_type': '2',
        'description': lorem_ipsum.words(20)[:255],
        'author': author
    }
    return Lecture.objects.create(**data)
Esempio n. 14
0
    def accounts(self, create, extracted, **kwargs):
        if not create:
            # Simple build, do nothing.
            return

        # A list of groups were passed in, use them
        for account in extracted:
            Membership.objects.create(
                user=self,
                account=account,
                role=Membership.ROLES.chair,
                first_name=lorem_ipsum.words(1, False).capitalize(),
                last_name=lorem_ipsum.words(1, False).capitalize())
Esempio n. 15
0
def create_lecture(zosia, author):
    data = {
        'zosia': zosia,
        'requests': lorem_ipsum.words(60)[:750],
        'events': lorem_ipsum.words(60)[:750],
        'title': lorem_ipsum.sentence()[:255],
        'abstract': ' '.join(lorem_ipsum.paragraphs(3))[:1000],
        'duration': random.choice(DURATION_CHOICES)[0],
        'lecture_type': random.choice(LECTURE_TYPE)[0],
        'person_type': LectureInternals.PERSON_NORMAL,
        'description': lorem_ipsum.words(20)[:255],
        'author': author
    }
    return Lecture.objects.create(**data)
Esempio n. 16
0
    def test_create(self):
        url = reverse('committees:create',
                      kwargs={'url': get_current_account(self).url})
        data = {
            'name': lorem_ipsum.words(2, False).capitalize()[:50],
            'chairman': self.membership_admin.id,
            'members': [self.membership_admin.id, self.membership.id],
            'summary': lorem_ipsum.words(5, True),
            'description': lorem_ipsum.words(20, True),
            'account': get_current_account(self)
        }

        response = self.client.post(url, data, follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertContains(response, 'Committee was added successfully.')
Esempio n. 17
0
 def test_update_wrong(self):
     user = UserFactory(accounts=[self.account])
     self.login_member(user.email)
     url = reverse('news:edit',
                   kwargs={
                       'pk': self.news.pk,
                       'url': get_current_account(self).url
                   })
     data = {
         'title': lorem_ipsum.words(2, False),
         'text': lorem_ipsum.words(5, True),
         'is_publish': True
     }
     response = self.client.post(url, data, follow=True)
     self.assertEqual(response.status_code, 403)
Esempio n. 18
0
 def test_update(self):
     url = reverse('news:edit',
                   kwargs={
                       'pk': self.news.pk,
                       'url': get_current_account(self).url
                   })
     data = {
         'title': lorem_ipsum.words(2, False),
         'text': lorem_ipsum.words(5, True)
     }
     response = self.client.post(url, data, follow=True)
     self.assertEqual(response.status_code, 200)
     self.assertContains(response, 'News was updated successfully.')
     self.assertEqual(
         News.objects.get(pk=self.news.pk).title, data['title'])
Esempio n. 19
0
 def test_common_words_in_string(self):
     """words(n) starts with the 19 standard lorem ipsum words for n > 19."""
     self.assertTrue(
         words(25).startswith(
             'lorem ipsum dolor sit amet consectetur adipisicing elit sed '
             'do eiusmod tempor incididunt ut labore et dolore magna aliqua'
         ))
Esempio n. 20
0
    def create_classification_project(self,
                                      owner,
                                      research_project,
                                      collections=None,
                                      roles=None,
                                      **kwargs):
        if 'name' not in kwargs:
            name = words(3, common=False)
        else:
            name = kwargs['nmae']

        params = {
            'name': name,
            'research_project': research_project,
            'owner': owner
        }
        params.update(kwargs or {})

        project = ClassificationProject.objects.create(**params)

        if collections:
            project.collections = collections

        if roles:
            for user, role_level in roles:
                ClassificationProjectRole.objects.create(
                    classification_project=project, user=user, name=role_level)
        return project
Esempio n. 21
0
    def test_resource_create_preselected(self):
        """
        Using create view create storage.Resource model instance
        After resource is created user is redirected to details
        page - version where user preselect existing file."""
        deployment = self.create_deployment(owner=self.alice)
        image_file = os.path.join(self.SAMPLE_MEDIA_PATH, 'image_1.jpg')
        temp_file = get_external_resources_path(self.alice.username,
                                                'image_1.jpg')
        temp_path = os.path.dirname(temp_file)
        # When test is run as single we need to make sure that copying file
        # is made to existing directory
        if not os.path.exists(temp_path):
            os.makedirs(temp_path)
        shutil.copyfile(image_file, temp_file)

        url = self.get_resource_create_url()
        self.login_alice()
        name = words(count=5, common=False)
        params = {
            'name': name,
            'date_recorded': '06.06.2015 06:06:06',
            'preselected_file': 'image_1.jpg',
            'status': ResourceStatus.PRIVATE,
            'deployment': deployment.pk
        }
        response = self.client.post(url, params)

        self.assertEqual(response.status_code, 302, response.status_code)
        self.assertTrue(
            Resource.objects.filter(name=name,
                                    date_recorded=datetime.datetime(
                                        2015, 6, 6, 6, 6, 6),
                                    status=ResourceStatus.PRIVATE,
                                    deployment=deployment).exists())
Esempio n. 22
0
def create_room(number):
    if random.random() < 0.1:
        data = {
            'name': f"Room nr. {number}",
            'description': lorem_ipsum.words(random.randint(3, 6)),
            'beds_double': 1,
            'available_beds_double': 1,
        }
    else:
        data = {
            'name': f"Room nr. {number}",
            'description': lorem_ipsum.words(random.randint(3, 6)),
            'beds_single': random.randint(1, 6),
            'available_beds_single': random.randint(1, 6),
        }
    return Room.objects.create(**data)
Esempio n. 23
0
    def test_update_lab(self):
        data = {
            'name': lorem_ipsum.words(1, False),
            'investigator': [self.owner.pk],
            'members': [self.member.pk],
            'guests': [self.guest.pk]
        }
        lab = LabFactory(**data)

        url = reverse('labs:update', kwargs={'lab_pk': lab.pk})
        data['name'] = name = 'test'
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, _('Login'))

        self.client.login(username=self.owner.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(Lab.objects.count(), 1)
        self.assertEqual(Lab.objects.first().name, name)

        self.client.login(username=self.member.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)

        self.client.login(username=self.guest.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 403)

        self.client.login(username=self.user4.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 403)
Esempio n. 24
0
    def handle(self, **options):
        if not User.objects.exists():
            usernames = words(NUMBER_OF_USERS).split(" ")
            User.objects.bulk_create([
                User(username=username,
                     password=username,
                     email="*****@*****.**" % username) for username in usernames
            ])

        if not Tag.objects.exists():
            Tag.objects.bulk_create([Tag(name=word) for word in WORDS])

        if not Post.objects.exists():
            users = list(User.objects.all())
            tags = list(Tag.objects.all())
            for p in range(NUMBER_OF_POSTS):
                post = Post.objects.create(
                    author=choice(users),
                    title=sentence(),
                    body="\n".join(paragraphs(randint(3, 5))),
                    thumbnail="http://test.com/test.jpg",
                    is_published=choice([True, True, False]),
                )
                post.tags.add(*sample(tags, randint(0, 10)))
                post.liked_by.add(*sample(users, randint(0, 10)))

                for i in range(comment_count()):
                    Comment.objects.create(
                        user=choice(users),
                        body=paragraph(),
                        post=post,
                        parent=None if random() < 0.5 or not post.is_published
                        else choice(post.comment_set.all() or [None]))
Esempio n. 25
0
 def test_negative_words(self):
     """words(n) returns n + 19 words, even if n is negative."""
     self.assertEqual(
         words(-5),
         "lorem ipsum dolor sit amet consectetur adipisicing elit sed do "
         "eiusmod tempor incididunt ut",
     )
Esempio n. 26
0
    def test_create(self):
        url = reverse('collections:create', kwargs={'lab_pk': self.lab.pk})
        data = {
            'title': lorem_ipsum.words(3, False),
            'units': [unicode(unit.pk) for unit in self.units],
            'owners': [self.owner.pk],
        }

        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, _('Login'))

        self.client.login(username=self.owner.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(Collection.objects.count(), 1)

        self.client.login(username=self.member.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, _(u'You have not permission to add this units {} in your '
                                    u'collection'.format(','.join([unit.__unicode__() for unit in self.units]))), 1)
        self.assertEqual(Collection.objects.count(), 1)

        self.client.login(username=self.guest.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertContains(resp, _(u'Select a valid choice. {} is not one of the available choices.'.format(self.units[0].pk)), 1)
        self.assertEqual(Collection.objects.count(), 1)

        self.client.login(username=self.user4.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 403)
        self.assertEqual(Collection.objects.count(), 1)
Esempio n. 27
0
    def test_latest_minichat(self):
        Message.objects.all().delete()
        for i in range(0,57):
            Message(user=self.author, text=words(5, False)).save()
        Message(user=self.author, text='Last message').save()

        response = self.client.get(reverse('minichat-api-latest-list'), format='json')

        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.data['count'], 58)
        self.assertEqual(len(response.data['results']), 10)

        first_message = response.data['results'][0]
        # Striclty check the fields to avoir extra disclosure (field id is not sent)
        self.assertEqual(list(first_message.keys()), ['user', 'text', 'date'])

        # Striclty check the fields to avoir extra disclosure (we should only send username
        # and profile, not password, email, ...)
        self.assertEqual(list(first_message['user'].keys()), ['username', 'profile', 'get_absolute_url'])


        # Striclty check the fields to avoir extra disclosure (we should only send avatar,
        # not last_visit, ...)
        self.assertEqual(list(first_message['user']['profile'].keys()), ['avatar'])

        self.assertEqual(first_message['text'], 'Last message')
Esempio n. 28
0
    def test_profile_change(self):
        """Update user profile"""
        logged_in = self.client.login(
            username=self.user.username, password=self.passwd
        )

        self.assertTrue(logged_in)

        first_name = 'Amanda'
        last_name = 'Amandasia'
        institution = 'Hogwart'

        about_me = words(5)

        self.client.post(
            self.profile_url,
            data={
                'first_name': first_name,
                'last_name': last_name,
                'institution': institution,
                'about_me': about_me,
                'update-profile': ''
            }
        )

        user = User.objects.get(pk=self.user.pk)
        profile = user.userprofile

        self.assertEqual(user.first_name, first_name)
        self.assertEqual(user.last_name, last_name)
        self.assertEqual(profile.institution, institution)
        self.assertEqual(profile.about_me, about_me)
Esempio n. 29
0
def get_random_article():
    """ Method returns random article dictionary with content, description and title. """
    return {
        'content': lorem.paragraph(),
        'description': lorem.sentence(),
        'title': lorem.words(count=4, common=False).capitalize(),
    }
Esempio n. 30
0
    def create_research_project(self,
                                owner,
                                status=None,
                                collections=None,
                                roles=None,
                                name=None):

        if status is None:
            status = ResearchProjectStatus.APPROVED
        name = name or words(3, common=False)
        acronym = name[:3]

        project = ResearchProject.objects.create(name=name,
                                                 acronym=acronym,
                                                 status=status,
                                                 owner=owner)

        if collections:
            project.collections = collections

        if roles:
            for user, role_level in roles:
                ResearchProjectRole.objects.create(project=project,
                                                   user=user,
                                                   name=role_level)
        return project
Esempio n. 31
0
    def create_resource(self,
                        owner,
                        status=None,
                        file_content=None,
                        managers=None,
                        **resource_kwargs):

        status = status or ResourceStatus.ON_DEMAND
        if not file_content:
            file_path = os.path.join(self.SAMPLE_MEDIA_PATH, 'image_1.jpg')
            with open(file_path) as handler:
                file_content = handler.read()

        file_name = u"{name}.png".format(name=create_hashcode())

        params = {
            'name': words(3, common=False),
            'file': SimpleUploadedFile(file_name, file_content),
            'date_recorded': now(),
            'status': status,
            'owner': owner
        }
        params.update(**resource_kwargs)

        resource = Resource.objects.create(**params)

        if managers:
            resource.managers = managers

        return resource
Esempio n. 32
0
    def test_create_with_perm(self):
        experiment1 = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.member.pk], viewers=[self.guest.pk])
        unit1 = UnitFactory(lab=self.lab, user=self.owner, experiments=[experiment1])

        experiment2 = ExperimentFactory(lab=self.lab, owners=[self.member.pk])
        unit2 = UnitFactory(lab=self.lab, user=self.member, experiments=[experiment2])

        url = reverse('collections:create', kwargs={'lab_pk': self.lab.pk})
        data = {
            'title': lorem_ipsum.words(3, False),
            'units': [unicode(unit1.pk), unicode(unit2.pk)],
            'owners': [self.owner.pk],
        }

        self.client.login(username=self.owner.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(Collection.objects.count(), 1)

        self.client.login(username=self.member.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(Collection.objects.count(), 2)

        self.client.login(username=self.guest.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, _(u'Select a valid choice. {} is not one of the available choices.'.format(unit2.pk)), 1)
        self.assertEqual(Collection.objects.count(), 2)

        self.client.login(username=self.user4.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 403)
        self.assertEqual(Collection.objects.count(), 2)
Esempio n. 33
0
 def test_negative_words(self):
     """words(n) returns n + 19 words, even if n is negative."""
     self.assertEqual(
         words(-5),
         'lorem ipsum dolor sit amet consectetur adipisicing elit sed do '
         'eiusmod tempor incididunt ut'
     )
Esempio n. 34
0
    def test_can_post_a_message(self):
        lexpagiens_link = self.selenium.find_element_by_link_text('Discussions')
        ActionChains(self.selenium).move_to_element(lexpagiens_link).perform()
        disconnect_link = self.selenium.find_element_by_link_text('Nouvelle discussion')
        disconnect_link.click()
        WebDriverWait(self.selenium, 1).until(
            lambda driver: driver.find_element_by_id('id_title'))
        # le Corbeau et le Renard, Jean de la Fontaine
        title = words(6, False)
        text = '\n'.join(paragraphs(5))
        title_input = self.selenium.find_element_by_name('title')
        title_input.send_keys(title)
        text_input = self.selenium.find_element_by_name('text')
        text_input.send_keys(text)
        self.selenium.find_element_by_css_selector('.fa.fa-bold').click()
        text_input.send_keys('Et du GRAS!')
        for i in range(len('[/b]')):
            text_input.send_keys(Keys.RIGHT)
        self.selenium.find_element_by_css_selector('.fa.fa-italic').click()
        text_input.send_keys('Et de l\'italique!')
        for i in range(len('[/i]')):
            text_input.send_keys(Keys.LEFT)

        self.selenium.find_element_by_xpath('//button[text()="Poster"]').click()
        WebDriverWait(self.selenium, 1).until(
            lambda driver: driver.find_element_by_xpath('//h3[text()="%s"]' % title))

        text_block = self.selenium.find_element_by_css_selector('.board-messagelist .message-text .bbcode')
        bbcode = '<b>Et du GRAS!</b><em>Et de l\'italique!</em>'
        formatted_message = '%s%s' % ('<br>'.join(text.split('\n')), bbcode)
        self.assertEqual(text_block.get_attribute('innerHTML').strip(), formatted_message)
Esempio n. 35
0
    def test_resource_create_upload(self):
        """
        Using create view create storage.Resource model instance
        After resource is created user is redirected to details
        page - version where user upload file."""

        deployment = self.create_deployment(owner=self.alice)

        image_file = os.path.join(self.SAMPLE_MEDIA_PATH, 'image_1.jpg')
        url = self.get_resource_create_url()
        self.login_alice()
        name = words(count=5, common=False)
        with open(image_file) as file_handler:
            params = {
                'name': name,
                'date_recorded': '08.08.2015 06:06:06',
                'file': file_handler,
                'status': ResourceStatus.PRIVATE,
                'deployment': deployment.pk
            }
            response = self.client.post(url, params)
            self.assertEqual(response.status_code, 302, response.status_code)
            self.assertTrue(
                Resource.objects.filter(name=name,
                                        date_recorded=datetime.datetime(
                                            2015, 8, 8, 6, 6, 6),
                                        status=ResourceStatus.PRIVATE,
                                        deployment=deployment).exists())
Esempio n. 36
0
 def test_dashboard_recent_save_meeting_create_without_notify(self):
     self.login_admin()
     self.account.send_notification = False
     self.account.save()
     self.client.get(
         reverse('meetings:create', kwargs={'url': self.account.url}))
     agenda = DocumentFactory(user=self.admin, type=Document.AGENDA)
     minutes = DocumentFactory(user=self.admin, type=Document.MINUTES)
     other_docs = DocumentFactory(user=self.admin, type=Document.OTHER)
     docs = '{},{},{}'.format(agenda.id, minutes.id, other_docs.id)
     date = timezone.now() + timedelta(days=2)
     data = {
         'name': lorem_ipsum.words(2, False).capitalize()[:50],
         'date': date.date().strftime("%b. %d, %Y"),
         'time_start': date.time().strftime("%I:%M %p"),
         'time_end':
         (date + timedelta(hours=3)).time().strftime("%I:%M %p"),
         'location': '709 Sixth Street, Newark, DE 19711',
         'committee': self.committee.id,
         'account': self.account,
         'uploaded': docs
     }
     resp = self.client.post(reverse('meetings:create',
                                     kwargs={'url': self.account.url}),
                             data,
                             follow=True)
     self.assertContains(resp, 'Meeting was added successfully.')
     self.assertTrue(len(RecentActivity.objects.all()) > 0)
     for item in RecentActivity.objects.all():
         self.assertEqual(item.content_object.name, data['name'])
     self.assertEqual(len(mail.outbox), 0)
Esempio n. 37
0
    def setUp(self):
        super(CollectionRequestTestCase, self).setUp()
        self.summon_alice()
        self.summon_ziutek()

        self.resource = self.create_resource(owner=self.alice)
        self.resource2 = self.create_resource(owner=self.alice)

        self.collection = self.create_collection(
            owner=self.alice, resources=[self.resource, self.resource2])
        self.research_project = self.create_research_project(owner=self.ziutek)

        self.message = Message.objects.create(
            subject=words(3),
            text=paragraph(),
            user_from=self.ziutek,
            user_to=self.alice,
            message_type=MessageType.COLLECTION_REQUEST)

        self.collection_request = CollectionRequest.objects.create(
            name='collection request',
            project=self.research_project,
            user=self.alice,
            user_from=self.ziutek,
            message=self.message)
        self.collection_request.collections.add(self.collection)
Esempio n. 38
0
    def setUp(self):
        self.old_setting = settings.FILEMANAGER_UPLOAD_ROOT
        settings.FILEMANAGER_UPLOAD_ROOT += '_test/'

        self.owner = UserFactory()

        url = reverse('labs:create')
        data = {
            'name': lorem_ipsum.words(1, False),
            'investigator': [self.owner.pk],
            # 'members': [self.member.pk],
        }
        self.client.login(username=self.owner.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.lab = Lab.objects.get(name=data['name'])

        with open(os.path.join(settings.FILEMANAGER_UPLOAD_ROOT, unicode(self.lab.pk) + '/', 'testfile1.txt'), 'w') as f:
            f.write('test file content')
        inner_directory = os.path.join(settings.FILEMANAGER_UPLOAD_ROOT, unicode(self.lab.pk) + '/', 'test dir')
        if not os.path.exists(inner_directory):
            os.makedirs(inner_directory)
        with open(os.path.join(inner_directory, 'testfile2.txt'), 'w') as f:
            f.write('test file content in dir')

        self.client.logout()
Esempio n. 39
0
    def test_recent_comment_activity_view(self):
        experiment = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.guest.pk])

        url = reverse('dashboard:comment-activity', kwargs={'lab_pk': self.lab.pk})
        resp = self.client.get(url)
        self.assertNotEqual(resp.status_code, 200)
        self.client.login(username=self.owner.email, password='******')
        resp = self.client.get(url)
        self.assertContains(resp, u'timeline')

        # Add comment
        text = lorem_ipsum.words(2)
        comment_url = reverse('comment:api-list', kwargs={
            'lab_pk': self.lab.pk,
            'instance_type': 'experiment',
            'object_id': experiment.pk,
        })
        data = {
            'text': text,
            'instance_type': 'experiment',
            'object_id': experiment.pk,
        }
        resp = self.client.post(comment_url, data, format='json')
        self.assertEqual(resp.status_code, 201)

        resp = self.client.get(url)
        self.assertContains(resp, title(self.owner.full_name))
        self.assertContains(resp, text)
Esempio n. 40
0
 def update_livelobg_plugin_content(plugin, publish=True):
     plugin_text = words(count=3, common=False)
     plugin.body = plugin_text
     plugin.publish = publish
     plugin.save()
     __, admin = plugin.get_plugin_instance()
     admin.save_model(get_request("/"), plugin, None, None)
     return plugin, admin, plugin_text
Esempio n. 41
0
    def test_event_committee_created(self, mock_track_event):
        # Create Committee
        url = reverse('committees:create',
                      kwargs={'url': get_current_account(self).url})
        data = {
            'name': lorem_ipsum.words(2, False).capitalize()[:50],
            'chairman': self.membership_admin.id,
            'members': [self.membership_admin.id, self.membership.id],
            'summary': lorem_ipsum.words(5, True),
            'description': lorem_ipsum.words(20, True),
            'account': get_current_account(self)
        }

        response = self.client.post(url, data, follow=True)
        self.assertEqual(response.status_code, 200)
        # Signal fired
        self.assertEquals(mock_track_event.call_count, 1)
Esempio n. 42
0
 def test_change_owners_by_editor(self):
     """
     Check Editors can't change owners in experiments
     """
     collection = CollectionFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.member.pk], user=self.owner, units=self.units)
     url = reverse('collections:update', kwargs={'lab_pk': self.lab.pk, 'pk': collection.pk})
     data = {
         'owners': [self.member.pk],
         'editors': [self.owner.pk],
         'description': lorem_ipsum.words(2),
         'title': lorem_ipsum.words(2),
     }
     self.client.login(username=self.member.email, password='******')
     resp = self.client.post(url, data, follow=True)
     self.assertEqual(resp.status_code, 200)
     self.assertContains(resp, 'You have not permission change owners', 1)
     self.assertEqual(Collection.objects.first().owners, [self.owner])
Esempio n. 43
0
def create_fake_data():
    # create some fake data to make sure we need to paginate
    if Person.objects.all().count() < 50:
        countries = list(Country.objects.all()) + [None]
        Person.objects.bulk_create([
            Person(name=words(3, common=False), country=choice(countries))
            for i in range(50)
        ])
Esempio n. 44
0
    def setUp(self):
        self.owner = UserFactory()
        self.member = UserFactory()
        self.guest = UserFactory()
        self.user4 = UserFactory()

        data = {"name": lorem_ipsum.words(1, False), "investigator": [self.owner.pk], "members": [self.member.pk]}
        self.lab = LabFactory(**data)
Esempio n. 45
0
 def test_common_words_in_string(self):
     """words(n) starts with the 19 standard lorem ipsum words for n > 19."""
     self.assertTrue(
         words(25).startswith(
             'lorem ipsum dolor sit amet consectetur adipisicing elit sed '
             'do eiusmod tempor incididunt ut labore et dolore magna aliqua'
         )
     )
Esempio n. 46
0
 def _generate_tags(self):
     """Сгенерировать теги для нескольких случайных фотографий."""
     tag_words = words(self.number_of_tags).split()
     for photo in Photo.objects.order_by('?')[:1000]:
         sample_length = random.randrange(
             0, self.average_tags_per_photo * 2)
         if sample_length:
             selected_tags = random.sample(tag_words, sample_length)
             photo.update_tags(selected_tags)
Esempio n. 47
0
    def test_recent_all_activity_view(self):

        experiment = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.guest.pk])

        url = reverse('dashboard:all-activity', kwargs={'lab_pk': self.lab.pk})
        resp = self.client.get(url)
        self.assertNotEqual(resp.status_code, 200)
        self.client.login(username=self.owner.email, password='******')
        resp = self.client.get(url)
        self.assertContains(resp, u'timeline')

        #Update experiment
        exp_url = reverse('experiments:update', kwargs={'lab_pk': self.lab.pk, 'pk': experiment.pk})
        data = {
            'owners': [self.owner.pk],
            'start': experiment.start.strftime('%m/%d/%Y %H:%M'),
            'end': experiment.end.strftime('%m/%d/%Y %H:%M'),
            'description': lorem_ipsum.words(2),
            'title': experiment.title,
            'status': experiment.status
        }
        resp = self.client.post(exp_url, data, follow=True)
        resp = self.client.get(url)
        self.assertContains(resp, title(self.owner.full_name))
        self.assertContains(resp, experiment.title)

        # Add comment
        text = lorem_ipsum.words(2)
        comment_url = reverse('comment:api-list', kwargs={
            'lab_pk': self.lab.pk,
            'instance_type': 'experiment',
            'object_id': experiment.pk,
        })
        data = {
            'text': text,
            'instance_type': 'experiment',
            'object_id': experiment.pk,
        }
        resp = self.client.post(comment_url, data, format='json')
        self.assertEqual(resp.status_code, 201)

        resp = self.client.get(url)
        self.assertContains(resp, title(self.owner.full_name))
        self.assertContains(resp, text)
Esempio n. 48
0
 def test_change_owners_by_editor(self):
     """
     Check Editors can't change owners in experiments
     """
     experiment = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.member.pk])
     url = reverse('experiments:update', kwargs={'lab_pk': self.lab.pk, 'pk': experiment.pk})
     data = {
         'owners': [self.member.pk],
         'editors': [self.owner.pk],
         'start': timezone.now().strftime('%m/%d/%Y %H:%M'),
         'end': timezone.now().strftime('%m/%d/%Y %H:%M '),
         'description': lorem_ipsum.words(2),
         'title': lorem_ipsum.words(2),
         'status': Experiment.STATUS[0][0]
     }
     self.client.login(username=self.member.email, password='******')
     resp = self.client.post(url, data, follow=True)
     self.assertEqual(resp.status_code, 200)
     self.assertContains(resp, 'You have not permission change owners', 1)
     self.assertEqual(list(Experiment.objects.all().first().owners.all()), [self.owner])
Esempio n. 49
0
    def setUp(self):
        self.owner = UserFactory()
        self.member = UserFactory()
        self.guest = UserFactory()
        self.user4 = UserFactory()

        data = {
            'name': lorem_ipsum.words(1, False),
            'investigator': [self.owner.pk],
            'members': [self.member.pk],
        }
        self.lab = LabFactory(**data)
Esempio n. 50
0
 def render(self, context):
     try:
         count = int(self.count.resolve(context))
     except (ValueError, TypeError):
         count = 1
     if self.method == 'w':
         return words(count, common=self.common)
     else:
         paras = paragraphs(count, common=self.common)
     if self.method == 'p':
         paras = ['<p>%s</p>' % p for p in paras]
     return '\n\n'.join(paras)
Esempio n. 51
0
def create_fake_data():
    # create some fake data to make sure we need to paginate
    if Country.objects.all().count() < 50:
        for country in COUNTRIES.splitlines():
            name, population = country.split(";")
            Country.objects.create(name=name, visits=0, population=int(population))

    if Person.objects.all().count() < 500:
        countries = list(Country.objects.all()) + [None]
        Person.objects.bulk_create(
            [Person(name=words(3, common=False), country=choice(countries)) for i in range(50)]
        )
Esempio n. 52
0
 def render(self, context):
     try:
         count = int(self.count.resolve(context))
     except (ValueError, TypeError):
         count = 1
     if self.method == "w":
         return words(count, common=self.common)
     else:
         paras = paragraphs(count, common=self.common)
     if self.method == "p":
         paras = ["<p>%s</p>" % p for p in paras]
     return "\n\n".join(paras)
Esempio n. 53
0
    def test_recent_experiment_activity_view(self):

        experiment = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.guest.pk])
        experiment2 = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.guest.pk])

        url = reverse('dashboard:experiment-all-activity', kwargs={'lab_pk': self.lab.pk, 'experiment_pk': experiment.pk})
        resp = self.client.get(url)
        self.assertNotEqual(resp.status_code, 200)
        self.client.login(username=self.owner.email, password='******')
        resp = self.client.get(url)
        self.assertContains(resp, u'timeline')

        #Update experiment
        exp_url = reverse('experiments:update', kwargs={'lab_pk': self.lab.pk, 'pk': experiment.pk})
        data = {
            'owners': [self.owner.pk],
            'start': experiment.start.strftime('%m/%d/%Y %H:%M'),
            'end': experiment.end.strftime('%m/%d/%Y %H:%M'),
            'description': lorem_ipsum.words(2),
            'title': experiment.title,
            'status': experiment.status
        }
        resp = self.client.post(exp_url, data, follow=True)
        resp = self.client.get(url)
        self.assertContains(resp, title(self.owner.full_name))
        self.assertContains(resp, experiment.title)

        #Update experiment2
        exp_url = reverse('experiments:update', kwargs={'lab_pk': self.lab.pk, 'pk': experiment2.pk})
        data = {
            'owners': [self.owner.pk],
            'start': experiment.start.strftime('%m/%d/%Y %H:%M'),
            'end': experiment.end.strftime('%m/%d/%Y %H:%M'),
            'description': lorem_ipsum.words(2),
            'title': experiment2.title,
            'status': experiment.status
        }
        resp = self.client.post(exp_url, data, follow=True)
        resp = self.client.get(url)
        self.assertNotContains(resp, experiment2.title)
Esempio n. 54
0
    def test_update(self):
        experiment1 = ExperimentFactory(lab=self.lab, owners=[self.member.pk])
        unit1 = UnitFactory(lab=self.lab, user=self.owner, experiments=[experiment1])
        collection = CollectionFactory(lab=self.lab, user=self.member, owners=[self.member], units=[unit1])
        url = reverse('collections:update', kwargs={'lab_pk': self.lab.pk, 'pk': collection.pk})

        data = {
            'title': lorem_ipsum.words(3, False),
            'units': [unicode(unit.pk) for unit in collection.units],
            'owners': [self.owner.pk],
        }

        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, _('Login'))

        self.client.login(username=self.owner.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(Collection.objects.first().title, data['title'])
        self.assertEqual(Collection.objects.count(), 1)

        data['title'] = lorem_ipsum.words(3, False)
        self.client.login(username=self.member.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(Collection.objects.first().title, data['title'])
        self.assertEqual(Collection.objects.count(), 1)

        data['title'] = lorem_ipsum.words(3, False)
        self.client.login(username=self.guest.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, _(u'Select a valid choice. {} is not one of the available choices.'.format(unit1.pk)), 1)
        self.assertEqual(Collection.objects.count(), 1)

        self.client.login(username=self.user4.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 403)
        self.assertEqual(Collection.objects.count(), 1)
Esempio n. 55
0
    def test_recent_experiment_activity_view(self):

        experiment = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.guest.pk])
        experiment2 = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.guest.pk])

        url = reverse("dashboard:api-experiment-all", kwargs={"lab_pk": self.lab.pk, "experiment_pk": experiment.pk})
        resp = self.client.get(url)
        self.assertNotEqual(resp.status_code, 200)
        self.client.login(username=self.owner.email, password="******")
        resp = self.client.get(url)
        self.assertEqual(resp.status_code, 200)

        # Update experiment
        exp_url = reverse("experiments:update", kwargs={"lab_pk": self.lab.pk, "pk": experiment.pk})
        data = {
            "owners": [self.owner.pk],
            "start": experiment.start.strftime("%m/%d/%Y %H:%M"),
            "end": experiment.end.strftime("%m/%d/%Y %H:%M"),
            "description": lorem_ipsum.words(2),
            "title": experiment.title,
            "status": experiment.status,
        }
        resp = self.client.post(exp_url, data, follow=True)
        resp = self.client.get(url)
        self.assertContains(resp, self.owner.full_name)
        self.assertContains(resp, experiment.title)

        # Update experiment2
        exp_url = reverse("experiments:update", kwargs={"lab_pk": self.lab.pk, "pk": experiment2.pk})
        data = {
            "owners": [self.owner.pk],
            "start": experiment.start.strftime("%m/%d/%Y %H:%M"),
            "end": experiment.end.strftime("%m/%d/%Y %H:%M"),
            "description": lorem_ipsum.words(2),
            "title": experiment2.title,
            "status": experiment.status,
        }
        resp = self.client.post(exp_url, data, follow=True)
        resp = self.client.get(url)
        self.assertNotContains(resp, experiment2.title)
Esempio n. 56
0
    def test_recent_all_activity_view(self):

        experiment = ExperimentFactory(lab=self.lab, owners=[self.owner.pk], editors=[self.guest.pk])

        url = reverse("dashboard:api-all", kwargs={"lab_pk": self.lab.pk})
        resp = self.client.get(url)
        self.assertNotEqual(resp.status_code, 200)
        self.client.login(username=self.owner.email, password="******")
        resp = self.client.get(url)
        self.assertEqual(resp.status_code, 200)

        # Update experiment
        exp_url = reverse("experiments:update", kwargs={"lab_pk": self.lab.pk, "pk": experiment.pk})
        data = {
            "owners": [self.owner.pk],
            "start": experiment.start.strftime("%m/%d/%Y %H:%M"),
            "end": experiment.end.strftime("%m/%d/%Y %H:%M"),
            "description": lorem_ipsum.words(2),
            "title": experiment.title,
            "status": experiment.status,
        }
        resp = self.client.post(exp_url, data, follow=True)
        resp = self.client.get(url)
        self.assertContains(resp, self.owner.full_name)
        self.assertContains(resp, experiment.title)

        # Add comment
        text = lorem_ipsum.words(2)
        comment_url = reverse(
            "comment:api-list",
            kwargs={"lab_pk": self.lab.pk, "instance_type": "experiment", "object_id": experiment.pk},
        )
        data = {"text": text, "instance_type": "experiment", "object_id": experiment.pk}
        resp = self.client.post(comment_url, data, format="json")
        self.assertEqual(resp.status_code, 201)

        resp = self.client.get(url)
        self.assertContains(resp, self.owner.full_name)
        self.assertContains(resp, text)
Esempio n. 57
0
    def create(self, tr):
        self.tds = tr.find_elements_by_tag_name('td')

        actions = ActionChains(self.driver)
        actions.move_to_element(self.tds[1])
        actions.double_click()
        actions.send_keys(lorem_ipsum.words(1, False))
        actions.perform()

        actions.move_to_element(self.tds[2])
        actions.double_click()
        actions.perform()

        self.driver.select('select.htSelectEditor', unicode(self.experiment.pk))
        self.driver.click('body')
Esempio n. 58
0
def bootstrap(request):
    '''Demonstrate the use of the bootstrap template'''
    # create some fake data to make sure we need to paginate
    if Person.objects.all().count() < 50:
        countries = list(Country.objects.all()) + [None]
        Person.objects.bulk_create([
            Person(name=words(3, common=False), country=choice(countries))
            for i in range(50)
        ])

    table = BootstrapTable(Person.objects.all())
    RequestConfig(request, paginate={"per_page": 10}).configure(table)

    return render(request, 'bootstrap_template.html', {
        'table': table
    })
Esempio n. 59
0
 def generate(self):
     if self.method == 'w':
         lorem = lorem_ipsum.words(self.count, common=self.common)
     elif self.method == 's':
         lorem = u' '.join([
                               lorem_ipsum.sentence()
                               for i in range(self.count)])
     else:
         paras = lorem_ipsum.paragraphs(self.count, common=self.common)
         if self.method == 'p':
             paras = ['<p>%s</p>' % p for p in paras]
         lorem = u'\n\n'.join(paras)
     if self.max_length:
         length = random.randint(round(int(self.max_length) / 10),
                                 self.max_length)
         lorem = lorem[:max(1, length)]
     return lorem.strip()
Esempio n. 60
0
    def test_create_lab(self):
        url = reverse('labs:create')
        name = lorem_ipsum.words(1, False)
        data = {
            'name': name,
            'investigator': [self.owner.pk],
            'members': [self.member.pk],
        }
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertContains(resp, _('Login'))

        self.client.login(username=self.owner.email, password='******')
        resp = self.client.post(url, data, follow=True)
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(Lab.objects.count(), 1)
        self.assertEqual(Lab.objects.all().first().name, name)