class ProfileTests(APITestCase):
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
def test_profile(self):
url = reverse('user:profile')
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_update_profile(self):
url = reverse('user:profile')
updated_name = 'FirstName'
response = self.client.patch(url, {
'phone_number': '1234567890',
'first_name': 'FirstName',
},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
user = User.objects.get(username=self.user.user.username)
self.assertEqual(user.first_name, updated_name)
class ContactTests(APITestCase):
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
def test_add_contact(self):
url = reverse('user:contact-list')
response = self.client.post(url,
data={
'name': 'Contact',
'email': '*****@*****.**',
'phone_number': '1234567890',
'description': 'Some description',
},
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_update_contact(self):
contact = ContactFactory(user=self.user)
url = reverse('user:contact-detail', kwargs={'pk': contact.id})
response = self.client.put(url,
data={
'name': 'Contact',
'email': '*****@*****.**',
'phone_number': '1234567890',
'description': 'Some description',
},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
class CryptoTests(APITestCase):
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
self.test_address = 'AGeneratedCryptoAddress'
AddressManagement.generate_address = MagicMock(
return_value=self.test_address)
def test_get_existing_address(self):
obj = TrackingAddressFactory(user=self.user,
currency=CURRENCY.ETH,
status=TRACKING_ADDRESS_STATUS.created)
url = reverse('exchange:address-list')
response = self.client.post(url + '?currency={}'.format(CURRENCY.ETH),
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.json(), obj.address)
def test_create_address(self):
url = reverse('exchange:address-list')
response = self.client.post(url + '?currency={}'.format(CURRENCY.ETH),
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.json(), self.test_address)
def setUp(self):
PriceManagement.get_cache_price = MagicMock(return_value=CryptoPrice(
CURRENCY.ETH,
Decimal('100'),
Decimal('100'),
))
RateManagement.get_cache_rate = MagicMock(
return_value=Decimal('23000'))
FeeFactory(key=FEE_COIN_ORDER_BANK,
value=Decimal('1'),
fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_ORDER_COD,
value=Decimal('10'),
fee_type=FEE_TYPE.percentage)
PoolFactory(currency=CURRENCY.ETH,
direction=DIRECTION.buy,
usage=1,
limit=2)
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
UserLimitFactory(fiat_currency=self.user.currency,
direction=DIRECTION_ALL,
usage=0,
limit=3000000,
user=self.user)
class ListOrderTests(APITestCase):
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
OrderFactory.create_batch(10, user=self.user)
def test_list(self):
url = reverse('exchange:order-list')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()['results']), 10)
def test_filter_1(self):
url = reverse('exchange:order-list')
response = self.client.get(url,
data={'direction': DIRECTION.buy},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()['results']), 5)
def test_filter_2(self):
url = reverse('exchange:order-list')
response = self.client.get(url,
data={'order_type': ORDER_TYPE.bank},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()['results']), 5)
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
self.order = OrderFactory(user=self.user,
order_type=ORDER_TYPE.bank,
status=ORDER_STATUS.pending)
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
self.test_address = 'AGeneratedCryptoAddress'
AddressManagement.generate_address = MagicMock(
return_value=self.test_address)
class OrderUpdateTest(APITestCase):
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
self.order = OrderFactory(user=self.user,
order_type=ORDER_TYPE.bank,
status=ORDER_STATUS.pending)
def test_update_receipt(self):
order = Order.objects.get(pk=self.order.pk)
test_receipt = 'SomeReceipt'
self.assertEqual(order.receipt_url, None)
url = reverse('exchange:order-receipt', args=[
self.order.pk,
])
response = self.client.put(url,
data={
'receipt_url': test_receipt,
},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
order = Order.objects.get(pk=self.order.pk)
self.assertEqual(order.receipt_url, test_receipt)
def test_update_receipt_wrong_status(self):
order_test = OrderFactory(user=self.user,
order_type=ORDER_TYPE.bank,
status=ORDER_STATUS.processing)
test_receipt = 'SomeReceipt'
url = reverse('exchange:order-receipt', args=[
order_test.pk,
])
response = self.client.put(url,
data={
'receipt_url': test_receipt,
},
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_update_receipt_wrong_type(self):
order_test = OrderFactory(user=self.user,
order_type=ORDER_TYPE.cod,
status=ORDER_STATUS.processing)
test_receipt = 'SomeReceipt'
url = reverse('exchange:order-receipt', args=[
order_test.pk,
])
response = self.client.put(url,
data={
'receipt_url': test_receipt,
},
format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
class ExchangeUserLogTests(APITestCase):
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
def test_add_contact(self):
url = reverse('user:exchangeuserlog-list')
response = self.client.post(url, data={
'name': 'Log',
}, format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
class AddSellingOrderTest(APITestCase):
def setUp(self):
PriceManagement.get_cache_price = MagicMock(return_value=CryptoPrice(
CURRENCY.ETH,
Decimal('100'),
Decimal('100'),
))
RateManagement.get_cache_rate = MagicMock(
return_value=Decimal('23000'))
FeeFactory(key=FEE_COIN_SELLING_ORDER_BANK,
value=Decimal('1'),
fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_SELLING_ORDER_COD,
value=Decimal('1'),
fee_type=FEE_TYPE.percentage)
PoolFactory(currency=CURRENCY.ETH,
direction=DIRECTION.sell,
usage=1,
limit=2)
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
UserLimitFactory(fiat_currency=FIAT_CURRENCY.PHP,
direction=DIRECTION_ALL,
usage=0,
limit=3000000,
user=self.user)
def test_add_order(self):
url = reverse('exchange:order-list')
response = self.client.post(
url,
data={
'amount': '1',
'currency': CURRENCY.ETH,
'fiat_local_amount': '2323000',
'fiat_local_currency': FIAT_CURRENCY.PHP,
'direction': DIRECTION.sell,
'order_type': ORDER_TYPE.bank,
'address': '0x6d86cf435978cb75aecc43d0a4e3a379af7667d8',
},
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
class ReviewTests(APITestCase):
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.auth_utils.create_exchange_user()
ReviewFactory.create_batch(10)
def test_list(self):
url = reverse('exchange:review-list')
response = self.client.get(url, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()['results']), 10)
def test_filter(self):
url = reverse('exchange:review-list')
response = self.client.get(url,
data={'country': COUNTRY.PH},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()['results']), 5)
def test_filter_2(self):
url = reverse('exchange:review-list')
response = self.client.get(url,
data={'direction': DIRECTION.buy},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.json()['results']), 5)
def test_add(self):
self.auth_utils.login()
order = OrderFactory()
url = reverse('exchange:review-list')
response = self.client.post(url,
data={
'direction': DIRECTION.buy,
'review': 'Some review',
'order': order.pk,
},
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_sign_up_referral(self):
url = reverse('user:sign-up')
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
response = self.client.post(url,
data={
'username': '******',
'password': '******',
'name': 'Username',
'country': COUNTRY.PH,
'referral': self.user.name
},
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
PriceManagement.get_cache_price = MagicMock(return_value=CryptoPrice(
CURRENCY.ETH,
Decimal('100'),
Decimal('100'),
))
RateManagement.get_cache_rate = MagicMock(return_value=Decimal('23000'))
FeeFactory(key=FEE_COIN_SELLING_ORDER_BANK, value=Decimal('1'), fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_SELLING_ORDER_COD, value=Decimal('1'), fee_type=FEE_TYPE.percentage)
PoolFactory(currency=CURRENCY.ETH, direction=DIRECTION.sell, usage=1, limit=2)
user = self.auth_utils.create_user()
exchange_user = ExchangeUserFactory(user=user, currency=FIAT_CURRENCY.PHP)
UserLimitFactory(fiat_currency=FIAT_CURRENCY.PHP, direction=DIRECTION_ALL, usage=2300000, limit=3000000,
user=exchange_user)
def setUp(self):
self.buy_rate = self.sell_rate = Decimal('100')
self.fiat_rate = Decimal('1')
PriceManagement.get_cache_price = MagicMock(return_value=CryptoPrice(
CURRENCY.ETH,
self.buy_rate,
self.sell_rate,
))
RateManagement.get_cache_rate = MagicMock(return_value=self.fiat_rate)
FeeFactory(key=FEE_COIN_ORDER_BANK,
value=Decimal('0'),
fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_ORDER_COD,
value=Decimal('0'),
fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_SELLING_ORDER_BANK,
value=Decimal('0'),
fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_SELLING_ORDER_COD,
value=Decimal('0'),
fee_type=FEE_TYPE.percentage)
PoolFactory(currency=CURRENCY.ETH,
direction=DIRECTION.buy,
usage=0,
limit=100)
PoolFactory(currency=CURRENCY.ETH,
direction=DIRECTION.sell,
usage=0,
limit=100)
self.auth_utils = AuthenticationUtils(self.client)
self.referral = self.auth_utils.create_exchange_user('referral_user')
self.user = self.auth_utils.create_exchange_user(None, self.referral)
self.auth_utils.login()
UserLimitFactory(fiat_currency=self.user.currency,
direction=DIRECTION_ALL,
usage=0,
limit=5000,
user=self.user)
class SignUpTests(APITestCase):
def setUp(self):
CountryDefaultConfigFactory(country=COUNTRY.PH,
currency=FIAT_CURRENCY.PHP,
language=LANGUAGE.en)
VerifyEmailView.send_verification_email = MagicMock(return_value=None)
def test_sign_up(self):
url = reverse('user:sign-up')
response = self.client.post(url,
data={
'username': '******',
'password': '******',
'name': 'Username',
'country': COUNTRY.PH,
'referral': ''
},
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_sign_up_referral(self):
url = reverse('user:sign-up')
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
response = self.client.post(url,
data={
'username': '******',
'password': '******',
'name': 'Username',
'country': COUNTRY.PH,
'referral': self.user.name
},
format='json')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.auth_utils.create_exchange_user()
ReviewFactory.create_batch(10)
class ReferralTest(APITestCase):
def setUp(self):
self.buy_rate = self.sell_rate = Decimal('100')
self.fiat_rate = Decimal('1')
PriceManagement.get_cache_price = MagicMock(return_value=CryptoPrice(
CURRENCY.ETH,
self.buy_rate,
self.sell_rate,
))
RateManagement.get_cache_rate = MagicMock(return_value=self.fiat_rate)
FeeFactory(key=FEE_COIN_ORDER_BANK,
value=Decimal('0'),
fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_ORDER_COD,
value=Decimal('0'),
fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_SELLING_ORDER_BANK,
value=Decimal('0'),
fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_SELLING_ORDER_COD,
value=Decimal('0'),
fee_type=FEE_TYPE.percentage)
PoolFactory(currency=CURRENCY.ETH,
direction=DIRECTION.buy,
usage=0,
limit=100)
PoolFactory(currency=CURRENCY.ETH,
direction=DIRECTION.sell,
usage=0,
limit=100)
self.auth_utils = AuthenticationUtils(self.client)
self.referral = self.auth_utils.create_exchange_user('referral_user')
self.user = self.auth_utils.create_exchange_user(None, self.referral)
self.auth_utils.login()
UserLimitFactory(fiat_currency=self.user.currency,
direction=DIRECTION_ALL,
usage=0,
limit=5000,
user=self.user)
def _make_buy_order(self, amount: Decimal):
url = reverse('exchange:order-list')
response = self.client.post(
url,
data={
'amount': amount,
'currency': CURRENCY.ETH,
'fiat_local_amount': amount * self.buy_rate * self.fiat_rate,
'fiat_local_currency': FIAT_CURRENCY.PHP,
'order_type': ORDER_TYPE.cod,
'direction': DIRECTION.buy,
'address': '0x6d86cf435978cb75aecc43d0a4e3a379af7667d8',
},
format='json')
data = response.json()
return data['id']
def _make_sell_order(self, amount: Decimal):
url = reverse('exchange:order-list')
response = self.client.post(
url,
data={
'amount': amount,
'currency': CURRENCY.ETH,
'fiat_local_amount': amount * self.buy_rate * self.fiat_rate,
'fiat_local_currency': FIAT_CURRENCY.PHP,
'direction': DIRECTION.sell,
'order_type': ORDER_TYPE.bank,
'address': '0x6d86cf435978cb75aecc43d0a4e3a379af7667d8',
},
format='json')
data = response.json()
return data['id']
def test_add_referral_for_buying(self):
PromotionRuleFactory()
order_id = self._make_buy_order(Decimal('10'))
order = Order.objects.get(id=order_id)
order.status = ORDER_STATUS.success
order.save(update_fields=[
'status',
])
ref1 = ReferralOrder.objects.filter(order=order,
user=self.referral).first()
ref2 = ReferralOrder.objects.filter(order=order,
user=self.user).first()
self.assertEqual(ref1.amount, Decimal('0.1'))
self.assertEqual(ref2.amount, Decimal('1'))
def test_add_referral_for_selling(self):
PromotionRuleFactory()
order_id = self._make_sell_order(Decimal('10'))
order = Order.objects.get(id=order_id)
order.status = ORDER_STATUS.success
order.save(update_fields=[
'status',
])
ref1 = ReferralOrder.objects.filter(order=order,
user=self.referral).first()
ref2 = ReferralOrder.objects.filter(order=order,
user=self.user).first()
self.assertEqual(ref1.amount, Decimal('0.1'))
self.assertEqual(ref2.amount, Decimal('1'))
def test_add_referral_without_referee(self):
PromotionRuleFactory(referee_percentage=0)
order_id = self._make_sell_order(Decimal('10'))
order = Order.objects.get(id=order_id)
order.status = ORDER_STATUS.success
order.save(update_fields=[
'status',
])
ref1 = ReferralOrder.objects.filter(order=order,
user=self.referral).first()
ref2 = ReferralOrder.objects.filter(order=order,
user=self.user).first()
self.assertIsNotNone(ref1)
self.assertIsNone(ref2)
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()
OrderFactory.create_batch(10, user=self.user)
class BuyingQuoteTests(APITestCase):
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
PriceManagement.get_cache_price = MagicMock(return_value=CryptoPrice(
CURRENCY.ETH,
Decimal('100'),
Decimal('100'),
))
RateManagement.get_cache_rate = MagicMock(return_value=Decimal('23000'))
FeeFactory(key=FEE_COIN_ORDER_BANK, value=Decimal('1'), fee_type=FEE_TYPE.percentage)
FeeFactory(key=FEE_COIN_ORDER_COD, value=Decimal('10'), fee_type=FEE_TYPE.percentage)
PoolFactory(currency=CURRENCY.ETH, direction=DIRECTION.buy, usage=1, limit=2)
user = self.auth_utils.create_user()
exchange_user = ExchangeUserFactory(user=user, currency=FIAT_CURRENCY.PHP)
UserLimitFactory(fiat_currency=FIAT_CURRENCY.PHP, direction=DIRECTION_ALL, usage=2300000, limit=3000000,
user=exchange_user)
def test_invalid(self):
url = reverse('exchange:quote-detail')
response = self.client.get(url, data={
}, format='json')
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_crypto_rate(self):
url = reverse('exchange:quote-detail')
response = self.client.get(url, data={
'amount': '1',
'currency': CURRENCY.ETH,
'fiat_currency': FIAT_CURRENCY.PHP,
}, format='json')
data = response.json()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(data['fiat_amount'], Decimal(101), '100 added 1%')
self.assertEqual(data['fiat_amount_cod'], Decimal(110), '100 added 10%')
self.assertEqual(data['fiat_local_amount'], Decimal(2323000), '100 added 1% * 23000')
self.assertEqual(data['fiat_local_amount_cod'], Decimal(2530000), '100 added 10% * 23000')
def test_check_pool_limit_success(self):
url = reverse('exchange:quote-detail')
response = self.client.get(url, data={
'amount': '1',
'currency': CURRENCY.ETH,
'fiat_currency': FIAT_CURRENCY.PHP,
'check': True,
}, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_check_pool_over_limit(self):
url = reverse('exchange:quote-detail')
response = self.client.get(url, data={
'amount': '2',
'currency': CURRENCY.ETH,
'fiat_currency': FIAT_CURRENCY.PHP,
'check': True,
}, format='json')
data = response.json()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(data['code'], 'coin_over_limit')
def test_check_user_limit_success(self):
self.auth_utils.login()
url = reverse('exchange:quote-detail')
response = self.client.get(url, data={
'amount': '0.1',
'currency': CURRENCY.ETH,
'fiat_currency': FIAT_CURRENCY.PHP,
'user_check': True,
}, format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_check_user_over_limit(self):
self.auth_utils.login()
url = reverse('exchange:quote-detail')
response = self.client.get(url, data={
'amount': '1',
'currency': CURRENCY.ETH,
'fiat_currency': FIAT_CURRENCY.PHP,
'user_check': True,
}, format='json')
data = response.json()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(data['code'], 'coin_user_over_limit')
def test_check_user_without_limit_setup(self):
url = reverse('exchange:quote-detail')
username = '******'
self.auth_utils.create_exchange_user(username)
self.auth_utils.login(username)
response = self.client.get(url, data={
'amount': '1',
'currency': CURRENCY.ETH,
'fiat_currency': FIAT_CURRENCY.PHP,
'user_check': True,
}, format='json')
data = response.json()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(data['code'], 'invalid_data')
def test_check_user_without_login(self):
url = reverse('exchange:quote-detail')
response = self.client.get(url, data={
'amount': '1',
'currency': CURRENCY.ETH,
'fiat_currency': FIAT_CURRENCY.PHP,
'user_check': True,
}, format='json')
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
def setUp(self):
self.auth_utils = AuthenticationUtils(self.client)
self.user = self.auth_utils.create_exchange_user()
self.auth_utils.login()