def test_policy_success(self):
bomb = Exception("Boom!")
callable = mock.MagicMock(side_effect=[bomb, mock.sentinel.OK])
retry = TimedRetryPolicy(0.3, delay=lambda i: 0.1)
retry.clock = mock.Mock()
retry.clock.sleep = mock.MagicMock()
retry.clock.time = mock.MagicMock(side_effect=[0, 0.15])
assert retry(callable) is mock.sentinel.OK
assert callable.call_count == 2
def test_decorator(self):
bomb = Exception("Boom!")
callable = mock.MagicMock(side_effect=[bomb, mock.sentinel.OK])
@TimedRetryPolicy.wrap(0.3, delay=lambda i: 0.1)
def retrying_func():
return callable()
retrying_func.clock = mock.Mock()
retrying_func.clock.sleep = mock.MagicMock()
retrying_func.clock.time = mock.MagicMock(side_effect=[0, 0.15, 0.25])
assert retrying_func() is mock.sentinel.OK
assert callable.call_count == 2
def test_set_session_expiration(self, mock_auth):
self.org = self.create_organization()
self.auth_provider = AuthProvider.objects.create(provider="saml2",
organization=self.org)
self.provider = SAML2Provider(key=self.auth_provider.provider)
self.provider.config = dummy_provider_config
self.auth_provider.get_provider = mock.MagicMock(
return_value=self.provider)
super(SAML2ACSViewTest, self).setUp()
request = self.make_request(user=None)
request.META = {
"PATH_INFO": "/",
}
test_view = SAML2ACSView()
helper = AuthHelper(request,
self.org,
AuthHelper.FLOW_LOGIN,
auth_provider=self.auth_provider)
def mock_next_step(self):
return
helper.next_step = types.MethodType(mock_next_step, helper)
instance = mock_auth.return_value
instance.get_errors.return_value = None
instance.get_attributes.return_value = {}
instance.get_session_expiration.return_value = 1591044492
test_view.dispatch(request, helper)
assert request.session.get_expiry_date() == datetime.fromtimestamp(
1591044492).replace(tzinfo=timezone.utc)
def test_policy_success(self) -> None:
callable = mock.MagicMock(side_effect=[self.bomb, mock.sentinel.OK])
always_retry = lambda i, e: True
assert ConditionalRetryPolicy(always_retry)(
callable) is mock.sentinel.OK
assert callable.call_count == 2
def test_policy_failure(self):
bomb = Exception("Boom!")
callable = mock.MagicMock(side_effect=bomb)
retry = TimedRetryPolicy(0.3, delay=lambda i: 0.1)
retry.clock = mock.Mock()
retry.clock.sleep = mock.MagicMock()
retry.clock.time = mock.MagicMock(side_effect=[0, 0.15, 0.25])
try:
retry(callable)
except RetryException as exception:
assert exception.exception is bomb
else:
self.fail(u"Expected {!r}!".format(RetryException))
assert callable.call_count == 2
def test_policy_counter(self) -> None:
callable = mock.MagicMock(side_effect=self.bomb)
retry_once = lambda i, e: i < 2
with pytest.raises(Exception) as e:
ConditionalRetryPolicy(retry_once)(callable)
assert callable.call_count == 2
assert e.value is self.bomb
def test_poilcy_failure(self) -> None:
callable = mock.MagicMock(side_effect=self.bomb)
never_retry = lambda i, e: False
with pytest.raises(Exception) as e:
ConditionalRetryPolicy(never_retry)(callable)
assert callable.call_count == 1
assert e.value is self.bomb
def test_policy_exception_filtering(self) -> None:
errors = [Exception(), Exception(), Exception()]
callable = mock.MagicMock(side_effect=errors)
sometimes_retry = lambda i, e: e is not errors[-1]
with pytest.raises(Exception) as e:
ConditionalRetryPolicy(sometimes_retry)(callable)
assert e.value is errors[-1]
assert callable.call_count == 3
def get_organization_quota(self):
inst = mock.MagicMock()
inst.return_value = (0, 60)
return inst
def get_project_quota(self):
inst = mock.MagicMock()
inst.return_value = (0, 60)
return inst
def test_transitions():
callback = mock.MagicMock()
state = SynchronizedPartitionStateManager(callback)
with pytest.raises(InvalidState):
state.validate_local_message("topic", 0, 0)
state.set_local_offset("topic", 0, 1)
assert callback.mock_calls[-1] == mock.call(
"topic",
0,
(None, Offsets(None, None)),
(SynchronizedPartitionState.UNKNOWN, Offsets(1, None)),
)
with pytest.raises(InvalidState):
state.validate_local_message("topic", 0, 0)
state.set_remote_offset("topic", 0, 1)
assert callback.mock_calls[-1] == mock.call(
"topic",
0,
(SynchronizedPartitionState.UNKNOWN, Offsets(1, None)),
(SynchronizedPartitionState.SYNCHRONIZED, Offsets(1, 1)),
)
with pytest.raises(InvalidStateTransition):
state.set_local_offset("topic", 0, None)
with pytest.raises(InvalidStateTransition):
state.set_remote_offset("topic", 0, None)
state.set_remote_offset("topic", 0, 2)
assert callback.mock_calls[-1] == mock.call(
"topic",
0,
(SynchronizedPartitionState.SYNCHRONIZED, Offsets(1, 1)),
(SynchronizedPartitionState.LOCAL_BEHIND, Offsets(1, 2)),
)
state.validate_local_message("topic", 0, 1)
with pytest.raises(MessageNotReady):
state.validate_local_message("topic", 0, 2)
state.set_local_offset("topic", 0, 2)
assert callback.mock_calls[-1] == mock.call(
"topic",
0,
(SynchronizedPartitionState.LOCAL_BEHIND, Offsets(1, 2)),
(SynchronizedPartitionState.SYNCHRONIZED, Offsets(2, 2)),
)
state.set_remote_offset("topic", 1, 5)
assert callback.mock_calls[-1] == mock.call(
"topic",
1,
(None, Offsets(None, None)),
(SynchronizedPartitionState.UNKNOWN, Offsets(None, 5)),
)
state.set_local_offset("topic", 1, 0)
assert callback.mock_calls[-1] == mock.call(
"topic",
1,
(SynchronizedPartitionState.UNKNOWN, Offsets(None, 5)),
(SynchronizedPartitionState.LOCAL_BEHIND, Offsets(0, 5)),
)
before_calls = len(callback.mock_calls)
state.set_local_offset("topic", 1, 1)
state.set_local_offset("topic", 1, 2)
state.set_local_offset("topic", 1, 3)
state.set_local_offset("topic", 1, 4)
assert len(callback.mock_calls) == before_calls
state.set_local_offset("topic", 1, 5)
assert callback.mock_calls[-1] == mock.call(
"topic",
1,
(SynchronizedPartitionState.LOCAL_BEHIND, Offsets(4, 5)),
(SynchronizedPartitionState.SYNCHRONIZED, Offsets(5, 5)),
)
state.set_local_offset("topic", 1, 6)
assert callback.mock_calls[-1] == mock.call(
"topic",
1,
(SynchronizedPartitionState.SYNCHRONIZED, Offsets(5, 5)),
(SynchronizedPartitionState.REMOTE_BEHIND, Offsets(6, 5)),
)
def logger():
return mock.MagicMock()
