def test_with_manager_not_in_state():
"""Test creating a user with manager not in state"""
user_key = helper.user.key()
user_id = user_key.public_key
manager_key = helper.user.key()
manager_id = manager_key.public_key
name = helper.user.name()
message = protobuf.user_transaction_pb2.CreateUser(user_id=user_id,
name=name,
metadata=None,
manager_id=manager_id)
inputs, outputs = rbac.user.make_addresses(message=message,
signer_user_id=user_id)
payload = batcher.make_payload(
message=message,
message_type=rbac.user.message_type,
inputs=inputs,
outputs=outputs,
signer_user_id=user_id,
signer_public_key=user_key.public_key,
)
status = rbac.user.send(signer_keypair=user_key, payload=payload)
assert len(status) == 1
assert status[0]["status"] == "INVALID"
def make_payload(self, message, signer_keypair=None):
"""Make a payload for the given message type"""
self.validate(message=message, signer=signer_keypair)
message_type = self.message_type
inputs, outputs = self.make_addresses(
message=message, signer_keypair=signer_keypair
)
inputs = set(inputs)
outputs = set(outputs)
if signer_keypair:
inputs.add(addresser.user.address(object_id=signer_keypair.public_key))
if not outputs.issubset(inputs):
raise ValueError(
"{} output addresses {} not contained in inputs".format(
self.message_type_name,
addresser.parse_addresses(outputs.difference(inputs)),
)
)
return batcher.make_payload(
message=message, message_type=message_type, inputs=inputs, outputs=outputs
)
def test_with_other_signer():
"""Test with signer is neither user nor manager"""
user_key = helper.user.key()
user_id = user_key.public_key
manager_key = helper.user.key()
manager_id = manager_key.public_key
other_id = helper.user.id()
other_key = helper.user.key()
name = helper.user.name()
message = protobuf.user_transaction_pb2.CreateUser(user_id=user_id,
name=name,
metadata=None,
manager_id=manager_id)
inputs, outputs = rbac.user.make_addresses(message=message,
signer_user_id=other_id)
payload = batcher.make_payload(
message=message,
message_type=rbac.user.message_type,
inputs=inputs,
outputs=outputs,
signer_user_id=other_id,
signer_public_key=other_key.public_key,
)
status = rbac.user.send(signer_keypair=other_key, payload=payload)
assert len(status) == 1
assert status[0]["status"] == "INVALID"
def make_payload(self, message, signer_keypair=None):
"""Make a payload for the given message type"""
self.validate(message=message, signer=signer_keypair)
message_type = self.message_type
inputs, outputs = self.make_addresses(message=message,
signer_keypair=signer_keypair)
if has_duplicates(inputs):
raise ValueError("{} inputs duplicated addresses {}".format(
self.message_type_name,
addresser.parse_addresses(duplicates(inputs)),
))
if has_duplicates(outputs):
raise ValueError("{} outputs duplicated addresses {}".format(
self.message_type_name,
addresser.parse_addresses(duplicates(outputs)),
))
if not set(outputs).issubset(set(inputs)):
raise ValueError(
"{} output addresses {} not contained in inputs".format(
self.message_type_name,
addresser.parse_addresses(
set(outputs).difference(set(inputs))),
))
return batcher.make_payload(message=message,
message_type=message_type,
inputs=inputs,
outputs=outputs)
def test_unmake_payload(self):
"""Test the unmake batch function"""
message, message_type, inputs, outputs, signer = self.get_test_inputs()
payload = batcher.make_payload(
message=message, message_type=message_type, inputs=inputs, outputs=outputs
)
messages = batcher.unmake(
batch_object=payload, signer_public_key=signer.public_key
)
self.assertEqual(len(messages), 1)
self.assertEqualMessage(message, messages[0])
def make_payload(self, message, signer_keypair=None):
"""Make a payload for the given message type"""
self.validate(message=message, signer=signer_keypair)
message_type = self.message_type
inputs, outputs = self.make_addresses(message=message,
signer_keypair=signer_keypair)
return batcher.make_payload(message=message,
message_type=message_type,
inputs=inputs,
outputs=outputs)
def get_test_payload(self):
"""Returns a test data payload for testing batcher functions"""
message, message_type, inputs, outputs, signer = self.get_test_inputs()
return (
batcher.make_payload(
message=message,
message_type=message_type,
inputs=inputs,
outputs=outputs,
),
signer,
)
def test_make_payload(self):
"""Test the make payload batch function"""
message, message_type, inputs, outputs, signer = self.get_test_inputs()
payload = batcher.make_payload(
message=message, message_type=message_type, inputs=inputs, outputs=outputs
)
self.assertIsInstance(payload, RBACPayload)
self.assertEqual(payload.message_type, message_type)
self.assertEqual(payload.inputs, inputs)
self.assertEqual(payload.outputs, outputs)
self.assertIsInstance(signer, Key)
self.assertValidPayload(
payload=payload, message=message, message_type=message_type
)
def make_payload(self, message, signer_user_id, signer_keypair):
"""Make a payload for the given message type"""
if not signer_keypair:
raise ValueError(
"{} signer_keypair is required".format(self.message_type_name)
)
if not signer_user_id:
raise ValueError(
"{} signer_user_id is required".format(self.message_type_name)
)
self.validate(
message=message,
signer=Signer(user_id=signer_user_id, public_key=signer_keypair.public_key),
)
message_type = self.message_type
inputs, outputs = self.make_addresses(
message=message, signer_user_id=signer_user_id
)
inputs = set(inputs)
outputs = set(outputs)
inputs.add(addresser.key.address(object_id=signer_keypair.public_key))
inputs.add(addresser.user.address(object_id=signer_user_id))
inputs.add(
addresser.user.key.address(
object_id=signer_user_id, related_id=signer_keypair.public_key
)
)
if not outputs.issubset(inputs):
raise ValueError(
"{} output addresses {} not contained in inputs".format(
self.message_type_name,
addresser.parse_addresses(outputs.difference(inputs)),
)
)
return batcher.make_payload(
message=message,
message_type=message_type,
inputs=inputs,
outputs=outputs,
signer_user_id=signer_user_id,
signer_public_key=signer_keypair.public_key,
)
def test_unmake(self):
"""Test the unmake batch function with a single message"""
message, message_type, inputs, outputs, signer_keypair = self.get_test_inputs()
payload = batcher.make_payload(
message=message,
message_type=message_type,
inputs=inputs,
outputs=outputs,
signer_user_id=message.user_id,
signer_public_key=signer_keypair.public_key,
)
transaction, batch, batch_list, batch_request = batcher.make(
payload=payload, signer_keypair=signer_keypair
)
messages = batcher.unmake(
batch_object=payload, signer_public_key=signer_keypair.public_key
)
self.assertEqual(len(messages), 1)
self.assertEqualMessage(message, messages[0])
messages = batcher.unmake(
batch_object=transaction, signer_public_key=signer_keypair.public_key
)
self.assertEqual(len(messages), 1)
self.assertEqualMessage(message, messages[0])
messages = batcher.unmake(
batch_object=batch, signer_public_key=signer_keypair.public_key
)
self.assertEqual(len(messages), 1)
self.assertEqualMessage(message, messages[0])
messages = batcher.unmake(
batch_object=batch_list, signer_public_key=signer_keypair.public_key
)
self.assertEqual(len(messages), 1)
self.assertEqualMessage(message, messages[0])
messages = batcher.unmake(
batch_object=batch_request, signer_public_key=signer_keypair.public_key
)
self.assertEqual(len(messages), 1)
self.assertEqualMessage(message, messages[0])
def test_with_self_manager(self):
"""Test creating a user with self as manager"""
user_key = helper.user.key()
user_id = user_key.public_key
name = helper.user.name()
message = protobuf.user_transaction_pb2.CreateUser(
user_id=user_id, name=name, metadata=None, manager_id=user_id
)
inputs, outputs = rbac.user.make_addresses(
message=message, signer_keypair=user_key
)
payload = batcher.make_payload(
message=message,
message_type=rbac.user.message_type,
inputs=inputs,
outputs=outputs,
)
_, status = rbac.user.send(signer_keypair=user_key, payload=payload)
self.assertStatusInvalid(status)
