def setUp(self):
super(TestCaseWithDB, self).setUp()
self.working_dir = self.createTempDir()
self.db_path = self.working_dir + '/test.db'
self.db = u1db_open(self.db_path, create=True)
self.db._set_replica_uid('test')
self.addCleanup(self.db.close)
def run(self, source, target):
"""Start a Sync request."""
source_db = u1db_open(source, create=False)
st = self._open_target(target)
syncer = sync.Synchronizer(source_db, st)
syncer.sync()
source_db.close()
def run(self, source, target):
"""Start a Sync request."""
source_db = u1db_open(source, create=False)
st = self._open_target(target)
syncer = sync.Synchronizer(source_db, st)
syncer.sync()
source_db.close()
def test_init_no_uid(self):
path = self.working_dir + '/test2.db'
cmd = self.make_command(client.CmdInitDB)
cmd.run(path, None)
self.assertTrue(os.path.exists(path))
db = u1db_open(path, create=False)
self.assertIsNot(None, db._replica_uid)
def test_init_no_uid(self):
path = self.working_dir + '/test2.db'
cmd = self.make_command(client.CmdInitDB)
cmd.run(path, None)
self.assertTrue(os.path.exists(path))
db = u1db_open(path, create=False)
self.assertIsNot(None, db._replica_uid)
def setUp(self):
super(TestCaseWithDB, self).setUp()
self.working_dir = self.createTempDir()
self.db_path = self.working_dir + '/test.db'
self.db = u1db_open(self.db_path, create=True)
self.db._set_replica_uid('test')
self.addCleanup(self.db.close)
def test_init_new(self):
path = self.working_dir + '/test2.db'
self.assertFalse(os.path.exists(path))
cmd = self.make_command(client.CmdInitDB)
cmd.run(path, 'test-uid')
self.assertTrue(os.path.exists(path))
db = u1db_open(path, create=False)
self.assertEqual('test-uid', db._replica_uid)
def setUp(self):
super(TestCmdSync, self).setUp()
self.db2_path = self.working_dir + '/test2.db'
self.db2 = u1db_open(self.db2_path, create=True)
self.addCleanup(self.db2.close)
self.db2._set_replica_uid('test2')
self.doc = self.db.create_doc(tests.simple_doc, doc_id='test-id')
self.doc2 = self.db2.create_doc(tests.nested_doc, doc_id='my-test-id')
def _open_target(self, target):
if target.startswith(('http://', 'https://')):
st = http_target.HTTPSyncTarget.connect(target)
set_oauth_credentials(st)
else:
db = u1db_open(target, create=True)
st = db.get_sync_target()
return st
def test_init_new(self):
path = self.working_dir + '/test2.db'
self.assertFalse(os.path.exists(path))
cmd = self.make_command(client.CmdInitDB)
cmd.run(path, 'test-uid')
self.assertTrue(os.path.exists(path))
db = u1db_open(path, create=False)
self.assertEqual('test-uid', db._replica_uid)
def setUp(self):
super(TestCmdSync, self).setUp()
self.db2_path = self.working_dir + '/test2.db'
self.db2 = u1db_open(self.db2_path, create=True)
self.addCleanup(self.db2.close)
self.db2._set_replica_uid('test2')
self.doc = self.db.create_doc(tests.simple_doc, doc_id='test-id')
self.doc2 = self.db2.create_doc(tests.nested_doc, doc_id='my-test-id')
def _open_target(self, target):
if target.startswith(('http://', 'https://')):
st = http_target.HTTPSyncTarget.connect(target)
set_oauth_credentials(st)
else:
db = u1db_open(target, create=True)
st = db.get_sync_target()
return st
def _open(self, database, create):
if database.startswith(('http://', 'https://')):
db = http_database.HTTPDatabase(database)
set_oauth_credentials(db)
db.open(create)
return db
else:
return u1db_open(database, create)
def _open(self, database, create):
if database.startswith(('http://', 'https://')):
db = http_database.HTTPDatabase(database)
set_oauth_credentials(db)
db.open(create)
return db
else:
return u1db_open(database, create)
def test_open_existing(self):
db = sqlite_backend.SQLitePartialExpandDatabase(self.db_path)
self.addCleanup(db.close)
doc = db.create_doc_from_json(tests.simple_doc)
# Even though create=True, we shouldn't wipe the db
db2 = u1db_open(self.db_path, create=True)
self.addCleanup(db2.close)
doc2 = db2.get_doc(doc.doc_id)
self.assertEqual(doc, doc2)
def test_open_existing(self):
db = sqlite_backend.SQLitePartialExpandDatabase(self.db_path)
self.addCleanup(db.close)
doc = db.create_doc_from_json(tests.simple_doc)
# Even though create=True, we shouldn't wipe the db
db2 = u1db_open(self.db_path, create=True)
self.addCleanup(db2.close)
doc2 = db2.get_doc(doc.doc_id)
self.assertEqual(doc, doc2)
def test_sync(self):
doc = self.db.create_doc_from_json(tests.simple_doc, doc_id='test-id')
self.db2_path = self.working_dir + '/test2.db'
self.db2 = u1db_open(self.db2_path, create=True)
self.addCleanup(self.db2.close)
ret, stdout, stderr = self.run_main(
['sync', self.db_path, self.db2_path])
self.assertEqual(0, ret)
self.assertEqual('', stdout)
self.assertEqual('', stderr)
self.assertGetDoc(
self.db2, 'test-id', doc.rev, tests.simple_doc, False)
def test_sync(self):
doc = self.db.create_doc_from_json(tests.simple_doc, doc_id='test-id')
self.db2_path = self.working_dir + '/test2.db'
self.db2 = u1db_open(self.db2_path, create=True)
self.addCleanup(self.db2.close)
ret, stdout, stderr = self.run_main(
['sync', self.db_path, self.db2_path])
self.assertEqual(0, ret)
self.assertEqual('', stdout)
self.assertEqual('', stderr)
self.assertGetDoc(self.db2, 'test-id', doc.rev, tests.simple_doc,
False)
def test_supply_working_dir(self):
tmp_dir = self.createTempDir('u1db-serve-test')
db = u1db_open(os.path.join(tmp_dir, 'landmark.db'), create=True)
db.close()
p = self.startU1DBServe(['--working-dir', tmp_dir])
starts = 'listening on:'
x = p.stdout.readline()
self.assertTrue(x.startswith(starts))
port = int(x[len(starts):].split(":")[1])
url = "http://127.0.0.1:%s/landmark.db" % port
c = http_client.HTTPClientBase(url)
self.addCleanup(c.close)
res, _ = c._request_json('GET', [])
self.assertEqual({}, res)
def test_create_get_put_delete(self):
db = u1db_open(self.getPath('test.db'), create=True)
url = self.getURL('test.db')
doc_id = '%abcd'
ret, stdout, stderr = self.run_main(['create', url, '--id', doc_id],
stdin=tests.simple_doc)
self.assertEqual(0, ret)
ret, stdout, stderr = self.run_main(['get', url, doc_id])
self.assertEqual(0, ret)
self.assertTrue(stderr.startswith('rev: '))
doc_rev = stderr[len('rev: '):].rstrip()
ret, stdout, stderr = self.run_main(['put', url, doc_id, doc_rev],
stdin=tests.nested_doc)
self.assertEqual(0, ret)
self.assertTrue(stderr.startswith('rev: '))
doc_rev1 = stderr[len('rev: '):].rstrip()
self.assertGetDoc(db, doc_id, doc_rev1, tests.nested_doc, False)
ret, stdout, stderr = self.run_main(['delete', url, doc_id, doc_rev1])
self.assertEqual(0, ret)
self.assertTrue(stderr.startswith('rev: '))
doc_rev2 = stderr[len('rev: '):].rstrip()
self.assertGetDocIncludeDeleted(db, doc_id, doc_rev2, None, False)
def test_create_get_put_delete(self):
db = u1db_open(self.getPath('test.db'), create=True)
url = self.getURL('test.db')
doc_id = '%abcd'
ret, stdout, stderr = self.run_main(['create', url, '--id', doc_id],
stdin=tests.simple_doc)
self.assertEqual(0, ret)
ret, stdout, stderr = self.run_main(['get', url, doc_id])
self.assertEqual(0, ret)
self.assertTrue(stderr.startswith('rev: '))
doc_rev = stderr[len('rev: '):].rstrip()
ret, stdout, stderr = self.run_main(['put', url, doc_id, doc_rev],
stdin=tests.nested_doc)
self.assertEqual(0, ret)
self.assertTrue(stderr.startswith('rev: '))
doc_rev1 = stderr[len('rev: '):].rstrip()
self.assertGetDoc(db, doc_id, doc_rev1, tests.nested_doc, False)
ret, stdout, stderr = self.run_main(['delete', url, doc_id, doc_rev1])
self.assertEqual(0, ret)
self.assertTrue(stderr.startswith('rev: '))
doc_rev2 = stderr[len('rev: '):].rstrip()
self.assertGetDocIncludeDeleted(db, doc_id, doc_rev2, None, False)
def test_init_db(self):
path = self.working_dir + '/test2.db'
ret, stdout, stderr = self.run_main(['init-db', path])
u1db_open(path, create=False)
def test_init_db(self):
path = self.working_dir + '/test2.db'
ret, stdout, stderr = self.run_main(['init-db', path])
u1db_open(path, create=False)
def test_init_db(self):
url = self.getURL('new.db')
ret, stdout, stderr = self.run_main(['init-db', url])
u1db_open(self.getPath('new.db'), create=False)
def test_open_create(self):
db = u1db_open(self.db_path, create=True)
self.addCleanup(db.close)
self.assertTrue(os.path.exists(self.db_path))
self.assertIsInstance(db, sqlite_backend.SQLiteDatabase)
def test_open_with_factory(self):
db = u1db_open(self.db_path, create=True,
document_factory=TestAlternativeDocument)
self.addCleanup(db.close)
self.assertEqual(TestAlternativeDocument, db._factory)
def test_init_db(self):
url = self.getURL('new.db')
ret, stdout, stderr = self.run_main(['init-db', url])
u1db_open(self.getPath('new.db'), create=False)
def test_open_existing_no_create(self):
db = sqlite_backend.SQLitePartialExpandDatabase(self.db_path)
self.addCleanup(db.close)
db2 = u1db_open(self.db_path, create=False)
self.addCleanup(db2.close)
self.assertIsInstance(db2, sqlite_backend.SQLitePartialExpandDatabase)
def test_open_create(self):
db = u1db_open(self.db_path, create=True)
self.addCleanup(db.close)
self.assertTrue(os.path.exists(self.db_path))
self.assertIsInstance(db, sqlite_backend.SQLiteDatabase)
def test_open_with_factory(self):
db = u1db_open(self.db_path,
create=True,
document_factory=TestAlternativeDocument)
self.addCleanup(db.close)
self.assertEqual(TestAlternativeDocument, db._factory)
def test_open_existing_no_create(self):
db = sqlite_backend.SQLitePartialExpandDatabase(self.db_path)
self.addCleanup(db.close)
db2 = u1db_open(self.db_path, create=False)
self.addCleanup(db2.close)
self.assertIsInstance(db2, sqlite_backend.SQLitePartialExpandDatabase)
def _landmark_db(self, name):
db = u1db_open(os.path.join(self.tmp_dir, name), create=True)
db.close()
