def test_get_environment_by_id(self):
em = EnvironmentsManager()
env1 = Environment()
env2 = Environment()
env3 = Environment()
env1.get_id = lambda: "Env1"
env2.get_id = lambda: "Env2"
env3.get_id = lambda: "Env3"
em.add_environment(env1)
em.add_environment(env2)
em.add_environment(env3)
self.assertTrue(env1 == em.get_environment_by_id("Env1"))
self.assertTrue(env2 == em.get_environment_by_id("Env2"))
self.assertTrue(env3 == em.get_environment_by_id("Env3"))
def test_change_config(self):
tk = TaskHeaderKeeper(EnvironmentsManager(), 10.0)
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
task_header = get_dict_task_header()
task_header["max_price"] = 9.0
tk.add_task_header(task_header)
self.assertNotIn("xyz", tk.supported_tasks)
self.assertIsNotNone(tk.task_headers["xyz"])
task_header["task_id"] = "abc"
task_header["max_price"] = 10.0
tk.add_task_header(task_header)
self.assertIn("abc", tk.supported_tasks)
self.assertIsNotNone(tk.task_headers["abc"])
config_desc = Mock()
config_desc.min_price = 10.0
tk.change_config(config_desc)
self.assertNotIn("xyz", tk.supported_tasks)
self.assertIn("abc", tk.supported_tasks)
config_desc.min_price = 8.0
tk.change_config(config_desc)
self.assertIn("xyz", tk.supported_tasks)
self.assertIn("abc", tk.supported_tasks)
config_desc.min_price = 11.0
tk.change_config(config_desc)
self.assertNotIn("xyz", tk.supported_tasks)
self.assertNotIn("abc", tk.supported_tasks)
def test_get_performance(self):
env = Environment()
perf = 6666.6
cfg_desc = ClientConfigDescriptor()
cfg_desc.estimated_performance = perf
result = env.get_performance(cfg_desc)
self.assertTrue(result == perf)
def test_get_task(self):
tk = TaskHeaderKeeper(EnvironmentsManager(), 10)
self.assertIsNone(tk.get_task())
task_header = get_dict_task_header()
task_header["task_id"] = "uvw"
self.assertTrue(tk.add_task_header(task_header))
self.assertIsNone(tk.get_task())
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
task_header["task_id"] = "xyz"
self.assertTrue(tk.add_task_header(task_header))
th = tk.get_task()
assert isinstance(th.task_owner, Node)
self.assertEqual(task_header["task_id"], th.task_id)
self.assertEqual(task_header["max_price"], th.max_price)
self.assertEqual(task_header["node_name"], th.node_name)
self.assertEqual(task_header["task_owner_port"], th.task_owner_port)
self.assertEqual(task_header["task_owner_key_id"],
th.task_owner_key_id)
self.assertEqual(task_header["environment"], th.environment)
self.assertEqual(task_header["deadline"], th.deadline)
self.assertEqual(task_header["subtask_timeout"], th.subtask_timeout)
self.assertEqual(task_header["max_price"], th.max_price)
self.assertEqual(task_header["task_id"], th.task_id)
def test_task_header_update(self):
e = Environment()
e.accept_tasks = True
tk = TaskHeaderKeeper(environments_manager=EnvironmentsManager(),
node=p2p.Node(),
min_price=10)
tk.environments_manager.add_environment(e)
task_header = get_task_header()
task_id = task_header.task_id
task_header.fixed_header.deadline = timeout_to_deadline(10)
task_header.fixed_header.update_checksum()
assert tk.add_task_header(task_header)
assert task_id in tk.supported_tasks
assert tk.add_task_header(task_header)
assert task_id in tk.supported_tasks
task_header = copy.deepcopy(task_header)
task_header.fixed_header.max_price = 1
task_header.fixed_header.update_checksum()
# An attempt to update fixed header should *not* succeed
assert not tk.add_task_header(task_header)
assert task_id in tk.supported_tasks
tk.task_headers = {}
tk.supported_tasks = []
assert tk.add_task_header(task_header)
assert task_id not in tk.supported_tasks
def test_old_tasks(frozen_time, _): # pylint: disable=no-self-argument
tk = TaskHeaderKeeper(environments_manager=EnvironmentsManager(),
node=p2p.Node(),
min_price=10)
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
task_header = get_task_header()
task_header.fixed_header.deadline = timeout_to_deadline(10)
assert tk.add_task_header(task_header)
task_id = task_header.task_id
task_header2 = get_task_header("abc")
task_header2.fixed_header.deadline = timeout_to_deadline(1)
task_id2 = task_header2.task_id
assert tk.add_task_header(task_header2)
assert tk.task_headers.get(task_id2) is not None
assert tk.task_headers.get(task_id) is not None
assert tk.removed_tasks.get(task_id2) is None
assert tk.removed_tasks.get(task_id) is None
assert len(tk.supported_tasks) == 2
frozen_time.tick(timedelta(seconds=1.1)) # pylint: disable=no-member
tk.remove_old_tasks()
assert tk.task_headers.get(task_id2) is None
assert tk.task_headers.get(task_id) is not None
assert tk.removed_tasks.get(task_id2) is not None
assert tk.removed_tasks.get(task_id) is None
assert len(tk.supported_tasks) == 1
assert tk.supported_tasks[0] == task_id
def test_is_supported(self):
tk = TaskHeaderKeeper(EnvironmentsManager(), 10.0)
self.assertFalse(tk.is_supported({}))
task = {"environment": Environment.get_id(), 'max_price': 0}
self.assertFalse(tk.is_supported(task))
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
self.assertFalse(tk.is_supported(task))
task["max_price"] = 10.0
self.assertFalse(tk.is_supported(task))
task["min_version"] = APP_VERSION
self.assertTrue(tk.is_supported(task))
task["max_price"] = 10.5
self.assertTrue(tk.is_supported(task))
config_desc = Mock()
config_desc.min_price = 13.0
tk.change_config(config_desc)
self.assertFalse(tk.is_supported(task))
config_desc.min_price = 10.0
tk.change_config(config_desc)
self.assertTrue(tk.is_supported(task))
task["min_version"] = "120"
self.assertFalse(tk.is_supported(task))
task["min_version"] = tk.app_version
self.assertTrue(tk.is_supported(task))
task["min_version"] = "abc"
with self.assertLogs(logger=logger, level=1):
self.assertFalse(tk.is_supported(task))
def test_task_header_update(self):
e = Environment()
e.accept_tasks = True
tk = TaskHeaderKeeper(EnvironmentsManager(), 10)
tk.environments_manager.add_environment(e)
assert not tk.add_task_header(dict())
task_header = get_dict_task_header()
task_id = task_header["task_id"]
task_header["deadline"] = timeout_to_deadline(10)
assert tk.add_task_header(task_header)
assert task_id in tk.supported_tasks
assert tk.add_task_header(task_header)
assert task_id in tk.supported_tasks
task_header["max_price"] = 1
assert tk.add_task_header(task_header)
assert task_id not in tk.supported_tasks
tk.task_headers = {}
tk.supported_tasks = []
task_header["max_price"] = 1
assert tk.add_task_header(task_header)
assert task_id not in tk.supported_tasks
task_header['task_id'] = "newtaskID"
task_header['deadline'] = "WRONG DEADLINE"
assert not tk.add_task_header(task_header)
def test_is_supported(self):
em = EnvironmentsManager()
em.environments = {}
em.support_statuses = {}
tk = TaskHeaderKeeper(environments_manager=EnvironmentsManager(),
node=p2p.Node(),
min_price=10.0)
header = get_task_header()
header.fixed_header.environment = None
header.fixed_header.max_price = None
header.fixed_header.min_version = None
self.assertFalse(tk.check_support(header))
header.fixed_header.environment = Environment.get_id()
header.fixed_header.max_price = 0
supported = tk.check_support(header)
self.assertFalse(supported)
self.assertIn(UnsupportReason.ENVIRONMENT_MISSING, supported.desc)
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
supported = tk.check_support(header)
self.assertFalse(supported)
self.assertIn(UnsupportReason.MAX_PRICE, supported.desc)
header.fixed_header.max_price = 10.0
supported = tk.check_support(header)
self.assertFalse(supported)
self.assertIn(UnsupportReason.APP_VERSION, supported.desc)
header.fixed_header.min_version = golem.__version__
self.assertTrue(tk.check_support(header))
header.fixed_header.max_price = 10.0
self.assertTrue(tk.check_support(header))
config_desc = mock.Mock()
config_desc.min_price = 13.0
tk.change_config(config_desc)
self.assertFalse(tk.check_support(header))
config_desc.min_price = 10.0
tk.change_config(config_desc)
self.assertTrue(tk.check_support(header))
header.fixed_header.min_version = "120"
self.assertFalse(tk.check_support(header))
header.fixed_header.min_version = tk.app_version
self.assertTrue(tk.check_support(header))
header.fixed_header.min_version = "abc"
with self.assertLogs(logger=logger, level='WARNING'):
self.assertFalse(tk.check_support(header))
def test_get_source_code(self):
env = Environment()
assert env.get_source_code() is None
file_name = path.join(self.path, "mainprogramfile")
env.main_program_file = file_name
assert env.get_source_code() is None
with open(file_name, 'w') as f:
f.write("PROGRAM CODE")
env.main_program_file = file_name
assert env.get_source_code() == "PROGRAM CODE"
def test_check_software(self):
env = Environment()
assert not env.check_software()
env.allow_custom_main_program_file = True
assert env.check_software()
env.allow_custom_main_program_file = False
file_name = path.join(self.path, "mainprogramfile")
env.main_program_file = file_name
with open(file_name, 'w') as f:
f.write("PROGRAM CODE")
assert env.check_software()
def test_change_config(self, tar):
tk = TaskHeaderKeeper(environments_manager=EnvironmentsManager(),
node=p2p.Node(),
min_price=10.0,
task_archiver=tar)
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
task_header = get_task_header()
task_id = task_header.task_id
task_header.fixed_header.max_price = 9.0
tk.add_task_header(task_header)
self.assertNotIn(task_id, tk.supported_tasks)
self.assertIn(task_id, tk.task_headers)
task_header = get_task_header("abc")
task_id2 = task_header.task_id
task_header.fixed_header.max_price = 10.0
tk.add_task_header(task_header)
self.assertIn(task_id2, tk.supported_tasks)
self.assertIn(task_id2, tk.task_headers)
config_desc = mock.Mock()
config_desc.min_price = 10.0
tk.change_config(config_desc)
self.assertNotIn(task_id, tk.supported_tasks)
self.assertIn(task_id2, tk.supported_tasks)
config_desc.min_price = 8.0
tk.change_config(config_desc)
self.assertIn(task_id, tk.supported_tasks)
self.assertIn(task_id2, tk.supported_tasks)
config_desc.min_price = 11.0
tk.change_config(config_desc)
self.assertNotIn(task_id, tk.supported_tasks)
self.assertNotIn(task_id2, tk.supported_tasks)
# Make sure the tasks stats are properly archived
tar.reset_mock()
config_desc.min_price = 9.5
tk.change_config(config_desc)
self.assertNotIn(task_id, tk.supported_tasks)
self.assertIn(task_id2, tk.supported_tasks)
tar.add_support_status.assert_any_call(
task_id, SupportStatus(False, {UnsupportReason.MAX_PRICE: 9.0}))
tar.add_support_status.assert_any_call(task_id2,
SupportStatus(True, {}))
def test_get_task(self):
em = EnvironmentsManager()
em.environments = {}
em.support_statuses = {}
tk = TaskHeaderKeeper(environments_manager=em,
node=p2p.Node(),
min_price=10)
self.assertIsNone(tk.get_task())
task_header = get_task_header("uvw")
self.assertTrue(tk.add_task_header(task_header))
self.assertIsNone(tk.get_task())
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
task_header2 = get_task_header("xyz")
self.assertTrue(tk.add_task_header(task_header2))
th = tk.get_task()
assert isinstance(th.task_owner, Node)
self.assertEqual(task_header2.to_dict(), th.to_dict())
def test_task_header_update_stats(self, tar):
e = Environment()
e.accept_tasks = True
tk = TaskHeaderKeeper(environments_manager=EnvironmentsManager(),
node=p2p.Node(),
min_price=10,
task_archiver=tar)
tk.environments_manager.add_environment(e)
task_header = get_task_header("good")
assert tk.add_task_header(task_header)
tar.add_task.assert_called_with(mock.ANY)
task_id = task_header.task_id
tar.add_support_status.assert_any_call(task_id,
SupportStatus(True, {}))
tar.reset_mock()
task_header2 = get_task_header("bad")
task_id2 = task_header2.task_id
task_header2.fixed_header.max_price = 1.0
assert tk.add_task_header(task_header2)
tar.add_task.assert_called_with(mock.ANY)
tar.add_support_status.assert_any_call(
task_id2, SupportStatus(False, {UnsupportReason.MAX_PRICE: 1.0}))
def test_old_tasks(self):
tk = TaskHeaderKeeper(EnvironmentsManager(), 10)
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
task_header = get_dict_task_header()
task_header["deadline"] = timeout_to_deadline(10)
assert tk.add_task_header(task_header)
task_header["deadline"] = timeout_to_deadline(1)
task_header["task_id"] = "abc"
assert tk.add_task_header(task_header)
assert tk.task_headers.get("abc") is not None
assert tk.task_headers.get("xyz") is not None
assert tk.removed_tasks.get("abc") is None
assert tk.removed_tasks.get("xyz") is None
assert len(tk.supported_tasks) == 2
time.sleep(1.1)
tk.remove_old_tasks()
assert tk.task_headers.get("abc") is None
assert tk.task_headers.get("xyz") is not None
assert tk.removed_tasks.get("abc") is not None
assert tk.removed_tasks.get("xyz") is None
assert len(tk.supported_tasks) == 1
assert tk.supported_tasks[0] == "xyz"
def __init__(self):
self.environment = Environment()
self.name = ''
def test_load_config_manager(self):
mgr = EnvironmentsManager()
mgr.environments.add(Environment())
mgr.load_config(self.path)
assert mgr.env_config
def test_load_config_manager(self):
mgr = EnvironmentsManager()
env = Environment()
mgr.environments[env.get_id()] = env
mgr.load_config(self.path)
assert mgr.env_config
def test_get_unsupport_reasons(self):
tk = TaskHeaderKeeper(environments_manager=EnvironmentsManager(),
node=p2p.Node(),
min_price=10)
e = Environment()
e.accept_tasks = True
tk.environments_manager.add_environment(e)
# Supported task
thd = get_task_header("good")
tk.add_task_header(thd)
# Wrong version
thd = get_task_header("wrong version")
thd.fixed_header.min_version = "42.0.17"
tk.add_task_header(thd)
# Wrong environment
thd = get_task_header("wrong env")
thd.fixed_header.environment = "UNKNOWN"
tk.add_task_header(thd)
# Wrong price
thd = get_task_header("wrong price")
thd.fixed_header.max_price = 1
tk.add_task_header(thd)
# Wrong price and version
thd = get_task_header("wrong price and version")
thd.fixed_header.min_version = "42.0.17"
thd.fixed_header.max_price = 1
tk.add_task_header(thd)
# And one more with wrong version
thd = get_task_header("wrong version 2")
thd.fixed_header.min_version = "42.0.44"
tk.add_task_header(thd)
reasons = tk.get_unsupport_reasons()
# 3 tasks with wrong version
self.assertIn(
{
'avg': golem.__version__,
'reason': 'app_version',
'ntasks': 3
}, reasons)
# 2 tasks with wrong price
self.assertIn({'avg': 7, 'reason': 'max_price', 'ntasks': 2}, reasons)
# 1 task with wrong environment
self.assertIn(
{
'avg': None,
'reason': 'environment_missing',
'ntasks': 1
}, reasons)
self.assertIn(
{
'avg': None,
'reason': 'environment_not_accepting_tasks',
'ntasks': 1
}, reasons)
def setUp(self):
super().setUp()
self.env = Environment()
