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_verify_user_exceptions():
"""
/SA1130/
"""
# Invalid token given
try:
user = User.get_user_by_username("verifyadmin")
except UserNotFoundException:
user = Administrator("verifyadmin", "token3")
request = {"user": "******", "token": "invalidtoken"}
json_string = json.dumps(request)
with pytest.raises(PermissionException):
app.verify_user(json_string)
"""
/SA1140/
"""
# Invalid token in database
try:
user = User.get_user_by_username("uyefv")
except UserNotFoundException:
user = User("uyefv", "token3")
request = {"user": "******", "token": "token1"}
json_string = json.dumps(request)
with pytest.raises(PermissionException):
app.verify_user(json_string)
def test_create_job_admin():
"""
/SA020/
"""
try:
user = User.get_user_by_username("createjobuser4")
except UserNotFoundException:
user = User("createjobuser4", "token")
try:
admin = User.get_user_by_username("admin1")
except UserNotFoundException:
admin = Administrator("admin1", "token")
request = {
"source": "source",
"target": "target",
"user": "******",
"for_user": "******",
"email": [True, True, False]
}
json_string = json.dumps(request)
job_id = app.create_job(json_string)
job = Job.get_job_by_id(job_id)
assert job.get_job_id() == job_id
assert job.has_start_notification()
assert not job.has_end_notification()
assert job.has_error_notification()
assert job.get_target_alias() == "target"
assert job.get_user().get_username() == "createjobuser4"
def ensure_existance(self, username):
try:
User.get_user_by_username(username)
except UserNotFoundException:
if username in self._config_handler.get_administrators():
Administrator(username)
else:
User(username)
def test_verify_user():
"""
/SA1110/
"""
try:
user = User.get_user_by_username("verifyadmin")
except UserNotFoundException:
user = Administrator("verifyadmin", "token3")
request = {"user": "******", "token": "token3"}
json_string = json.dumps(request)
response = json.loads(app.verify_user(json_string))
assert response["role"] == "Administrator"
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_administrator():
"""
/SA120/
"""
try:
user = User.get_user_by_username("canceljobuser2")
except UserNotFoundException:
user = User("canceljobuser2", "token")
try:
user = User.get_user_by_username("canceljobadmin2")
except UserNotFoundException:
user = Administrator("canceljobadmin2", "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_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_directory_list():
"""
1. Administrator requests directory list of another user /SA610/
2. User requests his own directory list /SA620/
3. Another user (not Administrator) requests directory list of user /SA630/
"""
try:
admin = User.get_user_by_username("diradmin")
except UserNotFoundException:
admin = Administrator("diradmin", "token")
try:
user1 = User.get_user_by_username("diruser1")
except UserNotFoundException:
user1 = User("diruser1", "token")
try:
user2 = User.get_user_by_username("diruser2")
except UserNotFoundException:
user2 = User("diruser2", "token")
# --------1--------
request = {
"target": "testtarget",
"user": "******",
"for_user": "******"
}
json_string = json.dumps(request)
response = json.loads(app.get_directory_list(json_string))
assert len(response) == 1
assert len(response['testtarget']) == 3
assert response['testtarget'][0] == "directory1"
assert response['testtarget'][1] == "directory2"
assert response['testtarget'][2] == "directory3"
# --------2--------
request = {
"target": "testtarget",
"user": "******",
"for_user": "******"
}
json_string = json.dumps(request)
response = json.loads(app.get_directory_list(json_string))
assert len(response) == 1
assert len(response['testtarget']) == 3
assert response['testtarget'][0] == "directory1"
assert response['testtarget'][1] == "directory2"
assert response['testtarget'][2] == "directory3"
# --------3--------
request = {
"target": "testtarget",
"user": "******",
"for_user": "******"
}
json_string = json.dumps(request)
with pytest.raises(PermissionException):
json.loads(app.get_directory_list(json_string))
def verify_user_via_token(self, username, token):
"""
Verifies the identity of user. If user doesn't exist in the database, he will be created after
given token will be compared with remote_token, that is stored by user.
Given token is compared with database entry.
:param username: user that has to be verified
:param token: user credentials string
:return: verified User
"""
try:
user = User.get_user_by_username(username)
except UserNotFoundException:
remote_token = search_class.get_user_credentials(username)
if remote_token != token:
return False
if username in self._config_handler.get_administrators():
user = Administrator(username, remote_token)
else:
user = User(username, remote_token)
# In case a User was registered using munge a token is not present in the data base entry
if not user.get_token():
remote_token = search_class.get_user_credentials(username)
user.set_token(remote_token)
# Check if the token match
if user.get_token() != token:
# Update database entry in case credentials have changed
remote_token = search_class.get_user_credentials(username)
if remote_token != user.get_token():
user.set_token(remote_token)
if user.get_token() != token:
return False
return True