def test_instantiate(self): start_test_env() time.sleep(5) client = Client() chain = client.new_chain(CHAIN_ID) client.set_state_store(file_key_value_store(self.kv_store_path)) chain.add_peer(Peer()) submitter = get_submitter() signing_identity = submitter.signing_identity cc_instantiate_req = create_instantiation_proposal_req( CHAINCODE_NAME, CHAINCODE_PATH, CHAINCODE_VERSION, signing_identity, args=['a', '100', 'b', '200']) queue = Queue(1) chain.instantiate_chaincode(cc_instantiate_req) \ .subscribe(lambda x: queue.put(x)) prop = queue.get() proposal_bytes = prop.proposal_bytes sig = prop.signature # verify the signature against the hash of proposal_bytes digest = signing_identity.msp.crypto_suite.hash(proposal_bytes) self.assertEqual( signing_identity.verify(str.encode(digest.hexdigest()), sig), True) shutdown_test_env()
def test_install_chaincode_success(self): self.client.state_store = file_key_value_store(self.kv_store_path) with open(self.peer0Org1_tls_certs) as f: pem = f.read() opts = ( ('grpc.ssl_target_name_override', self.peer0Org1_tls_hostname),) peer0_org1 = create_peer(endpoint=self.peer0Org1_req_endpoint, pem=pem, opts=opts) org1_admin = get_peer_org_admin(self.client, 'org1.example.com') crypto = ecies() tran_prop_req = create_tx_prop_req(CC_INSTALL, CC_PATH, CC_TYPE_GOLANG, CC_NAME, CC_VERSION) tx_context = create_tx_context(org1_admin, crypto, tran_prop_req) queue = Queue(1) sleep(5) response = self.client.send_install_proposal(tx_context, [peer0_org1]) response.subscribe( on_next=lambda x: queue.put(x), on_error=lambda x: queue.put(x) ) res = queue.get(timeout=5) proposal_response, _ = res[0][0] self.assertEqual(proposal_response.response.status, 200)
def test_async_write(self): """Test for async setting.""" key_value_store = file_key_value_store(self.path) queue = Queue(1) key_value_store.async_set_value(self.key, self.value) \ .subscribe(lambda x: queue.put(x)) self.assertTrue(queue.get(5))
def test_create_new_chain(self): client = Client() client.set_state_store(file_key_value_store(self.kv_store_path)) test_chain = client.new_chain('test') self.assertEqual(test_chain, client.get_chain('test')) no_chain = client.get_chain('test1') self.assertIsNone(no_chain)
def test_async_read(self): """Test for async getting.""" key_value_store = file_key_value_store(self.path) key_value_store.set_value(self.key, self.value) queue = Queue(1) key_value_store.async_get_value(self.key) \ .subscribe(lambda x: queue.put(x)) self.assertEqual(queue.get(5), self.value)
def test_get_submitter(self): time.sleep(5) submitter = get_submitter(file_key_value_store(self.kv_store_path)) self.assertTrue(submitter.is_enrolled()) # test the identity object carrying self.assertTrue( submitter.enrollment.cert.startswith( b"-----BEGIN CERTIFICATE-----"))
def test_user_state(self): store = file_key_value_store(self.path) user = User('test_user', 'peerOrg1', store) user.roles = ['test'] ec = ecies() enrollment = Enrollment(ec.generate_private_key(), "dasdasdasdasdasd") user.enrollment = enrollment user1 = User('test_user', 'peerOrg1', store) self.assertTrue(user1.roles == ['test']) self.assertTrue(user1.enrollment.cert == "dasdasdasdasdasd") pub_key = user1.enrollment.private_key.public_key() self.assertTrue( pub_key.public_bytes( encoding=Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo). startswith(b'-----BEGIN PUBLIC KEY'))
def test_install(self): start_test_env() time.sleep(5) client = Client() chain = client.new_chain(CHAIN_ID) client.set_state_store(file_key_value_store(self.kv_store_path)) chain.add_peer(Peer()) submitter = get_submitter() signing_identity = submitter.signing_identity cc_install_req = create_installment_proposal_req( CHAINCODE_NAME, CHAINCODE_PATH, CHAINCODE_VERSION, signing_identity) queue = Queue(1) chain.install_chaincode(cc_install_req) \ .subscribe(lambda x: queue.put(x)) response, _ = queue.get() self.assertEqual(200, response.response.status) shutdown_test_env()
def test_install(self): time.sleep(5) client = Client() chain = client.new_chain(CHAIN_ID) client.set_state_store(file_key_value_store(self.kv_store_path)) chain.add_peer(Peer()) chain.add_orderer(Orderer()) submitter = get_submitter() signing_identity = submitter.signing_identity cc_install_req = create_installment_proposal_req( CHAINCODE_NAME, CHAINCODE_PATH, CHAINCODE_VERSION) queue = Queue(1) chain.install_chaincode(cc_install_req, signing_identity) \ .subscribe(on_next=lambda x: queue.put(x), on_error=lambda x: queue.put(x)) response, _ = queue.get(timeout=5) # TODO: create channel not implement yet self.assertEqual(404, response.status)
def test_create_user(self): store = file_key_value_store(self.path) user = User('test_user', 'peerOrg1', store) self.assertTrue(isinstance(user, User))
def __init__(self, userID, orgName): """ key-value 저장소(./tmp/hfc-kvs)의 key로 User 객체 생성 """ path = os.getcwd() + '/tmp/hfc-kvs' + '/' + userID self._user = User(userID, orgName, file_key_value_store(path))
def test_create_client(self): # TODO impl client = Client() client.set_state_store(file_key_value_store(self.kv_store_path)) self.fail()
def test_write_and_read(self): """Test for setting and getting.""" key_value_store = file_key_value_store(self.path) key_value_store.set_value(self.key, self.value) self.assertEqual(key_value_store.get_value(self.key), self.value)
def test_wrong_path(self): """Test illegal path. """ path = os.path.join(self.base_path, 'wrong-path\0') with self.assertRaises(Exception): file_key_value_store(path)