Deleted datacash code as it has its own repository now

oscar/apps/payment/datacash/abstract_models.py

@@ -1,39 +0,0 @@
-import re
-
-from django.db import models
-
-
-class AbstractOrderTransaction(models.Model):
-    
-    # We track link with basket for audit
-    basket = models.ForeignKey('basket.Basket', null=True)
-    
-    # Note we don't use a foreign key as the order hasn't been created
-    # by the time the transaction takes place
-    order_number = models.CharField(max_length=128, db_index=True)
-    
-    # The 'method' of the transaction - one of 'auth', 'pre', 'cancel', ...
-    method = models.CharField(max_length=12)
-    amount = models.DecimalField(decimal_places=2, max_digits=12)
-    merchant_ref = models.CharField(max_length=128)
-    
-    # Response fields
-    datacash_ref = models.CharField(max_length=128)
-    auth_code = models.CharField(max_length=128, blank=True, null=True)
-    status = models.PositiveIntegerField()
-    reason = models.CharField(max_length=255)
-    
-    # Store full XML for debugging purposes
-    request_xml = models.TextField()
-    response_xml = models.TextField()
-    
-    date = models.DateTimeField(auto_now_add=True)
-    
-    class Meta:
-        abstract = True
-        
-    def save(self, *args, **kwargs):
-        if not self.pk:
-            reg_ex = re.compile(r'\d{12}')
-            self.request_xml = reg_ex.sub('XXXXXXXXXXXX', self.request_xml)
-        super(AbstractOrderTransaction, self).save(*args, **kwargs)

oscar/apps/payment/datacash/models.py

@@ -1,7 +0,0 @@
-from django.db import models
-
-from oscar.apps.payment.datacash.abstract_models import AbstractOrderTransaction
-
-
-class OrderTransaction(AbstractOrderTransaction):
-    pass

oscar/apps/payment/datacash/tests.py

@@ -1,91 +0,0 @@
-from decimal import Decimal as D
-from xml.dom.minidom import parseString
-import datetime
-
-from django.test import TestCase
-from django.conf import settings
-
-from oscar.apps.payment.datacash.models import OrderTransaction
-from oscar.apps.payment.datacash.utils import Gateway, Facade
-from oscar.apps.payment.utils import Bankcard
-
-
-class OrderTransactionTests(TestCase):
-    
-    def test_cc_numbers_are_not_saved(self):
-        
-        request_xml = """<?xml version="1.0" encoding="UTF-8" ?>
-<Request>
-    <Authentication>
-        <client>99000001</client>
-        <password>boomboom</password>
-    </Authentication>
-    <Transaction>
-    <CardTxn>
-        <Card>
-            <pan>1000011100000004</pan>
-            <expirydate>04/06</expirydate>
-            <startdate>01/04</startdate>
-        </Card>
-        <method>auth</method>
-    </CardTxn>
-    <TxnDetails>
-        <merchantreference>1000001</merchantreference>
-        <amount currency="GBP">95.99</amount>
-    </TxnDetails>
-    </Transaction>
-</Request>"""
-
-        response_xml = """<?xml version="1.0" encoding="UTF-8" ?>
-<Response>
-    <CardTxn>
-        <authcode>060642</authcode>
-        <card_scheme>Switch</card_scheme>
-        <country>United Kingdom</country>
-        <issuer>HSBC</issuer>
-    </CardTxn>
-    <datacash_reference>3000000088888888</datacash_reference>
-    <merchantreference>1000001</merchantreference>
-    <mode>LIVE</mode>
-    <reason>ACCEPTED</reason>
-    <status>1</status>
-    <time>1071567305</time>
-</Response>"""
-        
-        txn = OrderTransaction.objects.create(order_number='1000',
-                                              method='auth',
-                                              datacash_ref='3000000088888888',
-                                              merchant_ref='1000001',
-                                              amount=D('95.99'),
-                                              status=1,
-                                              reason='ACCEPTED',
-                                              request_xml=request_xml,
-                                              response_xml=response_xml)
-        doc = parseString(txn.request_xml)
-        element = doc.getElementsByTagName('pan')[0]
-        self.assertEqual('XXXXXXXXXXXX0004', element.firstChild.data)
-        
-        
-class IntegrationTests(TestCase):
-    
-    def _test_for_smoke(self):
-        gateway = Gateway(settings.DATACASH_CLIENT, 
-                          settings.DATACASH_PASSWORD,
-                          host=settings.DATACASH_HOST)
-        response = gateway.auth(card_number='1000011000000005',
-                                expiry_date='01/13',
-                                amount=D('50.00'),
-                                currency='GBP',
-                                merchant_reference='123456_%s' % datetime.datetime.now().microsecond)
-        print response
-        
-    def _test_adapter(self):
-        bankcard = Bankcard(card_number='1000011000000005', expiry_date='01/13')
-    
-        dc_facade = Facade()
-        reference = dc_facade.debit('102910', D('23.00'), bankcard)
-        print reference
-        
-        OrderTransaction.objects.get(order_number='102910')
-        
-    

oscar/apps/payment/datacash/utils.py

@@ -1,245 +0,0 @@
-import datetime
-from xml.dom.minidom import Document, parseString
-import httplib
-import urllib
-
-from django.conf import settings
-from django.db import transaction
-from django.utils.translation import ugettext_lazy as _
-from django.core.mail import mail_admins
-
-from oscar.core.loading import import_module
-import_module('payment.datacash.models', ['OrderTransaction'], locals())
-import_module('payment.exceptions', ['TransactionDeclined', 'GatewayError', 
-                                     'InvalidGatewayRequestError'], locals())
-
-# Status codes
-ACCEPTED, DECLINED, INVALID_CREDENTIALS = '1', '7', '10'
-
-
-class Gateway(object):
-
-    def __init__(self, client, password, host, cv2avs=False):
-        self._client = client
-        self._password = password
-        self._host = host
-        
-        # Fraud settings
-        self._cv2avs = cv2avs
-
-    def do_request(self, request_xml):
-        # Need to fill in HTTP request here
-        conn = httplib.HTTPSConnection(self._host, 443, timeout=30)
-        headers = {"Content-type": "application/xml",
-                   "Accept": ""}
-        conn.request("POST", "/Transaction", request_xml, headers)
-        response = conn.getresponse()
-        response_xml = response.read()
-        if response.status != httplib.OK:
-            raise GatewayError("Unable to communicate with payment gateway (code: %s, response: %s)" % (response.status, response_xml))
-        conn.close()
-        
-        # Save response XML
-        self._last_response_xml = response_xml
-        return response_xml
-
-    def _build_request_xml(self, method_name, **kwargs):
-        """
-        Builds the XML for a 'initial' transaction
-        """
-        doc = Document()
-        req = self._create_element(doc, doc, 'Request')
-        
-        # Authentication
-        auth = self._create_element(doc, req, 'Authentication')
-        self._create_element(doc, auth, 'client', self._client)
-        self._create_element(doc, auth, 'password', self._password)
-            
-        # Transaction    
-        txn = self._create_element(doc, req, 'Transaction') 
-        
-        # 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'])
-                
-            if self._cv2avs:
-                self._add_cv2avs_elements(doc, card, kwargs) 
-        
-        # 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']})
-        
-        # Save XML for later retrieval
-        self._last_request_xml = doc.toxml()
-        
-        return self.do_request(doc.toxml())
-
-    def _add_cv2avs_elements(self, doc, card, kwargs):
-        cv2avs = self._create_element(doc, card, 'Cv2Avs')
-        if 'ccv' in kwargs:
-            self._create_element(doc, cv2avs, 'cv2', kwargs['ccv'])
-
-    def _create_element(self, doc, parent, tag, value=None, attributes=None):
-        """
-        Creates an XML element
-        """
-        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 _get_element_text(self, doc, tag):
-        try:
-            ele = doc.getElementsByTagName(tag)[0]
-        except IndexError:
-            return None
-        return ele.firstChild.data
-
-    def _build_response_dict(self, response_xml, extra_elements=None):
-        doc = parseString(response_xml)
-        response = {'status': int(self._get_element_text(doc, 'status')),
-                    'datacash_reference': self._get_element_text(doc, 'datacash_reference'),
-                    'merchant_reference': self._get_element_text(doc, 'merchantreference'),
-                    'reason': self._get_element_text(doc, 'reason')}
-        if extra_elements:
-            for tag, key in extra_elements.items():
-                response[key] = self._get_element_text(doc, tag)
-        return response
-
-    # API
-
-    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.
-        """ 
-        self._check_kwargs(kwargs, ['amount', 'currency', 'card_number', 'expiry_date', 'merchant_reference'])
-        response_xml = self._build_request_xml('auth', **kwargs)
-        return self._build_response_dict(response_xml, {'authcode': 'auth_code'})
-        
-    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.
-        """ 
-        self._check_kwargs(kwargs, ['amount', 'currency', 'card_number', 'expiry_date', 'merchant_reference'])
-        response_xml = self._build_request_xml('pre', **kwargs)
-        return self._build_response_dict(response_xml, {'authcode': 'auth_code'})
-
-    def refund(self, **kwargs):
-        self._check_kwargs(kwargs, ['amount', 'currency', 'card_number', 'expiry_date', 'merchant_reference'])
-        response_xml = self._build_request_xml('refund', **kwargs)
-        return self._build_response_dict(response_xml, {'authcode': 'auth_code'})
-        
-    def erp(self, **kwargs):
-        self._check_kwargs(kwargs, ['amount', 'currency', 'card_number', 'expiry_date', 'merchant_reference'])
-        response_xml = self._build_request_xml('erp', **kwargs)
-        return self._build_response_dict(response_xml, {'authcode': 'auth_code'})
-        
-    # "Historic" transaction types    
-        
-    def cancel(self, txn_reference): 
-        response_xml = self._build_request_xml('cancel', txn_reference=txn_reference)
-        return self._build_response_dict(response_xml)
-    
-    def fulfil(self, **kwargs):
-        self._check_kwargs(kwargs, ['amount', 'currency', 'txn_reference', 'auth_code'])
-        response_xml = self._build_request_xml('fulfil', **kwargs)
-        return self._build_response_dict(response_xml)
-    
-    def txn_refund(self, **kwargs):
-        self._check_kwargs(kwargs, ['amount', 'currency', 'txn_reference'])
-        response_xml = self._build_request_xml('txn_refund', **kwargs)
-        return self._build_response_dict(response_xml)
-    
-    def last_request_xml(self):
-        return self._last_request_xml
-    
-    def last_response_xml(self):
-        return self._last_response_xml
-    
-    def _check_kwargs(self, kwargs, required_keys):
-        for key in required_keys:
-            if key not in kwargs:
-                raise RuntimeError('You must provide a "%s" argument' % key)
-
-
-class Facade(object):
-    """
-    Responsible for dealing with oscar objects
-    """
-    
-    def __init__(self):
-        self.gateway = Gateway(settings.DATACASH_CLIENT, settings.DATACASH_PASSWORD, settings.DATACASH_HOST)
-    
-    def debit(self, order_number, amount, bankcard, basket, billing_address=None):
-        with transaction.commit_on_success():
-            response = self.gateway.auth(card_number=bankcard.card_number,
-                                         expiry_date=bankcard.expiry_date,
-                                         amount=amount,
-                                         currency='GBP',
-                                         merchant_reference=self.generate_merchant_reference(order_number),
-                                         ccv=bankcard.ccv)
-            
-            # Create transaction model irrespective of whether transaction was successful or not
-            txn = OrderTransaction.objects.create(order_number=order_number,
-                                                  basket=basket,
-                                                  method='auth',
-                                                  datacash_ref=response['datacash_reference'],
-                                                  merchant_ref=response['merchant_reference'],
-                                                  amount=amount,
-                                                  auth_code=response['auth_code'],
-                                                  status=int(response['status']),
-                                                  reason=response['reason'],
-                                                  request_xml=self.gateway.last_request_xml(),
-                                                  response_xml=self.gateway.last_response_xml())
-        
-        # Test if response is successful
-        if response['status'] == INVALID_CREDENTIALS:
-            # This needs to notify the administrators straight away
-            import pprint
-            msg = "Order #%s:\n%s" % (order_number, pprint.pprint(response))
-            mail_admins("Datacash credentials are not valid", msg)
-            raise InvalidGatewayRequestError("Unable to communicate with payment gateway, please try again later")
-        
-        if response['status'] == DECLINED:
-            raise TransactionDeclined("Your bank declined this transaction, please check your details and try again")
-        
-        return response['datacash_reference']
-        
-    def generate_merchant_reference(self, order_number):
-        return '%s_%s' % (order_number, datetime.datetime.now().microsecond)
-        
-        
-

oscar/apps/payment/tests/__init__.py

@@ -1,4 +1,2 @@
 from oscar.apps.payment.tests.main import *
-from oscar.apps.payment.tests.datacash_requests import *
-from oscar.apps.payment.tests.datacash_responses import *
 

oscar/apps/payment/tests/datacash_requests.py

@@ -1,240 +0,0 @@
-import mock
-from decimal import Decimal as D
-from xml.dom.minidom import parseString
-
-from django.test import TestCase
-
-from oscar.apps.payment.datacash.utils import Gateway
-
-
-class TransactionMixin(object):
-    
-    def init_gateway(self, **kwargs):
-        self.gateway = Gateway(client="DUMMY", password="123456", host="dummyhost.com", **kwargs)
-        self.transport = mock.Mock()
-        self.gateway.do_request = self.transport
-        
-        # Set a default success response
-        response_xml = """<?xml version="1.0" encoding="UTF-8" ?>
-<Response>
-    <CardTxn>
-        <authcode>060642</authcode>
-        <card_scheme>Switch</card_scheme>
-        <country>United Kingdom</country>
-        <issuer>HSBC</issuer>
-    </CardTxn>
-    <datacash_reference>3000000088888888</datacash_reference>
-    <merchantreference>1000001</merchantreference>
-    <mode>LIVE</mode>
-    <reason>ACCEPTED</reason>
-    <status>1</status>
-    <time>1071567305</time>
-</Response>"""
-        self.transport.return_value = response_xml
-    
-    def assertXmlTagValue(self, tag_name, value):
-        request_xml = self.transport.call_args[0][0]
-        doc = parseString(request_xml)
-        try:
-            tag = doc.getElementsByTagName(tag_name)[0]
-            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]
-        doc = parseString(request_xml)
-        try:
-            tag = doc.getElementsByTagName(tag_name)[0]
-            self.assertEquals(value, tag.attributes[attribute].value)
-        except IndexError:
-            self.fail("Tag '%s' not found\n%s" % (tag_name, request_xml))
-    
-    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_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_request_can_include_issue_number(self):
-        self.make_request(issue_number='03')    
-        self.assertXmlTagValue('issuenumber', '03')    
-
-
-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_request_includes_method(self):
-        self.make_request()    
-        self.assertXmlTagValue('method', 'auth')
-    
-    
-class PreTransactionTests(TestCase, InitialTransactionMixin):
-    
-    def setUp(self):
-        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_request_includes_method(self):
-        self.make_request()    
-        self.assertXmlTagValue('method', 'pre')
-        
-        
-class RefundTransactionTests(TestCase, InitialTransactionMixin):
-    
-    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') 
-        
-        
-class Av2CVsTests(TestCase, TransactionMixin):
-    
-    def setUp(self):
-        self.init_gateway(cv2avs=True)
-    
-    def make_request(self, **kwargs):
-        self.gateway.auth(card_number='1000010000000007', 
-                          expiry_date='01/12',
-                          merchant_reference='123123',
-                          currency='GBP',
-                          amount=D('12.99'),
-                          ccv='234')
-        
-    def test_ccv_element_in_request(self):
-        self.make_request()
-        self.assertXmlTagValue('cv2', '234') 
-    

oscar/apps/payment/tests/datacash_responses.py

@@ -1,128 +0,0 @@
-import mock
-from decimal import Decimal as D
-from xml.dom.minidom import parseString
-
-from django.test import TestCase
-
-from oscar.apps.payment.datacash.utils import Gateway
-
-
-class AuthResponseHandlingTests(TestCase):
-    
-    success_response_xml = """<?xml version="1.0" encoding="UTF-8" ?>
-<Response>
-    <CardTxn>
-        <authcode>060642</authcode>
-        <card_scheme>Switch</card_scheme>
-        <country>United Kingdom</country>
-        <issuer>HSBC</issuer>
-    </CardTxn>
-    <datacash_reference>3000000088888888</datacash_reference>
-    <merchantreference>1000001</merchantreference>
-    <mode>LIVE</mode>
-    <reason>ACCEPTED</reason>
-    <status>1</status>
-    <time>1071567305</time>
-</Response>"""
-    
-    def setUp(self):
-        self.gateway = Gateway(client="DUMMY", password="123456", host="dummyhost.com",)
-        self.gateway.do_request = mock.Mock()
-    
-    def test_success_auth_response(self):
-        self.gateway.do_request.return_value = self.success_response_xml
-        response = self.gateway.auth(card_number='1000010000000007', 
-                                     expiry_date='01/12',
-                                     merchant_reference='1000001',
-                                     currency='GBP',
-                                     amount=D('12.99'))
-        self.assertEquals(1, response['status'])
-        self.assertEquals('3000000088888888', response['datacash_reference'])
-        self.assertEquals('1000001', response['merchant_reference'])
-        self.assertEquals('060642', response['auth_code'])
-        self.assertEquals('ACCEPTED', response['reason'])
-        
-    def test_success_pre_response(self):
-        self.gateway.do_request.return_value = self.success_response_xml
-        response = self.gateway.pre(card_number='1000010000000007', 
-                                     expiry_date='01/12',
-                                     merchant_reference='1000001',
-                                     currency='GBP',
-                                     amount=D('12.99'))
-        self.assertEquals(1, response['status'])
-        self.assertEquals('3000000088888888', response['datacash_reference'])
-        self.assertEquals('1000001', response['merchant_reference'])
-        self.assertEquals('060642', response['auth_code'])
-        self.assertEquals('ACCEPTED', response['reason'])
-        
-    def test_declined_auth_response(self):
-        response_xml = """<?xml version="1.0" encoding="UTF-8" ?>
-<Response>
-    <CardTxn>
-        <authcode>DECLINED</authcode>
-        <card_scheme>Mastercard</card_scheme>
-        <country>United Kingdom</country>
-    </CardTxn>
-    <datacash_reference>4400200045583767</datacash_reference>
-    <merchantreference>AA004630</merchantreference>
-    <mode>TEST</mode>
-    <reason>DECLINED</reason>
-    <status>7</status>
-    <time>1169223906</time>
-</Response>"""
-        self.gateway.do_request.return_value = response_xml
-        response = self.gateway.auth(card_number='1000010000000007', 
-                                     expiry_date='01/12',
-                                     merchant_reference='1000001',
-                                     currency='GBP',
-                                     amount=D('12.99'))
-        self.assertEquals(7, response['status'])
-        self.assertEquals('4400200045583767', response['datacash_reference'])
-        self.assertEquals('AA004630', response['merchant_reference'])
-        self.assertEquals('DECLINED', response['auth_code'])
-        self.assertEquals('DECLINED', response['reason'])
-
-    def test_successful_cancel_response(self):
-        response_xml = """<?xml version="1.0" encoding="UTF-8" ?>
-<Response>
-    <datacash_reference>4900200000000001</datacash_reference>
-    <merchantreference>4900200000000001</merchantreference>
-    <mode>TEST</mode>
-    <reason>CANCELLED OK</reason>
-    <status>1</status>
-    <time>1151567456</time>
-</Response>"""
-        self.gateway.do_request.return_value = response_xml
-        response = self.gateway.cancel(txn_reference='4900200000000001')
-        self.assertEquals(1, response['status'])
-        self.assertEquals('4900200000000001', response['datacash_reference'])
-        self.assertEquals('4900200000000001', response['merchant_reference'])
-        self.assertEquals('CANCELLED OK', response['reason'])
-        
-    def test_successful_fulfil_response(self):
-        response_xml = """<?xml version="1.0" encoding="UTF-8" ?>
-<Response>
-    <datacash_reference>3900200000000001</datacash_reference>
-    <merchantreference>3900200000000001</merchantreference>
-    <mode>LIVE</mode>
-    <reason>FULFILLED OK</reason>
-    <status>1</status>
-    <time>1071567356</time>
-</Response>
-"""
-        self.gateway.do_request.return_value = response_xml
-        response = self.gateway.fulfil(txn_reference='3900200000000001', 
-                                     merchant_reference='1000001',
-                                     currency='GBP',
-                                     amount=D('12.99'),
-                                     auth_code='asdf')
-        self.assertEquals(1, response['status'])
-        self.assertEquals('3900200000000001', response['datacash_reference'])
-        self.assertEquals('3900200000000001', response['merchant_reference'])
-        self.assertEquals('FULFILLED OK', response['reason'])
-
-
-
-        
-    
- 

run_tests.py

@@ -35,7 +35,6 @@ if not settings.configured:
                 'oscar.apps.catalogue.reviews',
                 'oscar.apps.basket',
                 'oscar.apps.payment',
-                'oscar.apps.payment.datacash',
                 'oscar.apps.offer',
                 'oscar.apps.address',
                 'oscar.apps.partner',