def test_read_config_no_signing_keys(self):
"""
Register a client without signing keys with a registration token.
Read config from storage to instantiate a client showing config
without signing keys is able to be used in client instantiation.
"""
config_client_public_key, config_client_private_key = e3db.Client.generate_keypair(
)
config_client_name = "client_{0}".format(
binascii.hexlify(os.urandom(16)))
test_config_client = e3db.Client.register(token,
config_client_name,
config_client_public_key,
backup=False,
api_url=api_url)
config_client_api_key_id = test_config_client.api_key_id
config_client_api_secret = test_config_client.api_secret
config_client_id = test_config_client.client_id
config_client_config = e3db.Config(config_client_id,
config_client_api_key_id,
config_client_api_secret,
config_client_public_key,
config_client_private_key,
api_url=api_url)
config_name = "integration_config_no_signing{0}".format(
binascii.hexlify(os.urandom(16)))
# write config with profile 'config_name' ~/.tozny/<profile>/e3db.json
config_client_config.write(config_name)
read_config_profile = e3db.Config.load(config_name)
# Remove signing keys from config.
read_config_profile.pop("public_signing_key", None)
read_config_profile.pop("private_signing_key", None)
# Assert config does not have signing keys
assert ('public_signing_key' not in read_config_profile)
assert ('private_signing_key' not in read_config_profile)
read_client_config = e3db.Config(read_config_profile['client_id'],
read_config_profile['api_key_id'],
read_config_profile['api_secret'],
read_config_profile['public_key'],
read_config_profile['private_key'],
read_config_profile['client_email'],
read_config_profile['version'],
read_config_profile['api_url'])
# Assert Config version defaults to 1 given no signing keys
assert (read_client_config.version == "1")
# If this doesn't throw an exception during instantiation, we loaded
# the configuration properly
config_client = e3db.Client(read_client_config())
# Assert signing keys defaulted to empty strings
assert (config_client.public_signing_key == "")
assert (config_client.private_signing_key == "")
def register_client(self):
client1_public_key, client1_private_key = e3db.Client.generate_keypair()
client1_name = "email_{0}@tozny.com".format(time.time())
test_client1 = e3db.Client.register(token, client1_name, client1_public_key, api_url=api_url)
client1_api_key_id = test_client1.api_key_id
client1_api_secret = test_client1.api_secret
client1_id = test_client1.client_id
client1_config = e3db.Config(
client1_id,
client1_api_key_id,
client1_api_secret,
client1_public_key,
client1_private_key,
api_url=api_url
)
self.client1 = e3db.Client(client1_config())
client2_public_key, client2_private_key = e3db.Client.generate_keypair()
client2_name = "email_{0}@tozny.com".format(time.time())
test_client2 = e3db.Client.register(token, client2_name, client2_public_key, api_url=api_url)
client2_api_key_id = test_client2.api_key_id
client2_api_secret = test_client2.api_secret
client2_id = test_client2.client_id
client2_config = e3db.Config(
client2_id,
client2_api_key_id,
client2_api_secret,
client2_public_key,
client2_private_key,
api_url=api_url
)
self.client2 = e3db.Client(client2_config())
def test_read_write_config(self):
"""
Register a client with a registration token.
Write that config to disk storage. Read config from storage to
instantiate a client showing config can be read and used later.
"""
config_client_public_key, config_client_private_key = e3db.Client.generate_keypair(
)
config_client_name = "client_{0}".format(
binascii.hexlify(os.urandom(16)))
test_config_client = e3db.Client.register(token,
config_client_name,
config_client_public_key,
api_url=api_url)
config_client_api_key_id = test_config_client.api_key_id
config_client_api_secret = test_config_client.api_secret
config_client_id = test_config_client.client_id
config_client_config = e3db.Config(config_client_id,
config_client_api_key_id,
config_client_api_secret,
config_client_public_key,
config_client_private_key,
api_url=api_url)
config_name = "integration_config_{0}".format(
binascii.hexlify(os.urandom(16)))
# write to default location at ~/.tozny/e3db.json, with no profile
config_client_config.write()
# write config with profile 'config_name' ~/.tozny/<profile>/e3db.json
config_client_config.write(config_name)
with pytest.raises(IOError):
# Try to write over existing config file.
# SDK will prevent key loss and throw an error
config_client_config.write()
read_config = e3db.Config.load()
read_config_profile = e3db.Config.load(config_name)
# Check both config files were written properly, and able to be loaded
assert (read_config == read_config_profile)
read_client_config = e3db.Config(read_config_profile['client_id'],
read_config_profile['api_key_id'],
read_config_profile['api_secret'],
read_config_profile['public_key'],
read_config_profile['private_key'],
read_config_profile['client_email'],
read_config_profile['version'],
read_config_profile['api_url'])
# If this doesn't throw an exception during instantiation, we loaded
# the configuration properly
config_client = e3db.Client(read_client_config())
def setup_class(self):
"""This code runs before the tests and assigns a dynamically configured client"""
client1_public_key, client1_private_key = e3db.Client.generate_keypair()
client1_public_signing_key, client1_private_signing_key = e3db.Client.generate_signing_keypair()
client1_name = "client_{0}".format(binascii.hexlify(os.urandom(16)))
test_client1 = e3db.Client.register(token, client1_name, client1_public_key, backup=False, api_url=api_url,
public_signing_key=client1_public_signing_key,
private_signing_key=client1_private_signing_key)
client1_api_key_id = test_client1.api_key_id
client1_api_secret = test_client1.api_secret
client1_id = test_client1.client_id
client1_config = e3db.Config(
client1_id,
client1_api_key_id,
client1_api_secret,
client1_public_key,
client1_private_key,
api_url=api_url,
public_signing_key=client1_public_signing_key,
private_signing_key=client1_private_signing_key
)
self.client1 = e3db.Client(client1_config())
# Client 2
client2_public_key, client2_private_key = e3db.Client.generate_keypair()
client2_public_signing_key, client2_private_signing_key = e3db.Client.generate_signing_keypair()
client2_name = "client_{0}".format(binascii.hexlify(os.urandom(16)))
test_client2 = e3db.Client.register(token, client2_name, client2_public_key, backup=False, api_url=api_url,
public_signing_key=client2_public_signing_key,
private_signing_key=client2_private_signing_key)
client2_api_key_id = test_client2.api_key_id
client2_api_secret = test_client2.api_secret
client2_id = test_client2.client_id
client2_config = e3db.Config(
client2_id,
client2_api_key_id,
client2_api_secret,
client2_public_key,
client2_private_key,
api_url=api_url,
public_signing_key=client2_public_signing_key,
private_signing_key=client2_private_signing_key
)
self.client2 = e3db.Client(client2_config())
def register_and_write_credentials():
public_key, private_key = e3db.Client.generate_keypair()
client_info = e3db.Client.register(registration_token, client_name,
public_key)
config = e3db.Config(client_info.client_id, client_info.api_key_id,
client_info.api_secret, public_key, private_key)
config.write(client_name)
def test_client_signing_keys_optional(self):
"""
Client created without signing keys contains correct value; client
created without it contains empty string.
"""
client_public_key, client_private_key = e3db.Client.generate_keypair()
client_name = "client_no_signing_{0}".format(
binascii.hexlify(os.urandom(16)))
test_client = e3db.Client.register(token,
client_name,
client_public_key,
backup=False,
api_url=api_url)
client_api_key_id = test_client.api_key_id
client_api_secret = test_client.api_secret
client_id = test_client.client_id
client_no_signing_config = e3db.Config(client_id,
client_api_key_id,
client_api_secret,
client_public_key,
client_private_key,
api_url=api_url)
client_no_signing_keys = e3db.Client(client_no_signing_config())
client_public_signing_key, client_private_signing_key = e3db.Client.generate_signing_keypair(
)
client_signing_config = e3db.Config(
client_id,
client_api_key_id,
client_api_secret,
client_public_key,
client_private_key,
api_url=api_url,
public_signing_key=client_public_signing_key,
private_signing_key=client_private_signing_key)
client_signing_keys = e3db.Client(client_signing_config())
assert (client_no_signing_keys.private_signing_key == "")
assert (client_no_signing_keys.public_signing_key == "")
assert (client_signing_keys.private_signing_key ==
client_private_signing_key)
assert (client_signing_keys.public_signing_key ==
client_public_signing_key)
def setup_class(self):
"""
Setup where we create two clients using registration tokens to associate
them with our Tozny account. They will be used to test operations
later in the integration tests where we don't want to create a new client
every time.
"""
client1_public_key, client1_private_key = e3db.Client.generate_keypair(
)
client1_public_signing_key, client1_private_signing_key = e3db.Client.generate_signing_keypair(
)
client1_name = "client_{0}".format(binascii.hexlify(os.urandom(16)))
test_client1 = e3db.Client.register(
token,
client1_name,
client1_public_key,
backup=False,
api_url=api_url,
public_signing_key=client1_public_signing_key,
private_signing_key=client1_private_signing_key)
self.test_client1 = test_client1
client1_api_key_id = test_client1.api_key_id
client1_api_secret = test_client1.api_secret
client1_id = test_client1.client_id
client1_config = e3db.Config(
client1_id,
client1_api_key_id,
client1_api_secret,
client1_public_key,
client1_private_key,
api_url=api_url,
public_signing_key=client1_public_signing_key,
private_signing_key=client1_private_signing_key)
self.client1 = e3db.Client(client1_config())
client2_public_key, client2_private_key = e3db.Client.generate_keypair(
)
client2_public_signing_key, client2_private_signing_key = e3db.Client.generate_signing_keypair(
)
client2_name = "client_{0}".format(binascii.hexlify(os.urandom(16)))
test_client2 = e3db.Client.register(
token,
client2_name,
client2_public_key,
backup=False,
api_url=api_url,
public_signing_key=client2_public_signing_key,
private_signing_key=client2_private_signing_key)
self.test_client2 = test_client2
client2_api_key_id = test_client2.api_key_id
client2_api_secret = test_client2.api_secret
client2_id = test_client2.client_id
client2_config = e3db.Config(
client2_id,
client2_api_key_id,
client2_api_secret,
client2_public_key,
client2_private_key,
api_url=api_url,
public_signing_key=client2_public_signing_key,
private_signing_key=client2_private_signing_key)
self.client2 = e3db.Client(client2_config())
client3_public_key, client3_private_key = e3db.Client.generate_keypair(
)
client3_public_signing_key, client3_private_signing_key = e3db.Client.generate_signing_keypair(
)
client3_name = "client_{0}".format(binascii.hexlify(os.urandom(16)))
test_client3 = e3db.Client.register(
token,
client3_name,
client3_public_key,
backup=False,
api_url=api_url,
public_signing_key=client1_public_signing_key,
private_signing_key=client1_private_signing_key)
self.test_client3 = test_client3
client3_api_key_id = test_client3.api_key_id
client3_api_secret = test_client3.api_secret
client3_id = test_client3.client_id
client3_config = e3db.Config(
client3_id,
client3_api_key_id,
client3_api_secret,
client3_public_key,
client3_private_key,
api_url=api_url,
public_signing_key=client3_public_signing_key,
private_signing_key=client3_private_signing_key)
self.client3 = e3db.Client(client3_config())
print("Client ID: {0}".format(client_id))
print("API Key ID: {0}".format(api_key_id))
print("API Secret: {0}".format(api_secret))
# ---------------------------------------------------------
# Usage
# ---------------------------------------------------------
# Once the client is registered, you can use it immediately to create the
# configuration used to instantiate a Client that can communicate with
# e3db directly.
config = e3db.Config(
client_id,
api_key_id,
api_secret,
public_key,
private_key
)
# Now create a client using that configuration.
client = e3db.Client(config())
# Optionally, if you want to save this Configuration to disk, do the following:
config.write()
# Configuration files live in ~/.tozny and you can have several
# different "profiles" like *dev* and *production*.
# Write ~/.tozny/dev/e3db.json profile
# config.write('dev')
import e3db
from e3db.types import Search
# For this example, instantiate a third party client
third_party_config = e3db.Config(
'a08ddc06-fake-fake-fake-e0589610a05b',
'fake6e9717e7ad5387c629553bf10db3055ed793376def7112ffa1624ec2fake',
'fake1467d1d79d078696d69e7d8082337d60a4aee13b55499f8fd9b9412efake',
'fakeLeDulPGJSddxY1GkvvZthoTZqsGmvS1AFszfake',
'fakemq3k9vfEaKPd1sRQubfZ2umWbWF0iB2buUSfake',
api_url = "https://api.e3db.com"
)
third_party_client = e3db.Client(third_party_config())
# Obtain records written by client from the third_party client
record_type = 'contact'
search_filter = Search(include_all_writers=True,include_data=True) \
.match(condition="AND", record_types=['contact'], writers=['tozny-client-id-that-shared-with-you'])
results = third_party_client.search(search_filter)
for record in results:
print(record.to_json())