Tests: create_class failure cases added

runtime-modules/content-directory/src/lib.rs

@@ -841,9 +841,9 @@ decl_module! {
             // Ensure ClassDescriptionLengthConstraint conditions satisfied
             Self::ensure_class_description_is_valid(&description)?;
 
-            // Perform required checks to ensure classs_maintainers under provided class_permissions are valid
-            let classs_maintainers = class_permissions.get_maintainers();
-            Self::ensure_class_maintainers_are_valid(classs_maintainers)?;
+            // Perform required checks to ensure class_maintainers under provided class_permissions are valid
+            let class_maintainers = class_permissions.get_maintainers();
+            Self::ensure_class_maintainers_are_valid(class_maintainers)?;
 
             //
             // == MUTATION SAFE ==
@@ -883,7 +883,7 @@ decl_module! {
             // Ensure Class under given id exists, return corresponding one
             let class = Self::ensure_known_class_id(class_id)?;
 
-            // Perform required checks to ensure classs_maintainers are valid
+            // Perform required checks to ensure class_maintainers are valid
             if let Some(ref updated_maintainers) = updated_maintainers {
                 Self::ensure_class_maintainers_are_valid(updated_maintainers)?;
             }

runtime-modules/content-directory/src/mock.rs

@@ -1,9 +1,8 @@
 #![cfg(test)]
 
-use crate::*;
-use std::cell::RefCell;
-
 use crate::InputValidationLengthConstraint;
+use crate::*;
+use core::iter::FromIterator;
 use primitives::H256;
 use runtime_primitives::{
     testing::Header,
@@ -12,6 +11,7 @@ use runtime_primitives::{
 };
 pub use srml_support::{assert_err, assert_ok};
 use srml_support::{impl_outer_event, impl_outer_origin, parameter_types};
+use std::cell::RefCell;
 
 /// Runtime Types
 
@@ -55,6 +55,8 @@ pub const SECOND_ENTITY_ID: EntityId = 2;
 // pub const UNKNOWN_PROPERTY_ID: PropertyId = 333;
 // pub const UNKNOWN_SCHEMA_ID: SchemaId = 444;
 
+pub const UNKNOWN_CURATOR_GROUP_ID: CuratorGroupId = 555;
+
 pub const FIRST_SCHEMA_ID: SchemaId = 0;
 pub const SECOND_SCHEMA_ID: SchemaId = 1;
 
@@ -317,7 +319,7 @@ impl Default for ExtBuilder {
             class_name_constraint: InputValidationLengthConstraint::new(1, 49),
             class_description_constraint: InputValidationLengthConstraint::new(0, 500),
 
-            max_number_of_classes: 1000,
+            max_number_of_classes: 100,
             max_number_of_maintainers_per_class: 10,
             max_number_of_schemas_per_class: 20,
             max_number_of_properties_per_class: 40,
@@ -509,22 +511,67 @@ pub fn curator_group_exists(curator_group_id: CuratorGroupId) -> bool {
 
 // Classes
 
-pub fn create_class_with_default_permissions() -> Class<Runtime> {
-    Class::new(
-        ClassPermissions::default(),
-        generate_text(ClassNameLengthConstraint::get().max() as usize),
-        generate_text(ClassDescriptionLengthConstraint::get().max() as usize),
-        MaxNumberOfEntitiesPerClass::get(),
-        IndividualEntitiesCreationLimit::get(),
-    )
-}
+pub enum ClassType {
+    Valid,
+    InvalidName,
+    InvalidDescription,
+    InvalidMaximumEntitiesCount,
+    InvalidDefaultVoucherUpperBound,
+    DefaultVoucherUpperBoundExceedsMaximumEntitiesCount,
+    MaintainersLimitReached,
+    CuratorGroupDoesNotExist,
+}
+
+pub fn create_simple_class(lead_origin: u64, class_type: ClassType) -> Result<(), &'static str> {
+    let mut class = create_class_with_default_permissions();
+    match class_type {
+        ClassType::Valid => (),
+        ClassType::InvalidName => {
+            class.name = generate_text(ClassNameLengthConstraint::get().max() as usize + 1);
+        }
+        ClassType::InvalidDescription => {
+            class.description =
+                generate_text(ClassDescriptionLengthConstraint::get().max() as usize + 1);
+        }
+        ClassType::InvalidMaximumEntitiesCount => {
+            class.maximum_entities_count = MaxNumberOfEntitiesPerClass::get() + 1;
+        }
+        ClassType::InvalidDefaultVoucherUpperBound => {
+            class.default_entity_creation_voucher_upper_bound =
+                IndividualEntitiesCreationLimit::get() + 1;
+        }
+        ClassType::DefaultVoucherUpperBoundExceedsMaximumEntitiesCount => {
+            class.default_entity_creation_voucher_upper_bound = 5;
 
-pub fn create_simple_class_with_default_permissions(lead_origin: u64) -> Result<(), &'static str> {
+            class.maximum_entities_count = 3;
+        }
+        ClassType::MaintainersLimitReached => {
+            let mut maintainers = BTreeSet::new();
+            for curator_group_id in 1..=MaxNumberOfMaintainersPerClass::get() {
+                maintainers.insert(curator_group_id as CuratorGroupId);
+            }
+            class.get_permissions_mut().set_maintainers(maintainers);
+        }
+        ClassType::CuratorGroupDoesNotExist => {
+            let maintainers = BTreeSet::from_iter(vec![UNKNOWN_CURATOR_GROUP_ID].into_iter());
+            class.get_permissions_mut().set_maintainers(maintainers);
+        }
+    };
     TestModule::create_class(
         Origin::signed(lead_origin),
+        class.name,
+        class.description,
+        class.class_permissions,
+        class.maximum_entities_count,
+        class.default_entity_creation_voucher_upper_bound,
+    )
+}
+
+pub fn create_class_with_default_permissions() -> Class<Runtime> {
+    Class::new(
+        ClassPermissions::default(),
         generate_text(ClassNameLengthConstraint::get().max() as usize),
         generate_text(ClassDescriptionLengthConstraint::get().max() as usize),
-        ClassPermissions::default(),
         MaxNumberOfEntitiesPerClass::get(),
         IndividualEntitiesCreationLimit::get(),
     )

runtime-modules/content-directory/src/tests.rs

@@ -27,10 +27,10 @@ use core::iter::FromIterator;
 
 pub fn add_entity_schemas_support() -> (Entity<Runtime>, Entity<Runtime>) {
     // Create first class with default permissions
-    assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+    assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
     // Create second class with default permissions
-    assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+    assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
     let actor = Actor::Lead;
 

runtime-modules/content-directory/src/tests/add_class_schema.rs

@@ -4,7 +4,7 @@ use super::*;
 fn add_class_schema_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Runtime tested state before call
 

runtime-modules/content-directory/src/tests/add_maintainer_to_class.rs

@@ -4,7 +4,7 @@ use super::*;
 fn add_maintainer_to_class_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Add curator group
         assert_ok!(add_curator_group(LEAD_ORIGIN));

runtime-modules/content-directory/src/tests/create_class.rs

@@ -12,7 +12,7 @@ fn create_class_success() {
         assert!(!class_exists(FIRST_CLASS_ID));
 
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Runtime tested state after call
 
@@ -26,3 +26,204 @@ fn create_class_success() {
         assert_event_success(class_created_event, number_of_events_before_call + 1);
     })
 }
+
+#[test]
+fn create_class_lead_auth_failed() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        // An attempt to create class with non lead origin
+        let create_class_result = create_simple_class(FIRST_MEMBER_ORIGIN, ClassType::Valid);
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_LEAD_AUTH_FAILED,
+            number_of_events_before_call,
+        );
+    })
+}
+
+#[test]
+fn create_class_limit_reached() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        let mut number_of_classes_created = 0;
+
+        // Creating classes before limit reached
+        let create_class_result = loop {
+            let create_class_result = create_simple_class(LEAD_ORIGIN, ClassType::Valid);
+            if create_class_result.is_err() {
+                break create_class_result;
+            } else {
+                number_of_classes_created += 1;
+            }
+        };
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_CLASS_LIMIT_REACHED,
+            number_of_events_before_call + number_of_classes_created,
+        );
+    })
+}
+
+#[test]
+fn create_class_name_is_too_long() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        // An attempt to create class with invalid name
+        let create_class_result = create_simple_class(LEAD_ORIGIN, ClassType::InvalidName);
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_CLASS_NAME_TOO_LONG,
+            number_of_events_before_call,
+        );
+    })
+}
+
+#[test]
+fn create_class_description_is_too_long() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        // An attempt to create class with invalid description
+        let create_class_result = create_simple_class(LEAD_ORIGIN, ClassType::InvalidDescription);
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_CLASS_DESCRIPTION_TOO_LONG,
+            number_of_events_before_call,
+        );
+    })
+}
+
+#[test]
+fn create_class_invalid_maximum_entities_count() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        // An attempt to create class with invalid maximum entities count value
+        let create_class_result =
+            create_simple_class(LEAD_ORIGIN, ClassType::InvalidMaximumEntitiesCount);
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_ENTITIES_NUMBER_PER_CLASS_CONSTRAINT_VIOLATED,
+            number_of_events_before_call,
+        );
+    })
+}
+
+#[test]
+fn create_class_invalid_default_voucher_upper_bound() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        // An attempt to create class with invalid default voucher upper bound value
+        let create_class_result =
+            create_simple_class(LEAD_ORIGIN, ClassType::InvalidDefaultVoucherUpperBound);
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_NUMBER_OF_CLASS_ENTITIES_PER_ACTOR_CONSTRAINT_VIOLATED,
+            number_of_events_before_call,
+        );
+    })
+}
+
+#[test]
+fn create_class_per_controller_creation_limit_exceeds_overall_limit() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        // An attempt to create class with per controller creation limit that exceeds overall entities creation limit
+        let create_class_result = create_simple_class(
+            LEAD_ORIGIN,
+            ClassType::DefaultVoucherUpperBoundExceedsMaximumEntitiesCount,
+        );
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_PER_CONTROLLER_ENTITIES_CREATION_LIMIT_EXCEEDS_OVERALL_LIMIT,
+            number_of_events_before_call,
+        );
+    })
+}
+
+#[test]
+fn create_class_maintainers_limit_reached() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Add curator groups to runtime
+        for _ in 1..=MaxNumberOfMaintainersPerClass::get() {
+            assert_ok!(add_curator_group(LEAD_ORIGIN));
+        }
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        // An attempt to create class with number of maintainers that exceeds runtime limit
+        let create_class_result =
+            create_simple_class(LEAD_ORIGIN, ClassType::MaintainersLimitReached);
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_NUMBER_OF_MAINTAINERS_PER_CLASS_LIMIT_REACHED,
+            number_of_events_before_call,
+        );
+    })
+}
+
+#[test]
+fn create_class_curator_group_does_not_exist() {
+    with_test_externalities(|| {
+        // Runtime tested state before call
+
+        // Events number before tested call
+        let number_of_events_before_call = System::events().len();
+
+        // An attempt to create class with curator group maintainer, which does not exist in runtime
+        let create_class_result =
+            create_simple_class(LEAD_ORIGIN, ClassType::CuratorGroupDoesNotExist);
+
+        // Failure checked
+        assert_failure(
+            create_class_result,
+            ERROR_CURATOR_GROUP_DOES_NOT_EXIST,
+            number_of_events_before_call,
+        );
+    })
+}

runtime-modules/content-directory/src/tests/create_entity.rs

@@ -4,7 +4,7 @@ use super::*;
 fn create_entity_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Update class permissions to force any maintainer be available to create entities
         assert_ok!(update_class_permissions(

runtime-modules/content-directory/src/tests/remove_curator_group.rs

@@ -81,7 +81,7 @@ fn curator_group_removal_forbidden() {
         // Runtime tested state before call
 
         // Create class
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Add curator group
         assert_ok!(add_curator_group(LEAD_ORIGIN));

runtime-modules/content-directory/src/tests/remove_entity.rs

@@ -4,7 +4,7 @@ use super::*;
 fn remove_entity_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         let actor = Actor::Lead;
 

runtime-modules/content-directory/src/tests/remove_maintainer_from_class.rs

@@ -4,7 +4,7 @@ use super::*;
 fn remove_maintainer_from_class_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Add first curator group
         assert_ok!(add_curator_group(LEAD_ORIGIN));

runtime-modules/content-directory/src/tests/transaction.rs

@@ -4,7 +4,7 @@ use super::*;
 fn transaction_success() {
     with_test_externalities(|| {
         // Create class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Create single reference property
         let property_type_reference =

runtime-modules/content-directory/src/tests/transfer_entity_ownership.rs

@@ -4,7 +4,7 @@ use super::*;
 fn transfer_entity_ownership_success() {
     with_test_externalities(|| {
         // Create class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         let actor = Actor::Lead;
 

runtime-modules/content-directory/src/tests/update_class_permissions.rs

@@ -4,7 +4,7 @@ use super::*;
 fn update_class_permissions_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Add first curator group
         assert_ok!(add_curator_group(LEAD_ORIGIN));

runtime-modules/content-directory/src/tests/update_class_schema_status.rs

@@ -4,7 +4,7 @@ use super::*;
 fn update_class_schema_status_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Runtime tested state before call
 

runtime-modules/content-directory/src/tests/update_entity_creation_voucher.rs

@@ -4,7 +4,7 @@ use super::*;
 fn create_entity_creation_voucher_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         // Runtime state before tested call
 
@@ -51,7 +51,7 @@ fn create_entity_creation_voucher_success() {
 fn update_entity_creation_voucher_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         let actor = Actor::Member(FIRST_MEMBER_ID);
 

runtime-modules/content-directory/src/tests/update_entity_permissions.rs

@@ -4,7 +4,7 @@ use super::*;
 fn update_entity_permissions_success() {
     with_test_externalities(|| {
         // Create simple class with default permissions
-        assert_ok!(create_simple_class_with_default_permissions(LEAD_ORIGIN));
+        assert_ok!(create_simple_class(LEAD_ORIGIN, ClassType::Valid));
 
         let actor = Actor::Lead;