def test_fix_match(self, env, result): result.fix.match( actual={'foo': 1, 'bar': 2, 'baz': 2}, expected={'foo': 1, 'bar': 2, 'bat': 3}, description='basic fix match', actual_description='description for actual', expected_description='description for expected', include_tags=['foo', 'bar'], exclude_tags=['baz', 'bat'] ) result.fix.match( actual={'foo': 1}, expected={'foo': 5}, description='simple failing match', ) result.fix.match( actual={'foo': 1, 'bar': 'hello'}, expected={ 'foo': cmp.Equal(1), 'bar': re.compile('he*') }, description='match with regex & custom func' ) result.fix.match( actual={'foo': 'hello'}, expected={ 'foo': re.compile('aaa*') }, description='failing pattern match' ) result.fix.match( actual={'foo': 1}, expected={ 'foo': cmp.Equal(5) }, description='failing comparator func' ) result.fix.match( actual={'foo': 1}, expected={ 'foo': error_func }, description='error func' ) typed_fixmsg_actual = test_utils.FixMessage( (('foo', 1), ('bar', 2.0)), typed_values=True) typed_fixmsg_ex = test_utils.FixMessage( (('foo', 1), ('bar', 2)), typed_values=True) result.fix.match( actual=typed_fixmsg_actual, expected=typed_fixmsg_ex, description='typed fixmsgs have different value types')
def test_dict_match(self, env, result): result.dict.match(actual={ 'foo': 1, 'bar': 2, 'baz': 2 }, expected={ 'foo': 1, 'bar': 2, 'bat': 3 }, description='basic dict match', actual_description='description for actual', expected_description='description for expected', include_keys=['foo', 'bar'], exclude_keys=['baz', 'bat']) result.dict.match( actual={'foo': 1}, expected={'foo': 5}, description='simple failing match', ) result.dict.match(actual={ 'foo': 1, 'bar': 'hello' }, expected={ 'foo': cmp.Equal(1), 'bar': re.compile('he*') }, description='match with regex & custom func') result.dict.match(actual={'foo': 'hello'}, expected={'foo': re.compile('aaa*')}, description='failing pattern match') result.dict.match(actual={'foo': 1}, expected={'foo': cmp.Equal(5)}, description='failing comparator func') result.dict.match(actual={'foo': 1}, expected={'foo': error_func}, description='error func') result.dict.match(actual={ 'foo': 1, 'bar': 2 }, expected={ 'foo': 1.0, 'bar': 2.0 }, description='type checking fails', value_cmp_func=cmp.COMPARE_FUNCTIONS['check_types'])
def test_fix_match(self, env, result): result.fix.match( actual={'foo': 1, 'bar': 2, 'baz': 2}, expected={'foo': 1, 'bar': 2, 'bat': 3}, description='basic fix match', actual_description='description for actual', expected_description='description for expected', include_tags=['foo', 'bar'], exclude_tags=['baz', 'bat'] ) result.fix.match( actual={'foo': 1}, expected={'foo': 5}, description='simple failing match', ) result.fix.match( actual={'foo': 1, 'bar': 'hello'}, expected={ 'foo': cmp.Equal(1), 'bar': re.compile('he*') }, description='match with regex & custom func' ) result.fix.match( actual={'foo': 'hello'}, expected={ 'foo': re.compile('aaa*') }, description='failing pattern match' ) result.fix.match( actual={'foo': 1}, expected={ 'foo': cmp.Equal(5) }, description='failing comparator func' ) result.fix.match( actual={'foo': 1}, expected={ 'foo': error_func }, description='error func' )
def test_fix_match(self, env, result): result.fix.match(actual={ 'foo': 1, 'bar': 2, 'baz': 2 }, expected={ 'foo': 1, 'bar': 2, 'bat': 3 }, description='basic fix match', actual_description='description for actual', expected_description='description for expected', include_tags=['foo', 'bar'], exclude_tags=['baz', 'bat']) result.fix.match(actual={ 'foo': 1, 'bar': 'hello' }, expected={ 'foo': cmp.Equal(1), 'bar': re.compile('he*') }, description='match with regex & custom func')
def test_fix_match(self, env, result): result.fix.match( actual={ "foo": 1, "bar": 2, "baz": 2 }, expected={ "foo": 1, "bar": 2, "bat": 3 }, description="basic fix match", actual_description="description for actual", expected_description="description for expected", include_tags=["foo", "bar"], exclude_tags=["baz", "bat"], ) result.fix.match( actual={ "foo": 1, "bar": "hello" }, expected={ "foo": cmp.Equal(1), "bar": re.compile("he*") }, description="match with regex & custom func", ) result.fix.match( actual={ "foo": 1, "bar": 1.54 }, expected={ "foo": "1", "bar": "1.54" }, description="default untyped fixmatch will stringify", ) typed_fixmsg = test_utils.FixMessage((("foo", 1), ("bar", 1.54)), typed_values=True) result.fix.match( actual=typed_fixmsg, expected=typed_fixmsg.copy(), description="typed fixmatch will compare types", ) untyped_fixmsg = test_utils.FixMessage((("foo", "1"), ("bar", "1.54")), typed_values=False) result.fix.match( actual=typed_fixmsg, expected=untyped_fixmsg, description="mixed fixmatch will compare string values", )
def test_dict_match(self, env, result): result.dict.match( actual={"foo": 1, "bar": 2, "baz": 2}, expected={"foo": 1, "bar": 2, "bat": 3}, description="basic dict match", actual_description="description for actual", expected_description="description for expected", include_keys=["foo", "bar"], exclude_keys=["baz", "bat"], ) result.dict.match( actual={"foo": 1, "bar": "hello"}, expected={"foo": cmp.Equal(1), "bar": re.compile("he*")}, description="match with regex & custom func", ) result.dict.match( actual={"foo": 1, "bar": "2"}, expected={"foo": 1, "bar": "2"}, description="dict match checking types", value_cmp_func=cmp.COMPARE_FUNCTIONS["check_types"], ) class AlwaysComparesTrue(object): """Object that compares equal to any other object.""" def __eq__(self, _): return True result.dict.match( actual={"foo": 1, "bar": 2}, expected={ "foo": AlwaysComparesTrue(), "bar": AlwaysComparesTrue(), }, description="comparison of different types", ) class HelloObj(object): """Object that returns 'hello' as its str() representation.""" def __str__(self): return "hello" result.dict.match( actual={"foo": 1, "bar": "hello"}, expected={"foo": "1", "bar": HelloObj()}, description="match with stringify method", value_cmp_func=cmp.COMPARE_FUNCTIONS["stringify"], )
def test_fix_match(self, env, result): result.fix.match(actual={ 'foo': 1, 'bar': 2, 'baz': 2 }, expected={ 'foo': 1, 'bar': 2, 'bat': 3 }, description='basic fix match', actual_description='description for actual', expected_description='description for expected', include_tags=['foo', 'bar'], exclude_tags=['baz', 'bat']) result.fix.match(actual={ 'foo': 1, 'bar': 'hello' }, expected={ 'foo': cmp.Equal(1), 'bar': re.compile('he*') }, description='match with regex & custom func') result.fix.match(actual={ 'foo': 1, 'bar': 1.54 }, expected={ 'foo': '1', 'bar': '1.54' }, description='default untyped fixmatch will stringify') typed_fixmsg = test_utils.FixMessage((('foo', 1), ('bar', 1.54)), typed_values=True) result.fix.match(actual=typed_fixmsg, expected=typed_fixmsg.copy(), description='typed fixmatch will compare types') untyped_fixmsg = test_utils.FixMessage((('foo', '1'), ('bar', '1.54')), typed_values=False) result.fix.match( actual=typed_fixmsg, expected=untyped_fixmsg, description='mixed fixmatch will compare string values')
def test_fix_match(self, env, result): result.fix.match( actual={ "foo": 1, "bar": 2, "baz": 2 }, expected={ "foo": 1, "bar": 2, "bat": 3 }, description="basic fix match", actual_description="description for actual", expected_description="description for expected", include_tags=["foo", "bar"], exclude_tags=["baz", "bat"], ) result.fix.match( actual={"foo": 1}, expected={"foo": 5}, description="simple failing match", ) result.fix.match( actual={ "foo": 1, "bar": "hello" }, expected={ "foo": cmp.Equal(1), "bar": re.compile("he*") }, description="match with regex & custom func", ) result.fix.match( actual={"foo": "hello"}, expected={"foo": re.compile("aaa*")}, description="failing pattern match", ) result.fix.match( actual={"foo": 1}, expected={"foo": cmp.Equal(5)}, description="failing comparator func", ) result.fix.match( actual={"foo": 1}, expected={"foo": error_func}, description="error func", ) typed_fixmsg_actual = test_utils.FixMessage((("foo", 1), ("bar", 2.0)), typed_values=True) typed_fixmsg_ex = test_utils.FixMessage((("foo", 1), ("bar", 2)), typed_values=True) result.fix.match( actual=typed_fixmsg_actual, expected=typed_fixmsg_ex, description="typed fixmsgs have different value types", )
def test_dict_match(self, env, result): result.dict.match( actual={ "foo": 1, "bar": 2, "baz": 2 }, expected={ "foo": 1, "bar": 2, "bat": 3 }, description="basic dict match", actual_description="description for actual", expected_description="description for expected", include_keys=["foo", "bar"], exclude_keys=["baz", "bat"], ) result.dict.match( actual={"foo": 1}, expected={"foo": 5}, description="simple failing match", ) result.dict.match( actual={ "foo": 1, "bar": "hello" }, expected={ "foo": cmp.Equal(1), "bar": re.compile("he*") }, description="match with regex & custom func", ) result.dict.match( actual={"foo": "hello"}, expected={"foo": re.compile("aaa*")}, description="failing pattern match", ) result.dict.match( actual={"foo": 1}, expected={"foo": cmp.Equal(5)}, description="failing comparator func", ) result.dict.match( actual={"foo": 1}, expected={"foo": error_func}, description="error func", ) result.dict.match( actual={ "foo": 1, "bar": 2 }, expected={ "foo": 1.0, "bar": 2.0 }, description="type checking fails", value_cmp_func=cmp.COMPARE_FUNCTIONS["check_types"], )
def test_custom_callable(): custom_callable = cmp.Custom(lambda value: value % 2 == 0, description="Value is even.") assert custom_callable(4) == True assert str(custom_callable) == "Value is even." @pytest.mark.parametrize( "composed_callable,value,expected,description", ( (cmp.LessEqual(5) & cmp.Greater(2), 4, True, "(VAL <= 5 and VAL > 2)"), ( cmp.In([1, 2, 3]) | cmp.Equal(None), None, True, "(VAL in [1, 2, 3] or VAL == None)", ), ( cmp.And( cmp.Or(cmp.Equal("foo"), cmp.In([1, 2, 3]), cmp.Less(10)), cmp.Or(cmp.Greater(5), cmp.IsFalse()), ), 8, True, "((VAL == foo or VAL in [1, 2, 3] or " "VAL < 10) and (VAL > 5 or bool(VAL) is False))", ), ),
assert callable_obj(value) == expected assert str(callable_obj) == description def test_custom_callable(): custom_callable = cmp.Custom(lambda value: value % 2 == 0, description='Value is even.') assert custom_callable(4) == True assert str(custom_callable) == 'Value is even.' @pytest.mark.parametrize( 'composed_callable,value,expected,description', ((cmp.LessEqual(5) & cmp.Greater(2), 4, True, '(VAL <= 5 and VAL > 2)'), (cmp.In([1, 2, 3]) | cmp.Equal(None), None, True, '(VAL in [1, 2, 3] or VAL == None)'), ( cmp.And(cmp.Or( cmp.Equal('foo'), cmp.In([1, 2, 3]), cmp.Less(10), ), cmp.Or(cmp.Greater(5), cmp.IsFalse())), 8, True, "((VAL == foo or VAL in [1, 2, 3] or " "VAL < 10) and (VAL > 5 or bool(VAL) is False))", ))) def test_comparator_composition(composed_callable, value, expected, description): assert composed_callable(value) == expected assert str(composed_callable) == description
def test_dict_match(self, env, result): result.dict.match(actual={ 'foo': 1, 'bar': 2, 'baz': 2 }, expected={ 'foo': 1, 'bar': 2, 'bat': 3 }, description='basic dict match', actual_description='description for actual', expected_description='description for expected', include_keys=['foo', 'bar'], exclude_keys=['baz', 'bat']) result.dict.match(actual={ 'foo': 1, 'bar': 'hello' }, expected={ 'foo': cmp.Equal(1), 'bar': re.compile('he*') }, description='match with regex & custom func') result.dict.match(actual={ 'foo': 1, 'bar': '2' }, expected={ 'foo': 1, 'bar': '2' }, description='dict match checking types', value_cmp_func=cmp.COMPARE_FUNCTIONS['check_types']) class AlwaysComparesTrue(object): """Object that compares equal to any other object.""" def __eq__(self, _): return True result.dict.match(actual={ 'foo': 1, 'bar': 2 }, expected={ 'foo': AlwaysComparesTrue(), 'bar': AlwaysComparesTrue() }, description='comparison of different types') class HelloObj(object): """Object that returns 'hello' as its str() representation.""" def __str__(self): return 'hello' result.dict.match(actual={ 'foo': 1, 'bar': 'hello' }, expected={ 'foo': '1', 'bar': HelloObj() }, description='match with stringify method', value_cmp_func=cmp.COMPARE_FUNCTIONS['stringify'])