def make(
self, user_id, name, user_name=None, email=None, metadata=None, manager_id=None
):
"""Makes a CreateUser message"""
return user_transaction_pb2.CreateUser(
user_id=user_id, name=name, metadata=metadata, manager_id=manager_id
)
def new_user(header, payload, state):
create_user = user_transaction_pb2.CreateUser()
create_user.ParseFromString(payload.content)
if len(create_user.name) < 5:
raise InvalidTransaction(
"CreateUser txn with name {} is invalid. Users "
"must have names longer than 4 characters.".format(
create_user.name))
if (create_user.user_id == header.signer_public_key
or header.signer_public_key == create_user.manager_id):
user_validator.validate_user_state(create_user, state)
if not create_user.manager_id:
state_change.confirm_new_user(create_user, state)
else:
user_validator.validate_manager_state(create_user, state)
state_change.confirm_new_user(create_user, state,
create_user.manager_id)
else:
raise InvalidTransaction(
"The public key {} that signed this CreateUser txn "
"does not belong to the user or their manager.".format(
header.signer_public_key))
def get_test_inputs(self, message_type=RBACPayload.CREATE_USER):
if message_type == RBACPayload.CREATE_USER:
signer = Key()
message = user_transaction_pb2.CreateUser(name="foobar")
message.user_id = signer.public_key
inputs = [make_user_address(signer.public_key)]
outputs = inputs
return message, message_type, inputs, outputs, signer
else:
raise Exception(
"get_test_payload doesn't yet support {}".format(message_type))
def get_test_inputs(self, message_type=RBACPayload.CREATE_USER):
"""Returns test data inputs for testing batcher functions"""
if message_type == RBACPayload.CREATE_USER:
signer = Key()
message = user_transaction_pb2.CreateUser(name="foobar")
message.user_id = signer.public_key
inputs = [addresser.user.address(message.user_id)]
outputs = inputs
return message, message_type, inputs, outputs, signer
raise Exception("batcher test doesn't support message_type: {}".format(
message_type))
def get_testdata_inputs(self, message_type=RBACPayload.CREATE_USER):
"""Get test data inputs for a create user message"""
if message_type == RBACPayload.CREATE_USER:
signer = Key()
message = user_transaction_pb2.CreateUser(name=self.get_testdata_name())
message.user_id = signer.public_key
inputs = [self.address(signer.public_key)]
outputs = inputs
return message, message_type, inputs, outputs, signer
else:
raise Exception(
"get_testdata_payload doesn't yet support {}".format(message_type)
)
def assertValidPayload(self, payload, message, message_type):
if isinstance(payload, bytes):
decoded = RBACPayload()
decoded.ParseFromString(payload)
payload = decoded
self.assertIsInstance(payload, RBACPayload)
if message_type == RBACPayload.CREATE_USER:
self.assertIsInstance(message, user_transaction_pb2.CreateUser)
self.assertEqual(message_type, RBACPayload.CREATE_USER)
decoded = user_transaction_pb2.CreateUser()
decoded.ParseFromString(payload.content)
self.assertEqual(decoded, message)
self.assertEqual(decoded.name, message.name)
else:
raise Exception(
"assertValidPayload doesn't yet support {}".format(message_type)
)
def create(self,
signer_keypair,
user,
do_batch=True,
do_send=True,
do_get=False):
if not isinstance(signer_keypair, Key):
raise TypeError("Expected signer_keypair to be a Key")
if not isinstance(user, user_state_pb2.User):
raise TypeError(
"Expected user to be a user_state_pb2.User, use make first")
message = user_transaction_pb2.CreateUser(
user_id=user.user_id,
# user_name=user_name,
name=user.name,
metadata=user.metadata,
)
inputs = [make_user_address(user_id=user.user_id)]
if user.manager_id:
message.manager_id = user.manager_id
inputs.append(make_user_address(user_id=user.manager_id))
transaction = self.batch.make_transaction(
message=message,
message_type=RBACPayload.CREATE_USER,
inputs=inputs,
outputs=inputs,
signer_keypair=signer_keypair,
)
if not do_batch:
return transaction
batch = self.batch.make_batch(transaction=transaction)
if not do_send:
return batch
batch_list = self.batch.batch_to_list(batch)
status = self.client.send_batches_get_status(batch_list=batch_list)
if not do_get:
return status
return self.get(user_id=user.user_id)
def assertValidPayload(self, payload, message, message_type):
"""Check a payload the valid representation of a message given its type"""
if isinstance(payload, bytes):
decoded = RBACPayload()
decoded.ParseFromString(payload)
payload = decoded
self.assertIsInstance(payload, RBACPayload)
if message_type == RBACPayload.CREATE_USER:
self.assertIsInstance(message, user_transaction_pb2.CreateUser)
self.assertEqual(message_type, RBACPayload.CREATE_USER)
decoded = user_transaction_pb2.CreateUser()
decoded.ParseFromString(payload.content)
self.assertEqual(decoded, message)
self.assertEqual(decoded.name, message.name)
else:
raise Exception(
"BatchAssertions.assertValidPayload doesn't support message_type {}"
.format(message_type))
def create_user(txn_key,
batch_key,
name,
user_name,
user_id,
metadata,
manager_id=None):
"""Create a BatchList with a CreateUser RBAC transaction.
Args:
txn_key (Key): The transaction signer's public/private key pair.
batch_key (Key): The batch signer's public/private key pair.
user_name (str): The user name of the User.
user_id (str): The User's public key.
metadata (str): Client supplied metadata.
manager_id (str): The optional id of the manager of this User.
Returns:
tuple
The CreateUser BatchList as the zeroth element and the
batch header_signature as the first element.
"""
create_user_payload = user_transaction_pb2.CreateUser(name=name,
user_name=user_name,
user_id=user_id,
metadata=metadata)
inputs = [addresser.make_user_address(user_id=user_id)]
outputs = [addresser.make_user_address(user_id=user_id)]
if manager_id:
create_user_payload.manager_id = manager_id
inputs.append(addresser.make_user_address(user_id=manager_id))
outputs.append(addresser.make_user_address(user_id=manager_id))
rbac_payload = rbac_payload_pb2.RBACPayload(
content=create_user_payload.SerializeToString(),
message_type=rbac_payload_pb2.RBACPayload.CREATE_USER,
)
return make_header_and_batch(rbac_payload, inputs, outputs, txn_key,
batch_key)
def create_user_transaction(self, name, username, metadata):
txn_private_key = Secp256k1PrivateKey.new_random()
batch_private_key = Secp256k1PrivateKey.new_random()
txn_key = Key(txn_private_key.as_hex())
batch_key = Key(batch_private_key.as_hex())
batchlist, sig = create_user(
txn_key, batch_key, name, username, txn_key.public_key, metadata
)
self.assertEqual(type(sig), str)
self.assertEqual(type(batchlist), batch_pb2.BatchList)
self.assertEqual(len(sig), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(sig))
batch_count = 0
for batch in batchlist.batches:
batch_count += 1
self.assertEqual(type(batch), batch_pb2.Batch)
self.assertEqual(type(batch.header_signature), str)
self.assertEqual(len(batch.header_signature), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(batch.header_signature))
trans_count = 0
for transaction in batch.transactions:
trans_count += 1
self.assertEqual(type(transaction.header), bytes)
self.assertEqual(type(transaction.header_signature), str)
self.assertEqual(type(transaction.payload), bytes)
self.assertEqual(len(transaction.header_signature), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(transaction.header_signature))
header = transaction_pb2.TransactionHeader()
header.ParseFromString(transaction.header)
self.assertEqual(type(header), transaction_pb2.TransactionHeader)
self.assertEqual(header.family_name, addresser.FAMILY_NAME)
self.assertEqual(header.family_version, addresser.FAMILY_VERSION)
self.assertEqual(header.batcher_public_key, batch_key.public_key)
self.assertEqual(header.signer_public_key, txn_key.public_key)
self.assertEqual(len(header.payload_sha512), SIGNATURE_LENGTH)
self.assertTrue(SIGNATURE_PATTERN.match(header.payload_sha512))
input_count = 0
for address in header.inputs:
input_count += 1
self.assertEqual(type(address), str)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH)
self.assertEqual(
addresser.address_is(address), addresser.AddressSpace.USER
)
self.assertEqual(input_count, 1)
output_count = 0
for address in header.outputs:
output_count += 1
self.assertEqual(type(address), str)
self.assertEqual(len(address), addresser.ADDRESS_LENGTH)
self.assertEqual(
addresser.address_is(address), addresser.AddressSpace.USER
)
self.assertEqual(output_count, 1)
payload = rbac_payload_pb2.RBACPayload()
payload.ParseFromString(transaction.payload)
self.assertEqual(type(payload), rbac_payload_pb2.RBACPayload)
self.assertEqual(
payload.message_type, rbac_payload_pb2.RBACPayload.CREATE_USER
)
self.assertEqual(type(payload.content), bytes)
user = user_transaction_pb2.CreateUser()
user.ParseFromString(payload.content)
self.assertEqual(type(user), user_transaction_pb2.CreateUser)
self.assertEqual(user.name, name)
self.assertEqual(user.user_name, username)
self.assertEqual(type(user.user_id), str)
self.assertEqual(user.user_id, txn_key.public_key)
self.assertEqual(trans_count, 1)
self.assertEqual(batch_count, 1)