796 lines
28 KiB
Python
796 lines
28 KiB
Python
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import print_function
|
|
from __future__ import unicode_literals
|
|
|
|
from .statements import *
|
|
|
|
nu = datetime.datetime.now()
|
|
|
|
from django_countries import countries
|
|
|
|
from rowers.braintreestuff import mocktest
|
|
|
|
import urllib
|
|
|
|
class PaymentTest(TestCase):
|
|
def setUp(self):
|
|
|
|
# settings.DEBUG = True
|
|
|
|
p1 = PaidPlan(
|
|
shortname='free',
|
|
name='Basic',
|
|
external_id='a',
|
|
price=0,
|
|
clubsize=0,
|
|
paymentprocessor='braintree',
|
|
paymenttype='single',
|
|
)
|
|
|
|
p1.save()
|
|
|
|
p2 = PaidPlan(
|
|
shortname='pro_recurring',
|
|
name='Pro (recurring)',
|
|
external_id='b',
|
|
price=15,
|
|
clubsize=0,
|
|
paymentprocessor='braintree',
|
|
paymenttype='single',
|
|
)
|
|
|
|
p2.save()
|
|
|
|
p3 = PaidPlan(
|
|
shortname='pro_single',
|
|
name='Pro (single)',
|
|
external_id='c',
|
|
price=20,
|
|
clubsize=0,
|
|
paymentprocessor='braintree',
|
|
paymenttype='single',
|
|
)
|
|
|
|
p3.save()
|
|
|
|
self.c = Client()
|
|
self.password = faker.word()
|
|
|
|
s = b"""filename: britishrowing.json
|
|
name: British Rowing Training Plan Beginner Week 1
|
|
trainingDays:
|
|
- order: 1
|
|
workouts:
|
|
- workoutName: Week 1 Session 1
|
|
steps:
|
|
- stepId: 0
|
|
wkt_step_name: Warmup
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Warmup
|
|
description: ""
|
|
- stepId: 1
|
|
wkt_step_name: Intervals
|
|
durationType: Time
|
|
durationValue: 60000
|
|
intensity: Active
|
|
description: ""
|
|
- stepId: 2
|
|
wkt_step_name: Interval Rest
|
|
durationType: Time
|
|
durationValue: 60000
|
|
intensity: Rest
|
|
description: ""
|
|
- stepId: 3
|
|
wkt_step_name: Rep
|
|
durationType: RepeatUntilStepsCmplt
|
|
durationValue: 1
|
|
targetValue: 5
|
|
- stepId: 4
|
|
wkt_step_name: Cooldown
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Cooldown
|
|
description: ""
|
|
sport: ""
|
|
description: ""
|
|
- order: 4
|
|
workouts:
|
|
- workoutName: Week 1 Session 2
|
|
steps:
|
|
- stepId: 0
|
|
wkt_step_name: Warmup
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Warmup
|
|
description: ""
|
|
- stepId: 1
|
|
wkt_step_name: Interval
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Active
|
|
description: ""
|
|
- stepId: 2
|
|
wkt_step_name: Interval Rest
|
|
durationType: Time
|
|
durationValue: 180000
|
|
intensity: Rest
|
|
description: ""
|
|
- stepId: 3
|
|
wkt_step_name: Rep
|
|
durationType: RepeatUntilStepsCmplt
|
|
durationValue: 1
|
|
targetValue: 5
|
|
- stepId: 4
|
|
wkt_step_name: Cooldown
|
|
durationType: Time
|
|
durationValue: 300000
|
|
intensity: Cooldown
|
|
description: ""
|
|
sport: ""
|
|
description: ""
|
|
duration: 7
|
|
description: ""
|
|
"""
|
|
|
|
self.file_data = {'yaml': SimpleUploadedFile('britishrowing.yml', s)}
|
|
|
|
with open('media/temp.yml','wb') as f:
|
|
f.write(s)
|
|
|
|
self.instantplan = InstantPlan(
|
|
uuid = "79b0dacf-9b49-4f33-9acf-e2e6734e22dc",
|
|
url = "https://thepeteplan.wordpress.com/beginner-training/",
|
|
name = faker.word(),
|
|
goal = faker.word(),
|
|
duration = 42,
|
|
description = faker.word(),
|
|
target = faker.word(),
|
|
hoursperweek = 3,
|
|
sessionsperweek = 3,
|
|
price = 0,
|
|
yaml = 'temp.yml',
|
|
)
|
|
|
|
self.instantplan.save()
|
|
|
|
# def tearDown(self):
|
|
# settings.DEBUG = False
|
|
|
|
@patch('rowers.braintreestuff.gateway',side_effect=MockBraintreeGateway)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_braintree_webhook(self,mocked_gateway,mocked_myqueue):
|
|
url = reverse('braintree_webhook_view')
|
|
response = self.c.get(url)
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
form_data = {
|
|
'bt_signature': 'aap',
|
|
'bt_payload': 'noot,'
|
|
}
|
|
|
|
response = self.c.post(url,form_data)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
@patch('rowers.views.braintreestuff.create_customer',side_effect=mock_create_customer)
|
|
@patch('rowers.views.braintreestuff.gateway',side_effect=MockBraintreeGateway)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_billing_view(self,mocked_create_customer,mocked_gateway,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/billing/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
plans = PaidPlan.objects.filter(price__gt=0).order_by('price')
|
|
plan = plans[0]
|
|
|
|
country=faker.country()
|
|
countrycode = 'NL'
|
|
for code, name in list(countries):
|
|
if name.lower() == country.lower():
|
|
countrycode = code
|
|
|
|
form_data = {
|
|
'street_address':faker.street_address(),
|
|
'city':faker.city(),
|
|
'postal_code':faker.postalcode(),
|
|
'country':countrycode,
|
|
'plan':plan.id,
|
|
}
|
|
|
|
form = RowerBillingAddressForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = PlanSelectForm(form_data,paymentprocessor='braintree')
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
expected_url = '/rowers/checkout/'+str(plan.id)+'/'
|
|
|
|
self.assertRedirects(response,
|
|
expected_url=expected_url,
|
|
status_code=302, target_status_code=200)
|
|
|
|
@patch('rowers.views.braintreestuff.gateway',side_effect=MockBraintreeGateway)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_upgrade_view(self,mocked_gateway,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
r.country = 'NL'
|
|
r.customer_id = 34
|
|
r.subscription_id = 34
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/upgrade/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
plans = PaidPlan.objects.filter(price__gt=0).order_by('price')
|
|
plan = plans[0]
|
|
|
|
country=faker.country()
|
|
countrycode = 'NL'
|
|
for code, name in list(countries):
|
|
if name.lower() == country.lower():
|
|
countrycode = code
|
|
|
|
form_data = {
|
|
'street_address':faker.street_address(),
|
|
'city':faker.city(),
|
|
'postal_code':faker.postalcode(),
|
|
'country':countrycode,
|
|
'plan':plan.id,
|
|
}
|
|
|
|
form = RowerBillingAddressForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = PlanSelectForm(form_data,paymentprocessor='braintree')
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
expected_url = '/rowers/upgradecheckout/'+str(plan.id)+'/'
|
|
|
|
self.assertRedirects(response,
|
|
expected_url=expected_url,
|
|
status_code=302, target_status_code=200)
|
|
|
|
@patch('rowers.views.braintreestuff.gateway',side_effect=MockBraintreeGateway)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_down_view(self,mocked_gateway,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
r.country = 'NL'
|
|
r.customer_id = 34
|
|
r.subscription_id = 34
|
|
r.save()
|
|
|
|
plans = PaidPlan.objects.all().order_by('price')
|
|
plan = plans[1]
|
|
|
|
r.paidplan = plan
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/downgrade/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
country=faker.country()
|
|
countrycode = 'NL'
|
|
for code, name in list(countries):
|
|
if name.lower() == country.lower():
|
|
countrycode = code
|
|
|
|
form_data = {
|
|
'street_address':faker.street_address(),
|
|
'city':faker.city(),
|
|
'postal_code':faker.postalcode(),
|
|
'country':countrycode,
|
|
'plan':plans[0].id,
|
|
}
|
|
|
|
form = RowerBillingAddressForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
form = PlanSelectForm(form_data,paymentprocessor='braintree')
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
expected_url = '/rowers/downgradecheckout/'+str(plans[0].id)+'/'
|
|
|
|
self.assertRedirects(response,
|
|
expected_url=expected_url,
|
|
status_code=302, target_status_code=200)
|
|
|
|
@patch('rowers.views.braintreestuff.gateway',side_effect=MockBraintreeGateway)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_planstop_view(self,mocked_gateway,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
r.country = 'NL'
|
|
r.customer_id = 34
|
|
r.subscription_id = 34
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
plans = PaidPlan.objects.all().order_by('price')
|
|
plan = plans[1]
|
|
|
|
r.paidplan = plan
|
|
r.save()
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/me/cancelsubscriptions/'
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
|
|
@patch('rowers.views.braintreestuff.gateway', side_effect=MockBraintreeGateway)
|
|
@patch('rowers.idoklad.create_invoice',side_effect=mocked_invoiceid)
|
|
@patch('rowers.utils.myqueue')
|
|
def test_purchase_trainingplan_view(self, mocked_gateway,mocked_invoiceid, mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
r.country = 'NL'
|
|
r.customer_id = 34
|
|
r.subscription_id = 34
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = reverse('buy_trainingplan_view',kwargs={'id':self.instantplan.id})
|
|
|
|
response = self.c.get(url)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
enddate = datetime.datetime.now()+datetime.timedelta(days=30)
|
|
startdate = datetime.datetime.now()
|
|
|
|
form_data = {
|
|
'enddate':enddate.strftime('%Y-%m-%d'),
|
|
'startdate':startdate.strftime('%Y-%m-%d'),
|
|
'notes': 'no notes',
|
|
'datechoice': 'enddate',
|
|
'name': 'no name',
|
|
}
|
|
|
|
response = self.c.post(url,form_data)
|
|
|
|
pars = {
|
|
'name': 'no name',
|
|
'enddate':enddate.strftime('%Y-%m-%d'),
|
|
'notes': 'no notes',
|
|
'status': True,
|
|
'rower':r.id,
|
|
}
|
|
params = urllib.parse.urlencode(pars)
|
|
expected_url = reverse('confirm_trainingplan_purchase_view',kwargs={'id':self.instantplan.id})
|
|
expected_url = expected_url + "?%s" % params
|
|
|
|
self.assertRedirects(response,expected_url=expected_url,status_code=302, target_status_code=200)
|
|
|
|
url = expected_url
|
|
|
|
response = self.c.get(url, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
url = reverse('purchase_checkouts_view')
|
|
|
|
form_data = {
|
|
'amount': '25.00',
|
|
'plan': self.instantplan.id,
|
|
'payment_method_nonce': 'aap',
|
|
'tac': 'tac',
|
|
'paymenttype': 'CreditCard',
|
|
'notes': 'no notes',
|
|
'enddate':enddate.strftime('%Y-%m-%d'),
|
|
'status': True,
|
|
}
|
|
|
|
form = TrainingPlanBillingForm(form_data)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
response = self.c.post(url,form_data, follow=True)
|
|
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
expected_url = reverse('plannedsessions_view')
|
|
startdate = enddate-datetime.timedelta(days=self.instantplan.duration)
|
|
timeperiod = startdate.strftime('%Y-%m-%d')+'/'+enddate.strftime('%Y-%m-%d')
|
|
expected_url = expected_url+'?when='+timeperiod
|
|
|
|
self.assertRedirects(response,
|
|
expected_url=expected_url,
|
|
status_code=302, target_status_code=200)
|
|
|
|
@patch('rowers.views.braintreestuff.gateway',side_effect=MockBraintreeGateway)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_planstobasic_view(self,mocked_gateway,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
r.country = 'NL'
|
|
r.customer_id = 34
|
|
r.subscription_id = 34
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
plans = PaidPlan.objects.all().order_by('price')
|
|
plan = plans[1]
|
|
|
|
r.paidplan = plan
|
|
r.save()
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/me/cancelsubscription/34/'
|
|
|
|
response = self.c.get(url, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/me/cancelsubscriptions/',
|
|
status_code=302, target_status_code=200)
|
|
|
|
@patch('rowers.tests.test_payments.mocktest', side_effect=mock_mocktest)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_patch(self, mock_mocktest,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
u.set_password(self.password)
|
|
u.save()
|
|
r.save()
|
|
result = mocktest(r)
|
|
self.assertEqual(result,'121')
|
|
|
|
@patch('rowers.views.braintreestuff.create_subscription', side_effect=mock_create_subscription)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_checkouts_view(self,mock_subscription,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
plans = PaidPlan.objects.all().order_by('price')
|
|
plan = plans[1]
|
|
|
|
form_data = {
|
|
'amount': '15.00',
|
|
'plan': plans[1].id,
|
|
'payment_method_nonce': 'aap',
|
|
'tac': 'tac',
|
|
'paymenttype': 'CreditCard'
|
|
}
|
|
|
|
form = BillingForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/checkouts/'
|
|
|
|
response = self.c.post(url, form_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/paymentcompleted/?amount=20.00',
|
|
status_code=302, target_status_code=200)
|
|
|
|
|
|
@patch('rowers.views.braintreestuff.update_subscription', side_effect=mock_update_subscription)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_upgrade_checkouts_view(self,mock_subscription,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
plans = PaidPlan.objects.all().order_by('price')
|
|
plan = plans[1]
|
|
|
|
form_data = {
|
|
'amount': '15.00',
|
|
'plan': plans[1].id,
|
|
'payment_method_nonce': 'aap',
|
|
'paymenttype': 'CreditCard',
|
|
'tac': 'tac',
|
|
}
|
|
|
|
form = BillingForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/upgradecheckouts/'
|
|
|
|
response = self.c.post(url, form_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/paymentcompleted/?amount=20.00',
|
|
status_code=302, target_status_code=200)
|
|
|
|
@patch('rowers.views.braintreestuff.update_subscription', side_effect=mock_update_subscription)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_downgrade_checkouts_view(self,mock_subscription,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
plans = PaidPlan.objects.all().order_by('price')
|
|
|
|
form_data = {
|
|
'amount': '15.00',
|
|
'plan': plans[1].id,
|
|
'payment_method_nonce': 'aap',
|
|
'paymenttype': 'CreditCard',
|
|
'tac': 'tac',
|
|
}
|
|
|
|
form = BillingForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/downgradecheckouts/'
|
|
|
|
response = self.c.post(url, form_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/downgradecompleted/',
|
|
status_code=302, target_status_code=200)
|
|
|
|
@patch('rowers.views.braintreestuff.create_subscription', side_effect=mock_create_subscription)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_checkouts_view(self,mock_subscription,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(),
|
|
)
|
|
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
plans = PaidPlan.objects.all().order_by('price')
|
|
plan = plans[1]
|
|
|
|
form_data = {
|
|
'amount': '15.00',
|
|
'plan': plans[1].id,
|
|
'payment_method_nonce': 'aap',
|
|
'paymenttype': 'CreditCard',
|
|
'tac': True,
|
|
}
|
|
|
|
form = BillingForm(form_data)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/checkouts/'
|
|
|
|
response = self.c.post(url, form_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
expected_url = '/rowers/paymentcompleted/?amount=20.00'
|
|
|
|
self.assertRedirects(response,
|
|
expected_url=expected_url,
|
|
status_code=302, target_status_code=200)
|
|
|
|
|
|
@patch('rowers.views.braintreestuff.update_subscription', side_effect=mock_update_subscription)
|
|
@patch('rowers.braintreestuff.myqueue')
|
|
def test_upgrade_checkouts_view(self,mock_subscription,mocked_myqueue):
|
|
u = UserFactory()
|
|
r = Rower.objects.create(user=u,
|
|
birthdate=faker.profile()['birthdate'],
|
|
gdproptin=True, ftpset=True, surveydone=True,
|
|
gdproptindate=timezone.now(),
|
|
rowerplan='pro',
|
|
paymentprocessor='braintree',
|
|
street_address=faker.street_address(),
|
|
city=faker.city(),
|
|
postal_code=faker.postalcode(),
|
|
country=faker.country(), )
|
|
|
|
r.save()
|
|
u.set_password(self.password)
|
|
u.save()
|
|
|
|
plans = PaidPlan.objects.all().order_by('price')
|
|
|
|
form_data = {
|
|
'amount': '15.00',
|
|
'plan': plans[1].id,
|
|
'payment_method_nonce': 'aap',
|
|
'paymenttype': 'CreditCard',
|
|
'tac': True, }
|
|
|
|
form = BillingForm(form_data)
|
|
self.assertTrue(form.is_valid())
|
|
|
|
login = self.c.login(username=u.username, password=self.password)
|
|
self.assertTrue(login)
|
|
|
|
url = '/rowers/upgradecheckouts/'
|
|
|
|
response = self.c.post(url, form_data, follow=True)
|
|
self.assertEqual(response.status_code, 200)
|
|
|
|
self.assertRedirects(response,
|
|
expected_url='/rowers/paymentcompleted/?amount=20.00',
|
|
status_code=302, target_status_code=200)
|