Issue-8: Test using query with an aliased key

Author: Carlo Feliciano Aureus

src/main/java/com/intuit/graphql/orchestrator/batch/EntityFetcherBatchLoader.java

@@ -58,7 +58,8 @@ public CompletionStage<List<DataFetcherResult<Object>>> load(List<DataFetchingEn
         GraphQLContext graphQLContext = dfeTemplate.getContext();
 
         List<Map<String, Object>> representations = dataFetchingEnvironments.stream()
-            .map(DataFetchingEnvironment::getSource)
+            //.map(DataFetchingEnvironment::getSource)
+            .map(dataFetchingEnvironment -> getSource(dataFetchingEnvironment))
             .map(source -> createRepresentation((Map<String, Object>) source))
             .collect(Collectors.toList());
 
@@ -77,6 +78,12 @@ public CompletionStage<List<DataFetcherResult<Object>>> load(List<DataFetchingEn
         .thenApply(result -> batchResultTransformer.toBatchResult(result, dataFetchingEnvironments));
     }
 
+    private Map<String, Object> getSource(DataFetchingEnvironment dataFetchingEnvironment) {
+        // TODO
+        // return a POJO with source, and metadata about alias mapping.
+        return dataFetchingEnvironment.getSource();
+    }
+
     private List<String> generateRepresentationTemplate(FederationMetadata.EntityExtensionMetadata metadata, String fieldName) {
         List<String> representationFields = new ArrayList<>();
 

src/test/groovy/com/intuit/graphql/orchestrator/integration/federation/FederatedQueryWithKeyAliasedSimpleSpec.groovy

@@ -0,0 +1,137 @@
+package com.intuit.graphql.orchestrator.integration.federation
+
+import com.google.common.collect.ImmutableMap
+import com.intuit.graphql.orchestrator.GraphQLOrchestrator
+import com.intuit.graphql.orchestrator.ServiceProvider
+import com.intuit.graphql.orchestrator.testhelpers.MockServiceProvider
+import com.intuit.graphql.orchestrator.testhelpers.SimpleMockServiceProvider
+import com.intuit.graphql.orchestrator.utils.GraphQLUtil
+import com.intuit.graphql.orchestrator.utils.SelectionSetUtil
+import graphql.ExecutionInput
+import graphql.language.Document
+import graphql.language.Field
+import graphql.language.OperationDefinition
+import graphql.parser.Parser
+import helpers.BaseIntegrationTestSpecification
+
+class FederatedQueryWithKeyAliasedSimpleSpec extends BaseIntegrationTestSpecification {
+
+    Parser parser = GraphQLUtil.parser
+
+    GraphQLOrchestrator specUnderTest
+
+    private def bookSchema = '''
+        type Query {
+            bookById(id: ID): Book
+        }
+        
+        type Book {
+            id: ID
+            name: String
+            pageCount: Int
+            author: Author
+        }    
+        
+        type Author @key(fields: "id") {
+            id: String
+        }    
+    '''
+
+    private def authorSchema = '''
+        type Query {
+            authorByid(id: ID!): Author
+        }
+        
+        type Author @extends @key(fields: "id") {
+            id: String @external
+            firstName: String!
+            lastName: String!
+        }      
+    '''
+
+    def setup() {
+    }
+
+    def "test Query"() {
+        given:
+        //def BOOK_QUERY = "query QUERY {bookById(id:\"12345\") {id name pageCount author {authorId:id}}}"
+        def bookResponse = [
+                data: [
+                        bookById: [
+                                id       : "book-1",
+                                name     : "GraphQuilt: The future of Schema Stitching",
+                                pageCount: 100,
+                                author   : [
+                                        "author": "12345"
+                                ]
+                        ]
+
+                ]
+        ]
+
+        SimpleMockServiceProvider bookService = createSimpleMockService("bookService",
+                ServiceProvider.ServiceType.FEDERATION_SUBGRAPH, bookSchema, bookResponse)
+
+
+        def authorResponse = [
+                data: [
+                        _entities: [
+                                [
+                                        __typename: "Author",
+                                        id        : "12345",
+                                        firstName : "Charles",
+                                        lastName  : "Wayne"
+                                ]
+                        ]
+                ]
+        ]
+        SimpleMockServiceProvider authorService = createSimpleMockService("authorService",
+                ServiceProvider.ServiceType.FEDERATION_SUBGRAPH, authorSchema, authorResponse)
+
+
+        ServiceProvider[] services = [bookService, authorService]
+        specUnderTest = createGraphQLOrchestrator(services)
+
+        when:
+        ExecutionInput booksAndPetsEI = ExecutionInput.newExecutionInput().query('''
+            query  {
+                bookById(id: "12345") {
+                    id 
+                    name
+                    pageCount
+                    author {
+                        authorId: id
+                        authorName: firstName
+                    }
+                }
+            }
+        ''')
+                .variables(ImmutableMap.of("includeType", Boolean.TRUE))
+                .build()
+
+        Map<String, Object> executionResult = specUnderTest.execute(booksAndPetsEI).get().toSpecification()
+
+        then:
+
+        def AUTHOR_QUERY = "query (\$REPRESENTATIONS:[_Any!]!) {_entities(representations:\$REPRESENTATIONS) {... on Author {firstName}}}"
+
+        executionResult.get("errors") == null
+        executionResult.get("data") != null
+
+        executionResult?.data?.bookById?.id == "book-1"
+        executionResult?.data?.bookById?.name == "GraphQuilt: The future of Schema Stitching"
+        executionResult?.data?.bookById?.pageCount == 100
+        executionResult?.data?.bookById?.author.authorId == "12345"
+        executionResult?.data?.bookById?.author.authorName == "Charles"
+
+        Map<String, Object> dataValue = (Map<String, Object>) executionResult.get("data")
+        dataValue.keySet().containsAll("bookById")
+        ((Map<String, Objects>) dataValue.get("bookById")).keySet().size() == 4
+        ExecutionInput authorServiceExecutionInput = getCapturedDownstreamExecutionInput(authorService)
+        authorServiceExecutionInput.getQuery() == AUTHOR_QUERY
+        Map<String, Object> authorsServiceVariables = authorServiceExecutionInput.getVariables()
+        authorsServiceVariables?.REPRESENTATIONS[0]?.__typename == "Author"
+        authorsServiceVariables?.REPRESENTATIONS[0]?.id == "12345"
+    }
+
+}

src/test/groovy/helpers/BaseIntegrationTestSpecification.groovy

@@ -36,6 +36,16 @@ class BaseIntegrationTestSpecification extends Specification {
                 .build()
     }
 
+    def createSimpleMockService(String namespace, ServiceProvider.ServiceType serviceType,
+                                String testSchema, Map<String, Object> mockServiceResponse) {
+        return SimpleMockServiceProvider.builder()
+                .sdlFiles(["schema.graphqls": testSchema])
+                .namespace(namespace)
+                .serviceType(serviceType)
+                .mockResponse(mockServiceResponse)
+                .build()
+    }
+
     def createQueryMatchingService(String namespace, ServiceProvider.ServiceType serviceType,
                                    String testSchema, Map<String, Object> mockServiceResponse) {
         return MockServiceProvider.builder()