def test_new_nodenet(test_nodenet, resourcepath, engine):
success, nodenet_uid = micropsi.new_nodenet("Test_Nodenet",
engine=engine,
worldadapter="Default",
owner="tester")
assert success
assert nodenet_uid != test_nodenet
assert micropsi.get_available_nodenets(
"tester")[nodenet_uid].name == "Test_Nodenet"
n_path = os.path.join(resourcepath, runtime.NODENET_DIRECTORY,
nodenet_uid + ".json")
assert os.path.exists(n_path)
# get_available_nodenets
nodenets = micropsi.get_available_nodenets()
mynets = micropsi.get_available_nodenets("tester")
assert test_nodenet in nodenets
assert nodenet_uid in nodenets
assert nodenet_uid in mynets
assert test_nodenet not in mynets
# delete_nodenet
micropsi.delete_nodenet(nodenet_uid)
assert nodenet_uid not in micropsi.get_available_nodenets()
assert not os.path.exists(n_path)
def test_unregister_logger():
res, uid1 = micropsi.new_nodenet("test1")
logging.getLogger("agent.%s" % uid1).warning('hello!')
micropsi.delete_nodenet(uid1)
assert "agent.%s" % uid1 not in micropsi.logger.loggers
assert "agent.%s" % uid1 not in micropsi.logger.record_storage
assert "agent.%s" % uid1 not in micropsi.logger.handlers
def pytest_runtest_setup(item):
engine_marker = item.get_marker("engine")
if engine_marker is not None:
engines = engine_marker.args
engine_marker = engine_marker.args[0]
if item.callspec.params['engine'] not in engines:
pytest.skip("test requires engine %s" % engine_marker)
for uid in list(micropsi_runtime.nodenets.keys()):
micropsi_runtime.stop_nodenetrunner(uid)
for uid in list(micropsi_runtime.nodenets.keys()):
micropsi_runtime.delete_nodenet(uid)
for uid in list(micropsi_runtime.worlds.keys()):
micropsi_runtime.delete_world(uid)
for item in os.listdir(testpath):
path = os.path.join(testpath, item)
if os.path.isdir(path):
shutil.rmtree(path)
else:
os.remove(path)
open(os.path.join(testpath, '__init__.py'), 'w').close()
os.mkdir(os.path.join(testpath, 'worlds'))
os.mkdir(os.path.join(testpath, 'nodenets'))
os.mkdir(os.path.join(testpath, 'nodenets', '__autosave__'))
os.mkdir(os.path.join(testpath, 'nodetypes'))
os.mkdir(os.path.join(testpath, 'recipes'))
os.mkdir(os.path.join(testpath, 'operations'))
os.mkdir(os.path.join(testpath, 'nodetypes', 'Test'))
open(os.path.join(testpath, 'nodetypes', 'Test', '__init__.py'), 'w').close()
micropsi_runtime.reload_code()
micropsi_runtime.logger.clear_logs()
micropsi_runtime.set_runner_properties(0, True)
set_logging_levels()
def delete_nodenet_from_console(nodenet_uid):
user_id, permissions, token = get_request_data()
if "manage nodenets" in permissions:
runtime.delete_nodenet(nodenet_uid)
response.set_cookie('notification', '{"msg":"Nodenet deleted", "status":"success"}', path='/')
redirect('/nodenet_mgt')
return template("error", msg="Insufficient rights to access nodenet console")
def test_unregister_logger():
res, uid1 = micropsi.new_nodenet("test1")
logging.getLogger("agent.%s" % uid1).warning('hello!')
micropsi.delete_nodenet(uid1)
assert "agent.%s" % uid1 not in micropsi.logger.loggers
assert "agent.%s" % uid1 not in micropsi.logger.record_storage
assert "agent.%s" % uid1 not in micropsi.logger.handlers
def fixed_nodenet(request, test_world, engine):
"""
A test nodenet filled with some example data (nodenet_data.py)
Structure:
-> A1 -> A2
/
S ACTA
\
-> B1 -> B2
S: Sensor, brightness_l
A1: Pipe
A2: Pipe
B1: Pipe
B2: Pipe
ACTA: Activator, por
"""
from micropsi_core.tests.nodenet_data import fixed_nodenet_data
if engine == "theano_engine":
fixed_nodenet_data = fixed_nodenet_data.replace('Root', 's0001')
success, uid = micropsi.new_nodenet("Fixednet",
engine=engine,
worldadapter="Braitenberg",
owner="Pytest User",
world_uid=test_world,
uid='fixed_test_nodenet')
micropsi.get_nodenet(uid)
micropsi.merge_nodenet(uid, fixed_nodenet_data, keep_uids=True)
micropsi.save_nodenet(uid)
yield uid
try:
micropsi.delete_nodenet(uid)
except:
pass
def fixed_nodenet(request, test_world, engine):
"""
A test nodenet filled with some example data (nodenet_data.py)
Structure:
-> A1 -> A2
/
S ACTA
\
-> B1 -> B2
S: Sensor, brightness_l
A1: Pipe
A2: Pipe
B1: Pipe
B2: Pipe
ACTA: Activator, por
"""
from micropsi_core.tests.nodenet_data import fixed_nodenet_data
if engine == "theano_engine":
fixed_nodenet_data = fixed_nodenet_data.replace('Root', 's0001')
success, uid = micropsi.new_nodenet("Fixednet", engine=engine, worldadapter="Braitenberg", owner="Pytest User", world_uid=test_world, uid='fixed_test_nodenet')
micropsi.get_nodenet(uid)
micropsi.merge_nodenet(uid, fixed_nodenet_data, keep_uids=True)
micropsi.save_nodenet(uid)
yield uid
try:
micropsi.delete_nodenet(uid)
except:
pass
def test_nodenet(request, test_world, engine):
"""
Fixture: A completely empty nodenet without a worldadapter
"""
global nn_uid
success, nn_uid = micropsi.new_nodenet("Testnet", engine=engine, owner="Pytest User", uid='Testnet')
micropsi.save_nodenet(nn_uid)
yield nn_uid
try:
micropsi.delete_nodenet(nn_uid)
except:
pass
def default_nodenet(request):
"""
A nodenet with the default engine
Use this for tests that are engine-agnostic
"""
success, nn_uid = micropsi_runtime.new_nodenet("Defaultnet", owner="Pytest User")
micropsi_runtime.save_nodenet(nn_uid)
yield nn_uid
try:
micropsi_runtime.delete_nodenet(nn_uid)
except:
pass
def test_nodenet(request, default_world, engine):
"""
An empty nodenet, with the currently tested engine.
Use this for tests that should run in both engines
"""
global nn_uid
success, nn_uid = micropsi_runtime.new_nodenet("Testnet", engine=engine, owner="Pytest User")
micropsi_runtime.save_nodenet(nn_uid)
yield nn_uid
try:
micropsi_runtime.delete_nodenet(nn_uid)
except:
pass
def pytest_runtest_teardown(item, nextitem):
if nextitem is None:
print("DELETING ALL STUFF")
shutil.rmtree(config['paths']['resource_path'])
else:
uids = list(micropsi.nodenets.keys())
for uid in uids:
micropsi.delete_nodenet(uid)
if os.path.isfile(nodetype_file):
os.remove(nodetype_file)
if os.path.isfile(nodefunc_file):
os.remove(nodefunc_file)
if os.path.isfile(recipes_file):
os.remove(recipes_file)
micropsi.reload_native_modules()
set_logging_levels()
def pytest_runtest_teardown(item, nextitem):
if nextitem is None:
print("DELETING ALL STUFF")
shutil.rmtree(config['paths']['resource_path'])
else:
uids = list(micropsi.nodenets.keys())
for uid in uids:
micropsi.delete_nodenet(uid)
if os.path.isfile(nodetype_file):
os.remove(nodetype_file)
if os.path.isfile(nodefunc_file):
os.remove(nodefunc_file)
if os.path.isfile(recipes_file):
os.remove(recipes_file)
micropsi.reload_native_modules()
set_logging_levels()
def test_save_nodenet(test_nodenet):
prepare_nodenet(test_nodenet)
# save_nodenet
micropsi.save_nodenet(test_nodenet)
# unload_nodenet
micropsi.unload_nodenet(test_nodenet)
try:
micropsi.get_nodenet_data(test_nodenet, None)
assert False, "could fetch a Nodespace that should not have been in memory"
except:
pass
# load_nodenet
micropsi.load_nodenet(test_nodenet)
nodespace = micropsi.get_nodenet_data(test_nodenet, None)
assert len(nodespace["nodes"]) == 4
micropsi.delete_nodenet(test_nodenet)
def test_new_nodenet(test_nodenet, resourcepath, engine):
success, nodenet_uid = micropsi.new_nodenet("Test_Nodenet", engine=engine, worldadapter="Default", owner="tester")
assert success
assert nodenet_uid != test_nodenet
assert micropsi.get_available_nodenets("tester")[nodenet_uid].name == "Test_Nodenet"
n_path = os.path.join(resourcepath, runtime.NODENET_DIRECTORY, nodenet_uid + ".json")
assert os.path.exists(n_path)
# get_available_nodenets
nodenets = micropsi.get_available_nodenets()
mynets = micropsi.get_available_nodenets("tester")
assert test_nodenet in nodenets
assert nodenet_uid in nodenets
assert nodenet_uid in mynets
assert test_nodenet not in mynets
# delete_nodenet
micropsi.delete_nodenet(nodenet_uid)
assert nodenet_uid not in micropsi.get_available_nodenets()
assert not os.path.exists(n_path)
def test_copy_nodes():
success, nodenet_uid1 = micropsi.new_nodenet("Origin_Nodenet", "Default", owner="tester")
success, nodenet_uid2 = micropsi.new_nodenet("Target_Nodenet", "Default", owner="tester")
# create a few nodes
assert nodenet_uid1 not in micropsi.nodenets
micropsi.load_nodenet(nodenet_uid1)
assert nodenet_uid1 in micropsi.nodenets
micropsi.load_nodenet(nodenet_uid2)
assert nodenet_uid1 in micropsi.nodenets
assert nodenet_uid2 in micropsi.nodenets
micropsi.add_node(nodenet_uid1, "Nodespace", (100, 150), "Root", uid="ns1")
micropsi.add_node(nodenet_uid1, "Nodespace", (200, 150), "Root", uid="confl")
micropsi.add_node(nodenet_uid1, "Nodespace", (400, 150), "Root", uid="ns2")
micropsi.add_node(nodenet_uid2, "Nodespace", (200, 150), "Root", uid="confl")
micropsi.add_node(nodenet_uid1, "Register", (300, 140), "Root", uid="n1")
micropsi.add_node(nodenet_uid1, "Register", (300, 240), "Root", uid="n2")
micropsi.add_node(nodenet_uid1, "Register", (300, 340), "Root", uid="associated_node")
micropsi.add_node(nodenet_uid1, "Register", (400, 240), "ns1", uid="n3")
micropsi.add_node(nodenet_uid1, "Register", (400, 240), "ns2", uid="n4")
micropsi.add_node(nodenet_uid1, "Register", (100, 240), "confl", uid="n5")
micropsi.add_node(nodenet_uid2, "Register", (100, 140), "Root", uid="n1")
micropsi.add_node(nodenet_uid2, "Register", (150, 240), "Root", uid="nt2")
micropsi.add_link(nodenet_uid1, "n1", "gen", "n2", "gen", uid="l1")
micropsi.add_link(nodenet_uid1, "n2", "gen", "n3", "gen", uid="l2")
micropsi.add_link(nodenet_uid1, "n1", "gen", "associated_node", "gen", uid="la")
micropsi.add_link(nodenet_uid1, "n3", "gen", "n1", "gen", uid="l3")
micropsi.add_link(nodenet_uid1, "n4", "gen", "n1", "gen", uid="l4")
micropsi.add_link(nodenet_uid2, "n1", "gen", "nt2", "gen", uid="l1")
# now copy stuff between nodespaces
micropsi.copy_nodes( ["n1", "n2", "n3", "n5", "ns1", "confl"], nodenet_uid1, nodenet_uid2)
micropsi.save_nodenet(nodenet_uid1)
micropsi.save_nodenet(nodenet_uid2)
target = micropsi.get_nodespace(nodenet_uid2, "Root", -1)
assert len(target["nodes"]) == 4 + 2
assert len(target["nodespaces"]) == 2 + 2
assert "n1" in target["nodes"]
assert "n2" in target["nodes"]
assert "n3" in target["nodes"]
assert "associated_node" not in target["nodes"]
assert "n4" not in target["nodes"]
assert "n5" in target["nodes"]
assert "nt2" in target["nodes"]
assert "ns1" in target["nodespaces"]
assert "ns2" not in target["nodespaces"]
assert "confl" in target["nodespaces"]
assert len(target["links"]) == 3 + 1
assert "l1" in target["links"]
assert "l2" in target["links"]
assert "l3" in target["links"]
assert "l4" not in target["links"]
# we should also test for parentage and link connectivity
# TODO now test copying within the same nodenet
micropsi.copy_nodes( ["n1", "n2", "n3", "n5", "ns1", "confl"], nodenet_uid1, nodenet_uid1, target_nodespace_uid="ns2" )
micropsi.save_nodenet(nodenet_uid1)
# delete_nodenets
micropsi.delete_nodenet(nodenet_uid1)
micropsi.delete_nodenet(nodenet_uid2)
def delete_nodenet(nodenet_uid):
return runtime.delete_nodenet(nodenet_uid)
def delete_nodenet(nodenet_uid):
""" Delete the given nodenet """
return runtime.delete_nodenet(nodenet_uid)
def fin():
if DELETE_TEST_FILES_ON_EXIT:
micropsi.delete_nodenet(uid)
def fin():
if DELETE_TEST_FILES_ON_EXIT:
try:
micropsi.delete_nodenet(uid)
except:
pass
