def testSendGetTxnReqSameAsExpected(looper, steward1, stewardWallet):
req, wallet = sendAddNewClient(STEWARD, "name", steward1, stewardWallet)
timeout = waits.expectedTransactionExecutionTime(len(
steward1.inBox)) + c_delay
nym_response = looper.run(
eventually(checkSufficientRepliesReceived,
steward1.inBox,
req.reqId,
fValue,
retryWait=1,
timeout=timeout))
op = {TXN_TYPE: GET_TXN, DATA: nym_response['seqNo']}
req = stewardWallet.signOp(op)
send_signed_requests(steward1, [req])
get_txn_response = looper.run(
eventually(checkSufficientRepliesReceived,
steward1.inBox,
req.reqId,
fValue,
retryWait=1,
timeout=timeout))
get_txn_response = json.loads(get_txn_response[DATA])
del nym_response['txnTime']
del get_txn_response['txnTime']
assert nym_response == get_txn_response
def test_dirty_read(looper, nodeSet, client1, wallet1):
"""
Tests the case when read request comes before write request is
not executed on some nodes
"""
slow_nodes = list(nodeSet)[2:4]
for node in slow_nodes:
logger.debug("Making node {} slow".format(node))
make_node_slow(node)
set_request = sendReqsToNodesAndVerifySuffReplies(looper,
wallet1,
client1,
numReqs=1)[0]
received_replies = getRepliesFromClientInbox(inbox=client1.inBox,
reqId=set_request.reqId)
seq_no = received_replies[0]["result"]["seqNo"]
get_request = [wallet1.signOp({"type": GET_TXN, DATA: seq_no})]
send_signed_requests(client1, get_request)
waitForSufficientRepliesForRequests(looper, client1, requests=get_request)
received_replies = getRepliesFromClientInbox(inbox=client1.inBox,
reqId=get_request[0].reqId)
results = [str(reply['result'][DATA]) for reply in received_replies]
assert len(set(results)) == 1
def test_plugin_dynamic_validation(nodeSet, looper, stewardWallet,
steward1, client1Connected,
sdk_wallet_steward, sdk_pool_handle):
"""
Check plugin dynamic validation fails and passes
"""
op = {
TXN_TYPE: AUCTION_END,
DATA: {'id': 'abcdef'}
}
send_signed_requests(steward1, sign_requests(stewardWallet, [op, ]))
waitRejectFromPoolWithReason(looper, nodeSet, steward1,
'unknown auction')
op = {
TXN_TYPE: AUCTION_START,
DATA: {'id': 'xyz'}
}
successful_op(looper, op, sdk_wallet_steward, sdk_pool_handle)
op = {
TXN_TYPE: AUCTION_END,
DATA: {'id': 'xyz'}
}
successful_op(looper, op, sdk_wallet_steward, sdk_pool_handle)
def test_request_no_protocol_version(looper, txnPoolNodeSet, client1, wallet1,
request_num):
reqs = random_request_objects(request_num, protocol_version=None)
reqs = sign_request_objects(wallet1, reqs)
for req in reqs:
assert req.protocolVersion is None
send_signed_requests(client1, reqs)
waitForSufficientRepliesForRequests(looper, client1, requests=reqs)
def test_request_with_correct_version(looper, txnPoolNodeSet, client1, wallet1,
request_num):
reqs = random_request_objects(request_num,
protocol_version=CURRENT_PROTOCOL_VERSION)
reqs = sign_request_objects(wallet1, reqs)
for req in reqs:
assert req.protocolVersion == CURRENT_PROTOCOL_VERSION
send_signed_requests(client1, reqs)
waitForSufficientRepliesForRequests(looper, client1, requests=reqs)
def test_version_not_set_by_default(looper, txnPoolNodeSet, client1, wallet1,
request_num):
req_dicts = random_requests(request_num)
reqs = [Request(operation=op) for op in req_dicts]
for req in reqs:
assert req.protocolVersion is None
reqs = sign_request_objects(wallet1, reqs)
for req in reqs:
assert req.protocolVersion is None
send_signed_requests(client1, reqs)
waitForSufficientRepliesForRequests(looper, client1, requests=reqs)
def test_request_with_invalid_version(tconf, looper, txnPoolNodeSet,
client1, client1Connected,
wallet1,
request_num):
reqs = random_request_objects(request_num, protocol_version=-1)
reqs = sign_request_objects(wallet1, reqs)
for req in reqs:
assert req.protocolVersion == -1
send_signed_requests(client1, reqs)
for node in txnPoolNodeSet:
looper.run(eventually(checkReqNackWithReason, client1,
'Unknown protocol version value -1',
node.clientstack.name, retryWait=1))
def testSendGetTxnReqForNotExistsSeqNo(looper, steward1, stewardWallet):
op = {TXN_TYPE: GET_TXN, DATA: randint(100, 1000)}
req = stewardWallet.signOp(op)
send_signed_requests(steward1, [req])
timeout = waits.expectedTransactionExecutionTime(len(
steward1.inBox)) + c_delay
get_txn_response = looper.run(
eventually(checkSufficientRepliesReceived,
steward1.inBox,
req.reqId,
fValue,
retryWait=1,
timeout=timeout))
assert not get_txn_response[DATA]
def test_request_executed_once_and_without_failing_behind(
tconf, looper, txnPoolNodeSet, client1, wallet1):
"""
Checks that all requests executed only once and without failing behind in
wrote transactions
1. Send request
2. When it is ordered - send checkpoint to replica to force it
make garbage collection
3. Check that ordered request executed and client receives reply
4. Check that ledgers on all nodes are the same and contain all
expected transactions
"""
number_of_requests = 5
tconf.CHK_FREQ = 1
for node in txnPoolNodeSet:
for replica in node.replicas:
set_checkpoint_faking(replica)
requests = [
wallet1.signOp(req) for req in random_requests(number_of_requests)
]
for request in requests:
send_signed_requests(client1, [request])
waitForSufficientRepliesForRequests(looper,
client1,
requests=[request])
expected = [request.reqId for request in requests]
for node in txnPoolNodeSet:
real_ledger_state = [
txn[1]['reqId']
for txn in node.getLedger(DOMAIN_LEDGER_ID).getAllTxn()
if 'reqId' in txn[1]
]
assert expected == real_ledger_state
def test_plugin_static_validation(nodeSet, looper, stewardWallet,
steward1, client1Connected,
sdk_wallet_steward, sdk_pool_handle):
"""
Check plugin static validation fails and passes
"""
op = {
TXN_TYPE: AUCTION_START
}
send_signed_requests(steward1, sign_requests(stewardWallet, [op, ]))
waitReqNackFromPoolWithReason(looper, nodeSet, steward1,
'attribute is missing or not in proper format')
op = {
TXN_TYPE: AUCTION_START,
DATA: 'should be a dict but giving a string'
}
send_signed_requests(steward1, sign_requests(stewardWallet, [op, ]))
waitReqNackFromPoolWithReason(looper, nodeSet, steward1,
'attribute is missing or not in proper format')
op = {
TXN_TYPE: AUCTION_START,
DATA: {'id': 'abc'}
}
successful_op(looper, op, sdk_wallet_steward, sdk_pool_handle)
op = {
TXN_TYPE: PLACE_BID,
DATA: {'id': 'abc', AMOUNT: -3}
}
send_signed_requests(steward1, sign_requests(stewardWallet, [op, ]))
waitReqNackFromPoolWithReason(looper, nodeSet, steward1,
'must be present and should be a number')
op = {
TXN_TYPE: PLACE_BID,
DATA: {'id': 'abc', AMOUNT: 20}
}
successful_op(looper, op, sdk_wallet_steward, sdk_pool_handle)
def send_and_check(signed_reqs, looper, txnPoolNodeSet, client):
reqs = send_signed_requests(client, signed_reqs)
waitForSufficientRepliesForRequests(looper, client, requests=reqs)
checkNodesHaveSameRoots(txnPoolNodeSet)
def sign_and_send(op):
signed = wallet.signOp(op)
send_signed_requests(client, [signed])
def test_already_processed_requests(looper, txnPoolNodeSet, client1, wallet1,
client1Connected):
"""
Client re-sending request and checking that nodes picked the reply from
ledger and did not process the request again
"""
def get_method_call_count(method):
counts = set()
for node in txnPoolNodeSet:
c = node.spylog.count(method)
counts.add(c)
assert len(counts) == 1
return counts.pop()
def get_getReplyFromLedger_call_count():
return get_method_call_count(
next(iter(txnPoolNodeSet)).getReplyFromLedger)
def get_recordAndPropagate_call_count():
return get_method_call_count(
next(iter(txnPoolNodeSet)).recordAndPropagate)
def get_last_returned_val():
rvs = []
for node in txnPoolNodeSet:
rv = getAllReturnVals(node, node.getReplyFromLedger)
rvs.append(rv[0])
# All items are same in the list
assert rvs.count(rvs[0]) == len(txnPoolNodeSet)
return rvs[0]
# Send a request
rlc1 = get_getReplyFromLedger_call_count()
rpc1 = get_recordAndPropagate_call_count()
req1, = sendReqsToNodesAndVerifySuffReplies(looper, wallet1, client1, 1)
rlc2 = get_getReplyFromLedger_call_count()
rpc2 = get_recordAndPropagate_call_count()
assert rlc2 - rlc1 == 1 # getReplyFromLedger was called
assert rpc2 - rpc1 == 1 # recordAndPropagate was called
r1 = get_last_returned_val()
assert r1 is None # getReplyFromLedger returned None since had not seen request
req2, = sendReqsToNodesAndVerifySuffReplies(looper, wallet1, client1, 1)
assert req2.reqId != req1.reqId
rlc3 = get_getReplyFromLedger_call_count()
rpc3 = get_recordAndPropagate_call_count()
assert rlc3 - rlc2 == 1 # getReplyFromLedger was called again
assert rpc3 - rpc2 == 1 # recordAndPropagate was called again
r2 = get_last_returned_val()
assert r2 is None # getReplyFromLedger returned None since had not seen request
# Reply for the first request, which is going to be sent again
rep1 = client1.getReply(req1.identifier, req1.reqId)
# Clear the client so that test waits for client getting reply
client1.inBox.clear()
client1.txnLog.reset()
# Client re-sending request
req3, = send_signed_requests(client1, [
req1,
])
waitForSufficientRepliesForRequests(looper, client1, requests=[
req3,
])
assert req3.reqId == req1.reqId
rlc4 = get_getReplyFromLedger_call_count()
rpc4 = get_recordAndPropagate_call_count()
assert rlc4 - rlc3 == 1 # getReplyFromLedger was called again
assert rpc4 - rpc3 == 0 # recordAndPropagate was not called
r3 = get_last_returned_val()
assert r3 is not None # getReplyFromLedger did not return None this time since had seen request
rep3 = client1.getReply(req3.identifier, req3.reqId)
# Since txnTime is not stored in ledger and reading from ledger return
# all possible fields from transactions
rep3 = {k: v for k, v in rep3[0].items() if v is not None}
rep1 = {k: v for k, v in rep1[0].items() if k in rep3}
assert rep3 == rep1 # The reply client got is same as the previous one
