def setUp(self):
super(TestTimeStampTokenVerifyCheck, self).setUp()
self.project = ProjectFactory()
self.node = self.project
self.user = self.project.creator
self.auth_obj = Auth(user=self.project.creator)
userkey_generation(self.user._id)
# Refresh records from database; necessary for comparing dates
self.project.reload()
self.user.reload()
def setUp(self):
super(TestAddTimestamp, self).setUp()
self.project = ProjectFactory()
self.node = self.project
self.user = self.project.creator
self.node_settings = self.project.get_addon('osfstorage')
self.auth_obj = Auth(user=self.project.creator)
userkey_generation(self.user._id)
# Refresh records from database; necessary for comparing dates
self.project.reload()
self.user.reload()
def setUp(self):
super(TestRemoveUserKey, self).setUp()
self.institution = InstitutionFactory()
self.user = AuthUserFactory()
self.request = RequestFactory().get('/fake_path')
self.delete_user = UserFactory()
userkey_generation(self.delete_user._id)
self.delete_user.affiliated_institutions.add(self.institution)
self.delete_user.is_delete = True
self.delete_user.date_disabled = timezone.now()
self.delete_user.save()
self.view = views.RemoveUserKey()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'user_id': self.delete_user.id, 'institution_id': self.institution.id}
def test_add_log_timestamptoken(self, mock_perform):
from osf.models import RdmFileTimestamptokenVerifyResult, NodeLog
from api_tests.utils import create_test_file
from website.views import userkey_generation
result_list1_count = RdmFileTimestamptokenVerifyResult.objects.filter(project_id=self.node._id).count()
nodelog_count1 = NodeLog.objects.all().count()
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
userkey_generation(self.user._id)
file_node = create_test_file(node=self.node, user=self.user, filename=path)
file_node._path = '/' + path
file_node.save()
metadata = {
'path': path,
'provider': 'osfstorage',
'name': path,
'materialized': '/' + path,
'extra': {
'version': 1
}
}
payload = self.build_payload(metadata=metadata)
logging.info('---test_add_log_timestamptoken.payload: {}'.format(payload))
nlogs = self.node.logs.count()
self.app.put_json(url, payload, headers={'Content-Type': 'application/json'})
self.node.reload()
assert_equal(self.node.logs.count(), nlogs + 1)
nodelog_count2 = NodeLog.objects.all().count()
assert_equal(nodelog_count1 + 1, nodelog_count2)
result_list2 = RdmFileTimestamptokenVerifyResult.objects.filter(project_id=self.node._id)
assert_true(mock_perform.called, 'perform not called')
## tearDown
import os
from api.base import settings as api_settings
from osf.models import RdmUserKey
rdmuserkey_pvt_key = RdmUserKey.objects.get(guid=self.user.id, key_kind=api_settings.PRIVATE_KEY_VALUE)
pvt_key_path = os.path.join(api_settings.KEY_SAVE_PATH, rdmuserkey_pvt_key.key_name)
os.remove(pvt_key_path)
rdmuserkey_pvt_key.delete()
rdmuserkey_pub_key = RdmUserKey.objects.get(guid=self.user.id, key_kind=api_settings.PUBLIC_KEY_VALUE)
pub_key_path = os.path.join(api_settings.KEY_SAVE_PATH, rdmuserkey_pub_key.key_name)
os.remove(pub_key_path)
rdmuserkey_pub_key.delete()
def setUp(self):
super(TestTimestampVerifyData, self).setUp()
self.user = AuthUserFactory()
## create project(affiliated institution)
self.project_institution = InstitutionFactory()
self.project_user = UserFactory()
userkey_generation(self.project_user._id)
self.project_user.affiliated_institutions.add(self.project_institution)
self.user = self.project_user
self.private_project1 = ProjectFactory(creator=self.project_user)
self.private_project1.affiliated_institutions.add(
self.project_institution)
self.node = self.private_project1
self.request_url = '/timestampadd/' + str(
self.project_institution.id) + '/nodes/' + str(
self.private_project1.id) + '/verify/verify_data/'
def setUp(self):
super(TestNodeTimeStampPatternChange, self).setUp()
self.user = AuthUserFactory()
## create project(affiliated institution)
self.project_institution = InstitutionFactory()
self.project_user = UserFactory()
userkey_generation(self.project_user._id)
self.project_user.affiliated_institutions.add(self.project_institution)
self.private_project1 = ProjectFactory(creator=self.project_user)
self.private_project1.affiliated_institutions.add(self.project_institution)
RdmTimestampGrantPattern.objects.get_or_create(institution_id=self.project_institution.id, node_guid=self.private_project1._id, timestamp_pattern_division=1)
self.request = RequestFactory().get('/timestampsettings/' + str(self.project_institution.id) + '/')
self.view = views.NodeTimeStampPatternChange()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'institution_id': self.project_institution.id}
def setUp(self):
super(TestAddTimestampData, self).setUp()
self.user = AuthUserFactory()
## create project(affiliated institution)
self.project_institution = InstitutionFactory()
self.project_user = UserFactory()
userkey_generation(self.project_user._id)
self.project_user.affiliated_institutions.add(self.project_institution)
self.user = self.project_user
self.private_project1 = ProjectFactory(creator=self.project_user)
self.private_project1.affiliated_institutions.add(
self.project_institution)
self.node = self.private_project1
self.request_url = '/timestampadd/' + str(
self.project_institution.id) + '/nodes/' + str(
self.private_project1.id) + '/'
self.request = RequestFactory().get(self.request_url)
self.view = views.TimeStampAddList()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs['institution_id'] = self.project_institution.id
self.view.kwargs['guid'] = self.private_project1.id
create_rdmfiletimestamptokenverifyresult(
self,
filename='osfstorage_test_file1.status_1',
provider='osfstorage',
inspection_result_status_1=True)
create_rdmfiletimestamptokenverifyresult(
self,
filename='osfstorage_test_file2.status_3',
provider='osfstorage',
inspection_result_status_1=False)
create_rdmfiletimestamptokenverifyresult(
self,
filename='osfstorage_test_file3.status_3',
provider='osfstorage',
inspection_result_status_1=False)
create_rdmfiletimestamptokenverifyresult(
self,
filename='s3_test_file1.status_3',
provider='s3',
inspection_result_status_1=False)
def setUp(self):
super(TestRemoveUserKeyList, self).setUp()
self.institution = InstitutionFactory()
self.user = AuthUserFactory()
## delete_uusers
self.delete_user1 = UserFactory()
self.delete_user2 = UserFactory()
self.delete_users = [self.delete_user1, self.delete_user2]
for user in self.delete_users:
userkey_generation(user._id)
user.affiliated_institutions.add(self.institution)
user.is_delete = True
user.date_disabled = timezone.now()
user.save()
self.request = RequestFactory().get('/keymanagement/' + str(self.institution.id) + '/')
self.view = views.RemoveUserKeyList()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'institution_id': self.institution.id}
def setUp(self):
super(TestInstitutionNodeList, self).setUp()
self.user = AuthUserFactory()
## create project(affiliated institution)
self.project_institution = InstitutionFactory()
self.project_user = UserFactory()
userkey_generation(self.project_user._id)
self.project_user.affiliated_institutions.add(self.project_institution)
self.private_project1 = ProjectFactory(creator=self.project_user)
self.private_project1.affiliated_institutions.add(
self.project_institution)
self.private_project2 = ProjectFactory(creator=self.project_user)
self.private_project2.affiliated_institutions.add(
self.project_institution)
self.request = RequestFactory().get('/timestampadd/' +
str(self.project_institution.id) +
'/nodes/')
self.view = views.InstitutionNodeList()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'institution_id': self.project_institution.id}
def dispatch(self, request, *args, **kwargs):
eppn = request.environ['HTTP_AUTH_EPPN']
seps = eppn.split(SHIB_EPPN_SCOPING_SEPARATOR)[-1]
institution = Institution.objects.filter(
domains__contains=[str(seps)]).first()
if not institution:
return redirect('auth:login')
if not eppn:
message = 'login failed: permission denied.'
logging.info(message)
messages.error(self.request, message)
return redirect('auth:login')
eppn_user = get_user(eppn=eppn)
if eppn_user:
try:
others = eppn_user.affiliated_institutions.exclude(
id=institution.id).get()
except Institution.DoesNotExist:
pass
else:
eppn_user.affiliated_institutions.remove(others)
eppn_user.affiliated_institutions.add(institution)
if 'GakuninRDMAdmin' in request.environ['HTTP_AUTH_ENTITLEMENT']:
# login success
# code is below this if/else tree
eppn_user.is_staff = True
eppn_user.save()
else:
# login failure occurs and the screen transits to the error screen
# not sure about this code
eppn_user.is_staff = False
eppn_user.save()
message = 'login failed: permission denied.'
logging.info(message)
messages.error(self.request, message)
return redirect('auth:login')
else:
if 'GakuninRDMAdmin' not in request.environ[
'HTTP_AUTH_ENTITLEMENT']:
message = 'login failed: no user with matching eppn'
messages.error(self.request, message)
return redirect('auth:login')
else:
new_user, created = get_or_create_user(
request.environ['HTTP_AUTH_DISPLAYNAME'] or 'NO NAME',
eppn,
reset_password=False)
USE_EPPN = login_by_eppn()
if USE_EPPN:
new_user.eppn = eppn
new_user.have_email = False
else:
new_user.eppn = None
new_user.have_email = True
new_user.is_staff = True
new_user.eppn = eppn
new_user.have_email = False
new_user.save()
new_user.affiliated_institutions.add(institution)
eppn_user = new_user
guid = Guid.objects.get(
object_id=eppn_user.id,
content_type_id=ContentType.objects.get_for_model(OSFUser).id)
if not userkey_generation_check(guid._id):
userkey_generation(guid._id)
login(request,
eppn_user,
backend='api.base.authentication.backends.ODMBackend')
# Transit to the administrator's home screen
return redirect(self.get_success_url())
