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_clientlib_call_contracts():
request = contracts_request()
successful, response = handle_response(handle_request(request))
assert successful == True
assert set(response) == {
'MyContract', 'DigitalCurrency', 'AuthDigitalCurrency'
}
def test_clientlib_call_request_fail():
request = call_request(call='add_account',
contract='AuthDigitalCurrency',
data={'key': 'yet_another_account'})
successful, response = handle_response(handle_request(request))
assert successful == False
assert response == 'Not enough permissions'
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 test_clientlib_call_request():
request = call_request(call='add_account',
user='******',
password='******',
contract='AuthDigitalCurrency',
data={'key': 'another_account'})
succesful, response = handle_response(handle_request(request))
assert succesful == True
assert response == 'another_account'
def onMessage(self, payload, isBinary):
try:
topic = payload[:36]
payload = payload[36:]
response = handle_request(payload)
except:
response = b'ERROR'
if topic == 36*b'0':
self.factory.broadcast(topic + response)
else:
self.sendMessage(topic + response, True)
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_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_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_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_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 test_clientlib_call_api():
request = api_request(contract='AuthDigitalCurrency')
successful, response = handle_response(handle_request(request))
assert successful == True
assert response == {
'add_account': {
'key': str
},
'balance': {
'key': str
},
'increment': {
'key': str,
'quantity': float
},
'transfer': {
'dest': str,
'quantity': float,
'source': str
}
}
def test_failed_message():
response = PyledgerResponse()
response.ParseFromString(handle_request(b'xxxyyy'))
assert response.successful == False
assert response.data == b'Message not properly formatted'
