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()
