Java ReflectionTestUtils类代码示例

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test
public void sendRegistrationSuccessEmailSMTP() {
    ReflectionTestUtils.setField(sut, "mailEnabled", true);

    String email = "[email protected]";
    String subject = "Your registration was successful";
    String expected = "Hello!\nYour registration was accepted by an administrator";

    sut.sendSuccessEmail(email, "registration");

    ArgumentCaptor<SimpleMailMessage> captor = ArgumentCaptor.forClass(SimpleMailMessage.class);
    verify(sender, times(1)).send(captor.capture());
    SimpleMailMessage message = captor.getValue();


    assertEquals(1, message.getTo().length);
    assertEquals(email, message.getTo()[0]);
    assertEquals(subject, message.getSubject());
    assertEquals(expected, message.getText());
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test
public void parseSessionDataFailsIfStampIsExpired() throws Exception {
    ReflectionTestUtils.setField(parser, "clock", expired);

    MultivaluedMap<String,String> initParams = getValidInitParams();
    initParams.putSingle("sessionId", "1234567890");
    when(authenticationHandlerUtils.popFromCache(any())).thenReturn(initParams);

    Map<String,String> attributeNameMap = mock(Map.class);
    when(attributeNameMap.get("B02K_CUSTID")).thenReturn("ATTRNAME_CUSTID");
    when(attributeNameMap.get("B02K_CUSTNAME")).thenReturn("ATTRNAME_CUSTNAME");

    MultivaluedMap<String,String> sessionParams = getValidSessionParamsWithHetu();
    sessionParams.putSingle("sessionId", "1234567890");

    assertNull(parser.parseSessionData(sessionParams));
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test
public void shouldHaveAwsCredentialsIntanceWhenEndpointUrlIsNotProvidedAndProfileIsProvided() {
    ReflectionTestUtils.setField(config, "ENDPOINT_URL", "");
    ReflectionTestUtils.setField(config, "PROFILE", "default");
    Assert.isInstanceOf(AWSCredentials.class,
            config.awsCredentials(new StubProfileCredentialsProvider()));
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    doNothing().when(mockMailService).sendActivationEmail((User) anyObject(), anyString());

    AccountResource accountResource = new AccountResource();
    ReflectionTestUtils.setField(accountResource, "userRepository", userRepository);
    ReflectionTestUtils.setField(accountResource, "userService", userService);
    ReflectionTestUtils.setField(accountResource, "mailService", mockMailService);

    AccountResource accountUserMockResource = new AccountResource();
    ReflectionTestUtils.setField(accountUserMockResource, "userRepository", userRepository);
    ReflectionTestUtils.setField(accountUserMockResource, "userService", mockUserService);
    ReflectionTestUtils.setField(accountUserMockResource, "mailService", mockMailService);

    this.restMvc = MockMvcBuilders.standaloneSetup(accountResource).build();
    this.restUserMockMvc = MockMvcBuilders.standaloneSetup(accountUserMockResource).build();
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test
public void portEightyShortenURL() {
    when(env.getProperty("local.server.port")).thenReturn("80");
    ReflectionTestUtils.setField(sut, "mailEnabled", false);
    String id = "1234567890";
    String email = "[email protected]";

    String expected = "Sent to [email protected]\nVerify Email\nHello!\n" +
            "Someone has created an account for this email address. If this was not you then just ignore " +
            "this message. If it was you then click the link bellow.\n\n" +
            "http://localhost/api/visitor/verify_email?id=" + id + "\n";

    sut.sendVerificationEmail(id, email);

    assertEquals(expected, outContent.toString());
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void testFlushAll() {
    InMemoryAttributeCache inMemoryAttributeCache = new InMemoryAttributeCache(5, TEST_ZONE,
            AbstractAttributeCache::subjectKey);
    Set<Attribute> attributes = Collections.singleton(new Attribute("https://test.com", "attribute1", "value1"));
    CachedAttributes cachedAttributes = new CachedAttributes(attributes);

    Map<String, CachedAttributes> cachedAttributesMap = new HashMap<>();
    String cacheKey = AbstractAttributeCache.subjectKey(TEST_ZONE, TEST_KEY);
    cachedAttributesMap.put(cacheKey, cachedAttributes);
    ReflectionTestUtils.setField(inMemoryAttributeCache, "attributeCache", cachedAttributesMap);
    Assert.assertEquals(inMemoryAttributeCache.get(TEST_KEY), cachedAttributes);
    inMemoryAttributeCache.flushAll();
    Assert.assertTrue(
            ((Map<String, CachedAttributes>) ReflectionTestUtils.getField(inMemoryAttributeCache, "attributeCache"))
                    .isEmpty());

}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  instanceConfigAuditUtil = new InstanceConfigAuditUtil();

  ReflectionTestUtils.setField(instanceConfigAuditUtil, "instanceService", instanceService);

  audits = (BlockingQueue<InstanceConfigAuditUtil.InstanceConfigAuditModel>)
      ReflectionTestUtils.getField(instanceConfigAuditUtil, "audits");

  someAppId = "someAppId";
  someClusterName = "someClusterName";
  someDataCenter = "someDataCenter";
  someIp = "someIp";
  someConfigAppId = "someConfigAppId";
  someConfigClusterName = "someConfigClusterName";
  someConfigNamespace = "someConfigNamespace";
  someReleaseKey = "someReleaseKey";

  someAuditModel = new InstanceConfigAuditUtil.InstanceConfigAuditModel(someAppId,
      someClusterName, someDataCenter, someIp, someConfigAppId, someConfigClusterName,
      someConfigNamespace, someReleaseKey);
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test
public void testCustomizeServletContainer() {
    env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION);
    UndertowEmbeddedServletContainerFactory container = new UndertowEmbeddedServletContainerFactory();
    webConfigurer.customize(container);
    assertThat(container.getMimeMappings().get("abs")).isEqualTo("audio/x-mpeg");
    assertThat(container.getMimeMappings().get("html")).isEqualTo("text/html;charset=utf-8");
    assertThat(container.getMimeMappings().get("json")).isEqualTo("text/html;charset=utf-8");
    if (container.getDocumentRoot() != null) {
        assertThat(container.getDocumentRoot().getPath()).isEqualTo("target/www");
    }

    Builder builder = Undertow.builder();
    container.getBuilderCustomizers().forEach(c -> c.customize(builder));
    OptionMap.Builder serverOptions = (OptionMap.Builder) ReflectionTestUtils.getField(builder, "serverOptions");
    assertThat(serverOptions.getMap().get(UndertowOptions.ENABLE_HTTP2)).isNull();
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  controller = new NotificationController();
  ReflectionTestUtils.setField(controller, "releaseMessageService", releaseMessageService);
  ReflectionTestUtils.setField(controller, "entityManagerUtil", entityManagerUtil);
  ReflectionTestUtils.setField(controller, "namespaceUtil", namespaceUtil);
  ReflectionTestUtils.setField(controller, "watchKeysUtil", watchKeysUtil);

  someAppId = "someAppId";
  someCluster = "someCluster";
  defaultCluster = ConfigConsts.CLUSTER_NAME_DEFAULT;
  defaultNamespace = ConfigConsts.NAMESPACE_APPLICATION;
  somePublicNamespace = "somePublicNamespace";
  someDataCenter = "someDC";
  someNotificationId = 1;
  someClientIp = "someClientIp";

  when(namespaceUtil.filterNamespaceName(defaultNamespace)).thenReturn(defaultNamespace);
  when(namespaceUtil.filterNamespaceName(somePublicNamespace)).thenReturn(somePublicNamespace);

  deferredResults =
      (Multimap<String, DeferredResult<ResponseEntity<ApolloConfigNotification>>>) ReflectionTestUtils
          .getField(controller, "deferredResults");
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test(dataProvider = "statuses")
public void testHealth(final GraphResourceRepository graphResourceRepository, final Status status,
        final AcsMonitoringUtilities.HealthCode healthCode, final boolean cassandraEnabled) throws Exception {
    GraphDbHealthIndicator graphDbHealthIndicator = new GraphDbHealthIndicator(graphResourceRepository);
    ReflectionTestUtils.setField(graphDbHealthIndicator, "cassandraEnabled", cassandraEnabled);
    Assert.assertEquals(status, graphDbHealthIndicator.health().getStatus());
    Assert.assertEquals(GraphDbHealthIndicator.DESCRIPTION,
            graphDbHealthIndicator.health().getDetails().get(AcsMonitoringUtilities.DESCRIPTION_KEY));
    if (healthCode == AcsMonitoringUtilities.HealthCode.AVAILABLE) {
        Assert.assertFalse(
                graphDbHealthIndicator.health().getDetails().containsKey(AcsMonitoringUtilities.CODE_KEY));
    } else {
        Assert.assertEquals(healthCode,
                graphDbHealthIndicator.health().getDetails().get(AcsMonitoringUtilities.CODE_KEY));
    }
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test
public void testCustomizeServletContainer() {
    env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION);
    UndertowEmbeddedServletContainerFactory container = new UndertowEmbeddedServletContainerFactory();
    webConfigurer.customize(container);
    assertThat(container.getMimeMappings().get("abs")).isEqualTo("audio/x-mpeg");
    assertThat(container.getMimeMappings().get("html")).isEqualTo("text/html;charset=utf-8");
    assertThat(container.getMimeMappings().get("json")).isEqualTo("text/html;charset=utf-8");
    if (container.getDocumentRoot() != null) {
        assertThat(container.getDocumentRoot().getPath()).isEqualTo(FilenameUtils.separatorsToSystem("build/www"));
    }

    Builder builder = Undertow.builder();
    container.getBuilderCustomizers().forEach(c -> c.customize(builder));
    OptionMap.Builder serverOptions = (OptionMap.Builder) ReflectionTestUtils.getField(builder, "serverOptions");
    assertThat(serverOptions.getMap().get(UndertowOptions.ENABLE_HTTP2)).isNull();
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test
public void testCustomizeServletContainer() {
    env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION);
    UndertowEmbeddedServletContainerFactory container = new UndertowEmbeddedServletContainerFactory();
    webConfigurer.customize(container);
    assertThat(container.getMimeMappings().get("abs")).isEqualTo("audio/x-mpeg");
    assertThat(container.getMimeMappings().get("html")).isEqualTo("text/html;charset=utf-8");
    assertThat(container.getMimeMappings().get("json")).isEqualTo("text/html;charset=utf-8");
    if (container.getDocumentRoot() != null) {
        assertThat(container.getDocumentRoot().getPath()).isEqualTo(FilenameUtils.separatorsToSystem("target/www"));
    }

    Builder builder = Undertow.builder();
    container.getBuilderCustomizers().forEach(c -> c.customize(builder));
    OptionMap.Builder serverOptions = (OptionMap.Builder) ReflectionTestUtils.getField(builder, "serverOptions");
    assertThat(serverOptions.getMap().get(UndertowOptions.ENABLE_HTTP2)).isNull();
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Test
public void shouldAddANewCustomer() throws Exception {

	final Customer newCustomer = Customer.ofType(PERSON).build();

	final ObjectId id = ObjectId.get();
	ReflectionTestUtils.setField(newCustomer, "id", id);

	given(repo.existsById(any(ObjectId.class))).willReturn(Mono.just(false));
	given(repo.save(any(Customer.class))).willReturn(Mono.just(newCustomer));

	webClient.post().uri("/customers")
		.contentType(APPLICATION_JSON_UTF8)
		.body(fromObject("{\"customer_type\":\"PERSON\"}"))
		.exchange()
		.expectStatus().isCreated()	// HTTP 201
		.expectHeader().valueEquals("Location", String.format("/customers/%s", id));
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  MockInjector.reset();

  MockInjector.setInstance(HttpUtil.class, httpUtil);

  someServerUrl = "http://someServer";
  ServiceDTO serviceDTO = mock(ServiceDTO.class);
  when(serviceDTO.getHomepageUrl()).thenReturn(someServerUrl);
  when(configServiceLocator.getConfigServices()).thenReturn(Lists.newArrayList(serviceDTO));
  MockInjector.setInstance(ConfigServiceLocator.class, configServiceLocator);

  MockInjector.setInstance(ConfigUtil.class, new MockConfigUtil());

  remoteConfigLongPollService = new RemoteConfigLongPollService();

  responseType =
      (Type) ReflectionTestUtils.getField(remoteConfigLongPollService, "m_responseType");

  someAppId = "someAppId";
  someCluster = "someCluster";
}
 

import org.springframework.test.util.ReflectionTestUtils; //导入依赖的package包/类
private ApplicationContext getApplicationContext(Object testInstance) {
    try {
        return (ApplicationContext) ReflectionTestUtils.getField(testInstance, "applicationContext");
    } catch (Exception e) {
        throw new IllegalStateException("@TuPactManager requires application context to be present, are you extending AbstractJUnit4SpringContextTests?");
    }
}