def testElement(self):
policy = base.BasePolicy()
tag = base.ElementBuilder(policy)
delay = common.delay
e = tag.A(a=1, b=delay(2, 0.01))("XX", delay("YY", 0.01), "ZZ")
self.assertTrue(IElement.providedBy(e))
self.assertTrue(IElementContent.providedBy(e.content))
self.assertFalse(e.is_leaf)
self.assertFalse(e.needs_no_closing)
self.assertTrue(e.is_self_closing)
self.assertEqual(e.tag, "a")
self.assertEqual(len(e), 2)
self.assertTrue("a" in e)
self.assertFalse("c" in e)
self.assertTrue(isinstance(e["a"], unicode))
self.assertTrue(isinstance(e["b"], defer.Deferred))
values = yield defer.join(*(list(e)))
self.assertEqual(set(values), set(["a", "b"]))
e["c"] = 3
self.assertEqual(len(e), 3)
self.assertTrue("a" in e)
self.assertTrue("c" in e)
self.assertTrue(isinstance(e["c"], unicode))
self.assertEqual("1", e["a"])
yield self.asyncEqual("2", e["b"])
self.assertEqual("3", e["c"])
values = yield defer.join(*(list(e)))
self.assertEqual(set(values), set(["a", "b", "c"]))
def render_value_info(value):
result = AsyncDict()
result.add("type", value.value_type.name)
if value.use_default:
result.add("default", value.default)
result.add_if_not_none("label", value.label)
result.add_if_not_none("desc", value.desc)
result.add_if_true("metadata", render_metadata(value))
if IEncodingInfo.providedBy(value):
encinfo = IEncodingInfo(value)
result.add_if_not_none("mimetype", encinfo.mime_type)
result.add_if_not_none("encoding", encinfo.encoding)
if IValueCollection.providedBy(value):
coll = IValueCollection(value)
allowed = [render_value_info(v) for v in coll.allowed_types]
result.add("allowed", defer.join(*allowed))
result.add("ordered", coll.is_ordered)
result.add_if_not_none("min_size", coll.min_size)
result.add_if_not_none("max_size", coll.max_size)
if IValueRange.providedBy(value):
vrange = IValueRange(value)
result.add("minimum", vrange.minimum)
result.add("maximum", vrange.maximum)
result.add_if_not_none("increment", vrange.increment)
if IValueOptions.providedBy(value):
options = IValueOptions(value)
result.add("restricted", options.is_restricted)
result.add("options", [{"label": o.label, "value": o.value}
for o in options.iter_options()])
return result.wait()
def create_items(names):
if not names:
return []
Item = DynamicModelItem
items = [Item(self, n).initiate().addErrback(log_error)
for n in names]
return defer.join(*items)
def testElementContent(self):
policy = base.BasePolicy()
tag = base.ElementBuilder(policy)
delay = common.delay
e = tag.A(a=1, b=delay(2, 0.01))("XX", delay("YY", 0.01), "ZZ")
self.assertEqual(len(e.content), 3)
self.assertEqual("XX", e.content[0])
self.assertTrue(isinstance(e.content[1], defer.Deferred))
yield self.asyncEqual("YY", e.content[1])
values = yield defer.join(*(list(e.content)))
self.assertEqual(set(values), set(["XX", "YY", "ZZ"]))
e.content.append("OO")
self.assertEqual(len(e.content), 4)
self.assertEqual("OO", e.content[3])
values = yield defer.join(*(list(e.content)))
self.assertEqual(set(values), set(["XX", "YY", "ZZ", "OO"]))
def testJoin(self):
res = yield defer.join(common.delay(0, 0.01),
common.delay(1, 0.01),
common.delay(2, 0.01))
self.assertEqual(res, [0, 1, 2])
res = yield defer.join(delay_raise(ValueError, 0.01),
delay_raise(ValueError, 0.01),
delay_raise(ValueError, 0.01))
self.assertEqual(res, [])
res = yield defer.join(common.delay(0, 0.01),
delay_raise(ValueError, 0.01),
common.delay(2, 0.01))
self.assertEqual(res, [0, 2])
res = yield defer.join(1, 2, 3)
self.assertEqual(res, [1, 2, 3])
res = yield defer.join(1, common.delay(2, 0.1), 3)
self.assertEqual(res, [1, 2, 3])
def count_actions(self):
def log_error(failure):
error.handle_failure(None, failure, "Error counting %s model "
"%s actions", self.identity, self.name)
return None
def count_items(items):
# Only count the action items whose initiate method
# returns a non None value
return len(filter(None, items))
items = [i(self).initiate().addErrback(log_error)
for i in self._action_items.itervalues()]
d = defer.join(*items) # Errors are ignored
d.addCallback(count_items)
return d
def fetch_items(self):
def log_error(failure):
error.handle_failure(None, failure, "Error fetching %s model "
"%s items", self.identity, self.name)
return None
def cleanup(items):
# Only return model items whose initiate method
# returns a non None value
return filter(None, items)
items = [item(self).initiate().addErrback(log_error)
for item in self._model_items.itervalues()]
d = defer.join(*items)
d.addCallback(cleanup)
return d
def fetch_actions(self):
def log_error(failure):
error.handle_failure(None, failure, "Error fetching %s model %s "
"actions", self.identity, self.name)
return None
def item_initiated(action_item):
# Only fetch action of items whose initiate method
# returns a non None value
if action_item is not None:
return action_item.fetch()
return None
def cleanup(actions):
# Cleanup actions whose action item's initiate method
# did not returns a non None value
return filter(None, actions)
actions = [i(self).initiate().addCallbacks(item_initiated, log_error)
for i in self._action_items.itervalues()]
d = defer.join(*actions)
d.addCallback(cleanup)
return d
