From 45a22717063bb5d0e2649ca57e424d35874f6a2c Mon Sep 17 00:00:00 2001 From: svc-excavator-bot Date: Tue, 17 Sep 2019 20:37:44 +0000 Subject: [PATCH] Excavator: Upgrades Baseline to the latest version --- .baseline/checkstyle/checkstyle.xml | 8 +- build.gradle | 2 +- .../conjure/defs/ConjureParserUtils.java | 9 +- .../EndpointDefinitionValidator.java | 7 +- .../validator/UnionDefinitionValidator.java | 2 +- .../parser/services/AuthDefinition.java | 4 +- .../types/BaseObjectTypeDefinition.java | 3 +- .../conjure/defs/ConjureSpecTest.java | 4 +- .../parsec/tests/TestUnitParsers.java | 87 +++++++++---------- 9 files changed, 63 insertions(+), 63 deletions(-) diff --git a/.baseline/checkstyle/checkstyle.xml b/.baseline/checkstyle/checkstyle.xml index efc641dfd..268ebe3fc 100644 --- a/.baseline/checkstyle/checkstyle.xml +++ b/.baseline/checkstyle/checkstyle.xml @@ -127,6 +127,11 @@ + + + + + @@ -417,6 +422,7 @@ + @@ -430,7 +436,7 @@ - + diff --git a/build.gradle b/build.gradle index 97d8fce5f..06021a067 100644 --- a/build.gradle +++ b/build.gradle @@ -29,7 +29,7 @@ buildscript { classpath 'com.netflix.nebula:gradle-info-plugin:5.0.3' classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4' classpath 'com.netflix.nebula:nebula-publishing-plugin:13.5.1' - classpath 'com.palantir.baseline:gradle-baseline-java:0.51.1' + classpath 'com.palantir.baseline:gradle-baseline-java:2.6.0' classpath 'com.palantir.gradle.conjure:gradle-conjure:4.13.1' classpath 'com.palantir.gradle.gitversion:gradle-git-version:0.12.2' classpath 'gradle.plugin.org.inferred:gradle-processors:3.1.0' diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java b/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java index 73da9db35..ca9c7b788 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/ConjureParserUtils.java @@ -72,6 +72,7 @@ import com.palantir.conjure.spec.UnionDefinition; import com.palantir.conjure.visitor.DealiasingTypeVisitor; import com.palantir.conjure.visitor.TypeDefinitionVisitor; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; import java.util.ArrayList; import java.util.Collection; import java.util.List; @@ -97,7 +98,7 @@ public static String parsePackageOrElseThrow( Optional defaultPackage) { String packageName = conjurePackage .map(p -> p.name()) - .orElseGet(() -> defaultPackage.orElseThrow(() -> new IllegalArgumentException( + .orElseGet(() -> defaultPackage.orElseThrow(() -> new SafeIllegalArgumentException( // TODO(rfink): Better errors: Can we provide context on where exactly no package was provided? "Must provide default conjure package or " + "explicit conjure package for every object and service"))); @@ -373,7 +374,7 @@ private static Optional parseAuthType( case NONE: return Optional.empty(); default: - throw new IllegalArgumentException("Unrecognized auth type."); + throw new SafeIllegalArgumentException("Unrecognized auth type."); } } @@ -415,14 +416,14 @@ private static ParameterType parseParameterType( return ParameterType.body(BodyParameterType.of()); } case HEADER: - String headerParamId = argumentDef.paramId().map(id -> id.name()).orElse(argName.get()); + String headerParamId = argumentDef.paramId().map(id -> id.name()).orElseGet(() -> argName.get()); return ParameterType.header(HeaderParameterType.of(ParameterId.of(headerParamId))); case PATH: return ParameterType.path(PathParameterType.of()); case BODY: return ParameterType.body(BodyParameterType.of()); case QUERY: - String queryParamId = argumentDef.paramId().map(id -> id.name()).orElse(argName.get()); + String queryParamId = argumentDef.paramId().map(id -> id.name()).orElseGet(() -> argName.get()); return ParameterType.query(QueryParameterType.of(ParameterId.of(queryParamId))); default: throw new IllegalArgumentException("Unknown parameter type: " + argumentDef.paramType()); diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java index c38fe80e3..320d4aaf2 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/EndpointDefinitionValidator.java @@ -39,6 +39,7 @@ import com.palantir.conjure.visitor.ParameterTypeVisitor; import com.palantir.conjure.visitor.TypeDefinitionVisitor; import com.palantir.conjure.visitor.TypeVisitor; +import com.palantir.logsafe.exceptions.SafeRuntimeException; import java.util.Arrays; import java.util.HashSet; import java.util.List; @@ -306,17 +307,17 @@ public Boolean visitMap(MapType value) { // DealiasingTypeVisitor above @Override public Boolean visitReference(TypeName value) { - throw new RuntimeException("Unexpected type when validating query parameters"); + throw new SafeRuntimeException("Unexpected type when validating query parameters"); } @Override public Boolean visitExternal(ExternalReference value) { - throw new RuntimeException("Unexpected type when validating query parameters"); + throw new SafeRuntimeException("Unexpected type when validating query parameters"); } @Override public Boolean visitUnknown(String unknownType) { - throw new RuntimeException("Unexpected type when validating query parameters"); + throw new SafeRuntimeException("Unexpected type when validating query parameters"); } })); } diff --git a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java index 1acfe5b42..c5c40197a 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java +++ b/conjure-core/src/main/java/com/palantir/conjure/defs/validator/UnionDefinitionValidator.java @@ -74,7 +74,7 @@ private static boolean isValidJavaIdentifier(String key) { @Override public void validate(UnionDefinition definition) { definition.getUnion().stream().forEach(fieldDef -> { - Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldDef.getFieldName().get()), + com.palantir.logsafe.Preconditions.checkArgument(!Strings.isNullOrEmpty(fieldDef.getFieldName().get()), "Union member key must not be empty"); Preconditions.checkArgument(isValidJavaIdentifier(fieldDef.getFieldName().get()), "Union member key must be a valid Java identifier: %s", diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java b/conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java index 2c767b10a..858da55dd 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/services/AuthDefinition.java @@ -16,12 +16,12 @@ package com.palantir.conjure.parser.services; -import static com.google.common.base.Preconditions.checkArgument; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonValue; import com.fasterxml.jackson.databind.annotation.JsonDeserialize; import com.palantir.conjure.defs.ConjureImmutablesStyle; +import com.palantir.logsafe.Preconditions; import java.util.Locale; import org.immutables.value.Value; @@ -81,7 +81,7 @@ static AuthDefinition fromString(String value) { id = "NONE"; break; case COOKIE: - checkArgument(parts.length == 2, "Cookie authorization type must include a cookie name"); + Preconditions.checkArgument(parts.length == 2, "Cookie authorization type must include a cookie name"); id = parts[1]; break; default: diff --git a/conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java b/conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java index 13479fcd5..de65e46ad 100644 --- a/conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java +++ b/conjure-core/src/main/java/com/palantir/conjure/parser/types/BaseObjectTypeDefinition.java @@ -29,6 +29,7 @@ import com.palantir.conjure.parser.types.complex.UnionTypeDefinition; import com.palantir.conjure.parser.types.names.ConjurePackage; import com.palantir.conjure.parser.types.reference.AliasTypeDefinition; +import com.palantir.logsafe.exceptions.SafeIllegalArgumentException; import java.io.IOException; import java.util.Optional; @@ -57,7 +58,7 @@ public BaseObjectTypeDefinition deserialize(JsonParser parser, DeserializationCo } else if (tree.get("namespace") != null) { return ErrorTypeDefinition.fromJson(parser, tree); } else { - throw new IllegalArgumentException( + throw new SafeIllegalArgumentException( "Unrecognized definition, types must have either fields, values or an alias defined."); } } diff --git a/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java b/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java index 80712fb80..be94910f8 100644 --- a/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java +++ b/conjure-core/src/test/java/com/palantir/conjure/defs/ConjureSpecTest.java @@ -69,7 +69,7 @@ public ConjureSpecTest(TestCaseDefinition testCaseDef) { @Test public void testConjureSpec() { // test positive cases - testCaseDef.positive().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> { + testCaseDef.positive().orElseGet(() -> new TreeMap<>()).entrySet().stream().forEach(entry -> { String testName = String.format("positive case %s", entry.getKey()); String yml = getYmlAsString(testName, entry.getValue().conjure()); try { @@ -80,7 +80,7 @@ public void testConjureSpec() { }); // test negative cases - testCaseDef.negative().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> { + testCaseDef.negative().orElseGet(() -> new TreeMap<>()).entrySet().stream().forEach(entry -> { String testName = String.format("negative case %s", entry.getKey()); String yml = getYmlAsString(testName, entry.getValue().conjure()); try { diff --git a/conjure-core/src/test/java/com/palantir/parsec/tests/TestUnitParsers.java b/conjure-core/src/test/java/com/palantir/parsec/tests/TestUnitParsers.java index d6ff1cf84..ce7b534d6 100644 --- a/conjure-core/src/test/java/com/palantir/parsec/tests/TestUnitParsers.java +++ b/conjure-core/src/test/java/com/palantir/parsec/tests/TestUnitParsers.java @@ -16,8 +16,7 @@ package com.palantir.parsec.tests; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNull; +import static org.assertj.core.api.Assertions.assertThat; import com.palantir.parsec.ParseException; import com.palantir.parsec.Parser; @@ -42,20 +41,18 @@ public final class TestUnitParsers { @Test public void testQuotedStringParser() throws ParseException { - assertEquals("Test 123", new QuotedStringParser(false).parse(new StringParserState("\"Test 123\""))); - assertEquals("Test \"123", - new QuotedStringParser(false).parse(new StringParserState("\"Test \\\"123\""))); - assertEquals("Test 123", new QuotedStringParser(false).parse(new StringParserState("\"Test \n\n123\""))); - assertEquals("Test \n\n123", - new QuotedStringParser(true).parse(new StringParserState("\"Test \n\n123\""))); + assertThat(new QuotedStringParser(false).parse(new StringParserState("\"Test 123\""))).isEqualTo("Test 123"); + assertThat(new QuotedStringParser(false).parse(new StringParserState("\"Test \\\"123\""))).isEqualTo("Test \"123"); + assertThat(new QuotedStringParser(false).parse(new StringParserState("\"Test \n\n123\""))).isEqualTo("Test 123"); + assertThat(new QuotedStringParser(true).parse(new StringParserState("\"Test \n\n123\""))).isEqualTo("Test \n\n123"); } @Test public void testRawStringParser() { - assertEquals("a:b123", new RawStringParser().parse(new StringParserState("a:b123"))); - assertNull(new RawStringParser().parse(new StringParserState(" a:b123"))); - assertEquals("ab123", new RawStringParser().parse(new StringParserState("ab123 "))); - assertEquals("ab123", new RawStringParser().parse(new StringParserState("ab123\n"))); + assertThat(new RawStringParser().parse(new StringParserState("a:b123"))).isEqualTo("a:b123"); + assertThat(new RawStringParser().parse(new StringParserState(" a:b123"))).isNull(); + assertThat(new RawStringParser().parse(new StringParserState("ab123 "))).isEqualTo("ab123"); + assertThat(new RawStringParser().parse(new StringParserState("ab123\n"))).isEqualTo("ab123"); } @Test @@ -65,29 +62,25 @@ public void testDispatchingParser() throws ParseException { map.put("dir1", new RawStringParser()); map.put("dir2", new QuotedStringParser()); - assertEquals("def", new DispatchingParser(map, Parsers.whitespace()) - .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))); - assertEquals("def", new DispatchingParser(map, Parsers.whitespace()) - .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))); + assertThat(new DispatchingParser(map, Parsers.whitespace()) + .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))).isEqualTo("def"); + assertThat(new DispatchingParser(map, Parsers.whitespace()) + .parse(new StringParserState("dir1 abc\ndir2 \"def\n\"\n"))).isEqualTo("def"); } @Test public void testExpectantParser() { - assertEquals(ExpectationResult.CORRECT, - new ExpectantParser("abcdef").parse(new StringParserState("abcdef"))); - assertEquals(ExpectationResult.INCORRECT, - new ExpectantParser("abcdef").parse(new StringParserState("abcde"))); - assertEquals(ExpectationResult.INCORRECT, - new ExpectantParser("abcdef").parse(new StringParserState("abcdeg"))); + assertThat(new ExpectantParser("abcdef").parse(new StringParserState("abcdef"))).isEqualTo(ExpectationResult.CORRECT); + assertThat(new ExpectantParser("abcdef").parse(new StringParserState("abcde"))).isEqualTo(ExpectationResult.INCORRECT); + assertThat(new ExpectantParser("abcdef").parse(new StringParserState("abcdeg"))).isEqualTo(ExpectationResult.INCORRECT); } @Test public void testBetweenParser() throws ParseException { - assertEquals("abcdef", - new BetweenParser(new ExpectantParser("{"), + assertThat(new BetweenParser(new ExpectantParser("{"), Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.prefix(Parsers.whitespace(), new ExpectantParser("}"))) - .parse(new StringParserState("{ abcdef }"))); + .parse(new StringParserState("{ abcdef }"))).isEqualTo("abcdef"); } @Test @@ -95,24 +88,24 @@ public void testListParser() throws ParseException { List list = new ArrayList<>(); list.add("abc"); list.add("def"); - assertEquals(list, new ListParser<>(new QuotedStringParser(), Parsers.whitespace()) - .parse(new StringParserState("\"abc\" \"def\""))); + assertThat(new ListParser<>(new QuotedStringParser(), Parsers.whitespace()) + .parse(new StringParserState("\"abc\" \"def\""))).isEqualTo(list); } @Test public void testMapParser() throws ParseException { Map map = new HashMap(); map.put("abc", "def"); - assertEquals(map, new MapParser(new RawStringParser(), + assertThat(new MapParser(new RawStringParser(), Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.whitespace()).parse( - new StringParserState("abc def"))); - assertEquals(map, new MapParser(Parsers.prefix(Parsers.whitespace(), new RawStringParser()), + new StringParserState("abc def"))).isEqualTo(map); + assertThat(new MapParser(Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.whitespace()).parse( - new StringParserState(" abc def"))); + new StringParserState(" abc def"))).isEqualTo(map); map.put("ghi", "jkl"); - assertEquals(map, new MapParser(Parsers.prefix(Parsers.whitespace(), new RawStringParser()), + assertThat(new MapParser(Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.prefix(Parsers.whitespace(), new RawStringParser()), Parsers.whitespace()).parse( - new StringParserState("abc def ghi jkl"))); + new StringParserState("abc def ghi jkl"))).isEqualTo(map); } @Test @@ -129,12 +122,12 @@ public void testMapParserBuiltup() throws ParseException { MapParser mapParser2 = new MapParser(whitespaceStringParser, whitespaceStringParser, Parsers.whitespace()); - assertEquals(map, mapParser1.parse(new StringParserState("abc def"))); - assertEquals(map, mapParser2.parse(new StringParserState(" abc def"))); + assertThat(mapParser1.parse(new StringParserState("abc def"))).isEqualTo(map); + assertThat(mapParser2.parse(new StringParserState(" abc def"))).isEqualTo(map); map.put("ghi", "jkl"); - assertEquals(map, mapParser2.parse(new StringParserState("abc def ghi jkl"))); + assertThat(mapParser2.parse(new StringParserState("abc def ghi jkl"))).isEqualTo(map); } @Test @@ -151,10 +144,8 @@ public String getDescription() { } }); - assertEquals("abcdef", - Parsers.or(rawNoPunctuation, new QuotedStringParser()).parse(new StringParserState("abcdef"))); - assertEquals("abcdef", - Parsers.or(rawNoPunctuation, new QuotedStringParser()).parse(new StringParserState("\"abcdef\""))); + assertThat(Parsers.or(rawNoPunctuation, new QuotedStringParser()).parse(new StringParserState("abcdef"))).isEqualTo("abcdef"); + assertThat(Parsers.or(rawNoPunctuation, new QuotedStringParser()).parse(new StringParserState("\"abcdef\""))).isEqualTo("abcdef"); } private static final Parser rsp = Parsers.prefix(Parsers.whitespace(), new RawStringParser()); @@ -164,28 +155,28 @@ public String getDescription() { public void testGingerlyBooleanFalse() throws ParseException { StringParserState state = new StringParserState("false 123"); - assertEquals(Boolean.FALSE, Parsers.gingerly(bp).parse(state)); - assertEquals("123", rsp.parse(state)); + assertThat(Parsers.gingerly(bp).parse(state)).isEqualTo(Boolean.FALSE); + assertThat(rsp.parse(state)).isEqualTo("123"); } @Test public void testGingerlyBooleanTrue() throws ParseException { StringParserState state = new StringParserState("true 123"); - assertEquals(Boolean.TRUE, Parsers.gingerly(bp).parse(state)); - assertEquals("123", rsp.parse(state)); + assertThat(Parsers.gingerly(bp).parse(state)).isEqualTo(Boolean.TRUE); + assertThat(rsp.parse(state)).isEqualTo("123"); } @Test public void testEofParser() throws ParseException { - assertEquals(ExpectationResult.CORRECT, Parsers.eof(new ExpectantParser("abc")) - .parse(new StringParserState("abc"))); + assertThat(Parsers.eof(new ExpectantParser("abc")) + .parse(new StringParserState("abc"))).isEqualTo(ExpectationResult.CORRECT); } @Test public void testEofParserFails() throws ParseException { - assertNull(Parsers.eof(new ExpectantParser("abc")) - .parse(new StringParserState("abcdef"))); + assertThat(Parsers.eof(new ExpectantParser("abc")) + .parse(new StringParserState("abcdef"))).isNull(); } }