def test_add_same_model_twice(db):
subject_category_id, object_category_id, action_category_id, meta_rule_id = mock_data.create_new_meta_rule(
subject_category_name="subject_category1",
object_category_name="object_category1",
action_category_name="action_category1",
meta_rule_name="meta_rule_1")
value = {
"name": "model1",
"description": "test",
"meta_rules": [meta_rule_id]
}
# prepare
model_helper.add_model(model_id="model_1", value=value) # add model twice
# act
subject_category_id, object_category_id, action_category_id, meta_rule_id = mock_data.create_new_meta_rule(
subject_category_name="subject_category2",
object_category_name="object_category2",
action_category_name="action_category2",
meta_rule_name="meta_rule_2")
value = {
"name": "model2",
"description": "test",
"meta_rules": [meta_rule_id]
}
with pytest.raises(ModelExisting) as exception_info:
model_helper.add_model(model_id="model_1", value=value)
model_helper.delete_all_models()
assert str(exception_info.value) == '409: Model Error'
def test_delete_models(db):
subject_category_id, object_category_id, action_category_id, meta_rule_id1 = mock_data.create_new_meta_rule(
subject_category_name="subject_category6",
object_category_name="object_category6",
action_category_name="action_category6",
meta_rule_name="meta_rule_6")
model_value1 = {
"name": "MLS",
"description": "test",
"meta_rules": [meta_rule_id1]
}
model1 = model_helper.add_model(value=model_value1)
subject_category_id, object_category_id, action_category_id, meta_rule_id2 = mock_data.create_new_meta_rule(
subject_category_name="subject_category7",
object_category_name="object_category7",
action_category_name="action_category7",
meta_rule_name="meta_rule_7")
model_value2 = {
"name": "rbac",
"description": "test",
"meta_rules": [meta_rule_id2]
}
model_helper.add_model(value=model_value2)
id = list(model1)[0]
model_helper.delete_models(id)
# assert
models = model_helper.get_models()
assert id not in models
model_helper.delete_all_models()
def test_update_policies_model_unused():
policy_name = uuid4().hex
client = utilities.register_client()
req = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(req.keys())[0]
data = {
"name": policy_name,
"description": "description of {}".format(policy_name),
"model_id": model_id,
"genre": "genre"
}
req = client.post("/policies/", data=json.dumps(data),
headers={'Content-Type': 'application/json'})
policy_id = next(iter(utilities.get_json(req.data)['policies']))
req = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(req.keys())[0]
data = {
"name": policy_name,
"description": "description of {}".format(policy_name),
"model_id": model_id,
"genre": "genre"
}
req = client.patch("/policies/{}".format(policy_id), data=json.dumps(data),
headers={'Content-Type': 'application/json'})
assert req.status_code == 200
def test_add_model_generate_new_uuid(db):
subject_category_id, object_category_id, action_category_id, meta_rule_id1 = mock_data.create_new_meta_rule(
subject_category_name="subject_category3",
object_category_name="object_category3",
action_category_name="action_category3",
meta_rule_name="meta_rule_3")
model_value1 = {
"name": "MLS",
"description": "test",
"meta_rules": [meta_rule_id1]
}
model1 = model_helper.add_model(value=model_value1)
subject_category_id, object_category_id, action_category_id, meta_rule_id2 = mock_data.create_new_meta_rule(
subject_category_name="subject_category4",
object_category_name="object_category4",
action_category_name="action_category4",
meta_rule_name="meta_rule_4")
model_value2 = {
"name": "rbac",
"description": "test",
"meta_rules": [meta_rule_id2]
}
model2 = model_helper.add_model(value=model_value2)
assert list(model1)[0] != list(model2)[0]
model_helper.delete_all_models()
def test_get_specific_model(db):
# prepare
model_helper.add_model(model_id="mls_model_id")
# act
models = model_helper.get_models(model_id="mls_model_id")
# assert
assert isinstance(models, dict)
assert models # assert model is not empty
assert len(models) is 1
model_helper.delete_all_models()
def get_policy_id(model_name="test_model", policy_name="policy_1", meta_rule_name="meta_rule1", category_prefix=""):
category_helper.add_subject_category(
category_prefix + "subject_category_id1",
value={"name": category_prefix + "subject_category_id1",
"description": "description 1"})
category_helper.add_subject_category(
category_prefix + "subject_category_id2",
value={"name": category_prefix + "subject_category_id2",
"description": "description 1"})
category_helper.add_object_category(
category_prefix + "object_category_id1",
value={"name": category_prefix + "object_category_id1",
"description": "description 1"})
category_helper.add_action_category(
category_prefix + "action_category_id1",
value={"name": category_prefix + "action_category_id1",
"description": "description 1"})
meta_rule = meta_rule_helper.add_meta_rule(value=create_meta_rule(meta_rule_name, category_prefix))
meta_rule_id = list(meta_rule.keys())[0]
model = model_helper.add_model(value=create_model(meta_rule_id, model_name))
model_id = list(model.keys())[0]
value = create_policy(model_id, policy_name)
policy = policy_helper.add_policies(value=value)
assert policy
policy_id = list(policy.keys())[0]
return policy_id
def test_update_model(db):
subject_category_id, object_category_id, action_category_id, meta_rule_id1 = mock_data.create_new_meta_rule(
subject_category_name="subject_category8",
object_category_name="object_category8",
action_category_name="action_category8",
meta_rule_name="meta_rule_8")
# prepare
model_value = {
"name": "MLS",
"description": "test",
"meta_rules": [meta_rule_id1]
}
model = model_helper.add_model(value=model_value)
model_id = list(model)[0]
subject_category_id, object_category_id, action_category_id, meta_rule_id2 = mock_data.create_new_meta_rule(
subject_category_name="subject_category9",
object_category_name="object_category9",
action_category_name="action_category9",
meta_rule_name="meta_rule_9")
new_model_value = {
"name": "MLS2",
"description": "test",
"meta_rules": [meta_rule_id2]
}
# act
model_helper.update_model(model_id=model_id, value=new_model_value)
# assert
model = model_helper.get_models(model_id)
for key in ("name", "meta_rules", "description"):
assert key in model[model_id]
assert model[model_id][key] == new_model_value[key]
model_helper.delete_all_models()
def test_delete_policies(db):
model = model_helper.add_model(model_id=uuid4().hex)
model_id = next(iter(model))
policy_name1 = uuid4().hex
value = {
"name": policy_name1,
"model_id": model_id,
"genre": "authz",
"description": "test",
}
policies = policy_helper.add_policies(value=value)
policy_id1 = list(policies.keys())[0]
policy_name2 = uuid4().hex
value = {
"name": policy_name2,
"model_id": model_id,
"genre": "authz",
"description": "test",
}
policies = policy_helper.add_policies(value=value)
policy_id2 = list(policies.keys())[0]
assert policy_id1 != policy_id2
policy_helper.delete_policies(policy_id1)
policies = policy_helper.get_policies()
assert policy_id1 not in policies
def create_new_policy(subject_category_name=None,
object_category_name=None,
action_category_name=None,
model_name=None,
policy_name=None,
meta_rule_name=None):
if not subject_category_name:
subject_category_name = "subjectCategory_" + uuid4().hex
if not object_category_name:
object_category_name = "objectCategory_" + uuid4().hex
if not action_category_name:
action_category_name = "actionCategory_" + uuid4().hex
if not meta_rule_name:
meta_rule_name = "meta_rule_" + uuid4().hex
if not model_name:
model_name = "model_name_" + uuid4().hex
if not policy_name:
policy_name = "policy_name_" + uuid4().hex
subject_category_id, object_category_id, action_category_id, meta_rule_id = create_new_meta_rule(
subject_category_name=subject_category_name + uuid4().hex,
object_category_name=object_category_name + uuid4().hex,
action_category_name=action_category_name + uuid4().hex,
meta_rule_name=meta_rule_name + uuid4().hex)
model = model_helper.add_model(
value=create_model(meta_rule_id, model_name + uuid4().hex))
model_id = list(model.keys())[0]
value = create_policy(model_id, policy_name + uuid4().hex)
policy = add_policies(value=value)
assert policy
policy_id = list(policy.keys())[0]
return subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id
def test_add_model(db):
# act
model = model_helper.add_model()
# assert
assert isinstance(model, dict)
assert model # assert model is not empty
assert len(model) is 1
model_helper.delete_all_models()
def test_add_models_with_same_name_twice(db):
subject_category_id, object_category_id, action_category_id, meta_rule_id = mock_data.create_new_meta_rule(
subject_category_name="subject_category5",
object_category_name="object_category5",
action_category_name="action_category5")
model_value1 = {
"name": "MLS",
"description": "test",
"meta_rules": [meta_rule_id]
}
models = model_helper.add_model(value=model_value1)
assert isinstance(models, dict)
assert models
with pytest.raises(Exception) as exception_info:
model_helper.add_model(value=model_value1)
model_helper.delete_all_models()
assert str(exception_info.value) == '409: Model Error'
def test_update_meta_rules_without_meta_rules():
value = {
"name": "mls_model_id" + uuid4().hex,
"description": "test",
"meta_rules": []
}
model = model_helper.add_model(value=value)
model_id = list(model.keys())[0]
client = utilities.register_client()
req_update = update_model_without_meta_rules_ids(client, model_id)
assert req_update[0].status_code == 200
def test_update_policy_name_with_existed_one():
policy_name1 = "testuser" + uuid4().hex
client = utilities.register_client()
req = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(req.keys())[0]
data = {
"name": policy_name1,
"description": "description of {}".format(policy_name1),
"model_id": model_id,
"genre": "genre"
}
req = client.post("/policies/", data=json.dumps(data),
headers={'Content-Type': 'application/json'})
policy_id1 = next(iter(utilities.get_json(req.data)['policies']))
policy_name2 = "testuser" + uuid4().hex
client = utilities.register_client()
req = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(req.keys())[0]
data = {
"name": policy_name2,
"description": "description of {}".format(policy_name2),
"model_id": model_id,
"genre": "genre"
}
req = client.post("/policies/", data=json.dumps(data),
headers={'Content-Type': 'application/json'})
policy_id2 = next(iter(utilities.get_json(req.data)['policies']))
data = {
"name": policy_name1,
"description": "description of {}".format(policy_name1),
"model_id": model_id,
"genre": "genre"
}
req = client.patch("/policies/{}".format(policy_id2), data=json.dumps(data),
headers={'Content-Type': 'application/json'})
assert req.status_code == 409
assert json.loads(req.data)["message"] == '409: Policy Already Exists'
def add_policies(client, name):
req = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(req.keys())[0]
data = {
"name": name,
"description": "description of {}".format(name),
"model_id": model_id,
"genre": "genre"
}
req = client.post("/policies", data=json.dumps(data),
headers={'Content-Type': 'application/json'})
policies = utilities.get_json(req.data)
return req, policies
def test_add_policies_twice_with_same_id(db):
policy_id = 'policy_id_1'
model = model_helper.add_model(model_id=uuid4().hex)
model_id = next(iter(model))
value = {
"name": "test_policy",
"model_id": model_id,
"genre": "authz",
"description": "test",
}
policy_helper.add_policies(policy_id, value)
with pytest.raises(PolicyExisting) as exception_info:
policy_helper.add_policies(policy_id, value)
assert str(exception_info.value) == '409: Policy Already Exists'
def test_add_policies_twice_with_same_name(db):
model = model_helper.add_model(model_id=uuid4().hex)
model_id = next(iter(model))
policy_name=uuid4().hex
value = {
"name": policy_name,
"model_id": model_id,
"genre": "authz",
"description": "test",
}
policy_helper.add_policies(value=value)
with pytest.raises(Exception) as exception_info:
policy_helper.add_policies(value=value)
assert str(exception_info.value) == '409: Policy Already Exists'
assert str(exception_info.value.description)== 'Policy name Existed'
def test_add_model_with_existed_meta_rules_list(db):
subject_category_id, object_category_id, action_category_id, meta_rule_id = mock_data.create_new_meta_rule(
subject_category_name=uuid4().hex,
object_category_name=uuid4().hex,
action_category_name=uuid4().hex)
model_value1 = {
"name": uuid4().hex,
"description": "test",
"meta_rules": [meta_rule_id]
}
models = model_helper.add_model(value=model_value1)
assert isinstance(models, dict)
assert models
model_value1 = {
"name": uuid4().hex,
"description": "test",
"meta_rules": [meta_rule_id]
}
with pytest.raises(Exception) as exception_info:
model_helper.add_model(value=model_value1)
model_helper.delete_all_models()
assert str(exception_info.value) == '409: Model Error'
assert str(exception_info.value.description
) == 'Meta Rules List Existed in another Model'
def test_update_models_with_no_assigned_policy():
client = utilities.register_client()
model = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(model.keys())[0]
data = {
"name": "model_" + uuid4().hex,
"description": "description of model_2",
"meta_rules": []
}
req = client.patch("/models/{}".format(model_id),
data=json.dumps(data),
headers={'Content-Type': 'application/json'})
assert req.status_code == 200
def test_add_policies(db):
model = model_helper.add_model(model_id=uuid4().hex)
model_id = next(iter(model))
value = {
"name": "test_policy",
"model_id": model_id,
"genre": "authz",
"description": "test",
}
policies = policy_helper.add_policies(value=value)
assert isinstance(policies, dict)
assert policies
assert len(policies.keys()) == 1
policy_id = list(policies.keys())[0]
for key in ("genre", "name", "model_id", "description"):
assert key in policies[policy_id]
assert policies[policy_id][key] == value[key]
def test_delete_model_assigned_to_policy():
policy_name = "testuser" + uuid4().hex
client = utilities.register_client()
req = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(req.keys())[0]
data = {
"name": policy_name,
"description": "description of {}".format(policy_name),
"model_id": model_id,
"genre": "genre"
}
req = client.post("/policies",
data=json.dumps(data),
headers={'Content-Type': 'application/json'})
req = client.delete("/models/{}".format(model_id))
assert req.status_code == 400
assert json.loads(req.data)["message"] == '400: Model With Policy Error'
def test_delete_model_assigned_to_policy(db):
model_value1 = {"name": "MLS", "description": "test", "meta_rules": []}
models = model_helper.add_model(value=model_value1)
assert isinstance(models, dict)
assert models
assert len(models.keys()) == 1
model_id = list(models.keys())[0]
value = {
"name": "test_policy",
"model_id": model_id,
"genre": "authz",
"description": "test",
}
policy_helper.add_policies(value=value)
with pytest.raises(DeleteModelWithPolicy) as exception_info:
model_helper.delete_models(uuid=model_id)
assert str(exception_info.value) == '400: Model With Policy Error'
def test_add_models_with_meta_rule_key():
client = utilities.register_client()
model = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(model.keys())[0]
data = {
"name": "model_" + uuid4().hex,
"description": "description of model_2",
}
req = client.patch("/models/{}".format(model_id),
data=json.dumps(data),
headers={'Content-Type': 'application/json'})
assert req.status_code == 400
assert json.loads(
req.data)["message"] == "Invalid Key :meta_rules not found"
def test_add_models(db):
subject_category_id, object_category_id, action_category_id, meta_rule_id = mock_data.create_new_meta_rule(
subject_category_name="subject_category5",
object_category_name="object_category5",
action_category_name="action_category5")
model_value1 = {
"name": "MLS",
"description": "test",
"meta_rules": [meta_rule_id]
}
models = model_helper.add_model(value=model_value1)
assert isinstance(models, dict)
assert models
assert len(models.keys()) == 1
model_id = list(models.keys())[0]
for key in ("name", "meta_rules", "description"):
assert key in models[model_id]
assert models[model_id][key] == model_value1[key]
model_helper.delete_all_models()
def test_update_models_with_assigned_policy():
client = utilities.register_client()
model = model_helper.add_model(model_id="mls_model_id" + uuid4().hex)
model_id = list(model.keys())[0]
value = {
"name": "test_policy" + uuid4().hex,
"model_id": model_id,
"description": "test",
}
policy = policy_helper.add_policies(value=value)
data = {
"name": "model_" + uuid4().hex,
"description": "description of model_2",
"meta_rules": []
}
req = client.patch("/models/{}".format(model_id),
data=json.dumps(data),
headers={'Content-Type': 'application/json'})
assert req.status_code == 400
assert json.loads(req.data)["message"] == "400: Model With Policy Error"
