From 42fa0740a6d8e5d2f8de8b96eb3c0ec689406254 Mon Sep 17 00:00:00 2001 From: Sander Roosendaal Date: Sun, 7 Dec 2025 14:08:53 +0100 Subject: [PATCH] getting tests to pass --- rowers/tests/atest_newusers.py | 181 ++++++++ rowers/tests/atest_payments.py | 795 +++++++++++++++++++++++++++++++++ 2 files changed, 976 insertions(+) create mode 100644 rowers/tests/atest_newusers.py create mode 100644 rowers/tests/atest_payments.py diff --git a/rowers/tests/atest_newusers.py b/rowers/tests/atest_newusers.py new file mode 100644 index 00000000..138643cb --- /dev/null +++ b/rowers/tests/atest_newusers.py @@ -0,0 +1,181 @@ +from __future__ import absolute_import +from __future__ import division +from __future__ import print_function +from __future__ import unicode_literals + +#from __future__ import print_function +from .statements import * + +nu = datetime.datetime.now() + +#@pytest.mark.django_db +@override_settings(TESTING=True) +class NewUserRegistrationTest(TestCase): + def setUp(self): + self.c = Client() + redis_connection.publish('tasks','KILL') + + def tearDown(self): + try: + os.remove('rowsandall_workouts_2018-01-01_2019-01-01.csv') + except: + pass + + @patch('rowers.dataprep.workout_summary_to_df',side_effect=mock_workout_summaries) + def test_newuser(self,mock_workout_summaries): + form_data = { + 'first_name':'Jan', + 'last_name':'Roeiert', + 'email':'jan@loop.nl', + 'username':'janderoeiert', + 'password1':'Aapindewei2', + 'password2':'Aapindewei2', + 'url': '', + 'tos':True, + 'weightcategory':'hwt', + 'adaptiveclass': 'None', + 'sex':'male', + 'next':'/rowers/list-workouts', + 'birthdate':datetime.datetime(year=1970,month=4,day=2) + } + + form = RegistrationFormSex(form_data) + self.assertTrue(form.is_valid()) + + response = self.c.post('/rowers/register/', form_data, follow=True) + self.assertEqual(response.status_code,200) + + # set opt-in + user = User.objects.get(username='janderoeiert') + user.rower.gdpr_optin = True + user.rower.ftpset = True + user.set_password('Aapindewei2') + user.is_active = True + user.save() + user.rower.save() + + login = self.c.login(username=user.username,password='Aapindewei2') + self.assertTrue(login) + + + url = '/rowers/list-workouts/' + + response = self.c.get(url) + + expected = '/rowers/me/gdpr-optin/?next=/rowers/list-workouts/' + + self.assertRedirects(response, + expected_url=expected, + status_code=302,target_status_code=200) + + url = '/rowers/me/gdpr-optin-confirm/?next=/rowers/list-workouts/' + + response = self.c.get(url) + + expected = '/rowers/list-workouts/' + self.assertRedirects(response, + expected_url=expected, + status_code=302,target_status_code=200) + + + url = '/rowers/exportallworkouts/' + + response = self.c.get(url,follow=True) + + + self.assertTrue(response.status_code,200) + + + form_data = { + 'startdate':'2018-01-01', + 'enddate':'2019-01-01' + } + + response = self.c.post(url,form_data) + + self.assertTrue(response.status_code,200) + + + + url = '/rowers/me/delete/' + + form_data = { + 'delete_user':True, + } + + response = self.c.post(url,form_data,follow=True) + self.assertRedirects(response, + expected_url='/login/', + status_code=302,target_status_code=200) + + @patch('rowers.dataprep.workout_summary_to_df',side_effect=mock_workout_summaries) + def test_newuser_false(self,mock_workout_summaries): + form_data = { + 'first_name':'Jan', + 'last_name':'Roeiert', + 'email':'jan@loop.nl', + 'username':'janderoeiert', + 'password1':'aapindewei2', + 'password2':'aapindewei2', + 'tos':True, + 'url': '', + 'weightcategory':'hwt', + 'adaptiveclass': 'None', + 'sex':'male', + 'next':'/rowers/list-workouts', + 'birthdate':datetime.datetime(year=1970,month=4,day=2) + } + + form = RegistrationFormSex(form_data) + self.assertFalse(form.is_valid()) + + @patch('rowers.dataprep.workout_summary_to_df',side_effect=mock_workout_summaries) + def test_newuser_honeypot(self,mock_workout_summaries): + form_data = { + 'first_name':'Jan', + 'last_name':'Roeiert', + 'email':'jan@loop.nl', + 'username':'janderoeiert', + 'password1':'Aapindewei2', + 'password2':'Aapindewei2', + 'url': 'http://example.com', + 'tos':True, + 'weightcategory':'hwt', + 'adaptiveclass': 'None', + 'sex':'male', + 'next':'/rowers/list-workouts', + 'birthdate':datetime.datetime(year=1970,month=4,day=2) + } + + form = RegistrationFormSex(form_data) + self.assertFalse(form.is_valid()) + + # still post it, should redirect to the registration page + response = self.c.post('/rowers/register/', form_data, follow=True) + self.assertEqual(response.status_code,200) + self.assertRedirects(response, + expected_url='/rowers/register/', + status_code=302,target_status_code=200) + + @patch('rowers.dataprep.workout_summary_to_df',side_effect=mock_workout_summaries) + def test_newuser_disposable(self,mock_workout_summaries): + form_data = { + 'first_name':'Jan', + 'last_name':'Roeiert', + 'email':'jan@powerscrews.com', + 'username':'janderoeiert', + 'password1':'Aapindewei2', + 'password2':'Aapindewei2', + 'url': '', + 'tos':True, + 'weightcategory':'hwt', + 'adaptiveclass': 'None', + 'sex':'male', + 'next':'/rowers/list-workouts', + 'birthdate':datetime.datetime(year=1970,month=4,day=2) + } + + form = RegistrationFormSex(form_data) + self.assertFalse(form.is_valid()) + + diff --git a/rowers/tests/atest_payments.py b/rowers/tests/atest_payments.py new file mode 100644 index 00000000..9423217c --- /dev/null +++ b/rowers/tests/atest_payments.py @@ -0,0 +1,795 @@ +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)