class GetRequestTestCase(unittest.TestCase):
""" Ensure we can retrieve existing Requests on Rinkeby
"""
def setUp(self):
super().setUp()
self.request_api = RequestNetwork()
def test_get_request_by_id(self):
request = self.request_api.get_request_by_id(
'0x8fc2e7f2498f1d06461ee2d547002611b801202b0000000000000000000003e4')
self.assertEqual(
'0x627306090abaB3A6e1400e9345bC60c78a8BEf57',
request.payer
)
self.assertEqual(
100000000000000,
request.payments[0].delta_amount
)
def test_get_request_by_transaction_hash(self):
request = self.request_api.get_request_by_transaction_hash(
'0xf9d484e56c038055e78344c9fa082e4bae640c7fde5d5063e6c394be20ceebd0')
self.assertEqual(
'0x627306090abaB3A6e1400e9345bC60c78a8BEf57',
request.payer
)
def is_broadcast(self):
""" Returns True if this Request can be successfully retrieved from the blockchain.
"""
from request_network.api import RequestNetwork
request_api = RequestNetwork()
try:
request = request_api.get_request_by_transaction_hash(self.transaction_hash)
except RequestNotFound:
return False
# TODO validate other parameters? Hash the Request and compare hashes?
return request.id == self.id
class Base64EncodingTestCase(unittest.TestCase):
def setUp(self):
super().setUp()
self.request_api = RequestNetwork()
def test_get_qr_code(self):
""" Generate the base64 and QR code data URI for a Signed Request, and validate the first
32 characters of each.
"""
signed_request = self.request_api.create_signed_request(
role=Roles.PAYEE,
currency=currencies_by_symbol['ETH'],
payees=[Payee(
id_address='0x821aea9a577a9b44299b9c15c88cf3087f3b5544',
amount=int(0.1 * 10 ** 18)
)],
expiration_date=7952342400000,
data={'reason': 'pay in advance'}
)
params = dict(callback_url='https://example.com', ethereum_network_id=4)
self.assertEqual(
'eyJzaWduZWRSZXF1ZXN0IjogeyJjdXJy',
signed_request.as_base64(**params)[:32]
)
self.assertEqual(
'data:text/png;base64,iVBORw0KGgo',
signed_request.get_qr_code_data_uri(**params)[:32]
)
class TestCreateRequestAsPayee(unittest.TestCase):
def setUp(self):
super().setUp()
self.request_api = RequestNetwork()
def test_create_request_as_payee(self):
tx_hash = self.request_api.create_request(
role=Roles.PAYEE,
currency=currencies_by_symbol['ETH'],
payees=payees,
payer=Payer(id_address=test_account, refund_address=None),
data={'reason': 'selling cool stuff'})
self.assertIsNotNone(tx_hash)
# Retrieve the request and validate it
request = self.request_api.get_request_by_transaction_hash(tx_hash)
self.assertEqual(test_amounts,
[payee.amount for payee in request.payees])
self.assertEqual('selling cool stuff', request.data['reason'])
self.assertTrue(request.is_broadcast)
def test_create_request_as_payer(self):
tx_hash = self.request_api.create_request(
role=Roles.PAYER,
currency=currencies_by_symbol['ETH'],
payees=payees,
payer=Payer(id_address=test_account, refund_address=None),
data={'reason': 'buying cool stuff'})
self.assertIsNotNone(tx_hash)
# Retrieve the request and validate it
request = self.request_api.get_request_by_transaction_hash(tx_hash)
self.assertEqual(test_amounts,
[payee.amount for payee in request.payees])
self.assertEqual('buying cool stuff', request.data['reason'])
self.assertTrue(request.is_broadcast)
class GetRequestTestCase(unittest.TestCase):
""" Retrieve Requests that were created by running the RequestNetwork.js
test suite.
This test case assumes it is running against a private Ethereum network
on which the Request Network smart contracts have been deployed and tested.
"""
def setUp(self):
super().setUp()
self.request_api = RequestNetwork()
def test_hash_request_object(self):
request = self.request_api.get_request_by_transaction_hash(
'0x1f97459c45402fcb6562410cf4b4253a9d5d9528f247a892f9bddeefdd878b2d'
)
# Manually add the expiration date as it is not stored on the contract
request.expiration_date = 7952342400000
hash_request_object(request)
def test_get_request_by_id(self):
request = self.request_api.get_request_by_id(
'0x8cdaf0cd259887258bc13a92c0a6da92698644c0000000000000000000000050'
)
self.assertEqual('0xC5fdf4076b8F3A5357c5E395ab970B5B54098Fef',
request.payer)
self.assertEqual(100000000, request.payments[0].delta_amount)
def test_get_request_by_transaction_hash(self):
request = self.request_api.get_request_by_transaction_hash(
'0x8d3ec9ef287f09577707bd8ffe7f053394d4cb5355f62495886dbd4a5589971b'
)
self.assertEqual('0x0F4F2Ac550A1b4e2280d04c21cEa7EBD822934b5',
request.payer)
self.assertIn('reason', request.data)
def test_get_nonexistent_request_by_id(self):
with self.assertRaises(RequestNotFound):
self.request_api.get_request_by_id(
'0x8cdaf0cd259887258bc13a92c0a6da92698644c0000000000000000000000000'
)
def test_get_nonexistent_request_by_transaction_hash(self):
with self.assertRaises(TransactionNotFound):
self.request_api.get_request_by_transaction_hash(
'0x8d3ec9ef287f09577707bd8ffe7f053394d4cb5355f62495886dbd4a55800000'
)
def setUp(self):
super().setUp()
self.request_api = RequestNetwork()
def setUp(self):
super().setUp()
self.request_api = RequestNetwork()
self.service = RequestERC20Service(
token_address=test_token_address
)
def main():
parser = argparse.ArgumentParser(
description=
'Create a signed Request and save it as a QR code in a PNG image.')
parser.add_argument('--payee',
type=str,
required=True,
help='Ethereum address which will receive the payment')
parser.add_argument('--amount',
type=float,
required=True,
help='The payment amount in ETH')
parser.add_argument('--output-file',
type=str,
required=True,
help='Output filename')
parser.add_argument('--callback-url',
type=str,
required=True,
help='Callback URL')
parser.add_argument(
'--network-id',
type=str,
required=True,
help='Ethereum network ID, e.g. 1 for "main" or 4 for "rinkeby"')
parser.add_argument(
'--expiration',
type=int,
default=3600,
help='The number of seconds after which this Request expires')
args = parser.parse_args()
if os.path.exists(args.output_file):
raise Exception('{} already exists'.format(args.output_file))
expiration_timestamp = int(
time.time()) + (args.expiration if args.expiration else 3600)
# Use format to get a string instead of a number in scientific notation
amount_in_wei = format(args.amount * (10**18), '.0f')
payee = Payee(id_address=Web3.toChecksumAddress(args.payee),
amount=amount_in_wei,
payment_address=None)
print('Generating signed Request and QR code')
print('Payee: {}'.format(payee.id_address))
print('Amount: {} ETH ({} Wei)'.format(args.amount, amount_in_wei))
print('Expiration: {}'.format(
datetime.datetime.fromtimestamp(expiration_timestamp).strftime(
'%Y-%m-%d %H:%M:%S')))
print('Ethereum network name: ID: {}'.format(args.network_id))
print('Callback URL: {}'.format(args.callback_url))
request_api = RequestNetwork()
signed_request = request_api.create_signed_request(
role=Roles.PAYEE,
currency=currencies_by_symbol['ETH'],
payees=[payee],
expiration_date=expiration_timestamp)
with open(args.output_file, 'wb') as f:
signed_request.write_qr_code(f,
callback_url=args.callback_url,
ethereum_network_id=args.network_id)
print('QR code written to {}'.format(args.output_file))