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

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

公開メンバ関数
void	prepare ()
void	saveNewClient_badId ()
void	saveNewClient_blacklisted ()
void	saveNewClient_idWasAssigned ()
void	saveNewClient_yesOfflineAccess ()
void	saveNewClient_noOfflineAccess ()
void	loadClientByClientId_badId ()
void	deleteClient_badId ()
void	deleteClient ()
void	updateClient_nullClients ()
void	updateClient_blacklistedUri ()
void	updateClient_yesOfflineAccess ()
void	updateClient_noOfflineAccess ()
void	heartMode_authcode_invalidGrants ()
void	heartMode_implicit_invalidGrants ()
void	heartMode_clientcreds_invalidGrants ()
void	heartMode_authcode_authMethod ()
void	heartMode_implicit_authMethod ()
void	heartMode_clientcreds_authMethod ()
void	heartMode_authcode_redirectUris ()
void	heartMode_implicit_redirectUris ()
void	heartMode_clientcreds_redirectUris ()
void	heartMode_clientSecret ()
void	heartMode_noJwks ()
void	heartMode_validAuthcodeClient ()
void	heartMode_nonLocalHttpRedirect ()
void	heartMode_multipleRedirectClass ()

非公開変数類
OAuth2ClientRepository	clientRepository
OAuth2TokenRepository	tokenRepository
ApprovedSiteService	approvedSiteService
WhitelistedSiteService	whitelistedSiteService
BlacklistedSiteService	blacklistedSiteService
SystemScopeService	scopeService
ResourceSetService	resourceSetService
StatsService	statsService
ConfigurationPropertiesBean	config
DefaultOAuth2ClientDetailsEntityService	service

詳解

著者

wkim

関数詳解

deleteClient()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.deleteClient ( )

inline

                                   {

                Long id = 12345L;
                String clientId = "b00g3r";

                ClientDetailsEntity client = Mockito.mock(ClientDetailsEntity.class);
                Mockito.when(client.getId()).thenReturn(id);
                Mockito.when(client.getClientId()).thenReturn(clientId);

                Mockito.when(clientRepository.getById(id)).thenReturn(client);

                WhitelistedSite site = Mockito.mock(WhitelistedSite.class);
                Mockito.when(whitelistedSiteService.getByClientId(clientId)).thenReturn(site);

                Mockito.when(resourceSetService.getAllForClient(client)).thenReturn(new HashSet<ResourceSet>());

                service.deleteClient(client);

                Mockito.verify(tokenRepository).clearTokensForClient(client);
                Mockito.verify(approvedSiteService).clearApprovedSitesForClient(client);
                Mockito.verify(whitelistedSiteService).remove(site);
                Mockito.verify(clientRepository).deleteClient(client);
        }

deleteClient_badId()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.deleteClient_badId ( )

inline

                                         {

                Long id = 12345L;
                ClientDetailsEntity client = Mockito.mock(ClientDetailsEntity.class);
                Mockito.when(client.getId()).thenReturn(id);
                Mockito.when(clientRepository.getById(id)).thenReturn(null);

                service.deleteClient(client);
        }

heartMode_authcode_authMethod()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_authcode_authMethod ( )

inline

                                                    {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("authorization_code");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.SECRET_POST);

                client.setRedirectUris(Sets.newHashSet("https://foo.bar/"));

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

        }

heartMode_authcode_invalidGrants()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_authcode_invalidGrants ( )

inline

                                                       {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("authorization_code");
                grantTypes.add("implicit");
                grantTypes.add("client_credentials");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setRedirectUris(Sets.newHashSet("https://foo.bar/"));

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

        }

heartMode_authcode_redirectUris()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_authcode_redirectUris ( )

inline

                                                      {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("authorization_code");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                service.saveNewClient(client);

        }

heartMode_clientcreds_authMethod()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_clientcreds_authMethod ( )

inline

                                                       {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("client_credentials");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.SECRET_BASIC);

                client.setRedirectUris(Sets.newHashSet("https://foo.bar/"));

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

        }

heartMode_clientcreds_invalidGrants()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_clientcreds_invalidGrants ( )

inline

                                                          {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("client_credentials");
                grantTypes.add("authorization_code");
                grantTypes.add("implicit");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

        }

heartMode_clientcreds_redirectUris()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_clientcreds_redirectUris ( )

inline

                                                         {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("client_credentials");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setRedirectUris(Sets.newHashSet("http://foo.bar/"));

                service.saveNewClient(client);

        }

heartMode_clientSecret()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_clientSecret ( )

inline

                                             {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("authorization_code");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setRedirectUris(Sets.newHashSet("http://foo.bar/"));

                client.setClientSecret("secret!");

                service.saveNewClient(client);

        }

heartMode_implicit_authMethod()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_implicit_authMethod ( )

inline

                                                    {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("implicit");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setRedirectUris(Sets.newHashSet("https://foo.bar/"));

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

        }

heartMode_implicit_invalidGrants()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_implicit_invalidGrants ( )

inline

                                                       {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("implicit");
                grantTypes.add("authorization_code");
                grantTypes.add("client_credentials");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.NONE);

                client.setRedirectUris(Sets.newHashSet("https://foo.bar/"));

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

        }

heartMode_implicit_redirectUris()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_implicit_redirectUris ( )

inline

                                                      {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("implicit");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.NONE);

                service.saveNewClient(client);

        }

heartMode_multipleRedirectClass()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_multipleRedirectClass ( )

inline

                                                      {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("authorization_code");
                grantTypes.add("refresh_token");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setRedirectUris(Sets.newHashSet("http://localhost/", "https://foo.bar", "foo://bar"));

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

        }

heartMode_noJwks()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_noJwks ( )

inline

                                       {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("authorization_code");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setRedirectUris(Sets.newHashSet("https://foo.bar/"));

                client.setJwks(null);
                client.setJwksUri(null);

                service.saveNewClient(client);

        }

heartMode_nonLocalHttpRedirect()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_nonLocalHttpRedirect ( )

inline

                                                     {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("authorization_code");
                grantTypes.add("refresh_token");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setRedirectUris(Sets.newHashSet("http://foo.bar/"));

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

        }

heartMode_validAuthcodeClient()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.heartMode_validAuthcodeClient ( )

inline

                                                    {
                Mockito.when(config.isHeartMode()).thenReturn(true);

                ClientDetailsEntity client = new ClientDetailsEntity();
                Set<String> grantTypes = new LinkedHashSet<>();
                grantTypes.add("authorization_code");
                grantTypes.add("refresh_token");
                client.setGrantTypes(grantTypes);

                client.setTokenEndpointAuthMethod(AuthMethod.PRIVATE_KEY);

                client.setRedirectUris(Sets.newHashSet("https://foo.bar/"));

                client.setJwksUri("https://foo.bar/jwks");

                service.saveNewClient(client);

                assertThat(client.getClientId(), is(notNullValue(String.class)));
                assertThat(client.getClientSecret(), is(nullValue()));
        }

loadClientByClientId_badId()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.loadClientByClientId_badId ( )

inline

                                                 {

                // null id
                try {
                        service.loadClientByClientId(null);
                        fail("Null client id. Expected an IllegalArgumentException.");
                } catch (IllegalArgumentException e) {
                        assertThat(e, is(notNullValue()));
                }

                // empty id
                try {
                        service.loadClientByClientId("");
                        fail("Empty client id. Expected an IllegalArgumentException.");
                } catch (IllegalArgumentException e) {
                        assertThat(e, is(notNullValue()));
                }

                // id not found
                String clientId = "b00g3r";
                Mockito.when(clientRepository.getClientByClientId(clientId)).thenReturn(null);
                try {
                        service.loadClientByClientId(clientId);
                        fail("Client id not found. Expected an InvalidClientException.");
                } catch (InvalidClientException e) {
                        assertThat(e, is(notNullValue()));
                }

        }

prepare()

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

inline

                              {
                Mockito.reset(clientRepository, tokenRepository, approvedSiteService, whitelistedSiteService, blacklistedSiteService, scopeService, statsService);

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

                Mockito.when(clientRepository.updateClient(Matchers.anyLong(), Matchers.any(ClientDetailsEntity.class))).thenAnswer(new Answer<ClientDetailsEntity>() {
                        @Override
                        public ClientDetailsEntity answer(InvocationOnMock invocation) throws Throwable {
                                Object[] args = invocation.getArguments();
                                return (ClientDetailsEntity) args[1];
                        }
                });

                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 reserved scopes here, just pass through when it's called
                Mockito.when(scopeService.removeReservedScopes(Matchers.anySet())).then(AdditionalAnswers.returnsFirstArg());

                Mockito.when(config.isHeartMode()).thenReturn(false);

        }

saveNewClient_badId()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.saveNewClient_badId ( )

inline

Failure case of existing client id.

                                          {

                // Set up a mock client.
                ClientDetailsEntity client = Mockito.mock(ClientDetailsEntity.class);
                Mockito.when(client.getId()).thenReturn(12345L); // any non-null ID will work

                service.saveNewClient(client);
        }

saveNewClient_blacklisted()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.saveNewClient_blacklisted ( )

inline

Failure case of blacklisted client uri.

                                                {

                ClientDetailsEntity client = Mockito.mock(ClientDetailsEntity.class);
                Mockito.when(client.getId()).thenReturn(null);

                String badUri = "badplace.xxx";

                Mockito.when(blacklistedSiteService.isBlacklisted(badUri)).thenReturn(true);
                Mockito.when(client.getRegisteredRedirectUri()).thenReturn(Sets.newHashSet(badUri));

                service.saveNewClient(client);
        }

saveNewClient_idWasAssigned()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.saveNewClient_idWasAssigned ( )

inline

                                                  {

                // Set up a mock client.
                ClientDetailsEntity client = Mockito.mock(ClientDetailsEntity.class);
                Mockito.when(client.getId()).thenReturn(null);

                service.saveNewClient(client);

                Mockito.verify(client).setClientId(Matchers.anyString());
        }

saveNewClient_noOfflineAccess()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.saveNewClient_noOfflineAccess ( )

inline

Makes sure client does not have offline access if not allowed to have refresh tokens.

                                                    {

                ClientDetailsEntity client = new ClientDetailsEntity();

                client = service.saveNewClient(client);

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

                assertThat(client.getScope().contains(SystemScopeService.OFFLINE_ACCESS), is(equalTo(false)));
        }

saveNewClient_yesOfflineAccess()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.saveNewClient_yesOfflineAccess ( )

inline

Makes sure client has offline access granted scope if allowed refresh tokens.

                                                     {

                ClientDetailsEntity client = new ClientDetailsEntity();

                Set<String> grantTypes = new HashSet<>();
                grantTypes.add("refresh_token");
                client.setGrantTypes(grantTypes);

                client = service.saveNewClient(client);

                assertThat(client.getScope().contains(SystemScopeService.OFFLINE_ACCESS), is(equalTo(true)));
        }

updateClient_blacklistedUri()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.updateClient_blacklistedUri ( )

inline

                                                  {

                ClientDetailsEntity oldClient = Mockito.mock(ClientDetailsEntity.class);
                ClientDetailsEntity newClient = Mockito.mock(ClientDetailsEntity.class);

                String badSite = "badsite.xxx";

                Mockito.when(newClient.getRegisteredRedirectUri()).thenReturn(Sets.newHashSet(badSite));
                Mockito.when(blacklistedSiteService.isBlacklisted(badSite)).thenReturn(true);

                service.updateClient(oldClient, newClient);
        }

updateClient_noOfflineAccess()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.updateClient_noOfflineAccess ( )

inline

                                                   {

                ClientDetailsEntity oldClient = new ClientDetailsEntity();

                oldClient.getScope().add(SystemScopeService.OFFLINE_ACCESS);

                ClientDetailsEntity client = new ClientDetailsEntity();

                client = service.updateClient(oldClient, client);

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

                assertThat(client.getScope().contains(SystemScopeService.OFFLINE_ACCESS), is(equalTo(false)));
        }

updateClient_nullClients()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.updateClient_nullClients ( )

inline

                                               {

                ClientDetailsEntity oldClient = Mockito.mock(ClientDetailsEntity.class);
                ClientDetailsEntity newClient = Mockito.mock(ClientDetailsEntity.class);

                try {
                        service.updateClient(oldClient, null);
                        fail("New client is null. Expected an IllegalArgumentException.");
                } catch (IllegalArgumentException e) {
                        assertThat(e, is(notNullValue()));
                }

                try {
                        service.updateClient(null, newClient);
                        fail("Old client is null. Expected an IllegalArgumentException.");
                } catch (IllegalArgumentException e) {
                        assertThat(e, is(notNullValue()));
                }

                try {
                        service.updateClient(null, null);
                        fail("Both clients are null. Expected an IllegalArgumentException.");
                } catch (IllegalArgumentException e) {
                        assertThat(e, is(notNullValue()));
                }
        }

updateClient_yesOfflineAccess()

void org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.updateClient_yesOfflineAccess ( )

inline

                                                    {

                ClientDetailsEntity oldClient = new ClientDetailsEntity();
                ClientDetailsEntity client = new ClientDetailsEntity();

                Set<String> grantTypes = new HashSet<>();
                grantTypes.add("refresh_token");
                client.setGrantTypes(grantTypes);

                client = service.updateClient(oldClient, client);

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

                assertThat(client.getScope().contains(SystemScopeService.OFFLINE_ACCESS), is(equalTo(true)));
        }

メンバ詳解

approvedSiteService

ApprovedSiteService org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.approvedSiteService

private

blacklistedSiteService

BlacklistedSiteService org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.blacklistedSiteService

private

clientRepository

OAuth2ClientRepository org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.clientRepository

private

config

ConfigurationPropertiesBean org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.config

private

resourceSetService

ResourceSetService org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.resourceSetService

private

scopeService

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

private

service

DefaultOAuth2ClientDetailsEntityService org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.service

private

statsService

StatsService org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.statsService

private

tokenRepository

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

private

whitelistedSiteService

WhitelistedSiteService org.mitre.oauth2.service.impl.TestDefaultOAuth2ClientDetailsEntityService.whitelistedSiteService

private

---

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

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