def test_resume_exception():
"""
/SA920/
"""
try:
user = User.get_user_by_username("resumeuser")
except UserNotFoundException:
user = User("resumeuser", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, False, True], user)
job.set_status(JobStatus.ACTIVE)
job_id = job.get_job_id()
request = {
"job_id": job_id,
}
json_string = json.dumps(request)
with pytest.raises(SemanticException):
app.resume(json_string)
"""
/SA930/
"""
request = {
"job_id":
"87497294723947289374823[7936593653456348756t3487657834658723452345",
}
json_string = json.dumps(request)
with pytest.raises(JobNotFoundException):
app.resume(json_string)
def test_done_job():
try:
user = User.get_user_by_username("uyefv")
except UserNotFoundException:
user = User("uyefv", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job.set_status(JobStatus.DONE)
notification_handler.resolve_notification(job)
def test_error_job():
try:
user = User.get_user_by_username("uyefv")
except UserNotFoundException:
user = User("uyefv", "token")
job = Job('storageA', 'storageB', '~/.data/', [False, False, False], user)
job.set_error("Target not mounted")
job.set_status(JobStatus.PAUSED)
notification_handler.resolve_notification(job)
def test_setters():
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
timestamp = datetime.datetime.now()
job.set_start_time(timestamp)
job.set_end_time(timestamp)
job.set_enqueue_time(timestamp)
assert job.get_start_time() == timestamp
assert job.get_end_time() == timestamp
assert job.get_enqueue_time() == timestamp
job.set_status(JobStatus.DONE)
assert job.get_status() == JobStatus.DONE
assert job.has_start_notification() == job.has_start_notification()
assert job.has_end_notification() == job.has_end_notification()
assert job.has_error_notification() == job.has_error_notification()
def test_resume():
"""
/SA910/
"""
try:
user = User.get_user_by_username("resumeuser")
except UserNotFoundException:
user = User("resumeuser", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, False, True], user)
job.set_status(JobStatus.PAUSED)
job_id = job.get_job_id()
request = {
"job_id": job_id,
}
json_string = json.dumps(request)
app.resume(json_string)
def test_cancel_job():
"""
/SA110/
"""
try:
user = User.get_user_by_username("canceljobuser1")
except UserNotFoundException:
user = User("canceljobuser1", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job_id = job.get_job_id()
job.set_status(JobStatus.ACTIVE)
request = {"job_id": job_id, "user": "******"}
json_string = json.dumps(request)
app.cancel_job(json_string)
assert Job.get_job_by_id(job_id).get_status() == JobStatus.CANCELED
def test_build_log():
try:
user = User.get_user_by_username("rbuser")
except UserNotFoundException:
user = User("rbuser", "token")
job1 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job1_id = job1.get_job_id()
job1.set_status(JobStatus.DONE)
timestamp = datetime.datetime.now()
job1.set_enqueue_time(timestamp)
job1.set_end_time(timestamp)
job2 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job2_id = job2.get_job_id()
job2.set_status(JobStatus.DONE)
timestamp = datetime.datetime.now()
job2.set_enqueue_time(timestamp)
job2.set_end_time(timestamp)
job1 = Job.get_job_by_id(job1_id)
job2 = Job.get_job_by_id(job2_id)
answer = json.loads(rb.build_log([job1, job2]))
job1 = Job.get_job_by_id(job1_id)
assert answer[0]["job_id"] == job1.get_job_id()
assert answer[0]["source"] == job1.get_source_alias(
) + ":" + job1.get_source_relative_path()
assert answer[0]["target"] == job1.get_target_alias()
assert answer[0]["enqueue_time"] == job1.get_enqueue_time().isoformat()
assert answer[0]["end_time"] == job1.get_end_time().isoformat()
assert answer[0]["creator"] == job1.get_user().get_username()
assert answer[0]["status"] == job1.get_status().name
assert answer[0]["error"] == job1.get_error()
job2 = Job.get_job_by_id(job2_id)
assert answer[1]["job_id"] == job2.get_job_id()
assert answer[1]["source"] == job2.get_source_alias(
) + ":" + job2.get_source_relative_path()
assert answer[1]["target"] == job2.get_target_alias()
assert answer[1]["enqueue_time"] == job2.get_enqueue_time().isoformat()
assert answer[1]["end_time"] == job2.get_end_time().isoformat()
assert answer[1]["creator"] == job2.get_user().get_username()
assert answer[1]["status"] == job2.get_status().name
assert answer[1]["error"] == job2.get_error()
def test_build_job():
try:
user = User.get_user_by_username("rbuser")
except UserNotFoundException:
user = User("rbuser", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job.set_status(JobStatus.QUEUED)
timestamp = datetime.datetime.now()
job.set_enqueue_time(timestamp)
answer = json.loads(rb.build_job(job))
assert answer["job_id"] == job.get_job_id()
assert answer["source"] == job.get_source_alias(
) + ":" + job.get_source_relative_path()
assert answer["target"] == job.get_target_alias()
assert answer["enqueue_time"] == job.get_enqueue_time().isoformat()
assert answer["creator"] == job.get_user().get_username()
assert answer["status"] == job.get_status().name
return
def test_set_priority():
"""
/SA1010/
"""
try:
user = User.get_user_by_username("priorityuser1")
except UserNotFoundException:
user = Administrator("priorityuser1", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job_id = job.get_job_id()
job.set_status(JobStatus.QUEUED)
request = {"job_id": job_id, "priority": 3}
json_string = json.dumps(request)
app.set_priority(json_string)
job = Job.get_job_by_id(job_id)
assert job.get_priority() == 3
def dequeue(self, job: Job, worker: Worker):
"""
Start working on a given job
:param job: the job to start
:param worker: the worker to assign to
@raises NoResponseFromWorkerException if the connection fails
"""
job.set_status('ACTIVE')
priority = job.priority
job.set_priority(None)
result = self._master_communicator.assign_task(job, worker)
if 'Exception' in result and result['Exception'] != 'None':
if result['Exception'] == 'WorkerStatusException':
worker.set_status(
self._master_communicator.get_status(worker)['status'])
if worker.get_status() == 'WAITING':
self.dequeue(job, worker)
else:
job.set_status('QUEUED')
job.set_priority(priority)
usable = Worker.get_idle_workers_for_storages(
job.source_alias, job.target_alias)
if usable:
self.dequeue(job, usable[0])
elif result['Exception'] == 'NamingConventionError':
job.set_error(
'NamingConventionError: The source file has a Filename that does not fit the Convention'
)
job.set_status('CANCELED')
notification_handler.resolve_notification(job)
def test_cancel_job_semantic_exception():
"""
/SA140/
"""
try:
user = User.get_user_by_username("canceljobuser4")
except UserNotFoundException:
user = User("canceljobuser4", "token")
try:
admin = User.get_user_by_username("canceljobadmin4")
except UserNotFoundException:
admin = Administrator("canceljobadmin4", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job_id = job.get_job_id()
job.set_status(JobStatus.DONE)
request = {"job_id": job_id, "user": "******"}
json_string = json.dumps(request)
with pytest.raises(SemanticException):
app.cancel_job(json_string)
def test_cancel_job_wrong_administrator():
"""
/SA130/
"""
try:
user = User.get_user_by_username("canceljobuser3")
except UserNotFoundException:
user = User("canceljobuser3", "token")
try:
admin = User.get_user_by_username("canceljobfalseadmin33")
except UserNotFoundException:
admin = User("canceljobfalseadmin33", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job_id = job.get_job_id()
job.set_status(JobStatus.ACTIVE)
request = {"job_id": job_id, "user": "******"}
json_string = json.dumps(request)
with pytest.raises(PermissionException):
app.cancel_job(json_string)
def test_get_log_different_days():
"""
/SA240/
"""
try:
user1 = User.get_user_by_username("loguser2")
jobs = Job.get_jobs([user1.get_username()], [
JobStatus.PAUSED, JobStatus.QUEUED, JobStatus.ACTIVE,
JobStatus.DONE
])
for current_job in jobs:
current_job.set_status(JobStatus.ACTIVE)
except UserNotFoundException:
user1 = User("loguser2", "token")
timestamp = datetime.date.today() - datetime.timedelta(days=2)
active_job_ids_user1 = []
job1 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1.set_status(JobStatus.DONE)
job1.set_start_time(timestamp)
job1.set_end_time(timestamp)
job1.set_enqueue_time(timestamp)
active_job_ids_user1.append(job1.get_job_id())
job2 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job2.set_status(JobStatus.DONE)
job2.set_start_time(timestamp)
job2.set_end_time(timestamp)
job2.set_enqueue_time(timestamp)
active_job_ids_user1.append(job2.get_job_id())
job3 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job3.set_status(JobStatus.DONE)
job3.set_start_time(timestamp)
job3.set_end_time(timestamp)
job3.set_enqueue_time(timestamp)
active_job_ids_user1.append(job3.get_job_id())
# Log for last 3 days
request = {"days": "3", "user": "******", "for_user": "******"}
json_string = json.dumps(request)
response = json.loads(app.get_log(json_string))
assert len(response) == 3
for job in response:
assert job['job_id'] in active_job_ids_user1
# Log for last day
request = {"days": "1", "user": "******", "for_user": "******"}
json_string = json.dumps(request)
response = json.loads(app.get_log(json_string))
assert len(response) == 0
def test_get_queue():
"""
/SA310/
"""
jobs = Job.get_jobs(None, [JobStatus.QUEUED])
for current_job in jobs:
current_job.set_status(JobStatus.DONE)
assert len(Job.get_jobs(None, [JobStatus.QUEUED])) == 0
timestamp = datetime.datetime.now()
try:
admin = User.get_user_by_username("queueadmin1")
except UserNotFoundException:
admin = Administrator("queueadmin1", "token")
job1 = Job('storageA', 'storageB', '~/.data/', [True, True, True], admin)
job1_id = job1.get_job_id()
job1.set_status(JobStatus.QUEUED)
job1.set_enqueue_time(timestamp)
job1.set_priority(1)
try:
user = User.get_user_by_username("queueuser1")
except UserNotFoundException:
user = Administrator("queueuser1", "token")
job2 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job2_id = job2.get_job_id()
job2.set_status(JobStatus.QUEUED)
job2.set_enqueue_time(timestamp)
job2.set_priority(2)
job3 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
job3_id = job3.get_job_id()
job3.set_status(JobStatus.QUEUED)
job3.set_enqueue_time(timestamp)
job3.set_priority(3)
response = json.loads(app.get_queue())
assert len(response) == 3
for job_json in response:
job = Job.get_job_by_id(job_json['job_id'])
assert job_json['job_id'] == job1_id or job_json[
'job_id'] == job2_id or job_json['job_id'] == job3_id
assert job_json['job_id'] == job.get_job_id()
assert job_json['source'] == job.get_source_alias(
) + ":" + job.get_source_relative_path()
assert job_json['enqueue_time'] == job.get_enqueue_time().isoformat()
assert job_json['creator'] == job.get_user().get_username()
assert job_json['priority'] == job.get_priority()
assert job_json['status'] == job.get_status().name
def test_get_log():
"""
1. Admin requests logs of user. /SA210/
2. User requests his own logs /SA220/
3. Another user(not admin) requests logs of user /SA230/
:return:
"""
try:
user1 = User.get_user_by_username("loguser1")
jobs = Job.get_jobs([user1.get_username()], [
JobStatus.PAUSED, JobStatus.QUEUED, JobStatus.ACTIVE,
JobStatus.DONE
])
for current_job in jobs:
current_job.set_status(JobStatus.ACTIVE)
except UserNotFoundException:
user1 = User("loguser1", "token")
timestamp = datetime.datetime.now()
active_job_ids_user1 = []
job1 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1.set_status(JobStatus.DONE)
job1.set_start_time(timestamp)
job1.set_end_time(timestamp)
job1.set_enqueue_time(timestamp)
active_job_ids_user1.append(job1.get_job_id())
job2 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job2.set_status(JobStatus.DONE)
job2.set_start_time(timestamp)
job2.set_end_time(timestamp)
job2.set_enqueue_time(timestamp)
active_job_ids_user1.append(job2.get_job_id())
job3 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job3.set_status(JobStatus.DONE)
job3.set_start_time(timestamp)
job3.set_end_time(timestamp)
job3.set_enqueue_time(timestamp)
active_job_ids_user1.append(job3.get_job_id())
# -----------1------------
try:
admin = User.get_user_by_username("logadmin1")
except UserNotFoundException:
admin = Administrator("logadmin1", "token")
request = {"days": "5", "user": "******", "for_user": "******"}
json_string = json.dumps(request)
response = json.loads(app.get_log(json_string))
assert len(response) == 3
for job in response:
assert job['job_id'] in active_job_ids_user1
# -----------2------------
request = {"days": "5", "user": "******", "for_user": "******"}
json_string = json.dumps(request)
response = json.loads(app.get_log(json_string))
assert len(response) == 3
for job in response:
assert job['job_id'] in active_job_ids_user1
# -----------3------------
try:
false_admin = User.get_user_by_username("logadminfalse1")
except UserNotFoundException:
false_admin = User("logadminfalse1", "token")
request = {"days": "5", "user": "******", "for_user": "******"}
json_string = json.dumps(request)
with pytest.raises(PermissionException):
app.get_log(json_string)
def test_get_jobs():
#Build users and jobs
try:
user1 = User.get_user_by_username("user1")
jobs = Job.get_jobs([user1.get_username()], [
JobStatus.PAUSED, JobStatus.QUEUED, JobStatus.ACTIVE,
JobStatus.PAUSED
])
for current_job in jobs:
current_job.set_status(JobStatus.DONE)
except UserNotFoundException:
user1 = User("user1", "token")
try:
user2 = User.get_user_by_username("user2")
jobs = Job.get_jobs([user2.get_username()], [
JobStatus.PAUSED, JobStatus.QUEUED, JobStatus.ACTIVE,
JobStatus.PAUSED
])
for current_job in jobs:
current_job.set_status(JobStatus.DONE)
except UserNotFoundException:
user2 = User("user2", "token")
try:
user3 = User.get_user_by_username("user3")
jobs = Job.get_jobs([user3.get_username()], [
JobStatus.PAUSED, JobStatus.QUEUED, JobStatus.ACTIVE,
JobStatus.PAUSED
])
for current_job in jobs:
current_job.set_status(JobStatus.DONE)
except UserNotFoundException:
user1 = User("user3", "token")
active_job_ids_user1 = []
job1_1 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_1.set_status(JobStatus.ACTIVE)
active_job_ids_user1.append(job1_1.get_job_id())
job1_2 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_2.set_status(JobStatus.ACTIVE)
active_job_ids_user1.append(job1_2.get_job_id())
job1_3 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_3.set_status(JobStatus.ACTIVE)
active_job_ids_user1.append(job1_3.get_job_id())
queued_job_ids_user1 = []
job1_4 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_4.set_status(JobStatus.QUEUED)
queued_job_ids_user1.append(job1_4.get_job_id())
job1_5 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_5.set_status(JobStatus.QUEUED)
queued_job_ids_user1.append(job1_5.get_job_id())
job1_6 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_6.set_status(JobStatus.QUEUED)
queued_job_ids_user1.append(job1_6.get_job_id())
canceled_job_ids_user1 = []
job1_7 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_7.set_status(JobStatus.CANCELED)
canceled_job_ids_user1.append(job1_7.get_job_id())
job1_8 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_8.set_status(JobStatus.CANCELED)
canceled_job_ids_user1.append(job1_8.get_job_id())
job1_9 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user1)
job1_9.set_status(JobStatus.CANCELED)
canceled_job_ids_user1.append(job1_9.get_job_id())
active_jobs_user1 = active_job_ids_user1.copy()
queued_jobs_user1 = queued_job_ids_user1.copy()
canceled_jobs_user1 = canceled_job_ids_user1.copy()
jobs = Job.get_jobs([user1.get_username()], [JobStatus.ACTIVE])
assert len(jobs) == 3
for job in jobs:
if job.get_job_id() not in active_jobs_user1:
assert 1 == 0
else:
assert 1 == 1
active_jobs_user1.remove(job.get_job_id())
assert active_jobs_user1 == []
active_jobs_user1 = active_job_ids_user1.copy()
jobs = Job.get_jobs([user1.get_username()],
[JobStatus.ACTIVE, JobStatus.QUEUED])
assert len(jobs) == 6
for job in jobs:
if job.get_job_id() not in active_jobs_user1:
if job.get_job_id() not in queued_jobs_user1:
assert 1 == 0
else:
assert 1 == 1
queued_jobs_user1.remove(job.get_job_id())
else:
assert 1 == 1
active_jobs_user1.remove(job.get_job_id())
assert active_jobs_user1 == []
assert queued_jobs_user1 == []
active_jobs_user1 = active_job_ids_user1.copy()
queued_jobs_user1 = queued_job_ids_user1.copy()
user2 = User.get_user_by_username("user2")
active_job_ids_user2 = []
job2_1 = Job('storageC', 'storageD', '~/.data/', [True, True, True], user2)
job2_1.set_status(JobStatus.ACTIVE)
active_job_ids_user2.append(job2_1.get_job_id())
job2_2 = Job('storageC', 'storageD', '~/.data/', [True, True, True], user2)
job2_2.set_status(JobStatus.ACTIVE)
active_job_ids_user2.append(job2_2.get_job_id())
job2_3 = Job('storageC', 'storageD', '~/.data/', [True, True, True], user2)
job2_3.set_status(JobStatus.ACTIVE)
active_job_ids_user2.append(job2_3.get_job_id())
queued_job_ids_user2 = []
job2_4 = Job('storageC', 'storageD', '~/.data/', [True, True, True], user2)
job2_4.set_status(JobStatus.QUEUED)
queued_job_ids_user2.append(job2_4.get_job_id())
job2_5 = Job('storageC', 'storageD', '~/.data/', [True, True, True], user2)
job2_5.set_status(JobStatus.QUEUED)
queued_job_ids_user2.append(job2_5.get_job_id())
job2_5 = Job('storageC', 'storageD', '~/.data/', [True, True, True], user2)
job2_5.set_status(JobStatus.QUEUED)
queued_job_ids_user2.append(job2_5.get_job_id())
active_jobs_user2 = active_job_ids_user2.copy()
queued_jobs_user2 = queued_job_ids_user2.copy()
jobs = Job.get_jobs(
[user1.get_username(), user2.get_username()], [JobStatus.ACTIVE])
assert len(jobs) == 6
for job in jobs:
if job.get_job_id() not in active_jobs_user1:
if job.get_job_id() not in active_jobs_user2:
assert 1 == 0
else:
assert 1 == 1
active_jobs_user2.remove(job.get_job_id())
else:
assert 1 == 1
active_jobs_user1.remove(job.get_job_id())
assert active_jobs_user1 == []
assert active_jobs_user2 == []
active_jobs_user1 = active_job_ids_user1.copy()
active_jobs_user2 = active_job_ids_user2.copy()
job3 = Job('storageA', 'storageB', '~/.data/', [True, True, True], user3)
job3.set_status(JobStatus.PAUSED)
time = datetime.datetime.now() - datetime.timedelta(days=10)
job3.set_end_time(time)
jobs = Job.get_jobs(None, [JobStatus.PAUSED], 8)
assert len(jobs) == 0
jobs = Job.get_jobs(None, [JobStatus.PAUSED], 12)
assert len(jobs) == 1