def test_pay_method(self):
self.mocks['sale'].create.return_value = successful_method()
self.product_mock.get('moz-brick').recurrence = None
seller, seller_product = create_seller()
method = create_method(create_braintree_buyer()[1])
res = self.client.post(
self.url,
data={
'amount': '10.00',
'paymethod': method.get_uri(),
'product_id': 'moz-brick'
}
)
self.mocks['sale'].create.assert_called_with({
'amount': Decimal('10.00'),
'type': 'sale',
'options': {'submit_for_settlement': True},
'payment_method_token': mock.ANY}
)
eq_(res.status_code, 200)
generic = res.json['mozilla']['generic']
eq_(generic['buyer'], method.braintree_buyer.buyer.get_uri())
braintree = res.json['mozilla']['braintree']
eq_(braintree['paymethod'], method.get_uri())
def test_plan_is_not_a_configured_product(self):
seller, prod = create_seller(seller_product_data={
'public_id': 'plan-id-not-in-config',
})
form = self.submit(expect_errors=True, data={'plan': prod.public_id})
assert 'plan' in form.errors, form.errors.as_text()
eq_(form.errors.as_data()['plan'][0].code, 'no_configured_product')
def test_ok(self):
self.mocks['sale'].create.return_value = successful_method()
self.product_mock.get('moz-brick').recurrence = None
seller, seller_product = create_seller()
res = self.client.post(
self.url,
data={
'amount': 10,
'nonce': 'some-nonce',
'product_id': 'moz-brick'
})
self.mocks['sale'].create.assert_called_with({
'amount': Decimal('10'),
'type': 'sale',
'options': {'submit_for_settlement': True},
'payment_method_nonce': u'some-nonce'}
)
eq_(res.status_code, 200)
generic = res.json['mozilla']['generic']
eq_(generic['buyer'], None)
eq_(generic['uid_support'], 'test-id')
eq_(generic['seller'], seller.get_uri())
eq_(generic['seller_product'], seller_product.get_uri())
def test_plan_amount_is_customizable(self):
seller, prod = create_seller(seller_product_data={
'public_id': 'charity-donation-monthly',
})
self.submit(data={
'plan': prod.public_id,
'amount': '1.99',
})
def setUp(self):
self.buyer, self.braintree_buyer = create_braintree_buyer()
self.method = create_method(self.braintree_buyer)
self.seller, self.seller_product = create_seller()
self.sub = create_subscription(self.method, self.seller_product)
self.url = reverse('braintree:mozilla:transaction-list')
self.transaction = Transaction.objects.create(uuid='some:uid')
super(TestBraintreeTransactionrMethod, self).setUp()
def test_different_amount_for_fixed_price(self):
seller, seller_product = create_seller()
form, errors = self.process({
'amount': '1.23',
'nonce': 'nonce',
'product_id': seller_product.public_id
})
eq_(errors.as_data()['amount'][0].code, 'invalid')
def test_recurring(self):
seller, seller_product = create_seller()
form, errors = self.process({
'amount': '10.00',
'nonce': 'nonce',
'product_id': seller_product.public_id
})
eq_(form.errors.as_data()['product_id'][0].code, 'invalid')
def test_plan_amount_is_customizable(self):
seller, prod = create_seller(seller_product_data={
'public_id': 'charity-donation-monthly',
})
self.submit(data={
'plan': prod.public_id,
'amount': '1.99',
})
def test_recurring(self):
seller, seller_product = create_seller()
form, errors = self.process({
'amount': '10.00',
'nonce': 'nonce',
'product_id': seller_product.public_id
})
eq_(form.errors.as_data()['product_id'][0].code, 'invalid')
def test_different_amount_for_fixed_price(self):
seller, seller_product = create_seller()
form, errors = self.process({
'amount': '1.23',
'nonce': 'nonce',
'product_id': seller_product.public_id
})
eq_(errors.as_data()['amount'][0].code, 'invalid')
def test_allow_variable_amounts_for_donations(self):
seller, seller_product = create_seller(
seller_product_data={'public_id': 'charity-donation'})
form, errors = self.process({
'amount': '99.00',
'nonce': 'nonce',
'product_id': seller_product.public_id
})
assert not errors, errors.as_text()
def setUp(self):
self.buyer, self.braintree_buyer = create_braintree_buyer()
self.method = create_method(self.braintree_buyer)
self.seller, self.seller_product = create_seller()
self.sub = create_subscription(self.method, self.seller_product)
self.url = reverse('braintree:mozilla:transaction-list')
self.transaction = Transaction.objects.create(uuid='some:uid',
buyer=self.buyer)
super(TestBraintreeTransaction, self).setUp()
def test_plan_is_not_a_configured_product(self):
seller, prod = create_seller(seller_product_data={
'public_id': 'plan-id-not-in-config',
})
form = self.submit(expect_errors=True,
data={'plan': prod.public_id})
assert 'plan' in form.errors, form.errors.as_text()
eq_(form.errors.as_data()['plan'][0].code,
'no_configured_product')
def setUp(self):
self.buyer, self.braintree_buyer = create_braintree_buyer()
self.method = create_method(self.braintree_buyer)
self.seller, self.seller_product = create_seller()
self.braintree_sub = BraintreeSubscription.objects.create(
paymethod=self.method,
seller_product=self.seller_product,
provider_id='some-bt:id')
self.sub = subscription(id='some-bt:id')
def setUp(self):
self.buyer, self.braintree_buyer = create_braintree_buyer()
self.method = create_method(self.braintree_buyer)
self.seller, self.seller_product = create_seller()
self.braintree_sub = BraintreeSubscription.objects.create(
paymethod=self.method,
seller_product=self.seller_product,
provider_id='some-bt:id'
)
self.sub = subscription(id='some-bt:id')
def test_allow_variable_amounts_for_donations(self):
seller, seller_product = create_seller(
seller_product_data={'public_id': 'charity-donation'}
)
form, errors = self.process({
'amount': '99.00',
'nonce': 'nonce',
'product_id': seller_product.public_id
})
assert not errors, errors.as_text()
def test_plan_requires_an_amount(self):
seller, prod = create_seller(seller_product_data={
'public_id': 'charity-donation-monthly',
})
# Submit the form without defining an amount.
form = self.submit(expect_errors=True, data={
'plan': prod.public_id,
})
assert 'amount' in form.errors, form.errors.as_text()
eq_(form.errors.as_data()['amount'][0].code,
'subscription_amount_missing')
def test_plan_requires_an_amount(self):
seller, prod = create_seller(seller_product_data={
'public_id': 'charity-donation-monthly',
})
# Submit the form without defining an amount.
form = self.submit(expect_errors=True, data={
'plan': prod.public_id,
})
assert 'amount' in form.errors, form.errors.as_text()
eq_(form.errors.as_data()['amount'][0].code,
'subscription_amount_missing')
def test_ok(self):
seller, seller_product = create_seller()
self.product_mock.get('moz-brick').recurrence = None
form, errors = self.process({
'amount': '10.00',
'nonce': 'noncey',
'product_id': seller_product.public_id
})
assert not errors, errors.as_text()
assert 'payment_method_token' not in form.braintree_data
eq_(form.braintree_data['payment_method_nonce'], 'noncey')
def test_multiple(self):
self.mocks['sale'].create.return_value = successful_method()
self.product_mock.get('moz-brick').recurrence = None
seller, seller_product = create_seller()
data = {'amount': 10, 'nonce': 123, 'product_id': 'moz-brick'}
res = self.client.post(self.url, data=data)
eq_(res.status_code, 200, res.content)
self.mocks['sale'].create.return_value = successful_method(id='two-id')
res = self.client.post(self.url, data=data)
eq_(res.status_code, 200, res.content)
def test_ok(self):
seller, seller_product = create_seller()
self.product_mock.get('moz-brick').recurrence = None
form, errors = self.process({
'amount': '10.00',
'nonce': 'noncey',
'product_id': seller_product.public_id
})
assert not errors, errors.as_text()
assert 'payment_method_token' not in form.braintree_data
eq_(form.braintree_data['payment_method_nonce'], 'noncey')
def test_ok_method(self):
seller, seller_product = create_seller()
self.product_mock.get('moz-brick').recurrence = None
method = create_method(create_braintree_buyer()[1])
form, errors = self.process({
'amount': '10.00',
'paymethod': method.get_uri(),
'product_id': seller_product.public_id
})
assert not errors, errors.as_text()
assert 'payment_method_nonce' not in form.braintree_data
eq_(form.braintree_data['payment_method_token'], method.provider_id)
def test_ok_method(self):
seller, seller_product = create_seller()
self.product_mock.get('moz-brick').recurrence = None
method = create_method(create_braintree_buyer()[1])
form, errors = self.process({
'amount': '10.00',
'paymethod': method.get_uri(),
'product_id': seller_product.public_id
})
assert not errors, errors.as_text()
assert 'payment_method_nonce' not in form.braintree_data
eq_(form.braintree_data['payment_method_token'], method.provider_id)
def test_create_with_custom_amount(self):
self.mocks['sub'].create.return_value = successful_subscription()
buyer, braintree_buyer = create_braintree_buyer()
seller, seller_product = create_seller(seller_product_data={
'public_id': 'charity-donation-monthly',
})
method = create_method(braintree_buyer)
res = self.post(paymethod=method.get_uri(), amount='4.99',
plan=seller_product.public_id)
eq_(res.status_code, 201, res.content)
subscription = BraintreeSubscription.objects.get()
eq_(subscription.amount, Decimal('4.99'))
# Make sure price is in braintree creation.
data = self.mocks['sub'].create.call_args[0][0]
eq_(data['price'], '4.99')
def test_patch_read_only(self):
obj = self.create()
paymethod = create_method(self.braintree_buyer)
seller, seller_product = create_seller()
data = {
'paymethod': paymethod.get_uri(),
'seller_product': seller_product.get_uri(),
'provider_id': 'different:id',
}
res = self.client.patch(obj.get_uri(), data=data)
eq_(res.status_code, 200, res.content)
res = self.client.get(obj.get_uri())
eq_(res.json['paymethod'], self.method.get_uri())
eq_(res.json['seller_product'], self.seller_product.get_uri())
eq_(res.json['provider_id'], 'some:id')
def test_patch_read_only(self):
obj = self.create()
paymethod = create_method(self.braintree_buyer)
seller, seller_product = create_seller(seller_product_data={"public_id": "a-different-brick"})
data = {
"paymethod": paymethod.get_uri(),
"seller_product": seller_product.get_uri(),
"provider_id": "different:id",
}
res = self.client.patch(obj.get_uri(), data=data)
eq_(res.status_code, 200, res.content)
res = self.client.get(obj.get_uri())
eq_(res.json["paymethod"], self.method.get_uri())
eq_(res.json["seller_product"], self.seller_product.get_uri())
eq_(res.json["provider_id"], "some:id")
def test_create_with_custom_amount(self):
self.mocks['sub'].create.return_value = successful_subscription()
buyer, braintree_buyer = create_braintree_buyer()
seller, seller_product = create_seller(
seller_product_data={
'public_id': 'charity-donation-monthly',
})
method = create_method(braintree_buyer)
res = self.post(paymethod=method.get_uri(),
amount='4.99',
plan=seller_product.public_id)
eq_(res.status_code, 201, res.content)
subscription = BraintreeSubscription.objects.get()
eq_(subscription.amount, Decimal('4.99'))
# Make sure price is in braintree creation.
data = self.mocks['sub'].create.call_args[0][0]
eq_(data['price'], '4.99')
def test_patch_read_only(self):
obj = self.create()
paymethod = create_method(self.braintree_buyer)
seller, seller_product = create_seller(
seller_product_data={'public_id': 'a-different-brick'})
data = {
'paymethod': paymethod.get_uri(),
'seller_product': seller_product.get_uri(),
'provider_id': 'different:id',
}
res = self.client.patch(obj.get_uri(), data=data)
eq_(res.status_code, 200, res.content)
res = self.client.get(obj.get_uri())
eq_(res.json['paymethod'], self.method.get_uri())
eq_(res.json['seller_product'], self.seller_product.get_uri())
eq_(res.json['provider_id'], 'some:id')
def create_method_all():
buyer, braintree_buyer = create_braintree_buyer()
seller, seller_product = create_seller()
method = create_method(braintree_buyer)
return method, seller_product
def setUp(self):
self.buyer, self.braintree_buyer = create_braintree_buyer()
self.method = create_method(self.braintree_buyer)
self.seller, self.seller_product = create_seller()
self.url = reverse('braintree:mozilla:subscription-list')
super(TestSubscriptionViewSet, self).setUp()
def create_method_all():
buyer, braintree_buyer = create_braintree_buyer()
seller, seller_product = create_seller()
method = create_method(braintree_buyer)
return method, seller_product
def setUp(self):
self.buyer, self.braintree_buyer = create_braintree_buyer()
self.method = create_method(self.braintree_buyer)
self.seller, self.seller_product = create_seller()
self.url = reverse('braintree:mozilla:subscription-list')
super(TestSubscriptionViewSet, self).setUp()
