@Override public void validate(ConjureDefinition definition) { // create mapping for resolving reference types during validation Map<TypeName, TypeDefinition> definitionMap = definition.getTypes().stream().collect( Collectors.toMap(entry -> entry.accept(TypeDefinitionVisitor.TYPE_NAME), entry -> entry)); definition.getTypes().stream().forEach(def -> validateTypeDefinition(def, definitionMap)); definition.getErrors().forEach(def -> validateErrorDefinition(def, definitionMap)); definition.getServices().forEach(def -> validateServiceDefinition(def, definitionMap)); }
@Override public void validate(ConjureDefinition definition) { Preconditions.checkState(definition.getVersion() == Conjure.SUPPORTED_IR_VERSION, "Definition version must be %s, but version %s is provided instead.", Conjure.SUPPORTED_IR_VERSION, definition.getVersion()); } }
}); ConjureDefinition definition = ConjureDefinition.builder() .version(Conjure.SUPPORTED_IR_VERSION) .types(typesBuilder.build())
@Override public void validate(ConjureDefinition definition) { // create mapping from object type name -> names of reference types that are fields of that type Multimap<TypeName, TypeName> typeToRefFields = HashMultimap.create(); definition.getTypes().stream().forEach(type -> getReferenceType(type) .ifPresent(entry -> typeToRefFields.put( type.accept(TypeDefinitionVisitor.TYPE_NAME), entry))); for (TypeName name : typeToRefFields.keySet()) { verifyTypeHasNoRecursiveDefinitions(name, typeToRefFields, new ArrayList<>()); } }
@Override public void validate(ConjureDefinition definition) { Set<String> seenNames = new HashSet<>(); definition.getServices().forEach(service -> { boolean isNewName = seenNames.add(service.getServiceName().getName()); Preconditions.checkState(isNewName, "Service names must be unique: %s", service.getServiceName().getName()); }); } }
@Test public void testNoSelfRecursiveType() { ConjureDefinition conjureDef = ConjureDefinition.builder() .version(1) .types(ImmutableList.of(TypeDefinition.object( ObjectDefinition.builder() .typeName(FOO) .fields(FieldDefinition.of(FieldName.of("self"), Type.reference(FOO), DOCS)) .build()))) .build(); assertThatThrownBy(() -> ConjureDefinitionValidator.NO_RECURSIVE_TYPES.validate(conjureDef)) .isInstanceOf(IllegalStateException.class) .hasMessage("Illegal recursive data type: Foo -> Foo"); }
@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); }
@Override public void validate(ConjureDefinition definition) { Set<TypeName> seenNames = new HashSet<>(); definition.getTypes().forEach(typeDef -> verifyNameIsUnique(seenNames, typeDef.accept(TypeDefinitionVisitor.TYPE_NAME))); definition.getErrors().forEach(errorDef -> verifyNameIsUnique(seenNames, errorDef.getErrorName())); definition.getServices().forEach(serviceDef -> verifyNameIsUnique(seenNames, serviceDef.getServiceName())); }
@Test public void testNoRecursiveCycleType() { ConjureDefinition conjureDef = ConjureDefinition.builder() .version(1) .types(ImmutableList.of( TypeDefinition.object( ObjectDefinition.builder() .typeName(FOO) .fields(field(FieldName.of("bar"), "Bar")) .build()), TypeDefinition.object( ObjectDefinition.builder() .typeName(BAR) .fields(field(FieldName.of("foo"), "Foo")) .build()))) .build(); assertThatThrownBy(() -> ConjureDefinitionValidator.NO_RECURSIVE_TYPES.validate(conjureDef)) .isInstanceOf(IllegalStateException.class) .hasMessageStartingWith("Illegal recursive data type: "); }
@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); }