Пример #1
0
 def test_creates_profile(self):
     """Should create a profile if a user doesn't have one."""
     user_without_profile = UserFactory()
     self.login(user_without_profile)
     self.client.get(self.get_url())
     profile = user_without_profile.get_profile()
     self.assertTrue(profile.pk)
Пример #2
0
 def test_creates_profile(self):
     """Should create a profile if a user doesn't have one."""
     user_without_profile = UserFactory()
     self.login(user_without_profile)
     self.client.get(self.get_url())
     profile = user_without_profile.get_profile()
     self.assertTrue(profile.pk)
    def setUp(self):
        self.entry = factories.NewsEntryFactory(pub_date=now() -
                                                timedelta(days=1))
        self.en_trans = self.entry.translations.get(language_code='en')

        self.user = UserFactory()
        self.admin = UserFactory(is_superuser=True)
 def setUp(self):
     self.user = UserFactory()
     self.content_object = UserFactory()
     self.review = factories.ReviewFactory(
         user=self.user,
         reviewed_item=self.content_object)
     self.other_user = UserFactory()
 def setUp(self):
     super(DashboardRenderWidgetViewTestCase, self).setUp()
     dashboard_widget_pool.discover_widgets()
     self.superuser = UserFactory(is_superuser=True)
     self.normal_user = UserFactory()
     self.data = {
         'name': 'DummyWidget',
     }
    def setUp(self):
        super(DashboardLastUpdateViewTestCase, self).setUp()
        self.superuser = UserFactory(is_superuser=True)
        self.normal_user = UserFactory()

        # This ensures that we have one last update in the database
        dashboard_widget_pool.get_widgets_that_need_update()
        time.sleep(1)
Пример #7
0
    def test_create_event(self):
        user = UserFactory()
        content_object = UserFactory()
        event = ObjectEvent.create_event(user, content_object)
        self.assertIsInstance(event, ObjectEvent)
        self.assertEqual(ObjectEvent.objects.all().count(), 1)
        self.assertEqual(ObjectEventType.objects.all().count(), 1)

        # Test with a new content_object, created for this event
        event_content_object = UserFactory()
        event = ObjectEvent.create_event(user, content_object,
                                         event_content_object)
        self.assertEqual(event.event_content_object, event_content_object)
Пример #8
0
 def setUp(self):
     self.user = UserFactory()
     # User needs this permission to access the create view.
     self.user.user_permissions.add(
         Permission.objects.get(codename="add_tinylink"))
     self.user.user_permissions.add(
         Permission.objects.get(codename="delete_tinylink"))
     self.tinylink = TinylinkFactory(user=self.user)
     self.second_user = UserFactory()
     self.second_user.user_permissions.add(
         Permission.objects.get(codename="add_tinylink"))
     self.second_user.user_permissions.add(
         Permission.objects.get(codename="delete_tinylink"))
     self.staff = UserFactory(is_staff=True, is_superuser=True)
Пример #9
0
 def test_get_user(self):
     self.assertEqual(self.review.get_user(), 'Anonymous', msg=(
         'Should return anonymous.'))
     self.user = UserFactory()
     self.review.user = self.user
     self.assertEqual(self.review.get_user(), self.user.email, msg=(
         'Should return a user\'s email.'))
Пример #10
0
    def test_form(self):
        data = {
            'feedback-email': '*****@*****.**',
            'feedback-message': 'Foo',
            'feedback-url': 'http://www.example.com',
        }
        form = FeedbackForm(data=data)
        self.assertTrue(form.is_valid())
        form.save()
        self.assertEqual(Message.objects.all().count(), 0)
        self.assertEqual(Feedback.objects.all().count(), 0)

        # Valid post
        data.update({'feedback-url': ''})
        form = FeedbackForm(data=data)
        self.assertTrue(form.is_valid())
        form.save()
        self.assertEqual(Message.objects.all().count(), 1)
        self.assertEqual(Feedback.objects.all().count(), 1)
        self.assertEqual(Feedback.objects.all()[0].message, 'Foo')
        self.assertEqual(Feedback.objects.all()[0].email, '*****@*****.**')
        Feedback.objects.all()[0].delete()
        Message.objects.all()[0].delete()

        # Valid post with user account
        user = UserFactory()
        data.update({'feedback-email': ''})
        form = FeedbackForm(data=data, user=user)
        self.assertTrue(form.is_valid())
        form.save()
        self.assertEqual(Message.objects.all().count(), 1)
        self.assertEqual(Feedback.objects.all().count(), 1)
        self.assertEqual(Feedback.objects.all()[0].message, 'Foo')
        self.assertEqual(Feedback.objects.all()[0].user, user)
Пример #11
0
    def test_adds_tag_list_to_form(self):
        """
        Should add the available tags for each given tag field to the form.

        This enables users to do this in their templates::

            $(document).ready(function() {
                $('#id_skills').tagit({
                    allowSpaces: true
                    ,availableTags: {{ form.available_tags_technical_skills|safe }}
                    ,caseSensitive: false
                    ,removeConfirmation: true
                });
            }

        """
        form = DummyModelForm(self.user, data=self.data)
        form.save()
        result = form.tags_tags_values()
        self.assertEqual(result, '["cinema", "family", "great day"]')
        result = form.global_tags_tags_values()
        self.assertEqual(result, '["bar", "foo"]')

        user2 = UserFactory()
        form = DummyModelForm(user2)
        result = form.tags_tags_values()
        self.assertEqual(result, '[]', msg=(
            'A user should not be able to see the private tags of another'
            ' user.'))

        form = DummyModelForm()
        result = form.tags_tags_values()
        self.assertEqual(result, '[]', msg=(
            'An anonymous user should not be able to see user specific tags.'))
Пример #12
0
    def test_handler(self):
        user = UserFactory()
        profile = UserProfileFactory(user=user)

        #empty response
        facebook_extra_values(self, user, {}, {})

        # This is how the response from facebook looks like. It contains many
        # more values but we only use these few.
        response = {
            'birthday': '09/08/1982',
            'gender': 'male',
            'username': '******',
            'first_name': 'Foo',
            'last_name': 'Bar',
            'location': {
                'id': '101883206519751',
                'name': 'Singapore, Singapore',
            },
        }
        facebook_extra_values(self, user, response, {})

        profile = UserProfile.objects.get(pk=profile.pk)
        self.assertEqual(profile.birthday,
                         timezone.datetime(1982, 9, 8).date(),
                         msg=('Should set the birthday correctly'))
        self.assertEqual(profile.gender,
                         'male',
                         msg=('Should set the gender correctly'))
        self.assertEqual(profile.location,
                         'Singapore, Singapore',
                         msg=('Should set the location correctly'))
    def setUp(self):
        self.user = UserFactory()
        self.item = ItemFactory()

        self.paypal_response = {
            'ACK': ['Success'],
            'TOKEN': ['abc123'],
        }

        self.expected_response = {
            'USER': settings.PAYPAL_USER,
            'PWD': settings.PAYPAL_PWD,
            'SIGNATURE': settings.PAYPAL_SIGNATURE,
            'VERSION': '91.0',
            'PAYMENTREQUEST_0_PAYMENTACTION': 'Sale',
            'METHOD': 'SetExpressCheckout',
            'L_PAYMENTREQUEST_0_NAME0': self.item.name,
            'L_PAYMENTREQUEST_0_DESC0': self.item.description,
            'L_PAYMENTREQUEST_0_AMT0': self.item.value,
            'L_PAYMENTREQUEST_0_QTY0': 1,
            'PAYMENTREQUEST_0_AMT': self.item.value,
            'PAYMENTREQUEST_0_ITEMAMT': self.item.value,
            'RETURNURL': settings.HOSTNAME + reverse('paypal_confirm'),
            'CANCELURL': settings.HOSTNAME + reverse('paypal_canceled')
        }
        self.data = {
            'item': self.item.pk,
            'quantity': 1,
        }

        self.old_call_paypal = PayPalFormMixin.call_paypal
        PayPalFormMixin.call_paypal = Mock(return_value=self.paypal_response)
Пример #14
0
 def setUp(self):
     """Creates a user and valid set of form data."""
     self.user = UserFactory()
     self.data = {
         'name': 'dummy',
         'tags': 'great day,family, cinema ',
         'global_tags': 'foo, bar',
     }
Пример #15
0
 def test_save_with_user(self):
     """Should create a checkin when user is given."""
     user = UserFactory()
     form = CheckinCreateForm(user=user, place=self.place, data=self.data)
     self.assertTrue(form.is_valid(),
                     msg=('Errors: {0}'.format(form.errors.items())))
     instance = form.save()
     self.assertTrue(instance.pk)
Пример #16
0
    def setUp(self):
        self.tagged_item = factories.TaggedItemFactory()
        self.dummy = self.tagged_item.object
        self.tag = self.tagged_item.tag
        self.other_tagged_item = factories.TaggedItemFactory(object=self.dummy)

        factories.TaggedItemFactory()

        self.user_item = factories.TaggedItemFactory(object=UserFactory())
Пример #17
0
 def test_method(self):
     user = UserFactory()
     create_profile_for_new_user(user)
     self.assertEqual(
         UserProfile.objects.all().count(),
         1,
         msg=(
             'When called with a new user it should create a new profile for'
             ' this user'))
Пример #18
0
 def test_save(self):
     """Should create a new subscription."""
     user = UserFactory()
     dummy = DummyModelFactory()
     form = SubscriptionCreateForm(user=user, content_object=dummy, data={})
     self.assertTrue(form.is_valid(),
                     msg=('Errors: {0}'.format(form.errors.items())))
     instance = form.save()
     self.assertTrue(instance.pk)
Пример #19
0
 def test_handler(self):
     user = UserFactory()
     new_users_handler(self, user, {}, {})
     self.assertEqual(
         UserProfile.objects.all().count(),
         1,
         msg=(
             'When called with a new user it should create a new profile for'
             ' this user'))
Пример #20
0
 def test_should_save_user_profile(self):
     user = UserFactory.create()
     user_registered_handler(self, user, {})
     self.assertEqual(
         UserProfile.objects.all().count(),
         1,
         msg=(
             'When called with a new user it should create a new profile for'
             ' this user'))
Пример #21
0
class DatedValueFactory(factory.DjangoModelFactory):
    """Factory for the ``DatedValue`` model."""
    FACTORY_FOR = DatedValue

    date = now()
    object = factory.LazyAttribute(lambda d: UserFactory())
    object_id = factory.LazyAttribute(lambda d: d.object.id)
    type = factory.SubFactory(
        'dated_values.tests.factories.DatedValueTypeFactory')
    value = Decimal('123.12345678')
Пример #22
0
 def handle(self, *args, **options):
     # NOTE WARNING!
     # When you use this in a test run, due to it being spawned in a
     # subprocess, it will write into the real database, not the test-only
     # database! Still need to figure out how to get around this.
     # Keeping this though for manual testing.
     UserFactory()
     # many commands write to stderr, maybe we can fetch that later
     sys.stderr.write('Command output to stderr.\n')
     # maybe some also use stdout
     sys.stderr.write('Command output to stdout.\n')
Пример #23
0
 def setUp(self):
     self.type1 = DatedValueTypeFactory()
     self.type2 = DatedValueTypeFactory()
     self.types = [self.type1, self.type2]
     self.user = UserFactory()
     self.staff = UserFactory(is_staff=True)
     self.superuser = UserFactory(is_superuser=True)
     self.ctype = ContentType.objects.get_for_model(User)
     self.data = {
         'date': (now() + relativedelta(days=30)).strftime(
             app_settings.DATE_FORMAT),
         'form-TOTAL_FORMS':
         u'2',
         'form-INITIAL_FORMS':
         u'2',
     }
     for i in range(0, 2):
         for j in range(0, 14):
             self.data.update(
                 {'form-{0}-value{1}'.format(i, j): '{0}.12'.format(j)})
Пример #24
0
 def setUp(self):
     self.type1 = DatedValueTypeFactory()
     self.type2 = DatedValueTypeFactory()
     self.types = [self.type1, self.type2]
     self.user = UserFactory()
     self.data = {
         'form-TOTAL_FORMS': u'2',
         'form-INITIAL_FORMS': u'2',
     }
     for i in range(0, 2):
         for j in range(0, 14):
             self.data.update(
                 {'form-{0}-value{1}'.format(i, j): '{0}.12'.format(j)})
    def setUp(self):
        self.user = UserFactory()
        self.item = ItemFactory()

        self.paypal_response = {
            'ACK': ['Success'],
            'TOKEN': ['abc123'],
        }

        self.data = {
            'item': self.item.pk,
            'quantity': 1,
        }
 def setUp(self):
     self.content_object = UserFactory()
     self.review = factories.ReviewFactory(
         reviewed_item=self.content_object)
     self.rating1 = factories.RatingFactory(review=self.review, value='4')
     # we create choices to simulate, that the previous value was the max
     for i in range(0, 5):
         factories.RatingCategoryChoiceFactory(
             ratingcategory=self.rating1.category, value=i)
     self.rating2 = factories.RatingFactory(review=self.review, value='6')
     # we create choices to simulate, that the previous value was the max
     for i in range(0, 7):
         factories.RatingCategoryChoiceFactory(
             ratingcategory=self.rating2.category, value=i)
Пример #27
0
 def test_get_username(self):
     user = UserFactory()
     resp = get_username(details={'email': user.email}, user=user)
     self.assertEqual(
         resp, {'username': user.username},
         msg=('Should respond the username. Response was {0}'.format(resp)))
     resp = get_username(details={'email': user.email})
     self.assertEqual(
         resp, {'username': user.username},
         msg=('Should respond the username. Response was {0}'.format(resp)))
     resp = get_username(details={'email': '*****@*****.**'})
     self.assertTrue(resp['username'],
                     msg=('Should return a generated username. Response was'
                          ' {0}'.format(resp['username'])))
Пример #28
0
 def setUp(self):
     super(GetFilesForDocumentTestCase, self).setUp()
     self.user = UserFactory()
     self.img = create_image()
     self.image_name = 'test_file.jpg'
     self.filename = os.path.join(settings.MEDIA_ROOT, self.image_name)
     self.img.save(self.filename, 'JPEG')
     self.file_obj = DjangoFile(open(self.filename), name=self.image_name)
     self.image = Image.objects.create(owner=self.user,
                                       original_filename=self.image_name,
                                       file=self.file_obj)
     self.doc_en = DocumentTitleENFactory(filer_file=self.image)
     self.doc_de = DocumentTitleDEFactory(document=self.doc_en.document,
                                          filer_file=self.image)
Пример #29
0
    def test_tag(self):
        # create context mock
        request = RequestFactory().get('/')
        request.user = AnonymousUser()
        SessionMiddleware().process_request(request)
        request.session.save()
        context = RequestContext(request)

        # Returns empty dict if there is no authenticated user
        self.assertEqual(render_notifications(context), '\n')

        # Returns notifications.html
        request.user = UserFactory()
        ObjectEventFactory(user=request.user)
        self.assertTrue(render_notifications(context))
Пример #30
0
    def test_render_tag(self):
        request = RequestFactory().get('/')
        request.user = AnonymousUser()
        c = RequestContext(request)
        t = Template('{% load feedback_tags %}{% feedback_form %}')
        self.assertIn('<input type="submit" value="Send Feedback" />',
                      t.render(c))
        # Should add the email field, because user is anonymous
        self.assertIn('email', t.render(c))

        # Test with logged in user
        request.user = UserFactory()
        c = RequestContext(request)
        self.assertIn('<input type="submit" value="Send Feedback" />',
                      t.render(c))
        self.assertNotIn('email', t.render(c))
    def setUp(self):
        self.user = UserFactory()
        self.transaction = PaymentTransactionFactory(user=self.user)
        self.item = ItemFactory()

        self.paypal_response = {
            'ACK': ['Success'],
            'TOKEN': ['abc123'],
            'PAYMENTINFO_0_TRANSACTIONID': ['abc123']
        }

        self.data = {
            'item': self.item.pk,
            'quantity': 1,
        }

        self.old_call_paypal = PayPalFormMixin.call_paypal
        PayPalFormMixin.call_paypal = Mock(return_value=self.paypal_response)
Пример #32
0
 def setUp(self):
     self.content_object = UserFactory()
     self.user = UserFactory()
Пример #33
0
class ReviewCreateViewTestCase(ViewTestMixin, TestCase):
    def setUp(self):
        self.content_object = UserFactory()
        self.user = UserFactory()

    def get_view_name(self):
        return 'review_create'

    def get_view_kwargs(self):
        return {
            'content_type': ContentType.objects.get_for_model(
                self.content_object),
            'object_id': self.content_object.pk,
        }

    def user_has_perm(self, user):
        # Simulates permission for the current user
        if user.first_name:
            return True
        return False

    def test_view(self):
        wrong_kwargs = {
            'content_type': 'Foo',
            'object_id': self.content_object.pk,
        }
        self.is_not_callable(kwargs=wrong_kwargs)

        wrong_kwargs = {
            'content_type': ContentType.objects.get_for_model(
                self.content_object),
            'object_id': '999',
        }
        self.is_not_callable(kwargs=wrong_kwargs)

        self.is_callable(user=self.user, message=(
            'View should be callable by an authenticated user.'))

        with self.settings(REVIEW_AVOID_MULTIPLE_REVIEWS=True):
            has_perm = lambda u, item: self.user_has_perm(u)
            with self.settings(REVIEW_PERMISSION_FUNCTION=has_perm):
                self.is_not_callable(method='post', user=self.user, message=(
                    'View should not be callable due to missing permissions.'))
                self.assertEqual(Review.objects.count(), 0, msg=(
                    'No reviews should\'ve been created.'))
                self.user.first_name = 'Foo'
                self.user.save()
                self.is_callable(method='post', user=self.user, message=(
                    'View should be callable by an authenticated user.'))
                self.assertEqual(Review.objects.count(), 1, msg=(
                    'One review should\'ve been created.'))
            self.is_callable(
                and_redirects_to=reverse('review_update', kwargs={
                    'pk': Review.objects.all()[0].pk}),
                method='post', user=self.user, message=(
                    'View should redirect, if review alreasy exists.'))
            self.assertEqual(Review.objects.count(), 1, msg=(
                'No new review should\'ve been created.'))

        with self.settings(REVIEW_ALLOW_ANONYMOUS=True):
            self.is_callable(anonymous=True, message=(
                'View should be callable as an anonymous user.'))
Пример #34
0
 def test_should_save_user_profile(self):
     user = UserFactory.create()
     user_registered_handler(self, user, {})
     self.assertEqual(UserProfile.objects.all().count(), 1, msg=(
         'When called with a new user it should create a new profile for'
         ' this user'))