def setup(self):
self.session = Mock(name='session')
self.user, _ = get_user_model().objects.get_or_create(
username='******',
password='******',
email='*****@*****.**',
)
self.subscriber = Subscriber(
event='foo.created',
url='http://example.com',
)
self.subscriber2 = Subscriber(
event='foo.changed',
url='http://example.com',
user=self.user,
)
self.req = Request(self.subscriber.event,
'a',
501,
self.subscriber,
timeout=3.03)
self.req2 = Request(self.subscriber2.event,
'a',
501,
self.subscriber2,
timeout=3.03)
def test_dispatch(mock_dispatch_request, dispatcher, app):
Session = app.Request.Session = Mock(name='Request.Session')
subscriber = Subscriber(url='http://example.com')
reqs = [
Request(mock_event('foo.created', dispatcher, app),
'a', 501, subscriber, timeout=3.03),
Request(mock_event('foo.changed', dispatcher, app),
'b', 501, subscriber, timeout=6.06),
Request(mock_event('foo.deleted', dispatcher, app),
'c', 501, subscriber, timeout=8.08),
]
dispatch_requests([req.as_dict() for req in reqs])
Session.assert_called_once_with()
mock_dispatch_request.assert_has_calls([
call(session=Session(), app=app, **req.as_dict())
for req in reqs
])
def mock_req(event, url, **kwargs):
kwargs.setdefault('on_success', Mock(name='on_success'))
kwargs.setdefault('on_timeout', Mock(name='on_timeout'))
kwargs.setdefault('on_error', Mock(name='on_error'))
subscriber = Mock(name='subscriber')
subscriber.url = url
subscriber.content_type = MIME_JSON
return Request(event, 'data', 'george', subscriber, timeout=3.03, **kwargs)
def setup(self):
self.session = Mock(name='session')
self.user, _ = get_user_model().objects.get_or_create(
username='******',
password='******',
email='*****@*****.**',
)
self.subscriber = Subscriber(
event='foo.created',
url='http://example.com',
)
self.subscriber2 = Subscriber(
event='foo.changed',
url='http://example.com',
user=self.user,
)
self.req = Request(
self.subscriber.event, 'a', 501, self.subscriber, timeout=3.03)
self.req2 = Request(
self.subscriber2.event, 'a', 501, self.subscriber2, timeout=3.03)
def test_dispatch(self, requests, dispatch_request):
subscriber = Subscriber(url='http://example.com')
reqs = [
Request(self.mock_event('foo.created'),
'a',
501,
subscriber,
timeout=3.03),
Request(self.mock_event('foo.changed'),
'b',
501,
subscriber,
timeout=6.06),
Request(self.mock_event('foo.deleted'),
'c',
501,
subscriber,
timeout=8.08),
]
dispatch_requests([req.as_dict() for req in reqs])
requests.Session.assert_called_once_with()
dispatch_request.assert_has_calls([
call(session=requests.Session(), **req.as_dict()) for req in reqs
])
def test_flush_buffer(self, group, app):
g = [None]
subscriber = Mock(name='subscriber')
subscriber.url = 'http://example.com/?e=1'
def group_consume_generator(arg):
g[0] = list(arg)
return group.return_value
group.side_effect = group_consume_generator
d = Dispatcher()
d.pending_outbound.extend(
Request('order.created', {}, None, subscriber) for i in range(100))
d.flush_buffer()
assert g[0]
assert len(g[0]) == 100 / app.settings.THORN_CHUNKSIZE
group.return_value.delay.assert_called_once_with()
assert not d.pending_outbound
class test_dispatch_request:
def setup(self):
self.session = Mock(name='session')
self.user, _ = get_user_model().objects.get_or_create(
username='******',
password='******',
email='*****@*****.**',
)
self.subscriber = Subscriber(
event='foo.created',
url='http://example.com',
)
self.subscriber2 = Subscriber(
event='foo.changed',
url='http://example.com',
user=self.user,
)
self.req = Request(self.subscriber.event,
'a',
501,
self.subscriber,
timeout=3.03)
self.req2 = Request(self.subscriber2.event,
'a',
501,
self.subscriber2,
timeout=3.03)
@pytest.fixture()
def app_or_default(self, patching):
return patching('thorn.tasks.app_or_default')
def test_success(self, app_or_default):
_Request = app_or_default().Request
dispatch_request(session=self.session, **self.req.as_dict())
subscriber_dict = self.subscriber.as_dict()
subscriber_dict.pop('user', None)
app_or_default().Subscriber.assert_called_once_with(**subscriber_dict)
_Request.assert_called_once_with(
self.req.event,
self.req.data,
self.req.sender,
app_or_default().Subscriber(),
id=self.req.id,
timeout=self.req.timeout,
retry=self.req.retry,
retry_max=self.req.retry_max,
retry_delay=self.req.retry_delay,
recipient_validators=DEFAULT_RECIPIENT_VALIDATORS,
allow_keepalive=True,
on_error=None,
on_success=None,
on_timeout=None)
_Request().dispatch.assert_called_once_with(session=self.session,
propagate=_Request().retry)
def test_when_keepalive_disabled(self, app_or_default):
_Request = app_or_default().Request
self.req.allow_keepalive = False
dispatch_request(session=self.session, **self.req.as_dict())
subscriber_dict = self.subscriber.as_dict()
subscriber_dict.pop('user', None)
app_or_default().Subscriber.assert_called_once_with(**subscriber_dict)
_Request.assert_called_once_with(
self.req.event,
self.req.data,
self.req.sender,
app_or_default().Subscriber(),
id=self.req.id,
timeout=self.req.timeout,
retry=self.req.retry,
retry_max=self.req.retry_max,
retry_delay=self.req.retry_delay,
recipient_validators=DEFAULT_RECIPIENT_VALIDATORS,
allow_keepalive=False,
on_error=None,
on_success=None,
on_timeout=None)
_Request().dispatch.assert_called_once_with(session=self.session,
propagate=_Request().retry)
def test_success__with_user(self, app_or_default):
_Request = app_or_default().Request
dispatch_request(session=self.session, **self.req2.as_dict())
subscriber_dict = self.subscriber2.as_dict()
subscriber_dict.pop('user', None)
app_or_default().Subscriber.assert_called_once_with(**subscriber_dict)
_Request.assert_called_once_with(
self.req2.event,
self.req2.data,
self.req2.sender,
app_or_default().Subscriber(),
id=self.req2.id,
timeout=self.req2.timeout,
retry=self.req2.retry,
retry_max=self.req2.retry_max,
retry_delay=self.req2.retry_delay,
recipient_validators=DEFAULT_RECIPIENT_VALIDATORS,
allow_keepalive=True,
on_error=None,
on_success=None,
on_timeout=None)
_Request().dispatch.assert_called_once_with(session=self.session,
propagate=_Request().retry)
def test_connection_error(self, task_retry, app_or_default):
_Request = app_or_default().Request
_Request.return_value.connection_errors = (ValueError, )
_Request.return_value.timeout_errors = ()
exc = _Request.return_value.dispatch.side_effect = ValueError(10)
task_retry.side_effect = exc
with pytest.raises(ValueError):
dispatch_request(session=self.session, **self.req.as_dict())
task_retry.assert_called_with(
exc=exc,
max_retries=_Request().retry_max,
countdown=_Request().retry_delay,
)
def test_connection_error__retry_disabled(self, task_retry,
app_or_default):
_Request = app_or_default().Request
_Request.return_value.connection_errors = (ValueError, )
_Request.return_value.timeout_errors = ()
_Request.return_value.retry = False
exc = _Request.return_value.dispatch.side_effect = ValueError(11)
task_retry.side_effect = exc
self.req.retry = False
with pytest.raises(ValueError):
dispatch_request(session=self.session, **self.req.as_dict())
task_retry.assert_not_called()
class test_dispatch_request:
def setup(self):
self.session = Mock(name='session')
self.user, _ = get_user_model().objects.get_or_create(
username='******',
password='******',
email='*****@*****.**',
)
self.subscriber = Subscriber(
event='foo.created',
url='http://example.com',
)
self.subscriber2 = Subscriber(
event='foo.changed',
url='http://example.com',
user=self.user,
)
self.req = Request(
self.subscriber.event, 'a', 501, self.subscriber, timeout=3.03)
self.req2 = Request(
self.subscriber2.event, 'a', 501, self.subscriber2, timeout=3.03)
@pytest.fixture()
def app_or_default(self, patching):
return patching('thorn.tasks.app_or_default')
def test_success(self, app_or_default):
_Request = app_or_default().Request
dispatch_request(session=self.session, **self.req.as_dict())
subscriber_dict = self.subscriber.as_dict()
subscriber_dict.pop('user', None)
app_or_default().Subscriber.assert_called_once_with(**subscriber_dict)
_Request.assert_called_once_with(
self.req.event, self.req.data,
self.req.sender, app_or_default().Subscriber(),
id=self.req.id, timeout=self.req.timeout, retry=self.req.retry,
retry_max=self.req.retry_max, retry_delay=self.req.retry_delay,
recipient_validators=DEFAULT_RECIPIENT_VALIDATORS,
allow_keepalive=True,
)
_Request().dispatch.assert_called_once_with(
session=self.session, propagate=_Request().retry)
def test_when_keepalive_disabled(self, app_or_default):
_Request = app_or_default().Request
self.req.allow_keepalive = False
dispatch_request(session=self.session, **self.req.as_dict())
subscriber_dict = self.subscriber.as_dict()
subscriber_dict.pop('user', None)
app_or_default().Subscriber.assert_called_once_with(**subscriber_dict)
_Request.assert_called_once_with(
self.req.event, self.req.data,
self.req.sender, app_or_default().Subscriber(),
id=self.req.id, timeout=self.req.timeout, retry=self.req.retry,
retry_max=self.req.retry_max, retry_delay=self.req.retry_delay,
recipient_validators=DEFAULT_RECIPIENT_VALIDATORS,
allow_keepalive=False,
)
_Request().dispatch.assert_called_once_with(
session=self.session, propagate=_Request().retry)
def test_success__with_user(self, app_or_default):
_Request = app_or_default().Request
dispatch_request(session=self.session, **self.req2.as_dict())
subscriber_dict = self.subscriber2.as_dict()
subscriber_dict.pop('user', None)
app_or_default().Subscriber.assert_called_once_with(**subscriber_dict)
_Request.assert_called_once_with(
self.req2.event, self.req2.data,
self.req2.sender, app_or_default().Subscriber(),
id=self.req2.id, timeout=self.req2.timeout, retry=self.req2.retry,
retry_max=self.req2.retry_max, retry_delay=self.req2.retry_delay,
recipient_validators=DEFAULT_RECIPIENT_VALIDATORS,
allow_keepalive=True,
)
_Request().dispatch.assert_called_once_with(
session=self.session, propagate=_Request().retry)
def test_connection_error(self, task_retry, app_or_default):
_Request = app_or_default().Request
_Request.return_value.connection_errors = (ValueError,)
_Request.return_value.timeout_errors = ()
exc = _Request.return_value.dispatch.side_effect = ValueError(10)
task_retry.side_effect = exc
with pytest.raises(ValueError):
dispatch_request(session=self.session, **self.req.as_dict())
task_retry.assert_called_with(
exc=exc, max_retries=_Request().retry_max,
countdown=_Request().retry_delay,
)
def test_connection_error__retry_disabled(
self, task_retry, app_or_default):
_Request = app_or_default().Request
_Request.return_value.connection_errors = (ValueError,)
_Request.return_value.timeout_errors = ()
_Request.return_value.retry = False
exc = _Request.return_value.dispatch.side_effect = ValueError(11)
task_retry.side_effect = exc
self.req.retry = False
with pytest.raises(ValueError):
dispatch_request(session=self.session, **self.req.as_dict())
task_retry.assert_not_called()
class test_dispatch_request(EventCase):
def setUp(self):
EventCase.setUp(self)
self.session = Mock(name='session')
self.user, _ = get_user_model().objects.get_or_create(
username='******',
password='******',
email='*****@*****.**',
)
self.subscriber = Subscriber(
event='foo.created',
url='http://example.com',
)
self.subscriber2 = Subscriber(
event='foo.changed',
url='http://example.com',
user=self.user,
)
self.req = Request(self.subscriber.event,
'a',
501,
self.subscriber,
timeout=3.03)
self.req2 = Request(self.subscriber2.event,
'a',
501,
self.subscriber2,
timeout=3.03)
@patch('thorn.tasks.current_app')
def test_success(self, current_app):
_Request = current_app().Request
dispatch_request(session=self.session, **self.req.as_dict())
subscriber_dict = self.subscriber.as_dict()
subscriber_dict.pop('user', None)
current_app().Subscriber.assert_called_once_with(**subscriber_dict)
_Request.assert_called_once_with(
self.req.event,
self.req.data,
self.req.sender,
current_app().Subscriber(),
id=self.req.id,
timeout=self.req.timeout,
retry=self.req.retry,
retry_max=self.req.retry_max,
retry_delay=self.req.retry_delay,
recipient_validators=DEFAULT_RECIPIENT_VALIDATORS,
)
_Request().dispatch.assert_called_once_with(session=self.session,
propagate=_Request().retry)
@patch('thorn.tasks.current_app')
def test_success__with_user(self, current_app):
_Request = current_app().Request
dispatch_request(session=self.session, **self.req2.as_dict())
subscriber_dict = self.subscriber2.as_dict()
subscriber_dict.pop('user', None)
current_app().Subscriber.assert_called_once_with(**subscriber_dict)
_Request.assert_called_once_with(
self.req2.event,
self.req2.data,
self.req2.sender,
current_app().Subscriber(),
id=self.req2.id,
timeout=self.req2.timeout,
retry=self.req2.retry,
retry_max=self.req2.retry_max,
retry_delay=self.req2.retry_delay,
recipient_validators=DEFAULT_RECIPIENT_VALIDATORS,
)
_Request().dispatch.assert_called_once_with(session=self.session,
propagate=_Request().retry)
@patch('thorn.tasks.current_app')
@patch('celery.app.task.Task.retry')
def test_connection_error(self, retry, current_app):
_Request = current_app().Request
_Request.return_value.connection_errors = (ValueError, )
_Request.return_value.timeout_errors = ()
exc = _Request.return_value.dispatch.side_effect = ValueError(10)
retry.side_effect = exc
with self.assertRaises(ValueError):
dispatch_request(session=self.session, **self.req.as_dict())
retry.assert_called_with(
exc=exc,
max_retries=_Request().retry_max,
countdown=_Request().retry_delay,
)
@patch('thorn.tasks.current_app')
@patch('celery.app.task.Task.retry')
def test_connection_error__retry_disabled(self, retry, current_app):
_Request = current_app().Request
_Request.return_value.connection_errors = (ValueError, )
_Request.return_value.timeout_errors = ()
_Request.return_value.retry = False
exc = _Request.return_value.dispatch.side_effect = ValueError(11)
retry.side_effect = exc
self.req.retry = False
with self.assertRaises(ValueError):
dispatch_request(session=self.session, **self.req.as_dict())
retry.assert_not_called()
