org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService クラス

org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService 連携図

公開メンバ関数
void	prepare ()
void	createAccessToken_nullAuth ()
void	createAccessToken_nullClient ()
void	createAccessToken_noRefresh ()
void	createAccessToken_yesRefresh ()
void	createAccessToken_expiration ()
void	createAccessToken_checkClient ()
void	createAccessToken_checkScopes ()
void	createAccessToken_checkAttachedAuthentication ()
void	refreshAccessToken_noRefreshToken ()
void	refreshAccessToken_notAllowRefresh ()
void	refreshAccessToken_clientMismatch ()
void	refreshAccessToken_expired ()
void	refreshAccessToken_verifyAcessToken ()
void	refreshAccessToken_rotateRefreshToken ()
void	refreshAccessToken_keepAccessTokens ()
void	refreshAccessToken_requestingSameScope ()
void	refreshAccessToken_requestingLessScope ()
void	refreshAccessToken_requestingMoreScope ()
void	refreshAccessToken_requestingMixedScope ()
void	refreshAccessToken_requestingEmptyScope ()
void	refreshAccessToken_requestingNullScope ()
void	refreshAccessToken_expiration ()

非公開変数類
OAuth2Authentication	authentication
ClientDetailsEntity	client
ClientDetailsEntity	badClient
String	clientId = "test_client"
String	badClientId = "bad_client"
Set< String >	scope = Sets.newHashSet("openid", "profile", "email", "offline_access")
OAuth2RefreshTokenEntity	refreshToken
String	refreshTokenValue = "refresh_token_value"
TokenRequest	tokenRequest
OAuth2Request	storedAuthRequest
OAuth2Authentication	storedAuthentication
AuthenticationHolderEntity	storedAuthHolder
Set< String >	storedScope
OAuth2TokenRepository	tokenRepository
AuthenticationHolderRepository	authenticationHolderRepository
ClientDetailsEntityService	clientDetailsService
TokenEnhancer	tokenEnhancer
SystemScopeService	scopeService
DefaultOAuth2ProviderTokenService	service

静的非公開変数類
static final long	DELTA = 100L

詳解

著者

wkim

関数詳解

createAccessToken_checkAttachedAuthentication()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.createAccessToken_checkAttachedAuthentication ( )

inline

                                                                    {

                AuthenticationHolderEntity authHolder = Mockito.mock(AuthenticationHolderEntity.class);
                Mockito.when(authHolder.getAuthentication()).thenReturn(authentication);

                Mockito.when(authenticationHolderRepository.save(Matchers.any(AuthenticationHolderEntity.class))).thenReturn(authHolder);

                OAuth2AccessTokenEntity token = service.createAccessToken(authentication);

                assertThat(token.getAuthenticationHolder().getAuthentication(), equalTo(authentication));
                Mockito.verify(authenticationHolderRepository).save(Matchers.any(AuthenticationHolderEntity.class));
                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

        }

createAccessToken_checkClient()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.createAccessToken_checkClient ( )

inline

                                                    {

                OAuth2AccessTokenEntity token = service.createAccessToken(authentication);

                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertThat(token.getClient().getClientId(), equalTo(clientId));
        }

createAccessToken_checkScopes()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.createAccessToken_checkScopes ( )

inline

                                                    {

                OAuth2AccessTokenEntity token = service.createAccessToken(authentication);

                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertThat(token.getScope(), equalTo(scope));
        }

createAccessToken_expiration()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.createAccessToken_expiration ( )

inline

Checks to see that the expiration date of new tokens is being set accurately to within some delta for time skew.

                                                   {

                Integer accessTokenValiditySeconds = 3600;
                Integer refreshTokenValiditySeconds = 600;

                Mockito.when(client.getAccessTokenValiditySeconds()).thenReturn(accessTokenValiditySeconds);
                Mockito.when(client.getRefreshTokenValiditySeconds()).thenReturn(refreshTokenValiditySeconds);

                long start = System.currentTimeMillis();
                OAuth2AccessTokenEntity token = service.createAccessToken(authentication);
                long end = System.currentTimeMillis();

                // Accounting for some delta for time skew on either side.
                Date lowerBoundAccessTokens = new Date(start + (accessTokenValiditySeconds * 1000L) - DELTA);
                Date upperBoundAccessTokens = new Date(end + (accessTokenValiditySeconds * 1000L) + DELTA);
                Date lowerBoundRefreshTokens = new Date(start + (refreshTokenValiditySeconds * 1000L) - DELTA);
                Date upperBoundRefreshTokens = new Date(end + (refreshTokenValiditySeconds * 1000L) + DELTA);

                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertTrue(token.getExpiration().after(lowerBoundAccessTokens) && token.getExpiration().before(upperBoundAccessTokens));
                assertTrue(token.getRefreshToken().getExpiration().after(lowerBoundRefreshTokens) && token.getRefreshToken().getExpiration().before(upperBoundRefreshTokens));
        }

createAccessToken_noRefresh()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.createAccessToken_noRefresh ( )

inline

Tests the creation of access tokens for clients that are not allowed to have refresh tokens.

                                                  {

                Mockito.when(client.isAllowRefresh()).thenReturn(false);

                OAuth2AccessTokenEntity token = service.createAccessToken(authentication);

                Mockito.verify(clientDetailsService).loadClientByClientId(Matchers.anyString());
                Mockito.verify(authenticationHolderRepository).save(Matchers.any(AuthenticationHolderEntity.class));
                Mockito.verify(tokenEnhancer).enhance(Matchers.any(OAuth2AccessTokenEntity.class), Matchers.eq(authentication));
                Mockito.verify(tokenRepository).saveAccessToken(Matchers.any(OAuth2AccessTokenEntity.class));
                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                Mockito.verify(tokenRepository, Mockito.never()).saveRefreshToken(Matchers.any(OAuth2RefreshTokenEntity.class));

                assertThat(token.getRefreshToken(), is(nullValue()));
        }

createAccessToken_nullAuth()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.createAccessToken_nullAuth ( )

inline

Tests exception handling for null authentication or null authorization.

                                                 {

                Mockito.when(authentication.getOAuth2Request()).thenReturn(null);

                try {
                        service.createAccessToken(null);
                        fail("Authentication parameter is null. Excpected a AuthenticationCredentialsNotFoundException.");
                } catch (AuthenticationCredentialsNotFoundException e) {
                        assertThat(e, is(notNullValue()));
                }

                try {
                        service.createAccessToken(authentication);
                        fail("AuthorizationRequest is null. Excpected a AuthenticationCredentialsNotFoundException.");
                } catch (AuthenticationCredentialsNotFoundException e) {
                        assertThat(e, is(notNullValue()));
                }
        }

createAccessToken_nullClient()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.createAccessToken_nullClient ( )

inline

Tests exception handling for clients not found.

                                                   {

                Mockito.when(clientDetailsService.loadClientByClientId(Matchers.anyString())).thenReturn(null);

                service.createAccessToken(authentication);
        }

createAccessToken_yesRefresh()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.createAccessToken_yesRefresh ( )

inline

Tests the creation of access tokens for clients that are allowed to have refresh tokens.

                                                   {

                OAuth2Request clientAuth = new OAuth2Request(null, clientId, null, true, Sets.newHashSet(SystemScopeService.OFFLINE_ACCESS), null, null, null, null);
                Mockito.when(authentication.getOAuth2Request()).thenReturn(clientAuth);
                Mockito.when(client.isAllowRefresh()).thenReturn(true);

                OAuth2AccessTokenEntity token = service.createAccessToken(authentication);

                // Note: a refactor may be appropriate to only save refresh tokens once to the repository during creation.
                Mockito.verify(tokenRepository, Mockito.atLeastOnce()).saveRefreshToken(Matchers.any(OAuth2RefreshTokenEntity.class));
                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertThat(token.getRefreshToken(), is(notNullValue()));

        }

prepare()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.prepare ( )

inline

Set up a mock authentication and mock client to work with.

                              {
                Mockito.reset(tokenRepository, authenticationHolderRepository, clientDetailsService, tokenEnhancer);



                authentication = Mockito.mock(OAuth2Authentication.class);
                OAuth2Request clientAuth = new OAuth2Request(null, clientId, null, true, scope, null, null, null, null);
                Mockito.when(authentication.getOAuth2Request()).thenReturn(clientAuth);

                client = Mockito.mock(ClientDetailsEntity.class);
                Mockito.when(client.getClientId()).thenReturn(clientId);
                Mockito.when(clientDetailsService.loadClientByClientId(clientId)).thenReturn(client);
                Mockito.when(client.isReuseRefreshToken()).thenReturn(true);

                // by default in tests, allow refresh tokens
                Mockito.when(client.isAllowRefresh()).thenReturn(true);

                // by default, clear access tokens on refresh
                Mockito.when(client.isClearAccessTokensOnRefresh()).thenReturn(true);

                badClient = Mockito.mock(ClientDetailsEntity.class);
                Mockito.when(badClient.getClientId()).thenReturn(badClientId);
                Mockito.when(clientDetailsService.loadClientByClientId(badClientId)).thenReturn(badClient);

                refreshToken = Mockito.mock(OAuth2RefreshTokenEntity.class);
                Mockito.when(tokenRepository.getRefreshTokenByValue(refreshTokenValue)).thenReturn(refreshToken);
                Mockito.when(refreshToken.getClient()).thenReturn(client);
                Mockito.when(refreshToken.isExpired()).thenReturn(false);

                tokenRequest = new TokenRequest(null, clientId, null, null);

                storedAuthentication = authentication;
                storedAuthRequest = clientAuth;
                storedAuthHolder = Mockito.mock(AuthenticationHolderEntity.class);
                storedScope = Sets.newHashSet(scope);

                Mockito.when(refreshToken.getAuthenticationHolder()).thenReturn(storedAuthHolder);
                Mockito.when(storedAuthHolder.getAuthentication()).thenReturn(storedAuthentication);
                Mockito.when(storedAuthentication.getOAuth2Request()).thenReturn(storedAuthRequest);

                Mockito.when(authenticationHolderRepository.save(Matchers.any(AuthenticationHolderEntity.class))).thenReturn(storedAuthHolder);

                Mockito.when(scopeService.fromStrings(Matchers.anySet())).thenAnswer(new Answer<Set<SystemScope>>() {
                        @Override
                        public Set<SystemScope> answer(InvocationOnMock invocation) throws Throwable {
                                Object[] args = invocation.getArguments();
                                Set<String> input = (Set<String>) args[0];
                                Set<SystemScope> output = new HashSet<>();
                                for (String scope : input) {
                                        output.add(new SystemScope(scope));
                                }
                                return output;
                        }
                });

                Mockito.when(scopeService.toStrings(Matchers.anySet())).thenAnswer(new Answer<Set<String>>() {
                        @Override
                        public Set<String> answer(InvocationOnMock invocation) throws Throwable {
                                Object[] args = invocation.getArguments();
                                Set<SystemScope> input = (Set<SystemScope>) args[0];
                                Set<String> output = new HashSet<>();
                                for (SystemScope scope : input) {
                                        output.add(scope.getValue());
                                }
                                return output;
                        }
                });

                // we're not testing restricted or reserved scopes here, just pass through
                Mockito.when(scopeService.removeReservedScopes(Matchers.anySet())).then(AdditionalAnswers.returnsFirstArg());
                Mockito.when(scopeService.removeRestrictedAndReservedScopes(Matchers.anySet())).then(AdditionalAnswers.returnsFirstArg());

                Mockito.when(tokenEnhancer.enhance(Matchers.any(OAuth2AccessTokenEntity.class), Matchers.any(OAuth2Authentication.class)))
                .thenAnswer(new Answer<OAuth2AccessTokenEntity>(){
                        @Override
                        public OAuth2AccessTokenEntity answer(InvocationOnMock invocation) throws Throwable {
                                Object[] args = invocation.getArguments();
                                return (OAuth2AccessTokenEntity) args[0];
                        }
                });

                Mockito.when(tokenRepository.saveAccessToken(Matchers.any(OAuth2AccessTokenEntity.class)))
                .thenAnswer(new Answer<OAuth2AccessTokenEntity>() {
                        @Override
                        public OAuth2AccessTokenEntity answer(InvocationOnMock invocation) throws Throwable {
                                Object[] args = invocation.getArguments();
                                return (OAuth2AccessTokenEntity) args[0];
                        }

                });

                Mockito.when(tokenRepository.saveRefreshToken(Matchers.any(OAuth2RefreshTokenEntity.class)))
                .thenAnswer(new Answer<OAuth2RefreshTokenEntity>() {
                        @Override
                        public OAuth2RefreshTokenEntity answer(InvocationOnMock invocation) throws Throwable {
                                Object[] args = invocation.getArguments();
                                return (OAuth2RefreshTokenEntity) args[0];
                        }
                });

        }

refreshAccessToken_clientMismatch()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_clientMismatch ( )

inline

                                                        {

                tokenRequest = new TokenRequest(null, badClientId, null, null);

                service.refreshAccessToken(refreshTokenValue, tokenRequest);
        }

refreshAccessToken_expiration()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_expiration ( )

inline

Checks to see that the expiration date of refreshed tokens is being set accurately to within some delta for time skew.

                                                    {

                Integer accessTokenValiditySeconds = 3600;

                Mockito.when(client.getAccessTokenValiditySeconds()).thenReturn(accessTokenValiditySeconds);

                long start = System.currentTimeMillis();
                OAuth2AccessTokenEntity token = service.refreshAccessToken(refreshTokenValue, tokenRequest);
                long end = System.currentTimeMillis();

                // Accounting for some delta for time skew on either side.
                Date lowerBoundAccessTokens = new Date(start + (accessTokenValiditySeconds * 1000L) - DELTA);
                Date upperBoundAccessTokens = new Date(end + (accessTokenValiditySeconds * 1000L) + DELTA);

                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertTrue(token.getExpiration().after(lowerBoundAccessTokens) && token.getExpiration().before(upperBoundAccessTokens));
        }

refreshAccessToken_expired()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_expired ( )

inline

                                                 {

                Mockito.when(refreshToken.isExpired()).thenReturn(true);

                service.refreshAccessToken(refreshTokenValue, tokenRequest);
        }

refreshAccessToken_keepAccessTokens()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_keepAccessTokens ( )

inline

                                                          {

                when(client.isClearAccessTokensOnRefresh()).thenReturn(false);

                OAuth2AccessTokenEntity token = service.refreshAccessToken(refreshTokenValue, tokenRequest);

                Mockito.verify(tokenRepository, never()).clearAccessTokensForRefreshToken(refreshToken);

                assertThat(token.getClient(), equalTo(client));
                assertThat(token.getRefreshToken(), equalTo(refreshToken));
                assertThat(token.getAuthenticationHolder(), equalTo(storedAuthHolder));

                Mockito.verify(tokenEnhancer).enhance(token, storedAuthentication);
                Mockito.verify(tokenRepository).saveAccessToken(token);
                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

        }

refreshAccessToken_noRefreshToken()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_noRefreshToken ( )

inline

                                                        {

                Mockito.when(tokenRepository.getRefreshTokenByValue(Matchers.anyString())).thenReturn(null);

                service.refreshAccessToken(refreshTokenValue, tokenRequest);
        }

refreshAccessToken_notAllowRefresh()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_notAllowRefresh ( )

inline

                                                         {

                Mockito.when(client.isAllowRefresh()).thenReturn(false);

                service.refreshAccessToken(refreshTokenValue, tokenRequest);
        }

refreshAccessToken_requestingEmptyScope()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_requestingEmptyScope ( )

inline

                                                              {

                Set<String> emptyScope = Sets.newHashSet();

                tokenRequest.setScope(emptyScope);

                OAuth2AccessTokenEntity token = service.refreshAccessToken(refreshTokenValue, tokenRequest);

                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertThat(token.getScope(), equalTo(storedScope));
        }

refreshAccessToken_requestingLessScope()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_requestingLessScope ( )

inline

                                                             {

                Set<String> lessScope = Sets.newHashSet("openid", "profile");

                tokenRequest.setScope(lessScope);

                OAuth2AccessTokenEntity token = service.refreshAccessToken(refreshTokenValue, tokenRequest);

                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertThat(token.getScope(), equalTo(lessScope));
        }

refreshAccessToken_requestingMixedScope()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_requestingMixedScope ( )

inline

Tests the case where only some of the valid scope values are being requested along with other extra unauthorized scope values.

                                                              {

                Set<String> mixedScope = Sets.newHashSet("openid", "profile", "address", "phone"); // no email or offline_access

                tokenRequest.setScope(mixedScope);

                service.refreshAccessToken(refreshTokenValue, tokenRequest);
        }

refreshAccessToken_requestingMoreScope()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_requestingMoreScope ( )

inline

                                                             {

                Set<String> moreScope = Sets.newHashSet(storedScope);
                moreScope.add("address");
                moreScope.add("phone");

                tokenRequest.setScope(moreScope);

                service.refreshAccessToken(refreshTokenValue, tokenRequest);
        }

refreshAccessToken_requestingNullScope()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_requestingNullScope ( )

inline

                                                             {

                tokenRequest.setScope(null);

                OAuth2AccessTokenEntity token = service.refreshAccessToken(refreshTokenValue, tokenRequest);

                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertThat(token.getScope(), equalTo(storedScope));

        }

refreshAccessToken_requestingSameScope()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_requestingSameScope ( )

inline

                                                             {

                OAuth2AccessTokenEntity token = service.refreshAccessToken(refreshTokenValue, tokenRequest);

                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

                assertThat(token.getScope(), equalTo(storedScope));
        }

refreshAccessToken_rotateRefreshToken()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_rotateRefreshToken ( )

inline

                                                            {

                when(client.isReuseRefreshToken()).thenReturn(false);

                OAuth2AccessTokenEntity token = service.refreshAccessToken(refreshTokenValue, tokenRequest);

                Mockito.verify(tokenRepository).clearAccessTokensForRefreshToken(refreshToken);

                assertThat(token.getClient(), equalTo(client));
                assertThat(token.getRefreshToken(), not(equalTo(refreshToken)));
                assertThat(token.getAuthenticationHolder(), equalTo(storedAuthHolder));

                Mockito.verify(tokenEnhancer).enhance(token, storedAuthentication);
                Mockito.verify(tokenRepository).saveAccessToken(token);
                Mockito.verify(tokenRepository).removeRefreshToken(refreshToken);
                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

        }

refreshAccessToken_verifyAcessToken()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshAccessToken_verifyAcessToken ( )

inline

                                                          {

                OAuth2AccessTokenEntity token = service.refreshAccessToken(refreshTokenValue, tokenRequest);

                Mockito.verify(tokenRepository).clearAccessTokensForRefreshToken(refreshToken);

                assertThat(token.getClient(), equalTo(client));
                assertThat(token.getRefreshToken(), equalTo(refreshToken));
                assertThat(token.getAuthenticationHolder(), equalTo(storedAuthHolder));

                Mockito.verify(tokenEnhancer).enhance(token, storedAuthentication);
                Mockito.verify(tokenRepository).saveAccessToken(token);
                Mockito.verify(scopeService, Mockito.atLeastOnce()).removeReservedScopes(Matchers.anySet());

        }

メンバ詳解

authentication

OAuth2Authentication org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.authentication

private

authenticationHolderRepository

AuthenticationHolderRepository org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.authenticationHolderRepository

private

badClient

ClientDetailsEntity org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.badClient

private

badClientId

String org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.badClientId = "bad_client"

private

client

ClientDetailsEntity org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.client

private

clientDetailsService

ClientDetailsEntityService org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.clientDetailsService

private

clientId

String org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.clientId = "test_client"

private

DELTA

final long org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.DELTA = 100L

staticprivate

refreshToken

OAuth2RefreshTokenEntity org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshToken

private

refreshTokenValue

String org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.refreshTokenValue = "refresh_token_value"

private

scope

Set<String> org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.scope = Sets.newHashSet("openid", "profile", "email", "offline_access")

private

scopeService

SystemScopeService org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.scopeService

private

service

DefaultOAuth2ProviderTokenService org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.service

private

storedAuthentication

OAuth2Authentication org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.storedAuthentication

private

storedAuthHolder

AuthenticationHolderEntity org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.storedAuthHolder

private

storedAuthRequest

OAuth2Request org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.storedAuthRequest

private

storedScope

Set<String> org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.storedScope

private

tokenEnhancer

TokenEnhancer org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.tokenEnhancer

private

tokenRepository

OAuth2TokenRepository org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.tokenRepository

private

tokenRequest

TokenRequest org.mitre.oauth2.service.impl.TestDefaultOAuth2ProviderTokenService.tokenRequest

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/mitreid-connect/src/openid-connect-server/src/test/java/org/mitre/oauth2/service/impl/TestDefaultOAuth2ProviderTokenService.java