getting tests to pass

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())
+
+        

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)