def test_get_addresses(self): client = Client(api_key, api_secret) addresses = client.get_addresses('foo') self.assertIsInstance(addresses, APIObject) self.assertEqual(addresses.data, mock_collection) for address in addresses.data: self.assertIsInstance(address, Address)
def test_get_transactions(self): client = Client(api_key, api_secret) transactions = client.get_transactions('foo') self.assertIsInstance(transactions, APIObject) self.assertEqual(transactions.data, mock_collection) for transaction in transactions.data: self.assertIsInstance(transaction, Transaction)
def test_get_sells(self): client = Client(api_key, api_secret) sells = client.get_sells('foo') self.assertIsInstance(sells, APIObject) self.assertEqual(sells.data, mock_collection) for sell in sells.data: self.assertIsInstance(sell, Sell)
def test_get_accounts(self): client = Client(api_key, api_secret) accounts = client.get_accounts() self.assertIsInstance(accounts, APIObject) self.assertEqual(accounts.data, mock_collection) for account in accounts.data: self.assertIsInstance(account, Account)
def test_get_withdrawals(self): client = Client(api_key, api_secret) withdrawals = client.get_withdrawals('foo') self.assertIsInstance(withdrawals, APIObject) self.assertEqual(withdrawals.data, mock_collection) for withdrawal in withdrawals.data: self.assertIsInstance(withdrawal, Withdrawal)
def test_create_report(self): client = Client(api_key, api_secret) report = client.create_report(email='*****@*****.**', type='transactions') self.assertIsInstance(report, APIObject) self.assertIsInstance(report, Report) self.assertEqual(report, mock_item)
def test_get_deposits(self): client = Client(api_key, api_secret) deposits = client.get_deposits('foo') self.assertIsInstance(deposits, APIObject) self.assertEqual(deposits.data, mock_collection) for deposit in deposits.data: self.assertIsInstance(deposit, Deposit)
def test_get_payment_methods(self): client = Client(api_key, api_secret) payment_methods = client.get_payment_methods() self.assertIsInstance(payment_methods, APIObject) self.assertEqual(payment_methods.data, mock_collection) for payment_method in payment_methods.data: self.assertIsInstance(payment_method, PaymentMethod)
def test_get_checkouts(self): client = Client(api_key, api_secret) checkouts = client.get_checkouts() self.assertIsInstance(checkouts, APIObject) self.assertEqual(checkouts.data, mock_collection) for checkout in checkouts.data: self.assertIsInstance(checkout, Checkout)
def test_get_checkout_orders(self): client = Client(api_key, api_secret) orders = client.get_checkout_orders('foo') self.assertIsInstance(orders, APIObject) self.assertEqual(orders.data, mock_collection) for order in orders.data: self.assertIsInstance(order, Order)
def test_get_reports(self): client = Client(api_key, api_secret) reports = client.get_reports() self.assertIsInstance(reports, APIObject) self.assertEqual(reports.data, mock_collection) for report in reports.data: self.assertIsInstance(report, Report)
def test_get_buys(self): client = Client(api_key, api_secret) buys = client.get_buys('foo') self.assertIsInstance(buys, APIObject) self.assertEqual(buys.data, mock_collection) for buy in buys.data: self.assertIsInstance(buy, Buy)
def test_request_helper_automatically_encodes_data(self): client = Client(api_key, api_secret) def server_response(request, uri, headers): self.assertIsInstance(request.body, six.binary_type) return 200, headers, '{}' hp.register_uri(hp.POST, re.compile('.*foo$'), server_response) self.assertEqual( client._post('foo', data={ 'name': 'example' }).status_code, 200)
def test_sell(self): client = Client(api_key, api_secret) with self.assertRaises(ValueError): client.sell('foo') for valid_kwargs in [{ 'amount': '1.0', 'currency': 'USD' }, { 'total': '1.0', 'currency': 'USD' }]: sell = client.sell('foo', **valid_kwargs) self.assertIsInstance(sell, Sell) self.assertEqual(sell, mock_item)
def test_response_handling(self): client = Client(api_key, api_secret) # Check that 2XX responses always return the response error_response = { 'errors': [{ 'id': 'fakeid', 'message': 'some error message', }], 'data': mock_item, } error_str = json.dumps(error_response) for code in [200, 201, 204]: hp.register_uri(hp.GET, re.compile('.*' + str(code) + '$'), lambda r, u, h: (code, h, error_str)) response = client._get(str(code)) self.assertEqual(response.status_code, code) # Check that when the error data is in the response, that's what is used. import pycoinbase.wallet.error for eid, eclass in six.iteritems( pycoinbase.wallet.error._error_id_to_class): error_response = { 'errors': [{ 'id': eid, 'message': 'some message', }], 'data': mock_item, } error_str = json.dumps(error_response) hp.reset() hp.register_uri(hp.GET, re.compile('.*test$'), lambda r, u, h: (400, h, error_str)) with self.assertRaises(eclass): client._get('test') # Check that when the error data is missing, the status code is used # instead. error_response = {'data': mock_item} for code, eclass in six.iteritems( pycoinbase.wallet.error._status_code_to_class): hp.reset() hp.register_uri( hp.GET, re.compile('.*test$'), lambda r, u, h: (code, h, json.dumps(error_response))) with self.assertRaises(eclass): client._get('test') # Check that when the response code / error id is unrecognized, a generic # APIError is returned hp.reset() hp.register_uri(hp.GET, re.compile('.*test$'), lambda r, u, h: (418, h, '{}')) with self.assertRaises(APIError): client._get('test')
def test_request_includes_auth_headers(self): client = Client(api_key, api_secret) def server_response(request, uri, response_headers): keys = [ 'CB-VERSION', 'CB-ACCESS-KEY', 'CB-ACCESS-SIGN', 'CB-ACCESS-TIMESTAMP', 'Accept', 'Content-Type', 'User-Agent' ] for key in keys: self.assertIn(key, request.headers) self.assertNotEqual(request.headers[key], '') return 200, response_headers, '{}' hp.register_uri(hp.GET, re.compile('.*test$'), server_response) self.assertEqual(client._get('test').status_code, 200)
def test_set_primary(self): client = Client(api_key, api_secret) account = new_api_object(client, mock_account, Account) data = account.set_primary() self.assertEqual(data, mock_account_updated) for key, value in six.iteritems(mock_account_updated): self.assertEqual(account[key], value)
def test_modify(self): client = Client(api_key, api_secret) account = new_api_object(client, mock_account, Account) data = account.modify(name='New Account Name') self.assertEqual(data, mock_account_updated) for key, value in six.iteritems(mock_account_updated): self.assertEqual(account[key], value)
def test_create_report(self): client = Client(api_key, api_secret) account = new_api_object(client, mock_account, Account) report = account.create_report(type='transactions', email='*****@*****.**') self.assertIsInstance(report, APIObject) self.assertIsInstance(report, Report) self.assertEqual(report, mock_item)
def test_request_money(self): client = Client(api_key, api_secret) # Start with none of the required arguments, and slowly make requests with # an additional required argument, expecting failure until all arguments # are present. send_kwargs = {} required_kwargs = {'to': 'bar', 'amount': '1.0', 'currency': 'USD'} while required_kwargs: with self.assertRaises(ValueError): transaction = client.request_money('foo', **send_kwargs) for key in required_kwargs: send_kwargs[key] = required_kwargs.pop(key) break transaction = client.request_money('foo', **send_kwargs) self.assertIsInstance(transaction, Transaction) self.assertEqual(transaction, mock_item)
def test_get_address(self): client = Client(api_key, api_secret) account = new_api_object(client, mock_account, Account) address = account.get_address('bar') self.assertIsInstance(address, Address) self.assertEqual(address, mock_item) pass
def test_create_checkout(self): client = Client(api_key, api_secret) # Start with none of the required arguments, and slowly make requests with # an additional required argument, expecting failure until all arguments # are present. send_kwargs = {} required_kwargs = {'name': 'bar', 'amount': '1.0', 'currency': 'USD'} while required_kwargs: with self.assertRaises(ValueError): client.create_checkout(**send_kwargs) for key in required_kwargs: send_kwargs[key] = required_kwargs.pop(key) break checkout = client.create_checkout(**send_kwargs) self.assertIsInstance(checkout, Checkout) self.assertEqual(checkout, mock_item)
def test_refund_order(self): client = Client(api_key, api_secret) # Start with none of the required arguments, and slowly make requests with # an additional required argument, expecting failure until all arguments # are present. send_kwargs = {} required_kwargs = {'currency': 'USD'} while required_kwargs: with self.assertRaises(ValueError): client.refund_order('foo', **send_kwargs) for key in required_kwargs: send_kwargs[key] = required_kwargs.pop(key) break order = client.refund_order('foo', **send_kwargs) self.assertIsInstance(order, Order) self.assertEqual(order, mock_item)
def test_get_withdrawals(self): client = Client(api_key, api_secret) account = new_api_object(client, mock_account, Account) withdrawals = account.get_withdrawals() self.assertIsInstance(withdrawals, APIObject) self.assertEqual(withdrawals.data, mock_collection) for withdrawal in withdrawals.data: self.assertIsInstance(withdrawal, Withdrawal)
def test_get_orders(self): client = Client(api_key, api_secret) checkout = new_api_object(client, mock_checkout, Checkout) orders = checkout.get_orders() self.assertIsInstance(orders, APIObject) self.assertEqual(orders.data, mock_collection) for order in orders.data: self.assertIsInstance(order, Order)
def test_commit(self): client = Client(api_key, api_secret) buy = new_api_object(client, mock_buy, Buy) buy2 = buy.commit() self.assertIsInstance(buy2, Buy) self.assertEqual(buy2, mock_buy_updated) for key, value in six.iteritems(mock_buy_updated): self.assertEqual(buy[key], value)
def test_commit(self): client = Client(api_key, api_secret) sell = new_api_object(client, mock_sell, Sell) sell2 = sell.commit() self.assertIsInstance(sell2, Sell) self.assertEqual(sell2, mock_sell_updated) for key, value in six.iteritems(mock_sell_updated): self.assertEqual(sell[key], value)
def test_commit(self): client = Client(api_key, api_secret) deposit = new_api_object(client, mock_deposit, Deposit) deposit2 = deposit.commit() self.assertIsInstance(deposit2, Deposit) self.assertEqual(deposit2, mock_deposit_updated) for key, value in six.iteritems(mock_deposit_updated): self.assertEqual(deposit[key], value)
def test_modify(self): client = Client(api_key, api_secret) user = new_api_object(client, mock_item, CurrentUser) user2 = user.modify(name='New Name') self.assertIsInstance(user2, CurrentUser) self.assertEqual(user2, mock_item_updated) for key, value in six.iteritems(mock_item_updated): self.assertEqual(user[key], value)
def test_buy(self): client = Client(api_key, api_secret) with self.assertRaises(ValueError): client.buy('foo') kwargs_list = [{ 'amount': '1.0', 'payment_method': 'bar', 'currency': 'USD' }, { 'total': '1.0', 'payment_method': 'bar', 'currency': 'USD' }] for valid_kwargs in kwargs_list: buy = client.buy('foo', **valid_kwargs) self.assertIsInstance(buy, Buy) self.assertEqual(buy, mock_item)