def test_serialize(self): """ Test a simple serialization of a class to its identifier. """ run_and_check_success(SerializeWorkChain, test=Int, reference=Str( ObjectLoader().identify_object(Int)))
def test_serialize_builder(self): """ Test serailization when using a builder. """ builder = SerializeWorkChain.get_builder() builder.test = Int builder.reference = Str(ObjectLoader().identify_object(Int)) work.launch.run(builder)
def define(cls, spec): super(SerializeWorkChain, cls).define(spec) spec.input( 'test', valid_type=Str, serializer=lambda x: Str(ObjectLoader().identify_object(x)) ) spec.outline(cls.echo)
def test_class_loader(self): cl = ObjectLoader() TemplatereplacerProcess = JobProcess.build(TemplatereplacerCalculation)
def test_class_loader(self): cl = ObjectLoader() AdditionalParameterProcess = JobProcess.build( AdditionalParameterCalculation)
def main(): expected_results_calculations = {} expected_results_workchains = {} code = Code.get_from_string(codename) # Submitting the Calculations the old way, creating and storing a JobCalc first and submitting it print "Submitting {} old style calculations to the daemon".format( number_calculations) for counter in range(1, number_calculations + 1): inputval = counter calc, expected_result = submit_calculation(code=code, counter=counter, inputval=inputval) expected_results_calculations[calc.pk] = expected_result # Submitting the Calculations the new way directly through the launchers print "Submitting {} new style calculations to the daemon".format( number_calculations) for counter in range(1, number_calculations + 1): inputval = counter calc, expected_result = launch_calculation(code=code, counter=counter, inputval=inputval) expected_results_calculations[calc.pk] = expected_result # Submitting the Workchains print "Submitting {} workchains to the daemon".format(number_workchains) for index in range(number_workchains): inp = Int(index) result, node = run_get_node(NestedWorkChain, inp=inp) expected_results_workchains[node.pk] = index print "Submitting a workchain with 'submit'." builder = NestedWorkChain.get_builder() input_val = 4 builder.inp = Int(input_val) proc = submit(builder) expected_results_workchains[proc.pk] = input_val print "Submitting a workchain with a nested input namespace." value = Int(-12) pk = submit(NestedInputNamespace, foo={'bar': {'baz': value}}).pk print "Submitting a workchain with a dynamic non-db input." value = [4, 2, 3] pk = submit(DynamicNonDbInput, namespace={'input': value}).pk expected_results_workchains[pk] = value print "Submitting a workchain with a dynamic db input." value = 9 pk = submit(DynamicDbInput, namespace={'input': Int(value)}).pk expected_results_workchains[pk] = value print "Submitting a workchain with a mixed (db / non-db) dynamic input." value_non_db = 3 value_db = Int(2) pk = submit(DynamicMixedInput, namespace={ 'inputs': { 'input_non_db': value_non_db, 'input_db': value_db } }).pk expected_results_workchains[pk] = value_non_db + value_db print("Submitting the serializing workchain") pk = submit(SerializeWorkChain, test=Int).pk expected_results_workchains[pk] = ObjectLoader().identify_object(Int) print "Submitting the ListEcho workchain." list_value = List() list_value.extend([1, 2, 3]) pk = submit(ListEcho, list=list_value).pk expected_results_workchains[pk] = list_value print "Submitting a WorkChain which contains a workfunction." value = Str('workfunction test string') pk = submit(WorkFunctionRunnerWorkChain, input=value).pk expected_results_workchains[pk] = value print "Submitting a WorkChain which contains an InlineCalculation." value = Str('test_string') pk = submit(InlineCalcRunnerWorkChain, input=value).pk expected_results_workchains[pk] = value calculation_pks = sorted(expected_results_calculations.keys()) workchains_pks = sorted(expected_results_workchains.keys()) pks = calculation_pks + workchains_pks print "Wating for end of execution..." start_time = time.time() exited_with_timeout = True while time.time() - start_time < timeout_secs: time.sleep(15) # Wait a few seconds # Print some debug info, both for debugging reasons and to avoid # that the test machine is shut down because there is no output print "#" * 78 print "####### TIME ELAPSED: {} s".format(time.time() - start_time) print "#" * 78 print "Output of 'verdi calculation list -a':" try: print subprocess.check_output( ["verdi", "calculation", "list", "-a"], stderr=subprocess.STDOUT, ) except subprocess.CalledProcessError as e: print "Note: the command failed, message: {}".format(e.message) print "Output of 'verdi work list':" try: print subprocess.check_output( ['verdi', 'work', 'list', '-a', '-p1'], stderr=subprocess.STDOUT, ) except subprocess.CalledProcessError as e: print "Note: the command failed, message: {}".format(e.message) print "Output of 'verdi daemon status':" try: print subprocess.check_output( ["verdi", "daemon", "status"], stderr=subprocess.STDOUT, ) except subprocess.CalledProcessError as e: print "Note: the command failed, message: {}".format(e.message) if jobs_have_finished(pks): print "Calculation terminated its execution" exited_with_timeout = False break if exited_with_timeout: print_daemon_log() print "" print "Timeout!! Calculation did not complete after {} seconds".format( timeout_secs) sys.exit(2) else: # create cached calculations -- these should be FINISHED immediately cached_calcs = [] for counter in range(1, number_calculations + 1): calc, expected_result = create_cache_calc(code=code, counter=counter, inputval=counter) cached_calcs.append(calc) expected_results_calculations[calc.pk] = expected_result # new style cached calculations, with 'run' with enable_caching(): for counter in range(1, number_calculations + 1): calc, expected_result = run_calculation(code=code, counter=counter, inputval=counter) cached_calcs.append(calc) expected_results_calculations[calc.pk] = expected_result if (validate_calculations(expected_results_calculations) and validate_workchains(expected_results_workchains) and validate_cached(cached_calcs)): print_daemon_log() print "" print "OK, all calculations have the expected parsed result" sys.exit(0) else: print_daemon_log() print "" print "ERROR! Some return values are different from the expected value" sys.exit(3)