def test_create_task_by_dictionary(self):
task = self.dal.task.create(Task(self.task_input_dict))
assert task.id
assert task.command == self.task_input_dict['command']
assert isinstance(task.start_time, datetime)
assert isinstance(task.end_time, datetime)
assert isinstance(task.duration, float)
assert isinstance(task.created_at, datetime)
assert isinstance(task.updated_at, datetime)
# Create a new Task and test if None values work and not same as first
test_task_input_dict = self.task_input_dict.copy()
test_task_input_dict['start_time'] = None
test_task_input_dict['end_time'] = None
test_task_input_dict['duration'] = None
task_2 = self.dal.task.create(Task(test_task_input_dict))
assert task_2.id != task.id
assert not task_2.start_time
assert not task_2.end_time
assert not task_2.duration
test_task_input_dict_1 = self.task_input_dict.copy()
test_task_input_dict_1['id'] = "task_id"
task_3 = self.dal.task.create(Task(test_task_input_dict_1))
assert task_3.id == test_task_input_dict_1['id']
def test_query_tasks(self):
task = self.dal.task.create(Task(self.task_input_dict))
assert len(self.dal.task.query({"id": task.id})) == 1
_ = self.dal.task.create(Task(self.task_input_dict))
assert len(
self.dal.task.query({"command":
self.task_input_dict['command']})) == 2
def test_sort_tasks(self):
task_1 = self.dal.task.create(Task(self.task_input_dict))
task_2 = self.dal.task.create(Task(self.task_input_dict))
# Sorting of snapshot in descending
items = self.dal.task.query(
{"model_id": self.task_input_dict["model_id"]},
sort_key="created_at",
sort_order="descending")
assert items[0].created_at == task_2.created_at
# Sorting of snapshot in ascending
items = self.dal.task.query(
{"model_id": self.task_input_dict["model_id"]},
sort_key="created_at",
sort_order="ascending")
assert items[0].created_at == task_1.created_at
# Wrong order being passed in
failed = False
try:
_ = self.dal.task.query(
{"model_id": self.task_input_dict["model_id"]},
sort_key="created_at",
sort_order="wrong_order")
except InvalidArgumentType:
failed = True
assert failed
# Wrong key and order being passed in
failed = False
try:
_ = self.dal.task.query(
{"model_id": self.task_input_dict["model_id"]},
sort_key="wrong_key",
sort_order="wrong_order")
except InvalidArgumentType:
failed = True
assert failed
# wrong key and right order being passed in
expected_items = self.dal.task.query(
{"model_id": self.task_input_dict["model_id"]},
sort_key="created_at",
sort_order="ascending")
items = self.dal.task.query(
{"model_id": self.task_input_dict["model_id"]},
sort_key="wrong_key",
sort_order="ascending")
expected_ids = [item.id for item in expected_items]
ids = [item.id for item in items]
assert set(expected_ids) == set(ids)
def test_query_tasks_range_query(self):
_ = self.dal.task.create(Task(self.task_input_dict))
_ = self.dal.task.create(Task(self.task_input_dict))
_ = self.dal.task.create(Task(self.task_input_dict))
tasks = self.dal.task.query({},
sort_key="created_at",
sort_order="descending")
result = self.dal.task.query({
"created_at": {
"$lt": tasks[1].created_at.strftime('%Y-%m-%dT%H:%M:%S.%fZ')
}
})
assert len(tasks) == 3
assert len(result) == 1
def test_str(self):
task_entity = Task(self.input_dict)
for k, v in self.input_dict.items():
if k not in [
"model_id", "data_file_path_map", "data_directory_path_map"
]:
assert str(v) in str(task_entity)
def create(self, dictionary):
"""Create Task object
Parameters
----------
dictionary : dict
command : str
full command used
Returns
-------
Task
object entity for Task (datmo.core.entity.task.Task)
"""
# Validate Inputs
create_dict = {
"model_id": self.model.id,
"session_id": self.current_session.id
}
## Required args
required_args = ["command"]
for required_arg in required_args:
# Add in any values that are
if required_arg in dictionary and dictionary[
required_arg] is not None:
create_dict[required_arg] = dictionary[required_arg]
else:
raise RequiredArgumentMissing(
__("error", "controller.task.create.arg", required_arg))
# Create Task
return self.dal.task.create(Task(create_dict))
def test_get_by_shortened_id_task(self):
task = self.dal.task.create(Task(self.task_input_dict))
result = self.dal.task.get_by_shortened_id(task.id[:10])
assert task.id == result.id
assert task.model_id == result.model_id
assert task.command == result.command
assert task.start_time == result.start_time
assert task.end_time == result.end_time
assert task.duration == result.duration
def test_delete_task(self):
task = self.dal.task.create(Task(self.task_input_dict))
self.dal.task.delete(task.id)
deleted = False
try:
self.dal.task.get_by_id(task.id)
except EntityNotFound:
deleted = True
assert deleted
def test_get_by_id_task_new_driver_instance(self):
task = self.dal.task.create(Task(self.task_input_dict))
# create new dal with new driver instance (success)
new_driver_instance = BlitzDBDALDriver("file", self.temp_dir)
new_dal_instance = LocalDAL(new_driver_instance)
new_task_1 = new_dal_instance.task.get_by_id(task.id)
assert new_task_1.id == task.id
# create new dal instance with same driver (success)
new_dal_instance = LocalDAL(self.datadriver)
new_task_2 = new_dal_instance.task.get_by_id(task.id)
assert new_task_2.id == task.id
def test_update_task(self):
task = self.dal.task.create(Task(self.task_input_dict))
# Update required and optional parameters
updated_task_input_dict = self.task_input_dict.copy()
updated_task_input_dict['id'] = task.id
updated_task_input_dict['command'] = "task_new"
updated_task_input_dict['ports'] = ["9000:9000"]
updated_task = self.dal.task.update(updated_task_input_dict)
assert task.id == updated_task.id
assert task.updated_at < updated_task.updated_at
assert updated_task.command == updated_task_input_dict['command']
assert updated_task.ports == updated_task_input_dict['ports']
def create(self):
"""Create Task object
Returns
-------
Task
object entity for Task (datmo.core.entity.task.Task)
"""
# Validate Inputs
create_dict = {
"model_id": self.model.id,
"session_id": self.current_session.id
}
# Create Task
return self.dal.task.create(Task(create_dict))
def create(self):
"""Create Task object
Returns
-------
Task
object entity for Task (datmo.core.entity.task.Task)
"""
# Validate Inputs
create_dict = {
"model_id": self.model.id,
}
try:
# Create Task
self.spinner.start()
task_obj = self.dal.task.create(Task(create_dict))
finally:
self.spinner.stop()
return task_obj
def test_init_with_id(self):
self.input_dict['id'] = "test"
task_entity = Task(self.input_dict)
for k, v in self.input_dict.items():
assert getattr(task_entity, k) == v
assert task_entity.before_snapshot_id == None
assert task_entity.ports == None
assert task_entity.interactive == False
assert task_entity.detach == False
assert task_entity.task_dirpath == None
assert task_entity.log_filepath == None
assert task_entity.start_time == None
# Post-Execution
assert task_entity.after_snapshot_id == None
assert task_entity.run_id == None
assert task_entity.logs == None
assert task_entity.status == None
assert task_entity.results == None
assert task_entity.end_time == None
assert task_entity.duration == None
assert task_entity.created_at
assert task_entity.updated_at
def test_to_dictionary(self):
task_entity = Task(self.input_dict)
output_dict = task_entity.to_dictionary()
for k, v in output_dict.items():
assert v == getattr(task_entity, k)
def test_eq(self):
task_entity_1 = Task(self.input_dict)
task_entity_2 = Task(self.input_dict)
assert task_entity_1 == task_entity_2
def test_str(self):
task_entity = Task(self.input_dict)
for k, v in self.input_dict.items():
if k != "model_id":
assert str(v) in str(task_entity)
