def test_asynchronous_finisher(self):
'''make termination action'''
termination = NullAction(rspec="kill")
termination.set_nexus(self.nexus)
alt = MockAlternative(u"my", u"spoken", u"words")
sira = StackItemRegisteredAction(termination, {"_node": alt})
'''setup function for asynchronous finisher'''
mutable_integer = {"value": 0}
def increment():
mutable_integer["value"] += 1
#
'''make asynchronous action'''
asynchronous = AsynchronousAction([L(S(["kill"], lambda: None))],
blocking=False,
finisher=Function(increment))
asynchronous.set_nexus(self.nexus)
'''make StackItemAsynchronous'''
sia1 = StackItemAsynchronous(asynchronous, {"_node": alt})
'''add it'''
self.nexus.state.add(sia1)
#
self.nexus.state.add(sira)
'''finisher should be executed when asynchronous finishes'''
self.assertEqual(mutable_integer["value"], 1)
def test_cancel(self):
mutable_integer = {"value": 0}
def increment():
mutable_integer["value"] += 1
'''make fake AsynchronousAction'''
context_set = S(["test", "words"], increment)
unused_context_set = S(["other"], Text, "words")
context_level = L(context_set, unused_context_set)
aa1 = AsynchronousAction([context_level],
time_in_seconds=0.2,
repetitions=20,
blocking=False)
aa1.set_nexus(self.nexus)
'''make fake StackItemAsynchronous'''
alt = MockAlternative(u"gray", u"fox")
sia1 = StackItemAsynchronous(
aa1, {"_node": alt}) # the dictionary is fake Dragonfly data
'''add it'''
self.nexus.state.add(sia1)
'''make fake canceling RegisteredAction'''
cancel = R(NullAction(), rspec="test")
cancel.set_nexus(self.nexus)
'''make fake StackItemRegisteredAction'''
alt2 = MockAlternative(u"my", u"spoken", u"words")
sira1 = StackItemRegisteredAction(cancel, {"_node": alt2})
'''add it'''
self.nexus.state.add(sira1)
'''AsynchronousAction should have executed exactly once,
when it was added, then immediately gotten canceled'''
self.assertEqual(mutable_integer["value"], 1)
def _execute(self, data=None):
if data is not None:
if "time_in_seconds" in data:
self.time_in_seconds = float(data["time_in_seconds"])
if "repetitions" in data:
self.time_in_seconds = int(data["repetitions"])
self.nexus().state.add(StackItemAsynchronous(self, data))
def test_blocking(self):
'''tests:
1 - successful termination (queued actions execute immediately)
2 - unsuccessful termination (queued actions are dropped)
3 - cancellation (queued actions are dropped)
'''
for i in range(0, 3):
'''make fake AsynchronousAction'''
context_set = S(["cancel", "words"], NullAction())
context_level = L(context_set)
aa1 = AsynchronousAction([context_level],
blocking=True) # turn blocking on
aa1.set_nexus(self.nexus)
'''make fake StackItemAsynchronous'''
alt = MockAlternative(u"run", u"blocker")
sia1 = StackItemAsynchronous(
aa1, {"_node": alt}) # the dictionary is fake Dragonfly data
'''add it'''
self.nexus.state.add(sia1)
'''blocked function'''
mutable_integer = {"value": 0}
def increment():
mutable_integer["value"] += 1
'''make fake incrementing RegisteredAction'''
inc = R(Function(increment), rspec="inc")
inc.set_nexus(self.nexus)
'''make fake StackItemRegisteredAction'''
alt2 = MockAlternative(u"my", u"spoken", u"words")
sira1 = StackItemRegisteredAction(inc, {"_node": alt2})
'''add it'''
self.nexus.state.add(sira1)
'''incrementing should be blocked at this point'''
self.assertEqual(mutable_integer["value"], 0)
if i == 0:
'''incrementing should happen that moment of unblocking'''
self.nexus.state.terminate_asynchronous(True)
self.assertEqual(mutable_integer["value"], 1)
elif i == 1:
'''incrementing gets dropped'''
self.nexus.state.terminate_asynchronous(False)
self.assertEqual(mutable_integer["value"], 0)
elif i == 2:
'''make fake canceling RegisteredAction'''
cancel = NullAction(rspec="cancel")
cancel.set_nexus(self.nexus)
'''make fake StackItemRegisteredAction'''
alt3 = MockAlternative(u"my", u"cancel", u"words")
sira2 = StackItemRegisteredAction(cancel, {"_node": alt3})
'''add it'''
self.nexus.state.add(sira2)
'''incrementing gets dropped'''
self.assertEqual(mutable_integer["value"], 0)
def generate_continuer_stack_item(self, continuer, data):
return StackItemAsynchronous(continuer, data)
def test_actions_cleaned(self):
'''these test functions should stay in sync with the clean methods for each stack action'''
def registered_is_clean(r):
return r.dragonfly_data is None and r.base is None
def seeker_is_clean(s):
result = True
levels = []
if s.back is not None: levels += s.back
if s.forward is not None: levels += s.forward
for context_level in levels:
result &= context_level.dragonfly_data is None
return result
def asynchronous_is_clean(a):
return a.closure is None
'''mock words being the same doesn't matter for this test, or most tests'''
alt = MockAlternative(u"my", u"spoken", u"words")
'''make fake NullActions'''
action1 = NullAction(rspec="barkley")
action2 = NullAction(rspec="gaiden")
action3 = NullAction(rspec="is")
action4 = NullAction(rspec="awesome")
action1.set_nexus(self.nexus)
action2.set_nexus(self.nexus)
action3.set_nexus(self.nexus)
action4.set_nexus(self.nexus)
'''make fake StackItemRegisteredActions'''
sira1 = StackItemRegisteredAction(action1, {"_node": alt})
sira2 = StackItemRegisteredAction(action2, {"_node": alt})
sira3 = StackItemRegisteredAction(action3, {"_node": alt})
sira4 = StackItemRegisteredAction(action4, {"_node": alt})
'''should not be clean before it's executed'''
self.assertFalse(registered_is_clean(sira1))
'''add first one for backward seeker'''
self.nexus.state.add(sira1)
'''should be clean as soon as it's executed'''
self.assertTrue(registered_is_clean(sira1))
'''make backward seeker'''
back_seeker = ContextSeeker(
back=[L(S(["minecraft"], Function(lambda: None)))])
back_seeker.set_nexus(self.nexus)
'''create backward seeker stack item'''
stack_seeker = StackItemSeeker(back_seeker, {"_node": alt})
'''add it'''
self.nexus.state.add(stack_seeker)
'''levels should be clean as soon as it's executed'''
self.assertTrue(
registered_is_clean(stack_seeker)
and seeker_is_clean(stack_seeker))
#
'''make forward seeker'''
forward_seeker = ContextSeeker(forward=[
L(S(["cave"], Function(lambda: None))),
L(S(["story"], Function(lambda: None)))
])
forward_seeker.set_nexus(self.nexus)
'''create context seeker stack item'''
stack_seeker2 = StackItemSeeker(forward_seeker, {"_node": alt})
'''add it'''
self.nexus.state.add(stack_seeker2)
self.nexus.state.add(sira2)
'''levels should not be clean before seeker is executed'''
self.assertFalse(
registered_is_clean(stack_seeker2)
or seeker_is_clean(stack_seeker2))
self.nexus.state.add(sira3)
'''levels should be clean as soon as it's executed'''
self.assertTrue(
registered_is_clean(stack_seeker2)
and seeker_is_clean(stack_seeker2))
#
'''make asynchronous action'''
asynchronous = AsynchronousAction(
[L(S(["eternal", "daughter", "awesome"], lambda: None))],
blocking=False)
asynchronous.set_nexus(self.nexus)
'''make StackItemAsynchronous'''
sia1 = StackItemAsynchronous(asynchronous, {"_node": alt})
'''add it'''
self.nexus.state.add(sia1)
'''closure should not be clean before asynchronous is executed'''
self.assertFalse(
registered_is_clean(sia1) or seeker_is_clean(sia1)
or asynchronous_is_clean(sia1))
self.nexus.state.add(sira4)
'''closure should be clean after asynchronous is executed'''
self.assertTrue(
registered_is_clean(sia1) and seeker_is_clean(sia1)
and asynchronous_is_clean(sia1))
def _execute(self, data=None):
self._["tries"] = 0 # reset
self._["dragonfly_data"] = data
h_launch.launch(self.box_type, data=self.encode_box_settings())
self.nexus().state.add(StackItemAsynchronous(self, data))