/** * Deserializes {@link ConjureDefinition} from their YAML representations in the given files. */ public static ConjureDefinition parse(Collection<File> files) { return ConjureParserUtils.parseConjureDef( files.stream().map(ConjureParser::parse).collect(Collectors.toList())); } }
@Override public TypeDefinition visit(EnumTypeDefinition def) { return ConjureParserUtils.parseEnumType( ConjureParserUtils.createTypeName(name, def, defaultPackage), def); }
@Override public TypeDefinition visit(AliasTypeDefinition def) { return ConjureParserUtils.parseAliasType( ConjureParserUtils.createTypeName(name, def, defaultPackage), def, typeResolver); }
@Override public TypeDefinition visit(ObjectTypeDefinition def) { return ConjureParserUtils.parseObjectType( ConjureParserUtils.createTypeName(name, def, defaultPackage), def, typeResolver); }
Map<TypeName, TypeDefinition> objects = parseObjects(parsed.types(), typeResolver); Map<TypeName, TypeDefinition> importedObjects = parseImportObjects(parsed.types().conjureImports()); Map<TypeName, TypeDefinition> allObjects = Maps.newHashMap(); allObjects.putAll(objects); servicesBuilder.add(parseService( service, TypeName.of(serviceName.name(), parseConjurePackage(service.conjurePackage())), typeResolver, dealiasingVisitor)); errorsBuilder.addAll(parseErrors(parsed.types().definitions(), typeResolver)); });
private static EndpointDefinition parseEndpoint( String name, com.palantir.conjure.parser.services.EndpointDefinition def, PathString basePath, Optional<AuthType> defaultAuth, ReferenceTypeResolver typeResolver, DealiasingTypeVisitor dealiasingVisitor) { HttpPath httpPath = parseHttpPath(def, basePath); EndpointDefinition endpoint = EndpointDefinition.builder() .endpointName(EndpointName.of(name)) .httpMethod(HttpMethod.valueOf(def.http().method())) .httpPath(httpPath) .auth(def.auth().map(ConjureParserUtils::parseAuthType).orElse(defaultAuth)) .args(parseArgs(def.args(), httpPath, typeResolver)) .markers(parseMarkers(def.markers(), typeResolver)) .returns(def.returns().map(t -> t.visit(new ConjureTypeParserVisitor(typeResolver)))) .docs(def.docs().map(Documentation::of)) .deprecated(def.deprecated().map(Documentation::of)) .build(); EndpointDefinitionValidator.validateAll(endpoint, dealiasingVisitor); return endpoint; }
@Override public TypeDefinition visit(UnionTypeDefinition def) { return ConjureParserUtils.parseUnionType( ConjureParserUtils.createTypeName(name, def, defaultPackage), def, typeResolver); } }
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(); }
static ServiceDefinition parseService( com.palantir.conjure.parser.services.ServiceDefinition parsed, TypeName serviceName, ReferenceTypeResolver typeResolver, DealiasingTypeVisitor dealiasingVisitor) { List<EndpointDefinition> endpoints = new ArrayList<>(); parsed.endpoints().forEach((name, def) -> endpoints.add( ConjureParserUtils.parseEndpoint( name, def, parsed.basePath(), parseAuthType(parsed.defaultAuth()), typeResolver, dealiasingVisitor))); ServiceDefinition service = ServiceDefinition.builder() .serviceName(serviceName) .docs(parsed.docs().map(Documentation::of)) .addAllEndpoints(endpoints) .build(); ServiceDefinitionValidator.validateAll(service); return service; }
@Test public void resolvesImportedAliases() { ConjureDefinition conjureDefinition = ConjureParserUtils.parseConjureDef( ImmutableList.of(ConjureParser.parse(new File("src/test/resources/example-conjure-imports.yml")))); assertThat(conjureDefinition.getTypes()).hasSize(1); }
@Test @Ignore public void handlesNonJavaExternalType() { ConjureDefinition conjureDefinition = ConjureParserUtils.parseConjureDef( ImmutableList.of(ConjureParser.parse(new File("src/test/resources/example-external-types.yml")))); } }
@Test public void testConjureSpec() { // test positive cases testCaseDef.positive().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> { String testName = String.format("positive case %s", entry.getKey()); String yml = getYmlAsString(testName, entry.getValue().conjure()); try { ConjureParserUtils.parseConjureDef(ImmutableList.of(MAPPER.readValue(yml, ConjureSourceFile.class))); } catch (Exception e) { Assertions.fail("Conjure for case should be valid according to the spec: " + testName, e); } }); // test negative cases testCaseDef.negative().orElse(new TreeMap<>()).entrySet().stream().forEach(entry -> { String testName = String.format("negative case %s", entry.getKey()); String yml = getYmlAsString(testName, entry.getValue().conjure()); try { ConjureParserUtils.parseConjureDef(ImmutableList.of(MAPPER.readValue(yml, ConjureSourceFile.class))); Assertions.fail("Conjure for case should be invalid according to the spec: " + testName); } catch (Exception e) { Assertions.assertThat(e).withFailMessage("Failure message for case did not match expectation: " + testName + "\nMessage:\n" + e.getMessage() + "\ndid not contain:\n" + entry.getValue().expectedError()).hasMessageContaining(entry.getValue().expectedError()); } }); }