def _get_experiment(self, entry, user):
experimentId, title, public_access = \
self._get_experiment_details(entry, user)
try:
try:
param_name = ParameterName.objects.\
get(name=self.PARAM_EXPERIMENT_ID, \
schema=AtomImportSchemas.get_schema(Schema.EXPERIMENT))
parameter = ExperimentParameter.objects.\
get(name=param_name, string_value=experimentId)
except ExperimentParameter.DoesNotExist:
raise Experiment.DoesNotExist
return parameter.parameterset.experiment
except Experiment.DoesNotExist:
experiment = Experiment(title=title,
created_by=user,
public_access=public_access)
experiment.save()
self._create_experiment_id_parameter_set(experiment, experimentId)
acl = ExperimentACL(experiment=experiment,
pluginId=django_user,
entityId=user.id,
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED)
acl.save()
return experiment
def _create_experiment(user, bad):
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_METADATA
experiment.save()
experiment.author_experiment_set.create(
order=0, author="John Cleese", url="http://nla.gov.au/nla.party-1")
experiment.author_experiment_set.create(
order=1, author="Michael Palin", url="http://nla.gov.au/nla.party-2")
psm = ParameterSetManager(parentObject=experiment, schema=SCHEMA_URI)
if bad:
params = {
'type': 'website',
'identifier': 'https://www.badexample.com/'
}
else:
params = {
'type': 'website',
'identifier': 'https://www.example.com/',
'title': 'Google',
'notes': 'This is a note.'
}
for k, v in params.items():
psm.set_param(k, v)
return experiment
class MRtaskTestCase(TestCase):
def setUp(self):
from django.contrib.auth.models import User
from tardis.tardis_portal.models import Experiment
from tardis.tardis_portal.models import ExperimentACL
from tardis.tardis_portal.models import Dataset
from tardis.apps.mrtardis.mrtask import MRtask
user = '******'
pwd = 'secret'
email = ''
self.user = User.objects.create_user(user, email, pwd)
self.experiment = Experiment(approved=True,
title="Test Experiment",
institution_name="Test Institution",
created_by=self.user,
public=False)
self.experiment.save()
acl = ExperimentACL(pluginId="django_user",
entityId="1",
experiment=self.experiment,
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True)
acl.save()
self.test_dataset = Dataset(experiment=self.experiment,
description="test dataset")
self.test_dataset.save()
self.test_mrtask = MRtask(dataset=self.test_dataset)
def test_mrtask(self):
self.assertEqual(len(self.test_mrtask.parameters), 0)
def _get_experiment(self, entry, user):
experimentId, title, public_access = \
self._get_experiment_details(entry, user)
try:
try:
param_name = ParameterName.objects.\
get(name=self.PARAM_EXPERIMENT_ID, \
schema=AtomImportSchemas.get_schema(Schema.EXPERIMENT))
parameter = ExperimentParameter.objects.\
get(name=param_name, string_value=experimentId)
except ExperimentParameter.DoesNotExist:
raise Experiment.DoesNotExist
return parameter.parameterset.experiment
except Experiment.DoesNotExist:
experiment = Experiment(title=title,
created_by=user,
public_access=public_access)
experiment.save()
self._create_experiment_id_parameter_set(experiment, experimentId)
acl = ObjectACL(content_object=experiment,
pluginId=django_user,
entityId=user.id,
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
return experiment
def testRightsRequireValidOwner(self):
# Create test owner without enough details
username, email, password = ("testuser", "*****@*****.**", "password")
user = User.objects.create_user(username, email, password)
# Create test experiment and make user the owner of it
experiment = Experiment(title="Text Experiment", institution_name="Test Uni", created_by=user)
experiment.save()
acl = ObjectACL(
pluginId=django_user,
entityId=str(user.id),
content_object=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED,
)
acl.save()
# Create client and login as user
client = Client()
login = client.login(username=username, password=password)
self.assertTrue(login)
# Get "Choose Rights" page, and check that we're forbidden
rights_url = reverse("tardis.tardis_portal.views.choose_rights", args=[str(experiment.id)])
response = client.get(rights_url)
expect(response.status_code).to_equal(403)
# Fill in remaining details
user.first_name = "Voltaire" # Mononymous persons are just fine
user.save()
# Get "Choose Rights" page, and check that we're now allowed access
response = client.get(rights_url)
expect(response.status_code).to_equal(200)
def setUp(self):
# Create test owner without enough details
username, email, password = ("testuser", "*****@*****.**", "password")
user = User.objects.create_user(username, email, password)
# Need UserAuthentication
UserAuthentication(userProfile=user.userprofile, username=username, authenticationMethod="localdb").save()
# Create staging dir
from os import path, makedirs
staging_dir = path.join(settings.STAGING_PATH, username)
if not path.exists(staging_dir):
makedirs(staging_dir)
# Ensure that staging dir is set up properly
expect(get_full_staging_path(username)).to_be_truthy()
# Create test experiment and make user the owner of it
experiment = Experiment(title="Text Experiment", institution_name="Test Uni", created_by=user)
experiment.save()
acl = ObjectACL(
pluginId=django_user,
entityId=str(user.id),
content_object=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED,
)
acl.save()
self.dataset = Dataset(description="dataset description...")
self.dataset.save()
self.dataset.experiments.add(experiment)
self.dataset.save()
self.username, self.password = (username, password)
def setUp(self):
self.client = Client()
# old_user
user_old_username = '******'
# new_user
user_new_username = '******'
pwd = 'secret'
email = '*****@*****.**'
self.user_new = User.objects.create_user(user_new_username, email, pwd)
self.user_old = User.objects.create_user(user_old_username, email, pwd)
# create group
self.group = Group.objects.create(name='test group')
# add old user to group
self.group.user_set.add(self.user_old)
# add user auth
user_auth = UserAuthentication(userProfile=UserProfile.objects.get(user=self.user_old),
username= self.user_old.username,
authenticationMethod='localdb')
user_auth.save()
# add experiments
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=self.user_old)
experiment.save()
acl = ObjectACL(
pluginId='django_user',
entityId=str(self.user_old.id),
content_object=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED,
)
acl.save()
class IntegrityCheckTestCase(TestCase):
def _make_dataset(self, exp, filenames):
dataset = Dataset(experiment=exp)
dataset.save()
for filename in filenames:
df = Dataset_File(dataset=dataset, size=41, protocol='file')
df.filename = filename
df.url = 'file://' + path.join(path.dirname(__file__), 'data', df.filename)
df.save()
def setUp(self):
self.user = User(username='******', password='******', email='*****@*****.**')
self.user.save()
self.bad_exp = Experiment(
approved = True,
title = 'title1',
institution_name = 'institution1',
description = 'description1',
created_by = self.user,
public_access = Experiment.PUBLIC_ACCESS_FULL
)
self.bad_exp.save()
self.bad_dataset = self._make_dataset(self.bad_exp, [
'file_that_exists',
'file_that_exists_too',
'file_that_exists_but_is_empty',
'file_that_doesnt_exist',
])
self.good_exp = Experiment(
approved = True,
title = 'title1',
institution_name = 'institution1',
description = 'description1',
created_by = self.user,
public_access = Experiment.PUBLIC_ACCESS_FULL
)
self.good_exp.save()
self.good_dataset = self._make_dataset(self.good_exp, [
'file_that_exists',
'file_that_exists_too'
])
def testBadExperimentFails(self):
result = IntegrityCheck(self.bad_exp).get_datafiles_integrity()
self.assertEqual(result['files_ok'], 2)
self.assertEqual(result['files_incomplete'], 1)
self.assertEqual(result['files_missing'], 1)
good_or_bad = IntegrityCheck(self.bad_exp).all_files_complete()
self.assertFalse(good_or_bad)
def testGoodExperimentPasses(self):
result = IntegrityCheck(self.good_exp).get_datafiles_integrity()
self.assertEqual(result['files_ok'], 2)
self.assertEqual(result['files_incomplete'], 0)
self.assertEqual(result['files_missing'], 0)
good_or_bad = IntegrityCheck(self.good_exp).all_files_complete()
self.assertTrue(good_or_bad)
def test_authors(self):
exp = Experiment(
title='test exp2',
institution_name='monash',
created_by=self.user,
)
exp.save()
ExperimentAuthor(experiment=exp, author='nigel', order=0).save()
exp = Experiment(
title='test exp1',
institution_name='monash',
created_by=self.user,
)
exp.save()
ae1 = ExperimentAuthor(experiment=exp, author='steve', order=100)
ae1.save()
ae2 = ExperimentAuthor(experiment=exp, author='russell', order=1)
ae2.save()
ae3 = ExperimentAuthor(experiment=exp, author='uli', order=50)
ae3.save()
authors = exp.experimentauthor_set.all()
# confirm that there are 2 authors
self.assertEqual(len(authors), 3)
self.assertTrue(ae1 in authors)
self.assertTrue(ae2 in authors)
self.assertTrue(ae3 == authors[1])
def _create_test_data():
user = User(username='******',
first_name='Thomas',
last_name='Atkins',
email='*****@*****.**')
user.save()
license_ = License(name='Creative Commons Attribution-NoDerivs 2.5 Australia',
url='http://creativecommons.org/licenses/by-nd/2.5/au/',
internal_description='CC BY 2.5 AU',
allows_distribution=True)
license_.save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
experiment.experimentauthor_set.create(order=0,
author="John Cleese",
url="http://nla.gov.au/nla.party-1")
experiment.experimentauthor_set.create(order=1,
author="Michael Palin",
url="http://nla.gov.au/nla.party-2")
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=True,
canRead=True,
canWrite=True,
canDelete=True,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
return user, experiment
def _create_test_data():
user = User(username='******',
first_name='Thomas',
last_name='Atkins',
email='*****@*****.**')
user.save()
user2 = User(username='******', email='*****@*****.**')
user2.save()
map(lambda u: UserProfile(user=u).save(), [user, user2])
license_ = License(name='Creative Commons Attribution-NoDerivs 2.5 Australia',
url='http://creativecommons.org/licenses/by-nd/2.5/au/',
internal_description='CC BY 2.5 AU',
allows_distribution=True)
license_.save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
acl = ExperimentACL(experiment=experiment,
pluginId='django_user',
entityId=str(user2.id),
isOwner=True,
canRead=True,
canWrite=True,
canDelete=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED)
acl.save()
return (user, experiment)
def _create_test_experiment(user, license_):
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
experiment.experimentauthor_set.create(
order=0,
author="John Cleese",
url="http://nla.gov.au/nla.party-1")
experiment.experimentauthor_set.create(
order=1,
author="Michael Palin",
url="http://nla.gov.au/nla.party-2")
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=True,
canRead=True,
canWrite=True,
canDelete=True,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
return experiment
def _create_test_data():
user = User(username='******',
first_name='Thomas',
last_name='Atkins',
email='*****@*****.**')
user.save()
UserProfile(user=user).save()
license_ = License(
name='Creative Commons Attribution-NoDerivs 2.5 Australia',
url='http://creativecommons.org/licenses/by-nd/2.5/au/',
internal_description='CC BY 2.5 AU',
allows_distribution=True)
license_.save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
experiment.author_experiment_set.create(
order=0, author="John Cleese", url="http://nla.gov.au/nla.party-1")
experiment.author_experiment_set.create(
order=1, author="Michael Palin", url="http://nla.gov.au/nla.party-2")
acl = ExperimentACL(experiment=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=True,
canRead=True,
canWrite=True,
canDelete=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED)
acl.save()
return (user, experiment)
def setUp(self):
self.client = Client()
# old_user
user_old_username = '******'
# new_user
user_new_username = '******'
pwd = 'secret'
email = '*****@*****.**'
self.user_new = User.objects.create_user(user_new_username, email, pwd)
self.user_old = User.objects.create_user(user_old_username, email, pwd)
# create group
self.group = Group.objects.create(name='test group')
# add old user to group
self.group.user_set.add(self.user_old)
# add user auth
user_auth = UserAuthentication(userProfile=UserProfile.objects.get(user=self.user_old),
username= self.user_old.username,
authenticationMethod='localdb')
user_auth.save()
# add experiments
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=self.user_old)
experiment.save()
acl = ObjectACL(
pluginId='django_user',
entityId=str(self.user_old.id),
content_object=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED,
)
acl.save()
def setUp(self):
# Create test owner without enough details
username, email, password = ('testuser',
'*****@*****.**',
'password')
user = User.objects.create_user(username, email, password)
profile = UserProfile(user=user, isDjangoAccount=True)
profile.save()
Location.force_initialize()
# Create test experiment and make user the owner of it
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=user)
experiment.save()
acl = ObjectACL(
pluginId='django_user',
entityId=str(user.id),
content_object=experiment,
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
dataset = Dataset(description='dataset description...')
dataset.save()
dataset.experiments.add(experiment)
dataset.save()
def create_datafile(filename):
testfile = path.join(path.dirname(__file__), 'fixtures',
filename)
size, sha512sum = get_size_and_sha512sum(testfile)
datafile = Dataset_File(dataset=dataset,
filename=path.basename(testfile),
size=size,
sha512sum=sha512sum)
datafile.save()
base_url = 'file://' + path.abspath(path.dirname(testfile))
location = Location.load_location({
'name': 'test-grabber', 'url': base_url, 'type': 'external',
'priority': 10, 'transfer_provider': 'local'})
replica = Replica(datafile=datafile,
url='file://'+path.abspath(testfile),
protocol='file',
location=location)
replica.verify()
replica.save()
return Dataset_File.objects.get(pk=datafile.pk)
self.dataset = dataset
self.datafiles = [create_datafile('data_grabber_test1.admin'),
create_datafile('testfile.txt')
]
def createhpcexperiment(request, user, dl):
from django.contrib.auth.models import User
from tardis.tardis_portal.views import _registerExperimentDocument
import os
import tempfile
# TODO
temp = tempfile.TemporaryFile()
for chunk in dl.chunks():
temp.write(chunk)
temp.seek(0)
metadata = {}
for line in temp:
key, value = line.split("~")
metadata[key] = value
temp.close()
author = metadata["Name"]
title = metadata["Experiment"]
ds_desc = metadata["Facility"]
desc = metadata["Description"]
fname = metadata["FolderName"]
counter = metadata["Counter"]
package = metadata["Package"]
exp = Experiment(
title=title, institution_name="RMIT University", description=desc, created_by=User.objects.get(id=user.pk)
)
exp.save()
eid = exp.id
# Store the author for the dataset
ae = models.Author_Experiment(experiment=exp, author=author, order="1")
ae.save()
auth_key = settings.DEFAULT_AUTH
try:
e = Experiment.objects.get(pk=eid)
except Experiment.DoesNotExist:
logger.exception("Experiment for eid %i in CreateHPCExperiment does not exist" % eid)
acl = ExperimentACL(
experiment=e,
pluginId=django_user,
entityId=str(user.id),
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED,
)
acl.save()
folder_desc = "%s.%s.%s.%s" % (ds_desc.strip(), package.strip(), fname.strip(), counter.strip())
logger.debug("folder_desc = %s" % folder_desc)
return eid, exp, folder_desc
def setUp(self):
# Create test owner without enough details
username, email, password = ('testuser', '*****@*****.**',
'password')
user = User.objects.create_user(username, email, password)
profile = UserProfile(user=user, isDjangoAccount=True)
profile.save()
Location.force_initialize()
# Create test experiment and make user the owner of it
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=user)
experiment.save()
acl = ObjectACL(
pluginId='django_user',
entityId=str(user.id),
content_object=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED,
)
acl.save()
dataset = Dataset(description='dataset description...')
dataset.save()
dataset.experiments.add(experiment)
dataset.save()
def create_datafile(index):
testfile = path.join(path.dirname(__file__), 'fixtures',
'jeol_sem_test%d.txt' % index)
size, sha512sum = get_size_and_sha512sum(testfile)
datafile = Dataset_File(dataset=dataset,
filename=path.basename(testfile),
size=size,
sha512sum=sha512sum)
datafile.save()
base_url = 'file://' + path.abspath(path.dirname(testfile))
location = Location.load_location({
'name': 'test-jeol',
'url': base_url,
'type': 'external',
'priority': 10,
'transfer_provider': 'local'
})
replica = Replica(datafile=datafile,
url='file://' + path.abspath(testfile),
protocol='file',
location=location)
replica.verify()
replica.save()
return Dataset_File.objects.get(pk=datafile.pk)
self.dataset = dataset
self.datafiles = [create_datafile(i) for i in (1, 2)]
class IntegrityCheckTestCase(TestCase):
def _make_dataset(self, exp, filenames):
dataset = Dataset()
dataset.save()
dataset.experiments.add(exp)
dataset.save()
for filename in filenames:
df = Dataset_File(dataset=dataset, size=41, protocol='file')
df.filename = filename
df.url = 'file://' + path.join(path.dirname(__file__), 'data',
df.filename)
df.save()
def setUp(self):
self.user = User(username='******',
password='******',
email='*****@*****.**')
self.user.save()
self.bad_exp = Experiment(approved=True,
title='title1',
institution_name='institution1',
description='description1',
created_by=self.user,
public_access=Experiment.PUBLIC_ACCESS_FULL)
self.bad_exp.save()
self.bad_dataset = self._make_dataset(self.bad_exp, [
'file_that_exists',
'file_that_exists_too',
'file_that_exists_but_is_empty',
'file_that_doesnt_exist',
])
self.good_exp = Experiment(approved=True,
title='title1',
institution_name='institution1',
description='description1',
created_by=self.user,
public_access=Experiment.PUBLIC_ACCESS_FULL)
self.good_exp.save()
self.good_dataset = self._make_dataset(
self.good_exp, ['file_that_exists', 'file_that_exists_too'])
def testBadExperimentFails(self):
result = IntegrityCheck(self.bad_exp).get_datafiles_integrity()
self.assertEqual(result['files_ok'], 2)
self.assertEqual(result['files_incomplete'], 1)
self.assertEqual(result['files_missing'], 1)
good_or_bad = IntegrityCheck(self.bad_exp).all_files_complete()
self.assertFalse(good_or_bad)
def testGoodExperimentPasses(self):
result = IntegrityCheck(self.good_exp).get_datafiles_integrity()
self.assertEqual(result['files_ok'], 2)
self.assertEqual(result['files_incomplete'], 0)
self.assertEqual(result['files_missing'], 0)
good_or_bad = IntegrityCheck(self.good_exp).all_files_complete()
self.assertTrue(good_or_bad)
def _create_test_data():
"""
Create Single experiment with two owners
"""
user1 = User(username='******',
first_name='Thomas',
last_name='Atkins',
email='*****@*****.**')
user1.save()
UserProfile(user=user1).save()
user2 = User(username='******',
first_name='Joe',
last_name='Bloggs',
email='*****@*****.**')
user2.save()
UserProfile(user=user2).save()
license_ = License(name='Creative Commons Attribution-NoDerivs '
+ '2.5 Australia',
url='http://creativecommons.org/licenses/by-nd/2.5/au/',
internal_description='CC BY 2.5 AU',
allows_distribution=True)
license_.save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user1)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
experiment.author_experiment_set.create(order=0,
author="John Cleese",
url="http://nla.gov.au/nla.party-1")
experiment.author_experiment_set.create(order=1,
author="Michael Palin",
url="http://nla.gov.au/nla.party-2")
acl1 = ExperimentACL(experiment=experiment,
pluginId='django_user',
entityId=str(user1.id),
isOwner=True,
canRead=True,
canWrite=True,
canDelete=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED)
acl1.save()
acl2 = ExperimentACL(experiment=experiment,
pluginId='django_user',
entityId=str(user2.id),
isOwner=True,
canRead=True,
canWrite=True,
canDelete=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED)
acl2.save()
return (user1, user2, experiment)
class TarDownloadTestCase(TestCase):
def setUp(self):
# create user
self.testuser = User(username="******")
self.testuser.save()
# create test experiment
self.exp = Experiment(
title="tar download test" * 15, created_by=self.testuser, public_access=Experiment.PUBLIC_ACCESS_FULL
)
self.exp.save()
# create test dataset
self.ds = self.exp.datasets.create(description="testing tar download dataset")
datafile_content = "\n".join(["some data %d" % i for i in range(1000)])
filesize = len(datafile_content)
md5sum = hashlib.md5(datafile_content).hexdigest()
# create test datafiles and datafile objects
self.dfs = []
for i in range(20):
df = self.ds.datafile_set.create(
filename="testfile%d.txt" % i,
mimetype="text/plain",
size=filesize,
md5sum=md5sum,
directory="/".join(["testdir%d" % i for i in range(i, i + 4)]),
)
df.file_object = StringIO(datafile_content)
df.refresh_from_db()
self.dfs.append(df)
# mock client
self.client = Client()
def tearDown(self):
# delete created objects and files
[ds.delete() for ds in self.exp.datasets.all()]
self.exp.delete()
def test_tar_experiment_download(self):
self.assertTrue(all(df.verified for df in self.dfs))
response = self.client.get(
reverse("tardis.tardis_portal.download.streaming_download_experiment", args=(self.exp.id, "tar"))
)
with NamedTemporaryFile("w") as tarfile:
for c in response.streaming_content:
tarfile.write(c)
tarfile.flush()
self.assertEqual(int(response["Content-Length"]), os.stat(tarfile.name).st_size)
tf = TarFile(tarfile.name)
for df in self.dfs:
full_path = os.path.join(
self.exp.title.replace(" ", "_"), self.ds.description, df.directory, df.filename
)
tf.extract(full_path, "/tmp")
self.assertEqual(os.stat(os.path.join("/tmp", full_path)).st_size, int(df.size))
def testNeverExpire(self):
experiment = Experiment(created_by=self.user, end_time=dt.datetime(1999,4,3))
experiment.save()
eh = EmbargoHandler(experiment.id, True)
self.assertFalse(eh.never_expires())
eh.prevent_expiry()
self.assertTrue(eh.never_expires())
self.assertFalse(eh.because_no_end_date())
def create_draft_publication(user, publication_title, publication_description):
# Note: Maybe this logic can be taken from the tardis_portal/views.py?
experiment = Experiment(created_by=user,
title=publication_title,
description=publication_description)
experiment.save()
ObjectACL(content_object=experiment,
pluginId=django_user,
entityId=str(user.id),
canRead=True,
canWrite=False,
canDelete=False,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED).save()
ObjectACL(content_object=experiment,
pluginId=django_group,
entityId=str(
Group.objects.get_or_create(
name=getattr(
settings, 'PUBLICATION_OWNER_GROUP',
default_settings.PUBLICATION_OWNER_GROUP))[0].id),
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED).save()
publication_schema = Schema.objects.get(
namespace=getattr(settings, 'PUBLICATION_SCHEMA_ROOT',
default_settings.PUBLICATION_SCHEMA_ROOT))
# Attach draft schema
draft_publication_schema = Schema.objects.get(
namespace=getattr(settings, 'PUBLICATION_DRAFT_SCHEMA',
default_settings.PUBLICATION_DRAFT_SCHEMA))
ExperimentParameterSet(schema=draft_publication_schema,
experiment=experiment).save()
# Attach root schema and blank form_state parameter
publication_root_schema = Schema.objects.get(
namespace=getattr(settings, 'PUBLICATION_SCHEMA_ROOT',
default_settings.PUBLICATION_SCHEMA_ROOT))
publication_root_parameter_set = ExperimentParameterSet(
schema=publication_schema,
experiment=experiment)
publication_root_parameter_set.save()
form_state_param_name = ParameterName.objects.get(
schema=publication_root_schema, name='form_state')
ExperimentParameter(name=form_state_param_name,
parameterset=publication_root_parameter_set).save()
return experiment
def setUp(self):
raise SkipTest # temporarily disabling this feature, needs coding
from tempfile import mkdtemp, mktemp
from django.conf import settings
import os
# Disconnect post_save signal
from django.db.models.signals import post_save
from tardis.tardis_portal.models import Experiment, \
staging_hook, Dataset, DataFile, DataFileObject, StorageBox
post_save.disconnect(staging_hook, sender=DataFileObject)
from django.contrib.auth.models import User
user = '******'
pwd = 'secret'
email = ''
self.user = User.objects.create_user(user, email, pwd)
try:
os.makedirs(settings.GET_FULL_STAGING_PATH_TEST)
except OSError:
pass
self.temp = mkdtemp(dir=settings.GET_FULL_STAGING_PATH_TEST)
self.filepath = mktemp(dir=self.temp)
content = 'test file'
with open(self.filepath, "w+b") as f:
f.write(content)
# make datafile
exp = Experiment(title='test exp1',
institution_name='monash',
created_by=self.user)
exp.save()
# make dataset
dataset = Dataset(description="dataset description...")
dataset.save()
dataset.experiments.add(exp)
dataset.save()
# create datafile
df = DataFile(dataset=dataset, size=len(content),
filename=path.basename(self.file),
md5sum='f20d9f2072bbeb6691c0f9c5099b01f3')
df.save()
# create replica
base_url = settings.GET_FULL_STAGING_PATH_TEST
s_box = StorageBox.get_default_storage(location=base_url)
dfo = DataFileObject(datafile=df,
uri=self.filepath,
storage_box=s_box)
dfo.save()
self.dfo = dfo
def create_draft_publication(user, publication_title, publication_description):
# Note: Maybe this logic can be taken from the tardis_portal/views.py?
experiment = Experiment(created_by=user,
title=publication_title,
description=publication_description)
experiment.save()
ObjectACL(content_object=experiment,
pluginId=django_user,
entityId=str(user.id),
canRead=True,
canWrite=False,
canDelete=False,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED).save()
ObjectACL(content_object=experiment,
pluginId=django_group,
entityId=str(
Group.objects.get_or_create(
name=getattr(
settings, 'PUBLICATION_OWNER_GROUP',
default_settings.PUBLICATION_OWNER_GROUP))[0].id),
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED).save()
publication_schema = Schema.objects.get(
namespace=getattr(settings, 'PUBLICATION_SCHEMA_ROOT',
default_settings.PUBLICATION_SCHEMA_ROOT))
# Attach draft schema
draft_publication_schema = Schema.objects.get(
namespace=getattr(settings, 'PUBLICATION_DRAFT_SCHEMA',
default_settings.PUBLICATION_DRAFT_SCHEMA))
ExperimentParameterSet(schema=draft_publication_schema,
experiment=experiment).save()
# Attach root schema and blank form_state parameter
publication_root_schema = Schema.objects.get(
namespace=getattr(settings, 'PUBLICATION_SCHEMA_ROOT',
default_settings.PUBLICATION_SCHEMA_ROOT))
publication_root_parameter_set = ExperimentParameterSet(
schema=publication_schema,
experiment=experiment)
publication_root_parameter_set.save()
form_state_param_name = ParameterName.objects.get(
schema=publication_root_schema, name='form_state')
ExperimentParameter(name=form_state_param_name,
parameterset=publication_root_parameter_set).save()
return experiment
def _create_test_data():
user = User(username='******',
first_name="Voltaire",
email='*****@*****.**')
user.save()
UserProfile(user=user).save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_METADATA
experiment.save()
return (experiment, user)
def setUp(self):
# Create test owner without enough details
username, email, password = ('testuser',
'*****@*****.**',
'password')
user = User.objects.create_user(username, email, password)
# Create test experiment and make user the owner of it
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=user)
experiment.save()
acl = ObjectACL(
pluginId='django_user',
entityId=str(user.id),
content_object=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED,
)
acl.save()
dataset = Dataset(description='dataset description...')
dataset.save()
dataset.experiments.add(experiment)
dataset.save()
base_path = path.join(path.dirname(__file__), 'fixtures')
s_box = StorageBox.get_default_storage(location=base_path)
def create_datafile(index):
testfile = path.join(base_path, 'middleware_test%d.txt' % index)
size, sha512sum = get_size_and_sha512sum(testfile)
datafile = DataFile(dataset=dataset,
filename=path.basename(testfile),
size=size,
sha512sum=sha512sum)
datafile.save()
dfo = DataFileObject(
datafile=datafile,
storage_box=s_box,
uri=path.basename(testfile))
dfo.save()
if index != 1:
dfo.verified = False
dfo.save(update_fields=['verified'])
return DataFile.objects.get(pk=datafile.pk)
self.dataset = dataset
self.datafiles = [create_datafile(i) for i in (1, 2)]
def _create_test_data():
user = User(username='******',
first_name="Voltaire",
email='*****@*****.**')
user.save()
UserProfile(user=user).save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_METADATA
experiment.save()
return (experiment, user)
def setUp(self):
self.ns = {
'r': 'http://ands.org.au/standards/rif-cs/registryObjects',
'o': 'http://www.openarchives.org/OAI/2.0/'
}
user, client = _create_user_and_login()
license_ = License(
name='Creative Commons Attribution-NoDerivs 2.5 Australia',
url='http://creativecommons.org/licenses/by-nd/2.5/au/',
internal_description='CC BY 2.5 AU',
allows_distribution=True)
license_.save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=False,
canRead=True,
canWrite=True,
canDelete=False,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
params = {
'code': '010107',
'name':
'Mathematical Logic, Set Theory, Lattices and Universal Algebra',
'uri': 'http://purl.org/asc/1297.0/2008/for/010107'
}
try:
response = client.post(\
reverse('tardis.apps.anzsrc_codes.views.'\
+'list_or_create_for_code',
args=[experiment.id]),
data=json.dumps(params),
content_type='application/json')
except: # no internet most likely
from nose.plugins.skip import SkipTest
raise SkipTest
# Check related info was created
expect(response.status_code).to_equal(201)
self.acl = acl
self.client = client
self.experiment = experiment
self.params = params
def setUp(self):
# Load schemas for test
from django.core.management import call_command
call_command('loaddata', 'as_schemas')
self.client = Client()
self.experiments = []
try:
user = User.objects.get(username='******')
except User.DoesNotExist:
user = User.objects.create_user('test', '', 'test')
user.save()
self.userprofile = user.userprofile
# base_path = path.abspath(path.dirname(__file__))
experiment = Experiment(title='SAXS Test',
created_by=user)
experiment.save()
acl = ObjectACL(pluginId=django_user,
entityId=str(user.id),
content_object=experiment,
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True)
acl.save()
self.experiments += [experiment]
schema = Schema.objects.get(type=Schema.DATAFILE, subtype='saxs')
parameter = ParameterName.objects.get(schema=schema, name='io')
parameter.is_searchable = True
parameter.save()
self.io_param_name = parameter.getUniqueShortName()
schema = Schema.objects.get(type=Schema.DATASET, subtype='saxs')
parameter = ParameterName.objects.get(schema=schema, name='frqimn')
parameter.is_searchable = True
parameter.save()
self.frqimn_param_name = parameter.getUniqueShortName()
new_schema = Schema()
new_schema.namespace = 'testschemawithduplicatename'
new_schema.save()
new_param = ParameterName(
schema=new_schema,
name='title',
full_name='Duplicate title parametername',
is_searchable=True)
new_param.save()
def create_experiment(i):
experiment = Experiment(title="Text Experiment #%d" % i, institution_name="Test Uni", created_by=user)
experiment.save()
acl = ObjectACL(
pluginId=django_user,
entityId=str(user.id),
content_object=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED,
)
acl.save()
return experiment
def testCleanExperiment(self):
experiment = Experiment(created_by=self.user)
experiment.save()
eh = EmbargoHandler(experiment.id)
self.assertTrue(eh.never_expires())
self.assertFalse(eh.has_any_expiry())
self.assertFalse(eh.can_be_defaulted())
self.assertTrue(eh.because_no_end_date())
self.assertEqual(None, eh.get_expiry_date())
self.assertRaises(Exception, eh.prevent_expiry)
eh.reset_to_default() # should not raise Exception
self.assertRaises(Exception, eh.set_expiry)
class ANDSDOITestCase(TestCase):
def setUp(self):
self.user = User.objects.create_user("test", "", "test")
self.expt = Experiment(title="test exp1", institution_name="monash", created_by=self.user)
self.schema, _ = Schema.objects.get_or_create(namespace=settings.DOI_NAMESPACE)
self.doi_name, _ = ParameterName.objects.get_or_create(schema=self.schema, full_name="DOI", name="doi")
self.expt.save()
def test_init(self):
doi_service = DOIService(self.expt)
def test_get_doi_none(self):
doi_service = DOIService(self.expt)
self.assertEquals(None, doi_service.get_doi())
def _get_experiment(self, entry, user):
'''
Finds the Experiment corresponding to this entry.
If it doesn't exist, a new Experiment is created and given
an appropriate ACL for the user.
'''
experimentId, title, public_access = self._get_experiment_details(entry, user)
if (experimentId, title) == (None, None):
return None
if experimentId:
try:
# Try and match ExperimentID if we have one.
param_name = ParameterName.objects.\
get(name=IngestOptions.PARAM_EXPERIMENT_ID, \
schema=AtomImportSchemas.get_schema(Schema.EXPERIMENT))
parameter = ExperimentParameter.objects.\
get(name=param_name, string_value=experimentId)
return parameter.parameterset.experiment
except ExperimentParameter.DoesNotExist:
pass
# Failing that, match ExperimentTitle if possible
if title:
try:
experiment = Experiment.objects.get(title=title, created_by=user)
return experiment
except Experiment.DoesNotExist:
pass
# No existing expriment - shall we create a new one?
if not IngestOptions.ALLOW_EXPERIMENT_CREATION:
logging.getLogger(__name__).info("Skipping dataset. ALLOW_EXPERIMENT_CREATION disabled, so ignoring (experimentId: {0}, title: {1}, user: {2})".format(
experimentId, title, user))
return None
experiment = Experiment(title=title, created_by=user, public_access=public_access)
experiment.save()
self._create_experiment_id_parameter_set(experiment, experimentId)
logging.getLogger(__name__).info("Created experiment {0} (title: {1}, user: {2}, experimentId: {3})".format(
experiment.id, experiment.title, experiment.created_by, experimentId))
acl = ExperimentACL(experiment=experiment,
pluginId=django_user,
entityId=user.id,
canRead=True,
canWrite=True,
canDelete=True,
isOwner=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED)
acl.save()
return experiment
def setUp(self):
self.ns = {
'r': 'http://ands.org.au/standards/rif-cs/registryObjects',
'o': 'http://www.openarchives.org/OAI/2.0/'
}
user, client = _create_user_and_login()
license_ = License(name='Creative Commons Attribution-NoDerivs '
'2.5 Australia',
url='http://creativecommons.org/licenses/by-nd/'
'2.5/au/',
internal_description='CC BY 2.5 AU',
allows_distribution=True)
license_.save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=False,
canRead=True,
canWrite=True,
canDelete=False,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
params = {
'type': 'website',
'identifier': 'https://www.google.com/',
'title': 'Google',
'notes': 'This is a note.'
}
response = client.post(\
reverse('tardis.apps.related_info.views.' +
'list_or_create_related_info',
args=[experiment.id]),
data=json.dumps(params),
content_type='application/json')
# Check related info was created
self.assertEqual(response.status_code, 201)
self.acl = acl
self.client = client
self.experiment = experiment
self.params = params
def create_experiment(i):
experiment = Experiment(title='Text Experiment #%d' % i,
institution_name='Test Uni',
created_by=user)
experiment.save()
acl = ExperimentACL(
pluginId=django_user,
entityId=str(user.id),
experiment=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED,
)
acl.save()
return experiment
def testResetToDefault(self):
expiry = dt.datetime(2034,12,4)
expiry_as_string = '2034/12/04'
experiment = Experiment(created_by=self.user)
experiment.save()
eh = EmbargoHandler(experiment.id, True)
eh.set_expiry(expiry_as_string)
self.assertEqual(expiry, eh.get_expiry_date())
eh = EmbargoHandler(experiment.id, True)
eh.reset_to_default()
self.assertEqual(None, eh.get_expiry_date())
def testCleanExperimentWithEndDate(self):
experiment = Experiment(created_by=self.user, end_time=dt.datetime(2011, 12, 31))
experiment.save()
expected_expiry = experiment.end_time + dt.timedelta(settings.EMBARGO_DAYS)
eh = EmbargoHandler(experiment.id)
self.assertFalse(eh.never_expires())
self.assertTrue(eh.has_any_expiry())
self.assertFalse(eh.can_be_defaulted())
self.assertFalse(eh.because_no_end_date())
self.assertEqual(expected_expiry, eh.get_expiry_date())
self.assertRaises(Exception, eh.prevent_expiry)
eh.reset_to_default() # should not raise Exception
self.assertRaises(Exception, eh.set_expiry)
def testSetExpiry(self):
expiry = dt.datetime(2034, 12, 4)
expiry_as_string = '2034/12/04'
experiment = Experiment(created_by=self.user)
experiment.save()
eh = EmbargoHandler(experiment.id)
self.assertTrue(eh.never_expires())
self.assertEqual(None, eh.get_expiry_date())
eh = EmbargoHandler(experiment.id, True)
eh.set_expiry(expiry_as_string)
eh = EmbargoHandler(experiment.id)
self.assertEqual(expiry, eh.get_expiry_date())
def setUp(self):
# Create test owner without enough details
username, email, password = ('testuser',
'*****@*****.**',
'password')
user = User.objects.create_user(username, email, password)
profile = UserProfile(user=user, isDjangoAccount=True)
profile.save()
# Create test experiment and make user the owner of it
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=user)
experiment.save()
acl = ExperimentACL(
pluginId='django_user',
entityId=str(user.id),
experiment=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED,
)
acl.save()
dataset = Dataset(description='dataset description...')
dataset.save()
dataset.experiments.add(experiment)
dataset.save()
def create_datafile(index):
testfile = path.join(path.dirname(__file__), 'fixtures',
'jeol_sem_test%d.txt' % index)
size, sha512sum = get_size_and_sha512sum(testfile)
datafile = Dataset_File(dataset=dataset,
filename=path.basename(testfile),
url='file://'+path.abspath(testfile),
protocol='file',
size=size,
sha512sum=sha512sum)
datafile.verify()
datafile.save()
return datafile
self.dataset = dataset
self.datafiles = [create_datafile(i) for i in (1,2)]
def setUp(self):
self.ns = {'r': 'http://ands.org.au/standards/rif-cs/registryObjects',
'o': 'http://www.openarchives.org/OAI/2.0/'}
user, client = _create_user_and_login()
license_ = License(name='Creative Commons Attribution-NoDerivs 2.5 Australia',
url='http://creativecommons.org/licenses/by-nd/2.5/au/',
internal_description='CC BY 2.5 AU',
allows_distribution=True)
license_.save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=False,
canRead=True,
canWrite=True,
canDelete=False,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
params = {'code': '010107',
'name': 'Mathematical Logic, Set Theory, Lattices and Universal Algebra',
'uri': 'http://purl.org/asc/1297.0/2008/for/010107'}
try:
response = client.post(\
reverse('tardis.apps.anzsrc_codes.views.'\
+'list_or_create_for_code',
args=[experiment.id]),
data=json.dumps(params),
content_type='application/json')
except: # no internet most likely
from nose.plugins.skip import SkipTest
raise SkipTest
# Check related info was created
expect(response.status_code).to_equal(201)
self.acl = acl
self.client = client
self.experiment = experiment
self.params = params
def setUp(self):
self.ns = {'r': 'http://ands.org.au/standards/rif-cs/registryObjects',
'o': 'http://www.openarchives.org/OAI/2.0/'}
user, client = _create_user_and_login()
license_ = License(name='Creative Commons Attribution-NoDerivs '
'2.5 Australia',
url='http://creativecommons.org/licenses/by-nd/'
'2.5/au/',
internal_description='CC BY 2.5 AU',
allows_distribution=True)
license_.save()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=False,
canRead=True,
canWrite=True,
canDelete=False,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
params = {'type': 'website',
'identifier': 'https://www.google.com/',
'title': 'Google',
'notes': 'This is a note.'}
response = client.post(\
reverse('tardis.apps.related_info.views.' +
'list_or_create_related_info',
args=[experiment.id]),
data=json.dumps(params),
content_type='application/json')
# Check related info was created
self.assertEqual(response.status_code, 201)
self.acl = acl
self.client = client
self.experiment = experiment
self.params = params
def setUp(self):
# Create test owner without enough details
username, email, password = ('testuser',
'*****@*****.**',
'password')
user = User.objects.create_user(username, email, password)
profile = UserProfile(user=user, isDjangoAccount=True)
profile.save()
# Need UserAuthentication
UserAuthentication(userProfile=profile,
username=username,
authenticationMethod='localdb').save()
# Create staging dir
from os import path, makedirs
staging_dir = path.join(settings.STAGING_PATH, username)
if not path.exists(staging_dir):
makedirs(staging_dir)
# Ensure that staging dir is set up properly
expect(get_full_staging_path(username)).to_be_truthy()
Location.force_initialize()
# Create test experiment and make user the owner of it
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=user)
experiment.save()
acl = ExperimentACL(
pluginId=django_user,
entityId=str(user.id),
experiment=experiment,\
canRead=True,
isOwner=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED,
)
acl.save()
self.dataset = \
Dataset(description='dataset description...')
self.dataset.save()
self.dataset.experiments.add(experiment)
self.dataset.save()
self.username, self.password = (username, password)
def test_experiment(self):
exp = Experiment(title='test exp1',
institution_name='monash',
created_by=self.user)
exp.save()
self.assertEqual(exp.title, 'test exp1')
self.assertEqual(exp.url, None)
self.assertEqual(exp.institution_name, 'monash')
self.assertEqual(exp.approved, False)
self.assertEqual(exp.handle, None)
self.assertEqual(exp.created_by, self.user)
self.assertEqual(exp.public_access, Experiment.PUBLIC_ACCESS_NONE)
target_id = Experiment.objects.first().id
self.assertEqual(
exp.get_absolute_url(), '/experiment/view/%d/' % target_id,
exp.get_absolute_url() + ' != /experiment/view/%d/' % target_id)
self.assertEqual(exp.get_or_create_directory(),
os.path.join(settings.FILE_STORE_PATH, str(exp.id)))
def generate_experiment(datasets=[], users=[]):
from tardis.tardis_portal.models import Experiment, ObjectACL
experiment = Experiment(created_by=users[0])
experiment.save()
for ds in datasets:
ds.experiments.add(experiment)
ds.save()
for user in users:
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=True,
canRead=True,
canWrite=True,
canDelete=True,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
return experiment
class ANDSDOITestCase(TestCase):
def setUp(self):
self.user = User.objects.create_user('test', '', 'test')
self.expt = Experiment(title='test exp1',
institution_name='monash',
created_by=self.user,
)
self.schema, _ = Schema.objects.get_or_create(namespace=settings.DOI_NAMESPACE)
self.doi_name, _ = ParameterName.objects.get_or_create(schema=self.schema, full_name='DOI', name='doi')
self.expt.save()
def test_init(self):
doi_service = DOIService(self.expt)
def test_get_doi_none(self):
doi_service = DOIService(self.expt)
self.assertEquals(None, doi_service.get_doi())
def setUp(self):
user, client = _create_user_and_login()
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.save()
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=False,
canRead=True,
canWrite=False,
canDelete=False,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
self.client = client
self.experiment = experiment
class ModelsTestCase(TestCase):
def setUp(self):
self.user = User(username='******',
password='******',
email='*****@*****.**')
self.user.save()
self.exp = Experiment(approved=True,
title='title1',
institution_name='institution1',
description='description1',
created_by=self.user,
public_access=Experiment.PUBLIC_ACCESS_FULL)
self.exp.save()
self.uid = 0
self.url = 'http://remotetardis:8080'
def testGetEmptyStatus(self):
exp = SyncedExperiment(experiment=self.exp,
uid=self.uid,
provider_url=self.url)
exp.save()
d = exp.status()
self.assertEqual(d, None)
def testGetStatus(self):
json_str = '{"key": "value"}'
exp = SyncedExperiment(experiment=self.exp,
uid=self.uid,
provider_url=self.url)
exp.msg = json_str
exp.save()
d = exp.status()
self.assertIsInstance(d, dict)
self.assertEqual(d['key'], 'value')
def testSetStatus(self):
d = {"key": "value"}
exp = SyncedExperiment(experiment=self.exp,
uid=self.uid,
provider_url=self.url)
exp.save()
exp.save_status(d)
json_d = json.loads(exp.msg)
self.assertEqual(d, json_d)
def setUp(self):
# Create test owner without enough details
username, email, password = ('testuser', '*****@*****.**',
'password')
user = User.objects.create_user(username, email, password)
profile = UserProfile(user=user, isDjangoAccount=True)
profile.save()
# Need UserAuthentication
UserAuthentication(userProfile=profile,
username=username,
authenticationMethod='localdb').save()
# Create staging dir
from os import path, makedirs
staging_dir = path.join(settings.STAGING_PATH, username)
if not path.exists(staging_dir):
makedirs(staging_dir)
# Ensure that staging dir is set up properly
expect(get_full_staging_path(username)).to_be_truthy()
Location.force_initialize()
# Create test experiment and make user the owner of it
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=user)
experiment.save()
acl = ObjectACL(
pluginId=django_user,
entityId=str(user.id),
content_object=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ObjectACL.OWNER_OWNED,
)
acl.save()
self.dataset = \
Dataset(description='dataset description...')
self.dataset.save()
self.dataset.experiments.add(experiment)
self.dataset.save()
self.username, self.password = (username, password)
def testRightsRequireValidOwner(self):
# Create test owner without enough details
username, email, password = ('testuser', '*****@*****.**',
'password')
user = User.objects.create_user(username, email, password)
profile = UserProfile(user=user, isDjangoAccount=True)
profile.save()
# Create test experiment and make user the owner of it
experiment = Experiment(title='Text Experiment',
institution_name='Test Uni',
created_by=user)
experiment.save()
acl = ExperimentACL(
pluginId=django_user,
entityId=str(user.id),
experiment=experiment,
canRead=True,
isOwner=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED,
)
acl.save()
# Create client and login as user
client = Client()
login = client.login(username=username, password=password)
self.assertTrue(login)
# Get "Choose Rights" page, and check that we're forbidden
rights_url = reverse('tardis.tardis_portal.views.choose_rights',
args=[str(experiment.id)])
response = client.get(rights_url)
expect(response.status_code).to_equal(403)
# Fill in remaining details
user.first_name = "Voltaire" # Mononymous persons are just fine
user.save()
# Get "Choose Rights" page, and check that we're now allowed access
response = client.get(rights_url)
expect(response.status_code).to_equal(200)
class ManagerTestCase(TestCase):
def setUp(self):
self.user = User(username='******',
password='******',
email='*****@*****.**')
self.user.save()
self.exp = Experiment(approved=True,
title='title1',
institution_name='institution1',
description='description1',
created_by=self.user,
public_access=Experiment.PUBLIC_ACCESS_FULL)
self.exp.save()
self.sync_exp = SyncedExperiment(experiment=self.exp,
uid='test.1',
provider_url='http://somewhere.com')
self.sync_exp.save()
self.site_manager = flexmock()
flexmock(SiteManager).new_instances(self.site_manager)
self.Http = flexmock()
flexmock(Http).new_instances(self.Http)
def _create_test_experiment(user, license_):
experiment = Experiment(title='Norwegian Blue',
description='Parrot + 40kV',
created_by=user)
experiment.public_access = Experiment.PUBLIC_ACCESS_FULL
experiment.license = license_
experiment.save()
experiment.author_experiment_set.create(
order=0, author="John Cleese", url="http://nla.gov.au/nla.party-1")
experiment.author_experiment_set.create(
order=1, author="Michael Palin", url="http://nla.gov.au/nla.party-2")
acl = ObjectACL(content_object=experiment,
pluginId='django_user',
entityId=str(user.id),
isOwner=True,
canRead=True,
canWrite=True,
canDelete=True,
aclOwnershipType=ObjectACL.OWNER_OWNED)
acl.save()
return experiment
class NotifyTestCase(TestCase):
def setUp(self):
self.user = User(username='******',
password='******',
email='*****@*****.**')
self.user.save()
self.exp = Experiment(approved=True,
title='title1',
institution_name='institution1',
description='description1',
created_by=self.user,
public_access=Experiment.PUBLIC_ACCESS_FULL)
self.exp.save()
self.synced_exp = SyncedExperiment(uid='tardis.1',
experiment=self.exp,
provider_url='url')
self.synced_exp.msg = '{"message": "You broke everything!"}'
self.synced_exp.save()
def testGetEmailTextFail(self):
(subject, msg) = notify._get_email_text(self.synced_exp, success=False)
self._assertEmailContentsCorrect(subject, msg)
def _assertEmailContentsCorrect(self, subject, msg):
print subject
print msg
self.assertTrue('\n' not in subject)
self.assertTrue('failed' in subject.lower())
self.assertTrue('tardis.1' in msg)
self.assertTrue('broke' in msg)
def testEmailAdmins(self):
mail.outbox = []
notify.email_admins(self.synced_exp, success=False)
self.assertEqual(len(mail.outbox), 1)
email = mail.outbox[0]
self._assertEmailContentsCorrect(email.subject, email.body)
self.assertEqual(email.from_email, settings.SERVER_EMAIL)
def test_dataset(self):
exp = Experiment(title='test exp1',
institution_name='monash',
created_by=self.user)
exp.save()
exp2 = Experiment(title='test exp2',
institution_name='monash',
created_by=self.user)
exp2.save()
group = Group(name="Test Manager Group")
group.save()
group.user_set.add(self.user)
facility = Facility(name="Test Facility", manager_group=group)
facility.save()
instrument = Instrument(name="Test Instrument", facility=facility)
instrument.save()
dataset = Dataset(description='test dataset1')
dataset.instrument = instrument
dataset.save()
dataset.experiments.set([exp, exp2])
dataset.save()
dataset_id = dataset.id
del dataset
dataset = Dataset.objects.get(pk=dataset_id)
self.assertEqual(dataset.description, 'test dataset1')
self.assertEqual(dataset.experiments.count(), 2)
self.assertIn(exp, list(dataset.experiments.iterator()))
self.assertIn(exp2, list(dataset.experiments.iterator()))
self.assertEqual(instrument, dataset.instrument)
target_id = Dataset.objects.first().id
self.assertEqual(
dataset.get_absolute_url(), '/dataset/%d' % target_id,
dataset.get_absolute_url() + ' != /dataset/%d' % target_id)
class UploadTestCase(TestCase):
def setUp(self):
from os import path, mkdir
from tempfile import mkdtemp
user = '******'
pwd = 'secret'
email = ''
self.user = User.objects.create_user(user, email, pwd)
self.userProfile = UserProfile(user=self.user)
self.test_dir = mkdtemp()
self.exp = Experiment(title='test exp1',
institution_name='monash',
created_by=self.user)
self.exp.save()
acl = ExperimentACL(
pluginId=django_user,
entityId=str(self.user.id),
experiment=self.exp,
canRead=True,
isOwner=True,
aclOwnershipType=ExperimentACL.OWNER_OWNED,
)
acl.save()
self.dataset = \
Dataset(description='dataset description...',
experiment=self.exp)
self.dataset.save()
self.experiment_path = path.join(settings.FILE_STORE_PATH,
str(self.dataset.experiment.id))
self.dataset_path = path.join(self.experiment_path,
str(self.dataset.id))
if not path.exists(self.experiment_path):
mkdir(self.experiment_path)
if not path.exists(self.dataset_path):
mkdir(self.dataset_path)
# write test file
self.filename = 'testfile.txt'
self.f1 = open(path.join(self.test_dir, self.filename), 'w')
self.f1.write('Test file 1')
self.f1.close()
self.f1_size = path.getsize(path.join(self.test_dir, self.filename))
self.f1 = open(path.join(self.test_dir, self.filename), 'r')
def tearDown(self):
from shutil import rmtree
self.f1.close()
rmtree(self.test_dir)
rmtree(self.dataset_path)
rmtree(self.experiment_path)
self.exp.delete()
def testFileUpload(self):
from os import path
c = Client()
c.login(username='******', password='******')
session_id = c.session.session_key
response = c.post('/upload/' + str(self.dataset.id) + '/', {
'Filedata': self.f1,
'session_id': session_id
})
test_files_db = \
Dataset_File.objects.filter(dataset__id=self.dataset.id)
self.assertTrue(
path.exists(path.join(self.dataset_path, self.filename)))
self.assertTrue(self.dataset.id == 1)
self.assertTrue(test_files_db[0].url == 'tardis://testfile.txt')
def testUploadComplete(self):
from django.http import QueryDict, HttpRequest
from tardis.tardis_portal.views import upload_complete
data = [('filesUploaded', '1'), ('speed', 'really fast!'),
('allBytesLoaded', '2'), ('errorCount', '0')]
post = QueryDict('&'.join(['%s=%s' % (k, v) for (k, v) in data]))
request = HttpRequest()
request.POST = post
response = upload_complete(request)
self.assertTrue('<p>Number: 1</p>' in response.content)
self.assertTrue('<p>Errors: 0</p>' in response.content)
self.assertTrue('<p>Bytes: 2</p>' in response.content)
self.assertTrue('<p>Speed: really fast!</p>' in response.content)
class MyTardisHSMUtilsTestCase(TestCase):
"""Test cases for the MyTardisHSM utils module"""
def setUp(self):
"""Setup test fixtures if needed."""
self.user = User.objects.create_user("doctor", '', "pwd")
self.exp = Experiment(title="Wonderful",
institution_name="Monash University",
created_by=self.user)
self.exp.save()
group = Group(name="Group1")
group.save()
facility = Facility(name="Test Facility", manager_group=group)
facility.save()
inst = Instrument(name="Test Instrument1", facility=facility)
inst.save()
self.dataset = Dataset(description="Dataset1", instrument=inst)
self.dataset.save()
storage_classes = getattr(settings, "HSM_STORAGE_CLASSES",
DEFAULT_HSM_CLASSES)
self.sbox1 = StorageBox(name="SBOX1",
django_storage_class=storage_classes[0],
status='online',
max_size=256)
self.sbox1.save()
sbox1_attr = StorageBoxAttribute(storage_box=self.sbox1,
key='type',
value=StorageBox.DISK)
sbox1_attr.save()
sbox1_loc_opt = StorageBoxOption(storage_box=self.sbox1,
key="location",
value="/dummy/path")
sbox1_loc_opt.save()
self.sbox2 = StorageBox(
name="SBOX2",
django_storage_class="any.non.disk.StorageSystem",
status='offline',
max_size=256)
self.sbox2.save()
sbox2_attr = StorageBoxAttribute(storage_box=self.sbox2,
key='type',
value=StorageBox.TAPE)
sbox2_attr.save()
self.df1 = DataFile(dataset=self.dataset, filename="test_df.jpg")
self.df1.save()
self.dfo1 = DataFileObject(datafile=self.df1,
storage_box=self.sbox1,
uri="stream/test.jpg")
self.dfo1.save()
def tearDown(self):
"""Remove stuff"""
def test_000_lock_datafile(self):
"""We should be able to lock a datafile to prevent concurrent access"""
with DatafileLock(self.df1, "dummy_oid1") as lock1:
if lock1:
with DatafileLock(self.df1, "dummy_oid2") as lock2:
self.assertTrue(lock1)
self.assertFalse(lock2)
def test_001_datafile_lock_expiry(self):
"""A datafile lock should not release until the expiry has been
reached"""
with DatafileLock(self.df1, "dummy_oid1", expires=2) as lock1:
self.assertTrue(lock1)
# If we retry lock right away, lock acquisition should fail because
# expiry hasn't been reached
with DatafileLock(self.df1, "dummy_oid1_1") as lock1:
self.assertFalse(lock1)
# wait 2s for lock to release
time.sleep(2)
# If we retry acquiring the lock now it should succeed
with DatafileLock(self.df1, "dummy_oid1_2") as lock1:
self.assertTrue(lock1)
class DownloadTestCase(TestCase):
def setUp(self):
# create a test user
self.user = User.objects.create_user(username='******',
email='',
password='******')
# create a public experiment
self.experiment1 = Experiment(
title='Experiment 1',
created_by=self.user,
public_access=Experiment.PUBLIC_ACCESS_FULL)
self.experiment1.save()
# create a non-public experiment
self.experiment2 = Experiment(
title='Experiment 2',
created_by=self.user,
public_access=Experiment.PUBLIC_ACCESS_NONE)
self.experiment2.save()
# dataset1 belongs to experiment1
self.dataset1 = Dataset(description='dangerous;name')
self.dataset1.save()
self.dataset1.experiments.add(self.experiment1)
self.dataset1.save()
# dataset2 belongs to experiment2
self.dataset2 = Dataset(description='terrible\nname')
self.dataset2.save()
self.dataset2.experiments.add(self.experiment2)
self.dataset2.save()
# absolute path first
filename1 = 'testfile.txt'
filename2 = 'testfile.tiff'
self.dest1 = abspath(
join(settings.FILE_STORE_PATH,
'%s/%s/' % (self.experiment1.id, self.dataset1.id)))
self.dest2 = abspath(
join(settings.FILE_STORE_PATH,
'%s/%s/' % (self.experiment2.id, self.dataset2.id)))
if not exists(self.dest1):
makedirs(self.dest1)
if not exists(self.dest2):
makedirs(self.dest2)
testfile1 = abspath(join(self.dest1, filename1))
f = open(testfile1, 'w')
f.write("Hello World!\n")
f.close()
testfile2 = abspath(join(self.dest2, filename2))
_generate_test_image(testfile2)
self.datafile1 = self._build_datafile(testfile1, filename1,
self.dataset1)
self.datafile2 = self._build_datafile(testfile2, filename2,
self.dataset2)
def _build_datafile(self,
testfile,
filename,
dataset,
checksum=None,
size=None,
mimetype=''):
filesize, sha512sum = get_size_and_sha512sum(testfile)
datafile = DataFile(dataset=dataset,
filename=filename,
mimetype=mimetype,
size=size if size is not None else filesize,
sha512sum=(checksum if checksum else sha512sum))
datafile.save()
dfo = DataFileObject(datafile=datafile,
storage_box=datafile.get_default_storage_box())
dfo.save()
with open(testfile, 'r') as sourcefile:
dfo.file_object = sourcefile
return DataFile.objects.get(pk=datafile.pk)
def tearDown(self):
self.user.delete()
self.experiment1.delete()
self.experiment2.delete()
rmtree(self.dest1)
rmtree(self.dest2)
def testView(self):
client = Client()
# check view of file1
response = client.get('/datafile/view/%i/' % self.datafile1.id)
self.assertEqual(response['Content-Disposition'],
'inline; filename="%s"' % self.datafile1.filename)
self.assertEqual(response.status_code, 200)
response_content = ""
for c in response.streaming_content:
response_content += c
self.assertEqual(response_content, 'Hello World!\n')
# check view of file2
response = client.get('/datafile/view/%i/' % self.datafile2.id)
# Should be forbidden
self.assertEqual(response.status_code, 403)
self.experiment2.public_access = Experiment.PUBLIC_ACCESS_FULL
self.experiment2.save()
# check view of file2 again
response = client.get('/datafile/view/%i/' % self.datafile2.id)
self.assertEqual(response.status_code, 200)
# The following behaviour relies on ImageMagick
if IMAGEMAGICK_AVAILABLE:
# file2 should have a ".png" filename
self.assertEqual(
response['Content-Disposition'],
'inline; filename="%s"' % (self.datafile2.filename + '.png'))
# file2 should be a PNG
self.assertEqual(response['Content-Type'], 'image/png')
png_signature = "\x89PNG\r\n\x1a\n"
self.assertEqual(response.content[0:8], png_signature)
else:
# file2 should have a ".tiff" filename
self.assertEqual(
response['Content-Disposition'],
'inline; filename="%s"' % (self.datafile2.filename))
# file2 should be a TIFF
self.assertEqual(response['Content-Type'], 'image/tiff')
tiff_signature = "II\x2a\x00"
self.assertEqual(response.content[0:4], tiff_signature)
def _check_tar_file(self,
content,
rootdir,
datafiles,
simpleNames=False,
noTxt=False):
with NamedTemporaryFile('w') as tempfile:
for c in content:
tempfile.write(c)
tempfile.flush()
if getsize(tempfile.name) > 0:
expect(is_tarfile(tempfile.name)).to_be_truthy()
try:
tf = TarFile(tempfile.name, 'r')
self._check_names(datafiles, tf.getnames(), rootdir,
simpleNames, noTxt)
finally:
tf.close()
else:
self._check_names(datafiles, [], rootdir, simpleNames, noTxt)
def _check_zip_file(self,
content,
rootdir,
datafiles,
simpleNames=False,
noTxt=False):
with NamedTemporaryFile('w') as tempfile:
for c in content:
tempfile.write(c)
tempfile.flush()
# It should be a zip file
expect(is_zipfile(tempfile.name)).to_be_truthy()
try:
zf = ZipFile(tempfile.name, 'r')
self._check_names(datafiles, zf.namelist(), rootdir,
simpleNames, noTxt)
finally:
zf.close()
def _check_names(self, datafiles, names, rootdir, simpleNames, noTxt):
# SimpleNames says if we expect basenames or pathnames
# NoTxt says if we expect '.txt' files to be filtered out
for name in names:
self.assertNotRegexpMatches(name, '\n|;')
expect(len(names)).to_equal(len(datafiles))
def testDownload(self):
client = Client()
# check download for experiment1 as tar
response = client.get('/download/experiment/%i/tar/' %
self.experiment1.id)
self.assertEqual(
response['Content-Disposition'],
'attachment; filename="%s-complete.tar"' %
self.experiment1.title.replace(' ', '_'))
self.assertEqual(response.status_code, 200)
self._check_tar_file(
response.streaming_content,
str(self.experiment1.title.replace(' ', '_')),
reduce(lambda x, y: x + y, [
ds.datafile_set.all()
for ds in self.experiment1.datasets.all()
]))
# check download of file1
response = client.get('/download/datafile/%i/' % self.datafile1.id)
self.assertEqual(response['Content-Disposition'],
'attachment; filename="%s"' % self.datafile1.filename)
self.assertEqual(response.status_code, 200)
response_content = ""
for c in response.streaming_content:
response_content += c
self.assertEqual(response_content, 'Hello World!\n')
# requesting file2 should be forbidden...
response = client.get('/download/datafile/%i/' % self.datafile2.id)
self.assertEqual(response.status_code, 403)
# check dataset1 download as tar
response = client.post(
'/download/datafiles/', {
'expid': self.experiment1.id,
'dataset': [self.dataset1.id],
'datafile': [],
'comptype': 'tar'
})
self.assertEqual(response.status_code, 200)
self._check_tar_file(response.streaming_content,
'Experiment 1-selection',
self.dataset1.datafile_set.all())
# check dataset2 download
response = client.post(
'/download/datafiles/', {
'expid': self.experiment2.id,
'dataset': [self.dataset2.id],
'datafile': []
})
self.assertEqual(response.status_code, 403)
# check datafile1 download via POST
response = client.post(
'/download/datafiles/', {
'expid': self.experiment1.id,
'dataset': [],
'datafile': [self.datafile1.id]
})
self.assertEqual(response.status_code, 200)
self._check_tar_file(response.streaming_content,
'Experiment 1-selection', [self.datafile1])
# check datafile2 download via POST
response = client.post(
'/download/datafiles/', {
'expid': self.experiment2.id,
'dataset': [],
'datafile': [self.datafile2.id]
})
self.assertEqual(response.status_code, 403)
# Check datafile2 download with second experiment to "metadata only"
self.experiment2.public_access = Experiment.PUBLIC_ACCESS_METADATA
self.experiment2.save()
response = client.get('/download/datafile/%i/' % self.datafile2.id)
# Metadata-only means "no file access"!
self.assertEqual(response.status_code, 403)
# Check datafile2 download with second experiment to public
self.experiment2.public_access = Experiment.PUBLIC_ACCESS_FULL
self.experiment2.save()
response = client.get('/download/datafile/%i/' % self.datafile2.id)
self.assertEqual(response.status_code, 200)
# This should be a TIFF (which often starts with "II\x2a\x00")
self.assertEqual(response['Content-Type'], 'image/tiff')
response_content = ""
for c in response.streaming_content:
response_content += c
self.assertEqual(response_content[0:4], "II\x2a\x00")
# check experiment tar download with alternative organization
response = client.get('/download/experiment/%i/tar/' %
self.experiment1.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response['Content-Disposition'],
'attachment; filename="%s-complete.tar"' %
self.experiment1.title.replace(' ', '_'))
self._check_tar_file(response.streaming_content,
str(self.experiment1.id),
reduce(lambda x, y: x + y, [
ds.datafile_set.all()
for ds in self.experiment1.datasets.all()
]),
simpleNames=True)
# check experiment1 download with '.txt' filtered out (none left)
response = client.get('/download/experiment/%i/tar/' %
self.experiment1.id)
self.assertEqual(response.status_code, 200)
# check experiment2 download with '.txt' filtered out
response = client.get('/download/experiment/%i/tar/' %
self.experiment2.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(
response['Content-Disposition'],
'attachment; filename="%s-complete.tar"' %
self.experiment2.title.replace(' ', '_'))
self._check_tar_file(response.streaming_content,
str(self.experiment2.id),
reduce(lambda x, y: x + y, [
ds.datafile_set.all()
for ds in self.experiment2.datasets.all()
]),
simpleNames=True,
noTxt=True)
def testDatasetFile(self):
# check registered text file for physical file meta information
df = DataFile.objects.get(pk=self.datafile1.id) # skipping test # noqa # pylint: disable=W0101
try:
from magic import Magic
self.assertEqual(df.mimetype, 'text/plain; charset=us-ascii')
except:
# XXX Test disabled because lib magic can't be loaded
pass
self.assertEqual(df.size, 13)
self.assertEqual(df.md5sum, '8ddd8be4b179a529afa5f2ffae4b9858')
# Now check we can calculate checksums and infer the mime type
# for a JPG file.
filename = 'tardis/tardis_portal/tests/test_data/ands-logo-hi-res.jpg'
dataset = Dataset.objects.get(pk=self.dataset1.id)
pdf1 = self._build_datafile(filename, basename(filename), dataset)
self.assertEqual(pdf1.file_objects.get().verify(), True)
pdf1 = DataFile.objects.get(pk=pdf1.pk)
try:
from magic import Magic # noqa
self.assertEqual(pdf1.mimetype, 'image/jpeg')
except:
# XXX Test disabled because lib magic can't be loaded
pass
self.assertEqual(pdf1.size, 14232)
self.assertEqual(pdf1.md5sum, 'c450d5126ffe3d14643815204daf1bfb')
# Now check that we can override the physical file meta information
# We are setting size/checksums that don't match the actual file, so
# the
pdf2 = self._build_datafile(
filename,
filename,
dataset,
checksum=
'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e',
size=0,
mimetype=
'application/vnd.openxmlformats-officedocument.presentationml.presentation'
) # noqa
self.assertEqual(pdf2.size, 0)
self.assertEqual(pdf2.md5sum, '')
self.assertEqual(pdf2.file_objects.get().verified, False)
pdf2 = DataFile.objects.get(pk=pdf2.pk)
try:
from magic import Magic # noqa
self.assertEqual(
pdf2.mimetype,
'application/vnd.openxmlformats-officedocument.presentationml.presentation'
) # noqa
except:
# XXX Test disabled because lib magic can't be loaded
pass
self.assertEqual(pdf2.size, 0)
self.assertEqual(pdf2.md5sum, '')
pdf2.mimetype = ''
pdf2.save()
pdf2.file_objects.get().save()
pdf2 = DataFile.objects.get(pk=pdf2.pk)
try:
from magic import Magic # noqa
self.assertEqual(pdf2.mimetype, 'application/pdf')
except:
# XXX Test disabled because lib magic can't be loaded
pass
class TokenTestCase(TestCase):
urls = 'tardis.tardis_portal.tests.urls'
def setUp(self):
from django.contrib.auth.models import User
from tardis.tardis_portal.models import Experiment
user = '******'
pwd = 'secret'
email = ''
self.user = User.objects.create_user(user, email, pwd)
self.experiment = Experiment(created_by=self.user)
self.experiment.save()
sys.modules['datetime'].datetime = FrozenTime
def tearDown(self):
sys.modules['datetime'].datetime = old_datetime
# expiry should default to today plus TOKEN_EXPIRY_DAYS
def test_default_expiry(self):
the_time = old_datetime(2011, 9, 20, 1, 52, 31, 570376)
FrozenTime.freeze_time(the_time)
expected_expiry = the_time.date() + \
datetime.timedelta(settings.TOKEN_EXPIRY_DAYS)
t = Token()
self.assertEqual(expected_expiry, t.expiry_date)
# token is valid up to and including day of expiry
def test_is_expired(self):
now = old_datetime(2011, 8, 20, 0, 0, 0, 1)
FrozenTime.freeze_time(now)
today = now.date()
yesterday = today - datetime.timedelta(1)
tomorrow = today + datetime.timedelta(1)
t = Token()
t.expiry_date = yesterday
self.assertTrue(t.is_expired())
t.expiry_date = today
self.assertFalse(t.is_expired())
t.expiry_date = tomorrow
self.assertFalse(t.is_expired())
def test_get_session_expiry(self):
three_am = old_datetime(2011, 8, 20, 3)
now = three_am
FrozenTime.freeze_time(now)
tomorrow_4am = old_datetime(2011, 8, 21, 4)
t = Token()
expected_expiry = tomorrow_4am
self.assertEqual(expected_expiry.year, t.get_session_expiry().year)
self.assertEqual(expected_expiry.month, t.get_session_expiry().month)
self.assertEqual(expected_expiry.day, t.get_session_expiry().day)
self.assertEqual(expected_expiry.hour, t.get_session_expiry().hour)
def test_get_session_expiry_near_expiry(self):
now = old_datetime(2011, 8, 20, 3)
FrozenTime.freeze_time(now)
t = Token()
t.expiry_date = now.date()
expected_expiry = old_datetime(2011, 8, 20, 23, 59, 59)
actual_expiry = t.get_session_expiry()
print actual_expiry
self.assertEqual(expected_expiry.year, actual_expiry.year)
self.assertEqual(expected_expiry.month, actual_expiry.month)
self.assertEqual(expected_expiry.day, actual_expiry.day)
self.assertEqual(expected_expiry.hour, actual_expiry.hour)
def test_get_session_expiry_expired_token(self):
now = old_datetime(2011, 8, 20, 13)
FrozenTime.freeze_time(now)
yesterday = (now - datetime.timedelta(1)).date()
t = Token()
t.expiry_date = yesterday
self.assertEqual(now.year, t.get_session_expiry().year)
self.assertEqual(now.month, t.get_session_expiry().month)
self.assertEqual(now.day, t.get_session_expiry().day)
self.assertEqual(now.hour, t.get_session_expiry().hour)
# check that we don't loop indefinitely when success is impossible
# check no token is assigned
def test_save_with_random_token_failures(self):
from django.core.exceptions import ObjectDoesNotExist
t = Token()
self.assertRaises(ObjectDoesNotExist, t.save_with_random_token)
self.assertEqual('', t.token)
t = Token(user=self.user)
self.assertRaises(ObjectDoesNotExist, t.save_with_random_token)
self.assertEqual('', t.token)
t = Token(experiment=self.experiment)
self.assertRaises(ObjectDoesNotExist, t.save_with_random_token)
self.assertEqual('', t.token)
# check that failure happens eventually
def test_save_with_random_token_gives_up(self):
from django.db import IntegrityError
t = Token(user=self.user, experiment=self.experiment)
t.save = _raise_integrity_error
self.assertRaises(IntegrityError, t.save_with_random_token)
# should have tried to assign at least one token
self.assertTrue(len(t.token) > 0)
def test_save_with_random_token(self):
t = Token(user=self.user, experiment=self.experiment)
t.save_with_random_token()
self.assertTrue(len(t.token) > 0)
