Update code to 4.6 official version

Change-Id: Ibd0da0e476e24b2685f54693efc11f7a58d40a62

3 files changed, 490 insertions, 30 deletions

diff --git a/python_moondb/tests/unit_python/models/test_categories.py b/python_moondb/tests/unit_python/models/test_categories.py
index f87d0e12..39dc4c71 100644
--- a/python_moondb/tests/unit_python/models/test_categories.py
+++ b/python_moondb/tests/unit_python/models/test_categories.py
@@ -10,13 +10,24 @@ from helpers import category_helper
 
 logger = logging.getLogger("moon.db.tests.models.test_categories")
 
+
 def test_add_subject_category_twice():
-    category = category_helper.add_subject_category(value={"name": "category name", "description": "description 1"})
+    category = category_helper.add_subject_category(
+        value={"name": "category name", "description": "description 1"})
     category_id = list(category.keys())[0]
     assert category is not None
     with pytest.raises(SubjectCategoryExisting):
         category_helper.add_subject_category(category_id,
-                                             value={"name": "category name", "description": "description 2"})
+                                             value={"name": "category name",
+                                                    "description": "description 2"})
+
+
+def test_add_subject_category_name_space():
+    with pytest.raises(CategoryNameInvalid) as exp:
+        category = category_helper.add_subject_category(value={"name": " ", "description":
+            "description 1"})
+    assert exp.value.code == 400
+    assert exp.value.description == 'The given category name is invalid.'
 
 
 def test_get_subject_categories():
@@ -34,12 +45,22 @@ def test_get_subject_categories_with_invalid_id():
 
 
 def test_add_object_category_twice():
-    category = category_helper.add_object_category(value={"name": "category name", "description": "description 1"})
+    category = category_helper.add_object_category(
+        value={"name": "category name", "description": "description 1"})
     category_id = list(category.keys())[0]
     assert category is not None
     with pytest.raises(ObjectCategoryExisting):
         category_helper.add_object_category(category_id,
-                                            value={"name": "category name", "description": "description 2"})
+                                            value={"name": "category name",
+                                                   "description": "description 2"})
+
+
+def test_add_object_category_name_space():
+    with pytest.raises(CategoryNameInvalid) as exp:
+        category = category_helper.add_object_category(value={"name": " ", "description":
+            "description 1"})
+    assert exp.value.code == 400
+    assert exp.value.description == 'The given category name is invalid.'
 
 
 def test_get_object_categories():
@@ -57,12 +78,23 @@ def test_get_object_categories_with_invalid_id():
 
 
 def test_add_action_category_twice():
-    category = category_helper.add_action_category(value={"name": "category name", "description": "description 1"})
+    category = category_helper.add_action_category(
+        value={"name": "category name", "description": "description 1"})
     category_id = list(category.keys())[0]
     assert category is not None
-    with pytest.raises(ActionCategoryExisting):
+    with pytest.raises(ActionCategoryExisting) as exp_info:
         category_helper.add_action_category(category_id,
-                                            value={"name": "category name", "description": "description 2"})
+                                            value={"name": "category name",
+                                                   "description": "description 2"})
+    assert str(exp_info.value)=='409: Action Category Existing'
+
+
+def test_add_action_category_name_space():
+    with pytest.raises(CategoryNameInvalid) as exp:
+        category = category_helper.add_action_category(value={"name": " ", "description":
+            "description 1"})
+    assert exp.value.code == 400
+    assert exp.value.description == 'The given category name is invalid.'
 
 
 def test_get_action_categories():
diff --git a/python_moondb/tests/unit_python/models/test_meta_rules.py b/python_moondb/tests/unit_python/models/test_meta_rules.py
index 102cd724..3b2b5b0e 100644
--- a/python_moondb/tests/unit_python/models/test_meta_rules.py
+++ b/python_moondb/tests/unit_python/models/test_meta_rules.py
@@ -5,16 +5,88 @@
 
 import pytest
 from helpers import meta_rule_helper
+from helpers import policy_helper
 import helpers.mock_data as mock_data
+import helpers.model_helper as model_helper
+from python_moonutilities.exceptions import *
+from uuid import uuid4
 
 
-def test_set_not_exist_meta_rule_error(db):
+def test_update_not_exist_meta_rule_error(db):
     # set not existing meta rule and expect to raise and error
-    with pytest.raises(Exception) as exception_info:
-        meta_rule_helper.set_meta_rule(meta_rule_id=None)
+    with pytest.raises(MetaRuleUnknown) as exception_info:
+        meta_rule_helper.update_meta_rule(meta_rule_id=None)
     assert str(exception_info.value) == '400: Meta Rule Unknown'
 
 
+def test_update_meta_rule_connected_with_policy_and_rule():
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy(
+        subject_category_name="subject_category1",
+        object_category_name="object_category1",
+        action_category_name="action_category1",
+        meta_rule_name="meta_rule_1",
+        model_name="model1")
+    subject_data_id = mock_data.create_subject_data(policy_id=policy_id,
+                                                    category_id=subject_category_id)
+    object_data_id = mock_data.create_object_data(policy_id=policy_id,
+                                                  category_id=object_category_id)
+    action_data_id = mock_data.create_action_data(policy_id=policy_id,
+                                                  category_id=action_category_id)
+
+    value = {
+        "rule": (subject_data_id, object_data_id, action_data_id),
+        "instructions": ({"decision": "grant"}),
+        "enabled": "",
+    }
+
+    rules = policy_helper.add_rule(policy_id=policy_id, meta_rule_id=meta_rule_id, value=value)
+    assert rules
+    assert len(rules) == 1
+
+    action_category_id = mock_data.create_action_category("action_category_id2")
+    subject_category_id = mock_data.create_subject_category("subject_category_id2")
+    object_category_id = mock_data.create_object_category("object_category_id2")
+
+    updated_value = {
+        "name": "MLS_meta_rule",
+        "description": "test",
+        "subject_categories": [subject_category_id],
+        "object_categories": [object_category_id],
+        "action_categories": [action_category_id]
+    }
+    with pytest.raises(MetaRuleUpdateError) as exception_info:
+        updated_meta_rule = meta_rule_helper.update_meta_rule(meta_rule_id, updated_value)
+    assert str(exception_info.value) == '400: Meta_Rule Update Error'
+
+
+def test_update_meta_rule_connected_with_policy(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy(
+        subject_category_name="subject_category1",
+        object_category_name="object_category1",
+        action_category_name="action_category1",
+        meta_rule_name="meta_rule_1",
+        model_name="model1")
+    action_category_id = mock_data.create_action_category("action_category_id2")
+    subject_category_id = mock_data.create_subject_category("subject_category_id2")
+    object_category_id = mock_data.create_object_category("object_category_id2")
+    value = {
+        "name": "MLS_meta_rule",
+        "description": "test",
+        "subject_categories": [subject_category_id],
+        "object_categories": [object_category_id],
+        "action_categories": [action_category_id]
+    }
+    meta_rules = meta_rule_helper.add_meta_rule(value=value)
+    assert isinstance(meta_rules, dict)
+    assert meta_rules
+    assert len(meta_rules) is 1
+    meta_rule_id = list(meta_rules.keys())[0]
+    for key in (
+    "name", "description", "subject_categories", "object_categories", "action_categories"):
+        assert key in meta_rules[meta_rule_id]
+        assert meta_rules[meta_rule_id][key] == value[key]
+
+
 def test_add_new_meta_rule_success(db):
     action_category_id = mock_data.create_action_category("action_category_id1")
     subject_category_id = mock_data.create_subject_category("subject_category_id1")
@@ -31,12 +103,29 @@ def test_add_new_meta_rule_success(db):
     assert meta_rules
     assert len(meta_rules) is 1
     meta_rule_id = list(meta_rules.keys())[0]
-    for key in ("name", "description", "subject_categories", "object_categories", "action_categories"):
+    for key in (
+    "name", "description", "subject_categories", "object_categories", "action_categories"):
         assert key in meta_rules[meta_rule_id]
         assert meta_rules[meta_rule_id][key] == value[key]
 
 
-def test_set_meta_rule_success(db):
+def test_meta_rule_with_blank_name(db):
+    action_category_id = mock_data.create_action_category(uuid4().hex)
+    subject_category_id = mock_data.create_subject_category(uuid4().hex)
+    object_category_id = mock_data.create_object_category(uuid4().hex)
+    value = {
+        "name": "",
+        "description": "test",
+        "subject_categories": [subject_category_id],
+        "object_categories": [object_category_id],
+        "action_categories": [action_category_id]
+    }
+    with pytest.raises(MetaRuleContentError) as exception_info:
+        meta_rule_helper.add_meta_rule(value=value)
+    assert str(exception_info.value) == '400: Meta Rule Error'
+
+
+def test_update_meta_rule_success(db):
     # arrange
     meta_rules = meta_rule_helper.add_meta_rule()
     meta_rule_id = list(meta_rules.keys())[0]
@@ -51,11 +140,79 @@ def test_set_meta_rule_success(db):
         "action_categories": [action_category_id]
     }
     # action
-    updated_meta_rule = meta_rule_helper.set_meta_rule(meta_rule_id, updated_value)
+    updated_meta_rule = meta_rule_helper.update_meta_rule(meta_rule_id, updated_value)
     # assert
     updated_meta_rule_id = list(updated_meta_rule.keys())[0]
     assert updated_meta_rule_id == meta_rule_id
-    assert updated_meta_rule[updated_meta_rule_id]["subject_categories"] == updated_value["subject_categories"]
+    assert updated_meta_rule[updated_meta_rule_id]["subject_categories"] == updated_value[
+        "subject_categories"]
+
+
+def test_update_meta_rule_with_existed_categories_combination(db):
+    action_category_id1 = mock_data.create_action_category(uuid4().hex)
+    subject_category_id1 = mock_data.create_subject_category(uuid4().hex)
+    object_category_id1 = mock_data.create_object_category(uuid4().hex)
+    meta_rule_name1=uuid4().hex
+    value1 = {
+        "name": meta_rule_name1,
+        "description": "test",
+        "subject_categories": [subject_category_id1],
+        "object_categories": [object_category_id1],
+        "action_categories": [action_category_id1]
+    }
+    meta_rules = meta_rule_helper.add_meta_rule(value=value1)
+
+    action_category_id2 = mock_data.create_action_category(uuid4().hex)
+    subject_category_id2 = mock_data.create_subject_category(uuid4().hex)
+    object_category_id2 = mock_data.create_object_category(uuid4().hex)
+    meta_rule_name2 = uuid4().hex
+    value2 = {
+        "name": meta_rule_name2,
+        "description": "test",
+        "subject_categories": [subject_category_id2],
+        "object_categories": [object_category_id2],
+        "action_categories": [action_category_id2]
+    }
+    meta_rules = meta_rule_helper.add_meta_rule(value=value2)
+    meta_rule_id2 = list(meta_rules.keys())[0]
+    value1['name']=value2['name']
+    with pytest.raises(MetaRuleExisting) as exception_info:
+         updated_meta_rule = meta_rule_helper.update_meta_rule(meta_rule_id2, value1)
+    assert str(exception_info.value) == '409: Meta Rule Existing'
+    assert exception_info.value.description=="Same categories combination existed"
+
+
+def test_update_meta_rule_with_different_categories_combination_but_same_data(db):
+    action_category_id1 = mock_data.create_action_category(uuid4().hex)
+    subject_category_id1 = mock_data.create_subject_category(uuid4().hex)
+    object_category_id1 = mock_data.create_object_category(uuid4().hex)
+    meta_rule_name1=uuid4().hex
+    value1 = {
+        "name": meta_rule_name1,
+        "description": "test",
+        "subject_categories": [subject_category_id1],
+        "object_categories": [object_category_id1],
+        "action_categories": [action_category_id1]
+    }
+    meta_rules = meta_rule_helper.add_meta_rule(value=value1)
+
+    action_category_id2 = mock_data.create_action_category(uuid4().hex)
+    subject_category_id2 = mock_data.create_subject_category(uuid4().hex)
+    object_category_id2 = mock_data.create_object_category(uuid4().hex)
+    meta_rule_name2 = uuid4().hex
+    value2 = {
+        "name": meta_rule_name2,
+        "description": "test",
+        "subject_categories": [subject_category_id2],
+        "object_categories": [object_category_id2],
+        "action_categories": [action_category_id2]
+    }
+    meta_rules = meta_rule_helper.add_meta_rule(value=value2)
+    meta_rule_id2 = list(meta_rules.keys())[0]
+    value1['name']=value2['name']
+    value1['object_categories']+=[object_category_id1]
+    updated_meta_rule = meta_rule_helper.update_meta_rule(meta_rule_id2, value1)
+    assert meta_rule_id2 in updated_meta_rule
 
 
 def test_add_existing_meta_rule_error(db):
@@ -71,9 +228,85 @@ def test_add_existing_meta_rule_error(db):
     }
     meta_rules = meta_rule_helper.add_meta_rule(value=value)
     meta_rule_id = list(meta_rules.keys())[0]
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(MetaRuleExisting) as exception_info:
         meta_rule_helper.add_meta_rule(meta_rule_id=meta_rule_id)
-    assert str(exception_info.value) == '400: Sub Meta Rule Existing'
+    assert str(exception_info.value) == '409: Meta Rule Existing'
+
+
+def test_add_meta_rule_with_existing_name_error(db):
+    action_category_id = mock_data.create_action_category(uuid4().hex)
+    subject_category_id = mock_data.create_subject_category(uuid4().hex)
+    object_category_id = mock_data.create_object_category(uuid4().hex)
+    name = uuid4().hex
+    value = {
+        "name": name,
+        "description": "test",
+        "subject_categories": [subject_category_id],
+        "object_categories": [object_category_id],
+        "action_categories": [action_category_id]
+    }
+    meta_rule_helper.add_meta_rule(value=value)
+    action_category_id = mock_data.create_action_category(uuid4().hex)
+    subject_category_id = mock_data.create_subject_category(uuid4().hex)
+    object_category_id = mock_data.create_object_category(uuid4().hex)
+    value = {
+        "name": name,
+        "description": 'test',
+        "subject_categories": [subject_category_id],
+        "object_categories": [object_category_id],
+        "action_categories": [action_category_id]
+    }
+    with pytest.raises(MetaRuleExisting) as exception_info:
+        meta_rule_helper.add_meta_rule(value=value)
+    assert str(exception_info.value) == '409: Meta Rule Existing'
+    assert exception_info.value.description == 'The meta rule already exists.'
+
+
+def test_add_meta_rule_with_existing_categories_combination(db):
+    action_category_id = mock_data.create_action_category(uuid4().hex)
+    subject_category_id = mock_data.create_subject_category(uuid4().hex)
+    object_category_id = mock_data.create_object_category(uuid4().hex)
+    name = uuid4().hex
+    value = {
+        "name": name,
+        "description": "test",
+        "subject_categories": [subject_category_id],
+        "object_categories": [object_category_id],
+        "action_categories": [action_category_id]
+    }
+    meta_rule_helper.add_meta_rule(value=value)
+    value['name'] = uuid4().hex
+    with pytest.raises(MetaRuleExisting) as exception_info:
+        meta_rule_helper.add_meta_rule(value=value)
+    assert str(exception_info.value) == '409: Meta Rule Existing'
+    assert exception_info.value.description == "Same categories combination existed"
+
+
+def test_add_meta_rule_with_different_categories_combination_but_same_data(db):
+    action_category_id = mock_data.create_action_category(uuid4().hex)
+    subject_category_id = mock_data.create_subject_category(uuid4().hex)
+    object_category_id1 = mock_data.create_object_category(uuid4().hex)
+    object_category_id2 = mock_data.create_object_category(uuid4().hex)
+
+    name1 = uuid4().hex
+    value = {
+        "name": name1,
+        "description": "test",
+        "subject_categories": [subject_category_id],
+        "object_categories": [object_category_id1],
+        "action_categories": [action_category_id]
+    }
+    meta_rule_helper.add_meta_rule(value=value)
+    name2 = uuid4().hex
+    value['name'] = name2
+    value['object_categories'] += [object_category_id2]
+    meta_rules = meta_rule_helper.add_meta_rule(value=value)
+    bool_found_meta_rule = 0
+    for meta_rule_id in meta_rules:
+        if meta_rules[meta_rule_id]['name'] == name2:
+            bool_found_meta_rule = 1
+            break
+    assert bool_found_meta_rule
 
 
 def test_get_meta_rule_success(db):
@@ -113,7 +346,8 @@ def test_get_meta_rule_success(db):
     assert meta_rules
     assert len(meta_rules) is 2
     for meta_rule_id in meta_rules:
-        for key in ("name", "description", "subject_categories", "object_categories", "action_categories"):
+        for key in (
+        "name", "description", "subject_categories", "object_categories", "action_categories"):
             assert key in meta_rules[meta_rule_id]
             assert meta_rules[meta_rule_id][key] == values[meta_rule_id][key]
 
@@ -127,7 +361,8 @@ def test_get_specific_meta_rule_success(db):
     meta_rule_id = list(meta_rules.keys())[0]
     # assert
     assert meta_rule_id == added_meta_rule_id
-    for key in ("name", "description", "subject_categories", "object_categories", "action_categories"):
+    for key in (
+    "name", "description", "subject_categories", "object_categories", "action_categories"):
         assert key in meta_rules[meta_rule_id]
         assert meta_rules[meta_rule_id][key] == added_meta_rules[added_meta_rule_id][key]
 
@@ -154,7 +389,15 @@ def test_delete_meta_rules_success(db):
     assert meta_rule_id1 not in meta_rules
 
 
+def test_delete_meta_rules_with_model(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+
+    with pytest.raises(DeleteMetaRuleWithModel) as exception_info:
+        meta_rule_helper.delete_meta_rules(meta_rule_id)
+    assert str(exception_info.value) == '400: Meta rule With Model Error'
+
+
 def test_delete_invalid_meta_rules_error(db):
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(MetaRuleUnknown) as exception_info:
         meta_rule_helper.delete_meta_rules("INVALID_META_RULE_ID")
     assert str(exception_info.value) == '400: Meta Rule Unknown'
diff --git a/python_moondb/tests/unit_python/models/test_models.py b/python_moondb/tests/unit_python/models/test_models.py
index 0026345c..1b171069 100644
--- a/python_moondb/tests/unit_python/models/test_models.py
+++ b/python_moondb/tests/unit_python/models/test_models.py
@@ -10,6 +10,8 @@ import helpers.mock_data as mock_data
 import helpers.model_helper as model_helper
 import helpers.category_helper as category_helper
 import helpers.policy_helper as policy_helper
+import helpers.assignment_helper as assignment_helper
+from uuid import uuid4
 
 logger = logging.getLogger("moon.db.tests.test_model")
 
@@ -83,7 +85,7 @@ def test_add_same_model_twice(db):
     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'
+    assert str(exception_info.value) == '409: Model Error'
 
 
 def test_add_model_generate_new_uuid(db):
@@ -148,9 +150,34 @@ def test_add_models_with_same_name_twice(db):
     models = model_helper.add_model(value=model_value1)
     assert isinstance(models, dict)
     assert models
-    with pytest.raises(Exception) as exc_info:
+    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_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_delete_models(db):
@@ -240,6 +267,7 @@ def test_delete_model_assigned_to_policy(db):
     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_subject_category(db):
@@ -253,13 +281,32 @@ def test_add_subject_category(db):
     assert len(subject_category) == 1
 
 
+def test_add_subject_categories_with_existed_name(db):
+    name = uuid4().hex
+    value = {
+        "name": name,
+        "description": "description subject_category"
+    }
+    subject_category = category_helper.add_subject_category(value=value)
+    assert subject_category
+    assert len(subject_category) == 1
+
+    value = {
+        "name": name,
+        "description": "description subject_category"
+    }
+    with pytest.raises(SubjectCategoryExisting) as exception_info:
+        category_helper.add_subject_category(value=value)
+    assert str(exception_info.value) == '409: Subject Category Existing'
+
+
 def test_add_subject_category_with_empty_name(db):
     category_id = "category_id1"
     value = {
         "name": "",
         "description": "description subject_category"
     }
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(CategoryNameInvalid) as exception_info:
         category_helper.add_subject_category(category_id, value)
     assert str(exception_info.value) == '400: Category Name Invalid'
 
@@ -271,7 +318,7 @@ def test_add_subject_category_with_same_category_id(db):
         "description": "description subject_category"
     }
     category_helper.add_subject_category(category_id, value)
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(SubjectCategoryExisting) as exception_info:
         category_helper.add_subject_category(category_id, value)
     assert str(exception_info.value) == '409: Subject Category Existing'
 
@@ -299,10 +346,41 @@ def test_delete_subject_category(db):
     assert not subject_category
 
 
+def test_delete_subject_category_with_data(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+
+    mock_data.create_subject_data(policy_id, subject_category_id)
+
+    with pytest.raises(DeleteSubjectCategoryWithMetaRule) as exception_info:
+        category_helper.delete_subject_category(subject_category_id)
+    assert str(exception_info.value) == '400: Subject Category With Meta Rule Error'
+
+
+def test_delete_subject_category_with_assignment(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+
+    subject_id = mock_data.create_subject(policy_id)
+    data_id = mock_data.create_subject_data(policy_id, subject_category_id)
+    assignment_helper.add_subject_assignment(policy_id, subject_id, subject_category_id, data_id)
+
+    with pytest.raises(DeleteSubjectCategoryWithMetaRule) as exception_info:
+        category_helper.delete_subject_category(subject_category_id)
+    assert str(exception_info.value) == '400: Subject Category With Meta Rule Error'
+
+
+def test_delete_subject_category_with_rule(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+    policy_helper.add_rule(policy_id=policy_id, meta_rule_id=meta_rule_id)
+
+    with pytest.raises(DeleteSubjectCategoryWithMetaRule) as exception_info:
+        category_helper.delete_subject_category(subject_category_id)
+    assert str(exception_info.value) == '400: Subject Category With Meta Rule Error'
+
+
 def test_delete_subject_category_with_unkown_category_id(db):
     category_id = "invalid_category_id"
 
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(SubjectCategoryUnknown) as exception_info:
         category_helper.delete_subject_category(category_id)
     assert str(exception_info.value) == '400: Subject Category Unknown'
 
@@ -318,6 +396,20 @@ def test_add_object_category(db):
     assert len(object_category) == 1
 
 
+def test_add_object_categories_with_existed_name(db):
+    name = uuid4().hex
+    value = {
+        "name": name,
+        "description": "description object_category"
+    }
+    object_category = category_helper.add_object_category(value=value)
+    assert object_category
+    assert len(object_category) == 1
+    with pytest.raises(ObjectCategoryExisting) as exception_info:
+        category_helper.add_object_category(value=value)
+    assert str(exception_info.value) == '409: Object Category Existing'
+
+
 def test_add_object_category_with_same_category_id(db):
     category_id = "category_id1"
     value = {
@@ -325,7 +417,7 @@ def test_add_object_category_with_same_category_id(db):
         "description": "description object_category"
     }
     category_helper.add_object_category(category_id, value)
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(ObjectCategoryExisting) as exception_info:
         category_helper.add_object_category(category_id, value)
     assert str(exception_info.value) == '409: Object Category Existing'
 
@@ -336,7 +428,7 @@ def test_add_object_category_with_empty_name(db):
         "name": "",
         "description": "description object_category"
     }
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(CategoryNameInvalid) as exception_info:
         category_helper.add_object_category(category_id, value)
     assert str(exception_info.value) == '400: Category Name Invalid'
 
@@ -364,10 +456,42 @@ def test_delete_object_category(db):
     assert not object_category
 
 
+def test_delete_object_category_with_data(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+    mock_data.create_subject_data(policy_id, subject_category_id)
+
+    mock_data.create_object_data(policy_id, object_category_id)
+
+    with pytest.raises(DeleteObjectCategoryWithMetaRule) as exception_info:
+        category_helper.delete_object_category(object_category_id)
+    assert str(exception_info.value) == '400: Object Category With Meta Rule Error'
+
+
+def test_delete_object_category_with_assignment(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+
+    object_id = mock_data.create_object(policy_id)
+    data_id = mock_data.create_object_data(policy_id, object_category_id)
+    assignment_helper.add_object_assignment(policy_id, object_id, object_category_id, data_id)
+
+    with pytest.raises(DeleteObjectCategoryWithMetaRule) as exception_info:
+        category_helper.delete_object_category(object_category_id)
+    assert str(exception_info.value) == '400: Object Category With Meta Rule Error'
+
+
+def test_delete_object_category_with_rule(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+    policy_helper.add_rule(policy_id=policy_id, meta_rule_id=meta_rule_id)
+
+    with pytest.raises(DeleteObjectCategoryWithMetaRule) as exception_info:
+        category_helper.delete_object_category(object_category_id)
+    assert str(exception_info.value) == '400: Object Category With Meta Rule Error'
+
+
 def test_delete_object_category_with_unkown_category_id(db):
     category_id = "invalid_category_id"
 
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(ObjectCategoryUnknown) as exception_info:
         category_helper.delete_object_category(category_id)
     assert str(exception_info.value) == '400: Object Category Unknown'
 
@@ -383,6 +507,20 @@ def test_add_action_category(db):
     assert len(action_category) == 1
 
 
+def test_add_action_categories_with_existed_name(db):
+    name = uuid4().hex
+    value = {
+        "name": name,
+        "description": "description action_category"
+    }
+    action_category = category_helper.add_action_category(value=value)
+    assert action_category
+    assert len(action_category) == 1
+    with pytest.raises(ActionCategoryExisting) as exception_info:
+        category_helper.add_action_category(value=value)
+    assert str(exception_info.value) == '409: Action Category Existing'
+
+
 def test_add_action_category_with_same_category_id(db):
     category_id = "category_id1"
     value = {
@@ -390,7 +528,7 @@ def test_add_action_category_with_same_category_id(db):
         "description": "description action_category"
     }
     category_helper.add_action_category(category_id, value)
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(ActionCategoryExisting) as exception_info:
         category_helper.add_action_category(category_id, value)
     assert str(exception_info.value) == '409: Action Category Existing'
 
@@ -401,7 +539,7 @@ def test_add_action_category_with_empty_name(db):
         "name": "",
         "description": "description action_category"
     }
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(CategoryNameInvalid) as exception_info:
         category_helper.add_action_category(category_id, value)
     assert str(exception_info.value) == '400: Category Name Invalid'
 
@@ -429,9 +567,56 @@ def test_delete_action_category(db):
     assert not action_category
 
 
+def test_delete_action_category_with_data(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+    mock_data.create_subject_data(policy_id, subject_category_id)
+
+    mock_data.create_action_data(policy_id, action_category_id)
+
+    with pytest.raises(DeleteActionCategoryWithMetaRule) as exception_info:
+        category_helper.delete_action_category(action_category_id)
+    assert str(exception_info.value) == '400: Action Category With Meta Rule Error'
+
+
+def test_delete_action_category_with_assignment(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+
+    action_id = mock_data.create_action(policy_id)
+    data_id = mock_data.create_action_data(policy_id, action_category_id)
+    assignment_helper.add_action_assignment(policy_id, action_id, action_category_id, data_id)
+
+    with pytest.raises(DeleteActionCategoryWithMetaRule) as exception_info:
+        category_helper.delete_action_category(action_category_id)
+    assert str(exception_info.value) == '400: Action Category With Meta Rule Error'
+
+
+def test_delete_action_category_with_rule(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+    policy_helper.add_rule(policy_id=policy_id, meta_rule_id=meta_rule_id)
+
+    with pytest.raises(DeleteActionCategoryWithMetaRule) as exception_info:
+        category_helper.delete_action_category(action_category_id)
+    assert str(exception_info.value) == '400: Action Category With Meta Rule Error'
+
+
 def test_delete_action_category_with_unkown_category_id(db):
     category_id = "invalid_category_id"
 
-    with pytest.raises(Exception) as exception_info:
+    with pytest.raises(ActionCategoryUnknown) as exception_info:
         category_helper.delete_action_category(category_id)
     assert str(exception_info.value) == '400: Action Category Unknown'
+
+
+def test_delete_data_categories_connected_to_meta_rule(db):
+    subject_category_id, object_category_id, action_category_id, meta_rule_id, policy_id = mock_data.create_new_policy()
+    with pytest.raises(DeleteSubjectCategoryWithMetaRule) as exception_info:
+        category_helper.delete_subject_category(subject_category_id)
+    assert str(exception_info.value) == '400: Subject Category With Meta Rule Error'
+
+    with pytest.raises(DeleteObjectCategoryWithMetaRule) as exception_info:
+        category_helper.delete_object_category(object_category_id)
+    assert str(exception_info.value) == '400: Object Category With Meta Rule Error'
+
+    with pytest.raises(DeleteActionCategoryWithMetaRule) as exception_info:
+        category_helper.delete_action_category(action_category_id)
+    assert str(exception_info.value) == '400: Action Category With Meta Rule Error'