def delete_project(self, project: Project):
try:
self.data.remove_project(project.id, True)
self.save()
project.unbind_meta_repo()
except (KeyError, AttributeError):
raise NonExistingProjectError(project)
def delete_project(self, project: Project):
try:
if self.get_tasks(project):
raise ProjectWithTasksError(project)
self.data.remove_project(project.id)
self.save()
project.unbind_meta_repo()
except (KeyError, AttributeError):
raise NonExistingProjectError(project)
def test_project__add_tasks(project_b: Project, task_factory, meta: MetadataRepository):
tasks = [task_factory() for _ in range(5)]
assert len(project_b.tasks) == 0
project_b.add_tasks(tasks)
assert len(project_b.tasks) == 5
for t in tasks:
task_id = t.id
assert task_id is not None
assert t == meta.get_task_by_id(task_id)
assert t == project_b.tasks[task_id]
assert t == project_b.tasks(t.name)
def test_project__add_task__new(set_project_id, meta: MetadataRepository,
project_b: Project, task_factory):
assert len(project_b.tasks) == 0
task: Task = task_factory()
if set_project_id:
task.project = project_b
project_b.add_task(task)
assert len(project_b.tasks) == 1
task_id = task.id
assert task_id is not None
assert task == meta.get_task_by_id(task_id)
assert task == project_b.tasks[task_id]
assert task == project_b.tasks(task.name)
def create_project(self, project: Project) -> Project:
if self.get_project_by_name(project.name) is not None:
raise ExistingProjectError(project)
project._id = str(uuid.uuid4())
self.data.add_project(copy.deepcopy(project))
self.save()
return project
def create_project(self, project: Project) -> Project:
if self.get_project_by_name(project.name) is not None:
raise ExistingProjectError(project)
project._id = self.data.get_and_increment('next_project_id')
self.data.add_project(copy.deepcopy(project))
self.save()
return project
def factory(saved=False):
nonlocal counter
counter += 1
project = Project('Test Project-{}'.format(counter))
if saved:
p = meta.create_project(project)
return p
return project
def to_obj(self) -> Project:
p = Project(self.name,
id=self.id,
author=self.author,
creation_date=self.creation_date)
for task in self.tasks:
p._tasks.add(task.to_obj())
return self.attach(p)
def delete_project(self, project: Project, cascade: bool = False):
""""
Deletes project and(if required) all tasks associated with it from metadata repository
:param project: project to delete
:param cascade: whether should project be deleted with all associated tasks
:return: Nothing
"""
return project.delete(cascade)
def test_update_project_with_tasks(meta: MetadataRepository, project: Project,
task: Task):
project = meta.create_project(project)
task.project = project
task = meta.create_task(task)
project.add_task(task)
project = update_object_fields(project, excepted_fields=['id', 'tasks'])
task = update_object_fields(task,
excepted_fields=['id', 'models', 'project_id'])
updated_project = meta.update_project(project)
assert updated_project is project
assert project.has_meta_repo
assert "Test project2" == updated_project.name
assert project == meta.get_project_by_id(project.id)
assert len(updated_project.tasks) == 1
assert task.id in updated_project.tasks
assert task == updated_project.tasks.get(task.id)
def test_pipeline_buildable(metadata_repo, pipeline):
proj = Project('proj')
task = Task('Test Task')
proj = metadata_repo.create_project(proj)
task.project = proj
task = metadata_repo.create_task(task)
pipeline.task = task
pipeline = metadata_repo.create_pipeline(pipeline)
buildable = PipelineBuildable(pipeline, server_type=FlaskServer.type)
assert buildable.get_provider().get_python_version(
) == platform.python_version()
assert buildable.task.name == 'Test Task'
assert buildable.pipeline == pipeline
def test_update_project_is_reference(meta: MetadataRepository,
project: Project):
project = meta.create_project(project)
id = project._id
project.name = "Test project2"
expected_project = meta.update_project(project)
assert id == expected_project._id
assert "Test project2" == expected_project.name
expected_project.name = "KEK"
actual_project = meta.get_project_by_id(expected_project.id)
assert_objects_equal_except_fields(expected_project,
actual_project,
excepted_fields=['name'])
def test_multimodel_buildable(metadata_repo):
# Dunno why, but it only worked w/o fixtures
proj = Project('proj')
task = Task('Test Task')
mdl = Model.create(lambda data: data, 'input', 'test_model')
proj = metadata_repo.create_project(proj)
task.project = proj
task = metadata_repo.create_task(task)
mdl.task = task
mdl = metadata_repo.create_model(mdl)
with pytest.raises(ValueError):
MultiModelBuildable([], server_type=FlaskServer.type)
assert mdl.has_meta_repo
mm_buildable = MultiModelBuildable([mdl], server_type=FlaskServer.type)
assert mm_buildable.task.name == 'Test Task'
assert mm_buildable.get_provider().get_python_version(
) == platform.python_version()
assert len(mm_buildable.models) == 1
def test_project__add_task__unbind(project: Project, task_factory):
with pytest.raises(UnboundObjectError):
project.add_task(task_factory())
def test_save_updated_existing_project_with_existing_name(
meta: MetadataRepository, project: Project, project2: Project):
meta.create_project(project)
project2.name = project.name
with pytest.raises(ExistingProjectError):
meta.save_project(project2)
def test_update_project_source_is_changed(meta: MetadataRepository,
project: Project):
project = meta.create_project(project)
project.name = "Test project2"
new_project = meta.update_project(project)
assert new_project == project
def project2():
return Project('Test project2')
def project(author, creation_date):
return Project("Test project", author=author, creation_date=creation_date)
def delete_project(self, project: Project):
self._delete_object(self.projects, project, NonExistingProjectError)
project.unbind_meta_repo()
def test_project__add_tasks__empty(project_b: Project):
project_b.add_tasks([])
assert len(project_b.tasks) == 0