static List<ErrorDefinition> parseErrors( NamedTypesDefinition defs, ConjureTypeParserVisitor.ReferenceTypeResolver typeResolver) { Optional<String> defaultPackage = defs.defaultConjurePackage().map(p -> p.name()); ImmutableList.Builder<ErrorDefinition> errorsBuidler = ImmutableList.builder(); errorsBuidler.addAll(defs.errors().entrySet().stream().map(entry -> { TypeName typeName = TypeName.of( entry.getKey().name(), parsePackageOrElseThrow(entry.getValue().conjurePackage(), defaultPackage)); return parseErrorType(typeName, entry.getValue(), typeResolver); }).collect(Collectors.toList())); return errorsBuidler.build(); }
public static TypeName createTypeName( String name, com.palantir.conjure.parser.types.BaseObjectTypeDefinition def, Optional<String> defaultPackage) { TypeName type = TypeName.of(name, parsePackageOrElseThrow(def.conjurePackage(), defaultPackage)); TypeNameValidator.validate(type); return type; }
private static Optional<TypeName> resolveReferenceType(Type type) { if (type.accept(TypeVisitor.IS_REFERENCE)) { return Optional.of(type.accept(TypeVisitor.REFERENCE)); } else if (type.accept(TypeVisitor.IS_PRIMITIVE)) { return Optional.of( TypeName.of(type.accept(TypeVisitor.PRIMITIVE).get().name(), "")); } return Optional.empty(); }
@Test public void testInvalidNames() { for (String invalid : new String[] {"a", "IFoo", "ABC", "$Special", "snake_case", "kebab-case", "Camel1B"}) { assertThatThrownBy(() -> TypeNameValidator.validate(TypeName.of(invalid, PACKAGE))) .isInstanceOf(IllegalArgumentException.class) .hasMessage("TypeNames must be a primitive type" + " [STRING, DATETIME, INTEGER, DOUBLE, SAFELONG, BINARY, ANY, BOOLEAN, UUID, RID," + " BEARERTOKEN, UNKNOWN] or match pattern ^[A-Z][a-z0-9]+([A-Z][a-z0-9]+)*$: %s", invalid); } } }
private FieldDefinition field(FieldName name, String type) { return FieldDefinition.of(name, Type.reference(TypeName.of(type, PACKAGE)), DOCS); } }
private static Type resolveFromTypeName( com.palantir.conjure.parser.types.names.TypeName name, TypesDefinition types) { Optional<String> defaultPackage = types.definitions().defaultConjurePackage().map(ConjureParserUtils::parseConjurePackage); BaseObjectTypeDefinition maybeDirectDef = types.definitions().objects().get(name); String conjurePackage; String typeName; if (maybeDirectDef == null) { ExternalTypeDefinition maybeExternalDef = types.imports().get(name); if (maybeExternalDef == null) { throw new IllegalStateException("Unknown LocalReferenceType: " + name); } String externalPath = maybeExternalDef.external().java(); int lastIndex = externalPath.lastIndexOf("."); conjurePackage = externalPath.substring(0, lastIndex); typeName = externalPath.substring(lastIndex + 1); return Type.external(ExternalReference.builder() .externalReference(TypeName.of(typeName, conjurePackage)) .fallback(ConjureParserUtils.parsePrimitiveType(maybeExternalDef.baseType())) .build()); } else { // Conjure-defined object conjurePackage = ConjureParserUtils.parsePackageOrElseThrow( maybeDirectDef.conjurePackage(), defaultPackage); return Type.reference(TypeName.of(name.name(), conjurePackage)); } } }
servicesBuilder.add(parseService( service, TypeName.of(serviceName.name(), parseConjurePackage(service.conjurePackage())), typeResolver, dealiasingVisitor));
@Test public void testUniqueEnumValues() { EnumDefinition.Builder definition = EnumDefinition.builder() .typeName(TypeName.of("Foo", "package")) .values(EnumValueDefinition.builder().value("FOO").build()) .values(EnumValueDefinition.builder().value("FOO").build()); assertThatThrownBy(() -> EnumDefinitionValidator.validateAll(definition.build())) .isInstanceOf(IllegalArgumentException.class) .hasMessage("Cannot declare a EnumTypeDefinition with duplicate enum values: FOO"); } }
@Test public void testUnionMemberKeyMustNotBeIllegalJavaIdentifier() { ImmutableList.of("%foo", "foo@").forEach(key -> { FieldDefinition fieldDefinition = FieldDefinition.builder() .fieldName(FieldName.of(key)) .type(Type.primitive(PrimitiveType.STRING)) .build(); assertThatThrownBy(() -> UnionDefinitionValidator.validateAll(UnionDefinition.builder() .union(fieldDefinition) .typeName(TypeName.of("string", "")) .build())) .isInstanceOf(IllegalArgumentException.class) .hasMessageStartingWith( String.format("Union member key must be a valid Java identifier: %s", key)); }); }
@Test public void testUnionMemberKeyMustNotBeEmpty() { FieldDefinition fieldDefinition = FieldDefinition.builder() .fieldName(FieldName.of("")) .type(Type.primitive(PrimitiveType.STRING)) .build(); assertThatThrownBy(() -> UnionDefinitionValidator.validateAll(UnionDefinition.builder() .union(fieldDefinition) .typeName(TypeName.of("string", "")) .build())) .isInstanceOf(IllegalArgumentException.class) .hasMessageStartingWith("Union member key must not be empty"); }
@Test public void testUnionMemberKeyMustNotHaveTrailingUnderscore() { FieldDefinition fieldDefinition = FieldDefinition.builder() .fieldName(FieldName.of("foo_")) .type(Type.primitive(PrimitiveType.STRING)) .build(); assertThatThrownBy(() -> UnionDefinitionValidator.validateAll(UnionDefinition.builder() .union(fieldDefinition) .typeName(TypeName.of("string", "")) .build())) .isInstanceOf(IllegalArgumentException.class) .hasMessageStartingWith("Union member key must not end with an underscore: foo_"); } }
private void testUniqueFieldNameValidator(String fieldName1, String fieldName2) { FieldDefinition field1 = FieldDefinition.builder() .fieldName(FieldName.of(fieldName1)) .type(Type.primitive(PrimitiveType.STRING)) .build(); FieldDefinition field2 = FieldDefinition.builder() .fieldName(FieldName.of(fieldName2)) .type(Type.primitive(PrimitiveType.STRING)) .build(); TypeName name = TypeName.of("Foo", "package"); ObjectDefinition definition = ObjectDefinition.builder() .typeName(name) .fields(field1) .fields(field2) .build(); assertThatThrownBy(() -> ObjectDefinitionValidator.validate(definition)) .isInstanceOf(IllegalArgumentException.class) .hasMessage(String.format("ObjectDefinition must not contain duplicate field names " + "(modulo case normalization): %s vs %s", fieldName2, fieldName1)); } }
@Test public void testComplexHeaderObject() { TypeName typeName = TypeName.of("SomeObject", "com.palantir.foo"); EndpointDefinition.Builder definition = EndpointDefinition.builder() .args(ArgumentDefinition.builder() .argName(ArgumentName.of("someName")) .type(Type.reference(typeName)) .paramType(ParameterType.header(HeaderParameterType.of(ParameterId.of("SomeId")))) .build()) .endpointName(ENDPOINT_NAME) .httpMethod(HttpMethod.GET) .httpPath(HttpPath.of("/a/path")); DealiasingTypeVisitor dealiasingVisitor = new DealiasingTypeVisitor(ImmutableMap.of( typeName, TypeDefinition.object(ObjectDefinition.of(typeName, ImmutableList.of(), Documentation.of(""))) )); assertThatThrownBy(() -> EndpointDefinitionValidator.validateAll(definition.build(), dealiasingVisitor)) .isInstanceOf(IllegalStateException.class) .hasMessage("Header parameters must be enums, primitives, aliases or optional primitive:" + " \"someName\" is not allowed"); } }
.build(); ErrorDefinition definition1 = ErrorDefinition.builder() .errorName(TypeName.of("Foo", "package")) .namespace(ErrorNamespace.of("Test")) .code(ErrorCode.INVALID_ARGUMENT) .build(); ErrorDefinition definition2 = ErrorDefinition.builder() .errorName(TypeName.of("Foo", "package")) .namespace(ErrorNamespace.of("Test")) .code(ErrorCode.INVALID_ARGUMENT)
@Test public void testRecursiveTypeOkInReference() { Type referenceType = Type.reference(FOO); TypeDefinition objectDefinition = TypeDefinition.object( ObjectDefinition.builder() .typeName(TypeName.of("Foo", "bar")) .addAllFields(ImmutableList.of( FieldDefinition.of(FieldName.of("selfOptional"), Type.optional(OptionalType.of(Type.reference(FOO))), DOCS), FieldDefinition.of(FieldName.of("selfMap"), Type.map(MapType.of(referenceType, referenceType)), DOCS), FieldDefinition.of(FieldName.of("selfSet"), Type.set(SetType.of(referenceType)), DOCS), FieldDefinition.of(FieldName.of("selfList"), Type.list(ListType.of(referenceType)), DOCS))) .build()); ConjureDefinition conjureDef = ConjureDefinition.builder() .version(1) .types(ImmutableList.of(objectDefinition)) .build(); ConjureDefinitionValidator.NO_RECURSIVE_TYPES.validate(conjureDef); }