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'