def test_perform_user_vlob_synchronize(app, app_no_cache):
blob = 'foo'
eff = app.perform_user_vlob_update(EUserVlobUpdate(1, blob))
perform_sequence([], eff)
# With cache enabled
assert app.user_vlob_cache.currsize == 0
eff = app.perform_user_vlob_synchronize(EUserVlobSynchronize())
sequence = [(
EBackendUserVlobUpdate(1, blob.encode()), # TODO encode ok ?
noop)]
synchronization = perform_sequence(sequence, eff)
assert synchronization is True
assert app.user_vlob is None
assert app.user_vlob_cache.currsize == 1
# With cache disabled
eff = app_no_cache.perform_user_vlob_update(EUserVlobUpdate(1, blob))
perform_sequence([], eff)
assert app_no_cache.user_vlob_cache.currsize == 0
eff = app_no_cache.perform_user_vlob_synchronize(EUserVlobSynchronize())
sequence = [(
EBackendUserVlobUpdate(1, blob.encode()), # TODO encode ok ?
noop)]
synchronization = perform_sequence(sequence, eff)
assert synchronization is True
assert app_no_cache.user_vlob is None
assert app_no_cache.user_vlob_cache.currsize == 0
# Do nothing
eff = app.perform_user_vlob_synchronize(EUserVlobSynchronize())
synchronization = perform_sequence([], eff)
assert synchronization is False
def test_perform_user_vlob_update(app):
with freeze_time('2012-01-01') as frozen_datetime:
eff = app.perform_user_vlob_update(EUserVlobUpdate(1, 'foo'))
perform_sequence([], eff)
assert app.last_modified == Arrow.fromdatetime(frozen_datetime())
blob = 'bar'
eff = app.perform_user_vlob_update(EUserVlobUpdate(1, blob))
perform_sequence([], eff)
eff = app.perform_user_vlob_read(EUserVlobRead())
user_vlob = perform_sequence([], eff)
assert sorted(list(user_vlob.keys())) == ['blob', 'version']
assert user_vlob['blob'] == blob
assert user_vlob['version'] == 1
def commit(self, recursive=True):
is_dirty = yield self.is_dirty()
if self.version != 0 and not is_dirty:
return
# Update manifest with new group vlobs
vlob_list = yield Effect(EVlobList())
if recursive:
for group_manifest in self.group_manifests.values():
new_vlob = yield group_manifest.commit()
if new_vlob and new_vlob is not True:
old_vlob = group_manifest.get_vlob()
new_vlob['key'] = old_vlob['key']
group_manifest.update_vlob(new_vlob)
# Update manifest entries with new file vlobs (dustbin entries are already commited)
for entry in self.entries.values():
if entry and entry['id'] in vlob_list:
file = yield File.load(entry['id'],
entry['key'],
entry['read_trust_seed'],
entry['write_trust_seed'])
new_vlob = yield file.commit()
if new_vlob and new_vlob is not True:
entry['id'] = new_vlob['id']
entry['read_trust_seed'] = new_vlob['read_trust_seed']
entry['write_trust_seed'] = new_vlob['write_trust_seed']
# Commit manifest
blob = yield self.dumps()
encrypted_blob = self.encryptor.pub_key.encrypt(blob.encode())
encrypted_blob = to_jsonb64(encrypted_blob)
yield Effect(EUserVlobUpdate(self.version + 1, encrypted_blob))
self.original_manifest = ejson_loads(blob)
synchronized = yield Effect(EUserVlobSynchronize())
if synchronized:
self.version += 1
def app(mock_crypto_passthrough, alice_identity):
# app = FSComponent()
# identity_component = IdentityComponent()
fs_component = FSComponent()
# synchronizer_component = SynchronizerComponent()
# identity_component = IdentityComponent()
# app = app_factory(
# fs_component.get_dispatcher(),
# synchronizer_component.get_dispatcher(),
# identity_component.get_dispatcher()
# )
blob = {
'dustbin': [],
'entries': {
'/': None
},
'groups': {},
'versions': {}
}
blob = ejson_dumps(blob).encode()
blob = to_jsonb64(blob)
sequence = [(EIdentityGet(), const(alice_identity)),
(EUserVlobRead(), const({
'blob': '',
'version': 0
})), (EUserVlobUpdate(1, blob), noop)]
perform_sequence(sequence, fs_component._get_manifest())
return fs_component
def restore(self, version=None):
if version is None:
version = self.version - 1 if self.version > 1 else 1
if version > 0 and version < self.version:
vlob = yield Effect(EUserVlobRead(version))
yield Effect(EUserVlobUpdate(self.version, vlob['blob']))
elif version < 1 or version > self.version:
raise ManifestError('bad_version', 'Bad version number.')
yield self.reload(reset=True)
def test_perform_user_vlob_exist(app):
eff = app.perform_user_vlob_exist(EUserVlobExist())
exist = perform_sequence([], eff)
assert exist is False
eff = app.perform_user_vlob_update(EUserVlobUpdate(1, 'foo'))
perform_sequence([], eff)
eff = app.perform_user_vlob_exist(EUserVlobExist())
exist = perform_sequence([], eff)
assert exist is True
def load(cls, private_key): # TODO retrieve key from id
self = UserManifest('USER')
self.encryptor = load_private_key(private_key)
try:
yield self.reload(reset=True)
except ManifestNotFound:
self.version = 0
self.group_manifests = {}
self.original_manifest = {'entries': deepcopy(self.entries),
'dustbin': deepcopy(self.dustbin),
'groups': deepcopy(self.group_manifests),
'versions': {}}
blob = yield self.dumps()
encrypted_blob = self.encryptor.pub_key.encrypt(blob.encode())
encrypted_blob = to_jsonb64(encrypted_blob)
yield Effect(EUserVlobUpdate(1, encrypted_blob))
return self
def test_perform_synchronize(app, alice_identity):
blob = {
'dustbin': [],
'entries': {
'/': None
},
'groups': {},
'versions': {}
}
blob = ejson_dumps(blob).encode()
blob = to_jsonb64(blob)
eff = app.perform_synchronize(ESynchronize())
sequence = [(EIdentityGet(), const(alice_identity)),
(EVlobList(), const([])), (EUserVlobUpdate(1, blob), noop),
(EUserVlobSynchronize(), noop)]
ret = perform_sequence(sequence, eff)
assert ret is None
def test_perform_user_vlob_delete(app):
eff = app.perform_user_vlob_update(EUserVlobUpdate(1, 'foo'))
perform_sequence([], eff)
# Delete from new user vlobs
with freeze_time('2012-01-01') as frozen_datetime:
eff = app.perform_user_vlob_delete(EUserVlobDelete())
perform_sequence([], eff)
assert app.last_modified == Arrow.fromdatetime(frozen_datetime())
# Delete in cache
app.user_vlob_cache[2] = {'foo': 'bar'}
assert app.user_vlob_cache.currsize == 1
with freeze_time('2012-01-01') as frozen_datetime:
eff = app.perform_user_vlob_delete(EUserVlobDelete(2))
perform_sequence([], eff)
assert app.last_modified == Arrow.fromdatetime(frozen_datetime())
assert app.user_vlob_cache.currsize == 0
# Not found
with pytest.raises(UserVlobNotFound):
eff = app.perform_user_vlob_delete(EUserVlobDelete(2))
perform_sequence([], eff)
def test_perform_user_vlob_read(app, app_no_cache):
local_blob = 'foo'
eff = app.perform_user_vlob_update(EUserVlobUpdate(1, local_blob))
perform_sequence([], eff)
# Read remote user vlob
assert app.user_vlob_cache.currsize == 0
remote_blob = b'bar'
eff = app.perform_user_vlob_read(EUserVlobRead(2))
sequence = [(EBackendUserVlobRead(2), const(UserVlobAtom(2, remote_blob)))]
user_vlob = perform_sequence(sequence, eff)
assert sorted(list(user_vlob.keys())) == ['blob', 'version']
assert user_vlob['blob'] == remote_blob.decode() # TODO decode?
assert user_vlob['version'] == 2
assert app.user_vlob_cache.currsize == 1
# Read remote user vlob with cache disabled
assert app_no_cache.user_vlob_cache.currsize == 0
remote_blob = b'bar'
eff = app_no_cache.perform_user_vlob_read(EUserVlobRead(2))
sequence = [(EBackendUserVlobRead(2), const(UserVlobAtom(2, remote_blob)))]
user_vlob = perform_sequence(sequence, eff)
assert sorted(list(user_vlob.keys())) == ['blob', 'version']
assert user_vlob['blob'] == remote_blob.decode() # TODO decode?
assert user_vlob['version'] == 2
assert app_no_cache.user_vlob_cache.currsize == 0
# Read user vlob in cache
remote_blob = b'bar'
eff = app.perform_user_vlob_read(EUserVlobRead(2))
user_vlob = perform_sequence([], eff)
assert sorted(list(user_vlob.keys())) == ['blob', 'version']
assert user_vlob['blob'] == remote_blob.decode() # TODO decode?
assert user_vlob['version'] == 2
# Delete user vlob from cache
eff = app.perform_user_vlob_delete(EUserVlobDelete(2))
perform_sequence([], eff)
# Read local user vlob
eff = app.perform_user_vlob_read(EUserVlobRead(1))
user_vlob = perform_sequence([], eff)
assert sorted(list(user_vlob.keys())) == ['blob', 'version']
assert user_vlob['blob'] == local_blob # TODO decode?
assert user_vlob['version'] == 1