def test_get_receipts(self): """Tests that the TransactionReceiptGetRequestHandler will return a response with the receipt for the transaction requested. """ receipt_store = TransactionReceiptStore(DictDatabase()) receipt = TransactionReceipt(data=[ TransactionReceipt.Data(data_type="dead", data="beef".encode()) ]) receipt_store.put("deadbeef", receipt) handler = ClientReceiptGetRequestHandler(receipt_store) request = ClientReceiptGetRequest( transaction_ids=['deadbeef']).SerializeToString() response = handler.handle('test_conn_id', request) self.assertEqual(HandlerStatus.RETURN, response.status) self.assertEqual(ClientReceiptGetResponse.OK, response.message_out.status) self.assertEqual([receipt], [r for r in response.message_out.receipts]) request = ClientReceiptGetRequest( transaction_ids=['unknown']).SerializeToString() response = handler.handle('test_conn_id', request) self.assertEqual(HandlerStatus.RETURN, response.status) self.assertEqual(ClientReceiptGetResponse.NO_RESOURCE, response.message_out.status)
def _make_receipts(self, results): receipts = [] for result in results: receipt = TransactionReceipt() receipt.data.extend([data for data in result.data]) receipt.state_changes.extend(result.state_changes) receipt.events.extend(result.events) receipt.transaction_id = result.signature receipts.append(receipt) return receipts
def test_chain_update(): """ Test that if there is no fork and only one value is udpated, only that value is in validated in the catch. """ # Set up cache so it does not fork testIdentityObserver = TestIdentityObserver() block1 = testIdentityObserver.create_block() testIdentityObserver._identity_obsever.chain_update(block1, []) testIdentityObserver._identity_cache.get_role("network", "state_root") testIdentityObserver._identity_cache.get_policy( "policy1", "state_root") # Add next block and event that says network was updated. block2 = testIdentityObserver.create_block("abcdef1234567890") event = Event( event_type="identity/update", attributes=[Event.Attribute(key="updated", value="network")]) receipts = TransactionReceipt(events=[event]) testIdentityObserver._identity_obsever.chain_update(block2, [receipts]) identity_view = \ testIdentityObserver._identity_view_factory.create_identity_view( "state_root")
def test_chain_update(self): """ Test that if there is no fork and only one value is updated, only that value is in validated in the catch. """ # Set up cache so it does not fork block1 = self.create_block() self._settings_obsever.chain_update(block1, []) self._settings_cache.get_setting("setting1", "state_root") self.assertNotEqual(self._settings_cache["setting1"], None) # Add next block and event that says network was updated. block2 = self.create_block("abcdef1234567890") event = Event( event_type="settings/update", attributes=[Event.Attribute(key="updated", value="setting1")]) receipts = TransactionReceipt(events=[event]) self._settings_obsever.chain_update(block2, [receipts]) # Check that only "network" was invalidated self.assertEqual(self._settings_cache["setting"], None) # check that the correct values can be fetched from state. settings_view = \ self._settings_view_factory.create_settings_view("state_root") self.assertEqual( self._settings_cache.get_setting("setting1", "state_root"), settings_view.get_setting("setting1"))
def do_chain_update(): block1 = testIdentityObserver.create_block() testIdentityObserver._identity_obsever.chain_update(block1, []) testIdentityObserver._identity_cache.get_role("network", "state_root") testIdentityObserver._identity_cache.get_policy( "policy1", "state_root") assert testIdentityObserver._identity_cache["network"] != None assert testIdentityObserver._identity_cache["policy1"] != None # Add next block and event that says network was updated. block2 = testIdentityObserver.create_block("abcdef1234567890") event = Event( event_type="identity/update", attributes=[Event.Attribute(key="updated", value="network")]) receipts = TransactionReceipt(events=[event]) testIdentityObserver._identity_obsever.chain_update(block2, [receipts]) # Check that only "network" was invalidated assert testIdentityObserver._identity_cache["network"] == None assert testIdentityObserver._identity_cache["policy1"] != None # check that the correct values can be fetched from state. identity_view = \ testIdentityObserver._identity_view_factory.create_identity_view("state_root") assert \ testIdentityObserver._identity_cache.get_role("network", "state_root") == \ identity_view.get_role("network") assert \ testIdentityObserver._identity_cache.get_policy("policy1", "state_root") == \ identity_view.get_policy("policy1")
def test_receipt_store_get_and_set(self): """Tests that we correctly get and set state changes to a ReceiptStore. This test sets a list of receipts and then gets them back, ensuring that the data is the same. """ receipt_store = TransactionReceiptStore(DictDatabase()) receipts = [] for i in range(10): state_changes = [] events = [] data = [] for j in range(10): string = str(j) byte = string.encode() state_changes.append( StateChange(address='a100000' + string, value=byte, type=StateChange.SET)) events.append( Event( event_type="test", data=byte, attributes=[Event.Attribute(key=string, value=string)])) data.append( TransactionReceipt.Data(data_type="test", data=byte)) receipts.append( TransactionReceipt(state_changes=state_changes, events=events, data=data)) for i in range(len(receipts)): receipt_store.put(str(i), receipts[i]) for i in range(len(receipts)): stored_receipt = receipt_store.get(str(i)) self.assertEqual(stored_receipt.state_changes, receipts[i].state_changes) self.assertEqual(stored_receipt.events, receipts[i].events) self.assertEqual(stored_receipt.data, receipts[i].data)
def get(self, txn_id): """Returns the TransactionReceipt Args: txn_id (str): the id of the transaction for which the receipt should be retrieved. Returns: TransactionReceipt: The receipt for the given transaction id. Raises: KeyError: if the transaction id is unknown. """ if txn_id not in self._receipt_db: raise KeyError('Unknown transaction id {}'.format(txn_id)) txn_receipt_bytes = self._receipt_db[txn_id] txn_receipt = TransactionReceipt() txn_receipt.ParseFromString(txn_receipt_bytes) return txn_receipt
def do_tf_events(): gen_data = [ ["test1", "test2"], ["test3"], ["test4", "test5", "test6"], ] event_sets = [[Event(event_type=event_type) for event_type in events] for events in gen_data] receipts = [TransactionReceipt(events=events) for events in event_sets] extractor = ReceiptEventExtractor(receipts) events = extractor.extract([]) assert [] == events events = extractor.extract([ EventSubscription(event_type="test1"), EventSubscription(event_type="test5"), ]) assert events == [event_sets[0][0], event_sets[2][1]]
def test_state_delta_events(self): """Test that sawtooth/state-delta events are generated correctly.""" gen_data = [ [("a", b"a", StateChange.SET), ("b", b"b", StateChange.DELETE)], [("a", b"a", StateChange.DELETE), ("d", b"d", StateChange.SET)], [("e", b"e", StateChange.SET)], ] change_sets = [[ StateChange(address=address, value=value, type=change_type) for address, value, change_type in state_changes ] for state_changes in gen_data] receipts = [ TransactionReceipt(state_changes=state_changes) for state_changes in change_sets ] extractor = ReceiptEventExtractor(receipts) factory = EventFilterFactory() events = extractor.extract([ EventSubscription(event_type="sawtooth/state-delta", filters=[factory.create("address", "a")]), EventSubscription( event_type="sawtooth/state-delta", filters=[ factory.create("address", "[ce]", EventFilter.REGEX_ANY) ], ) ]) self.assertEqual(events, [ Event( event_type="sawtooth/state-delta", attributes=[ Event.Attribute(key="address", value=address) for address in ["e", "d", "a", "b"] ], data=StateChangeList(state_changes=[ change_sets[2][0], change_sets[1][1], change_sets[1][0], change_sets[0][1], ]).SerializeToString(), ) ])
def test_tf_events(self): """Test that tf events are generated correctly.""" gen_data = [ ["test1", "test2"], ["test3"], ["test4", "test5", "test6"], ] event_sets = [[Event(event_type=event_type) for event_type in events] for events in gen_data] receipts = [TransactionReceipt(events=events) for events in event_sets] extractor = ReceiptEventExtractor(receipts) events = extractor.extract([]) self.assertEqual([], events) events = extractor.extract([ EventSubscription(event_type="test1"), EventSubscription(event_type="test5"), ]) self.assertEqual(events, [event_sets[0][0], event_sets[2][1]])
def do_get_receipts(): receipt_store = TransactionReceiptStore(DictDatabase()) receipt = TransactionReceipt( data=["beef".encode()]) receipt_store.put("deadbeef", receipt) handler = ClientReceiptGetRequestHandler(receipt_store) request = ClientReceiptGetRequest( transaction_ids=['deadbeef']).SerializeToString() response = handler.handle('test_conn_id', request) assert HandlerStatus.RETURN == response.status request = ClientReceiptGetRequest( transaction_ids=['unknown']).SerializeToString() response = handler.handle('test_conn_id', request) assert HandlerStatus.RETURN == response.status
def test_get_receipts(): """Tests that the TransactionReceiptGetRequestHandler will return a response with the receipt for the transaction requested. """ receipt_store = TransactionReceiptStore(DictDatabase()) receipt = TransactionReceipt( data=["beef".encode()]) receipt_store.put("deadbeef", receipt) handler = ClientReceiptGetRequestHandler(receipt_store) request = ClientReceiptGetRequest( transaction_ids=['deadbeef']).SerializeToString() response = handler.handle('test_conn_id', request) request = ClientReceiptGetRequest( transaction_ids=['unknown']).SerializeToString() response = handler.handle('test_conn_id', request)
def do_receipt_store_get_and_set(): receipt_store = TransactionReceiptStore(DictDatabase()) receipts = [] for i in range(10): state_changes = [] events = [] data = [] for j in range(10): string = str(j) byte = string.encode() state_changes.append( StateChange( address='a100000' + string, value=byte, type=StateChange.SET)) events.append( Event( event_type="test", data=byte, attributes=[Event.Attribute(key=string, value=string)])) data.append(byte) receipts.append( TransactionReceipt( state_changes=state_changes, events=events, data=data)) for i, receipt in enumerate(receipts): receipt_store.put(str(i), receipt) for i, receipt in enumerate(receipts): stored_receipt = receipt_store.get(str(i)) assert stored_receipt.state_changes == receipt.state_changes