def test_application_cancel(self):
"""
Test if the supplychain processor can cancel an application.
"""
try:
validator = self.validator
factory = self.factory
record_id = "serial number"
agent_pub_key = factory.public_key
application_addr = Addressing.application_address(record_id)
# 1. -> Send a set transaction
# <- Expect a state get request
validator.send(
factory.create_application_cancel_tp_process_request(
record_id, agent_pub_key, Application.OWNER))
# test for application existance
received = self.expect_get([application_addr])
application = factory.create_application(record_id, agent_pub_key,
Application.OWNER,
Application.OPEN)
self.respond_get(received, [(application_addr, application)])
# Update application
application.status = Application.CANCELED
received = self.expect_set([(application_addr, application)])
self.respond_set(received, [application_addr])
self.expect_ok()
except Exception:
LOGGER.exception("test_application_cancel exception")
raise
def _application_cancel(self, state, originator, data):
txn_data = ApplicationCancelPayload()
txn_data.ParseFromString(data)
application_addr = Addressing.application_address(
txn_data.record_identifier)
state_items = self._get(state, [application_addr])
# check that the application exists
applications = state_items.get(application_addr, None)
application = self._find_application(
applications, txn_data.applicant, txn_data.record_identifier,
txn_data.type)
if application is None:
raise InvalidTransaction("Application does not exists.")
# verify the txn signer is qualified to accept the application
if application.applicant != originator:
raise InvalidTransaction("Only Applicant can cancel Application.")
# update the application
application.status = Application.CANCELED
# send back the updated application list
self._set(state, [(application_addr, applications)])
def _application_cancel(self, state, originator, data):
txn_data = ApplicationCancelPayload()
txn_data.ParseFromString(data)
application_addr = Addressing.application_address(
txn_data.record_identifier)
state_items = self._get(state, [application_addr])
# check that the application exists
applications = state_items.get(application_addr, None)
application = self._find_application(applications, txn_data.applicant,
txn_data.record_identifier,
txn_data.type)
if application is None:
raise InvalidTransaction("Application does not exists.")
# verify the txn signer is qualified to accept the application
if application.applicant != originator:
raise InvalidTransaction("Only Applicant can cancel Application.")
# update the application
application.status = Application.CANCELED
# send back the updated application list
self._set(state, [(application_addr, applications)])
def _application_accept(self, state, originator, data):
txn_data = ApplicationAcceptPayload()
txn_data.ParseFromString(data)
record_addr = Addressing.record_address(txn_data.record_identifier)
application_addr = Addressing.application_address(
txn_data.record_identifier)
state_items = self._get(state, [application_addr, record_addr])
# check that the application exists
applications = state_items.get(application_addr, None)
application = self._find_application(applications, txn_data.applicant,
txn_data.record_identifier,
txn_data.type)
if application is None:
raise InvalidTransaction("Application does not exists.")
# check that the recorf exists
records = state_items.get(record_addr, None)
record = self._find_record(records, application.record_identifier)
if record is None:
raise InvalidTransaction("Record does not exists.")
if record.final:
raise InvalidTransaction("Record is final, no updates can be " +
"made.")
# verify the txn signer is qualified to accept the application
if application.type == Application.OWNER:
owner = record.owners[len(record.owners) - 1]
if owner.agent_identifier != originator:
raise InvalidTransaction(
"Application can only be accepted by owner.")
elif application.type == Application.CUSTODIAN:
custodian = record.custodians[len(record.custodians) - 1]
if custodian.agent_identifier != originator:
raise InvalidTransaction(
"Application can only be accepted by custodian.")
else:
raise InvalidTransaction("Invalid application type.")
# update the application
application.status = Application.ACCEPTED
# update the record
if application.type == Application.OWNER:
agent_record = record.owners.add()
elif application.type == Application.CUSTODIAN:
agent_record = record.custodians.add()
agent_record.agent_identifier = application.applicant
agent_record.start_time = txn_data.timestamp
# send back the updated application list
self._set(state, [(application_addr, applications),
(record_addr, records)])
def _application_accept(self, state, originator, data):
txn_data = ApplicationAcceptPayload()
txn_data.ParseFromString(data)
record_addr = Addressing.record_address(txn_data.record_identifier)
application_addr = Addressing.application_address(
txn_data.record_identifier)
state_items = self._get(state, [application_addr, record_addr])
# check that the application exists
applications = state_items.get(application_addr, None)
application = self._find_application(
applications, txn_data.applicant, txn_data.record_identifier,
txn_data.type)
if application is None:
raise InvalidTransaction("Application does not exists.")
# check that the recorf exists
records = state_items.get(record_addr, None)
record = self._find_record(records, application.record_identifier)
if record is None:
raise InvalidTransaction("Record does not exists.")
if record.final:
raise InvalidTransaction("Record is final, no updates can be " +
"made.")
# verify the txn signer is qualified to accept the application
if application.type == Application.OWNER:
owner = record.owners[len(record.owners) - 1]
if owner.agent_identifier != originator:
raise InvalidTransaction(
"Application can only be accepted by owner.")
elif application.type == Application.CUSTODIAN:
custodian = record.custodians[len(record.custodians) - 1]
if custodian.agent_identifier != originator:
raise InvalidTransaction(
"Application can only be accepted by custodian.")
else:
raise InvalidTransaction("Invalid application type.")
# update the application
application.status = Application.ACCEPTED
# update the record
if application.type == Application.OWNER:
agent_record = record.owners.add()
elif application.type == Application.CUSTODIAN:
agent_record = record.custodians.add()
agent_record.agent_identifier = application.applicant
agent_record.start_time = txn_data.timestamp
# send back the updated application list
self._set(state, [(application_addr, applications),
(record_addr, records)])
def application_create(self, record_identifier, application_type,
terms="", creation_time=None, wait=None):
outputs = [Addressing.application_address(record_identifier)]
inputs = outputs + [Addressing.agent_address(self.public_key),
Addressing.record_address(record_identifier)]
return self._send_txn(
SupplyChainPayload.APPLICATION_CREATE,
ApplicationCreatePayload(
record_identifier=record_identifier,
creation_time=creation_time or int(time.time()),
type=application_type,
terms=terms),
inputs=inputs, outputs=outputs, wait=wait)
def application_cancel(self, record_identifier, application_type,
wait=None):
outputs = [Addressing.application_address(record_identifier),
Addressing.record_address(record_identifier)]
inputs = outputs + [Addressing.agent_address(self.public_key),
Addressing.record_address(record_identifier)]
return self._send_txn(
SupplyChainPayload.APPLICATION_CANCEL,
ApplicationCancelPayload(
record_identifier=record_identifier,
applicant=self._public_key,
type=application_type),
inputs=inputs, outputs=outputs, wait=wait)
def test_create_application(self):
"""
Test if the supplychain processor can create a application.
"""
try:
validator = self.validator
factory = self.factory
record_id = "serial number"
record_addr = Addressing.record_address(record_id)
agent_pub_key = factory.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
application_addr = Addressing.application_address(record_id)
timestamp = int(time.time())
terms = "Please take this."
# 1. -> Send a set transaction
# <- Expect a state get request
validator.send(factory.create_application_tp_process_request(
agent_pub_key,
record_id,
timestamp,
Application.OWNER,
terms))
# test for record existance
received = self.expect_get(
[agent_addr, application_addr, record_addr])
agent = factory.create_agent(agent_pub_key)
record = factory.create_record(record_id)
self.respond_get(received,
[(agent_addr, agent),
(application_addr, None),
(record_addr, record)])
# Expect test for existance
application = factory.create_application(
record_id,
agent_pub_key,
Application.OWNER,
Application.OPEN,
timestamp,
terms)
received = self.expect_set([(application_addr, application)])
self.respond_set(received, [application_addr])
self.expect_ok()
except Exception:
LOGGER.exception("test_create_application exception")
raise
def test_application_accept(self):
"""
Test if the supplychain processor can create a application.
"""
try:
validator = self.validator
factory = self.factory
applicant_id = "applicant pub key"
record_id = "serial number"
record_addr = Addressing.record_address(record_id)
agent_pub_key = factory.public_key
application_addr = Addressing.application_address(record_id)
timestamp = int(time.time())
# 1. -> Send a set transaction
# <- Expect a state get request
validator.send(
factory.create_application_accept_tp_process_request(
record_id,
applicant_id,
Application.OWNER,
timestamp))
# test for application and record existance
received = self.expect_get([application_addr, record_addr])
application = factory.create_application(
record_id,
applicant_id,
Application.OWNER,
Application.OPEN)
record = factory.create_record(record_id)
factory.add_agent_record(record.owners, agent_pub_key)
self.respond_get(received,
[(application_addr, application),
(record_addr, record)])
# Update record and application
application.status = Application.ACCEPTED
factory.add_agent_record(record.owners, applicant_id, timestamp)
received = self.expect_set(
[(application_addr, application),
(record_addr, record)])
self.respond_set(received,
[application_addr, record_addr])
self.expect_ok()
except Exception:
LOGGER.exception("test_application_accept exception")
raise
def application_get(self, record_identifier, applicant, application_type):
address = Addressing.application_address(record_identifier)
result = self._send_get("state/{}".format(address))
try:
data = self._get_result_data(result)
applications = _decode_application_container(data)
return next(
(app for app in applications.entries
if app.record_identifier == record_identifier and
app.applicant == applicant and app.type == application_type),
None)
except BaseException:
return None
def application_accept(self, record_identifier,
applicant, application_type,
timestamp=None, wait=None):
outputs = [Addressing.application_address(record_identifier),
Addressing.record_address(record_identifier)]
inputs = outputs + [Addressing.agent_address(self.public_key),
Addressing.record_address(record_identifier)]
return self._send_txn(
SupplyChainPayload.APPLICATION_ACCEPT,
ApplicationAcceptPayload(
record_identifier=record_identifier,
applicant=applicant,
type=application_type,
timestamp=timestamp or time.time()),
inputs=inputs, outputs=outputs, wait=wait)
def application_get(self, record_identifier, applicant,
application_type):
address = Addressing.application_address(record_identifier)
result = self._send_get("state/{}".format(address))
try:
data = self._get_result_data(result)
applications = _decode_application_container(data)
return next((app for app in applications.entries
if app.record_identifier == record_identifier and
app.applicant == applicant and
app.type == application_type
), None)
except BaseException:
return None
def create_application_cancel_tp_process_request(self,
record_id,
applicant_id,
application_type):
record_addr = Addressing.record_address(record_id)
agent_pub_key = self.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
application_addr = Addressing.application_address(record_id)
inputs = [agent_addr, application_addr, record_addr]
outputs = [application_addr]
return self.create_tp_process_request(
SupplyChainPayload.APPLICATION_CANCEL,
ApplicationCancelPayload(record_identifier=record_id,
applicant=applicant_id,
type=application_type),
inputs, outputs)
def _application_create(self, state, originator, data):
txn_data = ApplicationCreatePayload()
txn_data.ParseFromString(data)
agent_addr = Addressing.agent_address(originator)
record_addr = Addressing.record_address(txn_data.record_identifier)
application_addr = Addressing.application_address(
txn_data.record_identifier)
state_items = self._get(state,
[agent_addr, application_addr, record_addr])
# check that the agent and record exists
agents = state_items.get(agent_addr, None)
if self._find_agent(agents, originator) is None:
raise InvalidTransaction("Agent is not registered.")
records = state_items.get(record_addr, None)
record = self._find_record(records, txn_data.record_identifier)
if record is None:
raise InvalidTransaction("Record does not exist.")
if record.final:
raise InvalidTransaction("Record is final, no updates can be " +
"proposed.")
# check that the application does not exists
applications = state_items.get(application_addr,
ApplicationContainer())
application = self._find_application(applications, originator,
txn_data.record_identifier,
txn_data.type)
if application is not None:
raise InvalidTransaction("Application already exists.")
# create the new application
application = applications.entries.add()
application.record_identifier = txn_data.record_identifier
application.applicant = originator
application.creation_time = txn_data.creation_time
application.type = txn_data.type
application.status = Application.OPEN
application.terms = txn_data.terms
# send back the updated application list
self._set(state, [(application_addr, applications)])
def test_create_application(self):
"""
Test if the supplychain processor can create a application.
"""
try:
validator = self.validator
factory = self.factory
record_id = "serial number"
record_addr = Addressing.record_address(record_id)
agent_pub_key = factory.public_key
agent_addr = Addressing.agent_address(agent_pub_key)
application_addr = Addressing.application_address(record_id)
timestamp = int(time.time())
terms = "Please take this."
# 1. -> Send a set transaction
# <- Expect a state get request
validator.send(
factory.create_application_tp_process_request(
agent_pub_key, record_id, timestamp, Application.OWNER,
terms))
# test for record existance
received = self.expect_get(
[agent_addr, application_addr, record_addr])
agent = factory.create_agent(agent_pub_key)
record = factory.create_record(record_id)
self.respond_get(received, [(agent_addr, agent),
(application_addr, None),
(record_addr, record)])
# Expect test for existance
application = factory.create_application(record_id, agent_pub_key,
Application.OWNER,
Application.OPEN,
timestamp, terms)
received = self.expect_set([(application_addr, application)])
self.respond_set(received, [application_addr])
self.expect_ok()
except Exception:
LOGGER.exception("test_create_application exception")
raise
def _application_create(self, state, originator, data):
txn_data = ApplicationCreatePayload()
txn_data.ParseFromString(data)
agent_addr = Addressing.agent_address(originator)
record_addr = Addressing.record_address(txn_data.record_identifier)
application_addr = Addressing.application_address(
txn_data.record_identifier)
state_items = self._get(state,
[agent_addr, application_addr, record_addr])
# check that the agent and record exists
agents = state_items.get(agent_addr, None)
if self._find_agent(agents, originator) is None:
raise InvalidTransaction("Agent is not registered.")
records = state_items.get(record_addr, None)
record = self._find_record(records, txn_data.record_identifier)
if record is None:
raise InvalidTransaction("Record does not exist.")
if record.final:
raise InvalidTransaction("Record is final, no updates can be " +
"proposed.")
# check that the application does not exists
applications = state_items.get(application_addr,
ApplicationContainer())
application = self._find_application(
applications, originator, txn_data.record_identifier,
txn_data.type)
if application is not None:
raise InvalidTransaction("Application already exists.")
# create the new application
application = applications.entries.add()
application.record_identifier = txn_data.record_identifier
application.applicant = originator
application.creation_time = txn_data.creation_time
application.type = txn_data.type
application.status = Application.OPEN
application.terms = txn_data.terms
# send back the updated application list
self._set(state, [(application_addr, applications)])
def test_application_accept(self):
"""
Test if the supplychain processor can create a application.
"""
try:
validator = self.validator
factory = self.factory
applicant_id = "applicant pub key"
record_id = "serial number"
record_addr = Addressing.record_address(record_id)
agent_pub_key = factory.public_key
application_addr = Addressing.application_address(record_id)
timestamp = int(time.time())
# 1. -> Send a set transaction
# <- Expect a state get request
validator.send(
factory.create_application_accept_tp_process_request(
record_id, applicant_id, Application.OWNER, timestamp))
# test for application and record existance
received = self.expect_get([application_addr, record_addr])
application = factory.create_application(record_id, applicant_id,
Application.OWNER,
Application.OPEN)
record = factory.create_record(record_id)
factory.add_agent_record(record.owners, agent_pub_key)
self.respond_get(received, [(application_addr, application),
(record_addr, record)])
# Update record and application
application.status = Application.ACCEPTED
factory.add_agent_record(record.owners, applicant_id, timestamp)
received = self.expect_set([(application_addr, application),
(record_addr, record)])
self.respond_set(received, [application_addr, record_addr])
self.expect_ok()
except Exception:
LOGGER.exception("test_application_accept exception")
raise
def application_cancel(self,
record_identifier,
application_type,
wait=None):
outputs = [
Addressing.application_address(record_identifier),
Addressing.record_address(record_identifier)
]
inputs = outputs + [
Addressing.agent_address(self.public_key),
Addressing.record_address(record_identifier)
]
return self._send_txn(SupplyChainPayload.APPLICATION_CANCEL,
ApplicationCancelPayload(
record_identifier=record_identifier,
applicant=self._public_key,
type=application_type),
inputs=inputs,
outputs=outputs,
wait=wait)
def application_create(self,
record_identifier,
application_type,
terms="",
creation_time=None,
wait=None):
outputs = [Addressing.application_address(record_identifier)]
inputs = outputs + [
Addressing.agent_address(self.public_key),
Addressing.record_address(record_identifier)
]
return self._send_txn(
SupplyChainPayload.APPLICATION_CREATE,
ApplicationCreatePayload(record_identifier=record_identifier,
creation_time=creation_time
or int(time.time()),
type=application_type,
terms=terms),
inputs=inputs,
outputs=outputs,
wait=wait)
def test_application_cancel(self):
"""
Test if the supplychain processor can cancel an application.
"""
try:
validator = self.validator
factory = self.factory
record_id = "serial number"
agent_pub_key = factory.public_key
application_addr = Addressing.application_address(record_id)
# 1. -> Send a set transaction
# <- Expect a state get request
validator.send(
factory.create_application_cancel_tp_process_request(
record_id,
agent_pub_key,
Application.OWNER))
# test for application existance
received = self.expect_get([application_addr])
application = factory.create_application(
record_id,
agent_pub_key,
Application.OWNER,
Application.OPEN)
self.respond_get(
received,
[(application_addr, application)])
# Update application
application.status = Application.CANCELED
received = self.expect_set([(application_addr, application)])
self.respond_set(received, [application_addr])
self.expect_ok()
except Exception:
LOGGER.exception("test_application_cancel exception")
raise
def application_accept(self,
record_identifier,
applicant_public_key,
application_type,
timestamp=None,
wait=None):
outputs = [
Addressing.application_address(record_identifier),
Addressing.record_address(record_identifier)
]
inputs = outputs + [
Addressing.agent_address(self.public_key),
Addressing.record_address(record_identifier)
]
return self._send_txn(SupplyChainPayload.APPLICATION_ACCEPT,
ApplicationAcceptPayload(
record_identifier=record_identifier,
applicant=applicant_public_key,
type=application_type,
timestamp=timestamp or int(time.time())),
inputs=inputs,
outputs=outputs,
wait=wait)
