How to use

isNull

method

in

org.assertj.core.api.AbstractStringAssert

  @Test
  public void getClaimAsStringWhenValueIsNullThenReturnNull() {
    String claimName = "claim-with-null-value";
    this.claims.put(claimName, null);

    assertThat(this.claimAccessor.getClaimAsString(claimName)).isNull();
  }
}

@Test
public void constructorWithErrorCodeWhenErrorCodeIsValidThenCreated() {
  BearerTokenError error = new BearerTokenError(TEST_ERROR_CODE, TEST_HTTP_STATUS, null, null);
  assertThat(error.getErrorCode()).isEqualTo(TEST_ERROR_CODE);
  assertThat(error.getHttpStatus()).isEqualTo(TEST_HTTP_STATUS);
  assertThat(error.getDescription()).isNull();
  assertThat(error.getUri()).isNull();
  assertThat(error.getScope()).isNull();
}

@Test
public void getAttribute() {
  assertThat(attribute.getAttribute()).isNull();
}

@Test
public void deserializeCasAuthenticationTestAfterEraseCredentialInvoked() throws Exception {
  CasAuthenticationToken token = mapper.readValue(CAS_TOKEN_CLEARED_JSON, CasAuthenticationToken.class);
  assertThat(((UserDetails) token.getPrincipal()).getPassword()).isNull();
}

@Test public void enclosing() throws Exception {
 assertThat(IdentifierSet.enclosing("a.b.Outer#member")).isEqualTo("a.b.Outer");
 assertThat(IdentifierSet.enclosing("a.b.Outer")).isEqualTo("a.b.*");
 assertThat(IdentifierSet.enclosing("a.b.*")).isEqualTo("a.*");
 assertThat(IdentifierSet.enclosing("a.*")).isEqualTo("*");
 assertThat(IdentifierSet.enclosing("*")).isNull();
}

@Test
public void resolveWhenHeaderWithWrongSchemeIsPresentThenTokenIsNotResolved() {
  MockHttpServletRequest request = new MockHttpServletRequest();
  request.addHeader("Authorization", "Basic " + Base64.getEncoder().encodeToString("test:test".getBytes()));
  assertThat(this.resolver.resolve(request)).isNull();
}

@Test
public void preAuthorize() {
  this.spring.register(SampleWebSecurityConfig.class).autowire();
  assertThat(this.methodSecurityService.secured()).isNull();
  assertThat(this.methodSecurityService.jsr250()).isNull();
  assertThatThrownBy(() -> this.methodSecurityService.preAuthorize())
    .isInstanceOf(AccessDeniedException.class);
}

@Test
public void testNullContextHolderIsNull() throws Exception {
  SecurityContextHolder.getContext().setAuthentication(null);
  // Create a connection and ensure our executor sets its
  // properties correctly
  AuthenticationSimpleHttpInvokerRequestExecutor executor = new AuthenticationSimpleHttpInvokerRequestExecutor();
  HttpURLConnection conn = new MockHttpURLConnection(new URL("http://localhost/"));
  executor.prepareConnection(conn, 10);
  // Check connection properties (shouldn't be an Authorization header)
  assertThat(conn.getRequestProperty("Authorization")).isNull();
}

@Test
public void deserializeUserWithNullPasswordNoAuthorityTest() throws Exception {
  String userJsonWithoutPasswordString = removeNode(userWithNoAuthoritiesJson(), mapper, "password");
  User user = mapper.readValue(userJsonWithoutPasswordString, User.class);
  assertThat(user).isNotNull();
  assertThat(user.getUsername()).isEqualTo("admin");
  assertThat(user.getPassword()).isNull();
  assertThat(user.getAuthorities()).isEmpty();
  assertThat(user.isEnabled()).isEqualTo(true);
}

@Test
public void resolveWhenNoHeaderIsPresentThenTokenIsNotResolved() {
  MockHttpServletRequest request = new MockHttpServletRequest();
  assertThat(this.resolver.resolve(request)).isNull();
}

@Test
public void customPermissionHandler() {
  this.spring.register(CustomPermissionEvaluatorWebSecurityConfig.class).autowire();
  assertThat(this.methodSecurityService.hasPermission("allowed")).isNull();
  assertThatThrownBy(() -> this.methodSecurityService.hasPermission("denied"))
    .isInstanceOf(AccessDeniedException.class);
}

@Test
public void resourceContainsExpectedData() throws Exception {
  InMemoryResource resource = new InMemoryResource("blah");
  assertThat(resource.getDescription()).isNull();
  assertThat(resource.hashCode()).isEqualTo(1);
  assertThat(resource.getInputStream()).isNotNull();
}

@Test
public void matchersFalse() {
  messages.matchers(matcher).permitAll();
  assertThat(getAttribute()).isNull();
}

@Test
public void filterWhenAuthorizedClientNullThenAuthorizationHeaderNull() {
  ClientRequest request = ClientRequest.create(GET, URI.create("https://example.com"))
    .build();
  this.function.filter(request, this.exchange).block();
  assertThat(this.exchange.getRequest().headers().getFirst(HttpHeaders.AUTHORIZATION)).isNull();
}

@Test
public void filterWhenAuthorizedClientNullThenAuthorizationHeaderNull() {
  ClientRequest request = ClientRequest.create(GET, URI.create("https://example.com"))
      .build();
  this.function.filter(request, this.exchange).block();
  assertThat(this.exchange.getRequest().headers().getFirst(HttpHeaders.AUTHORIZATION)).isNull();
}

  @Test
  public void resolveWhenQueryParameterIsPresentAndNotSupportedThenTokenIsNotResolved() {
    MockHttpServletRequest request = new MockHttpServletRequest();
    request.setMethod("GET");
    request.addParameter("access_token", TEST_TOKEN);

    assertThat(this.resolver.resolve(request)).isNull();
  }
}

@Test
public void getNameWhenJwtHasNoSubjectThenReturnsNull() {
  Jwt jwt = this.jwt(Maps.newHashMap("claim", "value"));
  JwtAuthenticationToken token = new JwtAuthenticationToken(jwt);
  assertThat(token.getName()).isNull();
}

@Test
public void resolveWhenFormParameterIsPresentAndNotSupportedThenTokenIsNotResolved() {
  MockHttpServletRequest request = new MockHttpServletRequest();
  request.setMethod("POST");
  request.setContentType("application/x-www-form-urlencoded");
  request.addParameter("access_token", TEST_TOKEN);
  assertThat(this.resolver.resolve(request)).isNull();
}

@Test
public void findByUsernameWhenClearCredentialsThenFindByUsernameStillHasCredentials() {
  User foundUser = users.findByUsername(USER_DETAILS.getUsername()).cast(User.class).block();
  assertThat(foundUser.getPassword()).isNotEmpty();
  foundUser.eraseCredentials();
  assertThat(foundUser.getPassword()).isNull();
  foundUser = users.findByUsername(USER_DETAILS.getUsername()).cast(User.class).block();
  assertThat(foundUser.getPassword()).isNotEmpty();
}

@Test
public void credentialsAreCleared() {
  LdapUserDetailsImpl.Essence mutableLdapUserDetails = new LdapUserDetailsImpl.Essence();
  mutableLdapUserDetails.setDn("uid=username1,ou=people,dc=example,dc=com");
  mutableLdapUserDetails.setUsername("username1");
  mutableLdapUserDetails.setPassword("password");
  LdapUserDetails ldapUserDetails = mutableLdapUserDetails.createUserDetails();
  assertThat(ldapUserDetails).isInstanceOf(CredentialsContainer.class);
  ldapUserDetails.eraseCredentials();
  assertThat(ldapUserDetails.getPassword()).isNull();
}