def test_proxy_url(self):
no_signals()
c = Client()
response = c.post('/media/proxy/create/')
# Response is JSON, should always be 200
self.assertEqual(200, response.status_code)
# Result should be error since we did not provide any credentials
data = json.loads(response.content)
self.assertEqual('error', data['result'])
login = c.login(username='******', password='******')
self.assertTrue(login)
TrustedSubnet.objects.create(subnet='127.0.0.1')
response = c.post('/media/proxy/create/',
{'url': self.record.get_thumbnail_url(), 'context': '_1_2'},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(200, response.status_code)
data = json.loads(response.content)
self.assertEqual('ok', data['result'])
id = data['id']
c.logout()
# try to retrieve content
url = '/media/proxy/%s/' % id
response = c.get(url, {'context': '_1_2'})
self.assertEqual(200, response.status_code)
self.assertEqual('image/jpeg', response['content-type'])
# make sure image dimension restrictions took effect
image = Image.open(StringIO(response.content))
width, height = image.size
self.assertEqual(50, width)
def testRecordNameFromEquivIdentifier(self):
no_signals()
record = Record.objects.create()
rid = record.id
self.assertTrue(record.id)
fv = FieldValue.objects.create(field=self.idfield,
record=record,
value='Identifier 407')
record = Record.objects.get(id=rid)
self.assertEqual('identifier-407', record.name)
# setting field value again should not change name
fv.save()
record = Record.objects.get(id=rid)
self.assertEqual('identifier-407', record.name)
# make sure setting another field value does not change the id
FieldValue.objects.create(field=standardfield('title'),
record=record,
value='Some title')
record = Record.objects.get(id=rid)
self.assertEqual('identifier-407', record.name)
def test_derivative_permissions(self):
no_signals()
Media.objects.filter(record=self.record).delete()
media = Media.objects.create(record=self.record, name='tiff', mimetype='image/tiff', storage=self.storage)
with open(os.path.join(os.path.dirname(__file__), 'test_data', 'dcmetro.tif'), 'rb') as f:
media.save_file('dcmetro.tif', f)
user1 = User.objects.create(username='******')
user2 = User.objects.create(username='******')
AccessControl.objects.create(content_object=self.collection, user=user1, read=True)
AccessControl.objects.create(content_object=self.collection, user=user2, read=True)
AccessControl.objects.create(content_object=self.storage, user=user1, read=True)
AccessControl.objects.create(content_object=self.storage, user=user2, read=True,
restrictions=dict(width=200, height=200))
result1 = get_image_for_record(self.record, width=400, height=400, user=user1)
result2 = get_image_for_record(self.record, width=400, height=400, user=user2)
self.assertEqual(400, Image.open(result1).size[0])
self.assertEqual(200, Image.open(result2).size[0])
result3 = get_image_for_record(self.record, width=400, height=400, user=user2)
self.assertEqual(result2, result3)
media.delete()
def test_get_files(self):
no_signals()
files = sorted(self.storage.get_files())
self.assertEqual(3, len(files))
self.assertEqual('id_1.txt', files[0])
self.assertEqual('id_2.txt', files[1])
self.assertEqual(os.path.join('sub', 'id_99.txt'), files[2])
def create_record(self, id):
no_signals()
record = Record.objects.create(name='id')
CollectionItem.objects.create(collection=self.collection, record=record)
FieldValue.objects.create(record=record, field=standardfield('identifier'), value=id)
self.records.append(record)
return record
def tearDown(self):
no_signals()
for record in self.records:
record.delete()
self.storage.delete()
self.collection.delete()
shutil.rmtree(self.tempdir, ignore_errors=True)
def test_pseudostreaming(self):
no_signals()
print '\nStorage : %s \nsystem: %s \nurlbase: %s' % (self.storage.title, self.storage.system, self.storage.urlbase)
TEST_STRING = 'Hello world'
content = StringIO(TEST_STRING)
print 'content - %s' % content.getvalue()
pseudofile = File(content)
self.media.save_file('testpsuedostream.txt', pseudofile)
# try:
# print 'saving file to '
# self.media.save_file('testpsuedostream.txt', content)
#
# print "\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n ____ self.media.get_absolute_url(): " \
# "%s" % self.media.get_absolute_url()
# except Exception as e:
# print e
# print 'ok, try sending a file instead?'
# # psf = open('content_file', 'w')
# # psf.write(TEST_STRING)
# #pseudofile = open(content, 'r')
# pseudofile = File(content)
# self.media.save_file('testpsuedostream.txt', pseudofile)
# pass
if self.media.file_exists():
c = Client()
response = c.get(self.media.get_absolute_url())
f = open(self.media.get_absolute_file_path(), 'r')
print 'test file:'
print f
self.assertEqual(TEST_STRING, response.content)
else:
raise AssertionError
def tearDown(self):
no_signals()
self.record.delete()
self.storage.delete()
self.collection.delete()
self.proxytest_user.delete()
shutil.rmtree(self.tempdir, ignore_errors=True)
def testPresentationContext(self):
no_signals()
record = Record.objects.create()
owned_collection = Collection.objects.create(title='Owned collection', owner=self.user)
v1 = record.fieldvalue_set.create(field=self.titleField, value='v')
v2 = record.fieldvalue_set.create(field=self.titleField, value='v-u1', owner=self.user)
v3 = record.fieldvalue_set.create(field=self.titleField, value='v-u2', owner=self.user2)
v4 = record.fieldvalue_set.create(field=self.titleField, value='v-u3', owner=self.user3)
v5 = record.fieldvalue_set.create(field=self.titleField, value='v-u1-ctx', owner=self.user,
context=owned_collection)
values = record.get_fieldvalues(owner=self.user2, context=owned_collection)
expected = ['v', 'v-u2']
for v in values:
self.assertTrue(v.value in expected)
expected.remove(v.value)
self.assertEqual([], expected)
values = record.get_fieldvalues(owner=self.user2, context=owned_collection, include_context_owner=True)
expected = ['v', 'v-u1', 'v-u2', 'v-u1-ctx']
for v in values:
self.assertTrue(v.value in expected)
expected.remove(v.value)
self.assertEqual([], expected)
def testKeepSystemFieldValues(self):
no_signals()
identifier = Field.objects.get(name='identifier', standard__prefix='dc')
title = Field.objects.get(name='title', standard__prefix='dc')
system = get_system_field()
r1 = Record.objects.create(name='s001')
CollectionItem.objects.create(record=r1, collection=self.collection)
r1.fieldvalue_set.create(field=identifier, value='S001')
r1.fieldvalue_set.create(field=title, value='Title')
r1.fieldvalue_set.create(field=system, value='Keep this')
testimport = SpreadsheetImport(StringIO("Identifier,Title\nS002,NewTitle2\nS001,NewTitle1"),
[self.collection])
testimport.name_field = 'Identifier'
testimport.run(update=True)
self.assertEqual(1, testimport.added)
self.assertEqual(1, testimport.updated)
self.assertEqual(0, testimport.added_skipped)
self.assertEqual(0, testimport.updated_skipped)
t1 = self.collection.records.get(name='s001').fieldvalue_set.filter(field=title)
t2 = self.collection.records.get(name='s002').fieldvalue_set.filter(field=title)
s = self.collection.records.get(name='s001').fieldvalue_set.filter(field=system)
self.assertEqual('NewTitle1', t1[0].value)
self.assertEqual('NewTitle2', t2[0].value)
self.assertEqual('Keep this', s[0].value)
def testSkipAdds(self):
no_signals()
identifier = Field.objects.get(name='identifier', standard__prefix='dc')
title = Field.objects.get(name='title', standard__prefix='dc')
r1 = Record.objects.create(name='r001')
CollectionItem.objects.create(record=r1, collection=self.collection)
r1.fieldvalue_set.create(field=identifier, value='R001')
r1.fieldvalue_set.create(field=title, value='Title')
testimport = SpreadsheetImport(StringIO("Identifier,Title\nR002,NewTitle1\nR001,NewTitle2"),
[self.collection])
testimport.name_field = 'Identifier'
testimport.run(add=False)
self.assertEqual(0, testimport.added)
self.assertEqual(1, testimport.updated)
self.assertEqual(1, testimport.added_skipped)
self.assertEqual(0, testimport.updated_skipped)
t1 = self.collection.records.get(name='r001').fieldvalue_set.filter(field=title)
t2 = self.collection.records.filter(name='r002')
self.assertEqual('NewTitle2', t1[0].value)
self.assertFalse(t2)
def testFieldValueBasicContext(self):
no_signals()
record = Record.objects.create()
CollectionItem.objects.create(record=record, collection=self.collection)
t1 = record.fieldvalue_set.create(field=self.titleField, label='Caption', value='Photograph of Mona Lisa')
t2 = record.fieldvalue_set.create(field=self.titleField, value='Photo Lisa')
c1 = record.fieldvalue_set.create(field=self.creatorField, label='Photographer', value='John Doe')
c2 = record.fieldvalue_set.create(field=self.creatorField, value='John X. Doe', context=self.collection)
l1 = record.fieldvalue_set.create(field=self.locationField, value='Harrisonburg', owner=self.user)
# this test was throwing this error:
# TypeError: can't subtract offset-naive and offset-aware datetimes
# - I'm pretty sure this is a problem with the test not what's being tested
# - dates created for records have timezones in them, so it should be checked against a tz-aware now()
# was:
# self.assertEqual(True, datetime.now() - record.created < timedelta(0, 120))
# self.assertEqual(True, datetime.now() - record.modified < timedelta(0, 120))
now = datetime.utcnow().replace(tzinfo=utc)
self.assertEqual(True, now - record.created < timedelta(0, 120))
self.assertEqual(True, now - record.modified < timedelta(0, 120))
self.assertEqual("Caption", t1.resolved_label)
self.assertEqual("Title", t2.resolved_label)
self.assertEqual(3, len(record.get_fieldvalues()))
self.assertEqual(4, len(record.get_fieldvalues(context=self.collection)))
self.assertEqual(4, len(record.get_fieldvalues(owner=self.user)))
self.assertEqual(5, len(record.get_fieldvalues(owner=self.user, context=self.collection)))
def testRecordMultiRowImport2(self):
no_signals()
identifier = Field.objects.get(name='identifier', standard__prefix='dc')
title = Field.objects.get(name='title', standard__prefix='dc')
testimport = SpreadsheetImport(StringIO("""Identifier,Title
,Title1
Z001,Title2
,Title3
Z003,Title7
Z002,Title4
Z002,Title5
Z002,Title6
Z003,Title8"""),
[self.collection])
testimport.name_field = 'Identifier'
testimport.run()
self.assertEqual(3, testimport.added)
self.assertEqual(0, testimport.updated)
self.assertEqual(1, testimport.duplicate_in_file_skipped)
self.assertEqual(1, testimport.no_id_skipped)
t1 = self.collection.records.get(name='z001').fieldvalue_set.filter(field=title)
t2 = self.collection.records.get(name='z002').fieldvalue_set.filter(field=title)
t3 = self.collection.records.get(name='z003').fieldvalue_set.filter(field=title)
self.assertEqual('Title2', t1[0].value)
self.assertEqual('Title3', t1[1].value)
self.assertEqual('Title4', t2[0].value)
self.assertEqual('Title5', t2[1].value)
self.assertEqual('Title6', t2[2].value)
self.assertEqual('Title7', t3[0].value)
def setUp(self):
no_signals()
self.tempdir = tempfile.mkdtemp()
self.collection = Collection.objects.create(title='GetMediaTest')
self.storage = Storage.objects.create(title='GetMediaTest', name='getmediatest', system='local', base=self.tempdir)
self.record = Record.objects.create(name='monalisa')
self.record.media_set.create(name='getmediatest', url='getmediatest', storage=self.storage)
CollectionItem.objects.create(collection=self.collection, record=self.record)
self.user, created = User.objects.get_or_create(username='******')
self.owner_can_read, created2 = User.objects.get_or_create(username='******')
self.owner_cant_read, created3 = User.objects.get_or_create(username='******')
AccessControl.objects.create(user=self.owner_can_read, content_object=self.collection, read=True)
self.record_standalone = Record.objects.create(name='no_collection', owner=self.owner_can_read)
self.record_standalone.media_set.create(name='getmediatest', url='getmediatest', storage=self.storage)
self.presentation_ok = Presentation.objects.create(title='GetMediaTest1', owner=self.owner_can_read)
self.presentation_ok.items.create(record=self.record, order=1)
self.presentation_hidden = Presentation.objects.create(title='GetMediaTest5', owner=self.owner_can_read, hidden=True)
self.presentation_hidden.items.create(record=self.record, order=1)
self.presentation_broken = Presentation.objects.create(title='GetMediaTest2', owner=self.owner_cant_read)
self.presentation_broken.items.create(record=self.record, order=1)
self.presentation_password = Presentation.objects.create(title='GetMediaTest3', owner=self.owner_can_read, password='******')
self.presentation_password.items.create(record=self.record, order=1)
self.presentation_no_record = Presentation.objects.create(title='GetMediaTest4', owner=self.owner_can_read)
self.presentation_standalone_record = Presentation.objects.create(title='GetMediaTest6', owner=self.owner_can_read)
self.presentation_standalone_record.items.create(record=self.record_standalone, order=1)
AccessControl.objects.create(user=self.user, content_object=self.storage, read=True)
def testOwnedRecordImport(self):
no_signals()
identifier = Field.objects.get(name='identifier', standard__prefix='dc')
title = Field.objects.get(name='title', standard__prefix='dc')
r1 = Record.objects.create(name='x001')
CollectionItem.objects.create(record=r1, collection=self.collection)
r1.fieldvalue_set.create(field=identifier, value='X001')
r1.fieldvalue_set.create(field=title, value='Standard')
r2 = Record.objects.create(name='x002', owner=self.user)
CollectionItem.objects.create(record=r2, collection=self.collection)
r2.fieldvalue_set.create(field=identifier, value='X002')
r2.fieldvalue_set.create(field=title, value='Owned')
testimport = SpreadsheetImport(StringIO("Identifier,Title\nX001,NewTitle1\nX002,NewTitle2\nX003,NewTitle3"),
[self.collection],
owner=self.user)
testimport.name_field = 'Identifier'
testimport.run()
self.assertEqual(1, testimport.added)
self.assertEqual(1, testimport.updated)
self.assertEqual(1, testimport.owner_skipped)
r1 = self.collection.records.get(name='x001')
r2 = self.collection.records.get(name='x002')
r3 = self.collection.records.get(name='x003')
self.assertEqual(None, r1.owner)
self.assertEqual(self.user, r2.owner)
self.assertEqual(self.user, r3.owner)
self.assertEqual('Standard', r1.title)
self.assertEqual('NewTitle2', r2.title)
self.assertEqual('NewTitle3', r3.title)
def setUp(self):
no_signals()
self.tempdir = tempfile.mkdtemp()
self.collection = Collection.objects.create(title='Test')
self.local_storage = Storage.objects.create(title='Test', name='test', system='local', base=self.tempdir)
self.storage = Storage.objects.create(title='PseudoStreamTest', name='pseudostreamtest', system='rooibos.storage.pseudostreaming',
base=self.tempdir,
urlbase='file:///' + self.tempdir.replace('\\', '/'))
self.record = Record.objects.create(name='record')
self.media = Media.objects.create(record=self.record, name='image', storage=self.storage)
self.local_media = Media.objects.create(record=self.record, name='image', storage=self.local_storage)
CollectionItem.objects.create(collection=self.collection, record=self.record)
AccessControl.objects.create(content_object=self.storage, read=True)
AccessControl.objects.create(content_object=self.collection, read=True)
print "\nstorage title: %s \nstorage base: %s" % (self.storage.title, self.storage.base)
print "\nstorage title: %s \nstorage base: %s" % (self.local_storage.title, self.local_storage.base)
print "\nstorage urlbase: %s \nstorage storage system: %s" % (self.storage.urlbase, self.storage.system)
print "PseudoStreamingStorageSystemTestCase setup complete"
try:
TEST_STRING = 'test local storage'
content = StringIO(TEST_STRING)
pseudofile = File(content)
except Exception as e:
print e
pass
def testImportSimple(self):
no_signals()
testimport = SpreadsheetImport(StringIO(csv_file), [self.collection])
self.assertEqual(0, self.collection.records.count())
testimport.analyze()
dc = dict(
identifier=Field.objects.get(name='identifier', standard__prefix='dc'),
title=Field.objects.get(name='title', standard__prefix='dc'),
creator=Field.objects.get(name='creator', standard__prefix='dc'),
coverage=Field.objects.get(name='coverage', standard__prefix='dc'),
)
testimport.mapping = {
'ID': dc['identifier'],
'Filename': None,
'Title': dc['title'],
'Creator': dc['creator'],
'Location': dc['coverage'],
}
testimport.name_field = 'ID'
self.assertNotEqual(None, testimport.get_identifier_field())
testimport.run()
self.assertEquals(2, self.collection.records.count())
r1 = self.collection.records.get(name='A001'.lower())
self.assertEqual('A001', r1.fieldvalue_set.get(field=dc['identifier']).value)
def testSubGroupRecords(self):
no_signals()
group_f = Collection.objects.create(title='F', name='f')
group_g = Collection.objects.create(title='G', name='g')
group_h = Collection.objects.create(title='H', name='h')
group_f.children.add(group_g)
group_f.save()
record = Record.objects.create()
self.assertEqual(0, len(group_f.all_records))
record = Record.objects.create()
CollectionItem.objects.create(record=record, collection=group_h)
self.assertEqual(0, len(group_f.all_records))
record = Record.objects.create()
CollectionItem.objects.create(record=record, collection=group_f)
self.assertEqual(1, len(group_f.all_records))
record = Record.objects.create()
CollectionItem.objects.create(record=record, collection=group_g)
self.assertEqual(2, len(group_f.all_records))
record = Record.objects.create()
CollectionItem.objects.create(record=record, collection=group_f)
CollectionItem.objects.create(record=record, collection=group_g)
self.assertEqual(3, len(group_f.all_records))
def testPersonalRecordInCollectionShared(self):
no_signals()
record = self.createRecord()
record.owner = self.owner
record.save()
CollectionItem.objects.create(collection=self.collection, record=record, hidden=False)
self.checkAccess(record, True, True, True, True, True)
def testTestOnly(self):
no_signals()
identifier = Field.objects.get(name='identifier', standard__prefix='dc')
title = Field.objects.get(name='title', standard__prefix='dc')
r1 = Record.objects.create(name='t001')
CollectionItem.objects.create(record=r1, collection=self.collection)
r1.fieldvalue_set.create(field=identifier, value='T001')
r1.fieldvalue_set.create(field=title, value='Title')
testimport = SpreadsheetImport(StringIO("""Identifier,Title
,Title1
T001,Title2
,Title3
T003,Title7
T002,Title4
T002,Title5
T002,Title6
T003,Title8"""),
[self.collection])
testimport.name_field = 'Identifier'
testimport.run(test=True)
self.assertEqual(2, testimport.added)
self.assertEqual(1, testimport.updated)
self.assertEqual(1, testimport.duplicate_in_file_skipped)
self.assertEqual(1, testimport.no_id_skipped)
r = self.collection.records.filter(name__startswith='t')
self.assertEqual(1, r.count())
t1 = self.collection.records.get(name='t001').fieldvalue_set.filter(field=title)
self.assertEqual('Title', t1[0].value)
def setUp(self):
no_signals()
self.collection = Collection.objects.create(title='Test Collection', name='test')
self.titleField = Field.objects.create(label='Title', name='title')
self.creatorField = Field.objects.create(label='Creator', name='creator')
self.locationField = Field.objects.create(label='Location', name='location')
self.user, created = User.objects.get_or_create(username='******')
self.records = []
def test_password_access(self):
no_signals()
self.assertEqual(0, get_media_for_record(self.record, user=self.user).count())
AccessControl.objects.create(user=self.user, content_object=self.presentation_password, read=True)
self.assertEqual(0, get_media_for_record(self.record, user=self.user).count())
passwords = dict(((self.presentation_password.id, 'test'),))
self.assertEqual(1, get_media_for_record(self.record, user=self.user, passwords=passwords).count())
AccessControl.objects.filter(user=self.user).delete()
def test_simple_presentation_access(self):
no_signals()
self.assertEqual(0, get_media_for_record(self.record, user=self.user).count())
AccessControl.objects.create(user=self.user, content_object=self.presentation_broken, read=True)
self.assertEqual(0, get_media_for_record(self.record, user=self.user).count())
AccessControl.objects.create(user=self.user, content_object=self.presentation_ok, read=True)
self.assertEqual(1, get_media_for_record(self.record, user=self.user).count())
AccessControl.objects.filter(user=self.user).delete()
def setUp(self):
no_signals()
self.collection = Collection.objects.create(title='Test')
self.storage = Storage.objects.create(title='Test', name='test', system='online')
self.record = Record.objects.create(name='monalisa')
CollectionItem.objects.create(collection=self.collection, record=self.record)
AccessControl.objects.create(content_object=self.storage, read=True)
AccessControl.objects.create(content_object=self.collection, read=True)
def testAnalyzeCollection(self):
no_signals()
empty = analyze_records(self.collection, self.storage)
self.assertEqual(2, len(empty))
titles = sorted(e.title for e in empty)
self.assertEqual('id_missing_other', titles[0])
self.assertEqual('id_no_media', titles[1])
def testRegularRecordInCollectionHidden(self):
no_signals()
record = self.createRecord()
record.save()
CollectionItem.objects.create(collection=self.collection, record=record, hidden=True)
self.checkAccess(record, False, True, True, False, True)
# Check to make sure result does not change if record is not hidden in another collection
CollectionItem.objects.create(collection=self.collection2, record=record, hidden=False)
self.checkAccess(record, False, True, True, False, True)
def tearDown(self):
no_signals()
self.collection.delete()
self.titleField.delete()
self.creatorField.delete()
self.locationField.delete()
self.user.delete()
self.user2.delete()
self.user3.delete()
def testIndividualRecord(self):
no_signals()
record = self.createRecord()
record.save()
self.checkAccess(record, False, False, False, False, True, user=False)
AccessControl.objects.create(content_object=record,
user=self.user,
read=True)
self.checkAccess(record, False, False, False, False, True, user=True)
def tearDown(self):
no_signals()
for record in self.records:
record.delete()
self.collection.delete()
self.titleField.delete()
self.creatorField.delete()
self.locationField.delete()
self.user.delete()
def testImport(self):
no_signals()
testimport = SpreadsheetImport(StringIO(csv_file), [self.collection])
self.assertFalse(testimport.analyzed)
data = testimport.analyze()
self.assertTrue(testimport.analyzed)
