def test_matching_archive(self):
version = factories.FileVersionFactory(
location={
'service': 'cloud',
settings.WATERBUTLER_RESOURCE: 'osf',
'object': 'd077f2',
},
metadata={'sha256': 'existing'}
)
factories.FileVersionFactory(
location={
'service': 'cloud',
settings.WATERBUTLER_RESOURCE: 'osf',
'object': '06d80e',
},
metadata={
'sha256': 'existing',
'vault': 'the cloud',
'archive': 'erchiv'
}
)
assert_is(version._find_matching_archive(), True)
assert_is_not(version.archive, None)
assert_equal(version.metadata['vault'], 'the cloud')
assert_equal(version.metadata['archive'], 'erchiv')
def test_is_duplicate_false(self):
version1 = factories.FileVersionFactory(location={
'service': 'cloud',
settings.WATERBUTLER_RESOURCE: 'osf',
'object': 'd077f2',
}, )
version2 = factories.FileVersionFactory(location={
'service': 'cloud',
settings.WATERBUTLER_RESOURCE: 'osf',
'object': '06d80e',
}, )
assert_false(version1.is_duplicate(version2))
assert_false(version2.is_duplicate(version1))
def test_move_nested_between_regions(self):
canada = RegionFactory()
new_component = NodeFactory(parent=self.project)
component_node_settings = new_component.get_addon('osfstorage')
component_node_settings.region = canada
component_node_settings.save()
move_to = component_node_settings.get_root()
to_move = self.node_settings.get_root().append_folder(
'Aaah').append_folder('Woop')
child = to_move.append_file('There it is')
for _ in range(2):
version = factories.FileVersionFactory(
region=self.node_settings.region)
child.add_version(version)
child.save()
moved = to_move.move_under(move_to)
child.reload()
assert new_component == child.target
versions = child.versions.order_by('-created')
assert versions.first().region == component_node_settings.region
assert versions.last().region == self.node_settings.region
def test_children_metadata(self):
path = u'kind/of/magíc.mp3'
record = recursively_create_file(self.node_settings, path)
version = factories.FileVersionFactory()
record.versions.add(version)
record.save()
res = self.send_hook(
'osfstorage_get_children',
{'fid': record.parent._id},
{},
)
assert_equal(len(res.json), 1)
res_data = res.json[0]
expected_data = record.serialize()
# Datetimes in response might not be exactly the same as in record.serialize
# because of the way Postgres serializes dates. For example,
# '2017-06-05T17:32:20.964950+00:00' will be
# serialized as '2017-06-05T17:32:20.96495+00:00' by postgres
# Therefore, we parse the dates then compare them
expected_date_modified = parse_datetime(expected_data.pop('modified'))
expected_date_created = parse_datetime(expected_data.pop('created'))
res_date_modified = parse_datetime(res_data.pop('modified'))
res_date_created = parse_datetime(res_data.pop('created'))
assert_equal(res_date_modified, expected_date_modified)
assert_equal(res_date_created, expected_date_created)
assert_equal(res_data, expected_data)
def test_update_metadata(self):
version = factories.FileVersionFactory()
version.update_metadata(
{'archive': 'glacier', 'size': 123, 'modified': 'Mon, 16 Feb 2015 18:45:34 GMT'})
version.reload()
assert_in('archive', version.metadata)
assert_equal(version.metadata['archive'], 'glacier')
def setUp(self):
super(TestGetRevisions, self).setUp()
self.path = 'tie/your/mother/down.mp3'
self.record = recursively_create_file(self.node_settings, self.path)
self.record.versions = [
factories.FileVersionFactory() for __ in range(15)
]
self.record.save()
def setUp(self):
super(TestSerializeRevision, self).setUp()
self.path = 'kind-of-magic.webm'
self.record = self.node_settings.get_root().append_file(self.path)
self.versions = [
factories.FileVersionFactory(creator=self.user) for __ in range(3)
]
attach_versions(self.record, self.versions)
self.record.save()
def test_file_metdata(self):
path = u'kind/of/magíc.mp3'
record = recursively_create_file(self.node_settings, path)
version = factories.FileVersionFactory()
record.versions.add(version)
record.save()
res = self.send_hook('osfstorage_get_metadata',
{'fid': record.parent._id}, {}, self.node)
assert_true(isinstance(res.json, dict))
assert_equal(res.json, record.parent.serialize(True))
def test_no_matching_archive(self):
models.FileVersion.objects.all().delete()
assert_is(False, factories.FileVersionFactory(
location={
'service': 'cloud',
settings.WATERBUTLER_RESOURCE: 'osf',
'object': 'd077f2',
},
metadata={'sha256': 'existing'}
)._find_matching_archive())
def test_children_metadata(self):
path = u'kind/of/magíc.mp3'
record = recursively_create_file(self.node_settings, path)
version = factories.FileVersionFactory()
record.versions.add(version)
record.save()
res = self.send_hook(
'osfstorage_get_children',
{'fid': record.parent._id},
{},
)
assert_equal(len(res.json), 1)
assert_equal(res.json[0], record.serialize())
def test_fields(self):
version = factories.FileVersionFactory(
size=1024,
content_type='application/json',
modified=timezone.now(),
)
retrieved = models.FileVersion.load(version._id)
assert_true(retrieved.creator)
assert_true(retrieved.location)
assert_true(retrieved.size)
# sometimes identifiers are strings, so this always has to be a string, sql is funny about that.
assert_equal(retrieved.identifier, u"0")
assert_true(retrieved.content_type)
assert_true(retrieved.modified)
def setUp(self):
super(TestUpdateMetadataHook, self).setUp()
self.path = 'greasy/pízza.png'
self.record = recursively_create_file(self.node_settings, self.path)
self.version = factories.FileVersionFactory()
self.record.versions = [self.version]
self.record.save()
self.payload = {
'metadata': {
'size': 123,
'modified': 'Mon, 16 Feb 2015 18:45:34 GMT',
'md5': 'askjasdlk;jsadlkjsadf',
'sha256': 'sahduashduahdushaushda',
},
'version': self.version._id,
'size': 321, # Just to make sure the field is ignored
}
def test_after_fork_copies_versions(self):
num_versions = 5
path = 'jazz/dreamers-ball.mp3'
record = self.node_settings.get_root().append_file(path)
for _ in range(num_versions):
version = factories.FileVersionFactory()
record.versions.add(version)
fork = self.project.fork_node(self.auth_obj)
fork_node_settings = fork.get_addon('osfstorage')
fork_node_settings.reload()
cloned_record = fork_node_settings.get_root().find_child_by_name(path)
assert_equal(list(cloned_record.versions.all()), list(record.versions.all()))
assert_true(fork_node_settings.root_node)
def test_after_fork_copies_versions(self, node, node_settings, auth_obj):
num_versions = 5
path = 'jazz/dreamers-ball.mp3'
record = node_settings.get_root().append_file(path)
for _ in range(num_versions):
version = factories.FileVersionFactory()
record.add_version(version)
fork = node.fork_node(auth_obj)
fork_node_settings = fork.get_addon('osfstorage')
fork_node_settings.reload()
cloned_record = fork_node_settings.get_root().find_child_by_name(path)
assert list(cloned_record.versions.all()) == list(
record.versions.all())
assert fork_node_settings.root_node
def test_is_duplicate_true(self):
version1 = factories.FileVersionFactory()
version2 = factories.FileVersionFactory()
assert_true(version1.is_duplicate(version2))
assert_true(version2.is_duplicate(version1))
def create_record_with_version(path, node_settings, **kwargs):
version = factories.FileVersionFactory(**kwargs)
node_settings.get_root().append_file(path)
record.versions.append(version)
record.save()
return record
