def test_all_dbs(self): mock_resp = mock.Mock() mock_resp.raise_for_status = mock.Mock() mock_resp.json = mock.Mock() mock_resp.json.return_value = ['db1', 'db2'] self.mock_instance.get.return_value = mock_resp c = CouchDB(self.username, self.password, url=self.url) c.connect() self.assertEqual(c.all_dbs(), mock_resp.json.return_value) self.assertTrue(mock_resp.raise_for_status.called)
def test_getitem(self): c = CouchDB(self.username, self.password, url=self.url) c.connect() c['a'] = c._DATABASE_CLASS(c, 'a') c['b'] = c._DATABASE_CLASS(c, 'b') self.assertTrue(isinstance(c['a'], c._DATABASE_CLASS)) self.assertTrue(isinstance(c['b'], c._DATABASE_CLASS)) self.assertRaises(KeyError, c.__getitem__, 'd') with mock.patch('cloudant.account.CouchDatabase.exists') as mock_exists: mock_exists.return_value = True self.assertTrue(isinstance(c['c'], c._DATABASE_CLASS))
def setUp(self): """ Set up test attributes for CouchDB Account tests """ self.user = os.environ['COUCHDB_USER'] self.pwd = os.environ['COUCHDB_PASSWORD'] self.url = os.environ['COUCHDB_URL'] self.client = CouchDB(self.user, self.pwd, url=self.url)
def test_db_updates(self): c = CouchDB(self.username, self.password, url=self.url) c.connect() updates_feed = """ {"dbname": "somedb3", "type": "created", "account": "bob", "seq": "3-g1AAAABteJzLYWBgYMxgTmFQSElKzi9KdUhJMtHLTc1NzTcwMNdLzskvTUnMK9HLSy3JAapkSmTIY2H4DwRZGcyJzLlAIfa0tKQUQ2NTIkzIAgD_wSJc"} {"dbname": "somedb2", "type": "updated", "account": "bob", "seq": "4-g1AAAABteJzLYWBgYMxgTmFQSElKzi9KdUhJMtHLTc1NzTcwMNdLzskvTUnMK9HLSy3JAapkSmTIY2H4DwRZGcyJLLlAIfa0tKQUQ2NTIkzIAgAAASJd"} {"dbname": "somedb1", "type": "deleted", "account": "bob", "seq": "9-g1AAAABteJzLYWBgYMxgTmFQSElKzi9KdUhJMtHLTc1NzTcwMNdLzskvTUnMK9HLSy3JAapkSmTIY2H4DwRZGcyJnLlAIfa0tKQUQ2NTIkzIAgAA9iJi"} {"dbname": "somedb2", "type": "created", "account": "bob", "seq": "11-g1AAAABteJzLYWBgYMxgTmFQSElKzi9KdUhJMtHLTc1NzTcwMNdLzskvTUnMK9HLSy3JAapkSmTIY2H4DwRZGcyJ3LlAIfa0tKQUQ2NTIkzIAgABWCJk"} {"dbname": "somedb1", "type": "updated", "account": "bob", "seq": "12-g1AAAABteJzLYWBgYMxgTmFQSElKzi9KdUhJMtHLTc1NzTcwMNdLzskvTUnMK9HLSy3JAapkSmTIY2H4DwRZGcyJPLlAIfa0tKQUQ2NTIkzIAgABiSJl"} """ with mock.patch('cloudant.account.Feed') as mock_feed: feed = (x.strip() for x in updates_feed.split('\n')) mock_feed.__iter__ = mock.MagicMock() mock_feed.return_value = feed updates = [u for u in c.db_updates()] self.assertEqual(len(updates), 5)
def test_get(self): c = CouchDB(self.username, self.password, url=self.url) c.connect() c['a'] = c._DATABASE_CLASS(c, 'a') self.assertEqual(c.get('a'), c['a']) self.assertEqual(c.get('d', None), None) with mock.patch('cloudant.account.CouchDatabase.exists') as mock_exists: mock_exists.return_value = True self.assertTrue(isinstance(c.get('b', remote=True), c._DATABASE_CLASS)) self.assertTrue(c.get('d', None, remote=True) is None)
def test_keys(self): c = CouchDB(self.username, self.password, url=self.url) c.connect() c.all_dbs = mock.Mock() c.all_dbs.return_value = ['db1', 'db2'] self.assertListEqual(list(c.keys()), []) self.assertEqual(c.keys(remote=True), c.all_dbs.return_value)
def test_setitem(self): c = CouchDB(self.username, self.password, url=self.url) c.connect() self.assertRaises(CloudantException, c.__setitem__, 'c', 'womp') value = c._DATABASE_CLASS(c, 'a') c.__setitem__('c', value) self.assertTrue(c['c'] == value) value.exists = mock.Mock() value.exists.return_value = False value.create = mock.Mock() c.__setitem__('c', value, remote=True) self.assertTrue(value.create.called) self.assertTrue(c['c'] == value)
def test_create_delete_methods(self): mock_resp = mock.Mock() mock_resp.json = mock.Mock() mock_resp.json.return_value = {} mock_resp.text = "mock response" mock_resp.status_code = 201 mock_del = mock.Mock() mock_del.status_code = 200 mock_get = mock.Mock() mock_get.status_code = 404 self.mock_instance.put.return_value = mock_resp self.mock_instance.delete.return_value = mock_del self.mock_instance.get.return_value = mock_get # instantiate and connect c = CouchDB(self.username, self.password, url=self.url) c.connect() self.assertTrue(self.mock_session.called) # create db call c.create_database("unittest") self.mock_instance.get.assert_has_calls( [ mock.call('http://127.0.0.1:5984/unittest') ] ) self.mock_instance.put.assert_has_calls( [ mock.call('http://127.0.0.1:5984/unittest') ] ) # delete db call mock_get.reset_mocks() mock_get.status_code = 200 c.delete_database("unittest") self.mock_instance.get.assert_has_calls( [ mock.call('http://127.0.0.1:5984/unittest') ] ) self.mock_instance.delete.assert_has_calls( [ mock.call('http://127.0.0.1:5984/unittest') ] ) # create existing db fails mock_get.reset_mocks() mock_get.status_code = 200 self.assertRaises(CloudantException, c.create_database, "unittest") # delete non-existing db fails mock_get.reset_mocks() mock_get.status_code = 404 self.assertRaises(CloudantException, c.delete_database, "unittest")
def test_delitem(self): c = CouchDB(self.username, self.password, url=self.url) c.connect() c.delete_database = mock.Mock() c['a'] = c._DATABASE_CLASS(c, 'a') c['b'] = c._DATABASE_CLASS(c, 'b') del c['a'] self.assertTrue('b' in c) self.assertTrue('a' not in c) c.__delitem__('b', remote=True) self.assertTrue(c.delete_database.called)
def test_session_calls(self): """test session related methods""" c = CouchDB(self.username, self.password, url=self.url) c.connect() self.assertTrue(self.mock_session.called) self.assertEqual( self.mock_instance.auth, (self.username, self.password) ) self.assertEqual( self.mock_instance.headers, {} ) self.assertEqual('COOKIE', c.session_cookie()) self.assertTrue(self.mock_instance.get.called) self.mock_instance.get.assert_has_calls( [ mock.call('http://127.0.0.1:5984/_session') ] ) self.assertTrue(self.mock_instance.post.called) self.mock_instance.post.assert_has_calls( [ mock.call( 'http://127.0.0.1:5984/_session', headers={'Content-Type': 'application/x-www-form-urlencoded'}, data={'password': '******', 'name': 'steve'} ) ] ) c.disconnect() self.assertTrue(self.mock_instance.delete.called) self.mock_instance.delete.assert_has_calls( [ mock.call('http://127.0.0.1:5984/_session') ] )
def test_basic_auth_str(self): c = CouchDB(self.username, self.password, url=self.url) auth_str = c.basic_auth_str() self.assertTrue(auth_str.startswith("Basic")) self.assertFalse(auth_str.endswith("Basic ")) self.assertFalse(auth_str.endswith("Basic"))
class CouchDBAccountTests(unittest.TestCase): """ CouchDB Class unit tests """ @classmethod def setUpClass(self): """ Set up CouchDB instance to be used by all tests If no user is specified then, assuming Admin Party and we need to create a user to run the CouchDB tests. Note: Admin Party is currently unsupported. """ if os.environ.get('COUCHDB_URL') is None: os.environ['COUCHDB_URL'] = 'http://127.0.0.1:5984' if os.environ.get('COUCHDB_USER') is None: os.environ['COUCHDB_USER_CREATED'] = '1' os.environ['COUCHDB_USER'] = '******'.format( unicode(uuid.uuid4()) ) os.environ['COUCHDB_PASSWORD'] = '******' resp = requests.put( '{0}/_config/admins/{1}'.format( os.environ['COUCHDB_URL'], os.environ['COUCHDB_USER'] ), data='"{0}"'.format(os.environ['COUCHDB_PASSWORD']) ) resp.raise_for_status() @classmethod def tearDownClass(self): """ Clean up CouchDB instance once all tests are complete """ if os.environ.get('COUCHDB_USER_CREATED') is not None: resp = requests.delete( '{0}://{1}:{2}@{3}/_config/admins/{4}'.format( os.environ['COUCHDB_URL'].split('://', 1)[0], os.environ['COUCHDB_USER'], os.environ['COUCHDB_PASSWORD'], os.environ['COUCHDB_URL'].split('://', 1)[1], os.environ['COUCHDB_USER'] ) ) resp.raise_for_status() def setUp(self): """ Set up test attributes for CouchDB Account tests """ self.user = os.environ['COUCHDB_USER'] self.pwd = os.environ['COUCHDB_PASSWORD'] self.url = os.environ['COUCHDB_URL'] self.client = CouchDB(self.user, self.pwd, url=self.url) def tearDown(self): """ Ensure the client is new for each test """ del self.client def dbname(self, database_name='account-unit-test-db'): return '{0}-{1}'.format(database_name, unicode(uuid.uuid4())) def test_constructor_with_url(self): """ Test instantiating an account object using a URL """ self.assertEqual( self.client.cloudant_url, self.url ) self.assertEqual(self.client.encoder, json.JSONEncoder) self.assertIsNone(self.client.r_session) def test_connect(self): """ Test connect and disconnect functionality """ try: self.client.connect() self.assertIsInstance(self.client.r_session, requests.Session) self.assertEqual(self.client.r_session.auth, (self.user, self.pwd)) finally: self.client.disconnect() self.assertIsNone(self.client.r_session) def test_session(self): """ Test getting session information """ try: self.client.connect() session = self.client.session() self.assertEqual(session['userCtx']['name'], self.user) finally: self.client.disconnect() def test_session_cookie(self): """ Test getting the session cookie """ try: self.client.connect() self.assertIsNotNone(self.client.session_cookie()) finally: self.client.disconnect() def test_basic_auth_str(self): """ Test getting the basic authentication string """ try: self.client.connect() expected = 'Basic {0}'.format( base64.urlsafe_b64encode("{0}:{1}".format(self.user, self.pwd)) ) self.assertEqual( self.client.basic_auth_str(), expected ) finally: self.client.disconnect() def test_all_dbs(self): """ Test getting a list of all of the databases in the account """ dbnames = [] for _ in range(3): dbnames.append(self.dbname()) try: self.client.connect() for dbname in dbnames: self.client.create_database(dbname) self.assertTrue(set(dbnames).issubset(self.client.all_dbs())) finally: for dbname in dbnames: self.client.delete_database(dbname) self.client.disconnect() def test_create_delete_database(self): """ Test database creation and deletion """ try: self.client.connect() dbname = self.dbname() # Create database db = self.client.create_database(dbname) self.assertTrue(db.exists()) # Delete database self.assertIsNone(self.client.delete_database(dbname)) self.assertFalse(db.exists()) finally: self.client.disconnect() def test_create_existing_database(self): """ Test creation of already existing database """ dbname = self.dbname() try: self.client.connect() self.client.create_database(dbname) self.client.create_database(dbname, throw_on_exists=True) self.fail('Above statement should raise a CloudantException') except CloudantException, err: self.assertEqual( str(err), 'Database {0} already exists'.format(dbname) ) finally: