Reorganise payment tests

oscar/apps/payment/bankcards.py

@@ -0,0 +1,46 @@
+VISA, MASTERCARD, AMEX, MAESTRO, DISCOVER = (
+    'Visa', 'Mastercard', 'American Express', 'Maestro', 'Discover')
+
+
+def bankcard_type(number):
+    """
+    Return the type of a bankcard based on its number.
+    """
+    number = str(number)
+    if len(number) == 13:
+        if number[0] == "4":
+            return VISA
+    elif len(number) == 14:
+        if number[:2] == "36":
+            return MASTERCARD
+    elif len(number) == 15:
+        if number[:2] in ("34", "37"):
+            return AMEX
+    elif len(number) == 16:
+        if number[:4] == "6011":
+            return DISCOVER
+        if number[:2] in ("51", "52", "53", "54", "55"):
+            return MASTERCARD
+        if number[0] == "4":
+            return VISA
+    return None
+
+
+def luhn(card_number):
+    """
+    Test whether a bankcard number passes the Luhn algorithm.
+    """
+    card_number = str(card_number)
+    sum = 0
+    num_digits = len(card_number)
+    odd_even = num_digits & 1
+
+    for i in range(0, num_digits):
+        digit = int(card_number[i])
+        if not ((i & 1) ^ odd_even):
+            digit = digit * 2
+        if digit > 9:
+            digit = digit - 9
+        sum = sum + digit
+
+    return (sum % 10) == 0

oscar/apps/payment/forms.py

@@ -5,61 +5,16 @@ import re
 from django import forms
 from django.db.models import get_model
 from django.utils.translation import ugettext_lazy as _
-from oscar.apps.address.forms import AbstractAddressForm
 
+from oscar.apps.address.forms import AbstractAddressForm
 from oscar.core.loading import get_class
+from . import bankcards
 
 Country = get_model('address', 'Country')
 BillingAddress = get_model('order', 'BillingAddress')
 BankcardModel = get_model('payment', 'Bankcard')
 Bankcard = get_class('payment.utils', 'Bankcard')
 
-VISA, MASTERCARD, AMEX, MAESTRO, DISCOVER = ('Visa', 'Mastercard', 'American Express', 'Maestro', 'Discover')
-
-
-def bankcard_type(number):
-    u"""
-    Returns the type of a bankcard based on its number.
-    """
-    number = str(number)
-    if len(number) == 13:
-        if number[0] == "4":
-            return VISA
-    elif len(number) == 14:
-        if number[:2] == "36":
-            return MASTERCARD
-    elif len(number) == 15:
-        if number[:2] in ("34", "37"):
-            return AMEX
-    elif len(number) == 16:
-        if number[:4] == "6011":
-            return DISCOVER
-        if number[:2] in ("51", "52", "53", "54", "55"):
-            return MASTERCARD
-        if number[0] == "4":
-            return VISA
-    return None
-
-
-def luhn(card_number):
-    u"""
-    Tests whether a bankcard number passes the Luhn algorithm.
-    """
-    card_number = str(card_number)
-    sum = 0
-    num_digits = len(card_number)
-    odd_even = num_digits & 1
-
-    for i in range(0, num_digits):
-        digit = int(card_number[i])
-        if not (( i & 1 ) ^ odd_even ):
-            digit = digit * 2
-        if digit > 9:
-            digit = digit - 9
-        sum = sum + digit
-
-    return (sum % 10) == 0
-
 
 class BankcardNumberField(forms.CharField):
 
@@ -69,7 +24,7 @@ class BankcardNumberField(forms.CharField):
         non_decimal = re.compile(r'\D+')
         value = non_decimal.sub('', value.strip())
 
-        if value and not luhn(value):
+        if value and not bankcards.luhn(value):
             raise forms.ValidationError(_("Please enter a valid credit card number."))
         return super(BankcardNumberField, self).clean(value)
 
@@ -239,4 +194,4 @@ class BillingAddressForm(AbstractAddressForm):
 
     class Meta:
         model = BillingAddress
-        exclude = ('search_text',)
+        exclude = ('search_text',)

tests/unit/payment/bankcard_tests.py

@@ -0,0 +1,46 @@
+import nose.tools
+
+from oscar.apps.payment import bankcards
+
+
+fixture_data = {
+    bankcards.VISA: ('4111111111111111',),
+    bankcards.MASTERCARD: ('5500000000000004',),
+    bankcards.DISCOVER: ('6011000000000004',),
+    bankcards.AMEX: ('340000000000009',),
+}
+
+
+def test_bankcard_type_sniffing():
+
+    def compare(number, type):
+        nose.tools.eq_(bankcards.bankcard_type(number), type)
+
+    for bankcard_type, numbers in fixture_data.items():
+        for number in numbers:
+            yield compare, number, bankcard_type
+
+
+valid_numbers = [
+    '4111111111111111',
+    '5500000000000004',
+    '6011000000000004',
+    '340000000000009']
+
+invalid_numbers = [
+    '4111111111111110',
+    '5500000000000009',
+    '6011000000000000',
+    '340000000000005']
+
+
+def test_luhn_check():
+    def is_valid(n):
+        assert bankcards.luhn(n) is True
+    for number in valid_numbers:
+        yield is_valid, number
+
+    def is_not_valid(n):
+        assert bankcards.luhn(n) is False
+    for number in invalid_numbers:
+        yield is_not_valid, number

tests/unit/payment/form_tests.py

@@ -0,0 +1,12 @@
+from django.test import TestCase
+
+from oscar.apps.payment import forms
+
+
+class BankcardNumberFieldTest(TestCase):
+
+    def setUp(self):
+        self.field = forms.BankcardNumberField()
+
+    def test_spaces_are_stipped(self):
+        self.assertEquals('4111111111111111', self.field.clean('  4111 1111 1111 1111'))

tests/unit/payment/model_tests.py

@@ -0,0 +1,11 @@
+from django.test import TestCase
+
+from oscar.apps.payment.models import Bankcard
+
+
+class TestBankcard(TestCase):
+
+    def test_get_obfuscated_number(self):
+        bankcard = Bankcard(number="1000011100000004")
+        self.assertEquals("XXXX-XXXX-XXXX-0004",
+                          bankcard._get_obfuscated_number())

tests/unit/payment_tests.py

@@ -1,69 +0,0 @@
-import datetime
-
-from django.test import TestCase
-from django.contrib.auth.models import User
-
-from oscar.apps.payment.models import Bankcard
-from oscar.apps.payment.forms import (bankcard_type, VISA, MASTERCARD, AMEX, DISCOVER, 
-                                      BankcardNumberField, BankcardExpiryMonthField, luhn)
-
-
-class BankcardTest(TestCase):
-    
-    def test_get_obfuscated_number(self):
-        bankcard = Bankcard(name="David Winterbottom", number="1000011100000004")
-        self.assertEquals("XXXX-XXXX-XXXX-0004", bankcard._get_obfuscated_number())
-    
-    def test_number_is_anonymised_when_saving(self):
-        user = User.objects.create(username='Dummy user')
-        expiry_date = datetime.date(year=2012, month=02, day=12)
-        bankcard = Bankcard.objects.create(name="David Winterbottom", number="1000011100000004", user=user, expiry_date=expiry_date)
-        self.assertEquals("XXXX-XXXX-XXXX-0004", bankcard.number)
-
-
-class BankcardTypeTest(TestCase):
-    
-    fixture_data = {
-        VISA: ('4111111111111111',),
-        MASTERCARD: ('5500000000000004',),
-        DISCOVER: ('6011000000000004',),
-        AMEX: ('340000000000009',),
-    }
-    
-    def test_bankcard_type_sniffer(self):
-        for type, numbers in self.fixture_data.items():
-            for n in numbers:
-                self.assertEquals(type, bankcard_type(n), "%s is a %s" % (n, type))
-        
-
-class BankcardNumberFieldTest(TestCase):
-    
-    def setUp(self):
-        self.f = BankcardNumberField()
-        
-    def test_spaces_are_stipped(self):
-        self.assertEquals('4111111111111111', self.f.clean('  4111 1111 1111 1111'))
-        
-
-class LuhnTest(TestCase):
-    
-    valid_numbers = ['4111111111111111',
-                     '5500000000000004',
-                     '6011000000000004',
-                     '340000000000009']
-    
-    # Tweaked versions of above valid numbers
-    invalid_numbers = ['4111111111111110',
-                     '5500000000000009',
-                     '6011000000000000',
-                     '340000000000005']
-    
-    def test_valid_numbers_pass(self):
-        for number in self.valid_numbers:
-            self.assertTrue(luhn(number))
-            
-    def test_invalid_numbers_fail(self):
-        for number in self.invalid_numbers:
-            self.assertFalse(luhn(number))
-    
-