def test_perform_file_create(app, alice_identity, file):
vlob = {'id': '2345', 'read_trust_seed': '42', 'write_trust_seed': '43'}
block_id = '4567'
# Already exist
blob = [{
'blocks': [{
'block': block_id,
'digest': digest(b''),
'size': 0
}],
'key': to_jsonb64(b'<dummy-key-00000000000000000003>')
}]
blob = ejson_dumps(blob).encode()
blob = to_jsonb64(blob)
eff = app.perform_file_create(EFileCreate('/foo'))
sequence = [
(EBlockCreate(''), const(block_id)),
(EVlobCreate(blob), const(vlob)),
(EIdentityGet(), const(alice_identity)),
(EVlobRead(vlob['id'], vlob['read_trust_seed'],
1), const({
'id': vlob['id'],
'blob': blob,
'version': 1
})),
(EBlockDelete(block_id), noop),
(EVlobDelete(vlob['id']), noop),
]
with pytest.raises(ManifestError):
perform_sequence(sequence, eff)
def test_discard(self, file):
content = b'This is a test content.'
block_ids = ['4567', '5678', '6789']
# Original content
chunk_1 = content[:5]
chunk_2 = content[5:14]
chunk_3 = content[14:]
blob = [{
'blocks': [{
'block': block_ids[0],
'digest': digest(chunk_1),
'size': len(chunk_1)
}, {
'block': block_ids[1],
'digest': digest(chunk_2),
'size': len(chunk_2)
}],
'key':
to_jsonb64(b'<dummy-key-00000000000000000003>')
}, {
'blocks': [{
'block': block_ids[2],
'digest': digest(chunk_3),
'size': len(chunk_3)
}],
'key':
to_jsonb64(b'<dummy-key-00000000000000000004>')
}]
blob = ejson_dumps(blob).encode()
blob = to_jsonb64(blob)
# Already synchronized
sequence = [
(EVlobRead('1234', '42',
1), const({
'id': '1234',
'blob': blob,
'version': 1
})),
(EBlockDelete('4567'), conste(BlockNotFound('Block not found.'))),
(EBlockDelete('5678'), noop),
(EBlockDelete('6789'), noop),
(EVlobDelete('1234'), conste(VlobNotFound('Block not found.'))
) # TODO vlob OR block exceptin
]
ret = perform_sequence(sequence, file.discard())
assert ret is False
# Not already synchronized
file.dirty = True
file.version = 0
sequence = [(EVlobRead('1234', '42', 1),
const({
'id': '1234',
'blob': blob,
'version': 1
})), (EBlockDelete('4567'), noop),
(EBlockDelete('5678'), noop), (EBlockDelete('6789'), noop),
(EVlobDelete('1234'), noop)]
ret = perform_sequence(sequence, file.discard())
assert ret is True
assert file.dirty is False
def test_perform_block_synchronize(app, app_no_cache):
content = 'foo'
eff = app.perform_block_create(EBlockCreate(content))
block_id = perform_sequence([], eff)
eff = app_no_cache.perform_block_create(EBlockCreate(content))
block_2_id = perform_sequence([], eff)
# With cache enabled
assert app.block_cache.currsize == 0
eff = app.perform_block_synchronize(EBlockSynchronize(block_id))
sequence = [(EBackendBlockCreate(block_id,
content), const(Block(block_id,
content)))]
synchronization = perform_sequence(sequence, eff)
assert synchronization is True
assert block_id not in app.blocks
assert app.block_cache.currsize == 1
# With cache disabled
assert app_no_cache.block_cache.currsize == 0
eff = app_no_cache.perform_block_synchronize(EBlockSynchronize(block_2_id))
sequence = [(EBackendBlockCreate(block_2_id, content),
const(Block(block_2_id, content)))]
synchronization = perform_sequence(sequence, eff)
assert synchronization is True
assert block_2_id not in app_no_cache.blocks
assert app_no_cache.block_cache.currsize == 0
# Do nothing
eff = app.perform_block_synchronize(EBlockSynchronize(block_2_id))
synchronization = perform_sequence([], eff)
assert synchronization is False
def test_perform_file_history(app, file, alice_identity):
vlob = {'id': '2345', 'read_trust_seed': '42', 'write_trust_seed': '43'}
blob = [{
'blocks': [{
'block': '4567',
'digest': digest(b''),
'size': 0
}],
'key': to_jsonb64(b'<dummy-key-00000000000000000001>')
}]
blob = ejson_dumps(blob).encode()
blob = to_jsonb64(blob)
eff = app.perform_file_history(EFileHistory('/foo', 1, 1))
sequence = [
(EIdentityGet(), const(alice_identity)),
(EIdentityGet(), const(alice_identity)),
(EVlobRead(vlob['id'], vlob['read_trust_seed']),
const({
'id': vlob['id'],
'blob': blob,
'version': 1
})),
(EVlobList(), const([])),
]
perform_sequence(sequence, eff)
def test_handshake(component, mock_crypto_passthrough, alice):
with patch('parsec.backend.session._generate_challenge'
) as generate_challenge:
generate_challenge.return_value = 'my-challenge'
eff = component.handshake()
sequence = [
(EHandshakeSend(
payload=
'{"challenge": "my-challenge", "handshake": "challenge"}'),
noop),
(EHandshakeRecv(),
const(
'{"handshake": "answer", "answer": "bXktY2hhbGxlbmdlLWFuc3dlcg==", "identity": "*****@*****.**"}'
)), (EPubKeyGet('*****@*****.**',
raw=False), const(alice.pub_key)),
(EHandshakeSend(payload='{"status": "ok", "handshake": "done"}'),
noop)
]
perform_sequence(sequence, eff)
# Now identity can retrieve authenticated user
intent = EGetAuthenticatedUser()
eff = component.perform_get_authenticated_user(intent)
sequence = []
ret = perform_sequence(sequence, eff)
assert ret == '*****@*****.**'
def test_perform_undelete(app, alice_identity, file):
vlob = {'id': '2345', 'read_trust_seed': '42', 'write_trust_seed': '43'}
blob = [{
'blocks': [{
'block': '4567',
'digest': digest(b''),
'size': 0
}],
'key': to_jsonb64(b'<dummy-key-00000000000000000001>')
}]
blob = ejson_dumps(blob).encode()
blob = to_jsonb64(blob)
eff = app.perform_delete(EDelete('/foo'))
sequence = [
(EIdentityGet(), const(alice_identity)),
(EVlobRead(vlob['id'], vlob['read_trust_seed']),
const({
'id': vlob['id'],
'blob': blob,
'version': 1
})), (EVlobList(), const([])),
(EVlobRead(vlob['id'], vlob['read_trust_seed'],
1), const({
'id': vlob['id'],
'blob': blob,
'version': 1
})),
(EBlockDelete('4567'), conste(BlockNotFound('Block not found.'))),
(EVlobDelete('2345'), conste(VlobNotFound('Vlob not found.')))
]
ret = perform_sequence(sequence, eff)
eff = app.perform_undelete(EUndelete('2345'))
sequence = [(EIdentityGet(), const(alice_identity))]
ret = perform_sequence(sequence, eff)
assert ret is None
def test_api_dustbin_show():
# Specific file in dustbin
eff = execute_cmd('dustbin_show', {'path': '/foo'})
sequence = [
(EDustbinShow('/foo'), const([{
'path': '/foo'
}])),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok', 'dustbin': [{'path': '/foo'}]}
# All files in dustbin
eff = execute_cmd('dustbin_show', {})
sequence = [
(EDustbinShow(), const([{
'path': '/foo'
}, {
'path': '/bar'
}])),
]
resp = perform_sequence(sequence, eff)
assert resp == {
'status': 'ok',
'dustbin': [{
'path': '/foo'
}, {
'path': '/bar'
}]
}
def test_load_file(self, file):
vlob_id = '1234'
other_vlob_id = '5678'
read_trust_seed = '42'
version = 1
# Load from open files
file2 = perform_sequence(
[],
File.load(vlob_id, to_jsonb64(b'<dummy-key-00000000000000000001>'),
read_trust_seed, '43'))
assert file == file2
File.files = {}
# Test reloading commited and not commited file
for synchronizer_vlob_list in [[vlob_id, other_vlob_id],
[other_vlob_id]]:
key = to_jsonb64(b'<dummy-key-00000000000000000001>')
sequence = [
(EVlobRead(vlob_id, read_trust_seed, None),
const({
'id': vlob_id,
'blob': 'foo',
'version': version
})),
(EVlobList(), const(synchronizer_vlob_list)),
]
file = perform_sequence(
sequence, File.load(vlob_id, key, read_trust_seed, '43'))
assert file.dirty is (vlob_id in synchronizer_vlob_list)
assert file.version == (version - 1 if file.dirty else version)
File.files = {}
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 test_perform_stat(app, alice_identity, file):
eff = app.perform_folder_create(EFolderCreate('/dir'))
sequence = [(EIdentityGet(), const(alice_identity))]
ret = perform_sequence(sequence, eff)
eff = app.perform_stat(EStat('/dir'))
sequence = [(EIdentityGet(), const(alice_identity))]
ret = perform_sequence(sequence, eff)
assert ret == {'children': [], 'type': 'folder'}
def test_perform_delete(app, alice_identity):
eff = app.perform_folder_create(EFolderCreate('/dir'))
sequence = [(EIdentityGet(), const(alice_identity))]
ret = perform_sequence(sequence, eff)
eff = app.perform_delete(EDelete('/dir'))
sequence = [(EIdentityGet(), const(alice_identity))]
ret = perform_sequence(sequence, eff)
assert ret is None
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 test_perform_block_create(app):
content = 'foo'
with freeze_time('2012-01-01') as frozen_datetime:
eff = app.perform_block_create(EBlockCreate(content))
block_id = perform_sequence([], eff)
assert app.last_modified == Arrow.fromdatetime(frozen_datetime())
eff = app.perform_block_read(EBlockRead(block_id))
block = perform_sequence([], eff)
assert block['content'] == content
def test_perform_pubkey_get_missing_key():
eff = perform_pubkey_get(EBackendPubKeyGet('*****@*****.**'))
backend_response = {
'status': 'pubkey_not_found',
'label': 'Public key not found'
}
sequence = [
(BackendCmd('pubkey_get', {'id': '*****@*****.**'}), const(backend_response))
]
with pytest.raises(PubKeyNotFound):
perform_sequence(sequence, eff)
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 test_perform_vlob_create(app):
blob = 'foo'
with freeze_time('2012-01-01') as frozen_datetime:
eff = app.perform_vlob_create(EVlobCreate(blob))
vlob = perform_sequence([], eff)
assert app.last_modified == Arrow.fromdatetime(frozen_datetime())
vlob_id = vlob['id']
read_trust_seed = vlob['read_trust_seed']
assert sorted(list(
vlob.keys())) == ['id', 'read_trust_seed', 'write_trust_seed']
eff = app.perform_vlob_read(EVlobRead(vlob_id, read_trust_seed))
vlob = perform_sequence([], eff)
assert vlob['blob'] == blob
def test_api_identity_info():
# Not loaded
eff = execute_cmd('identity_info', {})
sequence = [
(EIdentityGet(), conste(IdentityNotLoadedError())),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok', 'loaded': False, 'id': None}
# Loaded
eff = execute_cmd('identity_info', {})
sequence = [
(EIdentityGet(), const(Identity('JohnDoe', Mock(), Mock()))),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok', 'loaded': True, 'id': 'JohnDoe'}
def test_api_folder_create():
eff = execute_cmd('folder_create', {'path': '/dir'})
sequence = [
(EFolderCreate('/dir'), noop),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok'}
def test_perform_group_create():
eff = perform_group_create(EBackendGroupCreate('teamA'))
backend_response = {'status': 'ok'}
sequence = [(BackendCmd('group_create',
{'name': 'teamA'}), const(backend_response))]
ret = perform_sequence(sequence, eff)
assert ret is None
def test_api_identity_unload():
eff = execute_cmd('identity_unload', {})
sequence = [
(EIdentityUnload(), noop),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok'}
def test_api_undelete():
eff = execute_cmd('undelete', {'vlob': '123'})
sequence = [
(EUndelete('123'), noop),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok'}
def test_api_group_create():
eff = execute_cmd('group_create', {'group': 'share'})
sequence = [
(EGroupCreate('share'), noop),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok'}
def test_api_manifest_history():
summary_history = {
'summary_history': {
'entries': {
'added': {},
'changed': {},
'removed': {}
},
'dustbin': {
'added': [],
'removed': []
},
'versions': {
'added': {},
'changed': {},
'removed': {}
}
}
}
eff = execute_cmd('history', {})
sequence = [
(EManifestHistory(1, None, False), const(summary_history)),
]
resp = perform_sequence(sequence, eff)
summary_history['status'] = 'ok'
assert resp == summary_history
def test_api_file_create():
eff = execute_cmd('file_create', {'path': '/foo'})
sequence = [
(EFileCreate('/foo'), noop),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok'}
def test_api_manifest_restore():
eff = execute_cmd('restore', {})
sequence = [
(EManifestRestore(None), noop),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok'}
def test_catch_parsec_exception():
eff = execute_cmd('subscribe_event', {'event': 'foo', 'sender': 'bar'})
sequence = [
(EClientSubscribeEvent('foo', 'bar'), conste(ParsecError('error', 'msg'))),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'error', 'label': 'msg'}
def test_execute_cmd():
eff = execute_cmd('subscribe_event', {'event': 'foo', 'sender': 'bar'})
sequence = [
(EClientSubscribeEvent('foo', 'bar'), noop)
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok'}
def test_api_move():
eff = execute_cmd('move', {'src': '/foo', 'dst': '/bar'})
sequence = [
(EMove('/foo', '/bar'), noop),
]
resp = perform_sequence(sequence, eff)
assert resp == {'status': 'ok'}
def test_group_create_ok(self):
eff = execute_cmd('group_create', {'name': 'super adventure club'})
sequence = [
(EGroupCreate('super adventure club'), noop)
]
ret = perform_sequence(sequence, eff)
assert ret == {'status': 'ok'}
def test_group_read_unknown(self):
eff = execute_cmd('group_read', {'name': 'dummy-group'})
sequence = [
(EGroupRead('dummy-group'), conste(GroupNotFound('Group not found.')))
]
ret = perform_sequence(sequence, eff)
assert ret['status'] == 'group_not_found'
