Added XML generation for all transaction methods

oscar/apps/payment/datacash/utils.py

@@ -13,78 +13,98 @@ class Gateway(object):
     def do_request(self, request_xml):
         pass
 
-    def create_xml_doc(self):
-        
-        
-        return doc
-
-    def auth(self, card_number, expiry_date, amount, currency, merchant_reference, start_date=None):
+    def _initial_transaction(self, method_name, **kwargs):
+        """
+        Builds the XML for a 'initial' transaction
+        """
         doc = Document()
-        req = doc.createElement('Request')
-        doc.appendChild(req)
+        req = self._create_element(doc, doc, 'Request')
         
-        auth = doc.createElement('Authentication')
-        req.appendChild(auth)
-        
-        client = doc.createElement('client')
-        auth.appendChild(client)
-        client_text = doc.createTextNode(self._client)
-        client.appendChild(client_text)
-        
-        pw = doc.createElement('password')
-        auth.appendChild(pw)
-        pw_text = doc.createTextNode(self._password)
-        pw.appendChild(pw_text)
+        # Authentication
+        auth = self._create_element(doc, req, 'Authentication')
+        self._create_element(doc, auth, 'client', self._client)
+        self._create_element(doc, auth, 'password', self._password)
             
-        txn = doc.createElement('Transaction')
-        req.appendChild(txn)
-        card_txn = doc.createElement('CardTxn')
-        txn.appendChild(card_txn)
-        card = doc.createElement('Card')
-        card_txn.appendChild(card)
-        
-        pan = doc.createElement('pan')
-        card.appendChild(pan)
-        pan_text = doc.createTextNode(card_number)
-        pan.appendChild(pan_text)
-        
-        expiry = doc.createElement('expirydate')
-        card.appendChild(expiry)
-        expiry_text = doc.createTextNode(expiry_date)
-        expiry.appendChild(expiry_text)
-        
-        if start_date:
-            start = doc.createElement('startdate')
-            card.appendChild(start)
-            start_text = doc.createTextNode(start_date)
-            start.appendChild(start_text)
-        
-        txn_details = doc.createElement('TxnDetails')
-        txn.appendChild(txn_details)
-        
-        merchant = doc.createElement('merchantreference')
-        txn_details.appendChild(merchant)
-        merchant_text = doc.createTextNode(merchant_reference)
-        merchant.appendChild(merchant_text)
-        
-        amount_ele = doc.createElement('amount')
-        txn_details.appendChild(amount_ele)
-        amount_text = doc.createTextNode(str(amount))
-        amount_ele.appendChild(amount_text)
-        amount_ele.setAttribute('currency', currency)
+        # Transaction    
+        txn = self._create_element(doc, req, 'Transaction') 
         
-        method = doc.createElement('method')
-        card_txn.appendChild(method)
-        method_text = doc.createTextNode('auth')
-        method.appendChild(method_text)
+        # CardTxn
+        if 'card_number' in kwargs:
+            card_txn = self._create_element(doc, txn, 'CardTxn')
+            self._create_element(doc, card_txn, 'method', method_name)
+            
+            card = self._create_element(doc, card_txn, 'Card')
+            self._create_element(doc, card, 'pan', kwargs['card_number'])
+            self._create_element(doc, card, 'expirydate', kwargs['expiry_date'])
+            
+            if 'start_date' in kwargs:
+                self._create_element(doc, card, 'startdate', kwargs['start_date'])
+            
+            if 'issue_number' in kwargs:
+                self._create_element(doc, card, 'issuenumber', kwargs['issue_number'])
+          
+            if 'auth_code' in kwargs:
+                self._create_element(doc, card, 'authcode', kwargs['auth_code'])
+        
+        # HistoricTxn
+        if 'txn_reference' in kwargs:
+            historic_txn = self._create_element(doc, txn, 'HistoricTxn')
+            self._create_element(doc, historic_txn, 'reference', kwargs['txn_reference'])
+            self._create_element(doc, historic_txn, 'method', method_name)
+            if 'auth_code' in kwargs:
+                self._create_element(doc, historic_txn, 'authcode', kwargs['auth_code'])
+        
+        # TxnDetails
+        if 'amount' in kwargs:
+            txn_details = self._create_element(doc, txn, 'TxnDetails')
+            if 'merchant_reference' in kwargs:
+                self._create_element(doc, txn_details, 'merchantreference', kwargs['merchant_reference'])
+            self._create_element(doc, txn_details, 'amount', str(kwargs['amount']), {'currency': kwargs['currency']})
         
         self.do_request(doc.toxml())
 
-    def pre(self, request):
-        pass
+    def _create_element(self, doc, parent, tag, value=None, attributes=None):
+        ele = doc.createElement(tag)
+        parent.appendChild(ele)
+        if value:
+            text = doc.createTextNode(value)
+            ele.appendChild(text)
+        if attributes:
+            [ele.setAttribute(k, v) for k,v in attributes.items()]
+        return ele
 
-    def refund(self, request):
-        pass
+    def auth(self, **kwargs):
+        """
+        Performs an 'auth' request, which is to debit the money immediately
+        as a one-off transaction.
+        
+        Note that currency should be ISO 4217 Alphabetic format.
+        """ 
+        return self._initial_transaction('auth', **kwargs)
+        
+    def pre(self, **kwargs):
+        """
+        Performs an 'pre' request, which is to ring-fence the requested money
+        so it can be fulfilled at a later time.
+        """ 
+        return self._initial_transaction('pre', **kwargs)
+
+    def refund(self, **kwargs):
+        return self._initial_transaction('refund', **kwargs)
+        
+    def erp(self, **kwargs):
+        return self._initial_transaction('erp', **kwargs)
+        
+    # "Historic" transaction types    
+        
+    def cancel(self, txn_reference): 
+        return self._initial_transaction('cancel', txn_reference=txn_reference)
+    
+    def fulfil(self, **kwargs):
+        return self._initial_transaction('fulfil', **kwargs) 
+    
+    def txn_refund(self, **kwargs):
+        return self._initial_transaction('txn_refund', **kwargs) 
 
 
 class Adapter(object):

oscar/apps/payment/tests/datacash.py

@@ -7,9 +7,9 @@ from django.test import TestCase
 from oscar.apps.payment.datacash.utils import Gateway
 
 
-class AuthTransactionTests(TestCase):
+class TransactionMixin(object):
     
-    def setUp(self):
+    def init_gateway(self):
         self.gateway = Gateway(client="DUMMY", password="123456")
         self.transport = mock.Mock()
         self.gateway.do_request = self.transport
@@ -22,6 +22,12 @@ class AuthTransactionTests(TestCase):
             self.assertEquals(value, tag.firstChild.data)
         except IndexError:
             self.fail("Tag '%s' not found\n%s" % (tag_name, request_xml))
+    
+    def make_request(self, **kwargs):
+        """
+        Needs to be implemented by subclass.
+        """
+        pass
             
     def assertXmlTagAttributeValue(self, tag_name, attribute, value):
         request_xml = self.transport.call_args[0][0]
@@ -32,51 +38,171 @@ class AuthTransactionTests(TestCase):
         except IndexError:
             self.fail("Tag '%s' not found\n%s" % (tagName, request_xml))
     
-    def make_auth_request(self):
-        self.gateway.auth(card_number='1000010000000007', 
-                          start_date='01/10',
-                          expiry_date='01/12',
-                          issue_number='03',
-                          merchant_reference='123123',
-                          currency='GBP',
-                          amount=D('12.99'))
-    
-    def test_auth_includes_credentials(self):
-        self.make_auth_request()
+    def test_request_includes_credentials(self):
+        self.make_request()
         self.assertTrue(self.transport.called)
         self.assertXmlTagValue('client', 'DUMMY')
         self.assertXmlTagValue('password', '123456')
+
+
+class InitialTransactionMixin(TransactionMixin):
+    
+    def test_request_includes_merchant_reference(self):   
+        self.make_request()
+        self.assertXmlTagValue('merchantreference', '123123')
+        
+    def test_request_includes_amount_and_currency(self):   
+        self.make_request()
+        self.assertXmlTagValue('amount', '12.99')
+        self.assertXmlTagAttributeValue('amount', 'currency', 'GBP')
         
-    def test_auth_includes_card_details(self):   
-        self.make_auth_request()
+    def test_request_can_include_authcode(self):
+        self.make_request(auth_code='334455')    
+        self.assertXmlTagValue('authcode', '334455')
+    
+    def test_request_includes_card_details(self):   
+        self.make_request(start_date='01/10')
         self.assertXmlTagValue('pan', '1000010000000007')
         self.assertXmlTagValue('startdate', '01/10')
         self.assertXmlTagValue('expirydate', '01/12')
         
-    def test_auth_includes_merchant_reference(self):   
-        self.make_auth_request()
-        self.assertXmlTagValue('merchantreference', '123123')
+    def test_request_can_include_issue_number(self):
+        self.make_request(issue_number='03')    
+        self.assertXmlTagValue('issuenumber', '03')    
         
-    def test_auth_includes_amount_and_currency(self):   
-        self.make_auth_request()
-        self.assertXmlTagValue('amount', '12.99')
-        self.assertXmlTagAttributeValue('amount', 'currency', 'GBP')
+    def test_request_can_include_authcode(self):
+        self.make_request(auth_code='334455')    
+        self.assertXmlTagValue('authcode', '334455')
+
+
+class AuthTransactionTests(TestCase, InitialTransactionMixin):
+    
+    def setUp(self):
+        self.init_gateway()
+    
+    def make_request(self, **kwargs):
+        self.gateway.auth(card_number='1000010000000007', 
+                          expiry_date='01/12',
+                          merchant_reference='123123',
+                          currency='GBP',
+                          amount=D('12.99'),
+                          **kwargs)
         
-    def test_auth_includes_method(self):
-        self.make_auth_request()    
+    def test_request_includes_method(self):
+        self.make_request()    
         self.assertXmlTagValue('method', 'auth')
     
-
-class HistoricTransactionTests(TestCase):
+    
+class PreTransactionTests(TestCase, InitialTransactionMixin):
     
     def setUp(self):
-        self.gateway = Gateway(client="DUMMY", password="123456")
-
-    def test_cancel(self):
-        self.gateway.auth
+        self.init_gateway()
+    
+    def make_request(self, **kwargs):
+        self.gateway.pre(card_number='1000010000000007', 
+                         expiry_date='01/12',
+                         merchant_reference='123123',
+                         currency='GBP',
+                         amount=D('12.99'),
+                         **kwargs)    
         
-    def test_fulfil(self):
-        pass
+    def test_request_includes_method(self):
+        self.make_request()    
+        self.assertXmlTagValue('method', 'pre')
+        
+        
+class RefundTransactionTests(TestCase, InitialTransactionMixin):
     
-    def test_txn_refund(self):
-        pass
+    def setUp(self):
+        self.init_gateway()
+    
+    def make_request(self, **kwargs):
+        self.gateway.refund(card_number='1000010000000007', 
+                            expiry_date='01/12',
+                            merchant_reference='123123',
+                            currency='GBP',
+                            amount=D('12.99'),
+                            **kwargs)    
+        
+    def test_request_includes_method(self):
+        self.make_request()    
+        self.assertXmlTagValue('method', 'refund')
+    
+    
+class ErpTransactionTests(TestCase, InitialTransactionMixin):
+    
+    def setUp(self):
+        self.init_gateway()
+    
+    def make_request(self, **kwargs):
+        self.gateway.erp(card_number='1000010000000007', 
+                         expiry_date='01/12',
+                         merchant_reference='123123',
+                         currency='GBP',
+                         amount=D('12.99'),
+                         **kwargs)    
+        
+    def test_request_includes_method(self):
+        self.make_request()    
+        self.assertXmlTagValue('method', 'erp')    
+    
+    
+class CancelTransactionTests(TestCase, TransactionMixin):
+    
+    def setUp(self):
+        self.init_gateway()
+    
+    def make_request(self, **kwargs):
+        self.gateway.cancel(txn_reference='12312333444')
+        
+    def test_request_includes_method(self):
+        self.make_request()    
+        self.assertXmlTagValue('method', 'cancel') 
+        
+    def test_request_includes_reference(self):
+        self.make_request()    
+        self.assertXmlTagValue('reference', '12312333444') 
+        
+        
+class FulfilTransactionTests(TestCase, TransactionMixin):
+    
+    def setUp(self):
+        self.init_gateway()
+    
+    def make_request(self, **kwargs):
+        self.gateway.fulfil(currency='GBP',
+                            amount=D('12.99'),
+                            txn_reference='12312333444',
+                            auth_code='123444')
+        
+    def test_request_includes_method(self):
+        self.make_request()    
+        self.assertXmlTagValue('method', 'fulfil')   
+        
+    def test_request_includes_reference(self):
+        self.make_request()    
+        self.assertXmlTagValue('reference', '12312333444') 
+        
+    def test_request_includes_authcode(self):
+        self.make_request()    
+        self.assertXmlTagValue('authcode', '123444') 
+        
+        
+class TxnRefundTransactionTests(TestCase, TransactionMixin):
+    
+    def setUp(self):
+        self.init_gateway()
+    
+    def make_request(self, **kwargs):
+        self.gateway.txn_refund(currency='GBP',
+                                amount=D('12.99'),
+                                txn_reference='12312333444')
+        
+    def test_request_includes_method(self):
+        self.make_request()    
+        self.assertXmlTagValue('method', 'txn_refund')   
+        
+    def test_request_includes_reference(self):
+        self.make_request()    
+        self.assertXmlTagValue('reference', '12312333444') 
+