def test_init(self): # check from dictionary from_dict = AttributeFilter({"true": True, "false": False}) self.assertTrue(from_dict.true) self.assertFalse(from_dict.false) # todo: check template model # # check is_array_scalar # self.assertFalse(AttributeFilter().is_array_scalar) # self.assertTrue(AttributeFilter(is_array_scalar=True).is_array_scalar) # self.assertFalse(AttributeFilter(is_array_scalar=False).is_array_scalar) # check keyword args kwargs = AttributeFilter({ "true": True, "changed_to_false": True }, changed_to_false=False) self.assertTrue(kwargs.true) self.assertFalse(kwargs.changed_to_false) # check missing keyword arg self.assertRaises(KeyError, AttributeFilter, { "true": True, "false": False }, missing=True)
def test_blueprint(self): class MyModel(types.Model): pass class MyParamSet(ParameterSet): pass param_set = MyParamSet() response_template = MyModel() parameter_sets = [param_set, param_set] body_template = MyModel() attribute_filter = AttributeFilter({"name": True}) verb_config = VerbConfig( response_template=response_template, parameter_sets=parameter_sets, body_template=body_template, request_attribute_filter=attribute_filter ) blueprint = verb_config.blueprint() self.assertEqual(blueprint["response_template"], response_template.blueprint()) self.assertEqual(blueprint["parameter_sets"], [param_set.blueprint(), param_set.blueprint()]) self.assertEqual(blueprint["body_template"], body_template.blueprint()) self.assertEqual(blueprint["request_attribute_filter"], attribute_filter.blueprint())
def test_false_returns_false(self): values = {"a": False, "b": False, "c": False} attribute_filter = AttributeFilter(values) self.assertFalse(attribute_filter.is_attribute_visible("a")) self.assertFalse(attribute_filter.is_attribute_visible("b")) self.assertFalse(attribute_filter.is_attribute_visible("c"))
def test_mixed_returns_correct(self): values = {"a": False, "b": True, "c": False} attribute_filter = AttributeFilter(values) self.assertFalse(attribute_filter.is_attribute_visible("a")) self.assertTrue(attribute_filter.is_attribute_visible("b")) self.assertFalse(attribute_filter.is_attribute_visible("c"))
def test_all_false_returns_false(self): attribute_filter = AttributeFilter({ "a": False, "b": False, "c": False }) self.assertFalse(attribute_filter.are_all_attributes_visible())
def test_true_returns_true(self): values = {"a": True, "b": True, "c": True} attribute_filter = AttributeFilter(values) self.assertTrue(attribute_filter.is_attribute_visible("a")) self.assertTrue(attribute_filter.is_attribute_visible("b")) self.assertTrue(attribute_filter.is_attribute_visible("c"))
def test_invisible_sub_filter_returns_false(self): attribute_filter = AttributeFilter({ "a": { "a": False }, "b": True, "c": True }) self.assertFalse(attribute_filter.are_all_attributes_visible())
def test_mixed_returns_correct(self): values = { "a": False, "b": True, "c": False } attribute_filter = AttributeFilter(values) self.assertFalse(attribute_filter.is_attribute_visible("a")) self.assertTrue(attribute_filter.is_attribute_visible("b")) self.assertFalse(attribute_filter.is_attribute_visible("c"))
def test_false_returns_false(self): values = { "a": False, "b": False, "c": False } attribute_filter = AttributeFilter(values) self.assertFalse(attribute_filter.is_attribute_visible("a")) self.assertFalse(attribute_filter.is_attribute_visible("b")) self.assertFalse(attribute_filter.is_attribute_visible("c"))
def test_true_returns_true(self): values = { "a": True, "b": True, "c": True } attribute_filter = AttributeFilter(values) self.assertTrue(attribute_filter.is_attribute_visible("a")) self.assertTrue(attribute_filter.is_attribute_visible("b")) self.assertTrue(attribute_filter.is_attribute_visible("c"))
def test_init_from_dictionary(self): self.assertRaises(TypeError, AttributeFilter, "string") class MyModel(types.Model): name = types.String() tags = types.Array(element_template=types.String()) self.assertRaises(TypeError, AttributeFilter, {"name": True}, template_model="string") self.assertRaises(TypeError, AttributeFilter, {"name": "string"}) # check that filter is correctly reversed attribute_filter = AttributeFilter({"a": True}, template_model=MyModel()) self.assertTrue(attribute_filter.is_attribute_visible("name"))
def test_multi_levels_of_array_filtered(self): class ChildB(types.Model): child_b_name = types.String() child_b_age = types.Integer() class ChildA(types.Model): child_a_name = types.String() child_a_age = types.Integer() children = types.Array(element_template=ChildB()) class ParentModel(types.Model): parent_name = types.String() parent_percent = types.Float() children = types.Array(element_template=ChildA()) parent_model = ParentModel() parent_model.parent_name = "Nathan" parent_model.parent_percent = 33.3 child_model_a = ChildA() child_model_a.child_a_name = "Steve" child_model_a.child_a_age = 30 child_model_b = ChildB() child_model_b.child_b_name = "Betty" child_model_b.child_b_age = 54 child_model_a.children.append(child_model_b) parent_model.children.append(child_model_a) parent_filter = AttributeFilter.from_model(ParentModel(default=False)) parent_filter.parent_name = True parent_filter.parent_percent = True parent_filter.children.child_a_name = True parent_filter.children.child_a_age = True parent_filter.children.children.child_b_name = True parent_filter.children.children.child_b_age = True validated = ParentModel().validate(parent_model.as_serializable(attribute_filter=parent_filter)) self.assertEqual(validated.parent_name, "Nathan") self.assertEqual(validated.parent_percent, 33.3) self.assertEqual(validated.children[0].child_a_name, "Steve") self.assertEqual(validated.children[0].child_a_age, 30) self.assertEqual(validated.children[0].children[0].child_b_name, "Betty") self.assertEqual(validated.children[0].children[0].child_b_age, 54) parent_filter.parent_name = False parent_filter.children.child_a_name = False parent_filter.children.children.child_b_name = False validated = ParentModel().validate( parent_model.as_serializable(attribute_filter=parent_filter), attribute_filter=parent_filter ) self.assertEqual(validated.parent_name, None) self.assertEqual(validated.parent_percent, 33.3) self.assertEqual(validated.children[0].child_a_name, None) self.assertEqual(validated.children[0].child_a_age, 30) self.assertEqual(validated.children[0].children[0].child_b_name, None) self.assertEqual(validated.children[0].children[0].child_b_age, 54)
def test_partially_visible_sub_filter_returns_true(self): values = { "a": True, "b": False, "c": True, "d": { "a": True, "b": False } } attribute_filter = AttributeFilter(values) self.assertTrue(attribute_filter.is_attribute_visible("a")) self.assertFalse(attribute_filter.is_attribute_visible("b")) self.assertTrue(attribute_filter.is_attribute_visible("c")) self.assertTrue(attribute_filter.is_attribute_visible("d"))
def test_correct_values_returned(self): attribute_filter = AttributeFilter.from_model(FirstLevel(), False) immutable_filter = attribute_filter.as_immutable() self.assertFalse(immutable_filter.is_attribute_visible("first")) self.assertFalse(immutable_filter.is_attribute_visible("second_level")) self.assertFalse(immutable_filter.second_level.is_attribute_visible("second")) self.assertFalse(immutable_filter.second_level.is_attribute_visible("third_level")) self.assertFalse(immutable_filter.second_level.third_level.is_attribute_visible("third")) attribute_filter.second_level.second = True immutable_filter = attribute_filter.as_immutable() self.assertFalse(immutable_filter.is_attribute_visible("first")) self.assertTrue(immutable_filter.is_attribute_visible("second_level")) self.assertTrue(immutable_filter.second_level.is_attribute_visible("second")) self.assertFalse(immutable_filter.second_level.is_attribute_visible("third_level")) self.assertFalse(immutable_filter.second_level.third_level.is_attribute_visible("third")) attribute_filter.second_level.third_level.third = True immutable_filter = attribute_filter.as_immutable() self.assertFalse(immutable_filter.is_attribute_visible("first")) self.assertTrue(immutable_filter.is_attribute_visible("second_level")) self.assertTrue(immutable_filter.second_level.is_attribute_visible("second")) self.assertTrue(immutable_filter.second_level.is_attribute_visible("third_level")) self.assertTrue(immutable_filter.second_level.third_level.is_attribute_visible("third"))
def test_sets_none_for_invisible_attributes(self): class MyModel(types.Model): visible = types.String(default="visible") invisible = types.String(default="invisible") my_model = MyModel() import logging logging.error(my_model.visible) logging.error(my_model.invisible) self.assertEqual(my_model.visible, "visible") self.assertEqual(my_model.invisible, "invisible") attribute_filter = AttributeFilter.from_model(MyModel(), default_value=False) attribute_filter.visible = True validated = my_model.validate({}, attribute_filter) self.assertEqual(validated.visible, "visible") self.assertEqual(validated.invisible, None) attribute_filter.visible = False attribute_filter.invisible = True validated = my_model.validate({}, attribute_filter) self.assertIsNone(validated.visible) self.assertEqual(validated.invisible, "invisible")
def test_keys_from_model(self): # test created from model class MyModel(types.Model): name = types.String() tags = types.Array(element_template=types.String()) from_model = AttributeFilter.from_model(model_instance=MyModel()) self.assertEqual(from_model.keys(), ["name", "tags"])
def test_from_model(self): # check that non data collection raises exception self.assertRaises(TypeError, AttributeFilter.from_model, model_instance="string") # check that array scalar returns filter todo: work out how to further test this array_scalar = AttributeFilter.from_model( types.Array(element_template=types.String())) self.assertTrue(isinstance(array_scalar, AttributeFilter)) # check that a model is constructed correctly and default values work class MyModel(types.Model): name = types.String() age = types.Integer() tags = types.Array(element_template=types.String()) default = AttributeFilter.from_model(model_instance=MyModel()) self.assertFalse(default.name) self.assertFalse(default.age) self.assertFalse(default.tags) default_false = AttributeFilter.from_model(model_instance=MyModel(), default_value=False) self.assertFalse(default_false.name) self.assertFalse(default_false.age) self.assertFalse(default_false.tags) default_true = AttributeFilter.from_model(model_instance=MyModel(), default_value=True) self.assertTrue(default_true.name) self.assertTrue(default_true.age) self.assertTrue(default_true.tags) # check keyword args keyword_args = AttributeFilter.from_model(model_instance=MyModel(), age=True) self.assertFalse(keyword_args.name) self.assertTrue(keyword_args.age) self.assertFalse(keyword_args.tags) self.assertRaises(KeyError, AttributeFilter.from_model, model_instance=MyModel(), missing=True)
def test_from_model(self): class MyModel(types.Model): name = types.String() tags = types.Array(element_template=types.String()) from_model = AttributeFilter.from_model(model_instance=MyModel()) self.assertTrue("name" in from_model) self.assertTrue("tags" in from_model) self.assertFalse("age" in from_model)
def test_header_not_found_returns_none(self): request = Request(environ={"REQUEST_METHOD": VERB.GET}, charset="utf-8", logger=logging.getLogger(), deserializers=[JSON()], default_deserializer=JSON()) self.assertIsNone( request.get_response_attribute_filter( template_filter=AttributeFilter()))
def test_attribute_filter(self): attribute_filter = AttributeFilter() request = Request(environ={"REQUEST_METHOD": VERB.POST}, charset="utf-8", logger=logging.getLogger(), deserializers=[JSON()], default_deserializer=JSON()) request.attribute_filter = attribute_filter self.assertEqual(request.attribute_filter, attribute_filter)
def test_conforms_to_template_filter(self): # check exception raised if template is not an AttributeFilter self.assertRaises(TypeError, AttributeFilter().conforms_to_template_filter, "string") filter_a = AttributeFilter({"a": True, "b": {"a": True}, "c": False}) filter_b = AttributeFilter({"a": False, "b": {"a": False}, "d": True}) # check exception raised if keys differ self.assertRaises(exception.AttributeFilterDiffers, filter_a.conforms_to_template_filter, filter_b) filter_c = AttributeFilter({"a": False, "b": {"a": False}, "c": False}) # check that source values are copied across to template merged_filter = filter_a.conforms_to_template_filter(filter_c) self.assertTrue(merged_filter.is_attribute_visible("a")) self.assertTrue(merged_filter.is_attribute_visible("b")) self.assertTrue(merged_filter.b.is_attribute_visible("a")) self.assertFalse(merged_filter.is_attribute_visible("c"))
def test_as_serializable_filtered_default_false(self): from datetime import date from datetime import datetime from datetime import time from prestans.parser import AttributeFilter class SubModel(types.Model): name = types.String() class MyModel(types.Model): boolean = types.Boolean() date = types.Date() datetime = types.DateTime() float = types.Float() integer = types.Integer() string = types.String() sub = SubModel() time = types.Time() my_model = MyModel() my_model.boolean = True my_model.float = 33.3 my_model.integer = 22 my_model.string = "string" my_model.date = date(2018, 1, 18) my_model.datetime = datetime(2018, 1, 18, 13, 14, 15) my_model.time = time(12, 13, 14) my_model.sub.name = "name" attribute_filter = AttributeFilter.from_model(MyModel(), False) attribute_filter.float = True attribute_filter.string = True serialized = my_model.as_serializable(attribute_filter=attribute_filter) self.assertEqual(serialized, {"float": 33.3, "string": "string"}) attribute_filter = AttributeFilter.from_model(MyModel(), False) attribute_filter.sub.name = True serialized = my_model.as_serializable(attribute_filter=attribute_filter) self.assertEqual(serialized, {"sub": {"name": "name"}})
def test_is_filter_at_key(self): class SubModel(types.Model): name = types.String() class ModelWithSub(types.Model): tags = types.Array(element_template=types.String()) sub_model = SubModel() attribute_filter = AttributeFilter.from_model(model_instance=ModelWithSub()) self.assertTrue(attribute_filter.is_filter_at_key("sub_model")) self.assertFalse(attribute_filter.is_filter_at_key("tags"))
def test_is_filter_at_key(self): class SubModel(types.Model): name = types.String() class ModelWithSub(types.Model): tags = types.Array(element_template=types.String()) sub_model = SubModel() attribute_filter = AttributeFilter.from_model( model_instance=ModelWithSub()) self.assertTrue(attribute_filter.is_filter_at_key("sub_model")) self.assertFalse(attribute_filter.is_filter_at_key("tags"))
def test_single_child_of_type_data_collection(self): class ChildREST(types.Model): boolean = types.Boolean() float = types.Float() integer = types.Integer() string = types.String() class ParentREST(types.Model): child = ChildREST() class ChildPersistent(object): def __init__(self): self.integer = 33 self.string = "string" @property def boolean(self): return False @property def float(self): return 33.3 class ParentPersistent(object): @property def child(self): return ChildPersistent() adapters.registry.register_persistent_rest_pair(ParentPersistent, ParentREST) adapters.registry.register_persistent_rest_pair(ChildPersistent, ChildREST) attribute_filter = AttributeFilter.from_model(ParentREST(), False) attribute_filter.child.boolean = True attribute_filter.child.float = True attribute_filter.child.integer = True attribute_filter.child.string = True self.assertTrue(attribute_filter.is_attribute_visible("child")) self.assertTrue(attribute_filter.child.boolean) self.assertTrue(attribute_filter.child.float) self.assertTrue(attribute_filter.child.integer) self.assertTrue(attribute_filter.child.string) persistent_model = ParentPersistent() adapted_model = sqlalchemy.adapt_persistent_instance(persistent_model, ParentREST, attribute_filter) self.assertEqual(adapted_model.child.boolean, False) self.assertEqual(adapted_model.child.float, 33.3) self.assertEqual(adapted_model.child.integer, 33) self.assertEqual(adapted_model.child.string, "string")
def test_as_dict(self): dict_a = { "a": False, "b": True, "c": { "a": True, "b": False } } filter_a = AttributeFilter(dict_a) self.assertEqual(filter_a.as_dict(), dict_a) dict_b = { "a": False, "b": { "a": False, "b": True }, "c": False } filter_b = AttributeFilter(dict_b) self.assertEqual(filter_b.as_dict(), dict_b)
def test_as_dict(self): dict_a = {"a": False, "b": True, "c": {"a": True, "b": False}} filter_a = AttributeFilter(dict_a) self.assertEqual(filter_a.as_dict(), dict_a) dict_b = {"a": False, "b": {"a": False, "b": True}, "c": False} filter_b = AttributeFilter(dict_b) self.assertEqual(filter_b.as_dict(), dict_b)
def get_response_attribute_filter(self, template_filter, template_model=None): """ Prestans-Response-Attribute-List can contain a client's requested definition for attributes required in the response. This should match the response_attribute_filter_template? :param template_filter: :param template_model: the expected model that this filter corresponds to :return: :rtype: None | AttributeFilter """ if template_filter is None: return None if 'Prestans-Response-Attribute-List' not in self.headers: return None # header not set results in a None attribute_list_str = self.headers['Prestans-Response-Attribute-List'] # deserialize the header contents json_deserializer = deserializer.JSON() attribute_list_dictionary = json_deserializer.loads(attribute_list_str) # construct an AttributeFilter attribute_filter = AttributeFilter( from_dictionary=attribute_list_dictionary, template_model=template_model) #: Check template? Do this even through we might have template_model #: in case users have made a custom filter evaluated_filter = attribute_filter.conforms_to_template_filter( template_filter) return evaluated_filter
def get_attribute_filter(self, default_value=False): from prestans.parser import AttributeFilter attribute_filter = AttributeFilter() for attribute_name, type_instance in self.getmembers(): if isinstance(type_instance, DataCollection): setattr(attribute_filter, attribute_name, type_instance.get_attribute_filter(default_value)) else: setattr(attribute_filter, attribute_name, default_value) return attribute_filter
def test_from_model(self): # check that non data collection raises exception self.assertRaises(TypeError, AttributeFilter.from_model, model_instance="string") # check that array scalar returns filter todo: work out how to further test this array_scalar = AttributeFilter.from_model(types.Array(element_template=types.String())) self.assertTrue(isinstance(array_scalar, AttributeFilter)) # check that a model is constructed correctly and default values work class MyModel(types.Model): name = types.String() age = types.Integer() tags = types.Array(element_template=types.String()) default = AttributeFilter.from_model(model_instance=MyModel()) self.assertFalse(default.name) self.assertFalse(default.age) self.assertFalse(default.tags) default_false = AttributeFilter.from_model(model_instance=MyModel(), default_value=False) self.assertFalse(default_false.name) self.assertFalse(default_false.age) self.assertFalse(default_false.tags) default_true = AttributeFilter.from_model(model_instance=MyModel(), default_value=True) self.assertTrue(default_true.name) self.assertTrue(default_true.age) self.assertTrue(default_true.tags) # check keyword args keyword_args = AttributeFilter.from_model(model_instance=MyModel(), age=True) self.assertFalse(keyword_args.name) self.assertTrue(keyword_args.age) self.assertFalse(keyword_args.tags) self.assertRaises(KeyError, AttributeFilter.from_model, model_instance=MyModel(), missing=True)
def test_as_serializable_filtered_only_child_of_type_model(self): from prestans.parser import AttributeFilter class SubModel(types.Model): name = types.String() class ParentModel(types.Model): sub = SubModel() attribute_filter = AttributeFilter.from_model(ParentModel(), False) attribute_filter.sub.name = True parent_model = ParentModel() parent_model.sub.name = "james" serialized = parent_model.as_serializable(attribute_filter=attribute_filter) self.assertEqual(serialized, {"sub": {"name": "james"}})
def test_as_serializable_filtered_default_true(self): from datetime import date from datetime import datetime from datetime import time from prestans.parser import AttributeFilter class SubModel(types.Model): name = types.String() class MyModel(types.Model): boolean = types.Boolean() date = types.Date() datetime = types.DateTime() float = types.Float() integer = types.Integer() string = types.String() sub = SubModel() time = types.Time() my_model = MyModel() my_model.boolean = True my_model.float = 33.3 my_model.integer = 22 my_model.string = "string" my_model.date = date(2018, 1, 18) my_model.datetime = datetime(2018, 1, 18, 13, 14, 15) my_model.time = time(12, 13, 14) my_model.sub.name = "name" attribute_filter = AttributeFilter.from_model(MyModel(), True) attribute_filter.float = False attribute_filter.string = False serialized = my_model.as_serializable(attribute_filter=attribute_filter) self.assertTrue(isinstance(serialized, dict)) self.assertEqual(serialized["boolean"], True) self.assertTrue("float" not in serialized) self.assertEqual(serialized["integer"], 22) self.assertTrue("string" not in serialized) self.assertEqual(serialized["date"], "2018-01-18") self.assertEqual(serialized["datetime"], "2018-01-18 13:14:15") self.assertEqual(serialized["time"], "12:13:14") self.assertEqual(serialized["sub"]["name"], "name")
def test_header_correctly_parsed(self): request = Request( environ={ "REQUEST_METHOD": VERB.GET, "HTTP_PRESTANS_RESPONSE_ATTRIBUTE_LIST": '{"first_name": true, "last_name": false}' }, charset="utf-8", logger=logging.getLogger(), deserializers=[JSON()], default_deserializer=JSON() ) class Person(types.Model): first_name = types.String() last_name = types.String() response_filter = request.get_response_attribute_filter(template_filter=AttributeFilter.from_model(Person())) self.assertIsInstance(response_filter, AttributeFilter) self.assertTrue(response_filter.first_name) self.assertFalse(response_filter.last_name)
def test_header_correctly_parsed(self): request = Request(environ={ "REQUEST_METHOD": VERB.GET, "HTTP_PRESTANS_RESPONSE_ATTRIBUTE_LIST": '{"first_name": true, "last_name": false}' }, charset="utf-8", logger=logging.getLogger(), deserializers=[JSON()], default_deserializer=JSON()) class Person(types.Model): first_name = types.String() last_name = types.String() response_filter = request.get_response_attribute_filter( template_filter=AttributeFilter.from_model(Person())) self.assertIsInstance(response_filter, AttributeFilter) self.assertTrue(response_filter.first_name) self.assertFalse(response_filter.last_name)
def test_child_model_filtered(self): class ChildModel(types.Model): child_name = types.String() child_age = types.Integer() class ParentModel(types.Model): parent_name = types.String() parent_percent = types.Float() child = ChildModel() parent_model = ParentModel() parent_model.parent_name = "Nathan" parent_model.parent_percent = 33.3 parent_model.child.child_name = "Steve" parent_model.child.child_age = 30 parent_filter = AttributeFilter.from_model(ParentModel(default=False)) parent_filter.parent_name = True parent_filter.parent_percent = True parent_filter.child.child_name = True parent_filter.child.child_age = True validated = ParentModel().validate(parent_model.as_serializable(attribute_filter=parent_filter)) self.assertEqual(validated.parent_name, "Nathan") self.assertEqual(validated.parent_percent, 33.3) self.assertEqual(validated.child.child_name, "Steve") self.assertEqual(validated.child.child_age, 30) parent_filter.parent_name = False parent_filter.child.child_name = False validated = ParentModel().validate( parent_model.as_serializable(attribute_filter=parent_filter), attribute_filter=parent_filter ) self.assertEqual(validated.parent_name, None) self.assertEqual(validated.parent_percent, 33.3) self.assertEqual(validated.child.child_name, None) self.assertEqual(validated.child.child_age, 30)
def test_children_of_type_data_type(self): class RESTModel(types.Model): boolean = types.Boolean() float = types.Float() integer = types.Integer() string = types.String() class PersistentModel(object): def __init__(self): self.boolean = False self.float = 33.3 self.integer = 33 self.string = "string" adapters.registry.register_adapter(sqlalchemy.ModelAdapter( rest_model_class=RESTModel, persistent_model_class=PersistentModel )) attribute_filter = AttributeFilter.from_model(RESTModel(), False) attribute_filter.string = True persistent_model = PersistentModel() adapted_model = sqlalchemy.adapt_persistent_instance(persistent_model, RESTModel, attribute_filter) self.assertEqual(adapted_model.string, "string") attribute_filter.boolean = True attribute_filter.float = True attribute_filter.integer = True adapted_model = sqlalchemy.adapt_persistent_instance(persistent_model, RESTModel, attribute_filter) self.assertEqual(adapted_model.boolean, False) self.assertEqual(adapted_model.float, 33.3) self.assertEqual(adapted_model.integer, 33)
def test_keys_dict(self): # test created from dict from_dict = AttributeFilter({"a": True, "b": False, "c": True}) from_dict_keys = from_dict.keys() self.assertEqual(from_dict_keys, ["a", "b", "c"])
def test_children_of_type_data_type_and_data_collection(self): class ChildREST(types.Model): c_boolean = types.Boolean() c_float = types.Float() c_integer = types.Integer() c_string = types.String() class ParentREST(types.Model): p_boolean = types.Boolean() p_float = types.Float() p_integer = types.Integer() p_string = types.String() child = ChildREST() class ChildPersistent(object): def __init__(self): self.c_boolean = True self.c_float = 44.4 self.c_integer = 44 self.c_string = "string_c" class ParentPersistent(object): def __init__(self): self.p_boolean = False self.p_float = 33.3 self.p_integer = 33 self.p_string = "string_p" @property def child(self): return ChildPersistent() adapters.registry.register_adapter(sqlalchemy.ModelAdapter( rest_model_class=ParentREST, persistent_model_class=ParentPersistent )) adapters.registry.register_adapter(sqlalchemy.ModelAdapter( rest_model_class=ChildREST, persistent_model_class=ChildPersistent )) attribute_filter = AttributeFilter.from_model(ParentREST(), False) self.assertFalse(attribute_filter.as_immutable().p_boolean) self.assertFalse(attribute_filter.as_immutable().p_float) self.assertFalse(attribute_filter.as_immutable().p_integer) self.assertFalse(attribute_filter.as_immutable().p_string) self.assertFalse(attribute_filter.as_immutable().is_attribute_visible("child")) self.assertFalse(attribute_filter.as_immutable().child.c_boolean) self.assertFalse(attribute_filter.as_immutable().child.c_float) self.assertFalse(attribute_filter.as_immutable().child.c_integer) self.assertFalse(attribute_filter.as_immutable().child.c_string) attribute_filter.p_boolean = True attribute_filter.p_float = True attribute_filter.p_integer = False attribute_filter.p_string = True attribute_filter.child.c_boolean = True attribute_filter.child.c_float = True attribute_filter.child.c_integer = True self.assertTrue(attribute_filter.p_boolean) self.assertTrue(attribute_filter.p_float) self.assertFalse(attribute_filter.p_integer) self.assertFalse(attribute_filter.is_attribute_visible("p_integer")) self.assertTrue(attribute_filter.p_string) self.assertTrue(attribute_filter.is_attribute_visible("child")) self.assertTrue(attribute_filter.child.c_boolean) self.assertTrue(attribute_filter.child.c_float) self.assertTrue(attribute_filter.child.c_integer) self.assertFalse(attribute_filter.child.is_attribute_visible("c_string")) self.assertFalse(attribute_filter.child.c_string) self.assertTrue(attribute_filter.as_immutable().p_boolean) self.assertTrue(attribute_filter.as_immutable().p_float) self.assertFalse(attribute_filter.as_immutable().p_integer) self.assertTrue(attribute_filter.as_immutable().p_string) self.assertTrue(attribute_filter.as_immutable().is_attribute_visible("child")) self.assertTrue(attribute_filter.as_immutable().child.c_boolean) self.assertTrue(attribute_filter.as_immutable().child.c_float) self.assertTrue(attribute_filter.as_immutable().child.c_integer) self.assertFalse(attribute_filter.as_immutable().child.c_string) persistent_model = ParentPersistent() adapted_model = sqlalchemy.adapt_persistent_instance(persistent_model, ParentREST, attribute_filter) self.assertEqual(adapted_model.p_boolean, False) self.assertEqual(adapted_model.p_float, 33.3) self.assertIsNone(adapted_model.p_integer) self.assertEqual(adapted_model.p_string, "string_p") self.assertTrue(isinstance(adapted_model.child, ChildREST)) self.assertEqual(adapted_model.child.c_boolean, True) self.assertEqual(adapted_model.child.c_float, 44.4) self.assertEqual(adapted_model.child.c_integer, 44) self.assertIsNone(adapted_model.child.c_string) attribute_filter.p_integer = True attribute_filter.child.c_string = True self.assertTrue(attribute_filter.p_integer) self.assertTrue(attribute_filter.child.c_string) adapted_model = sqlalchemy.adapt_persistent_instance(persistent_model, ParentREST, attribute_filter) self.assertEqual(adapted_model.p_boolean, False) self.assertEqual(adapted_model.p_float, 33.3) self.assertEqual(adapted_model.p_integer, 33) self.assertEqual(adapted_model.p_string, "string_p") self.assertTrue(isinstance(adapted_model.child, ChildREST)) self.assertEqual(adapted_model.child.c_boolean, True) self.assertEqual(adapted_model.child.c_float, 44.4) self.assertEqual(adapted_model.child.c_integer, 44) self.assertEqual(adapted_model.child.c_string, "string_c")
def test_keys_empty(self): empty_dict = AttributeFilter() empty_dict_keys = empty_dict.keys() self.assertEqual(empty_dict_keys, [])
def test_created_with_correct_filter(self): from prestans.parser.attribute_filter_immutable import AttributeFilterImmutable mutable_filter = AttributeFilter() immutable_filter = mutable_filter.as_immutable() self.assertTrue(isinstance(immutable_filter, AttributeFilterImmutable))
def test_from_model_string_array(self): string_array = types.Array(element_template=types.String()) AttributeFilter.from_model(model_instance=string_array, default_value=True)
def test_from_model_integer_array(self): integer_array = types.Array(element_template=types.Integer()) AttributeFilter.from_model(model_instance=integer_array, default_value=True)
def test_from_model_boolean_array(self): boolean_array = types.Array(element_template=types.Boolean()) AttributeFilter.from_model(model_instance=boolean_array, default_value=True)
def test_from_model_float_array(self): float_array = types.Array(element_template=types.Float()) AttributeFilter.from_model(model_instance=float_array, default_value=True)