def test_create_database_cps(self): client = AsyncfluxClient() db_name = 'foo' # Using a string with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 201) client.create_database(db_name, callback=self.stop_op) response = self.wait() self.assertIsInstance(response, Database) self.assertEqual(response.name, db_name) self.assert_mock_args(m, '/db', method='POST', body=json.dumps({'name': db_name})) # Existing database response_body = 'database %s exists' % db_name with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 409, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): client.create_database(db_name, callback=self.stop_op) response = self.wait() self.assertEqual(response, response_body) self.assert_mock_args(m, '/db', method='POST', body=json.dumps({'name': db_name}))
def test_authenticate_cluster_admin(self): client = AsyncfluxClient() username = '******' password = '******' with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield client.authenticate_cluster_admin(username, password) self.assertTrue(response) self.assert_mock_args(m, '/cluster_admins/authenticate', auth_username=username, auth_password=password) # Invalid credentials response_body = 'Invalid username/password' with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 401, body=response_body) response = yield client.authenticate_cluster_admin(username, password) self.assertFalse(response) self.assert_mock_args(m, '/cluster_admins/authenticate', auth_username=username, auth_password=password)
def test_get_shard_spaces(self): client = AsyncfluxClient() shard_spaces = [{'name': 'default', 'database': 'foo', 'regex': '/.*/', 'retentionPolicy': 'inf', 'shardDuration': '7d', 'replicationFactor': 1, 'split': 1}, {'name': 'second', 'database': 'bar', 'regex': '/.*/', 'retentionPolicy': '365d', 'shardDuration': '15m', 'replicationFactor': 5, 'split': 5}, {'name': 'default', 'database': 'bar', 'regex': '/.*/', 'retentionPolicy': 'inf', 'shardDuration': '7d', 'replicationFactor': 1, 'split': 1}] with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200, body=shard_spaces) response = yield client.get_shard_spaces() for actual, expected in zip(response, shard_spaces): self.assertIsInstance(actual, ShardSpace) self.assertEqual(actual.client, client) self.assertEqual(actual.name, expected['name']) self.assertIsInstance(actual.database, Database) self.assertEqual(actual.database.name, expected['database']) self.assertEqual(actual.regex, expected['regex']) self.assertEqual(actual.retention_policy, expected['retentionPolicy']) self.assertEqual(actual.shard_duration, expected['shardDuration']) self.assertEqual(actual.replication_factor, expected['replicationFactor']) self.assertEqual(actual.split, expected['split']) self.assert_mock_args(m, '/cluster/shard_spaces')
def test_credential_properties_setters(self): client = AsyncfluxClient(username='******', password='******') username = '******' password = '******' client.username = username client.password = password self.assertEqual(client.username, username) self.assertEqual(client.password, password)
def test_ping(self): client = AsyncfluxClient() response_body = {'status': 'ok'} with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200, body=response_body) response = yield client.ping() self.assertEqual(response, response_body) self.assert_mock_args(m, '/ping')
def test_get_database_names(self): client = AsyncfluxClient() databases = [{'name': 'foo'}, {'name': 'bar'}] db_names = [db['name'] for db in databases] with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200, body=databases) response = yield client.get_database_names() self.assertEqual(response, db_names) self.assert_mock_args(m, '/db')
def test_get_cluster_admin_names(self): client = AsyncfluxClient() admins = [{'name': 'foo'}, {'name': 'bar'}] admin_names = [a['name'] for a in admins] with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200, body=admins) response = yield client.get_cluster_admin_names() self.assertListEqual(response, admin_names) self.assert_mock_args(m, '/cluster_admins')
def test_get_cluster_admins(self): client = AsyncfluxClient() admins = [{'name': 'foo'}, {'name': 'bar'}] admin_names = [a['name'] for a in admins] with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200, body=admins) response = yield client.get_cluster_admins() self.assertEqual(len(response), len(admin_names)) for r in response: self.assertIsInstance(r, ClusterAdmin) self.assertIn(r.name, admin_names) self.assert_mock_args(m, '/cluster_admins')
def test_create_database(self): client = AsyncfluxClient() db_name = 'foo' # Using a string with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 201) response = yield client.create_database(db_name) self.assertIsInstance(response, Database) self.assertEqual(response.name, db_name) self.assert_mock_args(m, '/db', method='POST', body=json.dumps({'name': db_name})) # Using an instance of Database db = Database(client, db_name) with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 201) response = yield client.create_database(db) self.assertIsInstance(response, Database) self.assertEqual(response.name, db_name) self.assert_mock_args(m, '/db', method='POST', body=json.dumps({'name': db_name})) # Using an unsupported type with self.patch_fetch_mock(client) as m: re_exc_msg = r'^name_or_database must be an instance' with self.assertRaisesRegexp(TypeError, re_exc_msg): yield client.create_database(None) self.assertFalse(m.called) # Existing database response_body = 'database %s exists' % db_name with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 409, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): response = yield client.create_database(db_name) self.assertEqual(response, response_body) self.assert_mock_args(m, '/db', method='POST', body=json.dumps({'name': db_name}))
def test_delete_cluster_admin(self): client = AsyncfluxClient() username = '******' with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield client.delete_cluster_admin(username) self.assertIsNone(response) self.assert_mock_args(m, '/cluster_admins/%s' % username, method='DELETE') # Non-existing cluster admin response_body = "User %s doesn't exists" % username with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield client.delete_cluster_admin(username) self.assert_mock_args(m, '/cluster_admins/%s' % username, method='DELETE')
def test_change_cluster_admin_password(self): client = AsyncfluxClient() username = '******' password = '******' with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield client.change_cluster_admin_password(username, password) self.assertIsNone(response) self.assert_mock_args(m, '/cluster_admins/%s' % username, method='POST', body=json.dumps({'password': password})) # Non-existing cluster admin response_body = 'Invalid user name %s' % username with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield client.change_cluster_admin_password(username, password) self.assert_mock_args(m, '/cluster_admins/%s' % username, method='POST', body=json.dumps({'password': password})) # Invalid password password = '******' response_body = ('Password must be more than 4 and less than 56 ' 'characters') with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield client.change_cluster_admin_password(username, password) self.assert_mock_args(m, '/cluster_admins/%s' % username, method='POST', body=json.dumps({'password': password}))
def test_create_cluster_admin(self): client = AsyncfluxClient() username = '******' password = '******' with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield client.create_cluster_admin(username, password) self.assertIsInstance(response, ClusterAdmin) self.assertEqual(response.name, username) self.assert_mock_args(m, '/cluster_admins', method='POST', body=json.dumps({'name': username, 'password': password})) # Existing cluster admin response_body = 'User %s already exists' % username with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield client.create_cluster_admin(username, password) self.assert_mock_args(m, '/cluster_admins', method='POST', body=json.dumps({'name': username, 'password': password})) # Invalid password password = '******' response_body = ('Password must be more than 4 and less than 56 ' 'characters') with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield client.create_cluster_admin(username, password) self.assert_mock_args(m, '/cluster_admins', method='POST', body=json.dumps({'name': username, 'password': password}))
def test_delete_database(self): client = AsyncfluxClient() db_name = 'foo' # Using a string with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 204) response = yield client.delete_database(db_name) self.assertIsNone(response) self.assert_mock_args(m, '/db/%s' % db_name, method='DELETE') # Using an instance of Database db = Database(client, db_name) with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 204) response = yield client.delete_database(db) self.assertIsNone(response) self.assert_mock_args(m, '/db/%s' % db_name, method='DELETE') # Using an unsupported type with self.patch_fetch_mock(client) as m: re_exc_msg = r'^name_or_database must be an instance' with self.assertRaisesRegexp(TypeError, re_exc_msg): yield client.delete_database(None) self.assertFalse(m.called) # Non-existing database response_body = "Database %s doesn't exist" % db_name with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield client.delete_database(db_name) self.assert_mock_args(m, '/db/%s' % db_name, method='DELETE')
def test_change_user_permissions(self): client = AsyncfluxClient() db_name = 'foo' db = client[db_name] username = '******' read_from = '^$' write_to = '^$' # Update permissions payload = {'readFrom': read_from, 'writeTo': write_to} with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield db.change_user_permissions(username, read_from=read_from, write_to=write_to) self.assertIsNone(response) self.assert_mock_args(m, '/db/%s/users/%s' % (db_name, username), method='POST', body=json.dumps(payload)) # Non-existing user response_body = "Invalid username %s" % username with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield db.change_user_permissions(username, read_from=read_from, write_to=write_to) self.assert_mock_args(m, '/db/%s/users/%s' % (db_name, username), method='POST', body=json.dumps(payload)) # Invalid permission argument values exc_msg = 'You have to provide read and write permissions' with self.assertRaisesRegexp(ValueError, exc_msg): yield db.change_user_permissions(username, None, None) with self.assertRaisesRegexp(ValueError, exc_msg): yield db.change_user_permissions(username, read_from, None) with self.assertRaisesRegexp(ValueError, exc_msg): yield db.change_user_permissions(username, None, write_to)
def test_change_user_password(self): client = AsyncfluxClient() db_name = 'foo' db = client[db_name] username = '******' password = '******' payload = {'password': password} with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield db.change_user_password(username, password) self.assertIsNone(response) self.assert_mock_args(m, '/db/%s/users/%s' % (db_name, username), method='POST', body=json.dumps(payload)) # Non-existing user response_body = "Invalid username %s" % username with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield db.change_user_password(username, password) self.assert_mock_args(m, '/db/%s/users/%s' % (db_name, username), method='POST', body=json.dumps(payload)) # Invalid password password = '******' payload = {'password': password} response_body = ('Password must be more than 4 and less than 56 ' 'characters') with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield db.change_user_password(username, password) self.assert_mock_args(m, '/db/%s/users/%s' % (db_name, username), method='POST', body=json.dumps(payload))
def test_delete(self): client = AsyncfluxClient() db_name = 'foo' db = Database(client, db_name) with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 204) response = yield db.delete() self.assertIsNone(response) self.assert_mock_args(m, '/db/%s' % db_name, method='DELETE') # Non-existing databse response_body = "Database %s doesn't exist" % db_name with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield db.delete() self.assert_mock_args(m, '/db/%s' % db_name, method='DELETE')
def test_get_user_names(self): client = AsyncfluxClient() db_name = 'foo' db = client[db_name] users = [{ 'name': 'foo', 'isAdmin': False, 'writeTo': '.*', 'readFrom': '.*' }, { 'name': 'bar', 'isAdmin': False, 'writeTo': '.*', 'readFrom': '.*' }] user_names = [u['name'] for u in users] with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200, body=users) response = yield db.get_user_names() self.assertListEqual(response, user_names) self.assert_mock_args(m, '/db/%s/users' % db_name)
def test_delete(self): client = AsyncfluxClient() db_name = 'foo' db = client[db_name] username = '******' user = User(db, username) with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield user.delete() self.assertIsNone(response) self.assert_mock_args(m, '/db/%s/users/%s' % (db_name, username), method='DELETE') # Non-existing user response_body = "User %s doesn't exist" % username with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield user.delete() self.assert_mock_args(m, '/db/%s/users/%s' % (db_name, username), method='DELETE')
def test_repr(self): host = 'localhost' port = 8086 self.assertEqual(repr(AsyncfluxClient(str(host), port)), "AsyncfluxClient('%s', %d)" % (host, port))
def test_non_callable(self): client = AsyncfluxClient() with self.assertRaisesRegexp(TypeError, 'callback must be a callable'): client.get_databases(callback='this is not a callable')
def test_class_instantiation(self): client = AsyncfluxClient() self.assertEqual(client.host, 'localhost') self.assertEqual(client.port, 8086) self.assertEqual(client.base_url, 'http://*****:*****@remotehost:8089') self.assertEqual(client.host, 'remotehost') self.assertEqual(client.port, 8089) self.assertEqual(client.base_url, 'http://*****:*****@remotehost:8089') self.assertEqual(client.host, 'remotehost') self.assertEqual(client.port, 8089) self.assertEqual(client.base_url, 'https://remotehost:8089') self.assertEqual(client.username, 'user') self.assertEqual(client.password, 'pass') client = AsyncfluxClient(username='******') self.assertEqual(client.host, 'localhost') self.assertEqual(client.port, 8086) self.assertEqual(client.base_url, 'http://localhost:8086') self.assertEqual(client.username, 'me') self.assertEqual(client.password, 'root') client = AsyncfluxClient(password='******') self.assertEqual(client.host, 'localhost') self.assertEqual(client.port, 8086) self.assertEqual(client.base_url, 'http://localhost:8086') self.assertEqual(client.username, 'root') self.assertEqual(client.password, 'mysecurepassword') client = AsyncfluxClient(is_secure=True) self.assertEqual(client.host, 'localhost') self.assertEqual(client.port, 8086) self.assertEqual(client.base_url, 'https://localhost:8086') self.assertEqual(client.username, 'root') self.assertEqual(client.password, 'root') self.assertRaisesRegexp(ValueError, 'Invalid URL scheme: ftp', AsyncfluxClient, 'ftp://localhost:23') self.assertRaisesRegexp(TypeError, 'port must be an instance of int', AsyncfluxClient, port='bar')
def test_create_user(self): client = AsyncfluxClient() db_name = 'foo' db = client[db_name] username = '******' password = '******' is_admin = True read_from = '.*' write_to = '.*' payload = { 'name': username, 'password': password, 'isAdmin': is_admin, 'readFrom': read_from, 'writeTo': write_to } with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield db.create_user(username, password, is_admin=is_admin, read_from=read_from, write_to=write_to) self.assertIsInstance(response, User) self.assertEqual(response.name, username) self.assert_mock_args(m, '/db/%s/users' % db_name, method='POST', body=json.dumps(payload)) # Without permissions payload = {'name': username, 'password': password, 'isAdmin': False} with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield db.create_user(username, password) self.assertIsInstance(response, User) self.assertEqual(response.name, username) self.assertEqual(response.is_admin, False) self.assertEqual(response.read_from, '.*') self.assertEqual(response.write_to, '.*') self.assert_mock_args(m, '/db/%s/users' % db_name, method='POST', body=json.dumps(payload)) # Invalid permission argument values exc_msg = 'You have to provide read and write permissions' with self.assertRaisesRegexp(ValueError, exc_msg): yield db.create_user(username, password, is_admin=is_admin, read_from=read_from) with self.assertRaisesRegexp(ValueError, exc_msg): yield db.create_user(username, password, is_admin=is_admin, write_to=write_to) # Existing database user payload = { 'name': username, 'password': password, 'isAdmin': is_admin, 'readFrom': read_from, 'writeTo': write_to } response_body = 'User %s already exists' % username with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield db.create_user(username, password, is_admin=is_admin, read_from=read_from, write_to=write_to) self.assert_mock_args(m, '/db/%s/users' % db_name, method='POST', body=json.dumps(payload)) # Invalid password password = '******' payload = { 'name': username, 'password': password, 'isAdmin': is_admin, 'readFrom': read_from, 'writeTo': write_to } response_body = ('Password must be more than 4 and less than 56 ' 'characters') with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 400, body=response_body) with self.assertRaisesRegexp(AsyncfluxError, response_body): yield db.create_user(username, password, is_admin=is_admin, read_from=read_from, write_to=write_to) self.assert_mock_args(m, '/db/%s/users' % db_name, method='POST', body=json.dumps(payload)) # Non-default permissions read_from = '^$' write_to = '^$' payload = { 'name': username, 'password': password, 'isAdmin': is_admin, 'readFrom': read_from, 'writeTo': write_to } with self.patch_fetch_mock(client) as m: self.setup_fetch_mock(m, 200) response = yield db.create_user(username, password, is_admin=is_admin, read_from=read_from, write_to=write_to) self.assertIsInstance(response, User) self.assertEqual(response.name, username) self.assert_mock_args(m, '/db/%s/users' % db_name, method='POST', body=json.dumps(payload))