def testListRecords(self):
results = self._getProvider().listRecords('rif')
# Iterate through headers
for header, metadata, _ in results:
if header.identifier().startswith('experiment'):
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('title'))\
.to_equal(str(self._experiment.title))
expect(metadata.getField('description'))\
.to_equal(str(self._experiment.description))
expect(metadata.getField('licence_uri'))\
.to_equal(License.get_none_option_license().url)
expect(metadata.getField('licence_name'))\
.to_equal(License.get_none_option_license().name)
else:
expect(header.identifier()).to_contain(str(self._user.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._user.last_login))
expect(metadata.getField('id')).to_equal(self._user.id)
expect(metadata.getField('email'))\
.to_equal(str(self._user.email))
expect(metadata.getField('given_name'))\
.to_equal(str(self._user.first_name))
expect(metadata.getField('family_name'))\
.to_equal(str(self._user.last_name))
# There should only have been one
expect(len(results)).to_equal(2)
# Remove public flag
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('rif')
# Not public, so should not appear
expect(len(headers)).to_equal(0)
def testListRecords(self):
results = self._getProvider().listRecords('rif')
# Iterate through headers
for header, metadata, _ in results:
if header.identifier().startswith('experiment'):
e = self._experiment if header.identifier() == _get_first_exp_id() \
else self._experiment2
self.assertIn(str(e.id), header.identifier())
self.assertEqual(
header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(e.update_time))
self.assertEqual(
metadata.getField('title'), str(e.title))
self.assertEqual(
metadata.getField('description'), str(e.description))
self.assertEqual(
metadata.getField('licence_uri'),
License.get_none_option_license().url)
self.assertEqual(
metadata.getField('licence_name'),
License.get_none_option_license().name)
if e == self._experiment:
ns = 'http://ands.org.au/standards/rif-cs/registryObjects#relatedInfo'
ps_id = ExperimentParameterSet.objects\
.filter(experiment=self._experiment,schema__namespace=ns).first().id
self.assertEqual(
metadata.getField('related_info'),
[{'notes': 'This is a note.', \
'identifier': 'https://www.example.com/', \
'type': 'website', \
'id': ps_id, \
'title': 'Google'}])
else:
self.assertEqual(
metadata.getField('related_info'), [{}])
else:
self.assertIn(str(self._user.id), header.identifier())
self.assertEqual(
header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(self._user.last_login))
self.assertEqual(metadata.getField('id'), self._user.id)
self.assertEqual(
metadata.getField('email'), str(self._user.email))
self.assertEqual(
metadata.getField('given_name'),
str(self._user.first_name))
self.assertEqual(
metadata.getField('family_name'),
str(self._user.last_name))
# There should have been two
self.assertEqual(len(results), 2)
# Remove public flag on first experiment
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('rif')
# Should now be one
self.assertEqual(len(headers), 1)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord(
'rif', _get_first_exp_id())
self.assertIn(str(self._experiment.id), header.identifier())
self.assertEqual(header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(self._experiment.update_time))
ns = 'http://ands.org.au/standards/rif-cs/registryObjects#relatedInfo'
ps_id = ExperimentParameterSet.objects\
.filter(experiment=self._experiment,schema__namespace=ns).first().id
self.assertEqual(metadata.getField('id'), self._experiment.id)
self.assertEqual(metadata.getField('title'),
str(self._experiment.title))
self.assertEqual(metadata.getField('description'),
str(self._experiment.description))
self.assertEqual(metadata.getField('licence_uri'),
License.get_none_option_license().url)
self.assertEqual(metadata.getField('licence_name'),
License.get_none_option_license().name)
self.assertEqual(
list(metadata.getField('related_info')),
[{'notes': 'This is a note.', \
'identifier': 'https://www.example.com/', \
'type': 'website', \
'id': ps_id, \
'title': 'Google'}])
self.assertEqual(len(metadata.getField('collectors')), 2)
self.assertIsNone(about)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord('rif',
_get_first_exp_id())
self.assertIn(str(self._experiment.id), header.identifier())
self.assertEqual(
header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(self._experiment.update_time))
ns = 'http://ands.org.au/standards/rif-cs/registryObjects#relatedInfo'
ps_id = ExperimentParameterSet.objects\
.filter(experiment=self._experiment,schema__namespace=ns).first().id
self.assertEqual(
metadata.getField('id'), self._experiment.id)
self.assertEqual(
metadata.getField('title'), str(self._experiment.title))
self.assertEqual(
metadata.getField('description'),
str(self._experiment.description))
self.assertEqual(
metadata.getField('licence_uri'),
License.get_none_option_license().url)
self.assertEqual(
metadata.getField('licence_name'),
License.get_none_option_license().name)
self.assertEqual(
metadata.getField('related_info'),
[{'notes': 'This is a note.', \
'identifier': 'https://www.example.com/', \
'type': 'website', \
'id': ps_id, \
'title': 'Google'}])
self.assertEqual(
len(metadata.getField('collectors')), 2)
self.assertIsNone(about)
def testListRecords(self):
results = self._getProvider().listRecords('rif')
# Iterate through headers
for header, metadata, _ in results:
if header.identifier().startswith('experiment'):
e = self._experiment if header.identifier() == 'experiment/1' \
else self._experiment2
expect(header.identifier()).to_contain(str(e.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(e.update_time))
expect(metadata.getField('title'))\
.to_equal(str(e.title))
expect(metadata.getField('description'))\
.to_equal(str(e.description))
expect(metadata.getField('licence_uri'))\
.to_equal(License.get_none_option_license().url)
expect(metadata.getField('licence_name'))\
.to_equal(License.get_none_option_license().name)
if e == self._experiment:
expect(metadata.getField('related_info'))\
.to_equal([{'notes': 'This is a note.', \
'identifier': 'https://www.example.com/', \
'type': 'website', \
'id': 1, \
'title': 'Google'}])
else:
expect(metadata.getField('related_info')).to_equal([{}])
else:
expect(header.identifier()).to_contain(str(self._user.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._user.last_login))
expect(metadata.getField('id')).to_equal(self._user.id)
expect(metadata.getField('email'))\
.to_equal(str(self._user.email))
expect(metadata.getField('given_name'))\
.to_equal(str(self._user.first_name))
expect(metadata.getField('family_name'))\
.to_equal(str(self._user.last_name))
# There should have been two
expect(len(results)).to_equal(2)
# Remove public flag on first experiment
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('rif')
# Should now be one
expect(len(headers)).to_equal(1)
def testListRecords(self):
results = self._getProvider().listRecords('rif')
# Iterate through headers
for header, metadata, _ in results:
if header.identifier().startswith('experiment'):
e = self._experiment if header.identifier() == 'experiment/1' \
else self._experiment2
expect(header.identifier()).to_contain(str(e.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(e.update_time))
expect(metadata.getField('title'))\
.to_equal(str(e.title))
expect(metadata.getField('description'))\
.to_equal(str(e.description))
expect(metadata.getField('licence_uri'))\
.to_equal(License.get_none_option_license().url)
expect(metadata.getField('licence_name'))\
.to_equal(License.get_none_option_license().name)
if e == self._experiment:
expect(metadata.getField('related_info'))\
.to_equal([{'notes': 'This is a note.', \
'identifier': 'https://www.example.com/', \
'type': 'website', \
'id': 1, \
'title': 'Google'}])
else:
expect(metadata.getField('related_info')).to_equal([{}])
else:
expect(header.identifier()).to_contain(str(self._user.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._user.last_login))
expect(metadata.getField('id')).to_equal(self._user.id)
expect(metadata.getField('email'))\
.to_equal(str(self._user.email))
expect(metadata.getField('given_name'))\
.to_equal(str(self._user.first_name))
expect(metadata.getField('family_name'))\
.to_equal(str(self._user.last_name))
# There should have been two
expect(len(results)).to_equal(2)
# Remove public flag on first experiment
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('rif')
# Should now be one
expect(len(headers)).to_equal(1)
def experiment_last_updated_badge(experiment):
return render_mustache(
'tardis_portal/badges/last_updated_badge', {
'actual_time':
experiment.update_time.strftime('%a %d %b %Y %H:%M'),
'iso_time': get_local_time(experiment.update_time).isoformat(),
'natural_time': naturalday(experiment.update_time),
})
def _get_in_range(self, from_, until):
from itertools import chain
experiments = Experiment.objects\
.select_related('created_by')\
.exclude(public_access=Experiment.PUBLIC_ACCESS_NONE)\
.exclude(description='')
# Filter based on boundaries provided
if from_:
from_ = get_local_time(from_.replace(tzinfo=pytz.utc)) # UTC->local
experiments = experiments.filter(update_time__gte=from_)
if until:
until = get_local_time(until.replace(tzinfo=pytz.utc)) # UTC->local
experiments = experiments.filter(update_time__lte=until)
def get_users_from_experiment(experiment):
return filter(lambda u: u.userprofile.isValidPublicContact(),
experiment.get_owners())
users = chain(map(get_users_from_experiment, experiments))
return frozenset(chain(experiments, *users))
def _get_in_range(self, from_, until):
from itertools import chain
experiments = Experiment.objects\
.select_related('created_by')\
.exclude(public_access=Experiment.PUBLIC_ACCESS_NONE)\
.exclude(description='')
# Filter based on boundaries provided
if from_:
from_ = get_local_time(from_.replace(tzinfo=pytz.utc)) # UTC->local
experiments = experiments.filter(update_time__gte=from_)
if until:
until = get_local_time(until.replace(tzinfo=pytz.utc)) # UTC->local
experiments = experiments.filter(update_time__lte=until)
def get_users_from_experiment(experiment):
return filter(lambda u: u.get_profile().isValidPublicContact(),
experiment.get_owners())
users = chain(map(get_users_from_experiment, experiments))
return frozenset(chain(experiments, *users))
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord('oai_dc', \
_get_first_exp_id())
self.assertIn(str(self._experiment.id), header.identifier())
self.assertEqual(header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(self._experiment.update_time))
self.assertEqual(metadata.getField('title'),
[str(self._experiment.title)])
self.assertEqual(metadata.getField('description'),
[str(self._experiment.description)])
self.assertIsNone(about)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord('oai_dc', \
'experiment/1')
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('title'))\
.to_equal([str(self._experiment.title)])
expect(metadata.getField('description'))\
.to_equal([str(self._experiment.description)])
expect(about).to_equal(None)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord('oai_dc', \
'experiment/1')
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('title'))\
.to_equal([str(self._experiment.title)])
expect(metadata.getField('description'))\
.to_equal([str(self._experiment.description)])
expect(about).to_equal(None)
def experiment_end_time_badge(experiment):
c = {
'actual_time': experiment.end_time.strftime('%a %d %b %Y %H:%M'),
'iso_time': get_local_time(experiment.end_time).isoformat(),
'natural_time': naturalday(experiment.end_time),
}
# We don't render via Mustache+Pystache - Django templating will do
# return render_mustache('badges/end_time_badge', c)
return loader.render_to_string('badges/end_time_badge.html', c)
def experiment_end_time_badge(experiment):
c = {
'actual_time': experiment.end_time.strftime('%a %d %b %Y %H:%M'),
'iso_time': get_local_time(experiment.end_time).isoformat(),
'natural_time': naturalday(experiment.end_time),
}
# We don't render via Mustache+Pystache - Django templating will do
# return render_mustache('badges/end_time_badge', c)
return loader.render_to_string(
'sequencing_facility/badges/end_time_badge.html', c)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord('oai_dc', \
_get_first_exp_id())
self.assertIn(str(self._experiment.id), header.identifier())
self.assertEqual(
header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(self._experiment.update_time))
self.assertEqual(
metadata.getField('title'), [str(self._experiment.title)])
self.assertEqual(
metadata.getField('description'),
[str(self._experiment.description)])
self.assertIsNone(about)
def testListRecords(self):
results = self._getProvider().listRecords('rif')
# Iterate through headers
for header, metadata, _ in results:
if header.identifier().startswith('experiment'):
expect(header.identifier()).to_contain(str(
self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('title'))\
.to_equal(str(self._experiment.title))
expect(metadata.getField('description'))\
.to_equal(str(self._experiment.description))
expect(metadata.getField('licence_uri'))\
.to_equal(License.get_none_option_license().url)
expect(metadata.getField('licence_name'))\
.to_equal(License.get_none_option_license().name)
else:
expect(header.identifier()).to_contain(str(self._user.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._user.last_login))
expect(metadata.getField('id')).to_equal(self._user.id)
expect(metadata.getField('email'))\
.to_equal(str(self._user.email))
expect(metadata.getField('given_name'))\
.to_equal(str(self._user.first_name))
expect(metadata.getField('family_name'))\
.to_equal(str(self._user.last_name))
# There should only have been one
expect(len(results)).to_equal(2)
# Remove public flag
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('rif')
# Not public, so should not appear
expect(len(headers)).to_equal(0)
def testListIdentifiers(self):
headers = self._getProvider() \
.listIdentifiers(self._getProviderMetadataPrefix())
# Iterate through headers
for header in headers:
if header.identifier().startswith('experiment'):
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
# Remove public flag
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider() \
.listIdentifiers(self._getProviderMetadataPrefix())
# Not public, so should not appear
expect(len(headers)).to_equal(0)
def testListIdentifiers(self):
headers = self._getProvider() \
.listIdentifiers(self._getProviderMetadataPrefix())
# Iterate through headers
for header in headers:
if header.identifier().startswith('experiment'):
expect(header.identifier()).to_contain(str(
self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
# Remove public flag
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider() \
.listIdentifiers(self._getProviderMetadataPrefix())
# Not public, so should not appear
expect(len(headers)).to_equal(0)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord(
'rif', 'experiment/1')
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('id')).to_equal(self._experiment.id)
expect(metadata.getField('title'))\
.to_equal(str(self._experiment.title))
expect(metadata.getField('description'))\
.to_equal(str(self._experiment.description))
expect(metadata.getField('licence_uri'))\
.to_equal(License.get_none_option_license().url)
expect(metadata.getField('licence_name'))\
.to_equal(License.get_none_option_license().name)
expect(metadata.getField('related_info'))\
.to_equal([])
expect(about).to_equal(None)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord('rif',
'experiment/1')
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('id')).to_equal(self._experiment.id)
expect(metadata.getField('title'))\
.to_equal(str(self._experiment.title))
expect(metadata.getField('description'))\
.to_equal(str(self._experiment.description))
expect(metadata.getField('licence_uri'))\
.to_equal(License.get_none_option_license().url)
expect(metadata.getField('licence_name'))\
.to_equal(License.get_none_option_license().name)
expect(metadata.getField('related_info'))\
.to_equal([])
expect(about).to_equal(None)
def testListRecords(self):
results = self._getProvider().listRecords('oai_dc')
# Iterate through headers
for header, metadata, _ in results:
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('title'))\
.to_equal([str(self._experiment.title)])
expect(metadata.getField('description'))\
.to_equal([str(self._experiment.description)])
# There should only have been one
expect(len(results)).to_equal(1)
# Remove public flag
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('oai_dc')
# Not public, so should not appear
expect(len(headers)).to_equal(0)
def testListIdentifiers(self):
headers = self._getProvider() \
.listIdentifiers(self._getProviderMetadataPrefix())
# Iterate through headers
for header in headers:
if not header.identifier().startswith('experiment'):
continue
e = self._experiment if header.identifier() == _get_first_exp_id() \
else self._experiment2
self.assertIn(str(e.id), header.identifier())
self.assertEqual(header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(e.update_time))
# Remove public flag on first experiment
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider() \
.listIdentifiers(self._getProviderMetadataPrefix())
# First is not public, so should not appear
self.assertEqual(len(list(headers)), 1)
def testListRecords(self):
results = self._getProvider().listRecords('oai_dc')
# Iterate through headers
for header, metadata, _ in results:
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('title'))\
.to_equal([str(self._experiment.title)])
expect(metadata.getField('description'))\
.to_equal([str(self._experiment.description)])
# There should only have been one
expect(len(results)).to_equal(1)
# Remove public flag
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('oai_dc')
# Not public, so should not appear
expect(len(headers)).to_equal(0)
def testListIdentifiers(self):
headers = self._getProvider() \
.listIdentifiers(self._getProviderMetadataPrefix())
# Iterate through headers
for header in headers:
if not header.identifier().startswith('experiment'):
continue
e = self._experiment if header.identifier() == _get_first_exp_id() \
else self._experiment2
self.assertIn(str(e.id), header.identifier())
self.assertEquals(
header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(e.update_time))
# Remove public flag on first experiment
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider() \
.listIdentifiers(self._getProviderMetadataPrefix())
# First is not public, so should not appear
self.assertEqual(len(headers), 1)
def testListRecords(self):
results = self._getProvider().listRecords('oai_dc')
# Iterate through headers
for header, metadata, _ in results:
e = self._experiment if header.identifier() == _get_first_exp_id() \
else self._experiment2
self.assertIn(str(e.id), header.identifier())
self.assertEqual(
header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(e.update_time))
self.assertEqual(
metadata.getField('title'), [str(e.title)])
self.assertEqual(
metadata.getField('description'), [str(e.description)])
# There should have been two
self.assertEqual(len(results), 2)
# Remove public flag on first one
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('oai_dc')
# First one not public, so should not appear
self.assertEqual(len(headers), 1)
def testListRecords(self):
results = self._getProvider().listRecords('oai_dc')
# Iterate through headers
result_count = 0
for header, metadata, _ in results:
result_count += 1
e = self._experiment if header.identifier() == _get_first_exp_id() \
else self._experiment2
self.assertIn(str(e.id), header.identifier())
self.assertEqual(header.datestamp().replace(tzinfo=pytz.utc),
get_local_time(e.update_time))
self.assertEqual(metadata.getField('title'), [str(e.title)])
self.assertEqual(metadata.getField('description'),
[str(e.description)])
# There should have been two
self.assertEqual(result_count, 2)
# Remove public flag on first one
self._experiment.public_access = Experiment.PUBLIC_ACCESS_NONE
self._experiment.save()
headers = self._getProvider().listRecords('oai_dc')
# First one not public, so should not appear
self.assertEqual(len(list(headers)), 1)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord(
'rif', 'experiment/1')
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('id')).to_equal(self._experiment.id)
expect(metadata.getField('title'))\
.to_equal(str(self._experiment.title))
expect(metadata.getField('description'))\
.to_equal(str(self._experiment.description))
expect(metadata.getField('licence_uri'))\
.to_equal(License.get_none_option_license().url)
expect(metadata.getField('licence_name'))\
.to_equal(License.get_none_option_license().name)
expect(metadata.getField('related_info'))\
.to_equal([{'notes': 'This is a note.', \
'identifier': 'https://www.example.com/', \
'type': 'website', \
'id': 1, \
'title': 'Google'}])
expect(len(metadata.getField('collectors')))\
.to_equal(2)
expect(about).to_equal(None)
def testGetRecord(self):
header, metadata, about = self._getProvider().getRecord('rif',
'experiment/1')
expect(header.identifier()).to_contain(str(self._experiment.id))
expect(header.datestamp().replace(tzinfo=pytz.utc))\
.to_equal(get_local_time(self._experiment.update_time))
expect(metadata.getField('id')).to_equal(self._experiment.id)
expect(metadata.getField('title'))\
.to_equal(str(self._experiment.title))
expect(metadata.getField('description'))\
.to_equal(str(self._experiment.description))
expect(metadata.getField('licence_uri'))\
.to_equal(License.get_none_option_license().url)
expect(metadata.getField('licence_name'))\
.to_equal(License.get_none_option_license().name)
expect(metadata.getField('related_info'))\
.to_equal([{'notes': 'This is a note.', \
'identifier': 'https://www.example.com/', \
'type': 'website', \
'id': 1, \
'title': 'Google'}])
expect(len(metadata.getField('collectors')))\
.to_equal(2)
expect(about).to_equal(None)
def experiment_last_updated_badge(experiment):
return render_mustache('tardis_portal/badges/last_updated_badge', {
'actual_time': experiment.update_time.strftime('%a %d %b %Y %H:%M'),
'iso_time': get_local_time(experiment.update_time).isoformat(),
'natural_time': naturalday(experiment.update_time),
})
