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_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_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_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_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_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_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_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)
