def test_add_rule_to_policy(mock):
# Should raise an exception if the rule does not exist
rule_uri = 'https://example.com#nonexistant'
policy_uri = 'https://example.com#policy'
db_access.create_policy(policy_uri)
with pytest.raises(ValueError):
db_access.add_rule_to_policy(rule_uri, policy_uri)
# Should raise an exception if the policy does not exist
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
db_access.delete_policy(policy_uri)
with pytest.raises(ValueError):
db_access.add_rule_to_policy(rule_uri, policy_uri)
# Should add a rule to a policy
db_access.create_policy(policy_uri)
db_access.add_rule_to_policy(rule_uri, policy_uri)
query_str = 'SELECT COUNT(1) FROM POLICY_HAS_RULE WHERE RULE_URI = ? AND POLICY_URI = ?'
rule_assigned = db_access.query_db(query_str, (rule_uri, policy_uri),
one=True)[0]
assert rule_assigned
# Should raise an exception if the rule is already included in the policy
with pytest.raises(ValueError):
db_access.add_rule_to_policy(rule_uri, policy_uri)
def test_get_rule(mock):
# Should raise an exception when the rule doesn't exist
rule_uri = 'http://example.com#rule'
with pytest.raises(ValueError):
db_access.get_rule(rule_uri)
# Should get uri, type and label of the rule
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
action_uri = 'http://www.w3.org/ns/odrl/2/distribute'
db_access.add_action_to_rule(action_uri, rule_uri)
assignor_uri = 'https://example.com#assignor'
assignee_uri = 'https://example.com#assignee'
db_access.create_party(assignor_uri)
db_access.create_party(assignee_uri)
db_access.add_assignor_to_rule(assignor_uri, rule_uri)
db_access.add_assignee_to_rule(assignee_uri, rule_uri)
rule = db_access.get_rule(rule_uri)
assert rule['URI'] == rule_uri
assert rule['TYPE_URI'] == rule_type
assert rule['TYPE_LABEL'] == 'Permission'
assert rule['LABEL'] == rule_label
# Should get actions associated with the rule
action = rule['ACTIONS'][0]
assert action['LABEL'] == 'Distribute'
assert action['URI'] == action_uri
assert action['DEFINITION'] == 'To supply the Asset to third-parties.'
# Should get assignors and assignees associated with the rule
assert rule['ASSIGNORS'] == [assignor_uri]
assert rule['ASSIGNEES'] == [assignee_uri]
def test_delete_rule(mock):
# Should not be able to delete if the rule is still used in any policies
policy_uri = 'https://example.com#policy'
db_access.create_policy(policy_uri)
rule_uri = 'http://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
assignor_uri = 'http://example.com#assignor'
db_access.create_party(assignor_uri)
db_access.add_assignor_to_rule(assignor_uri, rule_uri)
assignee_uri = 'http://example.com#assignee'
db_access.create_party(assignee_uri)
db_access.add_assignee_to_rule(assignee_uri, rule_uri)
action_uri = 'http://www.w3.org/ns/odrl/2/distribute'
db_access.add_action_to_rule(action_uri, rule_uri)
db_access.add_rule_to_policy(rule_uri, policy_uri)
with pytest.raises(ValueError):
db_access.delete_rule(rule_uri)
# Should delete the rule
db_access.remove_rule_from_policy(rule_uri, policy_uri)
db_access.delete_rule(rule_uri)
assert not db_access.rule_exists(rule_uri)
# Should also remove any actions from the rule
assert not db_access.rule_has_action(rule_uri, action_uri)
# Should also remove any assignors from the rule
assert not db_access.rule_has_assignor(assignor_uri, rule_uri)
# Should also remove any assignees from the rule
assert not db_access.rule_has_assignee(assignee_uri, rule_uri)
def test_get_policy(mock):
# Should raise an exception when the policy doesn't exist
policy_uri = 'https://example.com#policy'
with pytest.raises(ValueError):
db_access.get_policy(policy_uri)
# Should get all the attributes of the policy
db_access.create_policy(policy_uri)
policy_type = 'http://creativecommons.org/ns#License'
db_access.set_policy_attribute(policy_uri, 'TYPE', policy_type)
rule_uri = 'http://example.com#rule'
rule_type_uri = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type_uri, rule_label)
db_access.add_rule_to_policy(rule_uri, policy_uri)
policy = db_access.get_policy(policy_uri)
expected_policy_attributes = [
'URI', 'TYPE', 'LABEL', 'JURISDICTION', 'LEGAL_CODE', 'HAS_VERSION',
'LANGUAGE', 'SEE_ALSO', 'SAME_AS', 'COMMENT', 'LOGO', 'CREATED',
'STATUS', 'RULES'
]
assert all(attr in policy for attr in expected_policy_attributes)
assert policy['URI'] == policy_uri
assert policy['TYPE'] == policy_type
assert policy['RULES'] == [rule_uri]
def test_remove_assignee_from_rule(mock):
# Should remove an assignee from a rule
assignee_uri = 'http://example.com#assignee'
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
db_access.create_rule(rule_uri, rule_type)
db_access.create_party(assignee_uri)
db_access.add_assignee_to_rule(assignee_uri, rule_uri)
db_access.remove_assignee_from_rule(assignee_uri, rule_uri)
assert not db_access.rule_has_assignee(rule_uri, assignee_uri)
def test_rule_exists(mock):
# Should return false if the policy doesn't exist
rule_uri = 'https://example.com#rule'
assert not db_access.rule_exists(rule_uri)
# Should return true if the party exists
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
assert db_access.rule_exists(rule_uri)
def test_get_all_rules(mock):
rule1 = 'https://example.com#rule1'
rule2 = 'https://example.com#rule2'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule1_label = 'Rule1'
rule2_label = 'Rule2'
db_access.create_rule(rule1, rule_type, rule1_label)
db_access.create_rule(rule2, rule_type, rule2_label)
rules = db_access.get_all_rules()
assert rules == [rule1, rule2]
def test_remove_action_from_rule(mock):
# Should remove an action from a rule
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
action_uri = 'http://www.w3.org/ns/odrl/2/distribute'
db_access.add_action_to_rule(action_uri, rule_uri)
db_access.remove_action_from_rule(action_uri, rule_uri)
assert not db_access.rule_has_action(rule_uri, action_uri)
def test_get_actions_for_rule(mock):
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
action1 = 'http://www.w3.org/ns/odrl/2/acceptTracking'
action2 = 'http://www.w3.org/ns/odrl/2/aggregate'
db_access.add_action_to_rule(action1, rule_uri)
db_access.add_action_to_rule(action2, rule_uri)
actions = db_access.get_actions_for_rule(rule_uri)
assert all(action['URI'] in [action1, action2] for action in actions)
def test_remove_rule_from_policy(mock):
# Should remove a rule from a policy
policy_uri = 'https://example.com#policy'
db_access.create_policy(policy_uri)
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
db_access.add_rule_to_policy(rule_uri, policy_uri)
db_access.remove_rule_from_policy(rule_uri, policy_uri)
assert not db_access.policy_has_rule(policy_uri, rule_uri)
def test_get_assignors_for_rule(mock):
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
db_access.create_rule(rule_uri, rule_type)
assignor1 = 'https://example.com#assignor1'
assignor2 = 'https://example.com#assignor2'
db_access.create_party(assignor1)
db_access.create_party(assignor2)
db_access.add_assignor_to_rule(assignor1, rule_uri)
db_access.add_assignor_to_rule(assignor2, rule_uri)
assignors = db_access.get_assignors_for_rule(rule_uri)
assert assignors == [assignor1, assignor2]
def test_rule_has_assignee(mock):
# Should return false if the rule doesn't have that assignee
assignee_uri = 'http://example.com#assignee'
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
db_access.create_rule(rule_uri, rule_type)
assert not db_access.rule_has_assignee(rule_uri, assignee_uri)
# Should return true if the rule does have that assignee
db_access.create_party(assignee_uri)
db_access.add_assignee_to_rule(assignee_uri, rule_uri)
assert db_access.rule_has_assignee(rule_uri, assignee_uri)
def test_rule_has_action(mock):
# Should return false if the rule does not have the action
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
action_uri = 'http://www.w3.org/ns/odrl/2/distribute'
assert not db_access.rule_has_action(rule_uri, rule_type)
# Should return true if the rule has the action
db_access.add_action_to_rule(action_uri, rule_uri)
assert db_access.rule_has_action(rule_uri, action_uri)
def test_policy_has_rule(mock):
# Should return false if the policy does not have the rule
policy_uri = 'https://example.com#policy'
rule_uri = 'http://example.com#rule'
assert not db_access.policy_has_rule(policy_uri, rule_uri)
# Should return true if the policy has the rule
db_access.create_policy(policy_uri)
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
db_access.add_rule_to_policy(rule_uri, policy_uri)
assert db_access.policy_has_rule(policy_uri, rule_uri)
def test_get_assignees_for_rule(mock):
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
assignee1 = 'https://example.com#assignee1'
assignee2 = 'https://example.com#assignee2'
db_access.create_party(assignee1)
db_access.create_party(assignee2)
db_access.add_assignee_to_rule(assignee1, rule_uri)
db_access.add_assignee_to_rule(assignee2, rule_uri)
assignees = db_access.get_assignees_for_rule(rule_uri)
assert assignees == [assignee1, assignee2]
def test_get_rules_using_action(mock):
action_uri = 'http://www.w3.org/ns/odrl/2/acceptTracking'
rule1_uri = 'https://example.com#rule1'
rule1_type = 'http://www.w3.org/ns/odrl/2/permission'
rule1_label = 'Rule1'
db_access.create_rule(rule1_uri, rule1_type, rule1_label)
db_access.add_action_to_rule(action_uri, rule1_uri)
rule2_uri = 'https://example.com#rule2'
rule2_type = 'http://www.w3.org/ns/odrl/2/permission'
rule2_label = 'Rule2'
db_access.create_rule(rule2_uri, rule2_type, rule2_label)
db_access.add_action_to_rule(action_uri, rule2_uri)
rules = db_access.get_rules_using_action(action_uri)
assert all(rule['URI'] in [rule1_uri, rule2_uri] for rule in rules)
def test_get_policies_for_rule(mock):
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
policy1 = 'https://example.com#policy1'
db_access.create_policy(policy1)
db_access.add_rule_to_policy(rule_uri, policy1)
policy2 = 'https://example.com#policy2'
db_access.create_policy(policy2)
db_access.add_rule_to_policy(rule_uri, policy2)
policies = db_access.get_policies_for_rule(rule_uri)
assert {'URI': policy1, 'LABEL': None} in policies
assert {'URI': policy2, 'LABEL': None} in policies
def test_delete_party(mock):
# Should raise an exception if the Party is currently assigned to a Rule
party_uri = 'https://example.com#party'
rule_uri = 'https://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
db_access.create_party(party_uri)
db_access.create_rule(rule_uri, rule_type)
db_access.add_assignor_to_rule(party_uri, rule_uri)
with pytest.raises(ValueError):
db_access.delete_party(party_uri)
# Should delete the Party if not currently assigned to a Rule (deleting the rule drops the assignment)
db_access.delete_rule(rule_uri)
db_access.delete_party(party_uri)
assert not db_access.party_exists(party_uri)
def test_get_rules_for_party(mock):
party_uris = ['https://example.com/party/1', 'https://example.com/party/2']
for party_uri in party_uris:
db_access.create_party(party_uri)
rule_uris = [
'http://example.com/rule/1', 'http://example.com/rule/2',
'http://example.com/rule/3', 'http://example.com/rule/4'
]
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
for rule_uri in rule_uris:
db_access.create_rule(rule_uri, rule_type)
db_access.add_assignor_to_rule(party_uris[0], rule_uris[0])
db_access.add_assignor_to_rule(party_uris[0], rule_uris[1])
db_access.add_assignee_to_rule(party_uris[0], rule_uris[2])
db_access.add_assignor_to_rule(party_uris[1], rule_uris[3])
# Should list the parties assigned to a rule and only those parties
assert {rule_uris[0], rule_uris[1],
rule_uris[2]} == set(db_access.get_rules_for_party(party_uris[0]))
assert [rule_uris[3]] == db_access.get_rules_for_party(party_uris[1])
def test_add_assignee_to_rule(mock):
# Should raise an exception if the rule doesn't exist
rule_uri = 'https://example.com#rule'
assignee_uri = 'http://example.com#assignee'
db_access.create_party(assignee_uri)
with pytest.raises(ValueError):
db_access.add_assignee_to_rule(assignee_uri, rule_uri)
# Should raise an exception if the assignee doesn't exist
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
db_access.delete_party(assignee_uri)
db_access.create_rule(rule_uri, rule_type)
with pytest.raises(ValueError):
db_access.add_assignee_to_rule(assignee_uri, rule_uri)
# Should add an assignee to a rule
db_access.create_party(assignee_uri)
db_access.add_assignee_to_rule(assignee_uri, rule_uri)
assert db_access.rule_has_assignee(rule_uri, assignee_uri)
# Should raise an exception if the rule already has that assignee
with pytest.raises(ValueError):
db_access.add_assignee_to_rule(assignee_uri, rule_uri)
def test_add_action_to_rule(mock):
# Should raise an exception if the rule doesn't exist
rule_uri = 'https://example.com#rule'
action_uri = 'http://www.w3.org/ns/odrl/2/distribute'
with pytest.raises(ValueError):
db_access.add_action_to_rule(action_uri, rule_uri)
# Should raise an exception if the action doesn't exist
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
db_access.create_rule(rule_uri, rule_type, rule_label)
action_uri = 'nonexistent'
with pytest.raises(ValueError):
db_access.add_action_to_rule(action_uri, rule_uri)
# Should add an action to a rule
action_uri = 'http://www.w3.org/ns/odrl/2/distribute'
db_access.add_action_to_rule(action_uri, rule_uri)
assert db_access.rule_has_action(rule_uri, action_uri)
# Should raise an exception if the rule already has that action
with pytest.raises(ValueError):
db_access.add_action_to_rule(action_uri, rule_uri)
def test_get_policies_using_action(mock):
action_uri = 'http://www.w3.org/ns/odrl/2/acceptTracking'
rule1_uri = 'https://example.com#rule1'
rule1_type = 'http://www.w3.org/ns/odrl/2/permission'
rule1_label = 'Rule1'
db_access.create_rule(rule1_uri, rule1_type, rule1_label)
db_access.add_action_to_rule(action_uri, rule1_uri)
rule2_uri = 'https://example.com#rule2'
rule2_type = 'http://www.w3.org/ns/odrl/2/permission'
rule2_label = 'Rule2'
db_access.create_rule(rule2_uri, rule2_type, rule2_label)
db_access.add_action_to_rule(action_uri, rule2_uri)
policy1_uri = 'http://example.com#policy1'
policy2_uri = 'http://example.com#policy2'
policy3_uri = 'http://example.com#policy3'
db_access.create_policy(policy1_uri)
db_access.create_policy(policy2_uri)
db_access.create_policy(policy3_uri)
db_access.add_rule_to_policy(rule1_uri, policy1_uri)
db_access.add_rule_to_policy(rule2_uri, policy2_uri)
db_access.add_rule_to_policy(rule2_uri, policy3_uri)
policies = db_access.get_policies_using_action(action_uri)
assert all(policy['URI'] in [policy1_uri, policy2_uri, policy3_uri]
for policy in policies)
def test_create_rule(mock):
# Should raise an exception when the rule type is not valid
rule_label = 'Rule'
with pytest.raises(ValueError):
db_access.create_rule('rule', 'invalid_type', rule_label)
# Should add a rule
rule_uri = 'http://example.com#rule'
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
db_access.create_rule(rule_uri, rule_type, rule_label)
assert db_access.rule_exists(rule_uri)
# Should raise an exception when that rule already exists
with pytest.raises(ValueError):
db_access.create_rule(rule_uri, rule_type, rule_label)
def test_get_rules_for_policy(mock):
# Should return a list of URIs for all Rules assigned to a Policy
policy_uri = 'https://example.com#policy'
db_access.create_policy(policy_uri)
rule_type = 'http://www.w3.org/ns/odrl/2/permission'
rule_label = 'Rule'
rule1_uri = 'https://example.com#rule1'
rule2_uri = 'https://example.com#rule2'
db_access.create_rule(rule1_uri, rule_type, rule_label)
db_access.create_rule(rule2_uri, rule_type, rule_label)
db_access.add_rule_to_policy(rule1_uri, policy_uri)
db_access.add_rule_to_policy(rule2_uri, policy_uri)
assert db_access.get_rules_for_policy(policy_uri) == [rule1_uri, rule2_uri]
# Shouldn't include any other Rules
rule3_uri = 'https://example.com#rule3'
db_access.create_rule(rule3_uri, rule_type, rule_label)
assert db_access.get_rules_for_policy(policy_uri) == [rule1_uri, rule2_uri]
def create_policy(policy_uri, attributes=None, rules=None):
"""
Creates an entire policy with the given URI, attributes and Rules.
Will attempt to use Rule Type and Actions whether they are given by URI or Label.
If there is an error at any point, will rollback all changes to database to avoid leaving partially created
policies.
:param policy_uri:
:param attributes: Dictionary of optional attributes of the policy.
Permitted attributes: type, label, jurisdiction, legal_code, has_version, language, see_also
same_as, comment, logo, status
:param rules: List of Rules. Each Rule should be a Dictionary containing the following elements:
TYPE_URI*: string (i.e. 'http://www.w3.org/ns/odrl/2/duty')
TYPE_LABEL*: string (i.e. 'duty')
* At least one of TYPE_URI or TYPE_LABEL should be provided, but both are not required
ASSIGNORS: List of Assignors. Each Assignor should be a Dictionary containing a URI, LABEL and COMMENT.
ASSIGNEES: List of Assignees. Each Assignee should be a Dictionary containing a URI, LABEL and COMMENT.
ACTIONS: List of strings (URIs or labels)
:return:
"""
if not is_valid_uri(policy_uri):
raise ValueError('Not a valid URI: ' + policy_uri)
permitted_rule_types = []
try:
db_access.create_policy(policy_uri)
if attributes:
for attr_name, attr_value in attributes.items():
db_access.set_policy_attribute(policy_uri, attr_name,
attr_value)
if rules:
for rule in rules:
rule_uri = _conf.BASE_URI + 'rules/' + str(uuid4())
if 'TYPE_URI' in rule:
rule_type = rule['TYPE_URI']
elif 'TYPE_LABEL' in rule:
if not permitted_rule_types:
permitted_rule_types = db_access.get_permitted_rule_types(
)
rule_type = get_rule_type_uri(rule['TYPE_LABEL'],
permitted_rule_types)
if not rule_type:
raise ValueError('Cannot create policy - Rule type ' +
rule['TYPE_LABEL'] +
' is not permitted')
else:
raise ValueError(
'Cannot create policy - no Rule type provided')
db_access.create_rule(rule_uri, rule_type)
for action in rule['ACTIONS']:
if action:
if is_valid_uri(action):
action_uri = action
else:
permitted_actions = db_access.get_all_actions()
action_uri = get_action_uri(
action, permitted_actions)
if not action_uri:
raise ValueError(
'Cannot create policy - Action ' + action +
' is not permitted')
db_access.add_action_to_rule(action_uri, rule_uri)
if 'ASSIGNORS' in rule:
for assignor in rule['ASSIGNORS']:
if not db_access.party_exists(assignor['URI']):
db_access.create_party(assignor['URI'],
assignor['LABEL'],
assignor['COMMENT'])
db_access.add_assignor_to_rule(assignor['URI'],
rule_uri)
if 'ASSIGNEES' in rule:
for assignee in rule['ASSIGNEES']:
if not db_access.party_exists(assignee['URI']):
db_access.create_party(assignee['URI'],
assignee['LABEL'],
assignee['COMMENT'])
db_access.add_assignee_to_rule(assignee['URI'],
rule_uri)
db_access.add_rule_to_policy(rule_uri, policy_uri)
except Exception as error:
db_access.rollback_db()
raise error
db_access.commit_db()
