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_permission_exception():
"""
/SA030/
"""
try:
user = User.get_user_by_username("createjobuser4")
except UserNotFoundException:
user = User("createjobuser4", "token")
try:
admin = User.get_user_by_username("false_admin1")
except UserNotFoundException:
admin = User("false_admin1", "token")
request = {
"source": "source",
"target": "target",
"user": "******",
"for_user": "******",
"email": [True, True, False]
}
json_string = json.dumps(request)
with pytest.raises(PermissionException):
app.create_job(json_string)
def test_get_credentials_by_user():
"""
/SA710/
"""
try:
user = User.get_user_by_username("creduser")
except UserNotFoundException:
user = User("creduser", "token123")
request = {
"username": "******",
}
json_string = json.dumps(request)
response = json.loads(app.get_credentials_by_user(json_string))
assert response["token"] == "token123"
try:
user = User.get_user_by_username("credadmin")
except UserNotFoundException:
user = User("credadmin", "token321")
request = {
"username": "******",
}
json_string = json.dumps(request)
response = json.loads(app.get_credentials_by_user(json_string))
assert response["token"] == "token321"
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 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 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 add_user_to_team(self, for_user, to_manager):
"""
Routes add_user_to_team request to ApplicationFacade of another user (to_manager)
"""
for_user = User.get_user_by_username(for_user)
manager = User.get_user_by_username(to_manager)
# @Todo test inheritance of get_user_by_username
self.access_handler.check_add_user_to_team(for_user, manager)
manager.add_user_to_team(for_user)
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_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_user():
try:
user = User.get_user_by_username("testuser")
except UserNotFoundException:
user = User("testuser", "token")
assert user.get_token() == "token"
assert user.get_username() == "testuser"
assert user.get_user_type() == UserRole.User
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 get_jobs(self, days, user=None, for_user=None, statuses=None):
"""
:raises UserNotFoundException: if given 'user' or 'for_user' doesn't exist
:raises NoProjectManagerRightsException: @see access_handler
"""
calling_user = User.get_user_by_username(user) if user else None
team = True if for_user == "team" else False
for_user = None if for_user in [None, "team"] else User.get_user_by_username(for_user)
if team:
self.access_handler.check_read_rights(None, calling_user)
jobs = Job.get_jobs(calling_user.get_team_members(), statuses, days)
elif for_user is not None and calling_user is not None:
self.access_handler.check_read_rights(for_user, calling_user)
jobs = Job.get_jobs([for_user.get_username()], statuses, days)
else:
jobs = Job.get_jobs(None, statuses)
return build_log(jobs)
def test_inheritance():
try:
user = User.get_user_by_username("testuser5")
except UserNotFoundException:
user = User("testuser5", "token")
user.set_user_type(UserRole.Administrator)
assert user.get_user_type() == UserRole.Administrator
administrator = User.get_user_by_username("testuser5")
assert administrator.get_user_type() == UserRole.Administrator
assert isinstance(administrator, Administrator)
administrator.set_user_type(UserRole.User)
user = User.get_user_by_username("testuser5")
assert user.get_user_type() == UserRole.User
assert not isinstance(user, Administrator)
assert isinstance(user, User)
def set_rights(self, user, role):
"""
Routes set_rights request to ApplicationFacade.
:raises UserNotFoundException: if given 'user' doesn't exist
:raises PermissionException: @see access_handler
"""
for_user = User.get_user_by_username(user)
role = UserRole(role)
self.access_handler.check_set_rights(for_user, role)
for_user.set_user_type(role)
def test_create_job_config_exception():
"""Test for max. allowed number of active jobs per user"""
"""
/SA040/
"""
try:
user = User.get_user_by_username("createjobuser2")
except UserNotFoundException:
user = User("createjobuser2", "token")
request = {
"source": "source",
"target": "target",
"user": "******",
"for_user": "******",
"email": [True, True, True]
}
json_string = json.dumps(request)
try:
job_id = app.create_job(json_string)
job = Job.get_job_by_id(job_id)
job.set_status(JobStatus.QUEUED)
except PermissionException:
pass
try:
job_id = app.create_job(json_string)
job = Job.get_job_by_id(job_id)
job.set_status(JobStatus.QUEUED)
except PermissionException:
pass
try:
job_id = app.create_job(json_string)
job = Job.get_job_by_id(job_id)
job.set_status(JobStatus.QUEUED)
except PermissionException:
pass
try:
job_id = app.create_job(json_string)
job = Job.get_job_by_id(job_id)
job.set_status(JobStatus.QUEUED)
except PermissionException:
pass
try:
job_id = app.create_job(json_string)
job = Job.get_job_by_id(job_id)
job.set_status(JobStatus.QUEUED)
assert 1 == 0
except PermissionException:
assert 1 == 1
def cancel_job(self, job_id, user):
"""
:raises JobNotFoundException: if there is no job with 'job_id'
:raises UserNotFoundException: if 'user' doesn't exist
:raises PermissionException: if 'user' is not permitted to cancel given job
:raises SemanticException: if 'job' is already cancelled or done
"""
job = Job.get_job_by_id(job_id)
calling_user = User.get_user_by_username(user)
self.access_handler.check_cancel_job(job, calling_user)
self.master.cancel_job(job)
def get_job(self, user, job_id):
"""
Routes get_job request to ApplicationFacade
:raises UserNotFoundException: if given 'user' doesn't exist
:raises NoProjectManagerRightsException: @see access_handler
"""
calling_user = User.get_user_by_username(user)
job = Job.get_job_by_id(job_id)
for_user = job.get_user()
self.access_handler.check_read_rights(for_user, calling_user)
return build_job(job)
def get_directory_list(self, storage=None, user=None, for_user=None):
"""
Routes get_directory_list request to ApplicationFacade and builds JSON
:raises UserNotFoundException: if given 'user' or 'for_user' doesn't exist
:raises NoProjectManagerRightsException: @see access_handler
:raises StorageAliasNotFoundException: if 'storage' is not found.
:raises StorageNotMountedException: if a Storage to be worked on is not currently mounted.
:raises NoResponseFromSearchException: if Search is not reachable
"""
calling_user = User.get_user_by_username(user) if user else None
team = True if for_user == "team" else False
for_user = None if for_user in [None, "team"] else User.get_user_by_username(for_user)
if team:
self.access_handler.check_read_rights(None, calling_user)
users = calling_user.get_team_members()
elif self.has_read_permission(calling_user, for_user):
users = [for_user.get_username()] if for_user else None
else:
raise PermissionError("You have no access to this data!")
return search_class.get_directory_list(storage_alias=storage, usernames=users)
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_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_verify_admin():
"""
/SA1120/
"""
try:
user = User.get_user_by_username("verifyuser")
except UserNotFoundException:
user = User("verifyuser", "token2")
request = {"user": "******", "token": "token2"}
json_string = json.dumps(request)
response = json.loads(app.verify_user(json_string))
assert response["role"] == "User"
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 set_in_database(self, table, key, value, identifier, user):
# Strip down value to max 1024, probably should be improved
value = value[:1024]
user = User.get_user_by_username(user)
cls = self.table_to_class[table]
acl = self.cls_to_acl[cls]()
if not key in acl[user.get_user_type()]:
raise PermissionError('Users of type ' + user.get_user_type().name
+ ' are not allowed to set the ' + key + ' attribute in ' +table)
meth = self.cls_to_identifier_method[cls]
obj = meth(identifier)
if not obj: raise AttributeError('No ' + table + ' with identifier ' + identifier + ' was found.')
# Check if this operation, changing a users property (workspace), is authorized
if cls.__name__ == 'Workspaces' and user.name != obj.username and user.get_user_type() != UserRole.Administrator:
raise PermissionError('You are not allowed to modify the workspace ' + obj.full_name)
obj.set_value(key, value)
def test_cancel_job():
try:
johann = User.get_user_by_username('johann')
except UserNotFoundException:
johann = User('johann', 'jtoken')
job = Job('dmd_home', 'dmd1', 'home/centos/testdata/johann-directory-1', [False, False, False], johann)
job_id = job.id
master = Master.get_master()
master.add_to_queue(job)
master.cancel_job(job)
worker = master.get_workers()[0]
assert worker.name == 'worker1'
assert worker.status.name == 'WAITING'
assert Job.get_job_by_id(job_id).status.name == 'CANCELED'
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_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