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)
