Java EntityType.Combined方法代码示例

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Test(expected = IllegalArgumentException.class)
public void testUpdateThrowsIllegalArgumentExceptionForExpiredTokens() throws IOException {
    final AuthenticationToken<EntityType.Combined, TokenType.Simple> token1 = mockToken(false);
    final AuthenticationToken<EntityType.Combined, TokenType.Simple> token2 = mockToken(true);
    when(token2.hasExpired()).thenReturn(true);

    TokenProxy<EntityType.Combined, TokenType.Simple> key = null;

    try {
        key = tokenRepository.insert(token1);
    } catch (final IllegalArgumentException e) {
        fail("The initial token should not have expired");
    }

    tokenRepository.update(key, token2);
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Test
public void deserializes() throws IOException, ClassNotFoundException {
    final HodAuthentication<EntityType.Combined> deserializedAuthentication = deserializeFromResource("serializedHodAuthentication.ser");
    assertThat(deserializedAuthentication.getTokenProxy(), not(nullValue()));

    final Collection<GrantedAuthority> authorities = deserializedAuthentication.getAuthorities();
    assertThat(authorities, contains(GRANTED_AUTHORITY));

    final HodAuthenticationPrincipal principal = deserializedAuthentication.getPrincipal();
    assertThat(principal.getTenantUuid(), is(TENANT_UUID));
    assertThat(principal.getUserUuid(), is(USER_UUID));
    assertThat(principal.getApplication(), is(APPLICATION));
    assertThat(principal.getUserStoreInformation(), is(USER_STORE));
    assertThat(principal.getApplicationAuthentication(), is(APP_AUTHENTICATION));
    assertThat(principal.getUserAuthentication(), is(USER_AUTHENTICATION));
    assertThat(principal.getUserMetadata(), is(METADATA));
    assertThat(principal.getName(), is(NAME));
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Test
public void authenticatesWithRole() throws HodErrorException, IOException {
    final HodAuthenticationProvider provider = createSimpleProvider();
    final Authentication tokenAuthentication = new HodTokenAuthentication<>(combinedSsoToken);

    @SuppressWarnings("unchecked")
    final HodAuthentication<EntityType.Combined> authentication = (HodAuthentication<EntityType.Combined>) provider.authenticate(tokenAuthentication);

    verify(tokenRepository, times(1)).insert(combinedToken);

    assertThat(authentication.getTokenProxy(), is(tokenProxy));

    final HodAuthenticationPrincipal principal = authentication.getPrincipal();

    assertThat(principal.getApplication().getName(), is(APPLICATION_NAME));
    assertThat(principal.getUserUuid(), is(USER_UUID));
    assertThat(principal.getUserMetadata().size(), is(0));

    final Collection<GrantedAuthority> authorities = authentication.getAuthorities();

    assertThat(authorities, containsInAnyOrder(
            new SimpleGrantedAuthority(USER_ROLE),
            new HodApplicationGrantedAuthority(new ResourceName(APPLICATION_DOMAIN, APPLICATION_NAME))
    ));
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Before
public void setUp() throws IOException {
    tokenProxy = new TokenProxy<>(EntityType.Combined.INSTANCE, TokenType.Simple.INSTANCE);

    final AuthenticationToken<EntityType.Combined, TokenType.Simple> token = new AuthenticationToken<>(
            EntityType.Combined.INSTANCE,
            TokenType.Simple.INSTANCE,
            DateTime.now().plus(standardHours(2)),
            "token-id",
            "token-secret",
            DateTime.now().plus(standardHours(1))
    );

    final TokenRepository tokenRepository = mock(TokenRepository.class);
    when(tokenRepository.get(tokenProxy)).thenReturn(token);

    logoutSuccessHandler = new HodTokenLogoutSuccessHandler(REDIRECT_PATH, tokenRepository);
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Bean
@ConditionalOnMissingBean(AuthenticationInformationRetriever.class)
public AuthenticationInformationRetriever<HodAuthentication<EntityType.Combined>, HodAuthenticationPrincipal> authenticationInformationRetriever() {
    @SuppressWarnings("unchecked")
    final AuthenticationInformationRetriever<HodAuthentication<EntityType.Combined>, HodAuthenticationPrincipal> retriever =
            new SpringSecurityAuthenticationInformationRetriever<>((Class<HodAuthentication<EntityType.Combined>>) (Class<?>) HodAuthentication.class, HodAuthenticationPrincipal.class);
    return retriever;
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Bean
@ConditionalOnMissingBean(HodServiceConfig.class)
public HodServiceConfig<EntityType.Combined, TokenType.Simple> hodServiceConfig(
        final TokenProxyService<EntityType.Combined, TokenType.Simple> tokenProxyService,
        final HttpClient httpClient,
        final TokenRepository tokenRepository,
        final ObjectMapper objectMapper
) {
    return new HodServiceConfig.Builder<EntityType.Combined, TokenType.Simple>(HOD_URL)
            .setTokenProxyService(tokenProxyService)
            .setHttpClient(httpClient)
            .setTokenRepository(tokenRepository)
            .setObjectMapper(objectMapper)
            .build();
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Test
public void multipleTokenTypes() throws IOException {
    final AuthenticationToken<EntityType.Combined, TokenType.Simple> combinedToken = new AuthenticationToken<>(
        EntityType.Combined.INSTANCE,
        TokenType.Simple.INSTANCE,
        getExpiry(),
        "combined-id",
        "combined-secret",
        getRefresh()
    );

    final AuthenticationToken<EntityType.Developer, TokenType.HmacSha1> developerToken = new AuthenticationToken<>(
        EntityType.Developer.INSTANCE,
        TokenType.HmacSha1.INSTANCE,
        getExpiry(),
        "developer-id",
        "developer-secret",
        getRefresh()
    );

    final TokenProxy<EntityType.Combined, TokenType.Simple> combinedTokenProxy = tokenRepository.insert(combinedToken);
    final TokenProxy<EntityType.Developer, TokenType.HmacSha1> developerTokenProxy = tokenRepository.insert(developerToken);

    final AuthenticationToken<EntityType.Combined, TokenType.Simple> outputCombinedToken = tokenRepository.get(combinedTokenProxy);
    final AuthenticationToken<EntityType.Developer, TokenType.HmacSha1> outputDeveloperToken = tokenRepository.get(developerTokenProxy);

    assertThat(outputDeveloperToken, is(developerToken));
    assertThat(outputCombinedToken, is(combinedToken));
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Test
public void testUpdate() {
    final AuthenticationToken<EntityType.Combined, TokenType.Simple> token = mockToken(false);

    final TokenProxy<EntityType.Combined, TokenType.Simple> key = tokenRepository.insert(token);

    final AuthenticationToken<EntityType.Combined, TokenType.Simple> newToken = mockToken(false);
    tokenRepository.update(key, newToken);

    assertThat(tokenRepository.get(key), is(newToken));
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Test
public void testUpdateReturnsNullAndDoesNothingIfKeyNotPresent() {
    final TokenProxy<EntityType.Combined, TokenType.Simple> key = new TokenProxy<>(EntityType.Combined.INSTANCE, TokenType.Simple.INSTANCE);
    final AuthenticationToken<EntityType.Combined, TokenType.Simple> oldToken = tokenRepository.update(key, mockToken(false));

    assertThat(oldToken, is(nullValue()));
    assertThat(tokenRepository.get(key), is(nullValue()));
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Test
public void testRemove() {
    final AuthenticationToken<EntityType.Combined, TokenType.Simple> token = mockToken(false);
    final TokenProxy<EntityType.Combined, TokenType.Simple> key = tokenRepository.insert(token);

    assertThat(tokenRepository.remove(key), is(token));
    assertThat(tokenRepository.get(key), is(nullValue()));
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
private AuthenticationToken<EntityType.Combined, TokenType.Simple> mockToken(final boolean expired) {
    @SuppressWarnings("unchecked")
    final AuthenticationToken<EntityType.Combined, TokenType.Simple> token = mock(AuthenticationToken.class);

    when(token.hasExpired()).thenReturn(expired);
    when(token.getEntityType()).thenReturn(EntityType.Combined.INSTANCE);
    when(token.getTokenType()).thenReturn(TokenType.Simple.INSTANCE);

    return token;
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Override
public Collection<GrantedAuthority> resolveAuthorities(
        final TokenProxy<EntityType.Combined, TokenType.Simple> tokenProxy,
        final CombinedTokenInformation combinedTokenInformation
) {
    final Collection<GrantedAuthority> output = new LinkedList<>();

    for (final String authority : authorities) {
        output.add(new SimpleGrantedAuthority(authority));
    }

    return output;
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Override
public void onLogoutSuccess(final HttpServletRequest request, final HttpServletResponse response, final Authentication authentication) throws IOException, ServletException {
    String redirectUrl = redirectPath;

    if (authentication instanceof HodAuthentication) {
        // Usage of this class requires that application authentications are HodAuthentication<Combined>.
        @SuppressWarnings("unchecked")
        final HodAuthentication<EntityType.Combined> hodAuthentication = (HodAuthentication<EntityType.Combined>) authentication;

        final AuthenticationToken<EntityType.Combined, TokenType.Simple> combinedToken = tokenRepository.get(hodAuthentication.getTokenProxy());
        redirectUrl += "?token=" + uriEncode(combinedToken.toString());
    }

    redirectStrategy.sendRedirect(request, response, redirectUrl);
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
private HodUserMetadata retrieveMetadata (
        final TokenProxy<EntityType.Combined, TokenType.Simple> combinedTokenProxy,
        final CombinedTokenInformation combinedTokenInformation,
        final ResourceIdentifier userStore
) throws HodErrorException {
    return userStoreUsersService == null ?
            new HodUserMetadata("", Collections.emptyMap()) :
            hodUserMetadataResolver.resolve(userStoreUsersService.getUserMetadata(combinedTokenProxy, userStore, combinedTokenInformation.getUser().getUuid()));
}
 

import com.hp.autonomy.hod.client.api.authentication.EntityType; //导入方法依赖的package包/类
@Test
public void serializesAndDeserializes() throws IOException, ClassNotFoundException {
    final HodAuthentication<EntityType.Combined> authentication = new HodAuthentication<>(
            new TokenProxy<>(EntityType.Combined.INSTANCE, TokenType.Simple.INSTANCE),
            Collections.singleton(GRANTED_AUTHORITY),
            PRINCIPAL
    );

    final HodAuthentication<EntityType.Combined> outputAuthentication = writeAndReadObject(authentication);
    assertThat(outputAuthentication, is(authentication));
}