def test_continuous_changes_feed(baseurl, ioloop): def do_test(db): runs = [] def _got_change(change): runs.append(True) change['changes'][0].pop('rev') if len(runs) == 1: # First change eq(change, {'seq': 1, 'id': 'mydoc', 'changes': [{}]}) elif len(runs) == 2: # Second change eq(change, {'seq': 2, 'id': 'second_doc', 'changes': [{}]}) # Create another document db.set('third_doc', {'still': 'more'}, lambda x: None) elif len(runs) == 3: eq(change, {'seq': 3, 'id': 'third_doc', 'changes': [{}]}) ioloop.stop() def doc_created(response): assert not response.error db.changes(_got_change, feed='continuous') # Create another document db.set('second_doc', {'more': 'data'}, lambda x: None) db.set('mydoc', {'some': 'data'}, doc_created) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_long_polling_before_doc_created(baseurl, ioloop): changes = [] def do_test(db): def _got_change(change): changes.append(change.content) ioloop.stop() def doc_created(response): assert not response.error db.changes(_got_change, feed='longpoll', timeout=2) db.set('mydoc', {'some': 'data'}, doc_created) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start() changes[0]['results'][0]['changes'][0].pop('rev') eq(changes[0], { 'last_seq': 1, 'results': [{ 'changes': [{}], 'id': 'mydoc', 'seq': 1 }] })
def test_view_results_include_docs(baseurl, ioloop): def do_test(db): def create_view_callback(response): eq(response.code, 201) db.set({'data': 'data'}, create_first_doc_cb) def create_first_doc_cb(response): db.set({'another': 'data'}, create_docs_cb) def create_docs_cb(doc): db.view('testview', 'all', load_view_cb, include_docs=True) def load_view_cb(result): eq(result.error, False) eq(len(result), 2) eq(result.total_rows, 2) assert all(isinstance(x['doc'], trombi.Document) for x in result) ioloop.stop() db.server._fetch('%stestdb/_design/testview' % baseurl, create_view_callback, method='PUT', body=json.dumps({ 'language': 'javascript', 'views': { 'all': { 'map': '(function (doc) { emit(null, doc) })', } } })) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_bulk_mixed(baseurl, ioloop): def do_test(db): def bulks_cb(response): datas = [dict(response[0])] datas[0]['_deleted'] = True db.bulk_docs(datas, bulks_delete_cb) def bulks_delete_cb(response): eq(response.error, False) eq(len(response), 1) assert all(isinstance(x, trombi.BulkObject) for x in response) ioloop.stop() datas = [ { 'key1': 'data1' }, { 'key2': 'data2' }, ] db.bulk_docs(datas, bulks_cb) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_get_document_with_attachments(baseurl, ioloop): def do_test(db): def create_doc_callback(doc): db.get(doc.id, callback=get_doc_callback, attachments=True) def get_doc_callback(doc): assert isinstance(doc, trombi.Document) assert doc.id assert doc.rev eq(doc['testvalue'], 'something') def _assert_on_fetch(*a, **kw): assert False, 'Fetch detected, failing test!' doc.db._fetch = _assert_on_fetch doc.load_attachment('foo', got_attachment) def got_attachment(data): eq(data, b'bar') ioloop.stop() db.set({'testvalue': 'something'}, create_doc_callback, attachments={'foo': (None, b'bar')}) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_set_document_change_id(baseurl, ioloop): def do_test(db): def update_doc(doc): doc['newvalue'] = 'somethingelse' db.set('otherid', doc, doc_updated) def doc_updated(doc): eq(doc, { 'testvalue': 'something', 'newvalue': 'somethingelse', }) eq(doc.id, 'otherid') # Check that the original didn't change db.get('testid', check_original) def check_original(doc): eq(doc, {'testvalue': 'something'}) eq(doc.id, 'testid') ioloop.stop() db.set('testid', {'testvalue': 'something'}, update_doc) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', do_test) ioloop.start()
def test_load_view_empty_results(baseurl, ioloop): def do_test(db): def create_view_callback(response): eq(response.code, 201) db.view('testview', 'all', load_view_cb) def load_view_cb(result): assert isinstance(result, trombi.ViewResult) eq(result.error, False) eq(len(result), 0) ioloop.stop() db.server._fetch('%stestdb/_design/testview' % baseurl, create_view_callback, method='PUT', body=json.dumps({ 'language': 'javascript', 'views': { 'all': { 'map': 'function (doc) { emit(null, doc) }', } } })) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_delete_attachment(baseurl, ioloop): def create_db_callback(db): db.set( 'testid', {'testvalue': 'something'}, create_doc_callback, ) def create_doc_callback(doc): data = b'some textual data' doc.attach('foobar', data, callback=attach_callback) def attach_callback(doc): doc.delete_attachment('foobar', callback=delete_callback) def delete_callback(doc): try: urlopen('%stestdb/testid/foobar' % baseurl) except HTTPError: # Python 3 e = sys.exc_info()[1] eq(e.code, 404) else: assert 0 ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=create_db_callback) ioloop.start()
def test_load_view_no_such_view(baseurl, ioloop): def do_test(db): def create_view_callback(useless): db.view('testview', 'all', load_view_cb) def load_view_cb(result): eq(result.error, True) eq(result.errno, trombi.errors.NOT_FOUND) eq(result.msg, 'missing_named_view') ioloop.stop() db.server._fetch( '%stestdb/_design/testview' % baseurl, create_view_callback, method='PUT', body=json.dumps({ 'language': 'javascript', 'views': { 'foobar': { 'map': '(function (doc) { emit(doc.data, doc) })', 'reduce': '(function (key, value) { return \ value.length })', } } })) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_delete_document(baseurl, ioloop): def do_test(db): def create_doc_callback(doc): eq(db.error, False) db.delete(doc, callback=delete_doc_callback) def delete_doc_callback(db): eq(db.error, False) assert isinstance(db, trombi.Database) try: urlopen('%stestdb/testid' % baseurl) except HTTPError: # Python 3 e = sys.exc_info()[1] eq(e.code, 404) else: assert 0 ioloop.stop() db.set( 'testid', {'testvalue': 'something'}, create_doc_callback, ) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_load_view_with_results(baseurl, ioloop): def do_test(db): def create_view_callback(response): eq(response.code, 201) db.set({'data': 'data'}, create_doc_cb) def create_doc_cb(doc): db.view('testview', 'all', load_view_cb) def load_view_cb(result): eq(result.error, False) eq(len(result), 1) del result[0]['value']['_rev'] del result[0]['value']['_id'] del result[0]['id'] eq(list(result), [{'value': {'data': 'data'}, 'key': None}]) ioloop.stop() db.server._fetch('%stestdb/_design/testview' % baseurl, create_view_callback, method='PUT', body=json.dumps({ 'language': 'javascript', 'views': { 'all': { 'map': '(function (doc) { emit(null, doc) })', } } })) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_load_view_with_keys(baseurl, ioloop): def do_test(db): def create_view_callback(response): eq(response.code, 201) db.set({'data': 'data'}, create_1st_doc_cb) def create_1st_doc_cb(doc): db.set({'data': 'other'}, create_2nd_doc_cb) def create_2nd_doc_cb(doc): db.view('testview', 'all', load_view_cb, keys=['data']) def load_view_cb(result): eq(result.error, False) eq(len(result), 1) eq(result[0]['key'], 'data') ioloop.stop() db.server._fetch( '%stestdb/_design/testview' % baseurl, create_view_callback, method='PUT', body=json.dumps({ 'language': 'javascript', 'views': { 'all': { 'map': '(function (doc) { emit(doc.data, doc) })', } } })) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_view_results_with_offset(baseurl, ioloop): def do_test(db): def create_view_callback(response): eq(response.code, 201) db.set({'data': 'data'}, create_first_doc_cb) def create_first_doc_cb(response): db.set({'another': 'data'}, create_docs_cb) def create_docs_cb(doc): db.view('testview', 'all', load_view_cb, skip=1) def load_view_cb(result): eq(result.error, False) eq(len(result), 1) eq(result.total_rows, 2) eq(result.offset, 1) ioloop.stop() db.server._fetch('%stestdb/_design/testview' % baseurl, create_view_callback, method='PUT', body=json.dumps({ 'language': 'javascript', 'views': { 'all': { 'map': 'function (doc) { emit(null, doc) }', } } })) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_update_user(baseurl, ioloop): s = trombi.Server(baseurl, io_loop=ioloop) userdoc = [] def add_callback(doc): assert not doc.error userdoc.append(doc) ioloop.stop() s.add_user('updatetest', 'test', add_callback) ioloop.start() def update_callback(doc): assert not doc.error userdoc.append(doc) ioloop.stop() userdoc[0]['roles'].append('test') s.update_user(userdoc[0], update_callback) ioloop.start() eq(userdoc[1]['roles'], ['test']) def update_passwd_callback(doc): assert not doc.error userdoc.append(doc) ioloop.stop() s.update_user_password('updatetest', 'test2', update_passwd_callback) ioloop.start() eq(userdoc[1]['salt'], userdoc[2]['salt']) eq(userdoc[1]['password_sha'] != userdoc[2]['password_sha'], True)
def test_create_document_custom_id(baseurl, ioloop): def do_test(db): def create_doc_callback(doc): eq(doc.error, False) assert isinstance(doc, trombi.Document) eq(doc.id, 'testid') assert '_id' not in doc assert '_rev' not in doc assert doc.rev eq(doc['testvalue'], 'something') f = urlopen('%stestdb/testid' % baseurl) data = f.read().decode('utf-8') eq(json.loads(data), { '_id': 'testid', '_rev': doc.rev, 'testvalue': 'something', }) ioloop.stop() db.set( 'testid', {'testvalue': 'something'}, create_doc_callback, ) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=do_test) ioloop.start()
def test_get_create_doesnt_yet_exist(baseurl, ioloop): def callback(db): eq(db.error, False) eq(db.name, 'nonexistent') ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) s.get('nonexistent', create=True, callback=callback) ioloop.start()
def test_add_user(baseurl, ioloop): s = trombi.Server(baseurl, io_loop=ioloop) def callback(doc): assert not doc.error ioloop.stop() s.add_user('test', 'test', callback) ioloop.start()
def test_invalid_db_name(baseurl, ioloop): def callback(result): eq(result.error, True) eq(result.errno, trombi.errors.INVALID_DATABASE_NAME) eq(result.msg, "Invalid database name: 'this name is invalid'") ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) s.create('this name is invalid', callback=callback) ioloop.start()
def test_session_api_with_wrong_credentials(baseurl, ioloop): s = trombi.Server(baseurl, io_loop=ioloop) def session_callback(response): assert response.error eq(response.msg, 'Name or password is incorrect.') ioloop.stop() s.login(username="******", password="******", callback=session_callback) ioloop.start()
def test_set_document_with_kw_callback(baseurl, ioloop): def do_test(db): def update_doc(doc): ioloop.stop() db.set('testid', {'testvalue': 'something'}, callback=update_doc) s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', do_test) ioloop.start()
def test_delete_db_not_exists(baseurl, ioloop): def callback(result): eq(result.error, True) eq(result.errno, trombi.errors.NOT_FOUND) eq(result.msg, "Database does not exist: 'testdatabase'") ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) s.delete('testdatabase', callback=callback) ioloop.start()
def test_cannot_connect(ioloop): def create_callback(db): eq(db.error, True) eq(db.errno, 599) eq(db.msg, 'Unable to connect to CouchDB') ioloop.stop() s = trombi.Server('http://localhost:39998', io_loop=ioloop) s.create('couchdb-database', callback=create_callback) ioloop.start()
def test_temporary_view_no_such_db(baseurl, ioloop): def view_results(result): eq(result.error, True) eq(result.errno, trombi.errors.NOT_FOUND) eq(result.msg, 'no_db_file') ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) db = trombi.Database(s, 'doesnotexist') db.temporary_view(view_results, '(function() { emit(null);})') ioloop.start()
def test_create_db(baseurl, ioloop): def create_callback(db): eq(db.error, False) assert isinstance(db, trombi.Database) f = urlopen('%s_all_dbs' % baseurl) assert 'couchdb-database' in json.loads(f.read().decode('utf-8')) ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) s.create('couchdb-database', callback=create_callback) ioloop.start()
def test_get_document_does_not_exist(baseurl, ioloop): def create_db_callback(db): db.get('foo', callback=get_callback) def get_callback(doc): eq(doc, None) ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=create_db_callback) ioloop.start()
def test_open_nonexisting_database(baseurl, ioloop): s = trombi.Server(baseurl, io_loop=ioloop) def callback(result): eq(result.error, True) eq(result.errno, trombi.errors.NOT_FOUND) eq(result.msg, "Database not found: testdb1") ioloop.stop() s.get('testdb1', callback=callback) ioloop.start()
def test_open_database_bad_name(baseurl, ioloop): s = trombi.Server(baseurl, io_loop=ioloop) def callback(result): eq(result.error, True) eq(result.errno, trombi.errors.INVALID_DATABASE_NAME) eq(result.msg, "Invalid database name: 'not a valid name'") ioloop.stop() s.get('not a valid name', callback=callback) ioloop.start()
def test_load_view_no_design_doc(baseurl, ioloop): def create_db_callback(db): def load_view_cb(result): eq(result.error, True) eq(result.errno, trombi.errors.NOT_FOUND) eq(result.msg, 'missing') ioloop.stop() db.view('testview', 'all', load_view_cb, group='true') s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=create_db_callback) ioloop.start()
def test_temporary_view_empty_results(baseurl, ioloop): def create_db_callback(db): db.temporary_view(view_results, 'function(doc) { emit(null, doc); }') def view_results(result): assert isinstance(result, trombi.ViewResult) eq(result.error, False) eq(list(result), []) ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) s.create('testdb', callback=create_db_callback) ioloop.start()
def test_get_create_already_exists(baseurl, ioloop): def create_callback(db): eq(db.name, 'new') s.get('new', create=True, callback=get_callback) def get_callback(db): eq(db.error, False) eq(db.name, 'new') ioloop.stop() s = trombi.Server(baseurl, io_loop=ioloop) s.create('new', callback=create_callback) ioloop.start()