org.eclipse.microprofile.jwt.ClaimValue Java Examples

@Override
public Object apply(CreationalContext<Object> cc, BiFunctionBean<?> bean) {
    BeanManager beanManager = CDI.current().getBeanManager();
    InjectionPoint ip = (InjectionPoint) beanManager.getInjectableReference(new EmptyInjectionPoint(bean), cc);
    ClaimDefinition claimDefinition = toDefinition(ip);
    JWTPrincipal jwtPrincipal = CDI.current().select(JWTPrincipal.class).get();
    HammockClaimValue value = new HammockClaimValue<>(jwtPrincipal, claimDefinition);
    if (claimDefinition.returnType instanceof ParameterizedType &&
            ((Class)((ParameterizedType)claimDefinition.returnType).getRawType()).isAssignableFrom(ClaimValue.class)) {
        return value;
    }
    else {
        return value.getValue();
    }
}
 

@Test
public void testOptionalIssuerInjected() {
    jwtProducer = weld.select(PrincipalProducer.class).get();
    jwtProducer.setJsonWebToken(jwt);
    Mockito.when(jwt.claim(Claims.iss.name())).thenReturn(Optional.of("issuer1"));
    ClaimValue<Optional<String>> issuer = selectOptionalClaimValue("iss");

    assertNotNull(issuer);
    assertEquals("iss", issuer.getName());
    assertTrue(issuer.getValue().isPresent());
    assertEquals("issuer1", issuer.getValue().get());
}
 

@Test(expected = NoSuchElementException.class)
public void testOptionalIssuerNotPresent() {
    ClaimValue<Optional<String>> issuer = selectOptionalClaimValue("iss");

    assertNotNull(issuer);
    assertEquals("iss", issuer.getName());
    assertTrue(!issuer.getValue().isPresent());
    issuer.getValue().get();
}
 

@Test
public void testIssuerInjected() {
    jwtProducer = weld.select(PrincipalProducer.class).get();
    jwtProducer.setJsonWebToken(jwt);
    Mockito.when(jwt.claim(Claims.iss.name())).thenReturn(Optional.of("issuer1"));
    ClaimValue<String> issuer = selectClaimValue("iss");

    assertNotNull(issuer);
    assertEquals("iss", issuer.getName());
    assertEquals("issuer1", issuer.getValue());
}
 

@Test
public void testIssuerNull() {
    ClaimValue<String> issuer = selectClaimValue("iss");
    assertNotNull(issuer);
    assertEquals("iss", issuer.getName());
    assertNull(issuer.getValue());
}
 

ClaimValue<Set<String>> getSetClaimValue() {
    return setClaimValue;
}
 

@SuppressWarnings({ "serial" })
<T> ClaimValue<Optional<T>> selectOptionalClaimValue(String name) {
    return weld.select(new TypeLiteral<ClaimValue<Optional<T>>>() {
    },
            new ClaimQualifier(name, null)).get();
}
 

@SuppressWarnings("unchecked")
<T> ClaimValue<T> selectClaimValue(String name) {
    return weld.select(ClaimValue.class, new ClaimQualifier(name, null)).get();
}
 

ClaimValue<Optional<JsonObject>> getAddressClaimValueOptionalJson() {
    return addressClaimValueOptionalJson;
}
 

ClaimValue<JsonObject> getAddressClaimValueJson() {
    return addressClaimValueJson;
}
 

ClaimValue<Optional<Address>> getAddressClaimValueOptional() {
    return addressClaimValueOptional;
}
 

ClaimValue<Address> getAddressClaimValue() {
    return addressClaimValue;
}
 

ClaimValue<Optional<JsonArray>> getSetClaimValueOptionalJson() {
    return setClaimValueOptionalJson;
}
 

ClaimValue<JsonArray> getSetClaimValueJson() {
    return setClaimValueJson;
}
 

ClaimValue<Optional<Set<String>>> getSetClaimValueOptional() {
    return setClaimValueOptional;
}
 

@Produces
@Claim("")
<T> ClaimValue<T> produceClaim(InjectionPoint ip) {
    return new ClaimValueWrapper<>(ip, util);
}
 

ClaimValue<Optional<JsonString>> getStringClaimValueOptionalJson() {
    return stringClaimValueOptionalJson;
}
 

ClaimValue<JsonString> getStringClaimValueJson() {
    return stringClaimValueJson;
}
 

ClaimValue<Optional<String>> getStringClaimValueOptional() {
    return stringClaimValueOptional;
}
 

ClaimValue<String> getStringClaimValue() {
    return stringClaimValue;
}
 

ClaimValue<Optional<JsonNumber>> getLongClaimValueOptionalJson() {
    return longClaimValueOptionalJson;
}
 

ClaimValue<JsonNumber> getLongClaimValueJson() {
    return longClaimValueJson;
}
 

ClaimValue<Optional<Long>> getLongClaimValueOptional() {
    return longClaimValueOptional;
}
 

ClaimValue<Long> getLongClaimValue() {
    return longClaimValue;
}
 

ClaimValue<Optional<JsonValue>> getBooleanClaimValueOptionalJson() {
    return booleanClaimValueOptionalJson;
}
 

ClaimValue<JsonValue> getBooleanClaimValueJson() {
    return booleanClaimValueJson;
}
 

ClaimValue<Optional<Boolean>> getBooleanClaimValueOptional() {
    return booleanClaimValueOptional;
}
 

ClaimValue<Boolean> getBooleanClaimValue() {
    return booleanClaimValue;
}
 

private Class<?> unwrapType(final Type type, final InjectionPoint injectionPoint) {
    if (type instanceof ParameterizedType) {
        final ParameterizedType parameterizedType = (ParameterizedType) type;
        if (parameterizedType.getActualTypeArguments().length == 1) {
            final Type rawType = parameterizedType.getRawType();
            final Type actualType = parameterizedType.getActualTypeArguments()[0];

            if (rawType == ClaimValue.class) {
                return unwrapType(actualType, injectionPoint);
            }

            if (rawType == Optional.class) {
                // Needs to be improved, so we don't have a separate boolean flag if Optional. Kept this way to minimize code changes.
                return unwrapType(actualType, injectionPoint);
            }

            if (rawType instanceof Class && Set.class.isAssignableFrom((Class<?>) rawType)) {
                return (Class<?>) rawType;
            }

            if (rawType == Provider.class || rawType == Instance.class) {
                return unwrapType(actualType, injectionPoint);
            }
        }
    } else if (type instanceof Class) {
        final Class<?> klass = (Class<?>) type;
        if (Long.class.isAssignableFrom(klass) || klass == long.class ||
                Boolean.class.isAssignableFrom(klass) || klass == boolean.class ||
                String.class.isAssignableFrom(klass) ||
                JsonValue.class.isAssignableFrom(klass) ||
                ClaimValue.class.isAssignableFrom(klass) ||
                Optional.class.isAssignableFrom(klass)) {

            return klass;
        }
    }

    // We should throw DeploymentException here, but we never had validation on supported injection types, do it is
    // possible to inject non supported types as long as you get the right type from the claim set.
    //throw new DeploymentException("Type " + type + " not supported for @ClaimValue injection " + injectionPoint);
    return null;
}