def test_job_creation_with_already_built_triggers_scheduling(self):
# Create a repo for the project
repo = RepoFactory()
with patch(
'scheduler.tasks.jobs.jobs_build.apply_async') as mock_build:
job = JobFactory(project=repo.project)
assert mock_build.call_count == 1
assert job.project.repo is not None
assert JobStatus.objects.filter(job=job).count() == 1
assert list(
JobStatus.objects.filter(job=job).values_list(
'status', flat=True)) == [JobLifeCycle.CREATED]
with patch('scheduler.dockerizer_scheduler.create_build_job'
) as mock_start:
build = BuildJobFactory()
BuildJobStatus.objects.create(status=JobLifeCycle.SUCCEEDED,
job=build)
mock_start.return_value = build, True, True
jobs_build(job_id=job.id)
assert mock_start.call_count == 1
assert JobStatus.objects.filter(job=job).count() == 2
assert list(
JobStatus.objects.filter(job=job).values_list(
'status',
flat=True)) == [JobLifeCycle.CREATED, JobLifeCycle.SCHEDULED]
job.refresh_from_db()
assert job.last_status == JobLifeCycle.SCHEDULED
def test_independent_experiment_creation_with_run_triggers_experiment_building_scheduling(self):
config = ExperimentSpecification.read(exec_experiment_spec_content)
# Create a repo for the project
repo = RepoFactory()
with patch('scheduler.tasks.experiments.experiments_build.apply_async') as mock_build:
experiment = ExperimentFactory(config=config.parsed_data, project=repo.project)
assert mock_build.call_count == 1
assert experiment.project.repo is not None
assert experiment.is_independent is True
assert ExperimentStatus.objects.filter(experiment=experiment).count() == 1
assert list(ExperimentStatus.objects.filter(experiment=experiment).values_list(
'status', flat=True)) == [ExperimentLifeCycle.CREATED]
with patch('dockerizer.builders.experiments.build_experiment') as mock_build:
build_experiment(experiment_id=experiment.id)
assert mock_build.call_count == 1
assert ExperimentStatus.objects.filter(experiment=experiment).count() == 4
assert list(ExperimentStatus.objects.filter(experiment=experiment).values_list(
'status', flat=True)) == [ExperimentLifeCycle.CREATED,
ExperimentLifeCycle.BUILDING,
ExperimentLifeCycle.SCHEDULED,
ExperimentLifeCycle.FAILED]
experiment.refresh_from_db()
assert experiment.last_status == ExperimentLifeCycle.FAILED
def test_trigger(self):
assert Experiment.objects.count() == 0
assert ExperimentGroup.objects.count() == 0
assert Job.objects.count() == 0
assert BuildJob.objects.count() == 0
# No repo
assert ci.trigger(self.project) is False
assert Experiment.objects.count() == 0
assert ExperimentGroup.objects.count() == 0
assert Job.objects.count() == 0
assert BuildJob.objects.count() == 0
# New code
repo = RepoFactory(project=self.project)
open('{}/foo'.format(repo.path), 'w')
git.commit(repo.path, '*****@*****.**', 'username')
assert ci.trigger(self.project) is False
assert Experiment.objects.count() == 0
assert ExperimentGroup.objects.count() == 0
assert Job.objects.count() == 0
assert BuildJob.objects.count() == 0
# New file
shutil.copy(os.path.abspath('tests/fixtures_static/polyaxonfile.yml'),
'{}/polyaxonfile.yml'.format(repo.path))
git.commit(repo.path, '*****@*****.**', 'username')
assert ci.trigger(self.project) is True
assert Experiment.objects.count() == 1
assert ExperimentGroup.objects.count() == 0
assert Job.objects.count() == 0
assert BuildJob.objects.count() == 0
def test_independent_experiment_creation_with_run_triggers_experiment_scheduling(self):
config = ExperimentSpecification.read(exec_experiment_spec_content)
# Create a repo for the project
repo = RepoFactory()
with patch('scheduler.tasks.experiments.experiments_build.apply_async') as mock_build:
experiment = ExperimentFactory(content=config.raw_data, project=repo.project)
assert mock_build.call_count == 1
assert experiment.project.repo is not None
assert experiment.is_independent is True
assert ExperimentStatus.objects.filter(experiment=experiment).count() == 1
assert list(ExperimentStatus.objects.filter(experiment=experiment).values_list(
'status', flat=True)) == [ExperimentLifeCycle.CREATED]
with patch('scheduler.dockerizer_scheduler.create_build_job') as mock_start:
build = BuildJobFactory()
BuildJobStatus.objects.create(status=JobLifeCycle.SUCCEEDED, job=build)
mock_start.return_value = build, True, True
experiments_build(experiment_id=experiment.id)
assert mock_start.call_count == 1
assert ExperimentStatus.objects.filter(experiment=experiment).count() == 3
assert list(ExperimentStatus.objects.filter(experiment=experiment).values_list(
'status', flat=True)) == [ExperimentLifeCycle.CREATED,
ExperimentLifeCycle.SCHEDULED,
ExperimentLifeCycle.FAILED]
experiment.refresh_from_db()
assert experiment.last_status == ExperimentLifeCycle.FAILED
def test_sync_get_latest_commit_internal_repo(self):
assert self.ci.code_reference is None
# No repo
assert ci.sync(self.project) is False
assert self.ci.code_reference is None
# Repo but no commits
repo = RepoFactory(project=self.project)
assert ci.sync(self.project) is False
assert self.ci.code_reference is None
# Put file and commit
open('{}/foo'.format(repo.path), 'w')
git.commit(repo.path, '*****@*****.**', 'username')
assert ci.sync(self.project) is True
assert self.ci.code_reference is not None
last_code_ref = self.ci.code_reference
# Resync without change does not create new code ref
assert ci.sync(self.project) is False
assert self.ci.code_reference == last_code_ref
# Add new commit
open('{}/foo2'.format(repo.path), 'w')
git.commit(repo.path, '*****@*****.**', 'username')
assert ci.sync(self.project) is True
assert self.ci.code_reference is not None
assert self.ci.code_reference != last_code_ref
def test_job_creation_triggers_build(self):
# Create a repo for the project
repo = RepoFactory()
with patch(
'scheduler.tasks.jobs.jobs_build.apply_async') as mock_build:
job = JobFactory(project=repo.project)
assert mock_build.call_count == 1
assert job.project.repo is not None
assert JobStatus.objects.filter(job=job).count() == 1
assert list(
JobStatus.objects.filter(job=job).values_list(
'status', flat=True)) == [JobLifeCycle.CREATED]
with patch('scheduler.dockerizer_scheduler.start_dockerizer'
) as mock_start:
mock_start.return_value = True
jobs_build(job_id=job.id)
assert mock_start.call_count == 1
assert JobStatus.objects.filter(job=job).count() == 2
assert list(
JobStatus.objects.filter(job=job).values_list(
'status',
flat=True)) == [JobLifeCycle.CREATED, JobLifeCycle.BUILDING]
job.refresh_from_db()
assert job.last_status == JobLifeCycle.BUILDING
def setUp(self):
self.project = RepoFactory()
super().setUp()
self.tested_events = {
repo_events.REPO_CREATED,
repo_events.REPO_DOWNLOADED,
repo_events.REPO_NEW_COMMIT,
}
def test_repo_creation_results_in_repo_path_creation_deletion_results_in_path_deletion(self):
repo_path = '{}/{}/{}/{}'.format(conf.get('REPOS_MOUNT_PATH'),
self.project.user.username,
self.project.name,
self.project.name)
self.assertFalse(os.path.exists(repo_path))
# Create repo
repo = RepoFactory(project=self.project)
assert repo.path == repo_path
self.assertTrue(os.path.exists(repo_path))
git_file_path = '{}/.git'.format(repo_path)
self.assertTrue(os.path.exists(git_file_path))
# Delete repo
repo.delete()
self.assertFalse(os.path.exists(repo_path))
def setUp(self):
super().setUp()
self.object = self.factory_class(user=self.auth_client.user,
has_notebook=True)
RepoFactory(project=self.object)
self.url = '/{}/{}/{}/notebook/stop'.format(API_V1,
self.object.user.username,
self.object.name)
self.queryset = self.model_class.objects.all()
def setUp(self):
self.project = RepoFactory()
auditor.validate()
auditor.setup()
tracker.validate()
tracker.setup()
activitylogs.validate()
activitylogs.setup()
super(AuditorRepoTest, self).setUp()
def setUp(self):
super().setUp()
self.object = self.factory_class(user=self.auth_client.user)
tensorboard = NotebookJobFactory(project=self.object)
tensorboard.set_status(status=JobLifeCycle.RUNNING)
RepoFactory(project=self.object)
self.url = '/{}/{}/{}/notebook/stop'.format(API_V1,
self.object.user.username,
self.object.name)
self.queryset = self.model_class.objects.all()
def setUp(self):
self.project = RepoFactory()
auditor.validate()
auditor.setup()
tracker.validate()
tracker.setup()
activitylogs.validate()
activitylogs.setup()
notifier.validate()
notifier.setup()
super().setUp()
def test_copy_repo_path_to_tmp_dir(self):
project = ProjectFactory()
repo_path = '{}/{}/{}/{}'.format(settings.REPOS_ROOT,
project.user.username, project.name,
project.name)
self.assertFalse(os.path.exists(repo_path))
repo = RepoFactory(project=project)
assert repo.path == repo_path
self.assertTrue(os.path.exists(repo_path))
git_file_path = '{}/.git'.format(repo_path)
self.assertTrue(os.path.exists(git_file_path))
copy_to_tmp_dir(repo_path, 'new')
git_file_path = '{}/.git'.format(get_tmp_path('new'))
self.assertTrue(os.path.exists(git_file_path))
def test_has_code(self):
project = ProjectFactory()
assert project.has_code is False
RepoFactory(project=project)
assert project.has_code is True
def setUp(self):
super().setUp()
self.project = ProjectFactory()
self.repo = RepoFactory(project=self.project)
def test_create_project_with_ci_code_ref(self):
project = ProjectFactory()
repo = RepoFactory(project=project)
code_ref = CodeReferenceFactory(repo=repo)
ci = CIFactory(project=project, code_reference=code_ref)
assert ci.code_reference == code_ref
def setUp(self):
self.project = RepoFactory()
super().setUp()
def test_has_code(self):
project = ProjectFactory()
self.assertEqual(project.has_code, False)
RepoFactory(project=project)
self.assertEqual(project.has_code, True)