Exemple #1
0
    def setUp(self):
        set_backend(DummyCyclosBackend())

        self.group_1 = CyclosGroupFactory.create(initial=True)
        self.group_2 = CyclosGroupFactory.create()
        self.group_3 = CyclosGroupFactory.create()
        self.groupset = CyclosGroupSetFactory.create(
            groups=[self.group_1, self.group_2, self.group_3])

        self.community = CC3CommunityFactory.create(groupsets=[self.groupset])

        self.profile = CC3ProfileFactory.create(community=self.community,
                                                cyclos_group=CyclosGroupFactory(
                                                    name=settings.CYCLOS_CUSTOMER_MEMBER_GROUP))

        self.member_profile = AuthUserProfileFactory.create(
            groupset=self.groupset,
            community=self.community,
            business_name='MaykinMedia',
            web_payments_enabled=True)

        self.member_empty_profile = CC3ProfileFactory.create()

        # Create a Cyclos account for the 'member_profile'.
        self.cyclos_account = CyclosAccountFactory.create(
            cc3_profile=self.profile)
Exemple #2
0
    def setUp(self):
        self.backend = DummyCyclosBackend()
        set_backend(self.backend)

        self.group_1 = CyclosGroupFactory.create(initial=True)
        self.groupset = CyclosGroupSetFactory.create(
            groups=[self.group_1, ])
        self.community = CC3CommunityFactory.create(
            groupsets=[self.groupset], code='TST')

        # Create business with its terminal.
        self.user_1 = UserFactory.create()
        self.terminal_1 = TerminalFactory.create(business=self.user_1)
        self.token_1 = Token.objects.create(user=self.user_1)
        self.operator_1 = OperatorFactory(business=self.user_1)
        self.cc3profile_1 = CC3ProfileFactory.create(
            user=self.user_1, first_name='Test', last_name='Business',
            community=self.community, cyclos_group=self.group_1)
        self.business_settings = BusinessCauseSettingsFactory.create(
            user=self.user_1)

        # Create card users.
        self.user_2 = UserFactory.create()
        self.cc3profile_2 = CC3ProfileFactory.create(
            user=self.user_2, first_name='Test', last_name='User',
            community=self.community, cyclos_group=self.group_1)
        self.user_cause = UserCauseFactory.create(consumer=self.user_2)

        self.community_2 = CC3CommunityFactory.create(
            groupsets=[self.groupset], code='TST')

        self.user_3 = UserFactory.create()
        self.cc3profile_3 = CC3ProfileFactory.create(
            user=self.user_3, first_name='Test', last_name='User',
            community=self.community_2, cyclos_group=self.group_1)

        self.user_4 = UserFactory.create()
        self.terminal_4 = TerminalFactory.create(business=self.user_4)
        self.token_4 = Token.objects.create(user=self.user_4)
        self.operator_4 = OperatorFactory(business=self.user_4)

        self.client = self.client_class(HTTP_AUTHORIZATION='Token {0}'.format(
            self.token_1.key))
        self.card_2 = CardFactory.create(owner=self.user_2)
        self.card_3 = CardFactory.create(owner=self.user_3)

        self.url = reverse(
            'api_cards_card_reward', args=[self.card_2.number.uid_number])

        self.post_data = {
            'terminal_name': self.terminal_1.name,
            'operator_name': self.operator_1.name,
            'sender_id': self.operator_1.business.id,
            'receiver_id': self.card_2.owner.id,
            'amount': '100',
            'description': 'Reward to good cause {0}'.format(
                self.user_cause.cause)
        }
Exemple #3
0
    def setUp(self):
        self.backend = DummyCyclosBackend()
        set_backend(self.backend)

        self.consumer = CC3ProfileFactory.create()
        self.cause = CC3ProfileFactory.create()

        self.user_cause = UserCauseFactory.create(
            consumer=self.consumer.user, cause=self.cause.user)

        self.consumer.community.min_donation_percent = 20
        self.consumer.community.max_donation_percent = 60
        self.consumer.community.default_donation_percent = 40
        self.consumer.community.save()
Exemple #4
0
    def setUp(self):
        self.profile = CC3ProfileFactory.create()

        self.factory = RequestFactory()

        self.request = self.factory.get('/')
        self.request.user = self.profile.user
    def setUp(self):
        set_backend(DummyCyclosBackend())

        self.profile_1 = CC3ProfileFactory.create()
        self.profile_2 = CC3ProfileFactory.create()

        self.price_option = AdPricingOptionFactory.create(title='TBD')
        self.ad_active = AdFactory.create(price='10.0',
                                          status=AD_STATUS_ACTIVE,
                                          created_by=self.profile_1)
        self.ad_disabled = AdFactory.create(price='10.0',
                                            status=AD_STATUS_DISABLED,
                                            created_by=self.profile_1)
        self.ad_onhold = AdFactory.create(price='10.0',
                                          status=AD_STATUS_ONHOLD,
                                          created_by=self.profile_1)
Exemple #6
0
    def setUp(self):
        self.backend = DummyCyclosBackend()
        set_backend(self.backend)

        self.group_1 = CyclosGroupFactory.create(initial=True)
        self.groupset = CyclosGroupSetFactory.create(
            groups=[self.group_1, ])
        self.community = CC3CommunityFactory.create(
            groupsets=[self.groupset], code='TST')

        self.user_1 = UserFactory.create()
        self.terminal_1 = TerminalFactory.create(business=self.user_1)
        self.token_1 = Token.objects.create(user=self.user_1)
        self.operator_1 = OperatorFactory(business=self.user_1)
        self.cc3profile_1 = CC3ProfileFactory.create(
            user=self.user_1, first_name='Test', last_name='Business',
            community=self.community, cyclos_group=self.group_1)
        self.user_2 = UserFactory.create()
        self.cc3profile_2 = CC3ProfileFactory.create(
            user=self.user_2, first_name='Test', last_name='User',
            community=self.community, cyclos_group=self.group_1)

        self.user_3 = UserFactory.create()

        self.user_4 = UserFactory.create()
        self.terminal_4 = TerminalFactory.create(business=self.user_4)
        self.token_4 = Token.objects.create(user=self.user_4)
        self.operator_4 = OperatorFactory(business=self.user_4)

        self.client = self.client_class(HTTP_AUTHORIZATION='Token {0}'.format(
            self.token_1.key))
        self.card_2 = CardFactory.create(owner=self.user_2)
        self.card_3 = CardFactory.create(owner=self.user_3)

        self.community_5 = CC3CommunityFactory.create(
            groupsets=[self.groupset])
        self.user_5 = UserFactory.create()
        self.cc3profile_5 = CC3ProfileFactory.create(
            user=self.user_5, first_name='Test', last_name='User5',
            community=self.community_5, cyclos_group=self.group_1)
        self.card_5 = CardFactory.create(owner=self.user_5)
        self.blocked_card = CardFactory.create(owner=self.user_2)
        self.blocked_card.block_card()

        self.url = reverse(
            'api_cards_card_payment', args=[self.card_2.number.uid_number])
    def setUp(self):
        set_backend(DummyCyclosBackend())

        self.profile = CC3ProfileFactory.create()
        self.price_option = AdPricingOptionFactory.create(title='TBD')

        self.ad_1 = AdFactory.create(price='10.0',
                                     created_by=self.profile,
                                     status=AD_STATUS_ACTIVE)
        self.ad_2 = AdFactory.create(created_by=self.profile,
                                     price_option=self.price_option)
Exemple #8
0
    def test_failed_donation_user_not_committed(self):
        """
        Tests a failed donation when the user is not committed with any cause.
        """
        # Create new user, not related with any cause.
        consumer = CC3ProfileFactory.create()
#        default_good_cause = DefaultGoodCauseUserFactory.create(
#            community=consumer.community
#        )

        transaction = cause_reward(100, consumer.user, 1)

        self.assertIsNone(transaction)
Exemple #9
0
    def test_registration_choice_validation_error(self, mock):
        """
        Tests ``ValidationError`` raised if the user is not able to get a card.
        """
        # Mock the `can_order_card()` method to always return `False`.
        mock.return_value = False

        profile = CC3ProfileFactory.create()
        form = OwnerRegisterCardForm(profile)
        form.cleaned_data = {'registration_choice': 'Send'}

        self.assertRaisesMessage(
            ValidationError,
            _('Please fill in the necessary information in your profile for '
              'direct debit'),
            form.clean_registration_choice)
Exemple #10
0
    def setUp(self):
        set_backend(DummyCyclosBackend())

        self.ad = AdFactory.create()
        self.user = UserFactory.create(first_name='Vanessa',
                                       last_name='Gaultier',
                                       username='******',
                                       email='*****@*****.**')
        self.profile = CC3ProfileFactory.create(user=self.user)

        self.form = MarketplacePayForm(user=self.profile.user)
        self.test_data = {
            'amount': 10.0,
            'contact_name': 'Vanessa Gaultier',
            'description': 'Testing payment',
            'ad': self.ad.pk
        }
Exemple #11
0
    def setUp(self):
        set_backend(DummyCyclosBackend())

        self.user_1 = UserFactory.create()
        self.terminal_1 = TerminalFactory.create(business=self.user_1)
        self.token_1 = Token.objects.create(user=self.user_1)
        self.operator_1 = OperatorFactory(business=self.user_1)

        self.user_2 = UserFactory.create()
        self.cc3profile_2 = CC3ProfileFactory.create(user=self.user_2,
                                                     first_name='Test',
                                                     last_name='User')

        self.client = self.client_class(HTTP_AUTHORIZATION='Token {0}'.format(
            self.token_1.key))
        self.card_2 = CardFactory.create(owner=self.user_2)
        self.blocked_card = CardFactory.create(owner=self.user_2)
        self.blocked_card.block_card()
    def setUp(self):
        self.today = date.today()
        self.tomorrow = date.today() + timedelta(days=1)

        self.cyclos_group = CyclosGroupFactory.create()
        self.cc3_profile = CC3ProfileFactory.create(
            cyclos_group=self.cyclos_group)
        self.tax_regime = TaxRegime.objects.create(name="Big tax", percent=50)
        self.product = ProductFactory.create(tax_regime=self.tax_regime,
                                             max_discount_percent=25)
        self.terminal_qty_product = ProductFactory.create(
            auto_qty_type=AUTO_QTY_TYPE_TERMINALS)
        self.terminal_qty_product.user_groups.add(self.cyclos_group)
        self.terminal_qty_minus_one_product = ProductFactory.create(
            auto_qty_type=AUTO_QTY_TYPE_TERMINALS_MINUS_ONE)
        self.terminal_qty_minus_one_product.user_groups.add(self.cyclos_group)
        self.terminal_rental_product = ProductFactory.create(
            auto_assign_type=AUTO_ASSIGN_TYPE_TERMINAL_RENTAL,
            auto_qty_type=AUTO_QTY_TYPE_TERMINALS)
        self.terminal_rental_product.user_groups.add(self.cyclos_group)
Exemple #13
0
    def setUp(self):
        set_backend(DummyCyclosBackend())

        self.group_1 = CyclosGroupFactory.create(initial=True)
        self.group_2 = CyclosGroupFactory.create()
        self.group_3 = CyclosGroupFactory.create()
        self.groupset = CyclosGroupSetFactory.create(
            groups=[self.group_1, self.group_2, self.group_3])

        self.community = CC3CommunityFactory.create(
            groupsets=[self.groupset], code='TST')
        if 'cc3.rewards' in settings.INSTALLED_APPS:
            self.defaultgoodcause = DefaultGoodCauseUserFactory.create(
                community=self.community
            )
        self.reg_code = CommunityRegistrationCodeFactory.create(code="I",
            community=self.community, groupset=self.groupset)

        self.user = UserFactory.create()
        self.profile = CC3ProfileFactory.create(community=self.community)
        self.terminal_1 = TerminalFactory.create(business=self.profile.user)
        self.token_1 = Token.objects.create(user=self.profile.user)
        self.operator_1 = OperatorFactory(business=self.profile.user)

        self.client = self.client_class(HTTP_AUTHORIZATION='Token {0}'.format(
            self.token_1.key))

        # Invalid user (does not have any CC3Profile related, no business
        # available then).
        self.terminal_2 = TerminalFactory.create(business=self.user)
        self.token_2 = Token.objects.create(user=self.user)
        self.operator_2 = OperatorFactory(business=self.user)
        self.client_bad = self.client_class(
            HTTP_AUTHORIZATION='Token {0}'.format(self.token_2.key))

        self.card_number = CardNumberFactory.create(number='12345')
        self.url = reverse(
            'api_cards_card_new_account_detail', args=[
                self.card_number.uid_number])