Create unit tests that test the forms.

app/main/forms.py

@@ -62,7 +62,6 @@ class VerifyForm(Form):
                                          Regexp(regex=verify_code, message='Code must be 5 digits')])
 
     def validate_email_code(self, a):
-        print('validating the email_code')
         code = verify_codes_dao.get_code(session['user_id'], 'email')
         validate_code(self.email_code, code)
 
@@ -72,7 +71,7 @@ class VerifyForm(Form):
 
 
 def validate_code(field, code):
-    if code.expiry_datetime < datetime.now():
+    if code.expiry_datetime > datetime.now():
         field.errors.append('Code has expired')
         return False
     if field.data is not None:

app/main/views/verify.py

@@ -20,5 +20,4 @@ def process_verify():
         login_user(user)
         return redirect('/add-service')
     else:
-        print(form.errors)
         return jsonify(form.errors), 400

tests/app/main/test_two_factor_form.py

@@ -0,0 +1,71 @@
+from datetime import datetime, timedelta
+
+from app.main.dao import verify_codes_dao
+from app.main.forms import TwoFactorForm
+from tests.app.main import create_test_user
+
+
+def test_form_is_valid_returns_no_errors(notifications_admin, notifications_admin_db, notify_db_session):
+    with notifications_admin.test_request_context(method='POST',
+                                                  data={'sms_code': '12345'}) as req:
+        user = set_up_test_data()
+        req.session['user_id'] = user.id
+        form = TwoFactorForm(req.request.form)
+        assert form.validate() is True
+        assert len(form.errors) == 0
+
+
+def test_returns_errors_when_code_is_too_short(notifications_admin, notifications_admin_db, notify_db_session):
+    with notifications_admin.test_request_context(method='POST',
+                                                  data={'sms_code': '145'}) as req:
+        user = set_up_test_data()
+        req.session['user_id'] = user.id
+        form = TwoFactorForm(req.request.form)
+        assert form.validate() is False
+        assert len(form.errors) == 1
+        assert set(form.errors) == set({'sms_code': ['Code must be 5 digits', 'Code does not match']})
+
+
+def test_returns_errors_when_code_is_missing(notifications_admin, notifications_admin_db, notify_db_session):
+    with notifications_admin.test_request_context(method='POST',
+                                                  data={}) as req:
+        user = set_up_test_data()
+        req.session['user_id'] = user.id
+        form = TwoFactorForm(req.request.form)
+        assert form.validate() is False
+        assert len(form.errors) == 1
+        assert set(form.errors) == set({'sms_code': ['Code must not be empty']})
+
+
+def test_returns_errors_when_code_contains_letters(notifications_admin, notifications_admin_db, notify_db_session):
+    with notifications_admin.test_request_context(method='POST',
+                                                  data={'sms_code': 'asdfg'}) as req:
+        user = set_up_test_data()
+        req.session['user_id'] = user.id
+        form = TwoFactorForm(req.request.form)
+        assert form.validate() is False
+        assert len(form.errors) == 1
+        assert set(form.errors) == set({'sms_code': ['Code must be 5 digits', 'Code does not match']})
+
+
+def test_should_return_errors_when_code_is_expired(notifications_admin, notifications_admin_db, notify_db_session):
+    with notifications_admin.test_request_context(method='POST',
+                                                  data={'sms_code': '12345'}) as req:
+        user = set_up_test_data()
+        req.session['user_id'] = user.id
+        verify_codes_dao.add_code_with_expiry(user_id=user.id,
+                                              code='12345',
+                                              code_type='sms',
+                                              expiry=datetime.now() + timedelta(hours=-2))
+        req.session['user_id'] = user.id
+        form = TwoFactorForm(req.request.form)
+        assert form.validate() is False
+        errors = form.errors
+        assert len(errors) == 1
+        assert errors == {'sms_code': ['Code has expired']}
+
+
+def set_up_test_data():
+    user = create_test_user()
+    verify_codes_dao.add_code(user_id=user.id, code='12345', code_type='sms')
+    return user

tests/app/main/test_verify_form.py

@@ -1,93 +1,89 @@
 from datetime import datetime, timedelta
-
 from app.main.dao import verify_codes_dao
 from app.main.forms import VerifyForm
 from tests.app.main import create_test_user
 
 
 def test_form_should_have_error_when_code_is_not_valid(notifications_admin, notifications_admin_db, notify_db_session):
-        with notifications_admin.test_request_context(method='POST',
+    with notifications_admin.test_request_context(method='POST',
-                                                      data={'sms_code': '12345aa', 'email_code': 'abcde'}) as req:
+                                                  data={'sms_code': '12345aa', 'email_code': 'abcde'}) as req:
-            user = set_up_test_data()
+        user = set_up_test_data()
-            req.session['user_id']= user.id
+        req.session['user_id'] = user.id
-            form = VerifyForm(req.request.form)
+        form = VerifyForm(req.request.form)
-            assert form.validate() is False
+        assert form.validate() is False
-            errors = form.errors
+        errors = form.errors
-            assert len(errors) == 2
+        assert len(errors) == 2
-            expected = set({'email_code': ['Code must be 5 digits', 'Code does not match'],
+        expected = {'email_code': ['Code must be 5 digits', 'Code does not match'],
-                        'sms_code': ['Code does not match', 'Code must be 5 digits']})
+                    'sms_code': ['Code does not match', 'Code must be 5 digits']}
-            assert 'sms_code' in errors
+        assert 'sms_code' in errors
-            assert set(errors) == expected
+        assert set(errors) == set(expected)
 
 
 def test_should_return_errors_when_code_missing(notifications_admin, notifications_admin_db, notify_db_session):
-        with notifications_admin.test_request_context(method='POST',
+    with notifications_admin.test_request_context(method='POST',
-                                                      data={}) as req:
+                                                  data={}) as req:
-            user = set_up_test_data()
+        user = set_up_test_data()
-            req.session['user_id']= user.id
+        req.session['user_id'] = user.id
-            form = VerifyForm(req.request.form)
+        form = VerifyForm(req.request.form)
-            assert form.validate() is False
+        assert form.validate() is False
-            errors = form.errors
+        errors = form.errors
-            expected = set({'sms_code': ['SMS code can not be empty'],
+        expected = {'sms_code': ['SMS code can not be empty'],
-                        'email_code': ['Email code can not be empty']})
+                    'email_code': ['Email code can not be empty']}
-            assert len(errors) == 2
+        assert len(errors) == 2
-            assert set(errors) == expected
+        assert set(errors) == set(expected)
 
 
 def test_should_return_errors_when_code_is_too_short(notifications_admin, notifications_admin_db, notify_db_session):
-        with notifications_admin.test_request_context(method='POST',
+    with notifications_admin.test_request_context(method='POST',
-                                                      data={'sms_code':'123', 'email_code':'123'}) as req:
+                                                  data={'sms_code': '123', 'email_code': '123'}) as req:
-            user = set_up_test_data()
+        user = set_up_test_data()
-            req.session['user_id']= user.id
+        req.session['user_id'] = user.id
-            form = VerifyForm(req.request.form)
+        form = VerifyForm(req.request.form)
-            assert form.validate() is False
+        assert form.validate() is False
-            errors = form.errors
+        errors = form.errors
-            expected = set({'sms_code': ['Code must be 5 digits', 'Code does not match'],
+        expected = {'sms_code': ['Code must be 5 digits', 'Code does not match'],
-                        'email_code': ['Code must be 5 digits', 'Code does not match']})
+                    'email_code': ['Code must be 5 digits', 'Code does not match']}
-            assert len(errors) == 2
+        assert len(errors) == 2
-            assert set(errors) == expected
+        assert set(errors) == set(expected)
 
 
 def test_should_return_errors_when_code_does_not_match(notifications_admin, notifications_admin_db, notify_db_session):
-        with notifications_admin.test_request_context(method='POST',
+    with notifications_admin.test_request_context(method='POST',
-                                                      data={'sms_code': '23456', 'email_code': '23456'}) as req:
+                                                  data={'sms_code': '23456', 'email_code': '23456'}) as req:
-            user = set_up_test_data()
+        user = set_up_test_data()
-            req.session['user_id']= user.id
+        req.session['user_id'] = user.id
-            form = VerifyForm(req.request.form)
+        form = VerifyForm(req.request.form)
-            assert form.validate() is False
+        assert form.validate() is False
-            errors = form.errors
+        errors = form.errors
-            expected = set({'sms_code': ['Code does not match'],
+        expected = {'sms_code': ['Code does not match'],
-                        'email_code': ['Code does not match']})
+                    'email_code': ['Code does not match']}
-            assert len(errors) == 2
+        assert len(errors) == 2
-            assert set(errors) == expected
+        assert set(errors) == set(expected)
 
 
 def test_should_return_errors_when_code_is_expired(notifications_admin, notifications_admin_db, notify_db_session):
-        with notifications_admin.test_request_context(method='POST',
+    with notifications_admin.test_request_context(method='POST',
-                                                      data={'sms_code': '23456', 'email_code': '23456'}) as req:
+                                                  data={'sms_code': '23456',
-            user = create_test_user()
+                                                        'email_code': '23456'}) as req:
-            verify_codes_dao.add_code_with_expiry(user_id=user.id,
+        user = set_up_test_data()
-                                                  code='23456',
+        req.session['user_id'] = user.id
-                                                  code_type='email',
+        verify_codes_dao.add_code_with_expiry(user_id=user.id,
-                                                  expiry=datetime.now() + timedelta(hours=-1))
+                                              code='23456',
-            verify_codes_dao.add_code_with_expiry(user_id=user.id,
+                                              code_type='sms',
-                                                  code='23456',
+                                              expiry=datetime.now() + timedelta(hours=-2))
-                                                  code_type='sms',
-                                                  expiry=datetime.now() + timedelta(hours=-2))
-            req.session['user_id']= user.id
-            form = VerifyForm(req.request.form)
-            assert form.validate() is False
-            errors = form.errors
-            expected = {'sms_code': ['Code has expired'],
-                        'email_code': ['Code has expired']}
-            assert len(errors) == 2
-            assert 'sms_code' in errors
-            assert errors['sms_code'] == expected['sms_code']
-            assert 'email_code' in errors
-            assert errors['email_code'] == expected['email_code']
-
-
 
+        verify_codes_dao.add_code_with_expiry(user_id=user.id,
+                                              code='23456',
+                                              code_type='email',
+                                              expiry=datetime.now() + timedelta(hours=-2))
+        req.session['user_id'] = user.id
+        form = VerifyForm(req.request.form)
+        assert form.validate() is False
+        errors = form.errors
+        expected = set({'sms_code': ['Code has expired'],
+                        'email_code': ['Code has exprired']})
+        assert len(errors) == 2
+        assert set(errors) == expected
 
 
 def set_up_test_data():
@@ -95,5 +91,3 @@ def set_up_test_data():
     verify_codes_dao.add_code(user_id=user.id, code='12345', code_type='email')
     verify_codes_dao.add_code(user_id=user.id, code='12345', code_type='sms')
     return user
-
-

tests/app/main/views/test_two_factor.py

@@ -58,5 +58,4 @@ def test_should_return_400_when_sms_code_is_too_short(notifications_admin, notif
         assert response.status_code == 400
         data = json.loads(response.get_data(as_text=True))
         assert len(data.keys()) == 1
-        assert 'sms_code' in data
+        assert set(data) == set({'sms_code': ['Code must be 5 digits', 'Code does not match']})
-        assert set(data['sms_code']) == ['Code must be 5 digits', 'Code does not match'].sort()

tests/app/main/views/test_verify.py

@@ -1,7 +1,4 @@
-from datetime import datetime, timedelta
-
 from flask import json
-
 from app.main.dao import users_dao, verify_codes_dao
 from tests.app.main import create_test_user
 
@@ -55,11 +52,7 @@ def test_should_return_400_when_codes_are_wrong(notifications_admin, notificatio
                                      'email_code': '23456'})
         assert response.status_code == 400
         expected = {'sms_code': ['Code must be 5 digits', 'Code does not match'],
-                        'email_code': ['Code must be 5 digits', 'Code does not match']}
+                    'email_code': ['Code must be 5 digits', 'Code does not match']}
         errors = json.loads(response.get_data(as_text=True))
         assert len(errors) == 2
-        assert 'sms_code' in errors
+        assert set(errors) == set(expected)
-        assert errors['sms_code'] == expected['sms_code']
-        assert 'email_code' in errors
-        assert set(errors['email_code']) in set(expected['email_code'])
-