def test_wrong_request():
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'blahblah'
response.ParseFromString(handle_request(request.SerializeToString()))
assert response.successful == False
assert response.data == b'Request type blahblah not available'
def test_0_register_auth_contract():
class AuthDigitalCurrency(SimpleContract):
accounts = {}
@method_allow(Permissions.ROOT)
def add_account(self, key: str):
if key in self.accounts:
raise Exception('Account already exists')
self.accounts[key] = 0.0
return key
@method_allow(Permissions.ROOT)
def increment(self, key: str, quantity: float):
if key not in self.accounts:
raise Exception('Account not found')
self.accounts[key] += quantity
@method_allow(Permissions.USER)
def transfer(self, source: str, dest: str, quantity: float):
if source not in self.accounts:
raise Exception('Source account not found')
if dest not in self.accounts:
raise Exception('Destination account not found')
if self.accounts[source] < quantity:
raise Exception('Not enough funds in source account')
if quantity < 0:
raise Exception('You cannot transfer negative currency')
self.accounts[source] -= quantity
self.accounts[dest] += quantity
@method_allow(Permissions.USER)
def balance(self, key: str):
if key not in self.accounts:
print(self.accounts)
raise Exception('Account not found')
return str(self.accounts[key])
register_contract(AuthDigitalCurrency())
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'call'
request.contract = 'AuthDigitalCurrency'
request.call = 'add_account'
request.data = pickle.dumps({'key': 'new_account'})
byte_request = request.SerializeToString()
byte_response = handle_request(byte_request)
response.ParseFromString(byte_response)
assert response.successful == False
assert response.data == b'Not enough permissions'
def api_request(**kwargs):
request = PyledgerRequest()
request.request = 'api'
if 'contract' not in kwargs:
raise ValueError('Contract should be a keyword argument')
if kwargs['contract']:
request.contract = kwargs['contract']
else:
raise ValueError('You should give a contract name')
return request.SerializeToString()
def test_3_create_without_permissions():
"""
Try to create a user without the permissions
"""
request = PyledgerRequest()
request.request = 'new_user'
request.user = '******'
request.password = '******'
request.data = pickle.dumps(('user3', 'new_password'))
response = PyledgerResponse()
response.ParseFromString(handle_request(request.SerializeToString()))
assert response.successful == False
assert response.data == b'Not enough permissions'
def test_call_method():
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'call'
request.contract = 'somecontract'
request.call = 'somemethod'
byte_request = request.SerializeToString()
byte_response = handle_request(byte_request)
response.ParseFromString(byte_response)
assert response.successful == False
assert response.data == b'Contract somecontract not available'
def test_status():
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'status'
request.contract = 'DigitalCurrency'
byte_request = request.SerializeToString()
byte_response = handle_request(byte_request)
response.ParseFromString(byte_response)
status = pickle.loads(response.data)
assert response.successful == True
assert status == {'accounts': {}}
def test_exception():
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'call'
request.contract = 'DigitalCurrency'
request.call = 'increment'
request.data = pickle.dumps({'key': 'another_account', 'quantity': 100.0})
byte_request = request.SerializeToString()
byte_response = handle_request(byte_request)
response.ParseFromString(byte_response)
assert response.successful == False
assert response.data == b"Exception in user function: Exception('Account not found',)"
def test_contracts():
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'contracts'
byte_request = request.SerializeToString()
byte_response = handle_request(byte_request)
response.ParseFromString(byte_response)
assert response.successful == True
contracts = pickle.loads(response.data)
assert set(contracts) == {'MyContract', 'DigitalCurrency'}
def test_simple_call():
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'call'
request.contract = 'DigitalCurrency'
request.call = 'add_account'
request.data = pickle.dumps({'key': 'new_account'})
byte_request = request.SerializeToString()
byte_response = handle_request(byte_request)
response.ParseFromString(byte_response)
response_data = pickle.loads(response.data)
assert response.successful == True
assert response_data == response_data
def test_master_session():
"""
Get a master session key
"""
request = PyledgerRequest()
request.request = 'session'
request.user = '******'
request.password = '******'
response = PyledgerResponse()
response.ParseFromString(handle_request(request.SerializeToString()))
assert response.successful == True
session_key = response.data.decode('utf-8')
session = Session.from_key(session_key)
assert session.key == session_key
def test_2_create_user():
"""
Create a user from the API
"""
request = PyledgerRequest()
request.request = 'new_user'
request.user = '******'
request.password = '******'
request.session_key = 'test_session'
request.data = pickle.dumps(('user2', 'new_password'))
response = PyledgerResponse()
response.ParseFromString(handle_request(request.SerializeToString()))
assert response.successful == True
assert response.data == b'user2'
user = User.from_name('user2')
assert user.get_permissions() == Permissions.USER
assert user.check_password('new_password')
def test_access_contract_as_root():
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'call'
request.contract = 'AuthDigitalCurrency'
request.call = 'add_account'
request.user = '******'
request.password = '******'
request.data = pickle.dumps({'key': 'new_account'})
byte_request = request.SerializeToString()
byte_response = handle_request(byte_request)
response.ParseFromString(byte_response)
assert response.successful == True
response_data = pickle.loads(response.data)
assert response_data == 'new_account'
def test_api():
request = PyledgerRequest()
response = PyledgerResponse()
request.request = 'api'
request.contract = 'DigitalCurrency'
byte_request = request.SerializeToString()
byte_response = handle_request(byte_request)
response.ParseFromString(byte_response)
api = pickle.loads(response.data)
assert response.successful == True
assert api == {
'add_account': {'key': str},
'balance': {'key': str},
'increment': {'key': str, 'quantity': float},
'transfer': {'dest': str, 'quantity': float, 'source': str}
}
def call_request(**kwargs):
request = PyledgerRequest()
request.user, request.password = auth_info(kwargs)
request.session_key = session_info(kwargs)
request.request = 'call'
if 'contract' not in kwargs:
raise ValueError('Contract should be a keyword argument')
request.contract = kwargs['contract']
if 'call' not in kwargs:
raise ValueError('Call should be a keyword argument')
request.call = kwargs['call']
if 'data' not in kwargs:
raise ValueError('Data should be a keyword argument')
request.data = pickle.dumps(kwargs['data'])
return request.SerializeToString()
def broadcast_request(message):
request = PyledgerRequest()
request.request = 'broadcast'
request.data = pickle.dumps(message)
return request.SerializeToString()
def contracts_request(**kwargs):
# This is simple, doesn't require authentication.
request = PyledgerRequest()
request.request = 'contracts'
return request.SerializeToString()