Produits Entr'ouvert » EOPayment

import datetime

import pytz

        logger.debug(u'%r' % kwargs)

        if 'capture_date' in kwargs:

            capture_date = kwargs.pop('capture_date')

            delay_param = None

            for parameter in self.backend.description['parameters']:

                if parameter['name'] in ('capture_day', 'vads_capture_delay'):

                    delay_param = parameter['name']

                    break

            if delay_param is None:

                raise ValueError('capture_date is not supported by the backend.')

            if delay_param:

                if not isinstance(capture_date, datetime.date):

                    raise ValueError('capture_date should be a date object.')

                # backend timezone should come from some backend configuration

                backend_tz = pytz.timezone('Europe/Paris')

                utc_tz = pytz.timezone('Etc/UTC')

                backend_trans_date = utc_tz.localize(

                    datetime.datetime.utcnow()).astimezone(backend_tz)

                capture_delay = (capture_date - backend_trans_date.date()).days

                if capture_delay <= 0:

                    raise ValueError("capture_date needs to be superior to the transaction date.")

                kwargs[delay_param] = capture_delay

        capture_day = kwargs['capture_day'] if 'capture_day' in kwargs else self.capture_day

        if capture_day:

            d['PBX_DIFF'] = capture_day.zfill(2)

        if 'capture_day' in kwargs:

            data['captureDay'] = kwargs.get('capture_day')

                 'vads_payment_cards', 'vads_payment_config', 'vads_capture_delay'):

from datetime import date, datetime, timedelta

import mock

import pytest

def do_mock_backend(monkeypatch, delay_param):

    class MockBackend(object):

        request = mock.Mock()

        description = {

            'parameters': [

                {

                    'name': delay_param,

                }

            ]

        }

    def get_backend(*args, **kwargs):

        def backend(*args, **kwargs):

            return MockBackend

        return backend

    import eopayment

    monkeypatch.setattr(eopayment, 'get_backend', get_backend)

    return MockBackend, eopayment.Payment('kind', None)

@pytest.mark.parametrize('delay_param', ['capture_day', 'vads_capture_delay'])

def test_deferred_payment(monkeypatch, delay_param):

    mock_backend, payment = do_mock_backend(monkeypatch, delay_param)

    capture_date = (datetime.now().date() + timedelta(days=3))

    payment.request(amount=12.2, capture_date=capture_date)

    mock_backend.request.assert_called_with(12.2, **{delay_param: u'3'})

    # capture date can't be inferior to the transaction date

    capture_date = (datetime.now().date() - timedelta(days=3))

    with pytest.raises(

            ValueError, match='capture_date needs to be superior to the transaction date'):

        payment.request(amount=12.2, capture_date=capture_date)

    # capture date should be a date object

    capture_date = 'not a date'

    with pytest.raises(ValueError, match='capture_date should be a date object.'):

        payment.request(amount=12.2, capture_date=capture_date)

    # using capture date on a backend that does not support it raise an error

    capture_date = (datetime.now().date() + timedelta(days=3))

    mock_backend.description['parameters'] = []

    with pytest.raises(ValueError, match='capture_date is not supported by the backend.'):

        payment.request(amount=12.2, capture_date=capture_date)

@pytest.mark.freeze_time('2018-10-02 23:50:00')

@pytest.mark.parametrize('delay_param', ['capture_day', 'vads_capture_delay'])

def test_paris_timezone(monkeypatch, delay_param):

    _, payment = do_mock_backend(monkeypatch, delay_param)

    capture_date = date(year=2018, month=10, day=3)

    with pytest.raises(

            ValueError, match='capture_date needs to be superior to the transaction date'):

        # utcnow will return 2018-10-02 23:50:00,

        # converted to Europe/Paris it is already 2018-10-03

        # so 2018-10-03 for capture_date is invalid

        payment.request(amount=12.2, capture_date=capture_date)

        # capture_day can be used as a request argument

        params = BACKEND_PARAMS.copy()

        backend = eopayment.Payment('paybox', params)

        transaction_id, kind, what = backend.request(

                Decimal(amount), email=email, orderid=order_id,

                transaction_id=transaction, time=time, capture_day=2)

        root = ET.fromstring(str(what))

        form_params = dict(((

            node.attrib['name'], node.attrib['value']) for node in root

                            if node.attrib['type'] == 'hidden'))

        self.assertIn('PBX_DIFF', form_params)

        self.assertEqual(form_params['PBX_DIFF'], '02')

        # capture_day passed as a request argument

        # overrides capture_day from backend params

        params = BACKEND_PARAMS.copy()

        params['capture_day'] = '7'

        backend = eopayment.Payment('paybox', params)

        transaction_id, kind, what = backend.request(

                Decimal(amount), email=email, orderid=order_id,

                transaction_id=transaction, time=time, capture_day=2)

        root = ET.fromstring(str(what))

        form_params = dict(((

            node.attrib['name'], node.attrib['value']) for node in root

                            if node.attrib['type'] == 'hidden'))

        self.assertIn('PBX_DIFF', form_params)

        self.assertEqual(form_params['PBX_DIFF'], '02')

    transaction, f, form = backend.request(amount=u'12', info1='foobar', capture_day=u'1')

    data = [f for f in form.fields if f['name'] == 'Data']

    assert 'captureDay=1' in data[0]['value']

from datetime import datetime, timedelta

import eopayment

def get_field(form, field_name):

    for field in form.fields:

        if field['name'] == field_name:

            return field

def test_systempayv2_deferred_payment():

    default_params = {

        'secret_test': u'1122334455667788',

        'vads_site_id': u'12345678',

        'vads_ctx_mode': u'TEST',

    }

    default_data = {

        'amount': 15.24, 'orderid': '654321', 'first_name': u'John',

        'last_name': u'Doe'

    }

    # default vads_capture_delay used

    params = default_params.copy()

    params['vads_capture_delay'] = 1

    backend = eopayment.Payment('systempayv2', params)

    data = default_data.copy()

    transaction_id, f, form = backend.request(**data)

    assert get_field(form, 'vads_capture_delay')['value'] == '1'

    # vads_capture_delay can used in request and

    # override default vads_capture_delay

    params = default_params.copy()

    params['vads_capture_delay'] = 1

    p = eopayment.Payment('systempayv2', params)

    data = default_data.copy()

    data['vads_capture_delay'] = '3'

    transaction_id, f, form = p.request(**data)

    assert get_field(form, 'vads_capture_delay')['value'] == '3'

    # capture_date can be used for deffered_payment

    params = default_params.copy()

    params['vads_capture_delay'] = 1

    p = eopayment.Payment('systempayv2', params)

    data = default_data.copy()

    data['capture_date'] = (datetime.now().date() + timedelta(days=4))

    transaction_id, f, form = p.request(**data)

    assert get_field(form, 'vads_capture_delay')['value'] == '4'

  pytest-freezegun