def test_else_http(self):
# test hosts must not redirect http to https
hosts = [
"www.google.com",
]
for host in hosts:
# http by default
try:
verta.Client(host, max_retries=0)
except requests.HTTPError as e:
assert e.request.url.split(':', 1)[0] == "http"
else:
raise RuntimeError("faulty test; expected error")
# http if provided
try:
verta.Client("http://{}".format(host), max_retries=0)
except requests.HTTPError as e:
assert e.request.url.split(':', 1)[0] == "http"
else:
raise RuntimeError("faulty test; expected error")
# https if provided
try:
verta.Client("https://{}".format(host), max_retries=0)
except requests.HTTPError as e:
assert e.request.url.split(':', 1)[0] == "https"
else:
raise RuntimeError("faulty test; expected error")
def config_file_with_type_util(self, connect):
PROJECT_NAME = _utils.generate_default_name()
DATASET_NAME = _utils.generate_default_name()
EXPERIMENT_NAME = _utils.generate_default_name()
CONFIG_FILENAME = "verta_config.json"
HOST_KEY, EMAIL_KEY, DEV_KEY_KEY = "VERTA_HOST", "VERTA_EMAIL", "VERTA_DEV_KEY"
HOST, EMAIL, DEV_KEY = os.environ[HOST_KEY], os.environ[EMAIL_KEY], os.environ[DEV_KEY_KEY]
try:
del os.environ[HOST_KEY], os.environ[EMAIL_KEY], os.environ[DEV_KEY_KEY]
try:
with open(CONFIG_FILENAME, 'w') as f:
json.dump(
{
'host': HOST,
'email': EMAIL, 'dev_key': DEV_KEY,
'project': PROJECT_NAME,
'experiment': EXPERIMENT_NAME,
'dataset': DATASET_NAME,
},
f,
)
client = verta.Client(_connect=connect)
conn = client._conn
back_end_url = urlparse(HOST)
socket = back_end_url.netloc + back_end_url.path.rstrip('/')
assert conn.socket == socket
assert conn.auth['Grpc-Metadata-email'] == EMAIL
assert conn.auth['Grpc-Metadata-developer_key'] == DEV_KEY
assert conn.auth['Grpc-Metadata-developer-key'] == DEV_KEY
if connect:
try:
assert client.set_experiment_run()
assert client.proj.name == PROJECT_NAME
assert client.expt.name == EXPERIMENT_NAME
finally:
if client.proj is not None:
client.proj.delete()
dataset = client.set_dataset()
try:
assert dataset.name == DATASET_NAME
finally:
dataset.delete()
else:
assert client._set_from_config_if_none(None, "project") == PROJECT_NAME
assert client._set_from_config_if_none(None, "experiment") == EXPERIMENT_NAME
assert client._set_from_config_if_none(None, "dataset") == DATASET_NAME
finally:
if os.path.exists(CONFIG_FILENAME):
os.remove(CONFIG_FILENAME)
finally:
os.environ[HOST_KEY], os.environ[EMAIL_KEY], os.environ[DEV_KEY_KEY] = HOST, EMAIL, DEV_KEY
def test_no_auth(self, host):
client = verta.Client(host)
# it's just been revoked
client._conn.auth = None
assert client.set_project()
utils.delete_project(client.proj.id, client._conn)
def test_extra_auth_headers_in_request(self, strs):
headers = dict(zip(strs[:len(strs) // 2], strs[len(strs) // 2:]))
client = verta.Client(extra_auth_headers=headers)
url = "http://httpbin.org/anything"
response = _utils.make_request("GET", url, client._conn)
for key, val in headers.items():
assert key in response.request.headers
assert val == response.request.headers[key]
def test_verta_https(self):
hosts = [
"app.verta.ai",
]
for host in hosts:
# https by default
conn = verta.Client(host)._conn
assert conn.scheme == "https"
assert conn.scheme == conn.auth['Grpc-Metadata-scheme']
# http if provided
conn = verta.Client("http://{}".format(host))._conn
assert conn.scheme == "http"
assert conn.scheme == conn.auth['Grpc-Metadata-scheme']
# https if provided
conn = verta.Client("https://{}".format(host))._conn
assert conn.scheme == "https"
assert conn.scheme == conn.auth['Grpc-Metadata-scheme']
def test_config_file(self):
PROJECT_NAME = "test_project"
DATASET_NAME = "test_dataset"
EXPERIMENT_NAME = "test_experiment"
CONFIG_FILENAME = "verta_config.json"
HOST = "app.verta.ai"
EMAIL_KEY, DEV_KEY_KEY = "VERTA_EMAIL", "VERTA_DEV_KEY"
EMAIL, DEV_KEY = os.environ[EMAIL_KEY], os.environ[DEV_KEY_KEY]
try:
del os.environ[EMAIL_KEY], os.environ[DEV_KEY_KEY]
try:
with open(CONFIG_FILENAME, 'w') as f:
json.dump(
{
'host': HOST,
'email': EMAIL,
'dev_key': DEV_KEY,
'project': PROJECT_NAME,
'experiment': EXPERIMENT_NAME,
'dataset': DATASET_NAME,
},
f,
)
client = verta.Client()
conn = client._conn
assert conn.socket == HOST
assert conn.auth['Grpc-Metadata-email'] == EMAIL
assert conn.auth['Grpc-Metadata-developer_key'] == DEV_KEY
try:
assert client.set_experiment_run()
assert client.proj.name == PROJECT_NAME
assert client.expt.name == EXPERIMENT_NAME
finally:
if client.proj is not None:
utils.delete_project(client.proj.id, conn)
dataset = client.set_dataset()
try:
assert dataset.name == DATASET_NAME
finally:
utils.delete_datasets([dataset.id], conn)
finally:
if os.path.exists(CONFIG_FILENAME):
os.remove(CONFIG_FILENAME)
finally:
os.environ[EMAIL_KEY], os.environ[DEV_KEY_KEY] = EMAIL, DEV_KEY
def test_auth_headers(self, host):
expected_headers = {
'Grpc-Metadata-email': os.environ['VERTA_EMAIL'],
'Grpc-Metadata-developer_key': os.environ['VERTA_DEV_KEY'],
'Grpc-Metadata-developer-key': os.environ['VERTA_DEV_KEY'],
}
def assert_contains_expected_headers(headers):
for key, val in expected_headers.items():
assert key in headers
assert headers[key] == val
# present in Client state
client = verta.Client(host)
assert_contains_expected_headers(client._conn.auth)
# sent in requests
with pytest.raises(requests.HTTPError) as exc_info:
verta.Client("www.google.com")
request = exc_info.value.request
assert_contains_expected_headers(request.headers)
def test_wrong_credentials(self):
EMAIL_KEY, DEV_KEY_KEY = "VERTA_EMAIL", "VERTA_DEV_KEY"
old_email, old_dev_key = os.environ[EMAIL_KEY], os.environ[DEV_KEY_KEY]
try:
os.environ[EMAIL_KEY] = "*****@*****.**"
os.environ[DEV_KEY_KEY] = "def"
with pytest.raises(requests.exceptions.HTTPError) as excinfo:
verta.Client()
excinfo_value = str(excinfo.value).strip()
assert "401 Client Error" in excinfo_value
assert "authentication failed; please check `VERTA_EMAIL` and `VERTA_DEV_KEY`" in excinfo_value
finally:
os.environ[EMAIL_KEY], os.environ[DEV_KEY_KEY] = old_email, old_dev_key
def test_no_auth(self, host):
EMAIL_KEY, DEV_KEY_KEY = "VERTA_EMAIL", "VERTA_DEV_KEY"
EMAIL, DEV_KEY = os.environ.pop(EMAIL_KEY, None), os.environ.pop(DEV_KEY_KEY, None)
try:
client = verta.Client(host)
# still has source set
assert 'Grpc-Metadata-source' in client._conn.auth
assert client.set_project()
client.proj.delete()
finally:
if EMAIL is not None:
os.environ[EMAIL_KEY] = EMAIL
if DEV_KEY is not None:
os.environ[DEV_KEY_KEY] = DEV_KEY
def test_extra_auth_headers_in_conn(self, headers):
client = verta.Client(extra_auth_headers=headers, _connect=False)
for key, val in headers.items():
assert key in client._conn.auth
assert val == client._conn.auth[key]
