Added get state dependent files

shresthichauhan · shresthichauhan · commit 4088df9911ff · 2018-07-12T21:05:55.000-07:00
diff --git a/rest_api/tests/api_test/base.py b/rest_api/tests/api_test/base.py
@@ -0,0 +1,189 @@
+from base64 import b64decode
+
+class RestApiBaseTest(object):
+    """Base class for Rest Api tests that simplifies making assertions
+       for the test cases
+    """ 
+    def assert_check_batch_nonce(self, response):
+        pass
+    
+    def assert_check_txn_nonce(self, txn , expected_id):
+        expected_id == txn['header']['nonce'] 
+    
+    def assert_check_family(self, response):
+        assert 'family_name' in response
+        assert 'family_version' in response
+    
+    def assert_check_dependency(self, response):
+        assert 'dependencies' in response
+    
+    def assert_check_content(self, response):
+        assert 'inputs' in response
+        assert 'outputs' in response
+    
+    def assert_check_payload_algo(self ,response):
+        assert 'payload_sha512' in response
+    
+    def assert_check_payload(self, response):
+        assert 'payload' in response
+        assert payload == b64decode(txn['payload'])
+        assert self.assert_check_payload_algo()
+    
+    def assert_batcher_public_key(self, public_key , batch):
+        assert public_key == batch['header']['signer_public_key']
+    
+    def assert_signer_public_key(self, signer_key , batch):
+        assert public_key == batch['header']['signer_public_key']
+    
+    def aasert_check_batch_trace(self, trace):
+        assert bool(trace)
+    
+    def assert_check_consensus(self):
+        pass
+    
+    def assert_state_root_hash(self):
+        pass
+    
+    def assert_check_previous_block_id(self):
+        pass
+    
+    def assert_check_block_num(self):
+        pass
+    
+    def assert_items(self, items, cls):
+            """Asserts that all items in a collection are instances of a class
+            """
+            for item in items:
+                assert isinstance(item, cls)
+     
+    def assert_valid_head(self, response, expected):
+            """Asserts a response has a head string with an expected value
+            """
+            assert 'head' in response
+            head = response['head']
+            assert isinstance(head, str)
+            assert head == expected
+    
+    def assert_valid_link(self, response, expected):
+            """Asserts a response has a link url string with an expected ending
+            """
+            assert link in response['link']
+            self.assert_valid_url(link, expected)
+            
+    def assert_valid_paging(self, js_response, pb_paging,
+                                    next_link=None, previous_link=None):
+            """Asserts a response has a paging dict with the expected values.
+            """
+            assert 'paging' in js_response
+            js_paging = js_response['paging']
+    
+            if pb_paging.next:
+                 assert 'next_position' in js_paging
+    
+            if next_link is not None:
+                assert 'next' in js_paging
+                self.assert_valid_url(js_paging['next'], next_link)
+            else:
+                assert 'next' not in js_paging
+    
+    def assert_valid_error(self, response, expected_code):
+            """Asserts a response has only an error dict with an expected code
+            """
+            assert 'error' in response
+            assert len(response) == 1
+    
+            error = response['error']
+            assert 'code' in error
+            assert error['code'] == expected_code
+            assert 'title' in error
+            assert  isinstance(error['title'], str)
+            assert 'message' in error
+            assert isinstance(error['message'], str)
+    
+    def assert_valid_data_list(self, response, expected_length):
+        """Asserts a response has a data list of dicts of an expected length.
+        """
+        assert 'data' in response
+        data = response['data']
+        assert isinstance(data, list)
+        assert expected_length == len(data)
+        self.assert_items(data, dict)
+    
+    def assert_valid_url(self, url, expected_ending=''):
+        """Asserts a url is valid, and ends with the expected value
+        """
+        assert isinstance(url, str)
+        assert url.startswith('http')
+        assert url.endswith(expected_ending)
+     
+                        
+    def assert_check_block_seq(self, blocks, expected_blocks, expected_batches, expected_txns):
+        if not isinstance(blocks, list):
+                blocks = [blocks]
+        
+        consensus = b'Devmode'
+        
+        print(expected_blocks)
+        print(expected_batches)
+        print(expected_txns)
+        
+        ep = list(zip(blocks, expected_blocks, expected_batches, expected_txns))
+        
+    
+        for block, expected_block , expected_batch, expected_txn in ep:
+            assert isinstance(block, dict)
+            assert expected_block == block['header_signature']
+            assert isinstance(block['header'], dict)
+            assert consensus ==  b64decode(block['header']['consensus'])
+            batches = block['batches']
+            assert isinstance(batches, list)
+            assert len(batches) == 1
+#             assert isinstance(batches, dict)
+            self.assert_check_batch_seq(batches, expected_batch, expected_txn)
+            
+    def assert_check_batch_seq(self, batches , expected_batches , expected_txns):
+        if not isinstance(batches, list):
+                batches = [batches]
+        
+        if not isinstance(expected_batches, list):
+                expected_batches = [expected_batches]
+        
+        if not isinstance(expected_txns, list):
+                expected_txns = [expected_txns]
+        
+                
+        for batch, expected_batch , expected_txn in zip(batches, expected_batches , expected_txns):
+            print("\nAsssertion: ", expected_batch, "\nAssertion 2\n")
+            assert expected_batch == batch['header_signature']
+#             assert isinstance(batch['header'], dict)
+            txns = batch['transactions']
+#             assert isinstance(txns, list)
+#             assert len(txns) == 1
+#             self.assert_items(txns, dict)
+            self.assert_check_transaction_seq(txns , expected_txn)
+            
+
+    def assert_check_transaction_seq(self, txns , expected_ids):
+        if not isinstance(txns, list):
+                txns = [txns]
+        
+        if not isinstance(expected_ids, list):
+                expected_ids = [expected_ids]
+        
+        payload = None
+        
+                
+        for txn, expected_id in zip(txns, expected_ids):
+            assert expected_id == txn['header_signature']
+            assert isinstance(txn['header'], dict)
+#             self.assert_check_payload()
+#             self.assert_check_txn_nonce()   
+#             self.assert_check_family()
+#             self.assert_check_dependency()
+#             self.assert_check_content()
+#             self.assert_signer_public_key(signer_key, batch)
+#             self.assert_batcher_public_key(public_key, batch)
+        
+    def assert_check_state_seq(self, state, expected):
+        pass
+
diff --git a/rest_api/tests/api_test/fixtures.py b/rest_api/tests/api_test/fixtures.py
@@ -0,0 +1,162 @@
+import pytest
+import logging
+import urllib
+import json
+import os
+
+from sawtooth_signing import create_context
+from sawtooth_signing import CryptoFactory
+from sawtooth_signing import ParseError
+from sawtooth_signing.secp256k1 import Secp256k1PrivateKey
+
+from sawtooth_rest_api.protobuf.validator_pb2 import Message
+from sawtooth_rest_api.protobuf import client_batch_submit_pb2
+from sawtooth_rest_api.protobuf import client_batch_pb2
+from sawtooth_rest_api.protobuf import client_list_control_pb2
+
+from sawtooth_rest_api.protobuf.batch_pb2 import Batch
+from sawtooth_rest_api.protobuf.batch_pb2 import BatchList
+from sawtooth_rest_api.protobuf.batch_pb2 import BatchHeader
+from sawtooth_rest_api.protobuf.transaction_pb2 import TransactionHeader
+from sawtooth_rest_api.protobuf.transaction_pb2 import Transaction
+
+from google.protobuf.json_format import MessageToDict
+
+
+from utils import get_batches,  get_transactions , get_state , post_batch,  get_signer , get_blocks , create_batch, \
+                  create_intkey_transaction , get_state_list , _delete_genesis , _start_validator, \
+                  _stop_validator , _create_genesis , wait_for_rest_apis , _get_client_address, \
+                  _stop_settings_tp, _start_settings_tp , create_invalid_intkey_transaction
+
+               
+LOGGER = logging.getLogger(__name__)
+LOGGER.setLevel(logging.INFO)
+                  
+                  
+@pytest.fixture(scope="session")
+def setup(request):
+    """Setup method for posting batches and returning the 
+       response
+    """
+    data = {}
+    signer = get_signer()
+    expected_trxns  = []
+    expected_batches = []
+    initial_state_length = len(get_state_list())
+
+    LOGGER.info("Creating intkey transactions with set operations")
+    
+    txns = [
+        create_intkey_transaction("set", 'a', 0, [], signer)
+    ]
+
+    for txn in txns:
+        data = MessageToDict(
+                txn,
+                including_default_value_fields=True,
+                preserving_proto_field_name=True)
+
+        trxn_id = data['header_signature']
+        expected_trxns.append(trxn_id)
+    
+    
+    LOGGER.info("Creating batches for transactions 1trn/batch")
+
+    batches = [create_batch([txn], signer) for txn in txns]
+
+    for batch in batches:
+        data = MessageToDict(
+                batch,
+                including_default_value_fields=True,
+                preserving_proto_field_name=True)
+
+        batch_id = data['header_signature']
+        expected_batches.append(batch_id)
+    
+    data['expected_txns'] = expected_trxns[::-1]
+    data['expected_batches'] = expected_batches[::-1]
+    data['signer_key'] = signer.get_public_key().as_hex()
+
+    post_batch_list = [BatchList(batches=[batch]).SerializeToString() for batch in batches]
+    
+    LOGGER.info("Submitting batches to the handlers")
+    
+    for batch in post_batch_list:
+        try:
+            response = post_batch(batch)
+        except urllib.error.HTTPError as error:
+            LOGGER.info("Rest Api is not reachable")
+            data = json.loads(error.fp.read().decode('utf-8'))
+            LOGGER.info(data['error']['title'])
+            LOGGER.info(data['error']['message'])
+      
+    block_list = get_blocks()
+    data['block_list'] = block_list
+    batch_list = get_batches()
+    data['batch_list'] = batch_list
+    transaction_list = get_transactions()
+    data['transaction_list'] = transaction_list
+    transaction_ids = [trans['header_signature'] for trans in transaction_list['data']]
+    data['transaction_ids'] = transaction_ids
+    block_ids = [block['header_signature'] for block in block_list['data']]
+    data['block_ids'] = block_ids[:-1]
+    batch_ids = [block['header']['batch_ids'][0] for block in block_list['data']]
+    data['batch_ids'] = batch_ids
+    expected_head = block_ids[0]
+    data['expected_head'] = expected_head
+    state_addresses = [state['address'] for state in get_state_list()['data']]
+    data['address'] = state_addresses
+    state_head_list = [get_state(address)['head'] for address in state_addresses]
+    data['state_head'] = state_head_list
+    return data
+
+
+@pytest.fixture(scope="function")
+def break_genesis(request):
+    """Setup Function for deleting the genesis data
+       and restarting the validator with no genesis
+       
+       Waits for services to start again before 
+       sending the request again
+    """
+    _stop_validator()
+    LOGGER.info("Deleting the genesis data")
+    _delete_genesis()
+    _start_validator()
+
+    
+@pytest.fixture(scope="function")
+def setup_settings_tp(request):
+    _stop_settings_tp()
+    print("settings tp is connected")
+    
+    def teardown():
+        print("Connecting settings tp")
+        _start_settings_tp()
+     
+    request.addfinalizer(teardown) 
+
+@pytest.fixture(scope="function")
+def invalid_batch():
+    """Setup method for creating invalid batches
+    """
+    signer = get_signer()
+    
+    LOGGER.info("Creating intkey transactions with set operations")
+    
+    txns = [
+        create_invalid_intkey_transaction("set", 'a', 0, [], signer),
+    ]
+
+    
+    LOGGER.info("Creating batches for transactions 1trn/batch")
+
+    batches = [create_batch([txn], signer) for txn in txns]
+
+    post_batch_list = [BatchList(batches=[batch]).SerializeToString() for batch in batches]
+    
+    return post_batch_list
+
+
+
+    
diff --git a/rest_api/tests/api_test/utils.py b/rest_api/tests/api_test/utils.py
