def test_publish_event(organizations, default_org_id, default_team_id):
experiment_id = str(uuid.uuid4())
x_id = str(uuid.uuid4())
extensions = [
{
"name": "chaosiq",
"execution_id": x_id,
"experiment_id": experiment_id
}
]
activity = {}
run = {}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, default_team_id,
experiment_id, x_id, with_events=True)
m.post(url, status_code=201)
with client_session(ENDPOINT, organizations) as s:
publish_event(
s, "start-experiment", activity, None, None, extensions, None,
run)
r = json.loads(m.last_request.body)
assert r["specversion"] in ["0.3", "1.0"]
assert r["datacontenttype"] == "application/json"
assert r["type"] == "start-experiment"
assert r["source"] == "chaosiq-cloud"
assert "id" in r
assert "time" in r
assert "data" in r
def test_execution_not_created_when_experiment_is_invalid_type(
organizations, default_org_id,
default_team_id):
experiment_id = str(uuid.uuid4())
# the remote endpoint cannot deal with anything but a experiment
experiment = {
"extensions": [
{
"name": "chaosiq",
"experiment_id": experiment_id
}
]
}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, default_team_id,
experiment_id, with_executions=True)
m.post(
url, status_code=422, json=[
{
"loc": ["a_dict"],
"msg": "value is not a valid dict",
"type": "type_error.dict"
}
],
headers={
"content-type": "application/json"
}
)
with client_session(ENDPOINT, organizations) as s:
r = initialize_execution(s, experiment, {})
assert r.status_code == 422
def test_cannot_create_execution_from_unknown_experiment_id(
organizations, default_org_id,
default_team_id):
experiment_id = str(uuid.uuid4())
experiment = {
"title": "Hello there",
"extensions": [
{
"name": "chaosiq",
"experiment_id": experiment_id
}
]
}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, default_team_id,
experiment_id, with_executions=True)
m.post(
url, status_code=422,
json=[],
headers={
"content-type": "application/json"
}
)
with client_session(ENDPOINT, organizations) as s:
r = initialize_execution(s, experiment, {})
assert r.status_code == 422
assert "execution_id" not in experiment["extensions"][0]
def test_cannot_update_execution_with_invalid_execution_id(organizations,
default_org_id,
default_team_id):
experiment_id = str(uuid.uuid4())
x_id = str(uuid.uuid4())
journal = {
"experiment": {
"extensions": [
{
"name": "chaosiq",
"execution_id": x_id,
"experiment_id": experiment_id
}
]
}
}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, default_team_id,
experiment_id, execution_id=x_id)
m.put(
url, status_code=404,
headers={
"content-type": "text/plain"
}
)
with client_session(ENDPOINT, organizations) as s:
r = publish_execution(s, journal)
assert r.status_code == 404
def test_interrupt_experiment(organizations, default_org_id, default_team_id):
execution_id = str(uuid.uuid4())
experiment_id = str(uuid.uuid4())
with requests_mock.mock() as m:
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
experiment_id,
execution_id=execution_id,
with_safeguards=True)
m.get(url,
status_code=200,
json={
"allowed": False,
"policies": [{
"name": "godzilla says stop"
}]
})
with client_session(ENDPOINT, organizations) as s:
with pytest.raises(InterruptExecution):
is_allowed_to_continue(s, [{
"name": "chaosiq",
"execution_id": execution_id,
"experiment_id": experiment_id
}])
def test_store_safeguards_to_journal(organizations, default_org_id,
default_team_id):
execution_id = str(uuid.uuid4())
experiment_id = str(uuid.uuid4())
safeguards = [{"name": "godzilla says stop"}]
with requests_mock.mock() as m:
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
experiment_id,
execution_id=execution_id,
with_safeguards=True)
m.get(url,
status_code=200,
json={
"allowed": False,
"policies": safeguards
})
extensions = [{
"name": "chaosiq",
"execution_id": execution_id,
"experiment_id": experiment_id
}]
journal = {}
with client_session(ENDPOINT, organizations) as s:
with pytest.raises(InterruptExecution):
is_allowed_to_continue(s, extensions)
set_applied_safeguards_for_execution(extensions, journal)
assert journal["extensions"][0]["safeguards"] == safeguards
def test_organization_are_fetched_for_user(organizations):
with requests_mock.mock() as m:
url = urls.org(urls.base(ENDPOINT))
m.get(url, status_code=200, json=organizations)
r = request_orgs(url, token="XYZ", verify_tls=True)
assert r.status_code == 200
assert r.json() == organizations
def test_create_execution(organizations, default_org_id, default_team_id):
experiment_id = str(uuid.uuid4())
x_id = str(uuid.uuid4())
experiment = {
"title": "Hello there",
"extensions": [
{
"name": "chaosiq",
"experiment_id": experiment_id
}
]
}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, default_team_id,
experiment_id, with_executions=True)
m.post(
url, status_code=201,
json={
"id": x_id,
},
headers={
"content-type": "application/json",
"content-location": "{}/{}".format(url, x_id)
}
)
with client_session(ENDPOINT, organizations) as s:
r = initialize_execution(s, experiment, {})
assert r.status_code == 201
# we injected the execution_id
assert experiment["extensions"][0]["execution_id"] == x_id
def test_configure_control_creates_experiment_and_execution_when_new(
organizations, default_org_id, default_team_id, settings):
x_id = str(uuid.uuid4())
e_id = str(uuid.uuid4())
extensions = [{"name": "chaosiq"}]
experiment = {"title": "Hello there", "extensions": extensions}
with requests_mock.mock() as m:
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
with_experiments=True)
m.post(url,
status_code=201,
json={"id": e_id},
headers={
"content-type": "application/json",
"content-location": "{}/{}".format(url, e_id)
})
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
e_id,
with_executions=True)
m.post(url,
status_code=201,
json={
"id": x_id,
},
headers={
"content-type": "application/json",
"content-location": "{}/{}".format(url, x_id)
})
configure_control(experiment,
settings,
url=ENDPOINT,
organizations=organizations)
assert experiment["extensions"][0]["experiment_id"] == e_id
assert experiment["extensions"][0]["execution_id"] == x_id
def test_experiment_not_created_when_unmodified(organizations, default_org_id,
default_team_id):
experiment = {"title": "hello"}
with requests_mock.mock() as m:
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
with_experiments=True)
m.post(url, status_code=204)
with client_session(ENDPOINT, organizations) as s:
r = publish_experiment(s, experiment)
assert r.status_code == 204
def test_cannot_create_experiment_on_requests_connection_timeout(
organizations, default_org_id, default_team_id):
experiment = {"title": "hello"}
with requests_mock.mock() as m:
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
with_experiments=True)
m.post(url, exc=requests.exceptions.ConnectTimeout)
with client_session(ENDPOINT, organizations) as s:
r = publish_experiment(s, experiment)
assert r is None
def test_cannot_fetch_execution_non_published_experiment(organizations,
default_org_id,
default_team_id):
experiment_id = str(uuid.uuid4())
x_id = str(uuid.uuid4())
journal = {
"experiment": {}
}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, experiment_id,
default_team_id, x_id)
m.get(url, exc=requests.exceptions.ConnectTimeout)
with client_session(ENDPOINT, organizations) as s:
r = fetch_execution(s, journal)
assert r is None
assert m.call_count == 0
def test_cannot_publish_event_non_published_execution(organizations,
default_org_id,
default_team_id):
experiment_id = str(uuid.uuid4())
x_id = str(uuid.uuid4())
extensions = []
activity = {}
run = {}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, experiment_id,
default_team_id, x_id, with_events=True)
m.post(url, status_code=201)
with client_session(ENDPOINT, organizations) as s:
publish_event(
s, "start-experiment", activity, None, None, extensions, None,
run)
assert m.call_count == 0
def test_create_experiment(organizations, default_org_id, default_team_id):
x_id = str(uuid.uuid4())
experiment = {"title": "hello"}
with requests_mock.mock() as m:
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
with_experiments=True)
m.post(url,
status_code=201,
json={"id": x_id},
headers={
"content-type": "application/json",
"content-location": "{}/{}".format(url, x_id)
})
with client_session(ENDPOINT, organizations) as s:
r = publish_experiment(s, experiment)
assert r.status_code == 201
assert r.headers["content-location"] == "{}/{}".format(url, x_id)
def test_fetch_execution(organizations, default_org_id, default_team_id):
experiment_id = str(uuid.uuid4())
x_id = str(uuid.uuid4())
journal = {
"experiment": {
"extensions": [
{
"name": "chaosiq",
"execution_id": x_id,
"experiment_id": experiment_id
}
]
}
}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, default_team_id,
experiment_id, x_id)
m.get(url, json=journal)
with client_session(ENDPOINT, organizations) as s:
r = fetch_execution(s, journal)
assert r.status_code == 200
def test_no_check_when_execution_is_not_found(organizations, default_org_id,
default_team_id):
execution_id = str(uuid.uuid4())
experiment_id = str(uuid.uuid4())
with requests_mock.mock() as m:
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
experiment_id,
execution_id=execution_id,
with_safeguards=True)
m.get(url, status_code=404)
try:
with client_session(ENDPOINT, organizations) as s:
is_allowed_to_continue(s, [{
"name": "chaosiq",
"execution_id": execution_id,
"experiment_id": experiment_id
}])
except InterruptExecution:
pytest.fail(
"Missing execution identifier in experiment should not "
"lead to execution interruption")
def test_cannot_update_execution_on_request_connection_timeout(
organizations, default_org_id, default_team_id):
experiment_id = str(uuid.uuid4())
x_id = str(uuid.uuid4())
journal = {
"experiment": {
"extensions": [
{
"name": "chaosiq",
"execution_id": x_id,
"experiment_id": experiment_id
}
]
}
}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, experiment_id,
default_team_id, x_id)
m.put(url, exc=requests.exceptions.ConnectTimeout)
with client_session(ENDPOINT, organizations) as s:
r = publish_execution(s, journal)
assert r is None
def test_cannot_create_execution_on_requests_connection_timeout(
organizations, default_org_id,
default_team_id):
experiment_id = str(uuid.uuid4())
experiment = {
"title": "Hello there",
"extensions": [
{
"name": "chaosiq",
"experiment_id": experiment_id
}
]
}
with requests_mock.mock() as m:
url = urls.full(
urls.base(ENDPOINT), default_org_id, default_team_id,
experiment_id, with_executions=True)
m.post(
url,
exc=requests.exceptions.ConnectTimeout
)
with client_session(ENDPOINT, organizations) as s:
r = initialize_execution(s, experiment, {})
assert r is None
def base_team_url(default_org_id: str, default_team_id: str) -> str:
return urls.full(urls.base(ENDPOINT), default_org_id, default_team_id)
def test_organization_cannot_be_fetched_ssl_error_is_raised():
with requests_mock.mock() as m:
url = urls.org(urls.base(ENDPOINT))
m.get(url, exc=requests.exceptions.SSLError)
r = request_orgs(url, token="XYZ", verify_tls=True)
assert r is None
def test_experiment_id_must_be_stored_in_journal(organizations, default_org_id,
default_team_id, settings):
x_id = str(uuid.uuid4())
e_id = str(uuid.uuid4())
ev_id = str(uuid.uuid4())
extensions = [{
"name": "chaosiq",
"experiment_id": e_id,
"execution_id": x_id
}]
experiment = {"title": "Hello there", "extensions": extensions}
journal = {"experiment": experiment}
with requests_mock.mock() as m:
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
with_experiments=True)
m.post(url,
status_code=201,
json={"id": e_id},
headers={
"content-type": "application/json",
"content-location": "{}/{}".format(url, e_id)
})
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
e_id,
with_executions=True)
m.post(url,
status_code=201,
json={
"id": x_id,
},
headers={
"content-type": "application/json",
"content-location": "{}/{}".format(url, x_id)
})
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
e_id,
x_id,
with_executions=True,
with_events=True)
m.post(url,
status_code=201,
json={
"id": ev_id,
},
headers={
"content-type": "application/json",
"content-location": "{}/{}".format(url, ev_id)
})
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
e_id,
x_id,
with_executions=True,
with_safeguards=True)
m.get(url,
status_code=201,
json={"allowed": True},
headers={"content-type": "application/json"})
url = urls.full(urls.base(ENDPOINT),
default_org_id,
default_team_id,
e_id,
x_id,
with_executions=True)
m.put(url,
status_code=204,
json={},
headers={"content-type": "application/json"})
after_experiment_control(experiment,
journal,
extensions=extensions,
url=ENDPOINT,
organizations=organizations,
settings=settings)
assert journal["extensions"][0]["experiment_id"] == e_id
assert journal["extensions"][0]["execution_id"] == x_id
def test_build_base_url():
assert urls.base(ENDPOINT) == "{}/api/v1".format(ENDPOINT)
def test_build_safeguards_url():
base = urls.base(ENDPOINT)
assert urls.safeguard(base) == "{}/api/v1/policies".format(ENDPOINT)
def test_build_executions_url():
base = urls.base(ENDPOINT)
assert urls.execution(base) == "{}/api/v1/executions".format(ENDPOINT)
def test_build_experiment_url():
base = urls.base(ENDPOINT)
experiment_id = str(uuid.uuid4())
assert urls.experiment(base, experiment_id) == \
"{}/api/v1/experiments/{}".format(ENDPOINT, experiment_id)
def test_build_experiments_url():
base = urls.base(ENDPOINT)
assert urls.experiment(base) == \
"{}/api/v1/experiments".format(ENDPOINT)
def test_organization_cannot_be_fetched_when_token_is_rejected():
with requests_mock.mock() as m:
url = urls.org(urls.base(ENDPOINT))
m.get(url, status_code=401)
r = request_orgs(url, token="XYZ", verify_tls=True)
assert r.status_code == 401
