[Fusion] Abstract type & global object identification tests (ChilliCream#8284)

Author: tobias-tengler

src/HotChocolate/Fusion-vnext/src/Fusion.Composition/HotChocolate.Fusion.Composition.csproj

@@ -7,6 +7,7 @@
 
   <ItemGroup>
     <InternalsVisibleTo Include="HotChocolate.Fusion.Composition.Tests" />
+    <InternalsVisibleTo Include="HotChocolate.Fusion.Execution.Tests" />
   </ItemGroup>
 
   <ItemGroup>

src/HotChocolate/Fusion-vnext/test/Fusion.Execution.Tests/FusionTestBase.cs

@@ -1,15 +1,22 @@
+using System.Collections.Frozen;
 using System.Diagnostics.CodeAnalysis;
 using HotChocolate.Execution.Configuration;
+using HotChocolate.Fusion.Definitions;
+using HotChocolate.Fusion.Execution;
 using HotChocolate.Fusion.Execution.Nodes;
 using HotChocolate.Fusion.Logging;
 using HotChocolate.Fusion.Planning;
 using HotChocolate.Fusion.Rewriters;
 using HotChocolate.Fusion.Types;
 using HotChocolate.Language;
+using HotChocolate.Types;
+using HotChocolate.Types.Mutable;
+using HotChocolate.Types.Mutable.Serialization;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.TestHost;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.ObjectPool;
+using Directive = HotChocolate.Types.Mutable.Directive;
 
 namespace HotChocolate.Fusion;
 
@@ -133,4 +140,85 @@ protected virtual void Dispose(bool disposing)
             _testServerSession.Dispose();
         }
     }
+
+    protected record TestSubgraph([StringSyntax("graphql")] string Schema);
+
+    protected class TestSubgraphCollection(params TestSubgraph[] subgraphs)
+    {
+        public FusionSchemaDefinition BuildFusionSchema()
+        {
+            var schemas = subgraphs.Select(s => s.Schema).ToArray();
+            var rewrittenSchemas = new string[schemas.Length];
+
+            for (var i = 0; i < schemas.Length; i++)
+            {
+                var sourceSchema = SchemaParser.Parse(schemas[i]);
+
+                AddFusionDirectives(sourceSchema);
+
+                if (sourceSchema.Name == "default")
+                {
+                    sourceSchema.Name = $"Subgraph_{i + 1}";
+
+                    if (sourceSchema.DirectiveDefinitions.TryGetDirective(WellKnownDirectiveNames.SchemaName,
+                        out var schemaNameDirectiveDefinition))
+                    {
+                        sourceSchema.Directives.Add(new Directive(schemaNameDirectiveDefinition,
+                            new ArgumentAssignment(WellKnownArgumentNames.Value, sourceSchema.Name)));
+                    }
+                }
+
+                rewrittenSchemas[i] = sourceSchema.ToString();
+            }
+
+            return ComposeSchema(rewrittenSchemas);
+        }
+
+        private static void AddFusionDirectives(MutableSchemaDefinition schema)
+        {
+            var fieldSelectionMapType = MutableScalarTypeDefinition.Create(WellKnownTypeNames.FieldSelectionMap);
+            var fieldSelectionSetType = MutableScalarTypeDefinition.Create(WellKnownTypeNames.FieldSelectionSet);
+            var stringType = BuiltIns.String.Create();
+
+            var fusionDirectives = new Dictionary<string, MutableDirectiveDefinition>()
+            {
+                { "external", new ExternalMutableDirectiveDefinition() },
+                { "inaccessible", new InaccessibleMutableDirectiveDefinition() },
+                { "internal", new InternalMutableDirectiveDefinition() },
+                { "is", new IsMutableDirectiveDefinition(fieldSelectionMapType) },
+                { "key", new KeyMutableDirectiveDefinition(fieldSelectionSetType) },
+                { "lookup", new LookupMutableDirectiveDefinition() },
+                { "override", new OverrideMutableDirectiveDefinition(stringType) },
+                { "provides", new ProvidesMutableDirectiveDefinition(fieldSelectionSetType) },
+                { "require", new RequireMutableDirectiveDefinition(fieldSelectionMapType) },
+                { "schemaName", new SchemaNameMutableDirectiveDefinition(stringType) },
+                { "shareable", new ShareableMutableDirectiveDefinition() }
+            };
+
+            if (schema.Types.TryGetType(fieldSelectionMapType.Name, out var existingFieldSelectionMapType))
+            {
+                schema.Types.Remove(existingFieldSelectionMapType);
+            }
+
+            schema.Types.Add(fieldSelectionMapType);
+
+            if (schema.Types.TryGetType(fieldSelectionSetType.Name, out var existingFieldSelectionSetType))
+            {
+                schema.Types.Remove(existingFieldSelectionSetType);
+            }
+
+            schema.Types.Add(fieldSelectionSetType);
+
+            foreach (var fusionDirective in fusionDirectives.Values)
+            {
+                if (schema.DirectiveDefinitions.TryGetDirective(fusionDirective.Name,
+                    out var existingDirectiveDefinition))
+                {
+                    schema.DirectiveDefinitions.Remove(existingDirectiveDefinition);
+                }
+
+                schema.DirectiveDefinitions.Add(fusionDirective);
+            }
+        }
+    }
 }