def test_skipping_steps_prototype(self):
class SkipLogAdvice(object):
def should_skip(self, attr):
'''
Skip all scheduling actions.
:return: Bool indicating whether to activate.
'''
return 'schedule' in attr.func_name
def prelude(self, attr, _):
if self.should_skip(attr):
set_skip_log(True)
advice_to_apply = SkipLogAdvice()
advice_dict = {}
for target in dir(CustomerServiceWorkflow):
if target[:2] != "__":
advice_dict[eval('CustomerServiceWorkflow.' +
target)] = advice_to_apply
advice_dict[eval('SpecialistWorkflow.' +
target)] = advice_to_apply
weave_clazz(CustomerServiceWorkflow, advice_dict)
weave_clazz(SpecialistWorkflow, advice_dict)
self.company.recieve_message('start')
self.clock.tick(100)
for logged_item in map(lambda event: event[1], action_log[0]):
self.assertTrue('schedule' not in logged_item)
generate_XES(log_path='skipped_scheduling.xes')
def run_model(FuzzerClass,
num_ticks=100000,
num_start_messages=1000,
fuzzer_args=list(),
fuzzer_kwargs=dict()):
advice_to_apply = FuzzerClass(*fuzzer_args, **fuzzer_kwargs)
advice_dict = {}
for target in dir(CustomerServiceWorkflow):
if target[:2] != "__":
advice_dict[eval('CustomerServiceWorkflow.' +
target)] = advice_to_apply
advice_dict[eval('SpecialistWorkflow.' + target)] = advice_to_apply
weave_clazz(CustomerServiceWorkflow, advice_dict)
weave_clazz(SpecialistWorkflow, advice_dict)
'''
@issue: correct-message-pickup
@description
I'd bet that, because work gets put to the back of a queue, these start messages all get processed
before any of the work they produce --- not ideal. Should change to either pick up work from the queue randomly,
or space them after random (but sensible) number of ticks.
(This might be a change to the Troupe, if they pick up work randomly, or a change to
how I deploy the messages otherwise.)
'''
[company.recieve_message('start') for _ in range(num_start_messages)]
clock.tick(num_ticks)
def apply_to_specialist_workers():
advice_dict = dict()
forbidden = ['START', 'END']
for target in dir(SpecialistWorkflow):
if target[:2] != "__" and target not in forbidden:
advice_dict[eval('SpecialistActor.' +
target)] = advice_to_apply
weave_clazz(SpecialistActor, advice_dict)
def apply_to_customer_service_workers():
advice_dict = dict()
forbidden = ['START', 'END']
for target in dir(CustomerServiceWorkflow):
if target[:2] != "__" and target not in forbidden:
advice_dict[eval('CustomerServiceActor.' +
target)] = advice_to_apply
weave_clazz(CustomerServiceActor, advice_dict)
def test_before_and_after(self):
counting_aspect = CountingAspect()
advice = {Target.foo: counting_aspect}
weave_clazz(Target, advice)
Target().foo().foo().foo()
self.assertEqual(3, counting_aspect.invocations)
def test_encore_decorator(self):
@encore
def set_count_to_5_after_running(attr, context, *args, **kwargs):
context.count = 5
advice = {Target.increment_count: set_count_to_5_after_running}
weave_clazz(Target, advice)
target = Target()
target.increment_count()
self.assertEqual(target.count, 5)
def test_error_handling_decorator(self):
@error_handler
def handle_exception(attribute, context, exception):
self.assertTrue(True) # We caught the exception successfully! Pass!
advice = {Target.raise_exception: handle_exception}
weave_clazz(Target, advice)
target = Target()
try:
target.raise_exception()
except:
self.assertTrue(False) # We should have caught this; fail the test.
def test_error_raising(self):
class ExceptionHandlingCounter(CountingAspect):
def error_handling(aspect_self, attribute, context, exception):
self.assertTrue(True) # We handled! Pass the test!
ehc = ExceptionHandlingCounter()
advice = {Target.raise_exception: ehc}
weave_clazz(Target, advice)
target = Target()
try:
target.raise_exception()
except:
self.assertTrue(False) # We should have caught this; fail the test.
def test_around_decorator(self):
def set_count_to_5_before_running(attr, context, *args, **kwargs):
context.count = 5
def increment_counter_after_running(attr, context, *args, **kwargs):
context.count += 1
around_advice = generate_around_advice(set_count_to_5_before_running, increment_counter_after_running)
advice = {Target.increment_count: around_advice}
weave_clazz(Target, advice)
target = Target()
target.increment_count()
self.assertEqual(target.count, 5+1+1)
def test_confidence_interval(self):
advice_to_apply = TestConfidenceIntervals.SkipWhenOverconfident()
advice_dict = {}
for target in dir(CustomerServiceWorkflow):
if target[:2] != "__":
advice_dict[eval('CustomerServiceWorkflow.' +
target)] = advice_to_apply
advice_dict[eval('SpecialistWorkflow.' +
target)] = advice_to_apply
weave_clazz(CustomerServiceWorkflow, advice_dict)
weave_clazz(SpecialistWorkflow, advice_dict)
[self.company.recieve_message('start') for _ in range(1000)]
self.clock.tick(100000)
generate_XES(log_path='confident_actor_trace.xes')
def test_around(self):
class AroundTestingAspect(object):
def around(self, attribute, context, *args, **kwargs):
context.count = context.count ** 3
result = attribute(*args, **kwargs)
context.count *= 2
return result
def prelude(self, attribute, context, *args, **kwargs):
context.count += 2
test_around = AroundTestingAspect()
advice = {Target.increment_count: test_around}
weave_clazz(Target, advice)
target = Target()
target.increment_count()
# We add two in the prelude, then ^3, then add one, then multiply by two.
# This tests that the prelude is being executed before the around, but also that both are being executed.
self.assertEqual(target.count, ((2**3)+1)*2)
def run_model_advanced_aspect_application(
class_identifier_tuple, # Format (FuzzerClass, target_identifying_string, args, kwargs)
num_ticks=10000,
num_start_messages=100):
'''
:param class_identifier_tuple: Format (FuzzerClass, target_identifying_string, args, kwargs)
:param num_ticks:
:param num_start_messages:
:param fuzzer_args:
:param fuzzer_kwargs:
:return:
'''
for FuzzerClass, fuzzer_target_identifier, args, kwargs in class_identifier_tuple:
advice_to_apply = FuzzerClass(*args, **kwargs)
def apply_to_customer_service_workers():
advice_dict = dict()
forbidden = ['START', 'END']
for target in dir(CustomerServiceWorkflow):
if target[:2] != "__" and target not in forbidden:
advice_dict[eval('CustomerServiceActor.' +
target)] = advice_to_apply
weave_clazz(CustomerServiceActor, advice_dict)
def apply_to_specialist_workers():
advice_dict = dict()
forbidden = ['START', 'END']
for target in dir(SpecialistWorkflow):
if target[:2] != "__" and target not in forbidden:
advice_dict[eval('SpecialistActor.' +
target)] = advice_to_apply
weave_clazz(SpecialistActor, advice_dict)
if fuzzer_target_identifier == 'get_next_task':
advice_dict = dict()
advice_dict[CustomerServiceActor.get_next_task] = advice_to_apply
weave_clazz(CustomerServiceActor, advice_dict)
advice_dict = dict()
advice_dict[SpecialistActor.get_next_task] = advice_to_apply
weave_clazz(SpecialistActor, advice_dict)
elif fuzzer_target_identifier == 'customer service actors':
apply_to_customer_service_workers()
elif fuzzer_target_identifier == 'specialist actors':
apply_to_specialist_workers()
elif fuzzer_target_identifier == 'all workflows':
apply_to_specialist_workers()
apply_to_customer_service_workers()
elif fuzzer_target_identifier == 'end':
advice_dict = dict()
advice_dict[SpecialistActor.END] = advice_to_apply
weave_clazz(SpecialistActor, advice_dict)
advice_dict = dict()
advice_dict[CustomerServiceActor.END] = advice_to_apply
weave_clazz(CustomerServiceActor, advice_dict)
elif fuzzer_target_identifier == 'start':
advice_dict = dict()
advice_dict[SpecialistActor.START] = advice_to_apply
weave_clazz(SpecialistActor, advice_dict)
advice_dict = dict()
advice_dict[CustomerServiceActor.START] = advice_to_apply
weave_clazz(CustomerServiceActor, advice_dict)
[company.recieve_message('start') for _ in range(num_start_messages)]
old_man_time.tick(num_ticks)
