Java 类org.springframework.core.env.MapPropertySource 实例源码

private void addDefaultProperty(ConfigurableEnvironment environment, String name,
                                String value) {
    MutablePropertySources sources = environment.getPropertySources();
    Map<String, Object> map = null;
    if (sources.contains("defaultProperties")) {
        PropertySource<?> source = sources.get("defaultProperties");
        if (source instanceof MapPropertySource) {
            map = ((MapPropertySource) source).getSource();
        }
    } else {
        map = new LinkedHashMap<>();
        sources.addLast(new MapPropertySource("defaultProperties", map));
    }
    if (map != null) {
        map.put(name, value);
    }
}

@SuppressWarnings("unchecked")
private void translateZuulRoutes(ConfigurableEnvironment environment) {

  //TODO should be fixed to multiple propertySource usage
  MapPropertySource zuulSource = findZuulPropertySource(environment);
  if (zuulSource == null) {
    return;
  }

  Map<String, String> customServiceVersions = new HashMap<>();
  for (String name : zuulSource.getPropertyNames()) {
    extractServiceVersion(zuulSource, name, customServiceVersions);
  }

  Map<String, Object> properties = new HashMap<>();
  properties.put(CUSTOM_SERVICE_VERSIONS_PROP, customServiceVersions);
  MapPropertySource target = new MapPropertySource(ZUUL_PROPERTY_SOURCE_NAME, properties);
  environment.getPropertySources().addFirst(target);
}

@Before
public void setUp() throws IOException {
    AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
    applicationContext.register(TarantoolConfiguration.class);
    DockerPort dockerPort = docker.containers()
            .container("tarantool")
            .port(3301);
    ImmutableMap<String, Object> env = ImmutableMap.of("tarantoolPort", dockerPort.getExternalPort());
    applicationContext.getEnvironment().getPropertySources()
            .addFirst(new MapPropertySource("rule", env));
    applicationContext.refresh();

    TarantoolClientOps bean = (TarantoolClientOps) applicationContext.getBean("tarantoolSyncOps");
    String eval = IOUtils.toString(RepositoryIntegrationTests.class.getResource("/init.lua"));
    bean.eval(eval);
    //
    userRepository = applicationContext.getBean(UserRepository.class);
    userRepository.deleteAll();

    logEntryRepository = applicationContext.getBean(LogEntryRepository.class);
    logEntryRepository.deleteAll();

    addressRepository = applicationContext.getBean(AddressRepository.class);
    addressRepository.deleteAll();
}

@Before
    public void setUp() throws IOException {
        this.applicationContext = new AnnotationConfigApplicationContext();
        this.applicationContext.register(TarantoolConfiguration.class);
        DockerPort dockerPort = docker.containers().container("tarantool").port(3301);
        ImmutableMap<String, Object> env = ImmutableMap.of("tarantoolPort", dockerPort.getExternalPort());
        this.applicationContext.getEnvironment().getPropertySources()
                .addFirst(new MapPropertySource("rule", env));
        this.applicationContext.refresh();

        TarantoolClientOps bean = (TarantoolClientOps) applicationContext.getBean("tarantoolSyncOps");
        String eval = IOUtils.toString(RepositoryIntegrationTests.class.getResource("/init.lua"));
        bean.eval(eval);

        userOperations = ((TarantoolOperations<Long, User>) applicationContext.getBean("userTarantoolOperations"));
//        userOperations.deleteAll(SPACE_ID);
        //
        stringUserTarantoolOperations = ((TarantoolOperations<String, User>) applicationContext.getBean("stringUserTarantoolOperations"));
//        stringUserTarantoolOperations.deleteAll(SPACE_STRING_ID);
    }

@Override
public PropertySource<?> locate(Environment environment) {
    if (!this.enabled) {
        return new MapPropertySource(PROPERTY_SOURCE_NAME, Collections.emptyMap());
    }
    Map<String, Object> config;
    try {
        GoogleConfigEnvironment googleConfigEnvironment = getRemoteEnvironment();
        Assert.notNull(googleConfigEnvironment, "Configuration not in expected format.");
        config = googleConfigEnvironment.getConfig();
    }
    catch (Exception e) {
        String message = String.format("Error loading configuration for %s/%s_%s", this.projectId,
                this.name, this.profile);
        throw new RuntimeException(message, e);
    }
    return new MapPropertySource(PROPERTY_SOURCE_NAME, config);
}

public static Map<String,String> getAllProperties(AbstractEnvironment env, String prefix){
    int prefixLength = prefix.length();
    Map<String, Object> map = new TreeMap<>();
    for(Iterator it = (env).getPropertySources().iterator(); it.hasNext(); ) {
        org.springframework.core.env.PropertySource propertySource = (org.springframework.core.env.PropertySource) it.next();
        if (propertySource instanceof MapPropertySource) {
            map.putAll(((MapPropertySource) propertySource).getSource());
        }
    }

    Map<String,String> result = new TreeMap<>();
    for(String name: map.keySet()){
        if(name.startsWith(prefix)){
            result.put(name.substring(prefixLength + 1, name.length()), env.getProperty(name));
        }
    }
    return result;
}

/**
 * Constructor.
 *
 * @param catalogName      connector name. Also the catalog name.
 * @param infoConverter    hive info converter
 * @param connectorContext connector config
 */
HiveConnectorFactory(
    final String catalogName,
    final HiveConnectorInfoConverter infoConverter,
    final ConnectorContext connectorContext
) {
    super(catalogName, infoConverter, connectorContext);
    final boolean useLocalMetastore = Boolean.parseBoolean(
        connectorContext.getConfiguration()
            .getOrDefault(HiveConfigConstants.USE_EMBEDDED_METASTORE, "false")
    );
    final boolean useFastHiveService = useLocalMetastore && Boolean.parseBoolean(
        connectorContext.getConfiguration()
            .getOrDefault(HiveConfigConstants.USE_FASTHIVE_SERVICE, "false")
    );

    final Map<String, Object> properties = new HashMap<>();
    properties.put("useHiveFastService", useFastHiveService);
    properties.put("useEmbeddedClient", useLocalMetastore);
    super.addEnvProperties(new MapPropertySource("HIVE_CONNECTOR", properties));
    super.registerClazz(HiveConnectorFastServiceConfig.class,
        HiveConnectorClientConfig.class, HiveConnectorConfig.class);
    super.refresh();
}

@Test
public void shouldConfigureSsl() {

    Map<String, Object> map = new HashMap<String, Object>();
    map.put("vault.ssl.key-store", "classpath:certificate.json");
    map.put("vault.ssl.trust-store", "classpath:certificate.json");

    MapPropertySource propertySource = new MapPropertySource("shouldConfigureSsl",
            map);
    configurableEnvironment.getPropertySources().addFirst(propertySource);

    SslConfiguration sslConfiguration = configuration.sslConfiguration();

    assertThat(sslConfiguration.getKeyStore()).isInstanceOf(ClassPathResource.class);
    assertThat(sslConfiguration.getKeyStorePassword())
            .isEqualTo("key store password");

    assertThat(sslConfiguration.getTrustStore())
            .isInstanceOf(ClassPathResource.class);
    assertThat(sslConfiguration.getTrustStorePassword()).isEqualTo(
            "trust store password");

    configurableEnvironment.getPropertySources().remove(propertySource.getName());
}

/**
 * Add, remove or re-order any {@link PropertySource}s in this application's
 * environment.
 * @param environment this application's environment
 * @param args arguments passed to the {@code run} method
 * @see #configureEnvironment(ConfigurableEnvironment, String[])
 */
protected void configurePropertySources(ConfigurableEnvironment environment,
        String[] args) {
    MutablePropertySources sources = environment.getPropertySources();
    if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
        sources.addLast(
                new MapPropertySource("defaultProperties", this.defaultProperties));
    }
    if (this.addCommandLineProperties && args.length > 0) {
        String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
        if (sources.contains(name)) {
            PropertySource<?> source = sources.get(name);
            CompositePropertySource composite = new CompositePropertySource(name);
            composite.addPropertySource(new SimpleCommandLinePropertySource(
                    name + "-" + args.hashCode(), args));
            composite.addPropertySource(source);
            sources.replace(name, composite);
        }
        else {
            sources.addFirst(new SimpleCommandLinePropertySource(args));
        }
    }
}

@Override
public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
    ConfigurableEnvironment environment = event.getEnvironment();
    String url = cleanRemoteUrl(environment.getProperty(NON_OPTION_ARGS));
    Assert.state(StringUtils.hasLength(url), "No remote URL specified");
    Assert.state(url.indexOf(",") == -1, "Multiple URLs specified");
    try {
        new URI(url);
    }
    catch (URISyntaxException ex) {
        throw new IllegalStateException("Malformed URL '" + url + "'");
    }
    Map<String, Object> source = Collections.singletonMap("remoteUrl", (Object) url);
    PropertySource<?> propertySource = new MapPropertySource("remoteUrl", source);
    environment.getPropertySources().addLast(propertySource);
}

@Before
public void init() {
    this.propertySources.addFirst(new PropertySource<String>("static", "foo") {

        @Override
        public Object getProperty(String name) {
            if (name.equals(getSource())) {
                return "bar";
            }
            return null;
        }

    });
    this.propertySources.addFirst(new MapPropertySource("map",
            Collections.<String, Object>singletonMap("name", "${foo}")));
}

@Test
public void testOrderPreserved() {
    LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();
    map.put("one", 1);
    map.put("two", 2);
    map.put("three", 3);
    map.put("four", 4);
    map.put("five", 5);
    this.propertySources.addFirst(new MapPropertySource("ordered", map));
    PropertySourcesPropertyValues propertyValues = new PropertySourcesPropertyValues(
            this.propertySources);
    PropertyValue[] values = propertyValues.getPropertyValues();
    assertThat(values).hasSize(6);
    Collection<String> names = new ArrayList<String>();
    for (PropertyValue value : values) {
        names.add(value.getName());
    }
    assertThat(names).containsExactly("one", "two", "three", "four", "five", "name");
}

@Override
public ApplicationContext loadContext(MergedContextConfiguration config)
        throws Exception {
    SpringApplication application = new SpringApplication();
    application.setMainApplicationClass(config.getTestClass());
    application.setWebEnvironment(false);
    application.setSources(
            new LinkedHashSet<Object>(Arrays.asList(config.getClasses())));
    ConfigurableEnvironment environment = new StandardEnvironment();
    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("spring.jmx.enabled", "false");
    properties.putAll(TestPropertySourceUtils
            .convertInlinedPropertiesToMap(config.getPropertySourceProperties()));
    environment.getPropertySources().addAfter(
            StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
            new MapPropertySource("integrationTest", properties));
    application.setEnvironment(environment);
    return application.run();
}

@Override
public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
    ConfigurableEnvironment environment = event.getEnvironment();
    String url = cleanRemoteUrl(environment.getProperty(NON_OPTION_ARGS));
    Assert.state(StringUtils.hasLength(url), "No remote URL specified");
    Assert.state(url.indexOf(",") == -1, "Multiple URLs specified");
    try {
        new URI(url);
    }
    catch (URISyntaxException ex) {
        throw new IllegalStateException("Malformed URL '" + url + "'");
    }
    Map<String, Object> source = Collections.singletonMap("remoteUrl", (Object) url);
    PropertySource<?> propertySource = new MapPropertySource("remoteUrl", source);
    environment.getPropertySources().addLast(propertySource);
}

@Scheduled(initialDelayString = "${spring.cloud.kubernetes.reload.period:15000}", fixedDelayString = "${spring.cloud.kubernetes.reload.period:15000}")
public void executeCycle() {

    boolean changedConfigMap = false;
    if (properties.isMonitoringConfigMaps()) {
        MapPropertySource currentConfigMapSource = findPropertySource(ConfigMapPropertySource.class);
        if (currentConfigMapSource != null) {
            MapPropertySource newConfigMapSource = configMapPropertySourceLocator.locate(environment);
            changedConfigMap = changed(currentConfigMapSource, newConfigMapSource);
        }
    }

    boolean changedSecrets = false;
    if (properties.isMonitoringSecrets()) {
        MapPropertySource currentSecretSource = findPropertySource(SecretsPropertySource.class);
        if (currentSecretSource != null) {
            MapPropertySource newSecretSource = secretsPropertySourceLocator.locate(environment);
            changedSecrets = changed(currentSecretSource, newSecretSource);
        }
    }

    if (changedConfigMap || changedSecrets) {
        reloadProperties();
    }
}

@Override
public ConditionOutcome getMatchOutcome(ConditionContext context,
        AnnotatedTypeMetadata metadata) {
    Environment environment = context.getEnvironment();
    if ("true".equals(environment
            .resolvePlaceholders("${spring.sleuth.stream.enabled:}"))) {
        return ConditionOutcome
                .noMatch("Found spring.sleuth.stream.enabled=true");
    }
    if (environment instanceof ConfigurableEnvironment) {
        ConfigurableEnvironment configurable = (ConfigurableEnvironment) environment;
        configurable.getPropertySources()
                .addLast(
                        new MapPropertySource("spring.sleuth.stream",
                                Collections.<String, Object>singletonMap(
                                        "spring.sleuth.stream.enabled",
                                        "false")));
    }
    return ConditionOutcome.match("Not found: spring.sleuth.stream.enabled");
}

/**
 * Add, remove or re-order any {@link PropertySource}s in this application's
 * environment.
 * @param environment this application's environment
 * @param args arguments passed to the {@code run} method
 * @see #configureEnvironment(ConfigurableEnvironment, String[])
 */
protected void configurePropertySources(ConfigurableEnvironment environment,
        String[] args) {
    MutablePropertySources sources = environment.getPropertySources();
    if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
        sources.addLast(
                new MapPropertySource("defaultProperties", this.defaultProperties));
    }
    if (this.addCommandLineProperties && args.length > 0) {
        String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
        if (sources.contains(name)) {
            PropertySource<?> source = sources.get(name);
            CompositePropertySource composite = new CompositePropertySource(name);
            composite.addPropertySource(new SimpleCommandLinePropertySource(
                    name + "-" + args.hashCode(), args));
            composite.addPropertySource(source);
            sources.replace(name, composite);
        }
        else {
            sources.addFirst(new SimpleCommandLinePropertySource(args));
        }
    }
}

@Before
public void init() {
    this.propertySources.addFirst(new PropertySource<String>("static", "foo") {

        @Override
        public Object getProperty(String name) {
            if (name.equals(getSource())) {
                return "bar";
            }
            return null;
        }

    });
    this.propertySources.addFirst(new MapPropertySource("map",
            Collections.<String, Object>singletonMap("name", "${foo}")));
}

@Test
public void testOrderPreserved() {
    LinkedHashMap<String, Object> map = new LinkedHashMap<String, Object>();
    map.put("one", 1);
    map.put("two", 2);
    map.put("three", 3);
    map.put("four", 4);
    map.put("five", 5);
    this.propertySources.addFirst(new MapPropertySource("ordered", map));
    PropertySourcesPropertyValues propertyValues = new PropertySourcesPropertyValues(
            this.propertySources);
    PropertyValue[] values = propertyValues.getPropertyValues();
    assertThat(values).hasSize(6);
    Collection<String> names = new ArrayList<String>();
    for (PropertyValue value : values) {
        names.add(value.getName());
    }
    assertThat(names).containsExactly("one", "two", "three", "four", "five", "name");
}

@Override
public ApplicationContext loadContext(MergedContextConfiguration config)
        throws Exception {
    SpringApplication application = new SpringApplication();
    application.setMainApplicationClass(config.getTestClass());
    application.setWebEnvironment(false);
    application.setSources(
            new LinkedHashSet<Object>(Arrays.asList(config.getClasses())));
    ConfigurableEnvironment environment = new StandardEnvironment();
    Map<String, Object> properties = new LinkedHashMap<String, Object>();
    properties.put("spring.jmx.enabled", "false");
    properties.putAll(TestPropertySourceUtils
            .convertInlinedPropertiesToMap(config.getPropertySourceProperties()));
    environment.getPropertySources().addAfter(
            StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME,
            new MapPropertySource("integrationTest", properties));
    application.setEnvironment(environment);
    return application.run();
}

@Bean
public RedisClusterConfiguration getClusterConfiguration() {
    Map<String, Object> source = Maps.newHashMap();
    source.put("spring.redis.cluster.nodes", redisProperties.getClusterNodes());
    source.put("spring.redis.cluster.max-redirects", redisProperties.getMaxRedirects());
    return new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source));

}

public static StringValueResolver createStringValueResolver(Map<String, Object> map) {
  StandardEnvironment standardEnvironment = new StandardEnvironment();
  standardEnvironment.getPropertySources().addFirst(
      new MapPropertySource(UUID.randomUUID().toString(), map));

  return standardEnvironment::resolvePlaceholders;
}

/**
 * Configure endpoint via property source override.
 *
 * @param serviceInfo
 * @return
 */
@Override
protected PropertySource<?> toPropertySource(VaultServiceInfo serviceInfo) {

    Map<String, Object> properties = new HashMap<String, Object>();

    properties.put("spring.cloud.vault.host", serviceInfo.getHost());
    properties.put("spring.cloud.vault.port", serviceInfo.getPort());
    properties.put("spring.cloud.vault.scheme", serviceInfo.getScheme());

    return new MapPropertySource("spring-cloud-vault-connector", properties);
}

/**
 * redisCluster配置
 * @return
 */
@Bean
public RedisClusterConfiguration redisClusterConfiguration() {
    Map<String, Object> source = new HashMap<String, Object>();
    source.put("spring.redis.cluster.nodes", redisProperties.getNodes());
    source.put("spring.redis.cluster.timeout", redisProperties.getCommandTimeout());
    return new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source));
}

/**
 * redisCluster配置
 * @return
 */
@Bean
public RedisClusterConfiguration redisClusterConfiguration() {
    Map<String, Object> source = new HashMap<String, Object>();
    source.put("spring.redis.cluster.nodes", redisProperties.getNodes());
    source.put("spring.redis.cluster.timeout", redisProperties.getCommandTimeout());
    return new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source));
}

@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
    Map<String, Object> propertiesToAdd = new HashMap<>();
    propertiesToAdd.put("spring.cloud.stream.bindings.input.destination", "metrics");
    propertiesToAdd.put("spring.jackson.default-property-inclusion", "non_null");
    environment.getPropertySources().addLast(new MapPropertySource("collectorDefaultProperties", propertiesToAdd));
}

private MapPropertySource findZuulPropertySource(ConfigurableEnvironment environment) {
  for (PropertySource<?> propertySource : environment.getPropertySources()) {
    if (propertySource instanceof MapPropertySource) {
      for (String key : ((EnumerablePropertySource) propertySource).getPropertyNames()) {
        if (key.toLowerCase().startsWith(ZUUL_SERVICE_VERSIONS_ROOT)) {
          return (MapPropertySource) propertySource;
        }
      }
    }
  }
  return null;
}

private void extractServiceVersion(MapPropertySource zuulSource, String name, Map<String,String> targetMap) {
  if (!name.toLowerCase().startsWith(ZUUL_SERVICE_VERSIONS_ROOT)) {
    return;
  }
  if (!name.toLowerCase().contains(ZUUL_SERVICE_ID_PROP)) {
    return;
  }
  String baseName = name.replaceAll("." + ZUUL_SERVICE_ID_PROP, "");
  if (!zuulSource.containsProperty(baseName + "." + ZUUL_SERVICE_VERSIONS_PROP))
    return;
  String versions = (String) zuulSource.getProperty(baseName + "." + ZUUL_SERVICE_VERSIONS_PROP);
  String serviceId = (String) zuulSource.getProperty(baseName + "." + ZUUL_SERVICE_ID_PROP);

  targetMap.put(serviceId, versions);
}

private void translateClientVersionProperty(ConfigurableEnvironment environment) {
  if(!environment.containsProperty(CUSTOM_VERSION_PROP)) {
    return;
  }
  String versions = environment.getProperty(CUSTOM_VERSION_PROP);
  Map<String, Object> properties = new HashMap<>();
  properties.put(DEFAULT_VERSION_PROP, versions);
  MapPropertySource target = new MapPropertySource(CLIENT_PROPERTY_SOURCE_NAME, properties);
  environment.getPropertySources().addFirst(target);
}

@PostConstruct
public void postConstruct() {
  Map<String, Object> properties = ImmutableMap
      .<String, Object> builder()
      .put("copier-options.file-attribute", "replication, blocksize, user, group, permission, checksumtype, xattr")
      .put("copier-options.preserve-raw-xattrs", true)
      .build();
  env.getPropertySources().addLast(new MapPropertySource("distCpProperties", properties));
}

@Test
public void isSensitiveOverride() throws Exception {
    this.context = new AnnotationConfigApplicationContext();
    PropertySource<?> propertySource = new MapPropertySource("test",
            Collections.<String, Object>singletonMap(this.property + ".sensitive",
                    String.valueOf(!this.sensitive)));
    this.context.getEnvironment().getPropertySources().addFirst(propertySource);
    this.context.register(this.configClass);
    this.context.refresh();
    assertThat(getEndpointBean().isSensitive()).isEqualTo(!this.sensitive);
}

@Test
public void isSensitiveOverrideWithGlobal() throws Exception {
    this.context = new AnnotationConfigApplicationContext();
    Map<String, Object> properties = new HashMap<String, Object>();
    properties.put("endpoint.sensitive", this.sensitive);
    properties.put(this.property + ".sensitive", String.valueOf(!this.sensitive));
    PropertySource<?> propertySource = new MapPropertySource("test", properties);
    this.context.getEnvironment().getPropertySources().addFirst(propertySource);
    this.context.register(this.configClass);
    this.context.refresh();
    assertThat(getEndpointBean().isSensitive()).isEqualTo(!this.sensitive);
}

@Test
public void isEnabledFallbackToEnvironment() throws Exception {
    this.context = new AnnotationConfigApplicationContext();
    PropertySource<?> propertySource = new MapPropertySource("test", Collections
            .<String, Object>singletonMap(this.property + ".enabled", false));
    this.context.getEnvironment().getPropertySources().addFirst(propertySource);
    this.context.register(this.configClass);
    this.context.refresh();
    assertThat(getEndpointBean().isEnabled()).isFalse();
}

@Test
@SuppressWarnings("rawtypes")
public void isExplicitlyEnabled() throws Exception {
    this.context = new AnnotationConfigApplicationContext();
    PropertySource<?> propertySource = new MapPropertySource("test", Collections
            .<String, Object>singletonMap(this.property + ".enabled", false));
    this.context.getEnvironment().getPropertySources().addFirst(propertySource);
    this.context.register(this.configClass);
    this.context.refresh();
    ((AbstractEndpoint) getEndpointBean()).setEnabled(true);
    assertThat(getEndpointBean().isEnabled()).isTrue();
}

@Test
public void isAllEndpointsDisabled() throws Exception {
    this.context = new AnnotationConfigApplicationContext();
    PropertySource<?> propertySource = new MapPropertySource("test",
            Collections.<String, Object>singletonMap("endpoints.enabled", false));
    this.context.getEnvironment().getPropertySources().addFirst(propertySource);
    this.context.register(this.configClass);
    this.context.refresh();
    assertThat(getEndpointBean().isEnabled()).isFalse();
}

@Test
public void isOptIn() throws Exception {
    this.context = new AnnotationConfigApplicationContext();
    Map<String, Object> source = new HashMap<String, Object>();
    source.put("endpoints.enabled", false);
    source.put(this.property + ".enabled", true);
    PropertySource<?> propertySource = new MapPropertySource("test", source);
    this.context.getEnvironment().getPropertySources().addFirst(propertySource);
    this.context.register(this.configClass);
    this.context.refresh();
    assertThat(getEndpointBean().isEnabled()).isTrue();
}

private void testGlobalEndpointsSensitive(boolean sensitive) {
    this.context = new AnnotationConfigApplicationContext();
    PropertySource<?> propertySource = new MapPropertySource("test", Collections
            .<String, Object>singletonMap("endpoints.sensitive", sensitive));
    this.context.getEnvironment().getPropertySources().addFirst(propertySource);
    this.context.register(this.configClass);
    this.context.refresh();
    assertThat(getEndpointBean().isSensitive()).isEqualTo(sensitive);
}

@Test
public void testFooCreatePropertyTrue() {
  context.getEnvironment().getPropertySources().addLast(
      new MapPropertySource("test", Collections.singletonMap("foo.create", "true"))
  );
  context.register(FooConfiguration.class);
  context.refresh();
  assertNotNull(context.getBean(Foo.class));
}