def test_caching(self): with enable_caching(InlineCalculation): calc1, res1 = self.incr_inline(inp=Int(11)) calc2, res2 = self.incr_inline(inp=Int(11)) self.assertEquals(res1['res'].value, res2['res'].value, 12) self.assertEquals( calc1.get_extra('_aiida_cached_from', calc1.uuid), calc2.get_extra('_aiida_cached_from'))
def test_caching_change_code(self): with enable_caching(InlineCalculation): calc1, res1 = self.incr_inline(inp=Int(11)) @make_inline def incr_inline(inp): return {'res': Int(inp.value + 2)} calc2, res2 = incr_inline(inp=Int(11)) self.assertNotEquals(res1['res'].value, res2['res'].value) self.assertFalse('_aiida_cached_from' in calc2.extras())
def test_contextmanager_enable_explicit(self): with enable_caching(TemplatereplacerCalculation): self.assertTrue(get_use_cache(TemplatereplacerCalculation))
def test_invalid_config(self): with enable_caching(TemplatereplacerCalculation): self.assertRaises(ValueError, get_use_cache, TemplatereplacerCalculation)
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)