def test_create_admin_account_throws_rql_driver_error(self):
with patch.object(Interactions, 'insert',
side_effect=RqlDriverError(None)):
with self.assertRaises(RqlDriverError) as cm:
create_admin_account()
self.assertEqual(cm.exception,
RqlDriverError(None))
def close(self, noreply_wait=False, token=None, exception=None):
self._closing = True
if exception is not None:
err_message = "Connection is closed (%s)." % str(exception)
else:
err_message = "Connection is closed."
# Cursors may remove themselves when errored, so copy a list of them
for cursor in list(self._cursor_cache.values()):
cursor._error(err_message)
for query, async_res in iter(self._user_queries.values()):
async_res.set_exception(RqlDriverError(err_message))
self._user_queries = {}
self._cursor_cache = {}
if noreply_wait:
noreply = net.Query(pQuery.NOREPLY_WAIT, token, None, None)
self.run_query(noreply, False)
try:
self._socket.close()
except OSError:
pass
def _reader(self):
try:
while True:
buf = self._socket.recvall(12)
(token, length,) = struct.unpack("<qL", buf)
buf = self._socket.recvall(length)
cursor = self._cursor_cache.get(token)
if cursor is not None:
cursor._extend(buf)
elif token in self._user_queries:
# Do not pop the query from the dict until later, so
# we don't lose track of it in case of an exception
query, async_res = self._user_queries[token]
res = net.Response(token, buf, self._parent._get_json_decoder(query))
if res.type == pResponse.SUCCESS_ATOM:
async_res.set(net.maybe_profile(res.data[0], res))
elif res.type in (pResponse.SUCCESS_SEQUENCE,
pResponse.SUCCESS_PARTIAL):
cursor = GeventCursor(self, query, res)
async_res.set(net.maybe_profile(cursor, res))
elif res.type == pResponse.WAIT_COMPLETE:
async_res.set(None)
else:
async_res.set_exception(res.make_error(query))
del self._user_queries[token]
elif not self._closing:
raise RqlDriverError("Unexpected response received.")
except Exception as ex:
if not self._closing:
self.close(exception=ex)
class WhenTestingDrop(unittest.TestCase):
def setUp(self):
pass
@patch('pywebhooks.database.rethinkdb.drop.get_connection')
def test_drop_database(self, connection_method):
connection_method.return_value = Mock(__enter__=Mock, __exit__=Mock())
with patch.object(rethink, 'db_drop', return_value=Mock()) as \
db_drop_method:
drop_database()
db_drop_method.assert_called_once_with(DEFAULT_DB_NAME)
@patch('pywebhooks.database.rethinkdb.drop.get_connection',
side_effect=RqlDriverError(None))
def test_drop_database_throws_rql_driver_error(self, _):
with self.assertRaises(RqlDriverError) as cm:
drop_database()
self.assertEqual(cm.exception, RqlDriverError(None))
@patch('pywebhooks.database.rethinkdb.drop.get_connection',
side_effect=RqlRuntimeError(None, None, None))
def test_drop_database_throws_rql_runtime_error(self, _):
with self.assertRaises(RqlRuntimeError) as cm:
drop_database()
self.assertEqual(cm.exception, RqlRuntimeError(None, None, None))
def test_reset_key_rql_driver_error(self):
with self.app.test_request_context():
with patch.object(Interactions, 'query',
side_effect=RqlDriverError(None)):
response = reset_key('johndoe', 'api_key')
self.assertRaises(RqlDriverError)
self.assertEqual(response.status_code,
client.INTERNAL_SERVER_ERROR)
def test_delete_rql_driver_error(self):
with self.app.test_request_context():
with patch.object(Interactions, 'delete',
side_effect=RqlDriverError(None)):
response = delete(DEFAULT_SUBSCRIPTIONS_TABLE, '123')
self.assertRaises(RqlDriverError)
self.assertEqual(response.status_code,
client.INTERNAL_SERVER_ERROR)
def test_delete_registration_rql_driver_error(self):
with self.app.test_request_context():
with patch.object(Interactions, 'delete_specific',
side_effect=RqlDriverError(None)):
response = delete_registration('123')
self.assertRaises(RqlDriverError)
self.assertEqual(response.status_code,
client.INTERNAL_SERVER_ERROR)
def test_query_rql_driver_error(self):
with self.app.test_request_context():
with patch.object(Interactions, 'get',
side_effect=RqlDriverError(None)):
response = query(DEFAULT_REGISTRATIONS_TABLE, record_id='123')
self.assertRaises(RqlDriverError)
self.assertEqual(response.status_code,
client.INTERNAL_SERVER_ERROR)
def test_update_failed_count_exceptions(self):
with patch.object(Interactions, 'get',
side_effect=RqlRuntimeError(None, None, None)):
self.assertIsNone(update_failed_count(account_id='123'))
with patch.object(Interactions, 'get',
side_effect=RqlDriverError(None)):
self.assertIsNone(update_failed_count(account_id='123'))
def test_delete_account_rql_driver_error(self):
with self.app.test_request_context():
with patch.object(Interactions, 'query',
side_effect=RqlDriverError(None)):
response = insert_account(DEFAULT_SUBSCRIPTIONS_TABLE,
**self.param_kwargs)
self.assertRaises(RqlDriverError)
self.assertEqual(response.status_code,
client.INTERNAL_SERVER_ERROR)
def test_update_rql_driver_error(self):
with self.app.test_request_context():
with patch.object(Interactions, 'update',
side_effect=RqlDriverError(None)):
update(DEFAULT_REGISTRATIONS_TABLE,
record_id='123',
username=None,
updates={})
self.assertRaises(RqlDriverError)
def _check_error_response(cls, response, term):
if response.type == pResponse.RUNTIME_ERROR:
message = response.data[0]
frames = response.backtrace
return RqlRuntimeError(message, term, frames)
elif response.type == pResponse.COMPILE_ERROR:
message = response.data[0]
frames = response.backtrace
return RqlCompileError(message, term, frames)
elif response.type == pResponse.CLIENT_ERROR:
message = response.data[0]
frames = response.backtrace
return RqlClientError(message, term, frames)
elif response.type not in (pResponse.SUCCESS_ATOM,
pResponse.SUCCESS_SEQUENCE,
pResponse.SUCCESS_PARTIAL,
pResponse.SUCCESS_FEED,
pResponse.WAIT_COMPLETE):
return RqlDriverError(
"Unknown Response type %d encountered in response." %
response.type)
def test_drop_database_throws_rql_driver_error(self, _):
with self.assertRaises(RqlDriverError) as cm:
drop_database()
self.assertEqual(cm.exception, RqlDriverError(None))