class TestAuthenticationPolicy(object):
@pytest.fixture(autouse=True)
def policy(self):
self.api_policy = mock.Mock(spec_set=list(IAuthenticationPolicy))
self.fallback_policy = mock.Mock(spec_set=list(IAuthenticationPolicy))
self.policy = AuthenticationPolicy(
api_policy=self.api_policy, fallback_policy=self.fallback_policy)
self.fallback_policy.remember.return_value = [("Cookie", "auth=foobar")
]
# api_request and nonapi_request are parametrized fixtures, which will
# take on each value in the passed `params` sequence in turn. This is a
# quick and easy way to generate a named fixture which takes multiple
# values and can be used by multiple tests.
@pytest.fixture(params=API_PATHS)
def api_request(self, request, pyramid_request):
pyramid_request.path = request.param
return pyramid_request
@pytest.fixture(params=NONAPI_PATHS)
def nonapi_request(self, request, pyramid_request):
pyramid_request.path = request.param
return pyramid_request
def test_authenticated_userid_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.authenticated_userid(nonapi_request)
self.fallback_policy.authenticated_userid.assert_called_once_with(
nonapi_request)
assert result == self.fallback_policy.authenticated_userid.return_value
def test_authenticated_userid_uses_api_policy_for_api_paths(
self, api_request):
result = self.policy.authenticated_userid(api_request)
self.api_policy.authenticated_userid.assert_called_once_with(
api_request)
assert result == self.api_policy.authenticated_userid.return_value
def test_unauthenticated_userid_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.unauthenticated_userid(nonapi_request)
self.fallback_policy.unauthenticated_userid.assert_called_once_with(
nonapi_request)
assert result == self.fallback_policy.unauthenticated_userid.return_value
def test_unauthenticated_userid_uses_api_policy_for_api_paths(
self, api_request):
result = self.policy.unauthenticated_userid(api_request)
self.api_policy.unauthenticated_userid.assert_called_once_with(
api_request)
assert result == self.api_policy.unauthenticated_userid.return_value
def test_effective_principals_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.effective_principals(nonapi_request)
self.fallback_policy.effective_principals.assert_called_once_with(
nonapi_request)
assert result == self.fallback_policy.effective_principals.return_value
def test_effective_principals_uses_api_policy_for_api_paths(
self, api_request):
result = self.policy.effective_principals(api_request)
self.api_policy.effective_principals.assert_called_once_with(
api_request)
assert result == self.api_policy.effective_principals.return_value
def test_remember_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.remember(nonapi_request, "foo", bar="baz")
self.fallback_policy.remember.assert_called_once_with(nonapi_request,
"foo",
bar="baz")
assert result == self.fallback_policy.remember.return_value
def test_remember_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.remember(api_request, "foo", bar="baz")
self.api_policy.remember.assert_called_once_with(api_request,
"foo",
bar="baz")
assert result == self.api_policy.remember.return_value
def test_forget_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.forget(nonapi_request)
self.fallback_policy.forget.assert_called_once_with(nonapi_request)
assert result == self.fallback_policy.forget.return_value
def test_forget_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.forget(api_request)
self.api_policy.forget.assert_called_once_with(api_request)
assert result == self.api_policy.forget.return_value
class TestAuthenticationPolicy(object):
@pytest.fixture(autouse=True)
def policy(self):
self.api_policy = mock.Mock(spec_set=list(IAuthenticationPolicy))
self.fallback_policy = mock.Mock(spec_set=list(IAuthenticationPolicy))
self.policy = AuthenticationPolicy(api_policy=self.api_policy, fallback_policy=self.fallback_policy)
self.fallback_policy.remember.return_value = [("Cookie", "auth=foobar")]
# api_request and nonapi_request are parametrized fixtures, which will
# take on each value in the passed `params` sequence in turn. This is a
# quick and easy way to generate a named fixture which takes multiple
# values and can be used by multiple tests.
@pytest.fixture(params=API_PATHS)
def api_request(self, request, pyramid_request):
pyramid_request.path = request.param
return pyramid_request
@pytest.fixture(params=NONAPI_PATHS)
def nonapi_request(self, request, pyramid_request):
pyramid_request.path = request.param
return pyramid_request
def test_authenticated_userid_uses_fallback_policy_for_nonapi_paths(self, nonapi_request):
result = self.policy.authenticated_userid(nonapi_request)
self.fallback_policy.authenticated_userid.assert_called_once_with(nonapi_request)
assert result == self.fallback_policy.authenticated_userid.return_value
def test_authenticated_userid_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.authenticated_userid(api_request)
self.api_policy.authenticated_userid.assert_called_once_with(api_request)
assert result == self.api_policy.authenticated_userid.return_value
def test_unauthenticated_userid_uses_fallback_policy_for_nonapi_paths(self, nonapi_request):
result = self.policy.unauthenticated_userid(nonapi_request)
self.fallback_policy.unauthenticated_userid.assert_called_once_with(nonapi_request)
assert result == self.fallback_policy.unauthenticated_userid.return_value
def test_unauthenticated_userid_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.unauthenticated_userid(api_request)
self.api_policy.unauthenticated_userid.assert_called_once_with(api_request)
assert result == self.api_policy.unauthenticated_userid.return_value
def test_effective_principals_uses_fallback_policy_for_nonapi_paths(self, nonapi_request):
result = self.policy.effective_principals(nonapi_request)
self.fallback_policy.effective_principals.assert_called_once_with(nonapi_request)
assert result == self.fallback_policy.effective_principals.return_value
def test_effective_principals_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.effective_principals(api_request)
self.api_policy.effective_principals.assert_called_once_with(api_request)
assert result == self.api_policy.effective_principals.return_value
def test_remember_uses_fallback_policy_for_nonapi_paths(self, nonapi_request):
result = self.policy.remember(nonapi_request, "foo", bar="baz")
self.fallback_policy.remember.assert_called_once_with(nonapi_request, "foo", bar="baz")
assert result == self.fallback_policy.remember.return_value
def test_remember_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.remember(api_request, "foo", bar="baz")
self.api_policy.remember.assert_called_once_with(api_request, "foo", bar="baz")
assert result == self.api_policy.remember.return_value
def test_forget_uses_fallback_policy_for_nonapi_paths(self, nonapi_request):
result = self.policy.forget(nonapi_request)
self.fallback_policy.forget.assert_called_once_with(nonapi_request)
assert result == self.fallback_policy.forget.return_value
def test_forget_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.forget(api_request)
self.api_policy.forget.assert_called_once_with(api_request)
assert result == self.api_policy.forget.return_value
class TestAuthenticationPolicy(object):
@pytest.fixture(autouse=True)
def policy(self):
self.session_policy = mock.Mock(spec_set=SessionAuthenticationPolicy())
self.token_policy = mock.Mock(spec_set=TokenAuthenticationPolicy())
self.policy = AuthenticationPolicy()
self.policy.session_policy = self.session_policy
self.policy.token_policy = self.token_policy
# session_request and token_request are parametrized fixtures, which will
# take on each value in the passed `params` sequence in turn. This is a
# quick and easy way to generate a named fixture which takes multiple
# values and can be used by multiple tests.
@pytest.fixture(params=SESSION_AUTH_PATHS)
def session_request(self, request):
return DummyRequest(path=request.param)
@pytest.fixture(params=TOKEN_AUTH_PATHS)
def token_request(self, request):
return DummyRequest(path=request.param)
def test_authenticated_userid_uses_session_policy_for_session_auth_paths(
self, session_request):
result = self.policy.authenticated_userid(session_request)
self.session_policy.authenticated_userid.assert_called_once_with(
session_request)
assert result == self.session_policy.authenticated_userid.return_value
def test_authenticated_userid_uses_token_policy_for_token_auth_paths(
self, token_request):
result = self.policy.authenticated_userid(token_request)
self.token_policy.authenticated_userid.assert_called_once_with(
token_request)
assert result == self.token_policy.authenticated_userid.return_value
def test_unauthenticated_userid_uses_session_policy_for_session_auth_paths(
self, session_request):
result = self.policy.unauthenticated_userid(session_request)
self.session_policy.unauthenticated_userid.assert_called_once_with(
session_request)
assert result == self.session_policy.unauthenticated_userid.return_value
def test_unauthenticated_userid_uses_token_policy_for_token_auth_paths(
self, token_request):
result = self.policy.unauthenticated_userid(token_request)
self.token_policy.unauthenticated_userid.assert_called_once_with(
token_request)
assert result == self.token_policy.unauthenticated_userid.return_value
def test_effective_principals_uses_session_policy_for_session_auth_paths(
self, session_request):
result = self.policy.effective_principals(session_request)
self.session_policy.effective_principals.assert_called_once_with(
session_request)
assert result == self.session_policy.effective_principals.return_value
def test_effective_principals_uses_token_policy_for_token_auth_paths(
self, token_request):
result = self.policy.effective_principals(token_request)
self.token_policy.effective_principals.assert_called_once_with(
token_request)
assert result == self.token_policy.effective_principals.return_value
def test_remember_uses_session_policy_for_session_auth_paths(
self, session_request):
result = self.policy.remember(session_request, 'foo', bar='baz')
self.session_policy.remember.assert_called_once_with(session_request,
'foo',
bar='baz')
assert result == self.session_policy.remember.return_value
def test_remember_uses_token_policy_for_token_auth_paths(
self, token_request):
result = self.policy.remember(token_request, 'foo', bar='baz')
self.token_policy.remember.assert_called_once_with(token_request,
'foo',
bar='baz')
assert result == self.token_policy.remember.return_value
def test_forget_uses_session_policy_for_session_auth_paths(
self, session_request):
result = self.policy.forget(session_request)
self.session_policy.forget.assert_called_once_with(session_request)
assert result == self.session_policy.forget.return_value
def test_forget_uses_token_policy_for_token_auth_paths(
self, token_request):
result = self.policy.forget(token_request)
self.token_policy.forget.assert_called_once_with(token_request)
assert result == self.token_policy.forget.return_value
class TestAuthenticationPolicy(object):
@pytest.fixture(autouse=True)
def policy(self):
self.session_policy = mock.Mock(spec_set=SessionAuthenticationPolicy())
self.token_policy = mock.Mock(spec_set=TokenAuthenticationPolicy())
self.policy = AuthenticationPolicy()
self.policy.session_policy = self.session_policy
self.policy.token_policy = self.token_policy
# session_request and token_request are parametrized fixtures, which will
# take on each value in the passed `params` sequence in turn. This is a
# quick and easy way to generate a named fixture which takes multiple
# values and can be used by multiple tests.
@pytest.fixture(params=SESSION_AUTH_PATHS)
def session_request(self, request):
return DummyRequest(path=request.param)
@pytest.fixture(params=TOKEN_AUTH_PATHS)
def token_request(self, request):
return DummyRequest(path=request.param)
def test_authenticated_userid_uses_session_policy_for_session_auth_paths(self, session_request):
result = self.policy.authenticated_userid(session_request)
self.session_policy.authenticated_userid.assert_called_once_with(session_request)
assert result == self.session_policy.authenticated_userid.return_value
def test_authenticated_userid_uses_token_policy_for_token_auth_paths(self, token_request):
result = self.policy.authenticated_userid(token_request)
self.token_policy.authenticated_userid.assert_called_once_with(token_request)
assert result == self.token_policy.authenticated_userid.return_value
def test_unauthenticated_userid_uses_session_policy_for_session_auth_paths(self, session_request):
result = self.policy.unauthenticated_userid(session_request)
self.session_policy.unauthenticated_userid.assert_called_once_with(session_request)
assert result == self.session_policy.unauthenticated_userid.return_value
def test_unauthenticated_userid_uses_token_policy_for_token_auth_paths(self, token_request):
result = self.policy.unauthenticated_userid(token_request)
self.token_policy.unauthenticated_userid.assert_called_once_with(token_request)
assert result == self.token_policy.unauthenticated_userid.return_value
def test_effective_principals_uses_session_policy_for_session_auth_paths(self, session_request):
result = self.policy.effective_principals(session_request)
self.session_policy.effective_principals.assert_called_once_with(session_request)
assert result == self.session_policy.effective_principals.return_value
def test_effective_principals_uses_token_policy_for_token_auth_paths(self, token_request):
result = self.policy.effective_principals(token_request)
self.token_policy.effective_principals.assert_called_once_with(token_request)
assert result == self.token_policy.effective_principals.return_value
def test_remember_uses_session_policy_for_session_auth_paths(self, session_request):
result = self.policy.remember(session_request, 'foo', bar='baz')
self.session_policy.remember.assert_called_once_with(session_request, 'foo', bar='baz')
assert result == self.session_policy.remember.return_value
def test_remember_uses_token_policy_for_token_auth_paths(self, token_request):
result = self.policy.remember(token_request, 'foo', bar='baz')
self.token_policy.remember.assert_called_once_with(token_request, 'foo', bar='baz')
assert result == self.token_policy.remember.return_value
def test_forget_uses_session_policy_for_session_auth_paths(self, session_request):
result = self.policy.forget(session_request)
self.session_policy.forget.assert_called_once_with(session_request)
assert result == self.session_policy.forget.return_value
def test_forget_uses_token_policy_for_token_auth_paths(self, token_request):
result = self.policy.forget(token_request)
self.token_policy.forget.assert_called_once_with(token_request)
assert result == self.token_policy.forget.return_value
class TestAuthenticationPolicy(object):
@pytest.fixture(autouse=True)
def policy(self):
self.upstream_policy = mock.Mock(
spec_set=SessionAuthenticationPolicy())
self.policy = AuthenticationPolicy()
self.policy.session_policy = self.upstream_policy
# session_request and token_request are parametrized fixtures, which will
# take on each value in the passed `params` sequence in turn. This is a
# quick and easy way to generate a named fixture which takes multiple
# values and can be used by multiple tests.
@pytest.fixture(params=SESSION_AUTH_PATHS)
def session_request(self, request):
return DummyRequest(path=request.param)
@pytest.fixture(params=TOKEN_AUTH_PATHS)
def token_request(self, request):
return DummyRequest(path=request.param)
def test_authenticated_userid_delegates_for_session_auth_paths(
self, session_request):
result = self.policy.authenticated_userid(session_request)
self.upstream_policy.authenticated_userid.assert_called_once_with(
session_request)
assert result == self.upstream_policy.authenticated_userid.return_value
@mock.patch('h.auth.policy.tokens')
def test_authenticated_userid_uses_tokens_for_token_auth_paths(
self, tokens, token_request):
result = self.policy.authenticated_userid(token_request)
tokens.authenticated_userid.assert_called_once_with(token_request)
assert result == tokens.authenticated_userid.return_value
def test_unauthenticated_userid_delegates_for_session_auth_paths(
self, session_request):
result = self.policy.unauthenticated_userid(session_request)
self.upstream_policy.unauthenticated_userid.assert_called_once_with(
session_request)
assert result == self.upstream_policy.unauthenticated_userid.return_value
@mock.patch('h.auth.policy.tokens')
def test_unauthenticated_userid_uses_tokens_for_token_auth_paths(
self, tokens, token_request):
result = self.policy.unauthenticated_userid(token_request)
tokens.authenticated_userid.assert_called_once_with(token_request)
assert result == tokens.authenticated_userid.return_value
@mock.patch('h.auth.policy.util')
def test_effective_principals_calls_effective_principals_with_authenticated_userid(
self, util, authn_policy):
authn_policy.authenticated_userid.return_value = 'acct:[email protected]'
request = DummyRequest()
result = self.policy.effective_principals(request)
util.effective_principals.assert_called_once_with(
'acct:[email protected]', request)
assert result == util.effective_principals.return_value
def test_remember_delegates_for_session_auth_paths(self, session_request):
result = self.policy.remember(session_request, 'foo', bar='baz')
self.upstream_policy.remember.assert_called_once_with(session_request,
'foo',
bar='baz')
assert result == self.upstream_policy.remember.return_value
def test_remember_does_nothing_for_token_auth_paths(self, token_request):
result = self.policy.remember(token_request, 'foo', bar='baz')
self.upstream_policy.remember.assert_not_called()
assert result == []
def test_forget_delegates_for_session_auth_paths(self, session_request):
result = self.policy.forget(session_request)
self.upstream_policy.forget.assert_called_once_with(session_request)
assert result == self.upstream_policy.forget.return_value
def test_forget_does_nothing_for_token_auth_paths(self, token_request):
result = self.policy.forget(token_request)
self.upstream_policy.forget.assert_not_called()
assert result == []
class TestAuthenticationPolicy(object):
@pytest.fixture(autouse=True)
def policy(self):
self.api_policy = mock.Mock(spec_set=list(IAuthenticationPolicy))
self.fallback_policy = mock.Mock(spec_set=list(IAuthenticationPolicy))
self.migration_policy = mock.Mock(spec_set=list(IAuthenticationPolicy))
self.policy = AuthenticationPolicy(
api_policy=self.api_policy,
fallback_policy=self.fallback_policy,
migration_policy=self.migration_policy)
self.fallback_policy.remember.return_value = [('Cookie', 'auth=foobar')
]
# api_request and nonapi_request are parametrized fixtures, which will
# take on each value in the passed `params` sequence in turn. This is a
# quick and easy way to generate a named fixture which takes multiple
# values and can be used by multiple tests.
@pytest.fixture(params=API_PATHS)
def api_request(self, request, pyramid_request):
pyramid_request.path = request.param
return pyramid_request
@pytest.fixture(params=NONAPI_PATHS)
def nonapi_request(self, request, pyramid_request):
pyramid_request.path = request.param
return pyramid_request
def test_authenticated_userid_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.authenticated_userid(nonapi_request)
self.fallback_policy.authenticated_userid.assert_called_once_with(
nonapi_request)
assert result == self.fallback_policy.authenticated_userid.return_value
def test_authenticated_userid_uses_migration_policy_when_fallback_returns_none(
self, nonapi_request):
self.fallback_policy.authenticated_userid.return_value = None
result = self.policy.authenticated_userid(nonapi_request)
self.migration_policy.authenticated_userid.assert_called_once_with(
nonapi_request)
assert result == self.migration_policy.authenticated_userid.return_value
def test_authenticated_userid_remembers_value_from_migration_policy_in_fallback_policy(
self, nonapi_request):
self.fallback_policy.authenticated_userid.return_value = None
self.policy.authenticated_userid(nonapi_request)
self.fallback_policy.remember.assert_called_once_with(
nonapi_request,
self.migration_policy.authenticated_userid.return_value)
def test_authenticated_userid_sets_cookie_when_migrating(
self, nonapi_request):
self.fallback_policy.authenticated_userid.return_value = None
self.policy.authenticated_userid(nonapi_request)
cookies = nonapi_request.response.headers.getall('Cookie')
assert 'auth=foobar' in cookies
def test_authenticated_userid_uses_api_policy_for_api_paths(
self, api_request):
result = self.policy.authenticated_userid(api_request)
self.api_policy.authenticated_userid.assert_called_once_with(
api_request)
assert result == self.api_policy.authenticated_userid.return_value
def test_unauthenticated_userid_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.unauthenticated_userid(nonapi_request)
self.fallback_policy.unauthenticated_userid.assert_called_once_with(
nonapi_request)
assert result == self.fallback_policy.unauthenticated_userid.return_value
def test_unauthenticated_userid_uses_api_policy_for_api_paths(
self, api_request):
result = self.policy.unauthenticated_userid(api_request)
self.api_policy.unauthenticated_userid.assert_called_once_with(
api_request)
assert result == self.api_policy.unauthenticated_userid.return_value
def test_effective_principals_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.effective_principals(nonapi_request)
self.fallback_policy.effective_principals.assert_called_once_with(
nonapi_request)
assert result == self.fallback_policy.effective_principals.return_value
def test_effective_principals_uses_api_policy_for_api_paths(
self, api_request):
result = self.policy.effective_principals(api_request)
self.api_policy.effective_principals.assert_called_once_with(
api_request)
assert result == self.api_policy.effective_principals.return_value
def test_remember_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.remember(nonapi_request, 'foo', bar='baz')
self.fallback_policy.remember.assert_called_once_with(nonapi_request,
'foo',
bar='baz')
assert result == self.fallback_policy.remember.return_value
def test_remember_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.remember(api_request, 'foo', bar='baz')
self.api_policy.remember.assert_called_once_with(api_request,
'foo',
bar='baz')
assert result == self.api_policy.remember.return_value
def test_forget_uses_fallback_policy_for_nonapi_paths(
self, nonapi_request):
result = self.policy.forget(nonapi_request)
self.fallback_policy.forget.assert_called_once_with(nonapi_request)
assert result == self.fallback_policy.forget.return_value
def test_forget_uses_api_policy_for_api_paths(self, api_request):
result = self.policy.forget(api_request)
self.api_policy.forget.assert_called_once_with(api_request)
assert result == self.api_policy.forget.return_value
class TestAuthenticationPolicy(object):
@pytest.fixture(autouse=True)
def policy(self):
self.upstream_policy = mock.Mock(spec_set=SessionAuthenticationPolicy())
self.policy = AuthenticationPolicy()
self.policy.session_policy = self.upstream_policy
# session_request and token_request are parametrized fixtures, which will
# take on each value in the passed `params` sequence in turn. This is a
# quick and easy way to generate a named fixture which takes multiple
# values and can be used by multiple tests.
@pytest.fixture(params=SESSION_AUTH_PATHS)
def session_request(self, request):
return DummyRequest(path=request.param)
@pytest.fixture(params=TOKEN_AUTH_PATHS)
def token_request(self, request):
return DummyRequest(path=request.param)
def test_authenticated_userid_delegates_for_session_auth_paths(self, session_request):
result = self.policy.authenticated_userid(session_request)
self.upstream_policy.authenticated_userid.assert_called_once_with(session_request)
assert result == self.upstream_policy.authenticated_userid.return_value
@mock.patch('h.auth.policy.tokens')
def test_authenticated_userid_uses_tokens_for_token_auth_paths(self, tokens, token_request):
result = self.policy.authenticated_userid(token_request)
tokens.authenticated_userid.assert_called_once_with(token_request)
assert result == tokens.authenticated_userid.return_value
def test_unauthenticated_userid_delegates_for_session_auth_paths(self, session_request):
result = self.policy.unauthenticated_userid(session_request)
self.upstream_policy.unauthenticated_userid.assert_called_once_with(session_request)
assert result == self.upstream_policy.unauthenticated_userid.return_value
@mock.patch('h.auth.policy.tokens')
def test_unauthenticated_userid_uses_tokens_for_token_auth_paths(self, tokens, token_request):
result = self.policy.unauthenticated_userid(token_request)
tokens.authenticated_userid.assert_called_once_with(token_request)
assert result == tokens.authenticated_userid.return_value
@mock.patch('h.auth.policy.util')
def test_effective_principals_calls_effective_principals_with_authenticated_userid(self, util, authn_policy):
authn_policy.authenticated_userid.return_value = 'acct:[email protected]'
request = DummyRequest()
result = self.policy.effective_principals(request)
util.effective_principals.assert_called_once_with('acct:[email protected]', request)
assert result == util.effective_principals.return_value
def test_remember_delegates_for_session_auth_paths(self, session_request):
result = self.policy.remember(session_request, 'foo', bar='baz')
self.upstream_policy.remember.assert_called_once_with(session_request, 'foo', bar='baz')
assert result == self.upstream_policy.remember.return_value
def test_remember_does_nothing_for_token_auth_paths(self, token_request):
result = self.policy.remember(token_request, 'foo', bar='baz')
self.upstream_policy.remember.assert_not_called()
assert result == []
def test_forget_delegates_for_session_auth_paths(self, session_request):
result = self.policy.forget(session_request)
self.upstream_policy.forget.assert_called_once_with(session_request)
assert result == self.upstream_policy.forget.return_value
def test_forget_does_nothing_for_token_auth_paths(self, token_request):
result = self.policy.forget(token_request)
self.upstream_policy.forget.assert_not_called()
assert result == []
