def test_ignore_duplicated_payments(self):
# needed objects
payer_id = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id)
create_member(patron=ps.patron,
first_payment_year=2017,
first_payment_month=5)
# create a couple of payments, different timestamps
tstamp1 = make_aware(datetime.datetime(year=2017, month=2, day=5))
tstamp2 = make_aware(datetime.datetime(year=2017, month=2, day=6))
records = [
create_payment_record(payer_id, timestamp=tstamp1),
create_payment_record(payer_id, timestamp=tstamp2),
]
logic.create_recurring_payments(records)
# now receive them all again, with the last one duplicated
records.append(records[1])
logic.create_recurring_payments(records)
# check we have still only two payments
all_quotas = Quota.objects.all()
self.assertEqual(len(all_quotas), 2)
def test_no_payment_match(self):
# needed objects
payer_id = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id)
create_member(patron=ps.patron,
first_payment_year=2017,
first_payment_month=5)
# create two payments in different timestamps
tstamp1 = make_aware(datetime.datetime(year=2017, month=2, day=1))
tstamp2 = make_aware(datetime.datetime(year=2017, month=3, day=1))
records = [
create_payment_record(payer_id, timestamp=tstamp1),
create_payment_record(payer_id, timestamp=tstamp2),
]
logic.create_recurring_payments(records)
assert len(Quota.objects.all()) == 2
# now create other two, NOT overlapping
tstamp3 = make_aware(datetime.datetime(year=2017, month=6, day=1))
tstamp4 = make_aware(datetime.datetime(year=2017, month=7, day=1))
tstamp5 = make_aware(datetime.datetime(year=2017, month=8, day=1))
records = [
create_payment_record(payer_id, timestamp=tstamp3),
create_payment_record(payer_id, timestamp=tstamp4),
create_payment_record(payer_id, timestamp=tstamp5),
]
logic.create_recurring_payments(records)
# check we have no more payments created and proper error log (including the last
# recorded and two new retrieved)
self.assertEqual(len(Quota.objects.all()), 5)
self.assertLoggedWarning("Found exceeding payment limit", str(tstamp2),
f'remaining: {len(records)}')
def test_simple_previous_payments(self):
# needed objects
payer_id = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id)
member = create_member(patron=ps.patron,
first_payment_year=2017,
first_payment_month=5)
# create three payments in different timestamps
tstamp1 = make_aware(datetime.datetime(year=2017, month=2, day=5))
tstamp2 = make_aware(datetime.datetime(year=2017, month=2, day=6))
tstamp3 = make_aware(datetime.datetime(year=2017, month=2, day=7))
records = [
create_payment_record(payer_id, timestamp=tstamp1),
create_payment_record(payer_id, timestamp=tstamp2),
create_payment_record(payer_id, timestamp=tstamp3),
]
logic.create_recurring_payments(records)
# now create other two, overlapping
tstamp4 = make_aware(datetime.datetime(year=2017, month=2, day=8))
records = [
create_payment_record(payer_id, timestamp=tstamp3),
create_payment_record(payer_id, timestamp=tstamp4),
]
logic.create_recurring_payments(records)
# check we have four payments
all_quotas = Quota.objects.all()
self.assertEqual(len(all_quotas), 4)
self.assertEqual(sorted(q.payment.timestamp for q in all_quotas),
[tstamp1, tstamp2, tstamp3, tstamp4])
self.assertLoggedInfo("Creating recurring payments", payer_id,
str(member), "2017, 2, 8")
def test_simple_everything_previous(self):
# needed objects
payer_id = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id)
create_member(patron=ps.patron,
first_payment_year=2017,
first_payment_month=5)
# create two payments in different timestamps
tstamp1 = make_aware(datetime.datetime(year=2017, month=2, day=5))
tstamp2 = make_aware(datetime.datetime(year=2017, month=2, day=6))
records = [
create_payment_record(payer_id, timestamp=tstamp1),
create_payment_record(payer_id, timestamp=tstamp2),
]
logic.create_recurring_payments(records)
# now create another, repeated
records = [
create_payment_record(payer_id, timestamp=tstamp2),
]
logic.create_recurring_payments(records)
# check we have four payments
all_quotas = Quota.objects.all()
self.assertEqual(len(all_quotas), 2)
self.assertEqual(sorted(q.payment.timestamp for q in all_quotas),
[tstamp1, tstamp2])
def test_simple_empty(self):
# needed objects
payer_id = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id)
member = create_member(patron=ps.patron)
# create the payment
tstamp = make_aware(datetime.datetime(year=2017, month=2, day=5))
records = [
{
'timestamp': tstamp,
'amount': DEFAULT_FEE,
'payer_id': payer_id
},
]
logic.create_recurring_payments(records)
# check
self.assertLoggedInfo("Creating recurring payments", payer_id,
str(member), "2017, 2, 5")
(payed_fee, ) = Quota.objects.all()
self.assertEqual(payed_fee.year, member.first_payment_year)
self.assertEqual(payed_fee.month, member.first_payment_month)
self.assertEqual(payed_fee.member, member)
def test_multiple_payers(self):
# needed objects
payer_id1 = '*****@*****.**'
payer_id2 = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id1)
member1 = create_member(patron=ps.patron)
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id2)
member2 = create_member(patron=ps.patron)
# create the payment
tstampA = make_aware(datetime.datetime(year=2017, month=2, day=5))
tstampB = make_aware(datetime.datetime(year=2017, month=2, day=6))
tstampC = make_aware(datetime.datetime(year=2017, month=2, day=7))
records = [
{
'timestamp': tstampA,
'amount': DEFAULT_FEE,
'payer_id': payer_id1
},
{
'timestamp': tstampC,
'amount': DEFAULT_FEE,
'payer_id': payer_id1
},
{
'timestamp': tstampB,
'amount': DEFAULT_FEE,
'payer_id': payer_id2
},
{
'timestamp': tstampA,
'amount': DEFAULT_FEE,
'payer_id': payer_id2
},
]
logic.create_recurring_payments(records)
# check
self.assertLoggedInfo("Creating recurring payments", payer_id1,
str(member1), "2017, 2, 5", "2017, 2, 7")
self.assertLoggedInfo("Creating recurring payments", payer_id2,
str(member2), "2017, 2, 5", "2017, 2, 6")
payed_fees = Quota.objects.all()
self.assertEqual(payed_fees[0].member, member1)
self.assertEqual(payed_fees[0].payment.timestamp, tstampA)
self.assertEqual(payed_fees[1].member, member1)
self.assertEqual(payed_fees[1].payment.timestamp, tstampC)
self.assertEqual(payed_fees[2].member, member2)
self.assertEqual(payed_fees[2].payment.timestamp, tstampA)
self.assertEqual(payed_fees[3].member, member2)
self.assertEqual(payed_fees[3].payment.timestamp, tstampB)
def handle(self, *args, **options):
payment_id = options.get('payment_id')
payer_id = options.get('payer_id')
if payment_id is not None or payer_id is not None:
# if filtering, we want verbose
logging.getLogger('').setLevel(logging.DEBUG)
raw_info = self.get_raw_mercadopago_info()
if raw_info is None:
return
records = self.process_mercadopago(raw_info, payment_id, payer_id)
logic.create_recurring_payments(records)
def test_strategy_not_found(self):
# needed objects
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id='foo')
create_member(patron=ps.patron)
# create the payment
records = [
create_payment_record(payer_id='bar'),
]
logic.create_recurring_payments(records)
# check
self.assertEqual(len(Quota.objects.all()), 0)
self.assertLoggedError("PaymentStrategy not found", "bar")
def test_simple_custom_fee(self):
# needed objects
payer_id = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id)
create_member(patron=ps.patron,
first_payment_year=2017,
first_payment_month=5)
# create the payment
custom_fee = DEFAULT_FEE // 2
records = [
create_payment_record(payer_id, amount=custom_fee * 3),
]
logic.create_recurring_payments(records, custom_fee=custom_fee)
# check that payment got through ok, having 3 payments!
self.assertEqual(len(Quota.objects.all()), 3)
def test_sanity_check_multiple_patrons(self):
# create two members for the same patron, something we don't
# support for recurring payments
payer_id = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id)
create_member(patron=ps.patron)
create_member(patron=ps.patron)
# create the payment
records = [
create_payment_record(payer_id),
]
logic.create_recurring_payments(records)
# check
self.assertEqual(len(Quota.objects.all()), 0)
self.assertLoggedError("Found more than one member for Patron",
ps.patron.name)
def test_strategy_not_found(self):
# needed objects
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id='foo')
create_member(patron=ps.patron)
# create the payment
tstamp = make_aware(datetime.datetime(year=2017, month=2, day=5))
records = [
{
'timestamp': tstamp,
'amount': DEFAULT_FEE,
'payer_id': 'bar'
},
]
logic.create_recurring_payments(records)
# check
self.assertEqual(len(Quota.objects.all()), 0)
self.assertLoggedError("PaymentStrategy not found", "bar")
def test_sanity_check_multiple_patrons(self):
# create two members for the same patron, something we don't
# support for recurring payments
payer_id = '*****@*****.**'
ps = create_payment_strategy(platform=PaymentStrategy.MERCADO_PAGO,
payer_id=payer_id)
create_member(patron=ps.patron)
create_member(patron=ps.patron)
# create the payment
tstamp = make_aware(datetime.datetime(year=2017, month=2, day=5))
records = [
{
'timestamp': tstamp,
'amount': DEFAULT_FEE,
'payer_id': payer_id
},
]
logic.create_recurring_payments(records)
# check
self.assertEqual(len(Quota.objects.all()), 0)
self.assertLoggedError("Found more than one member for Patron",
ps.patron.name)
