def test_get_one_exceptions(self):
""" Test RessourceValue.one. """
def values_source():
return ["1st_obj", "2nd_obj"], ["1st_uriref", "2nd_uriref"]
instance = ResourceValue(values_source, MockResource(), "some_name")
self.assertRaises(surf.exc.CardinalityException, instance.get_one)
def setUp(self):
def values_source():
return ["1st_obj", "2nd_obj"], ["1st_uriref", "2nd_uriref"]
self.store = MockStore()
self.value = ResourceValue(values_source, MockResource(self.store),
"some_name")
def test_contains(self):
""" Test ResourceValue.__contains__. """
def values_source():
return ["value_as_surf_object"], ["value_as_uriref"]
instance = ResourceValue(values_source, MockResource(), "some_name")
# Test basic membership check.
self.assertTrue("value_as_surf_object" in instance)
# Test that "to_rdf" is tried.
self.assertTrue("value_as_uriref" in instance)
class TestResultValueQuery(unittest.TestCase):
def setUp(self):
def values_source():
return ["1st_obj", "2nd_obj"], ["1st_uriref", "2nd_uriref"]
self.store = MockStore()
self.value = ResourceValue(values_source, MockResource(self.store),
"some_name")
def test_limit_offset(self):
""" Test limit, offset. """
self.store.expect_args({"limit" : 10, "offset" : 5})
list(self.value.limit(10).offset(5))
def test_full(self):
""" Test full(). """
self.store.expect_args({"full" : True, "only_direct" : True})
list(self.value.full(only_direct = True))
def test_order_desc(self):
""" Test order, desc. """
self.store.expect_args({"order" : "some_attr", "desc" : True})
list(self.value.order("some_attr").desc())
def test_get_by(self):
""" Test get_by. """
expected = [(surf.ns.FOAF["name"], "Jane", True)]
self.store.expect_args({"get_by" : expected})
list(self.value.get_by(foaf_name = "Jane"))
def test_context(self):
""" Test context. """
self.store.expect_args({"context" : "my_context"})
list(self.value.context("my_context"))
def test_filter(self):
""" Test filter. """
self.store.expect_args({"filter" : [(surf.ns.FOAF["name"], "f", True)]})
list(self.value.filter(foaf_name = "f"))
def test_get_by_resource(self):
""" Test that get_by accepts Resources as values. """
resource = MockResource()
expected = [(surf.ns.FOAF["knows"], resource.subject, True)]
self.store.expect_args({"get_by" : expected})
list(self.value.get_by(foaf_knows = resource))
def __setattr__(self, name, value):
"""
The `set` method - responsible for *caching* the `value` to the
corresponding object attribute given by `name`.
.. note: This method sets the state of the resource to *dirty*
(the `resource` will be persisted if the `commit` `session` method
is called).
"""
def make_values_source(values, rdf_values):
""" Return callable that returns stored values for this attr. """
def setattr_values_source():
""" Return stored values for this attribute. """
return values, rdf_values
return setattr_values_source
predicate, direct = attr2rdf(name)
if predicate:
rdf_dict = direct and self.__rdf_direct or self.__rdf_inverse
if not isinstance(value, list):
value = [value]
rdf_dict[predicate] = []
rdf_dict[predicate].extend([self.to_rdf(val) for val in value])
self.dirty = True
if type(value) is ResourceValue:
pass
else:
if type(value) not in [list, tuple]:
value = [value]
value = map(value_to_rdf, value)
values_source = make_values_source(value, rdf_dict[predicate])
value = ResourceValue(values_source, self, name)
object.__setattr__(self, name, value)
def __getattr__(self, attr_name):
""" Retrieve and cache attribute values.
If attribute name is not in the "ns_predicate" form, an
`AttributeError` will be raised.
This method has no impact on the *dirty* state of the object.
"""
predicate, direct = attr2rdf(attr_name)
if not predicate:
raise AttributeError('Not a predicate: %s' % attr_name)
# Closure for lazy execution.
def make_values_source(resource, predicate, direct, do_query):
""" Return callable that loads and returns values. """
def getattr_values_source():
""" Load and return values for this attribute. """
if do_query:
store = resource.session[resource.store_key]
# Request to triple store
values = store.get(resource, predicate, direct)
# Instantiate SuRF objects
surf_values = resource._lazy(values)
else:
surf_values = []
# Select triple dictionary for synchronization
if direct:
rdf_dict = resource.__rdf_direct
else:
rdf_dict = resource.__rdf_inverse
# Save query_contexts
for i in range(len(surf_values)):
if isinstance(surf_values[i], Resource):
surf_values[i].query_contexts = self.query_contexts
# Initial synchronization
rdf_dict[predicate] = [
resource.to_rdf(value) for value in surf_values
]
return surf_values, rdf_dict[predicate]
return getattr_values_source
# If resource is fully loaded and still we're here
# at __getattr__, this must be an empty attribute, so
# no point querying triple store.
do_query = not self.__full
values_source = make_values_source(self, predicate, direct, do_query)
attr_value = ResourceValue(values_source, self, attr_name)
# Not using self.__setattr__, that would trigger loading of attributes
object.__setattr__(self, attr_name, attr_value)
self.dirty = False
return attr_value