From 1bdb4ef9f1b592c615bc3737bdcaf9993dcc55e8 Mon Sep 17 00:00:00 2001 From: Flow Jiang Date: Sat, 14 Apr 2018 20:46:17 +0800 Subject: [PATCH 1/2] Add support for python 3 --- mapperpy/attributes_util.py | 2 +- mapperpy/object_mapper.py | 4 +- mapperpy/one_way_mapper.py | 26 +++++---- .../test_custom_value_conversion.py | 8 +-- .../conversions/test_datetime_conversion.py | 7 ++- .../test/conversions/test_enum_conversion.py | 5 ++ mapperpy/test/test_dict_mapping.py | 16 +++--- mapperpy/test/test_object_mapper.py | 54 +++++++++---------- mapperpy/test/test_one_way_mapper.py | 52 +++++++++--------- 9 files changed, 98 insertions(+), 76 deletions(-) diff --git a/mapperpy/attributes_util.py b/mapperpy/attributes_util.py index 8b5e15c..0ef55e8 100644 --- a/mapperpy/attributes_util.py +++ b/mapperpy/attributes_util.py @@ -4,7 +4,7 @@ def get_attributes(obj): if isinstance(obj, dict): - return obj.keys() + return list(obj.keys()) attributes = inspect.getmembers(obj, lambda a: not(inspect.isroutine(a))) return [attr[0] for attr in attributes if not(attr[0].startswith('__') and attr[0].endswith('__'))] diff --git a/mapperpy/object_mapper.py b/mapperpy/object_mapper.py index 45b20ef..afc7de5 100644 --- a/mapperpy/object_mapper.py +++ b/mapperpy/object_mapper.py @@ -150,7 +150,7 @@ def __get_explicit_mapping(cls, input_mapping): mapping = {} rev_mapping = {} - for left, right in input_mapping.items(): + for left, right in list(input_mapping.items()): if right is None: # user requested to suppress implicit mapping for k mapping[left] = rev_mapping[left] = None @@ -164,7 +164,7 @@ def __split_converters(self, converters_dict): to_right_converters = {} to_left_converters = {} - for left_attr_name, converters_tuple in converters_dict.iteritems(): + for left_attr_name, converters_tuple in converters_dict.items(): if not isinstance(converters_tuple, tuple) or len(converters_tuple) != 2: raise ValueError("Converters for {} should be provided in a 2-element tuple".format(left_attr_name)) diff --git a/mapperpy/one_way_mapper.py b/mapperpy/one_way_mapper.py index 3e6a9df..be10bbd 100644 --- a/mapperpy/one_way_mapper.py +++ b/mapperpy/one_way_mapper.py @@ -1,3 +1,4 @@ +import collections from datetime import datetime from enum import Enum @@ -8,6 +9,12 @@ __author__ = 'lgrech' +try: + basestring +except NameError: + basestring = str + + class OneWayMapper(object): def __init__(self, target_class, target_prototype_obj=None, attributes_cache_provider=AttributesCache): @@ -87,7 +94,8 @@ def target_value_converters(self, converters_dict): self.__target_value_converters.update(converters_dict) return self - def options(self, (setting_name, setting_value)): + def options(self, settings): + (setting_name, setting_value) = settings self.__general_settings[setting_name] = setting_value return self @@ -100,7 +108,7 @@ def __try_create_target_object(self, param_dict): return self.__target_class(**param_dict) except TypeError as er: raise AttributeError("Error when initializing class {} with params: {}\n{}".format( - self.__target_class.__name__, param_dict, er.message)) + self.__target_class.__name__, param_dict, er.args[0])) def __get_mapped_params_dict(self, obj_from): @@ -111,12 +119,12 @@ def __get_mapped_params_dict(self, obj_from): mapped_params_dict.update(self.__apply_initializers(obj_from)) return mapped_params_dict except AttributeError as er: - raise AttributeError("Unknown attribute: {}".format(er.message)) + raise AttributeError("Unknown attribute: {}".format(er.args[0])) def __apply_initializers(self, source_obj): initialized_params_dict = {} - for attr_name, init_func in self.__target_initializers.items(): + for attr_name, init_func in list(self.__target_initializers.items()): initialized_params_dict[attr_name] = init_func(source_obj) return initialized_params_dict @@ -125,7 +133,7 @@ def __apply_mapping(self, source_obj, attr_name_mapping): mapped_params_dict = {} - for attr_name_from, attr_name_to in attr_name_mapping.items(): + for attr_name_from, attr_name_to in list(attr_name_mapping.items()): # skip since mapping is suppressed by user (attribute_name = None) if not (attr_name_from and attr_name_to): continue @@ -177,7 +185,7 @@ def __apply_type_conversion(cls, from_type, to_type, attr_value): return cls.__get_conversion_from_enum(attr_value, to_type) elif issubclass(to_type, Enum): return cls.__get_conversion_to_enum(attr_value, from_type, to_type) - elif issubclass(from_type, datetime) and issubclass(to_type, basestring): + elif issubclass(from_type, datetime) and issubclass(to_type, str): return cls.__get_conversion_from_datetime(attr_value) elif issubclass(from_type, basestring) and issubclass(to_type, datetime): return cls.__get_conversion_to_datetime(attr_value) @@ -192,7 +200,7 @@ def __get_conversion_to_datetime(cls, attr_value): return datetime.strptime(attr_value, "%Y-%m-%dT%H:%M:%S") except ValueError as e2: raise ValueError("Could not create datetime object from string: {}. {}. {}".format( - attr_value, e1.message, e2.message)) + attr_value, e1.args[0], e2.args[0])) @classmethod def __get_conversion_from_datetime(cls, attr_value): @@ -270,8 +278,8 @@ def __get_setting(self, mapper_option, default_val): @staticmethod def __verify_if_callable(name_callable_map, error_message_template): - for name, obj in name_callable_map.iteritems(): - if not callable(obj): + for name, obj in name_callable_map.items(): + if not isinstance(obj, collections.Callable): raise ValueError(error_message_template.format(name)) def __repr__(self): diff --git a/mapperpy/test/conversions/test_custom_value_conversion.py b/mapperpy/test/conversions/test_custom_value_conversion.py index 951f691..47a8c37 100644 --- a/mapperpy/test/conversions/test_custom_value_conversion.py +++ b/mapperpy/test/conversions/test_custom_value_conversion.py @@ -12,7 +12,7 @@ def test_target_value_converters_when_converter_not_function_should_raise_except OneWayMapper.for_target_class(TestClassSomePropertyEmptyInit1).target_value_converters( {"some_property_02": 7} ) - assert_that(context.exception.message).contains("some_property_02") + assert_that(context.exception.args[0]).contains("some_property_02") def test_map_for_single_converter(self): # given @@ -70,21 +70,21 @@ def test_object_mapper_value_converters_when_converters_not_in_tuple_should_rais ObjectMapper.from_class(TestClassSomePropertyEmptyInit1, TestClassSomePropertyEmptyInit2).value_converters( {"some_property_02": lambda val: 7}) - assert_that(context.exception.message).contains("some_property_02") + assert_that(context.exception.args[0]).contains("some_property_02") def test_object_mapper_value_converters_when_converter_not_in_2_element_tuple_should_raise_exception(self): with self.assertRaises(ValueError) as context: ObjectMapper.from_class(TestClassSomePropertyEmptyInit1, TestClassSomePropertyEmptyInit2).value_converters( {"some_property_02": (lambda val: 7,)}) - assert_that(context.exception.message).contains("some_property_02") + assert_that(context.exception.args[0]).contains("some_property_02") def test_object_mapper_value_converters_when_converter_not_callable_should_raise_exception(self): with self.assertRaises(ValueError) as context: ObjectMapper.from_class(TestClassSomePropertyEmptyInit1, TestClassSomePropertyEmptyInit2).value_converters( {"some_property_02": (lambda val: 7, "not_a_function")}) - assert_that(context.exception.message).contains("some_property_02") + assert_that(context.exception.args[0]).contains("some_property_02") def test_object_mapper_map_with_value_converter_and_default_mapping(self): # given diff --git a/mapperpy/test/conversions/test_datetime_conversion.py b/mapperpy/test/conversions/test_datetime_conversion.py index ce20d61..16ae2f8 100644 --- a/mapperpy/test/conversions/test_datetime_conversion.py +++ b/mapperpy/test/conversions/test_datetime_conversion.py @@ -1,3 +1,4 @@ +import sys import unittest from assertpy import assert_that @@ -9,6 +10,10 @@ __author__ = 'lgrech' +if sys.version_info > (3, 0): + unicode = str + + class DateTimeConversionTest(unittest.TestCase): def test_map_from_datetime_it_target_type_not_known(self): @@ -50,7 +55,7 @@ def test_map_from_string_to_datetime_wrong_format_should_raise_exception(self): mapper.map(TestClassSomePropertyEmptyInit1(some_property_02="wrong_date_format")) # then - assert_that(context.exception.message).contains("wrong_date_format") + assert_that(context.exception.args[0]).contains("wrong_date_format") def test_map_from_string_to_datetime(self): # given diff --git a/mapperpy/test/conversions/test_enum_conversion.py b/mapperpy/test/conversions/test_enum_conversion.py index b9fec2e..3ba62c9 100644 --- a/mapperpy/test/conversions/test_enum_conversion.py +++ b/mapperpy/test/conversions/test_enum_conversion.py @@ -1,3 +1,4 @@ +import sys import unittest from assertpy import assert_that from enum import Enum @@ -9,6 +10,10 @@ __author__ = 'lgrech' +if sys.version_info > (3, 0): + unicode = str + + class EnumConversionTest(unittest.TestCase): def test_enum_to_int_mapping_should_map_to_enum_value(self): diff --git a/mapperpy/test/test_dict_mapping.py b/mapperpy/test/test_dict_mapping.py index 92bc7e5..2f788b8 100644 --- a/mapperpy/test/test_dict_mapping.py +++ b/mapperpy/test/test_dict_mapping.py @@ -221,8 +221,8 @@ def test_map_when_ambiguous_nested_mapping_should_raise_exception(self): root_mapper.map(dict(some_property=TestClassSomePropertyEmptyInit1().__dict__)) # then - assert_that(context.exception.message).contains("some_property") - assert_that(context.exception.message).contains("dict") + assert_that(context.exception.args[0]).contains("some_property") + assert_that(context.exception.args[0]).contains("dict") def test_map_explicit_when_ambiguous_nested_mapping_should_raise_exception(self): # given @@ -237,9 +237,9 @@ def test_map_explicit_when_ambiguous_nested_mapping_should_raise_exception(self) root_mapper.map(dict(some_property=dict())) # then - assert_that(context.exception.message).contains("some_property") - assert_that(context.exception.message).contains("mapped_property") - assert_that(context.exception.message).contains("dict") + assert_that(context.exception.args[0]).contains("some_property") + assert_that(context.exception.args[0]).contains("mapped_property") + assert_that(context.exception.args[0]).contains("dict") def test_map_with_multiple_nested_mappings_when_no_matching_mapper_for_target_type_should_raise_exception(self): # given @@ -256,9 +256,9 @@ def test_map_with_multiple_nested_mappings_when_no_matching_mapper_for_target_ty root_mapper.map(dict(some_property=dict(some_property_02="nested_value_02"))) # then - assert_that(context.exception.message).contains("some_property") - assert_that(context.exception.message).contains("dict") - assert_that(context.exception.message).contains("TestClassMappedPropertyEmptyInit") + assert_that(context.exception.args[0]).contains("some_property") + assert_that(context.exception.args[0]).contains("dict") + assert_that(context.exception.args[0]).contains("TestClassMappedPropertyEmptyInit") def test_map_with_multiple_nested_mappings_for_one_attribute_when_target_type_known(self): # given diff --git a/mapperpy/test/test_object_mapper.py b/mapperpy/test/test_object_mapper.py index 384d56f..3a85774 100644 --- a/mapperpy/test/test_object_mapper.py +++ b/mapperpy/test/test_object_mapper.py @@ -22,7 +22,7 @@ def test_map_unknown_class_should_raise_exception(self): ObjectMapper.from_class(TestEmptyClass1, TestEmptyClass2).map(TestOtherClass()) self.fail("Should raise ValueError") except ValueError as er: - assert_that(er.message).contains(TestOtherClass.__name__) + assert_that(er.args[0]).contains(TestOtherClass.__name__) def test_map_one_explicit_property(self): # given @@ -54,7 +54,7 @@ def test_map_unknown_property_should_raise_exception(self): self.fail("Should raise AttributeError") except AttributeError as er: # then - assert_that(er.message).contains("unknown") + assert_that(er.args[0]).contains("unknown") # given mapper = ObjectMapper.from_class(TestClassSomeProperty1, TestClassMappedProperty).custom_mappings( @@ -66,7 +66,7 @@ def test_map_unknown_property_should_raise_exception(self): self.fail("Should raise AttributeError") except AttributeError as er: # then - assert_that(er.message).contains("unknown") + assert_that(er.args[0]).contains("unknown") def test_map_multiple_explicit_properties(self): # given @@ -211,8 +211,8 @@ def test_nested_mapper_when_wrong_param_type_should_raise_exception(self): root_mapper.nested_mapper(object()) # then - assert_that(context.exception.message).contains(ObjectMapper.__name__) - assert_that(context.exception.message).contains("object") + assert_that(context.exception.args[0]).contains(ObjectMapper.__name__) + assert_that(context.exception.args[0]).contains("object") def test_nested_mapper_when_the_same_mapper_added_should_raise_exception(self): # given @@ -226,8 +226,8 @@ def test_nested_mapper_when_the_same_mapper_added_should_raise_exception(self): ObjectMapper.from_class(TestClassSomePropertyEmptyInit1, TestClassSomePropertyEmptyInit2)) # then - assert_that(context.exception.message).contains(TestClassSomePropertyEmptyInit1.__name__) - assert_that(context.exception.message).contains(TestClassSomePropertyEmptyInit2.__name__) + assert_that(context.exception.args[0]).contains(TestClassSomePropertyEmptyInit1.__name__) + assert_that(context.exception.args[0]).contains(TestClassSomePropertyEmptyInit2.__name__) def test_map_with_nested_explicit_mapper(self): # given @@ -297,8 +297,8 @@ def test_map_when_ambiguous_nested_mapping_should_raise_exception(self): root_mapper.map(TestClassSomeProperty1(some_property=TestClassSomePropertyEmptyInit1())) # then - assert_that(context.exception.message).contains("some_property") - assert_that(context.exception.message).contains("TestClassSomePropertyEmptyInit1") + assert_that(context.exception.args[0]).contains("some_property") + assert_that(context.exception.args[0]).contains("TestClassSomePropertyEmptyInit1") def test_map_explicit_when_ambiguous_nested_mapping_should_raise_exception(self): # given @@ -314,9 +314,9 @@ def test_map_explicit_when_ambiguous_nested_mapping_should_raise_exception(self) root_mapper.map(TestClassSomeProperty1(some_property=TestClassSomePropertyEmptyInit1())) # then - assert_that(context.exception.message).contains("some_property") - assert_that(context.exception.message).contains("mapped_property") - assert_that(context.exception.message).contains("TestClassSomePropertyEmptyInit1") + assert_that(context.exception.args[0]).contains("some_property") + assert_that(context.exception.args[0]).contains("mapped_property") + assert_that(context.exception.args[0]).contains("TestClassSomePropertyEmptyInit1") def test_map_with_reversed_nested_mapper_should_not_use_nested_mapper(self): # given @@ -424,7 +424,7 @@ def test_map_with_option_fail_on_get_attr(self): mapper_strict.map(TestEmptyClass1()) self.fail("Should raise AttributeError") except AttributeError as er: - assert_that(er.message).contains("non_existing_property") + assert_that(er.args[0]).contains("non_existing_property") def test_map_attr_name_for_empty_classes_should_raise_exception(self): # given @@ -435,7 +435,7 @@ def test_map_attr_name_for_empty_classes_should_raise_exception(self): mapper.map_attr_name("unmapped_property") # then - assert_that(context.exception.message).contains("unmapped_property") + assert_that(context.exception.args[0]).contains("unmapped_property") def test_map_attr_name_for_unmapped_explicit_property_should_raise_exception(self): # given @@ -447,7 +447,7 @@ def test_map_attr_name_for_unmapped_explicit_property_should_raise_exception(sel mapper.map_attr_name("unmapped_property") # then - assert_that(context.exception.message).contains("unmapped_property") + assert_that(context.exception.args[0]).contains("unmapped_property") def test_map_attr_name_for_explicit_mapping(self): # given @@ -474,14 +474,14 @@ def test_map_attr_name_for_implicit_mapping(self): mapper.map_attr_name("unmapped_property1") # then - assert_that(context.exception.message).contains("unmapped_property1") + assert_that(context.exception.args[0]).contains("unmapped_property1") # when with self.assertRaises(ValueError) as context: mapper.map_attr_name("unmapped_property2") # then - assert_that(context.exception.message).contains("unmapped_property2") + assert_that(context.exception.args[0]).contains("unmapped_property2") def test_map_attr_value_when_attr_name_unknown_should_raise_exception(self): # when @@ -490,7 +490,7 @@ def test_map_attr_value_when_attr_name_unknown_should_raise_exception(self): map_attr_value("unknown_property", "some_value", MappingDirection.left_to_right) # then - assert_that(context.exception.message).contains("unknown_property") + assert_that(context.exception.args[0]).contains("unknown_property") def test_map_attr_value_when_attr_name_unknown_should_raise_exception_rev(self): # when @@ -499,7 +499,7 @@ def test_map_attr_value_when_attr_name_unknown_should_raise_exception_rev(self): map_attr_value("unknown_property", "some_value", MappingDirection.right_to_left) # then - assert_that(context.exception.message).contains("unknown_property") + assert_that(context.exception.args[0]).contains("unknown_property") def test_map_attr_value_when_opposite_direction_should_raise_exception(self): # when @@ -509,8 +509,8 @@ def test_map_attr_value_when_opposite_direction_should_raise_exception(self): map_attr_value("some_property_02", "some_value", MappingDirection.right_to_left) # then - assert_that(context.exception.message).contains("some_property_02") - assert_that(context.exception.message).contains("right_to_left") + assert_that(context.exception.args[0]).contains("some_property_02") + assert_that(context.exception.args[0]).contains("right_to_left") def test_map_attr_value_when_opposite_direction_should_raise_exception_rev(self): # when @@ -520,8 +520,8 @@ def test_map_attr_value_when_opposite_direction_should_raise_exception_rev(self) map_attr_value("mapped_property_02", "some_value", MappingDirection.left_to_right) # then - assert_that(context.exception.message).contains("mapped_property_02") - assert_that(context.exception.message).contains("left_to_right") + assert_that(context.exception.args[0]).contains("mapped_property_02") + assert_that(context.exception.args[0]).contains("left_to_right") def test_map_attr_value(self): # when @@ -559,8 +559,8 @@ def test_map_attr_value_when_opposite_direction_for_class_should_raise_exception map_attr_value("some_property_02", "some_value", target_class=TestClassSomePropertyEmptyInit1) # then - assert_that(context.exception.message).contains("some_property_02") - assert_that(context.exception.message).contains("TestClassSomePropertyEmptyInit1") + assert_that(context.exception.args[0]).contains("some_property_02") + assert_that(context.exception.args[0]).contains("TestClassSomePropertyEmptyInit1") def test_map_attr_value_when_opposite_direction_for_class_should_raise_exception_rev(self): # when @@ -570,8 +570,8 @@ def test_map_attr_value_when_opposite_direction_for_class_should_raise_exception map_attr_value("mapped_property_02", "some_value", target_class=TestClassMappedPropertyEmptyInit) # then - assert_that(context.exception.message).contains("mapped_property_02") - assert_that(context.exception.message).contains("TestClassMappedPropertyEmptyInit") + assert_that(context.exception.args[0]).contains("mapped_property_02") + assert_that(context.exception.args[0]).contains("TestClassMappedPropertyEmptyInit") def test_map_attr_value_for_target_class(self): # when diff --git a/mapperpy/test/test_one_way_mapper.py b/mapperpy/test/test_one_way_mapper.py index 5551439..d134893 100644 --- a/mapperpy/test/test_one_way_mapper.py +++ b/mapperpy/test/test_one_way_mapper.py @@ -1,6 +1,10 @@ +import sys import unittest from assertpy import assert_that -from mock import Mock +if sys.version_info > (3, 0): + from unittest.mock import Mock +else: + from mock import Mock from mapperpy.attributes_util import AttributesCache from mapperpy.test.common_test_classes import * @@ -38,7 +42,7 @@ def test_map_unknown_property_should_raise_exception(self): mapper.map(TestClassSomeProperty1(some_property="some_value")) # then - assert_that(context.exception.message).contains("unknown") + assert_that(context.exception.args[0]).contains("unknown") def test_map_multiple_explicit_properties(self): # given @@ -137,8 +141,8 @@ def test_nested_mapper_when_wrong_param_type_should_raise_exception(self): root_mapper.nested_mapper(object(), TestClassSomeProperty1) # then - assert_that(context.exception.message).contains(OneWayMapper.__name__) - assert_that(context.exception.message).contains("object") + assert_that(context.exception.args[0]).contains(OneWayMapper.__name__) + assert_that(context.exception.args[0]).contains("object") def test_nested_mapper_when_the_same_mapper_added_should_raise_exception(self): # given @@ -154,8 +158,8 @@ def test_nested_mapper_when_the_same_mapper_added_should_raise_exception(self): TestClassSomePropertyEmptyInit1) # then - assert_that(context.exception.message).contains(TestClassSomePropertyEmptyInit1.__name__) - assert_that(context.exception.message).contains(TestClassSomePropertyEmptyInit2.__name__) + assert_that(context.exception.args[0]).contains(TestClassSomePropertyEmptyInit1.__name__) + assert_that(context.exception.args[0]).contains(TestClassSomePropertyEmptyInit2.__name__) def test_map_with_nested_explicit_mapper(self): # given @@ -201,8 +205,8 @@ def test_map_when_ambiguous_nested_mapping_should_raise_exception(self): root_mapper.map(TestClassSomeProperty1(some_property=TestClassSomePropertyEmptyInit1())) # then - assert_that(context.exception.message).contains("some_property") - assert_that(context.exception.message).contains("TestClassSomePropertyEmptyInit1") + assert_that(context.exception.args[0]).contains("some_property") + assert_that(context.exception.args[0]).contains("TestClassSomePropertyEmptyInit1") def test_map_explicit_when_ambiguous_nested_mapping_should_raise_exception(self): # given @@ -218,9 +222,9 @@ def test_map_explicit_when_ambiguous_nested_mapping_should_raise_exception(self) root_mapper.map(TestClassSomeProperty1(some_property=TestClassSomePropertyEmptyInit1())) # then - assert_that(context.exception.message).contains("some_property") - assert_that(context.exception.message).contains("mapped_property") - assert_that(context.exception.message).contains("TestClassSomePropertyEmptyInit1") + assert_that(context.exception.args[0]).contains("some_property") + assert_that(context.exception.args[0]).contains("mapped_property") + assert_that(context.exception.args[0]).contains("TestClassSomePropertyEmptyInit1") def test_map_with_multiple_nested_mappings_when_no_matching_mapper_for_target_type_should_raise_exception(self): # given @@ -237,9 +241,9 @@ def test_map_with_multiple_nested_mappings_when_no_matching_mapper_for_target_ty some_property=TestClassSomePropertyEmptyInit1(some_property_02="nested_value_02"))) # then - assert_that(context.exception.message).contains("some_property") - assert_that(context.exception.message).contains("TestClassSomePropertyEmptyInit1") - assert_that(context.exception.message).contains("TestClassMappedPropertyEmptyInit") + assert_that(context.exception.args[0]).contains("some_property") + assert_that(context.exception.args[0]).contains("TestClassSomePropertyEmptyInit1") + assert_that(context.exception.args[0]).contains("TestClassMappedPropertyEmptyInit") def test_map_with_multiple_nested_mappings_for_one_attribute_when_target_type_known(self): # given @@ -297,7 +301,7 @@ def test_map_with_custom_target_initializers_when_initializer_not_function_shoul OneWayMapper.for_target_prototype(TestClassSomePropertyEmptyInit1()).target_initializers( {"some_property_02": 7} ) - assert_that(context.exception.message).contains("some_property_02") + assert_that(context.exception.args[0]).contains("some_property_02") def test_map_with_custom_target_initializers(self): # given @@ -335,7 +339,7 @@ def test_map_with_option_fail_on_get_attr(self): mapper_strict.map(TestEmptyClass1()) # then - assert_that(context.exception.message).contains("non_existing_property") + assert_that(context.exception.args[0]).contains("non_existing_property") def test_map_attr_name_for_empty_classes_should_raise_exception(self): # given @@ -346,7 +350,7 @@ def test_map_attr_name_for_empty_classes_should_raise_exception(self): mapper.map_attr_name("unmapped_property") # then - assert_that(context.exception.message).contains("unmapped_property") + assert_that(context.exception.args[0]).contains("unmapped_property") def test_map_attr_name_for_unmapped_explicit_property_should_raise_exception(self): # given @@ -358,7 +362,7 @@ def test_map_attr_name_for_unmapped_explicit_property_should_raise_exception(sel mapper.map_attr_name("unmapped_property") # then - assert_that(context.exception.message).contains("unmapped_property") + assert_that(context.exception.args[0]).contains("unmapped_property") def test_map_attr_name_for_opposite_way_should_raise_exception(self): # given @@ -370,7 +374,7 @@ def test_map_attr_name_for_opposite_way_should_raise_exception(self): mapper.map_attr_name("mapped_property") # then - assert_that(context.exception.message).contains("mapped_property") + assert_that(context.exception.args[0]).contains("mapped_property") def test_map_attr_name_for_explicit_mapping(self): # given @@ -394,7 +398,7 @@ def test_map_attr_name_for_implicit_mapping(self): mapper.map_attr_name("unmapped_property1") # then - assert_that(context.exception.message).contains("unmapped_property1") + assert_that(context.exception.args[0]).contains("unmapped_property1") def test_for_target_class_when_object_passed_should_raise_exception(self): # when @@ -402,7 +406,7 @@ def test_for_target_class_when_object_passed_should_raise_exception(self): OneWayMapper.for_target_class(object()) # then - assert_that(context.exception.message).contains("object") + assert_that(context.exception.args[0]).contains("object") def test_for_target_class(self): assert_that(OneWayMapper.for_target_class(object)).is_not_none() @@ -413,7 +417,7 @@ def test_for_target_prototype_when_class_passed_should_raise_exception(self): OneWayMapper.for_target_prototype(object) # then - assert_that(context.exception.message).contains("object") + assert_that(context.exception.args[0]).contains("object") def test_for_target_prototype(self): assert_that(OneWayMapper.for_target_prototype(object())).is_not_none() @@ -425,7 +429,7 @@ def test_map_attr_value_when_unknown_attr_name_should_raise_exception(self): OneWayMapper.for_target_class(TestClassSomePropertyEmptyInit1).map_attr_value("unknown_attr", "some_value") # then - assert_that(context.exception.message).contains("unknown_attr") + assert_that(context.exception.args[0]).contains("unknown_attr") def test_map_attr_value_for_none_attr_name_should_raise_exception(self): @@ -434,7 +438,7 @@ def test_map_attr_value_for_none_attr_name_should_raise_exception(self): OneWayMapper.for_target_class(TestClassSomePropertyEmptyInit1).map_attr_value(None, "some_value") # then - assert_that(context.exception.message).contains("None") + assert_that(context.exception.args[0]).contains("None") def test_map_attr_value_for_none_value(self): # given From 15829059c697aa41552fc728ece4e6f1995f789d Mon Sep 17 00:00:00 2001 From: Flow Jiang Date: Sat, 14 Apr 2018 21:05:18 +0800 Subject: [PATCH 2/2] Bump version to 0.11.1py34 --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 44c221f..4a8a3d8 100644 --- a/setup.py +++ b/setup.py @@ -3,7 +3,7 @@ from distutils.core import setup setup(name='MapperPy', - version='0.11.1', + version='0.11.1py34', description='Automatic object mapping tool', author='Lukasz Grech', author_email='mapperpy@gmail.com',