def test_intg_rqr_is_not_equal_throws_error_on_identical_object(): """ Tests the `is_not_equal_to()` requires validator method through `Condition.requires_obj()` to see if it, throws an ArgumentError when the object is identical to the supplied object. """ # Arrange actual = TypeExample() expected = TypeExample() # Assert with pytest.raises(ArgumentError): # Act Condition.requires_obj(actual, 'actual').is_not_equal_to(expected)
def test_is_not_equal_throws_error_on_identical_object(): """ Tests that the `is_not_equal_to()` method throws an ArgumentError when the object is identical to the supplied object. """ # Arrange actual = TypeExample() expected = TypeExample() validator = ObjectValidator(actual, 'actual') # Assert with pytest.raises(ArgumentError): # Act validator.is_not_equal_to(expected)
def test_is_equal_returns_validator_self(): """ Tests if the `is_equal_to()` validator method returns itself after the validation is performed, so that additional validations can be performed. """ actual = TypeExample() expected = TypeExample() validator = ObjectValidator(actual, 'actual') # Act validator_returned = validator.is_equal_to(expected) # Assert assert validator_returned is validator
def test_intg_rqr_is_equal_to_accepts_identical_object(): """ Tests the `is_equal_to()` requires validator method through `Condition.requires_obj()` to see if it, throws an ArgumentError when the object is identical to the supplied object. """ # Arrange actual = TypeExample() expected = TypeExample() # Act try: Condition.requires_obj(actual, 'actual').is_equal_to(expected) # Assert except ArgumentError: pytest.fail(f'`{actual.__class__.__name__}` should be equal to `{expected.__class__.__name__}`, but an error occurred')
def test_is_equal_to_accepts_identical_object(): """ Tests that the `is_equal_to()` method does not throw an ArgumentError when the object is identical to the supplied object. """ # Arrange actual = TypeExample() expected = TypeExample() validator = ObjectValidator(actual, 'actual') # Act try: validator.is_equal_to(expected) # Assert except ArgumentError: pytest.fail(f'`{actual.__class__.__name__}` should be equal to `{expected.__class__.__name__}`, but an error occurred')
def test_intg_rqr_is_not_of_type_name_throws_error_on_no_supplied_initialized_object(): """ Tests the `is_not_of_type_name()` requires validator method through `Condition.requires_obj()` to see if it, throws a TypeError when it is supplied with a type that is not initialized. """ # Arrange obj = TypeExample() # Assert with pytest.raises(TypeError): # Act Condition.requires_obj(obj, 'obj').is_not_of_type_name(TypeExample2)
def test_is_null_throws_error_on_not_null_value(): """ Tests that the `is_null()` method throws an ArgumentNullError when it is supplied with a type that is not None (Null). """ # Arrange type = TypeExample() validator = ObjectValidator(type, 'type') # Assert with pytest.raises(ArgumentNullError): # Act validator.is_null()
def test_is_not_of_type_throws_error_on_equivalent_type(): """ Tests that the `is_not_of_type()` method throws an ArgumentError when it is supplied with a type that is the same as the specified class type. """ # Arrange obj = TypeExample() validator = ObjectValidator(obj, 'obj') # Assert with pytest.raises(ArgumentError): # Act validator.is_not_of_type(TypeExample)
def test_is_not_of_type_name_throws_error_on_no_supplied_initialized_object(): """ Tests that the `is_not_of_type_name()` method throws a TypeError when it is supplied with a type that is not initialized. """ # Arrange obj = TypeExample() validator = ObjectValidator(obj, 'obj') # Assert with pytest.raises(TypeError): # Act validator.is_not_of_type_name(TypeExample2)
def test_intg_rqr_is_null_throws_error_on_not_null_value(): """ Tests the `is_null()` requires validator method through `Condition.requires_obj()` to see if it, throws an ArgumentNullError when it is supplied with a type that is not None (Null). """ # Arrange type = TypeExample() # Assert with pytest.raises(ArgumentNullError): # Act Condition.requires_obj(type, 'type').is_null()
def test_intg_ensr_is_of_type_throws_error_on_different_type(): """ Tests the `is_of_type()` ensures validator method through `Condition.ensures_obj()` to see if it, throws an ArgumentError when it is supplied with a type that is different to the specified type. """ # Arrange obj = TypeExample() # Assert with pytest.raises(ArgumentError): # Act Condition.ensures_obj(obj, 'obj').is_of_type(TypeExample2)
def test_intg_rqr_is_not_of_type_throws_error_on_equivalent_type(): """ Tests the `is_not_of_type()` requires validator method through `Condition.requires_obj()` to see if it, throws an ArgumentError when it is supplied with a type that is the same as the specified class type. """ # Arrange obj = TypeExample() # Assert with pytest.raises(ArgumentError): # Act Condition.requires_obj(obj, 'obj').is_not_of_type(TypeExample)
def test_intg_ensr_is_of_type_accepts_equivalent_multi_types(): """ Tests the `is_of_type()` ensures validator method does not throw an ArgumentError when it is supplied with multiple types that one or more of, are equivalent to the specified type. """ # Arrange obj = TypeExample() # Act try: Condition.ensures_obj(obj, 'obj').is_of_type(TypeExample, TypeExample2) # Assert except ArgumentError: pytest.fail(f'Type `{obj.__class__.__name__}` should match type `{TypeExample.__name__}`, but an error occurred.')
def test_is_not_of_type_returns_validator_self(): """ Tests if the `is_not_of_type()` validator method returns itself after the validation is performed, so that additional validations can be performed. """ # Arrange obj = TypeExample() validator = ObjectValidator(obj, 'obj') # Act validator_returned = validator.is_not_of_type(TypeExample2) # Assert assert validator_returned is validator
def test_intg_rqr_is_not_of_type_accepts_different_multi_types(): """ Tests the `is_not_of_type()` requires validator method does not throw an ArgumentError when it is supplied with multiple types that are all different from the specified class type. """ # Arrange obj = TypeExample() # Act try: Condition.requires_obj(obj, 'obj').is_not_of_type(TypeExample2, TypeExample3) # Assert except ArgumentError: pytest.fail(f'Type `{obj.__class__.__name__}` should match type `{TypeExample.__name__}`, but an error occurred.')
def test_is_not_null_returns_validator_self(): """ Tests if the `is_not_null()` validator method returns itself after the validation is performed, so that additional validations can be performed. """ # Arrange type = TypeExample() validator = ObjectValidator(type, 'type') # Act validator_returned = validator.is_not_null() # Assert assert validator_returned is validator
def test_intg_rqr_is_not_null_accepts_not_null_value(): """ Tests the `is_not_null()` requires validator method through `Condition.requires_obj()` to see if it, throws an ArgumentNullError when it is supplied with a type that is not None (Null). """ # Arrange type = TypeExample() # Act try: Condition.requires_obj(type, 'type').is_not_null() # Assert except ArgumentNullError: pytest.fail(f'The object should have been None (Null), but an error occurred.')
def test_intg_rqr_is_not_of_type_accepts_different_type(): """ Tests the `is_not_of_type()` requires validator method through `Condition.requires_obj()` to see if it, throws an ArgumentError when it is supplied with a type that is different to the specified class type. """ # Arrange obj = TypeExample() # Act try: Condition.requires_obj(obj, 'obj').is_not_of_type(TypeExample2) # Assert except ArgumentError: pytest.fail(f'Type `{obj.__class__.__name__}` should match type `{TypeExample.__name__}`, but an error occurred.')
def test_is_not_null_accepts_not_null_value(): """ Tests that the `is_not_null()` method does not throw an ArgumentNullError when it is supplied with a type that is not None (Null). """ # Arrange type = TypeExample() validator = ObjectValidator(type, 'type') # Act try: validator.is_not_null() # Assert except ArgumentNullError: pytest.fail(f'The object should have been None (Null), but an error occurred.')
def test_is_not_of_type_accepts_different_type(): """ Tests that the `is_not_of_type()` method does not throw an ArgumentError when it is supplied with a type that is different to the specified class type. """ # Arrange obj = TypeExample() validator = ObjectValidator(obj, 'obj') # Act try: validator.is_not_of_type(TypeExample2) # Assert except ArgumentError: pytest.fail(f'Type `{obj.__class__.__name__}` should match type `{TypeExample.__name__}`, but an error occurred.')