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 create_job(self, user, for_user, workspace, target, email):
"""
:return: ID of a new Job
:raises UserNotFoundException: if 'for_user' or 'user' doesn't exist in database
:raises SearchException: Search raises an exception. See exception's message for details
:raises StorageNotAcceptingException: if one of the referenced Storages doesn't accept jobs currently
:raises NoAdministratorRightsException: if 'user' can not create jobs for 'for_user'
:raises PermissionException: if 'for_user' reached his max. amount of jobs
:raises MasterPausedException: if Master is paused
"""
caller = User.get_user_by_username(user)
for_user = User.get_user_by_username(for_user) if for_user else caller
target_storj = Storage.get_storage_by_name(target)
src_workspace = Workspaces.get_by_full_name(workspace)
if src_workspace.username != caller.name and caller.get_user_type() != UserRole.Administrator:
raise PermissionError('Unauthorized to move workspaces of other users.')
src_storj = Storage.get_storage_by_name(src_workspace.storage)
source = src_workspace.full_path
addr = search_class.verify_job(source, target)
target_path = target_storj.mountpoint + addr['source_relative_path']
copy_options = determine_copytool(src_storj, target_storj)
job = Job(addr['source_alias'], target, source, email, for_user, target_path=target_path, copy_options=json.dumps(copy_options))
self.access_handler.check_create_job(job, caller)
self.master.add_to_queue(job)
return job.get_job_id()
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_getters():
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
another_job = Job.get_job_by_id(job.get_job_id())
assert another_job.get_job_id() == job.get_job_id()
assert another_job.get_source_alias() == job.get_source_alias()
assert another_job.get_target_alias() == job.get_target_alias()
assert another_job.get_source_relative_path(
) == job.get_source_relative_path()
assert another_job.get_start_time() == job.get_start_time()
assert another_job.get_end_time() == job.get_end_time()
assert another_job.get_enqueue_time() == job.get_enqueue_time()
assert another_job.get_status() == job.get_status()
assert another_job.has_start_notification() == job.has_start_notification()
assert another_job.has_end_notification() == job.has_end_notification()
assert another_job.has_error_notification() == job.has_error_notification()
assert another_job.get_user().get_username() == job.get_user(
).get_username()
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 get_workers(self, ):
workers = []
worker1 = Worker('worker1', 'WAITING', None, '192.168.0.1:1234',
['storageA', 'storageB'])
workers.append(worker1)
try:
user = User.get_user_by_username("workeruser1")
except UserNotFoundException:
user = User("workeruser1", "token")
job = Job('storageA', 'storageB', '~/.data/', [True, True, True], user)
worker2 = Worker('worker2', 'ACTIVE', job.get_job_id(),
'192.168.0.2:1234', None)
workers.append(worker2)
return workers
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_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 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():
"""
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
