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)