def setUp(self):
super(WalletBaseTestCase, self).setUp()
# look at:
# nexchange/tests/fixtures/transaction_history.xml self.order_data
# matches first transaction from the XML file
okpay_pref = PaymentPreference.objects.filter(
user__is_staff=True,
payment_method__name__icontains='okpay').first()
payeer_pref = PaymentPreference.objects.filter(
user__is_staff=True,
payment_method__name__icontains='payeer').first()
mock = get_ok_pay_mock()
self.okpay_order_data = {
'amount_quote': Decimal(split_ok_pay_mock(mock, 'Net')),
'amount_base': Decimal(0.1),
'pair': self.BTCEUR,
'user': self.user,
'admin_comment': 'tests Order',
'unique_reference': split_ok_pay_mock(mock, 'Comment'),
'payment_preference': okpay_pref,
}
self.payeer_order_data = deepcopy(self.okpay_order_data)
self.payeer_order_data['payment_preference'] = payeer_pref
self.okpay_order_data_address = deepcopy(self.okpay_order_data)
addr = Address(address='A555B', user=self.user)
addr.save()
self.okpay_order_data_address['withdraw_address'] = addr
self.payeer_order_data_address = deepcopy(
self.okpay_order_data_address)
self.payeer_order_data_address['payment_preference'] = payeer_pref
def setUp(self):
self.professional = Professional.objects.create(
user=User.objects.create_user(
email='*****@*****.**',
password='******',
is_active=True,
cpf="396.852.650-38",
))
self.professional.user.save()
self.professional.save()
self.user = User.objects.create_user(
email='*****@*****.**',
password='******',
is_active=True,
born=(now() - timedelta(days=10000)).date(),
full_name='Nerso da Silva',
cellphone='988883333',
cpf="529.982.247-25",
cellphone_ddd='43',
)
address = Address(
user=self.user,
street='Rua Tal',
street_number='45',
zipcode='45666-333',
state='MG',
city='Notredame',
neighborhood='Gran',
complementary='Fundos',
)
address.save()
self.user.save()
self.proposal = Proposal(client=self.user,
professional=self.professional,
city='Curitiba',
state='PR',
professional_type='AE',
service_type='AC',
start_datetime=TODAY + timedelta(days=1),
end_datetime=TODAY + timedelta(days=3),
value=300.00,
description='Lorem Ipsum dolores')
self.proposal.save()
self.proposal.accept()
self.user.create_customer()
self.user.create_card({
"card_expiration_date": "1122",
"card_number": "4018720572598048",
"card_cvv": "123",
"card_holder_name": "Cersei Lannister"
})
self.professional.create_recipient(
**{
'agency': '0932',
'agency_dv': '5',
'bank_code': '341',
'account': '58054',
'account_dv': '1',
'legal_name': 'HOUSE TARGARYEN'
})
def user_btc_adress(request):
btc_address = request.POST.get('btcAddress')
user = request.user
validate_bc(str(btc_address))
address = Address(address=btc_address, user=user)
address.save()
return JsonResponse({'status': 'OK'})
def test_can_set_as_paid_if_has_withdraw_address_internal(self):
# Creates an withdraw address fro this user
address = Address(user=self.user,
type='W',
address='17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j')
address.save()
payment_method = PaymentMethod(name='Internal Test', is_internal=True)
payment_method.save()
pref = PaymentPreference(payment_method=payment_method,
user=self.order.user,
identifier='InternalTestIdentifier')
pref.save()
payment = Payment(payment_preference=pref,
amount_cash=self.order.amount_cash,
order=self.order,
currency=self.RUB,
user=self.order.user)
payment.save()
# Creates an Transaction for the Order, using the user Address
transaction = Transaction(order=self.order,
address_to=address,
address_from=address)
transaction.save()
# Set Order as Paid
response = self.client.post(self.url, {'paid': 'true'})
expected = {"frozen": True, "paid": True, "status": "OK"}
self.assertJSONEqual(
json.dumps(expected),
str(response.content, encoding='utf8'),
)
def setUp(self):
super(UpdateWithdrawAddressTestCase, self).setUp()
PaymentMethod.objects.all().delete()
method_data = {
'bin': 426101,
'fee': 0.0,
'is_slow': 0,
'name': 'Alpha Bank Visa'
}
payment_method = PaymentMethod(**method_data)
payment_method.save()
pref_data = {
'user': self.user,
'identifier': str(payment_method.bin),
'comment': 'Just testing'
}
pref = PaymentPreference(**pref_data)
pref.save()
pref.currency.add(self.USD)
pref.save()
"""Creates an order"""
data = {
'amount_cash': Decimal(30674.85),
'amount_btc': Decimal(1.00),
'currency': self.USD,
'user': self.user,
'admin_comment': 'test Order',
'unique_reference': '12345',
'payment_preference': pref
}
order = Order(**data)
# TODO: patch and uncomment
# order.full_clean() # ensure is initially correct
order.save()
self.order = order
pk = self.order.pk
self.url = reverse('core.update_withdraw_address', kwargs={'pk': pk})
self.addr_data = {
'type': 'W',
'name': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j',
'address': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j',
}
self.addr = Address(**self.addr_data)
self.addr.user = self.user
self.addr.save()
# The 'other' address for the Transaction
user = User.objects.create_user(username='******')
addr2 = Address(**self.addr_data)
addr2.user = user
addr2.save()
def process_data(request, data):
# Process Employer
try:
employer = Employer.objects.get(name=data[0]['name'])
except (Employer.DoesNotExist):
empl_address = Address(street=data[0]['street'],
city=data[0]['city'],
state=data[0]['state'],
zip_code=data[0]['zip_code'],
address_type=data[0]['address_type'])
empl_address.save()
employer = Employer(name=data[0]['name'],
employer_address=empl_address)
try:
employer.full_clean()
employer.save()
except ValidationError as e:
print(e, 'employer error')
# Process Employee
try:
employee = EmployeeModel.objects.get(empl_ssn=data[1]['empl_ssn'])
except (EmployeeModel.DoesNotExist):
try:
empl_address = Address.objects.get(street=data[1]['street'],
zip_code=data[1]['zip_code'])
except (Address.DoesNotExist):
empl_address = Address(street=data[1]['street'],
city=data[1]['city'],
state=data[1]['state'],
zip_code=data[1]['zip_code'],
address_type=data[1]['address_type'])
empl_address.save()
try:
employee = EmployeeModel(empl_full_name=data[1]['empl_full_name'],
empl_hire_date=data[1]['empl_hire_date'],
empl_dob=data[1]['empl_dob'],
empl_ssn=data[1]['empl_ssn'],
empl_gender=data[1]['empl_gender'],
empl_address=empl_address,
employer=employer,
form_type=data[1]['form_type'])
employee.full_clean()
employee.save()
except ValidationError as e:
print(e, 'employee creation error')
app_model = ApplicationModel(name=employee.form_type,
submit_user=request.user,
employee=employee)
try:
app_model.full_clean()
app_model.save()
except ValidationError as e:
print(e, 'app model error')
return employee
def _create_withdraw_adress(self, currency, address):
addr_data = {
'type': 'W',
'name': address,
'address': address,
'currency': currency
}
addr = Address(**addr_data)
addr.user = self.user
addr.save()
return addr
def update(self, instance, validated_data):
refund_address = validated_data.pop('refund_address')
addr_list = Address.objects.filter(address=refund_address['address'])
if not addr_list:
address = Address(**refund_address)
address.type = Address.WITHDRAW
address.currency = instance.pair.quote
address.save()
else:
address = addr_list[0]
instance.refund_address = address
instance.save()
return instance
def generate_addresses(request, times):
for i in range(0, times):
a = Address()
idx = random.randint(0, 1)
a.address_type = ['B', 'S'][idx]
a.first_name = random_text('t', 15)
a.last_name = random_text('t', 15)
a.address = random_text('t', 50)
a.zipcode = random_text('n', 5)
a.country = random_text('t', 10)
a.city = random_text('t', 10)
a.save()
return HttpResponse(f'{times} Addresses generated !')
def create_withdraw_address(request, order_pk):
error_message = 'Error creating address: %s'
order = Order.objects.get(pk=order_pk)
if not order.user.profile.is_verified and not order.exchange:
pm = order.payment_preference.payment_method
if pm.required_verification_buy or order.user.profile.anonymous_login:
resp = {
'status':
'ERR',
'msg':
'You need to be a verified user to set withdrawal '
'address for order with payment method \'{}\''
''.format(pm.name)
}
return JsonResponse(resp, safe=False)
address = request.POST.get('value')
addr = Address()
addr.type = Address.WITHDRAW
addr.user = request.user
addr.address = address
if order.order_type == Order.BUY:
currency = order.pair.base
else:
currency = order.pair.quote
addr.currency = currency
try:
if currency.code == 'BTC':
validate_btc(addr.address)
elif currency.code == 'LTC':
validate_ltc(addr.address)
elif currency.code == 'ETH':
validate_eth(addr.address)
else:
validate_address(addr.address)
addr.save()
resp = {'status': 'OK', 'pk': addr.pk, 'target': addr.currency.code}
except ValidationError:
resp = {'status': 'ERR', 'msg': 'The supplied address is invalid.'}
except Exception as e:
msg = error_message % (e)
resp = {'status': 'ERR', 'msg': msg}
return JsonResponse(resp, safe=False)
def create(self, validated_data):
for field in READABLE_FIELDS:
validated_data.pop(field, None)
withdraw_address = validated_data.pop('withdraw_address')
payment_id = withdraw_address.pop('payment_id', None)
destination_tag = withdraw_address.pop('destination_tag', None)
validated_data.pop('pair')
# Just making sure
addr_list = Address.objects.filter(address=withdraw_address['address'])
order = Order(pair=self.pair, **validated_data)
if payment_id:
order.payment_id = payment_id
if destination_tag:
order.destination_tag = destination_tag
if not addr_list:
address = Address(**withdraw_address)
address.type = Address.WITHDRAW
address.currency = order.pair.base
address.save()
else:
address = addr_list[0]
order.withdraw_address = address
try:
order.save()
# get post_save stuff in sync
order.refresh_from_db()
self.fields['deposit_address'] = NestedReadOnlyAddressSerializer(
many=False,
read_only=True,
additional_params={
'destination_tag': order.quote_destination_tag,
'payment_id': order.quote_payment_id
})
self.fields['withdraw_address'] = NestedAddressSerializer(
many=False,
read_only=False,
additional_params={
'destination_tag': order.base_destination_tag,
'payment_id': order.base_payment_id
})
return order
except ValidationError as e:
raise RestValidationError({'non_field_errors': [e.message]})
def post(self, *args, **kwargs):
form = CheckoutForm(self.request.POST)
if form.is_valid():
email = form.cleaned_data.get('email')
name = form.cleaned_data.get('name')
phone = form.cleaned_data.get('phone')
if is_valid_form([email, name, phone]):
shipping_address = Address(
email=email,
name=name,
phone=phone,
)
shipping_address.save()
BasketItem.objects.all()
return redirect("core:thank-you")
else:
messages.info(self.request, "All fields are required.")
return redirect("core:checkout")
def test_can_set_as_paid_if_has_withdraw_address(self):
# Creates an withdraw address fro this user
address = Address(user=self.user,
type='W',
address='17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j')
address.save()
# Creates an Transaction for the Order, using the user Address
transaction = Transaction(order=self.order,
address_to=address,
address_from=address)
transaction.save()
# Set Order as Paid
response = self.client.post(self.url, {'paid': 'true'})
expected = {"frozen": None, "paid": True, "status": "OK"}
self.assertJSONEqual(
json.dumps(expected),
str(response.content, encoding='utf8'),
)
def create_user_wallet(self, user, currency):
one_card_currencies = ['XMR', 'XRP']
unassigned_cards = AddressReserve.objects.filter(currency=currency,
user=None,
disabled=False)
if currency.code in one_card_currencies:
unassigned_cards = AddressReserve.objects.filter(currency=currency,
disabled=False)
if len(unassigned_cards) == 0 \
and currency.code not in one_card_currencies:
self.logger.warning('instance {} has no reserve cards available'
' for {} calling renew_cards_reserve()'.format(
user, currency))
self.renew_cards_reserve(
expected_reserve=settings.EMERGENCY_CARDS_RESERVE_COUNT)
unassigned_cards = AddressReserve.objects.filter(currency=currency,
user=None,
disabled=False)
if unassigned_cards:
# FIFO
card = unassigned_cards.earliest('id')
card.user = user
try:
address = Address.objects.get(address=card.address)
except Address.DoesNotExist:
address = Address(address=card.address,
user=card.user,
currency=currency,
type=Address.DEPOSIT,
reserve=card)
address.save()
card.save()
return card, address
else:
self.logger.error(
'instance {} has no cards available'.format(currency))
return None, None
def signupLevel1(request):
activationKey = request.data.get('activationKey')
verifyMobileNumber = request.data.get('verifyMobileNumber')
profile = get_object_or_404(Profile, activationKey=activationKey)
profile.user.set_password(request.data.get('password'))
profile.user.is_active = True
profile.user.save()
profile.dob = request.data.get('dob')
address = Address()
address.country = request.data.get('country')
address.region = request.data.get('region')
address.city = request.data.get('city')
address.street = request.data.get('address')
address.zipCode = request.data.get('zipcode')
address.save()
profile.defaultAddress = address
profile.mobile = request.data.get('mobile')
if request.data.get('ssn') and len(request.data.get('ssn')) > 0:
profile.ssn = request.data.get('ssn')
profile.termsAgreement = request.data.get('agreement')
profile.setVerificationCode()
profile.save()
try:
if verifyMobileNumber:
messageSend = sendVerificationCodeSMS(request,
profile.verificationCode,
profile.mobile)
else:
profile.setActivationKey()
profile.mobileVerified = True
profile.save()
return Response({'success': True})
except Exception as e:
return Response({
'success': False,
'error': {
'code': 'no.sms.sent',
'msg': e.message
}
})
def create_withdraw_address(request):
error_message = 'Error creating address: %s'
address = request.POST.get('value')
addr = Address()
addr.type = Address.WITHDRAW
addr.user = request.user
addr.address = address
try:
validate_bc(addr.address)
addr.save()
resp = {'status': 'OK', 'pk': addr.pk}
except ValidationError:
resp = {'status': 'ERR', 'msg': 'The supplied address is invalid.'}
except Exception as e:
msg = error_message % (e)
resp = {'status': 'ERR', 'msg': msg}
return JsonResponse(resp, safe=False)
def create(self, validated_data):
for field in READABLE_FIELDS:
validated_data.pop(field, None)
withdraw_address = validated_data.pop('withdraw_address')
refund_address = validated_data.pop('refund_address')
validated_data.pop('pair')
withdraw_addr_list = Address.objects.filter(
address=withdraw_address['address'])
order = LimitOrder(pair=self.pair,
order_book=self.order_book,
**validated_data)
if not withdraw_addr_list:
w_address = Address(**withdraw_address)
w_address.type = Address.WITHDRAW
w_address.currency = order.withdraw_currency
w_address.save()
else:
w_address = withdraw_addr_list[0]
order.withdraw_address = w_address
refund_addr_list = Address.objects.filter(
address=refund_address['address'])
if not refund_addr_list:
r_address = Address(**refund_address)
r_address.type = Address.REFUND
r_address.currency = order.refund_currency
r_address.save()
else:
r_address = refund_addr_list[0]
order.refund_address = r_address
try:
order.save()
# get post_save stuff in sync
order.refresh_from_db()
return order
except ValidationError as e:
raise RestValidationError({'non_field_errors': [e.message]})
def basket_create(request):
if request.POST.get("address"):
address = Address.objects.get(id=request.POST.get("address"))
else:
address = Address(user=request.user,
name=request.POST.get("name"),
city=request.POST.get("city"),
street=request.POST.get("street"),
home=request.POST.get("home"),
flat=request.POST.get("flat"))
address.save()
order_ = Order.objects.get(user=request.user, status__base_status__id=1)
order_.address = address
order_.payment_method = PaymentMethod.objects.get(
id=request.POST.get("payment_method"))
status = Status(base_status=BaseStatus.objects.get(id=2),
datetime=datetime.now())
status.save()
order_.status.add(status)
order_.status.remove(order_.status.all()[0])
order_.save()
return HttpResponseRedirect("/profile/")
class RetryReleaseTestCase(TickerBaseTestCase):
def setUp(self):
super(RetryReleaseTestCase, self).setUp()
self.address = Address(
type=Address.WITHDRAW,
address='0x993cE7372Ed0621ddD4593ac3433E678236A496D')
self.address.save()
self.ETH = Currency.objects.get(code='ETH')
self.client = UpholdApiClient()
self._create_order()
self.order.status = Order.PRE_RELEASE
self.order.withdraw_address = self.address
self.order.save()
self.tx_data = {
'currency': self.order.pair.base,
'amount': self.order.amount_base,
'order': self.order,
'address_to': self.order.withdraw_address,
'type': Transaction.WITHDRAW
}
self.retry_release = RetryOrderRelease(api=self.client)
@patch('orders.models.app.send_task')
@patch(UPHOLD_ROOT + 'execute_txn')
@patch(UPHOLD_ROOT + 'prepare_txn')
def test_retry_release_true(self, prepare_txn, execute_txn, send_task):
prepare_txn.return_value = self.generate_txn_id()
execute_txn.return_value = {'code': 'validation_failed'}
self.order.release(self.tx_data, api=self.client)
self.assertEqual(send_task.call_count, 1)
@patch('orders.models.app.send_task')
@patch(UPHOLD_ROOT + 'execute_txn')
@patch(UPHOLD_ROOT + 'prepare_txn')
def test_retry_release_false(self, prepare_txn, execute_txn, send_task):
prepare_txn.return_value = self.generate_txn_id()
execute_txn.return_value = {'code': 'OK'}
self.order.release(self.tx_data, api=self.client)
self.assertEqual(send_task.call_count, 0)
@patch('orders.models.app.send_task')
@patch(UPHOLD_ROOT + 'execute_txn')
@patch(UPHOLD_ROOT + 'prepare_txn')
def test_retry_release_false_no_tx_id(self, prepare_txn, execute_txn,
send_task):
prepare_txn.return_value = ''
execute_txn.return_value = {'code': 'validation_failed'}
self.order.release(self.tx_data, api=self.client)
self.assertEqual(send_task.call_count, 0)
@patch(UPHOLD_ROOT + 'execute_txn')
@patch(UPHOLD_ROOT + 'prepare_txn')
def test_retry_x_times(self, prepare_txn, execute_txn):
prepare_txn.return_value = self.generate_txn_id()
execute_txn.return_value = {'code': 'validation_failed'}
self.order.release(self.tx_data, api=self.client)
txn = self.order.transactions.last()
release_retry_invoke.apply([txn.pk])
self.assertEqual(execute_txn.call_count,
settings.RETRY_RELEASE_MAX_RETRIES + 2)
@data_provider(lambda: (
('Bad type', {
'type': Transaction.DEPOSIT
}, {
'success': False,
'retry': False
}),
('tx_id exists', {
'tx_id': '123sdf'
}, {
'success': False,
'retry': False
}),
('txn flagged', {
'flagged': True
}, {
'success': False,
'retry': False
}),
('txn is_verified', {
'is_verified': True
}, {
'success': False,
'retry': False
}),
('ok', {}, {
'success': True,
'retry': False
}),
))
@patch(UPHOLD_ROOT + 'execute_txn')
@patch(UPHOLD_ROOT + 'prepare_txn')
def test_retry_release_class_errors_tx_data(self, name, tx_data_update,
result, prepare_txn,
execute_txn):
tx_data = {
'type': Transaction.WITHDRAW,
'tx_id': '',
'flagged': False,
'is_verified': False
}
tx_data.update(tx_data_update)
prepare_txn.return_value = self.generate_txn_id()
execute_txn.return_value = {'code': 'validation_failed'}
self.order.release(self.tx_data, api=self.client)
execute_txn.return_value = {'code': 'ok'}
txn = self.order.transactions.last()
for attr, value in tx_data.items():
setattr(txn, attr, value)
txn.save()
res = self.retry_release.run(txn.pk)
self.assertEqual(res, result, name)
@data_provider(lambda: (
('ok', {}, {
'success': True,
'retry': False
}),
('Bad amount', {
'amount_base': 11.111
}, {
'success': False,
'retry': False
}),
('Bad currency', {
'pair_id': 1
}, {
'success': False,
'retry': False
}),
('Bad status', {
'status': Order.COMPLETED
}, {
'success': False,
'retry': False
}),
('Bad address', {
'withdraw_address_id': 1
}, {
'success': False,
'retry': False
}),
))
@patch(UPHOLD_ROOT + 'execute_txn')
@patch(UPHOLD_ROOT + 'prepare_txn')
def test_retry_release_class_errors_order_data(self, name,
order_data_update, result,
prepare_txn, execute_txn):
self._create_order()
self.order.status = Order.PRE_RELEASE
self.order.withdraw_address = self.address
self.order.save()
self.tx_data.update({'order': self.order})
prepare_txn.return_value = self.generate_txn_id()
execute_txn.return_value = {'code': 'validation_failed'}
self.order.release(self.tx_data, api=self.client)
execute_txn.return_value = {'code': 'ok'}
txn = self.order.transactions.last()
for attr, value in order_data_update.items():
setattr(self.order, attr, value)
self.order.save()
res = self.retry_release.run(txn.pk)
self.assertEqual(res, result, name)
@patch(UPHOLD_ROOT + 'execute_txn')
@patch(UPHOLD_ROOT + 'prepare_txn')
def test_retry_release_success(self, prepare_txn, execute_txn):
prepare_txn.return_value = self.generate_txn_id()
execute_txn.return_value = {'code': 'validation_failed'}
self.order.release(self.tx_data, api=self.client)
txn = self.order.transactions.last()
self.assertFalse(txn.is_verified)
self.assertEqual(execute_txn.call_count, 1)
# First retry (success=False)
res = self.retry_release.run(txn.pk)
txn.refresh_from_db()
self.assertEqual(res, {'success': False, 'retry': True})
self.assertFalse(txn.is_verified)
self.assertEqual(execute_txn.call_count, 2)
execute_txn.return_value = {'code': 'ok'}
# Second retry (success=True)
res = self.retry_release.run(txn.pk)
txn.refresh_from_db()
self.assertEqual(res, {'success': True, 'retry': False})
self.assertTrue(txn.is_verified)
self.assertEqual(execute_txn.call_count, 3)
# Third retry (stop because already released)
res = self.retry_release.run(txn.pk)
txn.refresh_from_db()
self.assertEqual(res, {'success': False, 'retry': False})
self.assertTrue(txn.is_verified)
self.assertEqual(execute_txn.call_count, 3)
class UpdateWithdrawAddressTestCase(UserBaseTestCase, OrderBaseTestCase):
def setUp(self):
super(UpdateWithdrawAddressTestCase, self).setUp()
PaymentMethod.objects.all().delete()
method_data = {
'bin': 426101,
'fee': 0.0,
'is_slow': 0,
'name': 'Alpha Bank Visa'
}
payment_method = PaymentMethod(**method_data)
payment_method.save()
pref_data = {
'user': self.user,
'identifier': str(payment_method.bin),
'comment': 'Just testing'
}
pref = PaymentPreference(**pref_data)
pref.save()
pref.currency.add(self.USD)
pref.save()
"""Creates an order"""
data = {
'amount_cash': Decimal(30674.85),
'amount_btc': Decimal(1.00),
'currency': self.USD,
'user': self.user,
'admin_comment': 'test Order',
'unique_reference': '12345',
'payment_preference': pref
}
order = Order(**data)
# TODO: patch and uncomment
# order.full_clean() # ensure is initially correct
order.save()
self.order = order
pk = self.order.pk
self.url = reverse('core.update_withdraw_address', kwargs={'pk': pk})
self.addr_data = {
'type': 'W',
'name': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j',
'address': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j',
}
self.addr = Address(**self.addr_data)
self.addr.user = self.user
self.addr.save()
# The 'other' address for the Transaction
user = User.objects.create_user(username='******')
addr2 = Address(**self.addr_data)
addr2.user = user
addr2.save()
def test_forbiden_to_update_other_users_orders(self):
username = '******'
password = '******'
User.objects.create_user(username=username, password=password)
client = self.client
client.login(username=username, password=password)
response = client.post(self.url, {
'pk': self.order.pk,
'value': self.addr.pk
})
self.assertEqual(403, response.status_code)
self.client.login(username=self.user.username, password='******')
def test_sucess_to_update_withdraw_adrress(self):
response = self.client.post(self.url, {
'pk': self.order.pk,
'value': self.addr.pk,
})
self.assertJSONEqual(
'{"status": "OK"}',
str(response.content, encoding='utf8'),
)
self.assertEqual(self.order.withdraw_address, self.addr.address)
def test_throw_error_for_invalid_withdraw_adrress(self):
response = self.client.post(self.url, {
'pk': self.order.pk,
'value': 50
})
self.assertEqual(b'Invalid addresses informed.', response.content)
class PaymentReleaseTestCase(UserBaseTestCase, OrderBaseTestCase):
def setUp(self):
super(PaymentReleaseTestCase, self).setUp()
self.method_data = {"is_internal": 1, 'name': 'Robokassa'}
amount_cash = Decimal(30000.00)
self.payment_method = PaymentMethod(name='ROBO')
self.payment_method.save()
self.addr_data = {
'type': 'W',
'name': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j',
'address': '17NdbrSGoUotzeGCcMMCqnFkEvLymoou9j',
}
self.addr = Address(**self.addr_data)
self.addr.user = self.user
self.addr.save()
pref_data = {
'user': self.user,
'comment': 'Just testing',
'payment_method': self.payment_method
}
pref = PaymentPreference(**pref_data)
pref.save('internal')
self.data = {
'amount_cash': amount_cash,
'amount_btc': Decimal(1.00),
'currency': self.RUB,
'user': self.user,
'admin_comment': 'test Order',
'unique_reference': '12345',
'payment_preference': pref,
'is_paid': True
}
self.order = Order(**self.data)
self.order.save()
self.pay_data = {
'amount_cash': self.order.amount_cash,
'currency': self.RUB,
'user': self.user,
'payment_preference': pref,
}
self.payment = Payment(**self.pay_data)
self.payment.save()
tx_id_ = '76aa6bdc27e0bb718806c93db66525436' \
'fa621766b52bad831942dee8b618678'
self.transaction = Transaction(tx_id=tx_id_,
order=self.order,
address_to=self.addr)
self.transaction.save()
def test_bad_release_payment(self):
for o in Order.objects.filter(is_paid=True, is_released=False):
p = Payment.objects.filter(user=o.user,
amount_cash=o.amount_cash,
payment_preference=o.payment_preference,
is_complete=False,
currency=o.currency).first()
if p is not None:
tx_id_ = release_payment(o.withdraw_address, o.amount_btc)
self.assertEqual(tx_id_, None)
def test_orders_with_approved_payments(self):
for o in Order.objects.filter(is_paid=True, is_released=False):
p = Payment.objects.filter(user=o.user,
amount_cash=o.amount_cash,
payment_preference=o.payment_preference,
is_complete=False,
currency=o.currency).first()
if p is not None:
o.is_released = True
o.save()
p.is_complete = True
p.save()
self.assertTrue(o.is_released)
self.assertTrue(p.is_complete)
def checker_transactions(self):
if check_transaction(self.transaction.tx_id):
self.transaction.is_completed = True
self.transaction.save()
self.assertTrue(self.transaction.is_completed)
def post(self, request, *args, **kwargs):
if not request.user.id == self.kwargs.get('pk'):
raise Http404
if 'profile_edit' in request.POST and request.method == 'POST':
instance = get_object_or_404(Profile, user=request.user)
form = ProfileForm(self.request.POST or None, instance=instance)
if form.is_valid():
print("sanity check")
form.save(commit=False)
form.email = request.user.email
form.save()
elif 'address_edit' in request.POST and request.method == 'POST':
form = AddressForm(self.request.POST or None)
if form.is_valid():
address_form_form = form.cleaned_data.get('street_address')
apartment_address = form.cleaned_data.get('apartment_address')
country = form.cleaned_data.get('country')
city = form.cleaned_data.get('city')
zip = form.cleaned_data.get('zip')
try:
address = Address.objects.get(user=request.user,
default=True)
address.user = self.request.user
address.street_address = address_form_form
address.apartment_address = apartment_address
address.country = country
address.city = city
address.zip = zip
address.save()
except ObjectDoesNotExist:
address = Address(user=self.request.user,
street_address=address_form_form,
apartment_address=apartment_address,
country=country,
city=city,
zip=zip,
default=True)
address.save()
else:
messages.warning(self.request,
"Please fill in the required fields")
elif 'socialMedia_edit' in request.POST and request.method == 'POST':
instance, created = SocialMedia.objects.get_or_create(
user=request.user)
if created:
form = SocialMediaForm(self.request.POST, instance=created)
if form.is_valid():
form.save()
else:
form = SocialMediaForm(self.request.POST, instance=instance)
if form.is_valid():
form.save()
else:
form = ProfileImageForm(request.POST, request.FILES)
if form.is_valid():
try:
picture = ProfileImage.objects.get(user=request.user)
picture.file.delete()
picture.delete()
form.instance.user = request.user
form.save()
messages.info(
request,
"If photo doesnt change, please reload the page")
except ObjectDoesNotExist:
form.instance.user = request.user
form.save()
messages.info(
request,
"If photo doesnt change, please reload the page")
return redirect('profile', kwargs['pk'])
def test_has_a_withdraw_address(self):
address = Address(user=self.user, type=Address.WITHDRAW)
address.save()
self.user.refresh_from_db()
self.assertTrue(self.user.profile.has_withdraw_address)
def _create_address(self, address_data):
address = Address(**address_data)
address.full_clean()
address.save()
return address
class BaseOrderReleaseTestCase(OrderBaseTestCase):
def generate_orm_obj(self, _constructor, base_data, modifiers=None):
objs = []
for modifier in modifiers:
actual_data = deepcopy(base_data)
actual_data.update(modifier)
_obj = _constructor(**actual_data)
_obj.save()
_obj.refresh_from_db()
objs.append(_obj)
return objs
def purge_orm_objects(self, *args):
for objs in args:
while len(objs):
obj = objs.pop()
obj.delete()
def edit_orm_obj(self, object, modifiers):
for modifier, value in modifiers.items():
setattr(object, modifier, value)
object.save()
object.refresh_from_db()
return object
def setUp(self):
super(BaseOrderReleaseTestCase, self).setUp()
enable_all_pairs()
currencies = Currency.objects.filter(is_crypto=False)
for curr in currencies:
curr.maximal_amount = 50000000
curr.minimal_amount = 0.1
curr.save()
self.payments = []
self.orders = []
self.addr = Address(address='12345', user=self.user)
self.addr.save()
self.our_pref = PaymentPreference.objects.first()
self.order_data = {
'amount_quote': Decimal(30674.85),
'amount_base': Decimal(1.00),
'user': self.user,
'admin_comment': 'tests Order',
'unique_reference': '123456',
'payment_preference': self.our_pref,
'withdraw_address': self.addr,
'pair': self.BTCRUB,
}
self.pref, created = PaymentPreference.objects.get_or_create(
payment_method=self.our_pref.payment_method,
user=self.user,
identifier='1234567',
)
self.pref.currency.add(self.BTCRUB.quote)
self.pref.save()
self.base_payment_data = {
'user': self.user,
'currency': self.BTCRUB.quote,
'payment_preference': self.pref,
'amount_cash': self.order_data['amount_quote'],
'is_success': True
}
def tearDown(self):
with transaction.atomic(using='default'):
self.purge_orm_objects(self.orders, self.payments)
class TransactionImportBaseTestCase(OrderBaseTestCase):
fixtures = [
'market.json',
'currency_algorithm.json',
'transaction_price.json',
'currency_crypto.json',
'currency_fiat.json',
'currency_tokens.json',
'pairs_cross.json',
'pairs_btc.json',
'pairs_ltc.json',
'pairs_rns.json',
'pairs_eth.json',
'pairs_doge.json',
'pairs_bch.json',
'pairs_xvg.json',
'pairs_nano.json',
'pairs_omg.json',
'pairs_bdg.json',
'pairs_eos.json',
'pairs_zec.json',
'pairs_usdt.json',
'pairs_xmr.json',
'pairs_kcs.json',
'pairs_bnb.json',
'pairs_knc.json',
'pairs_bix.json',
'pairs_ht.json',
'pairs_bnt.json',
'pairs_coss.json',
'pairs_cob.json',
'pairs_dash.json',
'pairs_bmh.json',
'pairs_xrp.json',
'payment_method.json',
'payment_preference.json',
'reserve.json',
'account.json',
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.uphold_import_transactions_empty = None
def setUp(self):
super(TransactionImportBaseTestCase, self).setUp()
self.main_pref = self.okpay_pref = PaymentPreference.objects.get(
user__is_staff=True, payment_method__name__icontains='okpay')
self.payeer_pref = PaymentPreference.objects.filter(
user__is_staff=True,
payment_method__name__icontains='payeer').first()
self.order = Order(order_type=Order.SELL,
amount_base=0.2,
pair=self.BTCEUR,
user=self.user,
status=Order.INITIAL,
payment_preference=self.main_pref)
with requests_mock.mock() as mock:
self._mock_cards_reserve(mock)
self.order.save()
self.order_modifiers = [{
'confirmations':
self.order.pair.base.min_confirmations
}, {
'confirmations':
self.order.pair.base.min_confirmations - 1
}]
self._read_fixture()
self.order.amount_base = \
Decimal(str(self.amounts[self.status_ok_list_index]))
self.order.save()
self.address = Address(
name='test address',
address=self.wallet_address,
currency=self.BTC,
user=self.user,
type=Address.DEPOSIT,
)
self.address.save()
xmr_card = AddressReserve(
currency=Currency.objects.get(code='XMR'),
address='41pLNkSGSJK8pWAG9dd57YcWB82gH5ucHNEPnGt1FBN59P'
'rdYqKUGB1SfZxGQPcYcDEbctmpN2kpVbtuie6yCRf16oXkjuY',
)
xmr_card.save()
xrp_card = AddressReserve(currency=Currency.objects.get(code='XRP'),
address='rnErCcvuHdxfUEcU81NtujYv36mQ4BaSP2')
xrp_card.save()
self.url_addr = 'http://btc.blockr.io/api/v1/address/txs/{}'.format(
self.wallet_address)
self.url_tx_1 = 'http://btc.blockr.io/api/v1/tx/info/{}'.format(
self.tx_ids[0])
self.url_tx_2 = 'http://btc.blockr.io/api/v1/tx/info/{}'.format(
self.tx_ids[1])
self.LTC = Currency.objects.get(code='LTC')
self.ETH = Currency.objects.get(code='ETH')
self.RNS = Currency.objects.get(code='RNS')
self.DOGE = Currency.objects.get(code='DOGE')
self.BCH = Currency.objects.get(code='BCH')
self.ZEC = Currency.objects.get(code='ZEC')
self.USDT = Currency.objects.get(code='USDT')
self.XMR = Currency.objects.get(code='XMR')
self.DASH = Currency.objects.get(code='DASH')
self.XRP = Currency.objects.get(code='XRP')
self.XVG = Currency.objects.get(code='XVG')
self.BTC_address = self._create_withdraw_adress(
self.BTC, '1GR9k1GCxJnL3B5yryW8Kvz7JGf31n8AGi')
self.LTC_address = self._create_withdraw_adress(
self.LTC, 'LYUoUn9ATCxvkbtHseBJyVZMkLonx7agXA')
self.ETH_address = self._create_withdraw_adress(
self.ETH, '0x8116546AaC209EB58c5B531011ec42DD28EdFb71')
self.RNS_address = self._create_withdraw_adress(
self.RNS, 'RJrEPzpgwfhsyz2tKYxVYSAEfBNWXh8W2v')
self.DOGE_address = self._create_withdraw_adress(
self.DOGE, 'DPjMRpkNKEfnYVHqmAan4FbriqP4DyUt2u')
self.BCH_address = self._create_withdraw_adress(
self.BCH, '142banESr9veN2RkFg6k67AjDdCepdmVLm')
self.ZEC_address = self._create_withdraw_adress(
self.ZEC, 't1a7HFeidzBswwdXaFV1gKtSphn41rLcEmK')
self.USDT_address = self._create_withdraw_adress(
self.USDT, '1AzrxFRwxGmXPeSum9Bsisv7XxhSAeANwH')
self.XMR_address = self._create_withdraw_adress(
self.XMR, '41pLNkSGSJK8pWAG9dd57YcWB82gH5ucHNEPnGt1FBN59P'
'rdYqKUGB1SfZxGQPcYcDEbctmpN2kpVbtupm6yCRf16oXkjuY')
self.DASH_address = self._create_withdraw_adress(
self.DASH, 'XgJdGA5NWn71TmFYxVPvpZxUKAe8x7YWrP')
self.XRP_address = self._create_withdraw_adress(
self.XRP, 'r9y61YwVUQtTWHtwcmYc1Epa5KvstfUzSm')
self.XVG_address = self._create_withdraw_adress(
self.XVG, 'DQkwDpRYUyNNnoEZDf5Cb3QVazh4FuPRs9')
def _read_fixture(self):
path_addr_fixture = os.path.join(
settings.BASE_DIR, 'nexchange/tests/fixtures/'
'blockr/address_transactions.json')
path_tx1_fixture = os.path.join(
settings.BASE_DIR, 'nexchange/tests/fixtures/'
'blockr/address_tx_1.json')
path_tx2_fixture = os.path.join(
settings.BASE_DIR, 'nexchange/tests/fixtures/'
'blockr/address_tx_2.json')
uphold_get_details_fixture = os.path.join(
settings.BASE_DIR,
'nexchange/tests/fixtures/uphold/get_card_details.json')
uphold_commit_tx_fixture = os.path.join(
settings.BASE_DIR,
'nexchange/tests/fixtures/uphold/commit_transaction.json')
uphold_reverse_completed_fixture = os.path.join(
settings.BASE_DIR,
'nexchange/tests/fixtures/uphold/transaction_completed.json')
uphold_reverse_pending_fixture = os.path.join(
settings.BASE_DIR,
'nexchange/tests/fixtures/uphold/transaction_pending.json')
uphold_import_transactions_empty = os.path.join(
settings.BASE_DIR,
'nexchange/tests/fixtures/uphold/import_transactions_empty.json')
with open(path_addr_fixture) as f:
self.blockr_response_addr =\
f.read().replace('\n', '').replace(' ', '')
self.wallet_address = json.loads(
self.blockr_response_addr)['data']['address']
txs = json.loads(self.blockr_response_addr)['data']['txs']
self.amounts = [tx['amount'] for tx in txs]
self.tx_ids = [tx['tx'] for tx in txs]
with open(path_tx1_fixture) as f:
self.blockr_response_tx1 =\
f.read().replace('\n', '').replace(' ', '')
self.blockr_response_tx1_parsed = json.loads(
self.blockr_response_tx1)
with open(path_tx2_fixture) as f:
self.blockr_response_tx2 =\
f.read().replace('\n', '').replace(' ', '')
self.blockr_response_tx2_parsed = json.loads(
self.blockr_response_tx2)
with open(uphold_get_details_fixture) as f:
self.uphold_get_card = \
f.read().replace('\n', '').replace(' ', '')
self.uphold_tx_id = json.loads(self.uphold_get_card)['id']
with open(uphold_commit_tx_fixture) as f:
self.uphold_commit_tx = \
f.read().replace('\n', '').replace(' ', '')
with open(uphold_reverse_completed_fixture) as f:
self.uphold_tx_completed = \
f.read().replace('\n', '').replace(' ', '')
with open(uphold_reverse_pending_fixture) as f:
self.uphold_tx_pending = \
f.read().replace('\n', '').replace(' ', '')
with open(uphold_import_transactions_empty) as f:
self.uphold_import_transactions_empty = \
f.read().replace('\n', '').replace(' ', '')
self.txs = [
self.blockr_response_tx1_parsed, self.blockr_response_tx2_parsed
]
self.tx_texts = [self.blockr_response_tx1, self.blockr_response_tx2]
self.status_ok_list_index = 0
self.status_bad_list_index = 1
def _create_price_for_pair(self, pair):
ticker = Ticker(pair=pair,
ask=OrderBaseTestCase.PRICE_BUY_EUR,
bid=OrderBaseTestCase.PRICE_SELL_EUR)
ticker.save()
price = Price(pair=pair, ticker=ticker)
price.save()
return price
@patch(UPHOLD_ROOT + 'get_transactions')
@patch(UPHOLD_ROOT + 'get_reserve_transaction')
def base_test_create_transactions_with_task(self, run_method, reserve_txs,
import_txs):
pair_name = 'BTCLTC'
pair = Pair.objects.get(name=pair_name)
self._create_price_for_pair(pair)
order = Order.objects.filter(pair__name=pair_name).first()
self._create_mocks_uphold(amount2=order.amount_quote, order=order)
reserve_txs.return_value = json.loads(self.completed)
import_txs.return_value = json.loads(self.import_txs)
run_method()
tx_ok = Transaction.objects.filter(
tx_id_api=json.loads(self.import_txs)[1]['id'])
self.assertEqual(len(tx_ok), 1,
'Transaction must be created if order is found!')
order.refresh_from_db()
self.assertEquals(order.status, Order.PAID_UNCONFIRMED,
'Order should be marked as paid after pipeline')
tx_bad = Transaction.objects.filter(
tx_id_api=json.loads(self.import_txs)[0]['id'])
self.assertEqual(
len(tx_bad), 0,
'Transaction must not be created if order is not found!')
run_method()
tx_ok = Transaction.objects.filter(
tx_id_api=json.loads(self.import_txs)[1]['id'])
self.assertEqual(len(tx_ok), 1,
'Transaction must be created only one time!')
def _update_withdraw_address(self, order, address):
order.refresh_from_db()
order.withdraw_address = address
order.save()
def _create_withdraw_adress(self, currency, address):
addr_data = {
'type': 'W',
'name': address,
'address': address,
'currency': currency
}
addr = Address(**addr_data)
addr.user = self.user
addr.save()
return addr
def _create_mocks_uphold(self,
amount2=Decimal('0.0'),
currency1=None,
currency2=None,
card_id=None,
order=None):
order = self.order if not order else order
if len(self.order.user.addressreserve_set.all()) == 0:
with requests_mock.mock() as mock:
self._mock_cards_reserve(mock)
self._create_an_order_for_every_crypto_currency_card(self.user)
if order is not None:
self.order = order
self.tx_ids_api = ['12345', '54321']
if not currency1:
currency1 = self.order.pair.base.code
if not currency2:
currency2 = self.order.pair.quote.code
if card_id is None and self.order.pair.quote.is_crypto:
card_id = self.order.deposit_address.reserve.card_id
else:
card_id = time()
self.import_txs = self.uphold_import_transactions_empty.format(
tx_id_api1=self.tx_ids_api[0],
tx_id_api2=self.tx_ids_api[1],
amount1=self.order.amount_base,
amount2=amount2,
currency1=currency1,
currency2=currency2,
card_id=card_id,
)
reserve_url = 'https://api.uphold.com/v0/reserve/transactions/{}'
self.reverse_url1 = reserve_url.format(self.tx_ids_api[0])
self.reverse_url2 = reserve_url.format(self.tx_ids_api[1])
self.completed = '{"status": "completed", "type": "deposit",' \
'"params": {"progress": 999}}'
self.pending = '{"status": "pending", "type": "deposit"}'
def post(self, *args, **kwargs):
form = CheckoutForm(self.request.POST or None)
try:
order = Order.objects.get(user=self.request.user, ordered=False)
if form.is_valid():
use_default_shipping = form.cleaned_data.get(
'use_default_shipping')
if use_default_shipping:
print("Using the defualt shipping address")
address_qs = Address.objects.filter(user=self.request.user,
address_type='S',
default=True)
if address_qs.exists():
shipping_address = address_qs[0]
order.shipping_address = shipping_address
order.save()
else:
messages.info(self.request,
"No default shipping address available")
return redirect('core:checkout')
else:
print("User is entering a new shipping address")
shipping_address1 = form.cleaned_data.get(
'shipping_address')
shipping_address2 = form.cleaned_data.get(
'shipping_address2')
shipping_country = form.cleaned_data.get(
'shipping_country')
shipping_zip = form.cleaned_data.get('shipping_zip')
if is_valid_form(
[shipping_address1, shipping_country, shipping_zip]):
shipping_address = Address(
user=self.request.user,
street_address=shipping_address1,
apartment_address=shipping_address2,
country=shipping_country,
zip=shipping_zip,
address_type='S')
shipping_address.save()
order.shipping_address = shipping_address
order.save()
set_default_shipping = form.cleaned_data.get(
'set_default_shipping')
if set_default_shipping:
shipping_address.default = True
shipping_address.save()
else:
messages.info(
self.request,
"Please fill in the required shipping address fields"
)
use_default_billing = form.cleaned_data.get(
'use_default_billing')
same_billing_address = form.cleaned_data.get(
'same_billing_address')
if same_billing_address:
billing_address = shipping_address
billing_address.pk = None
billing_address.save()
billing_address.address_type = 'B'
billing_address.save()
order.billing_address = billing_address
order.save()
elif use_default_billing:
print("Using the defualt billing address")
address_qs = Address.objects.filter(user=self.request.user,
address_type='B',
default=True)
if address_qs.exists():
billing_address = address_qs[0]
order.billing_address = billing_address
order.save()
else:
messages.info(self.request,
"No default billing address available")
return redirect('core:checkout')
else:
print("User is entering a new billing address")
billing_address1 = form.cleaned_data.get('billing_address')
billing_address2 = form.cleaned_data.get(
'billing_address2')
billing_country = form.cleaned_data.get('billing_country')
billing_zip = form.cleaned_data.get('billing_zip')
if is_valid_form(
[billing_address1, billing_country, billing_zip]):
billing_address = Address(
user=self.request.user,
street_address=billing_address1,
apartment_address=billing_address2,
country=billing_country,
zip=billing_zip,
address_type='B')
billing_address.save()
order.billing_address = billing_address
order.save()
set_default_billing = form.cleaned_data.get(
'set_default_billing')
if set_default_billing:
billing_address.default = True
billing_address.save()
else:
messages.info(
self.request,
"Please fill in the required billing address fields"
)
payment_option = form.cleaned_data.get('payment_option')
if payment_option == 'S':
return redirect('core:payment', payment_option='stripe')
elif payment_option == 'P':
return redirect('core:payment', payment_option='paypal')
else:
messages.warning(self.request,
"Invalid payment option selected")
return redirect('core:checkout')
except ObjectDoesNotExist:
messages.warning(self.request, "You do not have an active order")
return redirect("core:order-summary")
def create_addresss(self, address, currency=None):
address = Address(address=address, currency=currency)
address.save()
return address
