Merge pull request #470 from Netflix/add-tests

Add tests to verify only required types are generated with include qu…
Netflix · Oct 11, 2022 · 5d66e5d · 5d66e5d
2 parents 2e33ed1 + 5e44693
commit 5d66e5d
Show file tree

Hide file tree

Showing 2 changed files with 154 additions and 7 deletions.
diff --git a/graphql-dgs-codegen-core/src/main/kotlin/com/netflix/graphql/dgs/codegen/CodeGen.kt b/graphql-dgs-codegen-core/src/main/kotlin/com/netflix/graphql/dgs/codegen/CodeGen.kt
@@ -196,24 +196,19 @@ class CodeGen(private val config: CodeGenConfig) {
     }
 
     private fun generateJavaUnions(definitions: Collection<Definition<*>>): CodeGenResult {
-        if (!config.generateDataTypes) {
-            return CodeGenResult()
-        }
         return definitions.asSequence()
             .filterIsInstance<UnionTypeDefinition>()
             .excludeSchemaTypeExtension()
+            .filter { config.generateDataTypes || config.generateInterfaces || it.name in requiredTypeCollector.requiredTypes }
             .map { UnionTypeGenerator(config).generate(it, findUnionExtensions(it.name, definitions)) }
             .fold(CodeGenResult()) { t: CodeGenResult, u: CodeGenResult -> t.merge(u) }
     }
 
     private fun generateJavaInterfaces(definitions: Collection<Definition<*>>): CodeGenResult {
-        if (!config.generateDataTypes && !config.generateInterfaces) {
-            return CodeGenResult()
-        }
-
         return definitions.asSequence()
             .filterIsInstance<InterfaceTypeDefinition>()
             .excludeSchemaTypeExtension()
+            .filter { config.generateDataTypes || config.generateInterfaces || it.name in requiredTypeCollector.requiredTypes }
             .map {
                 val extensions = findInterfaceExtensions(it.name, definitions)
                 InterfaceGenerator(config, document).generate(it, extensions)

diff --git a/graphql-dgs-codegen-core/src/test/kotlin/com/netflix/graphql/dgs/codegen/CodeGenTest.kt b/graphql-dgs-codegen-core/src/test/kotlin/com/netflix/graphql/dgs/codegen/CodeGenTest.kt
@@ -1786,6 +1786,157 @@ class CodeGenTest {
         assertCompilesJava(result.javaDataTypes + result.javaInterfaces)
     }
 
+    @Test
+    fun generateOnlyRequiredDataTypesForQuery() {
+        val schema = """
+            type Query {
+                shows(showFilter: ShowFilter): [Video]
+                people(personFilter: PersonFilter): [Person]
+            }
+            
+            union Video = Show | Movie
+            
+            type Movie {
+                title: String
+                duration: Int
+                related: Related
+            }
+            
+            type Related {
+                 video: Video
+            }
+            
+            type Show {
+                title: String
+                tags(from: Int, to: Int, sourceType: SourceType): [ShowTag]
+                isLive(countryFilter: CountryFilter): Boolean
+            }
+            
+            enum ShouldNotInclude { YES, NO }
+            
+            input NotUsed {
+                field: String
+            }
+            
+            input ShowFilter {
+                title: String
+                showType: ShowType
+                similarTo: SimilarityInput
+            }
+            
+            input SimilarityInput {
+                tags: [String]
+            }
+            
+            enum ShowType {
+                MOVIE, SERIES
+            }
+            
+            input CountryFilter {
+                countriesToExclude: [String]
+            }
+                 
+            enum SourceType { FOO, BAR }
+           
+            type Person {
+                name: String
+            }
+        """.trimIndent()
+
+        val codeGenResult = CodeGen(
+            CodeGenConfig(
+                schemas = setOf(schema),
+                packageName = basePackageName,
+                includeQueries = setOf("shows"),
+                generateDataTypes = false,
+                writeToFiles = false
+            )
+        ).generate()
+
+        assertThat(codeGenResult.javaDataTypes)
+            .extracting("typeSpec").extracting("name").containsExactly("ShowFilter", "SimilarityInput", "CountryFilter")
+        assertThat(codeGenResult.javaEnumTypes)
+            .extracting("typeSpec").extracting("name").containsExactly("ShowType", "SourceType")
+        assertThat(codeGenResult.clientProjections).isEmpty()
+
+        assertCompilesJava(codeGenResult.javaDataTypes + codeGenResult.javaEnumTypes)
+    }
+
+    @Test
+    fun generateAllDataTypesForAllQueriesWhenSetToTrue() {
+        val schema = """
+            type Query {
+                shows(showFilter: ShowFilter): [Video]
+                people(personFilter: PersonFilter): [Person]
+            }
+            
+            union Video = Show | Movie
+            
+            type Movie {
+                title: String
+                duration: Int
+                related: Related
+            }
+            
+            type Related {
+                 video: Video
+            }
+            
+            type Show {
+                title: String
+                isLive(countryFilter: CountryFilter): Boolean
+            }
+            
+            enum ShouldNotInclude { YES, NO }
+            
+            input NotUsed {
+                field: String
+            }
+            
+            input ShowFilter {
+                title: String
+                showType: ShowType
+                similarTo: SimilarityInput
+            }
+            
+            input SimilarityInput {
+                tags: [String]
+            }
+            
+            enum ShowType {
+                MOVIE, SERIES
+            }
+            
+            input CountryFilter {
+                countriesToExclude: [String]
+            }
+                 
+            enum SourceType { FOO, BAR }
+           
+            type Person {
+                name: String
+            }
+        """.trimIndent()
+
+        val codeGenResult = CodeGen(
+            CodeGenConfig(
+                schemas = setOf(schema),
+                packageName = basePackageName,
+                includeQueries = setOf("shows"),
+                generateDataTypes = true,
+                writeToFiles = false
+            )
+        ).generate()
+
+        assertThat(codeGenResult.javaDataTypes)
+            .extracting("typeSpec").extracting("name").containsExactly("Movie", "Related", "Show", "Person", "NotUsed", "ShowFilter", "SimilarityInput", "CountryFilter")
+        assertThat(codeGenResult.javaEnumTypes)
+            .extracting("typeSpec").extracting("name").containsExactly("ShouldNotInclude", "ShowType", "SourceType")
+        assertThat(codeGenResult.clientProjections).isEmpty()
+
+        assertCompilesJava(codeGenResult.javaDataTypes + codeGenResult.javaEnumTypes + codeGenResult.javaInterfaces)
+    }
+
     @Test
     fun skipCodegenOnTypes() {
         val schema = """
@@ -2690,6 +2841,7 @@ class CodeGenTest {
         assertThat(searchResultPage.typeSpec.superinterfaces).extracting("simpleName").containsExactly("ISearchResultPage")
         assertThat(searchResultPage.typeSpec.fieldSpecs).extracting("name").containsExactly("items")
         parameterizedTypeName = searchResultPage.typeSpec.fieldSpecs[0].type as ParameterizedTypeName
+        parameterizedTypeName = searchResultPage.typeSpec.fieldSpecs[0].type as ParameterizedTypeName
         assertThat(parameterizedTypeName.rawType).extracting("simpleName").isEqualTo("List")
         assertThat(parameterizedTypeName.typeArguments[0]).extracting("simpleName").isEqualTo("SearchResult")