target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void extractsPlaceholderNamesAndDefaults() { String valueWithPlaceholders = "foo ${with.default:defaultValue} bar ${without.default} ${configLocation:classpath:}foo"; List<Placeholder> placeholders = PlaceholderResolver.extractPlaceholders(valueWithPlaceholders); List<Placeholder> expected = ImmutableList.... | @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder); if (placeholderMatche... | PlaceholderResolver { @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder);... | PlaceholderResolver { @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder);... | PlaceholderResolver { @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder);... | PlaceholderResolver { @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder);... |
@Test public void extractsPlaceholderNamesAndEmptyDefaults() { String valueWithPlaceholders = "${FOO:}"; List<Placeholder> placeholders = PlaceholderResolver.extractPlaceholders(valueWithPlaceholders); assertThat(placeholders, is(singletonList(new Placeholder("FOO", "")))); } | @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder); if (placeholderMatche... | PlaceholderResolver { @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder);... | PlaceholderResolver { @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder);... | PlaceholderResolver { @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder);... | PlaceholderResolver { @VisibleForTesting public static List<Placeholder> extractPlaceholders(String value) { List<Placeholder> namesAndDefaults = new ArrayList<>(); for (String placeholder : extractPlaceholderStrings(value)) { Matcher placeholderMatcher = PLACEHOLDER_REGEX_CAPTURE_NAME_AND_DEFAULT.matcher(placeholder);... |
@Test public void replacesPlaceholder() { String original = "foo ${with.default:defaultValue} bar ${without.default}"; assertThat(PlaceholderResolver.replacePlaceholder(original, "with.default", "replacement"), is("foo replacement bar ${without.default}")); assertThat(PlaceholderResolver.replacePlaceholder(original, "w... | @VisibleForTesting public static String replacePlaceholder(String originalString, String placeholderName, String placeholderValue) { return originalString.replaceAll("\\$\\{" + quote(placeholderName) + "(?:\\:[^\\}]*?)?\\}", placeholderValue); } | PlaceholderResolver { @VisibleForTesting public static String replacePlaceholder(String originalString, String placeholderName, String placeholderValue) { return originalString.replaceAll("\\$\\{" + quote(placeholderName) + "(?:\\:[^\\}]*?)?\\}", placeholderValue); } } | PlaceholderResolver { @VisibleForTesting public static String replacePlaceholder(String originalString, String placeholderName, String placeholderValue) { return originalString.replaceAll("\\$\\{" + quote(placeholderName) + "(?:\\:[^\\}]*?)?\\}", placeholderValue); } PlaceholderResolver(ObjectNode rootNode, Map<String,... | PlaceholderResolver { @VisibleForTesting public static String replacePlaceholder(String originalString, String placeholderName, String placeholderValue) { return originalString.replaceAll("\\$\\{" + quote(placeholderName) + "(?:\\:[^\\}]*?)?\\}", placeholderValue); } PlaceholderResolver(ObjectNode rootNode, Map<String,... | PlaceholderResolver { @VisibleForTesting public static String replacePlaceholder(String originalString, String placeholderName, String placeholderValue) { return originalString.replaceAll("\\$\\{" + quote(placeholderName) + "(?:\\:[^\\}]*?)?\\}", placeholderValue); } PlaceholderResolver(ObjectNode rootNode, Map<String,... |
@Test public void getsProperty() { assertThat(yamlConfig.get("simpleProperty", String.class), isValue("simpleValue")); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void sendsMeter() throws InterruptedException { registry.meter("meter").mark(1234); service.report(); assertThat(sender.data, hasItem(matchesRegex("test.meter.count=1234"))); assertThat(sender.data, hasItem(matchesRegex("test.meter.m1_rate=0.00"))); assertThat(sender.data, hasItem(matchesRegex("test.meter.... | @VisibleForTesting void report() { this.reporter.report(); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } |
@Test public void getsNestedProperties() { assertThat(yamlConfig.get("metrics.graphite.host", String.class), isValue("data.internal.com")); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void resolvesPlaceholderFromYaml() { assertThat(yamlConfig.get("propWithPlaceholder", String.class), isValue("placeholderValue")); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void usesDefaultIfPlaceholderCannotBeResolved() { assertThat(yamlConfig.get("jvmRouteName", String.class), isValue("noJvmRouteSet")); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void resolvesPlaceholderFromSystemProperty() { YamlConfiguration yamlConfig = config(yaml, singletonMap("jvm.route", "staging")); assertThat(yamlConfig.get("jvmRouteName", String.class), isValue("staging")); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void nonTextValuesCanBeSubstitutes() { String yaml = "" + "prop1: ${prop2}\n" + "prop2: 1234\n"; YamlConfiguration yamlConfig = config(yaml); assertThat(yamlConfig.get("prop1", Integer.class), isValue(1234)); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void getsAndConvertsTypes() { assertThat(yamlConfig.get("metrics.graphite.port", Integer.class), isValue(2003)); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void getsListItems() { assertThat(yamlConfig.get("proxy.connectors[0].port", Integer.class), isValue(8080)); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void getsPrimitiveListItems() { String yaml = "" + "proxy:\n" + " supportedProtocols:\n" + " - http\n" + " - https"; YamlConfiguration yamlConfig = config(yaml); assertThat(yamlConfig.get("proxy.supportedProtocols[0]", String.class), isValue("http")); assertThat(yamlConfig.get("proxy.supportedProtocols[1]"... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void getsListWithinListItems() { String yaml = "" + "list:\n" + "-\n" + " - nested1\n" + " - nested2\n"; YamlConfiguration yamlConfig = config(yaml); assertThat(yamlConfig.get("list[0][0]", String.class), isValue("nested1")); assertThat(yamlConfig.get("list[0][1]", String.class), isValue("nested2")); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void getsAsMap() { Map expected = ImmutableMap.of( "type", "http", "port", 8080); assertThat(yamlConfig.get("proxy.connectors[0]", Map.class), matches(MapMatcher.isMap(expected))); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void sendsTimer() throws InterruptedException { registry.timer("timer").update(1234, MILLISECONDS); service.report(); assertThat(sender.data, hasItem(matchesRegex("test.timer.count=1"))); assertThat(sender.data, hasItem(matchesRegex("test.timer.m1_rate=0.00"))); assertThat(sender.data, hasItem(matchesRegex... | @VisibleForTesting void report() { this.reporter.report(); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } |
@Test public void getsLists() { Map expected = ImmutableMap.of( "type", "http", "port", 8080); assertThat(yamlConfig.get("proxy.connectors", List.class), matches(contains(isMap(expected)))); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void getsAndConvertsToAnnotatedClass() { assertThat(yamlConfig.get("metrics.graphite", StubGraphiteConfig.class), isValue(new StubGraphiteConfig("data.internal.com", 2003))); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void doesNotGetNonOverridingSystemProperty() { YamlConfiguration yamlConfig = config(yaml, singletonMap("foo", "bar")); assertThat(yamlConfig.get("foo", String.class), isAbsent()); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void systemPropertyOverridesSimpleProperty() { YamlConfiguration yamlConfig = config(yaml, singletonMap("simpleProperty", "foo")); assertThat(yamlConfig.get("simpleProperty", String.class), isValue("foo")); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void systemPropertyOverridesCanBeConvertedToNonStringTypes() { YamlConfiguration yamlConfig = config(yaml, singletonMap("simpleProperty", "1234")); assertThat(yamlConfig.get("simpleProperty", Integer.class), isValue(1234)); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void systemPropertyOverridesPropertyInAnnotatedClass() { YamlConfiguration yamlConfig = config(yaml, singletonMap("metrics.graphite.host", "example.org")); assertThat(yamlConfig.get("metrics.graphite", StubGraphiteConfig.class), isValue(new StubGraphiteConfig("example.org", 2003))); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void systemPropertyOverridesPropertyInAnnotatedClassEvenIfTypeIsNotString() { YamlConfiguration yamlConfig = config(yaml, singletonMap("metrics.graphite.port", "1234")); assertThat(yamlConfig.get("metrics.graphite", StubGraphiteConfig.class), isValue(new StubGraphiteConfig("data.internal.com", 1234))); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void systemPropertyOverridesComplexProperty() { YamlConfiguration yamlConfig = config(yaml, singletonMap("proxy.connectors[0].port", "5555")); assertThat(yamlConfig.get("proxy.connectors[0].port", Integer.class), isValue(5555)); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void systemPropertiesCannotAddStructuresNotPresentInOriginalYaml() { String yaml = "foo: bar\n"; YamlConfiguration yamlConfig = config(yaml, ImmutableMap.of( "metrics.graphite.host", "data.internal.com", "metrics.graphite.port", "2003")); assertThat(yamlConfig.get("metrics.graphite", StubGraphiteConfig.cla... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void systemPropertyDoesNotOverridesStructuresNotPresentInOriginalYaml() { String yaml = "" + "proxy.connectors[0].port: 5555\n"; YamlConfiguration yamlConfig = config(yaml, singletonMap("foo", "bar")); assertThat(yamlConfig.get("foo"), isAbsent()); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void sendsCounter() throws InterruptedException { registry.counter("counter").inc(1234); service.report(); assertThat(sender.data, hasItem(matchesRegex("test.counter.count=1234"))); } | @VisibleForTesting void report() { this.reporter.report(); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } | GraphiteReporterService extends AbstractStyxService { @VisibleForTesting void report() { this.reporter.report(); } private GraphiteReporterService(Builder builder); } |
@Test public void systemPropertyDoesNotOverridesListWithinListItemsNotPresentInOriginalYaml() { String yaml = "" + "foo: 1\n"; YamlConfiguration yamlConfig = config(yaml, ImmutableMap.of( "list[0][0]", "nested1", "list[0][1]", "nested2")); assertThat(yamlConfig.get("list[0][0]", String.class), isAbsent()); assertThat(y... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void systemPropertyWithInvalidPathHasNoEffect() { YamlConfiguration yamlConfig = config(yaml, singletonMap("metrics.graphite[0]", "example.org")); assertThat(yamlConfig.get("metrics.graphite", StubGraphiteConfig.class), isValue(new StubGraphiteConfig("data.internal.com", 2003))); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void canIncludeFiles() throws Exception { String yaml = "" + "include: %s\n" + "metrics:\n" + " graphite:\n" + " port: 2004\n"; String include = "" + "metrics:\n" + " graphite:\n" + " port: 2003\n" + " intervalMillis: 5000\n"; testYamlWithInclude(yaml, include, yamlConfig -> { assertThat(yamlConfig.get("me... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void overwritesArraysInInclude() throws Exception { String yaml = "" + "include: %s\n" + "array:\n" + "- \"right1\"\n" + "- \"right2\"\n"; String include = "" + "array:\n" + "- \"wrong1\"\n" + "- \"wrong2\"\n"; testYamlWithInclude(yaml, include, yamlConfig -> assertThat(yamlConfig.get("array", List.class),... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void resolvesPlaceholdersInIncludeFromMainYaml() throws Exception { String yaml = "" + "include: %s\n" + "resolution: \"resolved\"\n"; String include = "" + "myprop: \"${resolution}\"\n"; testYamlWithInclude(yaml, include, yamlConfig -> assertThat(yamlConfig.get("myprop", String.class), isValue("resolved")... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void canSubstituteArrayElements() { String yaml = "" + "array:\n" + "- ${element1}\n" + "- ${element2}\n" + "- ${element3:gamma}\n" + "- ${element4}\n"; YamlConfiguration yamlConfig = config(yaml, ImmutableMap.of("element1", "alpha", "element2", "beta", "element4", "delta")); assertThat(yamlConfig.get("arr... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void resolvesPlaceholdersInMainYamlFromInclude() throws Exception { String yaml = "" + "include: %s\n" + "myprop: \"${resolution}\"\n"; String include = "" + "resolution: \"resolved\"\n"; testYamlWithInclude(yaml, include, yamlConfig -> assertThat(yamlConfig.get("myprop", String.class), isValue("resolved")... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void mainYamlOverridesIncludedYaml() throws Exception { String yaml = "" + "include: %s\n" + "foo: main\n"; String include = "" + "foo: included\n"; testYamlWithInclude(yaml, include, yamlConfig -> assertThat(yamlConfig.get("foo", String.class), isValue("main"))); } | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void overridesPropertiesWithReplacedPlaceholders() throws Exception { Map<String, String> systemProperties = ImmutableMap.of("FOO", "production1"); String yaml = "" + "include: %s\n" + "foo: \"\"\n"; String include = "" + "foo: ${FOO:}-\n" + "domain: de.${foo}example.com\n"; File file = createTestFile(); t... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void includePlaceholdersAreResolved() throws Exception { Map<String, String> systemProperties = ImmutableMap.of( "FOO", "production1", "LOCATION", ""); String yaml = "" + "include: ${LOCATION}%s\n" + "foo: \"\"\n"; String include = "" + "foo: ${FOO:}-\n" + "domain: de.${foo}example.com\n"; File file = crea... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void logsExceptionsDuringReportingOfAMetric() { reporter.report( map("fail_gauge", failGauge("gauge failed as intended")), map("fail_counter", failCounter("counter failed as intended")), map("fail_histogram", failHistogram("histogram failed as intended")), map("fail_meter", failMeter("meter failed as inten... | @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); gauges.forEach((name, gauge) -> doReport(name, ... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... |
@Test public void supportsMultipleIncludes() throws Exception { String yaml2 = "" + "include: %s\n" + "onlyIn2: alpha\n" + "override1With2: beta\n" + "override0With2: gamma\n" + "override0With1Then2: delta\n"; String yaml1 = "" + "include: %s\n" + "onlyIn1: abc\n" + "override1With2: def\n" + "override0With1: ghi\n" + "... | @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } } | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... | YamlConfiguration implements ExtensibleConfiguration<YamlConfiguration> { @Override public <T> Optional<T> get(String property, Class<T> tClass) { return nodeAt(property) .map(node -> { if (tClass == Path.class) { return (T) Paths.get(node.textValue()); } return parseNodeToClass(node, tClass); }); } YamlConfiguration(J... |
@Test public void canGetTopLevelProperty() { assertThat(new NodePath("text").findMatchingDescendant(root), matches(isTextNode("abc"))); } | public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } } | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... |
@Test public void canGetArrayElements() { assertThat(new NodePath("array[0]").findMatchingDescendant(root), matches(isTextNode("alpha"))); assertThat(new NodePath("array[1]").findMatchingDescendant(root), matches(isTextNode("beta"))); assertThat(new NodePath("array[2]").findMatchingDescendant(root), matches(isTextNode(... | public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } } | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... |
@Test public void canGetObjectField() { assertThat(new NodePath("object.field1").findMatchingDescendant(root), matches(isTextNode("foo"))); assertThat(new NodePath("object.field2").findMatchingDescendant(root), matches(isTextNode("bar"))); } | public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } } | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... |
@Test public void canGetFieldsWithinArrayElementObjects() { assertThat(new NodePath("array2[0].arrayObjectField1").findMatchingDescendant(root), matches(isTextNode("abc"))); assertThat(new NodePath("array2[0].arrayObjectField2").findMatchingDescendant(root), matches(isTextNode("def"))); } | public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } } | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... | NodePath { public Optional<JsonNode> findMatchingDescendant(JsonNode rootNode) { JsonNode current = rootNode; for (PathElement element : elements) { current = element.child(current); if (current == null) { return Optional.empty(); } } return Optional.ofNullable(current); } NodePath(String path); NodePath(List<PathEle... |
@Test public void extractsDefaultStringTypeConfigurationFromJsonNode() { JsonNode rootNode = jsonNode("{\"text\":\"foo\"}"); JsonNodeConfig config = new JsonNodeConfig(rootNode); assertThat(config.get("text"), isValue("foo")); assertThat(config.get("nonExistent"), isAbsent()); } | @Override public Optional<String> get(String key) { return get(key, String.class); } | JsonNodeConfig implements Configuration { @Override public Optional<String> get(String key) { return get(key, String.class); } } | JsonNodeConfig implements Configuration { @Override public Optional<String> get(String key) { return get(key, String.class); } JsonNodeConfig(JsonNode rootNode); protected JsonNodeConfig(JsonNode rootNode, ObjectMapper mapper); } | JsonNodeConfig implements Configuration { @Override public Optional<String> get(String key) { return get(key, String.class); } JsonNodeConfig(JsonNode rootNode); protected JsonNodeConfig(JsonNode rootNode, ObjectMapper mapper); @Override Optional<String> get(String key); @Override Optional<T> get(String property, Clas... | JsonNodeConfig implements Configuration { @Override public Optional<String> get(String key) { return get(key, String.class); } JsonNodeConfig(JsonNode rootNode); protected JsonNodeConfig(JsonNode rootNode, ObjectMapper mapper); @Override Optional<String> get(String key); @Override Optional<T> get(String property, Clas... |
@Test public void extractsSpecifiedTypeConfigurationFromJsonNode() { JsonNode rootNode = jsonNode("{\"text\":\"foo\",\"number\":123}"); JsonNodeConfig config = new JsonNodeConfig(rootNode); assertThat(config.get("text", String.class), isValue("foo")); assertThat(config.get("nonExistent", String.class), isAbsent()); ass... | @Override public Optional<String> get(String key) { return get(key, String.class); } | JsonNodeConfig implements Configuration { @Override public Optional<String> get(String key) { return get(key, String.class); } } | JsonNodeConfig implements Configuration { @Override public Optional<String> get(String key) { return get(key, String.class); } JsonNodeConfig(JsonNode rootNode); protected JsonNodeConfig(JsonNode rootNode, ObjectMapper mapper); } | JsonNodeConfig implements Configuration { @Override public Optional<String> get(String key) { return get(key, String.class); } JsonNodeConfig(JsonNode rootNode); protected JsonNodeConfig(JsonNode rootNode, ObjectMapper mapper); @Override Optional<String> get(String key); @Override Optional<T> get(String property, Clas... | JsonNodeConfig implements Configuration { @Override public Optional<String> get(String key) { return get(key, String.class); } JsonNodeConfig(JsonNode rootNode); protected JsonNodeConfig(JsonNode rootNode, ObjectMapper mapper); @Override Optional<String> get(String key); @Override Optional<T> get(String property, Clas... |
@Test public void providesConfig() { createStubConfig("/fake/simple-config.yml", ImmutableMap.of( "foo", 123, "bar", "abc")); ConfigurationParser<StubConfiguration> parser = new ConfigurationParser.Builder<StubConfiguration>() .format(format) .build(); StubConfiguration parsedConfiguration = parser.parse(configSource(n... | public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.unresolvedPlaceholders()... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... |
@Test public void includesParent() { ConfigurationParser<StubConfiguration> parser = new ConfigurationParser.Builder<StubConfiguration>() .format(format) .build(); StubConfiguration parsedConfiguration = parser.parse(configSource(newResource("/fake/base-config.yml"))); assertThat(parsedConfiguration.get("string"), isVa... | public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.unresolvedPlaceholders()... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... |
@Test public void includedValuesCanBeOverridden() { ConfigurationParser<StubConfiguration> parser = new ConfigurationParser.Builder<StubConfiguration>() .format(format) .build(); StubConfiguration parsedConfiguration = parser.parse(configSource(newResource("/fake/base-config.yml"))); assertThat(parsedConfiguration.get(... | public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.unresolvedPlaceholders()... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... |
@Test public void continuesReportingMetricsAfterOneThrowsAnException() throws IOException { ReportCollector reported = new ReportCollector(); doAnswer(reported::recordArguments).when(graphite).send(any(String.class), any(String.class), eq(TIMESTAMP)); ReportArgs reportArgs = new ReportArgs() .addGauge("fail_gauge", fai... | @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); gauges.forEach((name, gauge) -> doReport(name, ... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... |
@Test public void resolvesPlaceholdersInConfig() { ConfigurationParser<StubConfiguration> parser = new ConfigurationParser.Builder<StubConfiguration>() .format(format) .build(); StubConfiguration parsedConfiguration = parser.parse(configSource(newResource("/fake/base-config.yml"))); assertThat(parsedConfiguration.get("... | public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.unresolvedPlaceholders()... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... |
@Test public void appliesOverrides() { ConfigurationParser<StubConfiguration> parser = new ConfigurationParser.Builder<StubConfiguration>() .format(format) .overrides(ImmutableMap.of("string", "overridden")) .build(); StubConfiguration parsedConfiguration = parser.parse(configSource(newResource("/fake/base-config.yml")... | public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.unresolvedPlaceholders()... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... |
@Test public void includeValueCanContainPlaceholder() { createStubConfig("/test/base-config.yml", ImmutableMap.of( "include", "${include-placeholder}", "number", 123, "string", "abc", "numberFromParent", 999, "hasPlaceholder", "${string}" )); createStubConfig("/test/parent-config.yml", ImmutableMap.of( "numberFromParen... | public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.unresolvedPlaceholders()... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... |
@Test public void childCanReplaceParentPlaceholders() { createStubConfig("/test/base-config.yml", ImmutableMap.of( "include", "/test/parent-config.yml", "childString", "abc" )); createStubConfig("/test/parent-config.yml", ImmutableMap.of( "parentString", "${childString}" )); ConfigurationParser<StubConfiguration> parse... | public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.unresolvedPlaceholders()... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... | ConfigurationParser { public C parse(ConfigurationSource provider) { LOGGER.debug("Parsing configuration in format={} from source={}", format, provider); C configuration = doParse(provider).withOverrides(overrides); PlaceholderResolutionResult<C> resolved = configuration.resolvePlaceholders(overrides); if (!resolved.un... |
@Test public void announcesInitialStateWhenStarts() throws IOException { Resource configurationFile = mockResource("/styx/config", new ByteArrayInputStream(originalContent)); registry = new FileBackedRegistry<>(configurationFile, bytes -> ImmutableList.of(backendService), any -> true); registry.addListener(listener); a... | @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("timestamp=%s, md5-hash=%s", modifyTime, hashCode);... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... |
@Test public void announcesNoMeaningfulChangesWhenFileDidNotChange() throws Exception { Resource configurationFile = mockResource("/styx/config", new ByteArrayInputStream(originalContent), new ByteArrayInputStream(originalContent) ); registry = new FileBackedRegistry<>(configurationFile, bytes -> ImmutableList.of(backe... | @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("timestamp=%s, md5-hash=%s", modifyTime, hashCode);... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... |
@Test public void announcesNoMeaningfulChangesWhenNoSemanticChanges() throws Exception { Resource configurationFile = mockResource("/styx/config", new ByteArrayInputStream(originalContent)); registry = new FileBackedRegistry<>(configurationFile, bytes -> ImmutableList.of(backendService), any -> true); registry.addListe... | @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("timestamp=%s, md5-hash=%s", modifyTime, hashCode);... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... |
@Test public void announcesChanges() throws Exception { BackendService backendService1 = new BackendService.Builder().id("x").path("/x").build(); BackendService backendService2 = new BackendService.Builder().id("x").path("/y").build(); Resource configurationFile = mockResource("/styx/config", new ByteArrayInputStream(o... | @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("timestamp=%s, md5-hash=%s", modifyTime, hashCode);... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... |
@Test public void completesWithExceptionWhenErrorsDuringReload() throws Exception { Resource configurationFile = mockResource("/styx/config", new ByteArrayInputStream(originalContent), new ByteArrayInputStream(newContent)); registry = new FileBackedRegistry<>( configurationFile, bytes -> { if (new String(bytes).equals(... | @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("timestamp=%s, md5-hash=%s", modifyTime, hashCode);... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... |
@Test public void modifyTimeProviderHandlesExceptions() throws Exception { registry = new FileBackedRegistry<>( mockResource("/styx/config", new ByteArrayInputStream(originalContent)), bytes -> ImmutableList.of(new BackendService.Builder().id("x").path("/x").build()), any -> true ); registry.addListener(listener); veri... | @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("timestamp=%s, md5-hash=%s", modifyTime, hashCode);... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... | FileBackedRegistry extends AbstractRegistry<T> { @Override public CompletableFuture<ReloadResult> reload() { return supplyAsync(() -> { byte[] content = readFile(); HashCode hashCode = md5().hashBytes(content); String modifyTime = fileModificationTime().map(FileTime::toString).orElse("NA"); String logPrefix = format("t... |
@Test public void initConnectionRetriesOnFailure() throws Exception { doThrow(new UnknownHostException("UNKNOWN-HOST")).when(graphite).connect(); try { reporter.initConnection(); fail("Should have thrown an exception"); } catch (UncheckedIOException e) { verify(graphite, times(MAX_RETRIES)).connect(); } } | @VisibleForTesting void initConnection() { tryTimes( MAX_RETRIES, graphite::connect, (e) -> attemptErrorHandling(graphite::close) ); } | GraphiteReporter extends ScheduledReporter { @VisibleForTesting void initConnection() { tryTimes( MAX_RETRIES, graphite::connect, (e) -> attemptErrorHandling(graphite::close) ); } } | GraphiteReporter extends ScheduledReporter { @VisibleForTesting void initConnection() { tryTimes( MAX_RETRIES, graphite::connect, (e) -> attemptErrorHandling(graphite::close) ); } private GraphiteReporter(MetricRegistry registry,
GraphiteSender graphite,
Clock ... | GraphiteReporter extends ScheduledReporter { @VisibleForTesting void initConnection() { tryTimes( MAX_RETRIES, graphite::connect, (e) -> attemptErrorHandling(graphite::close) ); } private GraphiteReporter(MetricRegistry registry,
GraphiteSender graphite,
Clock ... | GraphiteReporter extends ScheduledReporter { @VisibleForTesting void initConnection() { tryTimes( MAX_RETRIES, graphite::connect, (e) -> attemptErrorHandling(graphite::close) ); } private GraphiteReporter(MetricRegistry registry,
GraphiteSender graphite,
Clock ... |
@Test public void addsResources() { BackendService landing = backendService("landing", 9091); BackendService shopping = backendService("shopping", 9090); MemoryBackedRegistry<BackendService> registry = new MemoryBackedRegistry<>(); registry.add(landing); registry.addListener(listener); registry.add(shopping); assertTha... | public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } | MemoryBackedRegistry extends AbstractRegistry<T> { public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } } | MemoryBackedRegistry extends AbstractRegistry<T> { public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } MemoryBackedRegistry(); private MemoryBackedRegistry(boolean autoReload); } | MemoryBackedRegistry extends AbstractRegistry<T> { public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } MemoryBackedRegistry(); private MemoryBackedRegistry(boolean autoReload); void add(T t); void removeById(Id id); void reset(); @Override CompletableFuture<ReloadResult> reload(); } | MemoryBackedRegistry extends AbstractRegistry<T> { public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } MemoryBackedRegistry(); private MemoryBackedRegistry(boolean autoReload); void add(T t); void removeById(Id id); void reset(); @Override CompletableFuture<ReloadResult> reload(); } |
@Test public void updatesResources() { BackendService landing = backendService("landing", 9091); MemoryBackedRegistry<BackendService> registry = new MemoryBackedRegistry<>(); registry.add(backendService("shopping", 9090)); registry.add(landing); registry.addListener(listener); BackendService shopping = backendService("... | public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } | MemoryBackedRegistry extends AbstractRegistry<T> { public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } } | MemoryBackedRegistry extends AbstractRegistry<T> { public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } MemoryBackedRegistry(); private MemoryBackedRegistry(boolean autoReload); } | MemoryBackedRegistry extends AbstractRegistry<T> { public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } MemoryBackedRegistry(); private MemoryBackedRegistry(boolean autoReload); void add(T t); void removeById(Id id); void reset(); @Override CompletableFuture<ReloadResult> reload(); } | MemoryBackedRegistry extends AbstractRegistry<T> { public void add(T t) { resources.put(t.id(), t); if (autoReload) { reload(); } } MemoryBackedRegistry(); private MemoryBackedRegistry(boolean autoReload); void add(T t); void removeById(Id id); void reset(); @Override CompletableFuture<ReloadResult> reload(); } |
@Test public void extractsTheExceptionClassMethodAndCreatesAUniqueExceptionId() throws Exception { ExceptionConverter converter = newExceptionConverter(); assertThat(converter.convert(loggingEvent).trim(), endsWith("[exceptionClass=com.hotels.styx.infrastructure.logging.ExceptionConverterTest, exceptionMethod=<init>, e... | @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } @Override String convert(final ILoggingEvent loggingEvent); } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } @Override String convert(final ILoggingEvent loggingEvent); static final String TARGET_CLASSES_PROPERTY_NAME; } |
@Test public void gracefullyHandlesExceptionInstancesWithoutStackTrace() throws Exception { ExceptionConverter converter = newExceptionConverter(); ILoggingEvent errorEvent = newErrorLoggingEvent(new NoStackException()); assertThat(converter.convert(errorEvent), endsWith("")); } | @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } @Override String convert(final ILoggingEvent loggingEvent); } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } @Override String convert(final ILoggingEvent loggingEvent); static final String TARGET_CLASSES_PROPERTY_NAME; } |
@Test public void prioritizeTargetClassStackTraceElementsOverTheRootOnes() throws Exception { ExceptionConverter converter = newExceptionConverter(); converter.getContext() .putProperty(TARGET_CLASSES_PROPERTY_NAME, "TargetClass"); ILoggingEvent loggingEvent = newErrorLoggingEvent(new TargetClass().blow()); assertThat(... | @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } @Override String convert(final ILoggingEvent loggingEvent); } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } @Override String convert(final ILoggingEvent loggingEvent); static final String TARGET_CLASSES_PROPERTY_NAME; } |
@Test public void errorsIfTargetClassPropertyIsEmpty() throws Exception { ContextBase contextBase = new ContextBase(); StatusManager statusManager = mock(StatusManager.class); contextBase.setStatusManager(statusManager); ExceptionConverter converter = newExceptionConverter(contextBase); converter.getContext() .putPrope... | @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } @Override String convert(final ILoggingEvent loggingEvent); } | ExceptionConverter extends ClassicConverter { @Override public String convert(final ILoggingEvent loggingEvent) { return Optional.ofNullable(loggingEvent) .map(this::getExceptionData) .orElse(NO_MSG); } @Override String convert(final ILoggingEvent loggingEvent); static final String TARGET_CLASSES_PROPERTY_NAME; } |
@Test public void canConfigureLoggingFromClasspath() { initLogging("classpath:conf/logback.xml", false); } | public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = location.replaceAll("\\\\... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... |
@Test public void canConfigureLoggingFromURL() { initLogging(LOGBackConfigurerTest.class.getResource("/conf/logback.xml"), false); } | public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = location.replaceAll("\\\\... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... |
@Test public void resolvesPlaceholdersBeforeInitializing() { System.setProperty("CONFIG_LOCATION", "classpath:"); initLogging("${CONFIG_LOCATION}conf/logback.xml", false); } | public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = location.replaceAll("\\\\... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... |
@Test public void failsForInvalidLogbackPath() { assertThrows(IllegalArgumentException.class, () -> initLogging(NON_EXISTENT_LOGBACK, false)); } | public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = location.replaceAll("\\\\... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... | LOGBackConfigurer { public static void initLogging(String logConfigLocation, boolean installJULBridge) { try { String location = resolvePlaceholders(logConfigLocation); if (location.indexOf("${") >= 0) { throw new IllegalStateException("unable to resolve certain placeholders: " + sanitise(location)); } location = locat... |
@Test public void failsAfterLimitOfIoExceptions() throws IOException { ReportCollector reported = new ReportCollector(); doAnswer(invocationOnMock -> { if (invocationOnMock.getArguments()[0].equals("prefix.timer.mean")) { throw new IOException(); } return reported.recordArguments(invocationOnMock); }).when(graphite).se... | @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); gauges.forEach((name, gauge) -> doReport(name, ... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... |
@Test public void readsTheDefaultValueForBossThreadsCountIfNotConfigured() { assertThat(styxConfig.proxyServerConfig().bossThreadsCount(), is(HALF_OF_AVAILABLE_PROCESSORS)); } | public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } | StyxConfig implements Configuration { public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } } | StyxConfig implements Configuration { public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } StyxConfig(); StyxConfig(Configuration configuration); } | StyxConfig implements Configuration { public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } StyxConfig(); StyxConfig(Configuration configuration); @Override Optional<T> get(String key, Class<T> tClass); @Override X as(Class<X> type); @Override Optional<String> get(String key); StyxHeaderConfig sty... | StyxConfig implements Configuration { public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } StyxConfig(); StyxConfig(Configuration configuration); @Override Optional<T> get(String key, Class<T> tClass); @Override X as(Class<X> type); @Override Optional<String> get(String key); StyxHeaderConfig sty... |
@Test public void readsTheDefaultValueForClientWorkerThreadsCountIfNotConfigured() { assertThat(styxConfig.proxyServerConfig().clientWorkerThreadsCount(), is(HALF_OF_AVAILABLE_PROCESSORS)); } | public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } | StyxConfig implements Configuration { public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } } | StyxConfig implements Configuration { public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } StyxConfig(); StyxConfig(Configuration configuration); } | StyxConfig implements Configuration { public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } StyxConfig(); StyxConfig(Configuration configuration); @Override Optional<T> get(String key, Class<T> tClass); @Override X as(Class<X> type); @Override Optional<String> get(String key); StyxHeaderConfig sty... | StyxConfig implements Configuration { public ProxyServerConfig proxyServerConfig() { return proxyServerConfig; } StyxConfig(); StyxConfig(Configuration configuration); @Override Optional<T> get(String key, Class<T> tClass); @Override X as(Class<X> type); @Override Optional<String> get(String key); StyxHeaderConfig sty... |
@Test public void stickySessionIsDisabledByDefault() { YamlApplicationsProvider config = loadFromPath("classpath:conf/origins/origins-for-configtest.yml"); BackendService app = applicationFor(config, "shopping"); assertThat(app.stickySessionConfig().stickySessionEnabled(), CoreMatchers.is(false)); } | public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... |
@Test public void stickySessionEnabledWhenYamlStickySessionEnabledIsTrue() { YamlApplicationsProvider config = loadFromPath("classpath:conf/origins/origins-for-configtest.yml"); BackendService app = applicationFor(config, "webapp"); assertThat(app.stickySessionConfig().stickySessionEnabled(), CoreMatchers.is(true)); } | public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... |
@Test public void cannotLoadWithNoApplications() throws IOException { Exception e = assertThrows(Exception.class, () -> loadFromPath("classpath:/conf/origins/empty-origins-for-configtest.yml")); assertThat(e.getMessage(), matchesPattern("Invalid YAML from classpath:conf/origins/empty-origins-for-configtest.yml: No cont... | public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... |
@Test public void doesNotLoadIfFileDoesNotExist() { Exception e = assertThrows(RuntimeException.class, () -> loadFromPath("/sadiusadasd")); assertThat(e.getMessage(), matchesPattern("Unable to load YAML from.*")); } | public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... |
@Test public void cannotLoadWithSyntaxErrors() throws IOException { Exception e = assertThrows(RuntimeException.class, () -> loadFromPath("classpath:/conf/origins/origins-with-syntax-error-for-configtest.yml")); assertThat(e.getMessage(), matchesPattern("Invalid YAML from classpath:conf/origins/origins-with-syntax-erro... | public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); } | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... | YamlApplicationsProvider { public static YamlApplicationsProvider loadFromPath(String path) { return new YamlApplicationsProvider(newResource(path)); } private YamlApplicationsProvider(String yamlText); YamlApplicationsProvider(Resource resource); static YamlApplicationsProvider loadFromPath(String path); static Yaml... |
@Test public void serviceReturnsCorrectlyFromCall() { assertThat(loadRetryPolicy(environment.configuration(), environment, "myRetry.factory", RetryPolicy.class).get(), is(instanceOf(RetryPolicy.class))); } | public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryConfig.factory(), Ret... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... |
@Test public void serviceReturnsEmptyWhenFactoryKeyDoesNotExist() { assertThat(loadRetryPolicy(environment.configuration(), environment, "invalid.key", RetryPolicy.class), isAbsent()); } | public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryConfig.factory(), Ret... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... |
@Test public void servicesReturnCorrectlyFromCall() { Map<String, String> services = loadServices(environment.configuration(), environment, "multi", String.class); assertThat(services, isMap(ImmutableMap.of( "one", "valueNumber1", "two", "valueNumber2", "three", "valueNumber3" ))); } | public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... |
@Test public void doesNotReportStringGaugeValues() throws Exception { reporter.report(map("gauge", gauge("value")), emptyMap(), emptyMap(), emptyMap(), emptyMap()); InOrder inOrder = inOrder(graphite); inOrder.verify(graphite).connect(); inOrder.verify(graphite, never()).send("prefix.gauge", "value", TIMESTAMP); inOrde... | @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); gauges.forEach((name, gauge) -> doReport(name, ... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... |
@Test public void isInstanceWorks() { Environment env = environmentWithConfig(yamlForServices); Map<String, StyxService> services = loadServices(env.configuration(), env, "multi", StyxService.class); assertThat(services.get("backendProvider"), instanceOf(BackendServiceProvider.class)); assertThat(services.get("routingP... | public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... |
@Test public void loadsNewConfigurationFormat() { Environment env = environmentWithConfig(yamlForServiceFactories); Map<String, StyxService> services = loadServices(env.configuration(), env, "multi", StyxService.class); assertThat(services.get("backendProvider"), instanceOf(BackendServiceProvider.class)); assertThat(se... | public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... |
@Test public void loadsFromMixedConfigFormat() { Environment env = environmentWithConfig(yamlForMixedServiceFactories); Map<String, StyxService> services = loadServices(env.configuration(), env, "multi", StyxService.class); assertThat(services.get("backendProvider"), instanceOf(BackendServiceProvider.class)); assertTha... | public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... |
@Test public void ignoresDisabledServices() { Environment env = environmentWithConfig(mixedDisabledServices); Map<String, StyxService> services = loadServices(env.configuration(), env, "multi", StyxService.class); assertThat(services.isEmpty(), is(true)); } | public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... |
@Test public void servicesReturnEmptyWhenFactoryKeyDoesNotExist() { Map<String, String> services = loadServices(environment.configuration(), environment, "invalid.key", String.class); assertThat(services, isMap(emptyMap())); } | public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... |
@Test public void throwsExceptionWhenClassDoesNotExist() { Exception e = assertThrows(Exception.class, () -> loadRetryPolicy(environment.configuration(), environment, "not.real", RetryPolicy.class)); assertThat(e.getMessage(), matchesPattern("(?s).*No such class 'my.FakeClass'.*")); } | public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryConfig.factory(), Ret... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... | ServiceProvision { public static <E extends RetryPolicy> Optional<E> loadRetryPolicy( Configuration configuration, Environment environment, String key, Class<? extends E> serviceClass) { return configuration .get(key, ServiceFactoryConfig.class) .map(factoryConfig -> { RetryPolicyFactory factory = newInstance(factoryCo... |
@Test public void throwsExceptionForInvalidServiceFactoryConfig() { String config = "" + "multi:\n" + " factories:\n" + " backendProvider:\n" + " enabled: false\n" + " config:\n" + " stringValue: valueNumber1\n"; Environment env = environmentWithConfig(config); Exception e = assertThrows(ConfigurationException.class, (... | public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... |
@Test public void throwsExceptionForInvalidSpiExtensionFactory() { String config = "" + "multi:\n" + " factories:\n" + " backendProvider:\n" + " enabled: false\n" + " factory:\n" + " classPath: /path/to/jar\n" + " config:\n" + " attribute: x\n"; Environment env = environmentWithConfig(config); Exception e = assertThrow... | public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } } | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... | ServiceProvision { public static <T> Map<String, T> loadServices(Configuration configuration, Environment environment, String key, Class<? extends T> serviceClass) { return configuration.get(key, JsonNode.class) .<Map<String, T>>map(node -> servicesMap(node, environment, serviceClass)) .orElse(emptyMap()); } private S... |
@Test public void serverDoesNotStartUntilPluginsAreStarted() throws InterruptedException { CountDownLatch latch = new CountDownLatch(1); StyxServer styxServer = styxServerWithPlugins(ImmutableMap.of( "slowlyStartingPlugin", new Plugin() { @Override public void styxStarting() { try { latch.await(); } catch (InterruptedE... | public InetSocketAddress proxyHttpAddress() { return Optional.ofNullable(httpServer) .map(InetServer::inetAddress) .orElse(null); } | StyxServer extends AbstractService { public InetSocketAddress proxyHttpAddress() { return Optional.ofNullable(httpServer) .map(InetServer::inetAddress) .orElse(null); } } | StyxServer extends AbstractService { public InetSocketAddress proxyHttpAddress() { return Optional.ofNullable(httpServer) .map(InetServer::inetAddress) .orElse(null); } StyxServer(StyxServerComponents config); StyxServer(StyxServerComponents components, Stopwatch stopwatch); } | StyxServer extends AbstractService { public InetSocketAddress proxyHttpAddress() { return Optional.ofNullable(httpServer) .map(InetServer::inetAddress) .orElse(null); } StyxServer(StyxServerComponents config); StyxServer(StyxServerComponents components, Stopwatch stopwatch); static void main(String[] args); InetSocket... | StyxServer extends AbstractService { public InetSocketAddress proxyHttpAddress() { return Optional.ofNullable(httpServer) .map(InetServer::inetAddress) .orElse(null); } StyxServer(StyxServerComponents config); StyxServer(StyxServerComponents components, Stopwatch stopwatch); static void main(String[] args); InetSocket... |
@Test public void startsFromMain() { try { setProperty("STYX_HOME", fixturesHome()); StyxServer.main(new String[0]); eventually(() -> assertThat(log.log(), hasItem(loggingEvent(INFO, "Started Styx server in \\d+ ms")))); } finally { clearProperty("STYX_HOME"); } } | public static void main(String[] args) { try { StyxServer styxServer = createStyxServer(args); getRuntime().addShutdownHook(new Thread(() -> styxServer.stopAsync().awaitTerminated())); styxServer.startAsync().awaitRunning(); } catch (SchemaValidationException cause) { LOG.error(cause.getMessage()); System.exit(2); } ca... | StyxServer extends AbstractService { public static void main(String[] args) { try { StyxServer styxServer = createStyxServer(args); getRuntime().addShutdownHook(new Thread(() -> styxServer.stopAsync().awaitTerminated())); styxServer.startAsync().awaitRunning(); } catch (SchemaValidationException cause) { LOG.error(caus... | StyxServer extends AbstractService { public static void main(String[] args) { try { StyxServer styxServer = createStyxServer(args); getRuntime().addShutdownHook(new Thread(() -> styxServer.stopAsync().awaitTerminated())); styxServer.startAsync().awaitRunning(); } catch (SchemaValidationException cause) { LOG.error(caus... | StyxServer extends AbstractService { public static void main(String[] args) { try { StyxServer styxServer = createStyxServer(args); getRuntime().addShutdownHook(new Thread(() -> styxServer.stopAsync().awaitTerminated())); styxServer.startAsync().awaitRunning(); } catch (SchemaValidationException cause) { LOG.error(caus... | StyxServer extends AbstractService { public static void main(String[] args) { try { StyxServer styxServer = createStyxServer(args); getRuntime().addShutdownHook(new Thread(() -> styxServer.stopAsync().awaitTerminated())); styxServer.startAsync().awaitRunning(); } catch (SchemaValidationException cause) { LOG.error(caus... |
@Test public void reportsByteGaugeValues() throws Exception { reporter.report(map("gauge", gauge((byte) 1)), emptyMap(), emptyMap(), emptyMap(), emptyMap()); InOrder inOrder = inOrder(graphite); inOrder.verify(graphite).connect(); inOrder.verify(graphite).send("prefix.gauge", "1", TIMESTAMP); inOrder.verify(graphite).f... | @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); gauges.forEach((name, gauge) -> doReport(name, ... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... | GraphiteReporter extends ScheduledReporter { @Override public void report(SortedMap<String, Gauge> gauges, SortedMap<String, Counter> counters, SortedMap<String, Histogram> histograms, SortedMap<String, Meter> meters, SortedMap<String, Timer> timers) { long timestamp = clock.getTime() / 1000; try { initConnection(); ga... |
@Test public void gaugeReportsHeapMemoryUsageValue() throws Exception { when(metricUnderTest.usedHeapMemory()).thenReturn(1L); NettyAllocatorMetricSet metricSet = new NettyAllocatorMetricSet("test-metric", metricUnderTest); Gauge<Long> metric = (Gauge<Long>) metricSet.getMetrics().get("test-metric.usedHeapMemory"); ass... | @Override public Map<String, Metric> getMetrics() { Map<String, Metric> gauges = new HashMap<>(); gauges.put(name(namespace, "usedDirectMemory"), (Gauge<Long>) metric::usedDirectMemory); gauges.put(name(namespace, "usedHeapMemory"), (Gauge<Long>) metric::usedHeapMemory); return copyOf(gauges); } | NettyAllocatorMetricSet implements MetricSet { @Override public Map<String, Metric> getMetrics() { Map<String, Metric> gauges = new HashMap<>(); gauges.put(name(namespace, "usedDirectMemory"), (Gauge<Long>) metric::usedDirectMemory); gauges.put(name(namespace, "usedHeapMemory"), (Gauge<Long>) metric::usedHeapMemory); r... | NettyAllocatorMetricSet implements MetricSet { @Override public Map<String, Metric> getMetrics() { Map<String, Metric> gauges = new HashMap<>(); gauges.put(name(namespace, "usedDirectMemory"), (Gauge<Long>) metric::usedDirectMemory); gauges.put(name(namespace, "usedHeapMemory"), (Gauge<Long>) metric::usedHeapMemory); r... | NettyAllocatorMetricSet implements MetricSet { @Override public Map<String, Metric> getMetrics() { Map<String, Metric> gauges = new HashMap<>(); gauges.put(name(namespace, "usedDirectMemory"), (Gauge<Long>) metric::usedDirectMemory); gauges.put(name(namespace, "usedHeapMemory"), (Gauge<Long>) metric::usedHeapMemory); r... | NettyAllocatorMetricSet implements MetricSet { @Override public Map<String, Metric> getMetrics() { Map<String, Metric> gauges = new HashMap<>(); gauges.put(name(namespace, "usedDirectMemory"), (Gauge<Long>) metric::usedDirectMemory); gauges.put(name(namespace, "usedHeapMemory"), (Gauge<Long>) metric::usedHeapMemory); r... |
@Test public void defaultFormatDoesNotIncludeVersion() { String info = new ResponseInfoFormat(defaultEnvironment()).format(request); assertThat(info, is("noJvmRouteSet;" + request.id())); } | public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } | ResponseInfoFormat { public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } } | ResponseInfoFormat { public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } ResponseInfoFormat(Environment environment); } | ResponseInfoFormat { public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } ResponseInfoFormat(Environment environment); String format(LiveHttpRequest request); } | ResponseInfoFormat { public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } ResponseInfoFormat(Environment environment); String format(LiveHttpRequest request); } |
@Test public void canConfigureCustomHeaderFormatWithVersion() { StyxHeaderConfig styxHeaderConfig = new StyxHeaderConfig( new StyxHeaderConfig.StyxHeader( null, "{VERSION};{REQUEST_ID};{INSTANCE}"), null, null); Environment environment = environment(new MapBackedConfiguration() .set("styxHeaders", styxHeaderConfig)); S... | public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } | ResponseInfoFormat { public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } } | ResponseInfoFormat { public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } ResponseInfoFormat(Environment environment); } | ResponseInfoFormat { public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } ResponseInfoFormat(Environment environment); String format(LiveHttpRequest request); } | ResponseInfoFormat { public String format(LiveHttpRequest request) { return String.format(format, request == null ? "" : request.id()); } ResponseInfoFormat(Environment environment); String format(LiveHttpRequest request); } |
@Test public void getsConfigAsClass() throws IOException { JsonNode configNode = MAPPER.readTree("foo: bar"); SpiExtension metadata = new SpiExtension(new SpiExtensionFactory("factoryClass", "classPath"), configNode, null); TestObject config = metadata.config(TestObject.class); assertThat(config.foo, is("bar")); } | public JsonNode config() { return config; } | SpiExtension { public JsonNode config() { return config; } } | SpiExtension { public JsonNode config() { return config; } @JsonCreator SpiExtension(@JsonProperty("factory") SpiExtensionFactory factory,
@JsonProperty("config") JsonNode config,
@JsonProperty("enabled") Boolean enabled); } | SpiExtension { public JsonNode config() { return config; } @JsonCreator SpiExtension(@JsonProperty("factory") SpiExtensionFactory factory,
@JsonProperty("config") JsonNode config,
@JsonProperty("enabled") Boolean enabled); SpiExtensionFactory factory(); JsonNode config()... | SpiExtension { public JsonNode config() { return config; } @JsonCreator SpiExtension(@JsonProperty("factory") SpiExtensionFactory factory,
@JsonProperty("config") JsonNode config,
@JsonProperty("enabled") Boolean enabled); SpiExtensionFactory factory(); JsonNode config()... |
@Test public void throwsAppropriateExceptionIfClassNotFound() { ExtensionObjectFactory factory = new ExtensionObjectFactory(extensionFactory -> name -> { throw new ClassNotFoundException(); }); Exception e = assertThrows(ExtensionLoadingException.class, () -> factory.newInstance(new SpiExtensionFactory("some.FakeClass"... | public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw e; } catch (Exception e)... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... |
@Test public void throwsAppropriateExceptionIfObjectCannotBeInstantiated() { ExtensionObjectFactory factory = new ExtensionObjectFactory(extensionFactory -> DEFAULT_CLASS_LOADER); String className = CannotInstantiate.class.getName(); try { factory.newInstance(new SpiExtensionFactory(className, "/fake/class/path"), Obje... | public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw e; } catch (Exception e)... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... |
@Test public void instantiatesObjects() { ExtensionObjectFactory factory = new ExtensionObjectFactory(extensionFactory -> DEFAULT_CLASS_LOADER); String className = String.class.getName(); Object object = factory.newInstance(new SpiExtensionFactory(className, "/fake/class/path"), Object.class); assertThat(object, is(ins... | public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw e; } catch (Exception e)... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... | ExtensionObjectFactory { public <T> T newInstance(SpiExtensionFactory extensionFactory, Class<T> type) throws ExtensionLoadingException { try { Class<?> extensionClass = loadClass(extensionFactory); Object instance = extensionClass.newInstance(); return type.cast(instance); } catch (ExtensionLoadingException e) { throw... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.