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): # 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_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 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)