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)