From 5d30ab9d635f913bda232f1161e6b688f3c4d78d Mon Sep 17 00:00:00 2001 From: Matias Anaya Date: Fri, 8 Nov 2019 16:10:15 +1100 Subject: [PATCH] Add namespace to test cases for embedded in testserver --- codegen/testserver/embedded.go | 12 +- codegen/testserver/embedded.graphql | 12 +- codegen/testserver/embedded_test.go | 38 ++-- codegen/testserver/generated.go | 316 ++++++++++++++-------------- codegen/testserver/resolver.go | 4 +- codegen/testserver/stub.go | 12 +- 6 files changed, 197 insertions(+), 197 deletions(-) diff --git a/codegen/testserver/embedded.go b/codegen/testserver/embedded.go index 82324ff52b9..79d250b207c 100644 --- a/codegen/testserver/embedded.go +++ b/codegen/testserver/embedded.go @@ -1,7 +1,7 @@ package testserver -// Case1 model -type Case1 struct { +// EmbeddedCase1 model +type EmbeddedCase1 struct { Empty *ExportedEmbeddedPointerAfterInterface } @@ -17,8 +17,8 @@ func (*ExportedEmbeddedPointerAfterInterface) ExportedEmbeddedPointerExportedMet return "ExportedEmbeddedPointerExportedMethodResponse" } -// Case2 model -type Case2 struct { +// EmbeddedCase2 model +type EmbeddedCase2 struct { *unexportedEmbeddedPointer } @@ -29,7 +29,7 @@ func (*unexportedEmbeddedPointer) UnexportedEmbeddedPointerExportedMethod() stri return "UnexportedEmbeddedPointerExportedMethodResponse" } -// Case3 model -type Case3 interface { +// EmbeddedCase3 model +type EmbeddedCase3 interface { ExplicitInterfaceMethod() string } diff --git a/codegen/testserver/embedded.graphql b/codegen/testserver/embedded.graphql index 7ad1ad98f9c..13dda4744f5 100644 --- a/codegen/testserver/embedded.graphql +++ b/codegen/testserver/embedded.graphql @@ -1,17 +1,17 @@ extend type Query { - case1: Case1 - case2: Case2 - # case3: Case3 + embeddedCase1: EmbeddedCase1 + embeddedCase2: EmbeddedCase2 + # embeddedCase3: EmbeddedCase3 } -type Case1 @goModel(model:"testserver.Case1") { +type EmbeddedCase1 @goModel(model:"testserver.EmbeddedCase1") { exportedEmbeddedPointerExportedMethod: String! } -type Case2 @goModel(model:"testserver.Case2") { +type EmbeddedCase2 @goModel(model:"testserver.EmbeddedCase2") { unexportedEmbeddedPointerExportedMethod: String! } -# type Case3 @goModel(model:"testserver.Case3") { +# type EmbeddedCase3 @goModel(model:"testserver.EmbeddedCase3") { # explicitInterfaceMethod: String! # } diff --git a/codegen/testserver/embedded_test.go b/codegen/testserver/embedded_test.go index 8384b069d44..f080d9a46c8 100644 --- a/codegen/testserver/embedded_test.go +++ b/codegen/testserver/embedded_test.go @@ -9,22 +9,22 @@ import ( "github.com/stretchr/testify/require" ) -// type fakeCase3 struct{} +type fakeEmbeddedCase3 struct{} -// func (fakeCase3) ExplicitInterfaceMethod() string { -// return "ExplicitInterfaceMethodResponse" -// } +func (fakeEmbeddedCase3) ExplicitInterfaceMethod() string { + return "ExplicitInterfaceMethodResponse" +} func TestEmbedded(t *testing.T) { resolver := &Stub{} - resolver.QueryResolver.Case1 = func(ctx context.Context) (*Case1, error) { - return &Case1{}, nil + resolver.QueryResolver.EmbeddedCase1 = func(ctx context.Context) (*EmbeddedCase1, error) { + return &EmbeddedCase1{}, nil } - resolver.QueryResolver.Case2 = func(ctx context.Context) (*Case2, error) { - return &Case2{&unexportedEmbeddedPointer{}}, nil + resolver.QueryResolver.EmbeddedCase2 = func(ctx context.Context) (*EmbeddedCase2, error) { + return &EmbeddedCase2{&unexportedEmbeddedPointer{}}, nil } - // resolver.QueryResolver.Case3 = func(ctx context.Context) (Case3, error) { - // return &fakeCase3{}, nil + // resolver.QueryResolver.EmbeddedCase3 = func(ctx context.Context) (EmbeddedCase3, error) { + // return &fakeEmbeddedCase3{}, nil // } c := client.New(handler.GraphQL( @@ -33,34 +33,34 @@ func TestEmbedded(t *testing.T) { t.Run("embedded case 1", func(t *testing.T) { var resp struct { - Case1 struct { + EmbeddedCase1 struct { ExportedEmbeddedPointerExportedMethod string } } - err := c.Post(`query { case1 { exportedEmbeddedPointerExportedMethod } }`, &resp) + err := c.Post(`query { embeddedCase1 { exportedEmbeddedPointerExportedMethod } }`, &resp) require.NoError(t, err) - require.Equal(t, resp.Case1.ExportedEmbeddedPointerExportedMethod, "ExportedEmbeddedPointerExportedMethodResponse") + require.Equal(t, resp.EmbeddedCase1.ExportedEmbeddedPointerExportedMethod, "ExportedEmbeddedPointerExportedMethodResponse") }) t.Run("embedded case 2", func(t *testing.T) { var resp struct { - Case2 struct { + EmbeddedCase2 struct { UnexportedEmbeddedPointerExportedMethod string } } - err := c.Post(`query { case2 { unexportedEmbeddedPointerExportedMethod } }`, &resp) + err := c.Post(`query { embeddedCase2 { unexportedEmbeddedPointerExportedMethod } }`, &resp) require.NoError(t, err) - require.Equal(t, resp.Case2.UnexportedEmbeddedPointerExportedMethod, "UnexportedEmbeddedPointerExportedMethodResponse") + require.Equal(t, resp.EmbeddedCase2.UnexportedEmbeddedPointerExportedMethod, "UnexportedEmbeddedPointerExportedMethodResponse") }) // t.Run("embedded case 3", func(t *testing.T) { // var resp struct { - // Case3 struct { + // EmbeddedCase3 struct { // ExplicitInterfaceMethod bool // } // } - // err := c.Post(`query { case3 { explicitInterfaceMethod } }`, &resp) + // err := c.Post(`query { Embeddedcase3 { explicitInterfaceMethod } }`, &resp) // require.NoError(t, err) - // require.Equal(t, resp.Case3.ExplicitInterfaceMethod, "ExplicitInterfaceMethodResponse") + // require.Equal(t, resp.EmbeddedCase3.ExplicitInterfaceMethod, "ExplicitInterfaceMethodResponse") // }) } diff --git a/codegen/testserver/generated.go b/codegen/testserver/generated.go index 069155f7b5f..81845d19eb4 100644 --- a/codegen/testserver/generated.go +++ b/codegen/testserver/generated.go @@ -96,14 +96,6 @@ type ComplexityRoot struct { ID func(childComplexity int) int } - Case1 struct { - ExportedEmbeddedPointerExportedMethod func(childComplexity int) int - } - - Case2 struct { - UnexportedEmbeddedPointerExportedMethod func(childComplexity int) int - } - Circle struct { Area func(childComplexity int) int Radius func(childComplexity int) int @@ -117,6 +109,14 @@ type ComplexityRoot struct { Foo func(childComplexity int) int } + EmbeddedCase1 struct { + ExportedEmbeddedPointerExportedMethod func(childComplexity int) int + } + + EmbeddedCase2 struct { + UnexportedEmbeddedPointerExportedMethod func(childComplexity int) int + } + EmbeddedDefaultScalar struct { Value func(childComplexity int) int } @@ -218,8 +218,6 @@ type ComplexityRoot struct { Query struct { Autobind func(childComplexity int) int - Case1 func(childComplexity int) int - Case2 func(childComplexity int) int Collision func(childComplexity int) int DefaultScalar func(childComplexity int, arg string) int DeprecatedField func(childComplexity int) int @@ -234,6 +232,8 @@ type ComplexityRoot struct { DirectiveObject func(childComplexity int) int DirectiveObjectWithCustomGoModel func(childComplexity int) int DirectiveUnimplemented func(childComplexity int) int + EmbeddedCase1 func(childComplexity int) int + EmbeddedCase2 func(childComplexity int) int ErrorBubble func(childComplexity int) int Errors func(childComplexity int) int Fallback func(childComplexity int, arg FallbackToStringEncoding) int @@ -376,8 +376,8 @@ type QueryResolver interface { DirectiveField(ctx context.Context) (*string, error) DirectiveDouble(ctx context.Context) (*string, error) DirectiveUnimplemented(ctx context.Context) (*string, error) - Case1(ctx context.Context) (*Case1, error) - Case2(ctx context.Context) (*Case2, error) + EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error) + EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error) Shapes(ctx context.Context) ([]Shape, error) NoShape(ctx context.Context) (Shape, error) MapStringInterface(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error) @@ -487,20 +487,6 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.B.ID(childComplexity), true - case "Case1.exportedEmbeddedPointerExportedMethod": - if e.complexity.Case1.ExportedEmbeddedPointerExportedMethod == nil { - break - } - - return e.complexity.Case1.ExportedEmbeddedPointerExportedMethod(childComplexity), true - - case "Case2.unexportedEmbeddedPointerExportedMethod": - if e.complexity.Case2.UnexportedEmbeddedPointerExportedMethod == nil { - break - } - - return e.complexity.Case2.UnexportedEmbeddedPointerExportedMethod(childComplexity), true - case "Circle.area": if e.complexity.Circle.Area == nil { break @@ -529,6 +515,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.ContentUser.Foo(childComplexity), true + case "EmbeddedCase1.exportedEmbeddedPointerExportedMethod": + if e.complexity.EmbeddedCase1.ExportedEmbeddedPointerExportedMethod == nil { + break + } + + return e.complexity.EmbeddedCase1.ExportedEmbeddedPointerExportedMethod(childComplexity), true + + case "EmbeddedCase2.unexportedEmbeddedPointerExportedMethod": + if e.complexity.EmbeddedCase2.UnexportedEmbeddedPointerExportedMethod == nil { + break + } + + return e.complexity.EmbeddedCase2.UnexportedEmbeddedPointerExportedMethod(childComplexity), true + case "EmbeddedDefaultScalar.value": if e.complexity.EmbeddedDefaultScalar.Value == nil { break @@ -819,20 +819,6 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Query.Autobind(childComplexity), true - case "Query.case1": - if e.complexity.Query.Case1 == nil { - break - } - - return e.complexity.Query.Case1(childComplexity), true - - case "Query.case2": - if e.complexity.Query.Case2 == nil { - break - } - - return e.complexity.Query.Case2(childComplexity), true - case "Query.collision": if e.complexity.Query.Collision == nil { break @@ -966,6 +952,20 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Query.DirectiveUnimplemented(childComplexity), true + case "Query.embeddedCase1": + if e.complexity.Query.EmbeddedCase1 == nil { + break + } + + return e.complexity.Query.EmbeddedCase1(childComplexity), true + + case "Query.embeddedCase2": + if e.complexity.Query.EmbeddedCase2 == nil { + break + } + + return e.complexity.Query.EmbeddedCase2(childComplexity), true + case "Query.errorBubble": if e.complexity.Query.ErrorBubble == nil { break @@ -1560,20 +1560,20 @@ type ObjectDirectivesWithCustomGoModel { } `}, &ast.Source{Name: "embedded.graphql", Input: `extend type Query { - case1: Case1 - case2: Case2 - # case3: Case3 + embeddedCase1: EmbeddedCase1 + embeddedCase2: EmbeddedCase2 + # embeddedCase3: EmbeddedCase3 } -type Case1 @goModel(model:"testserver.Case1") { +type EmbeddedCase1 @goModel(model:"testserver.EmbeddedCase1") { exportedEmbeddedPointerExportedMethod: String! } -type Case2 @goModel(model:"testserver.Case2") { +type EmbeddedCase2 @goModel(model:"testserver.EmbeddedCase2") { unexportedEmbeddedPointerExportedMethod: String! } -# type Case3 @goModel(model:"testserver.Case3") { +# type EmbeddedCase3 @goModel(model:"testserver.EmbeddedCase3") { # explicitInterfaceMethod: String! # } `}, @@ -3088,7 +3088,7 @@ func (ec *executionContext) _B_id(ctx context.Context, field graphql.CollectedFi return ec.marshalNID2string(ctx, field.Selections, res) } -func (ec *executionContext) _Case1_exportedEmbeddedPointerExportedMethod(ctx context.Context, field graphql.CollectedField, obj *Case1) (ret graphql.Marshaler) { +func (ec *executionContext) _Circle_radius(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) { ctx = ec.Tracer.StartFieldExecution(ctx, field) defer func() { if r := recover(); r != nil { @@ -3098,31 +3098,28 @@ func (ec *executionContext) _Case1_exportedEmbeddedPointerExportedMethod(ctx con ec.Tracer.EndFieldExecution(ctx) }() rctx := &graphql.ResolverContext{ - Object: "Case1", + Object: "Circle", Field: field, Args: nil, - IsMethod: true, + IsMethod: false, } ctx = graphql.WithResolverContext(ctx, rctx) ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.ExportedEmbeddedPointerExportedMethod(), nil + return obj.Radius, nil }) if resTmp == nil { - if !ec.HasError(rctx) { - ec.Errorf(ctx, "must not be null") - } return graphql.Null } - res := resTmp.(string) + res := resTmp.(float64) rctx.Result = res ctx = ec.Tracer.StartFieldChildExecution(ctx) - return ec.marshalNString2string(ctx, field.Selections, res) + return ec.marshalOFloat2float64(ctx, field.Selections, res) } -func (ec *executionContext) _Case2_unexportedEmbeddedPointerExportedMethod(ctx context.Context, field graphql.CollectedField, obj *Case2) (ret graphql.Marshaler) { +func (ec *executionContext) _Circle_area(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) { ctx = ec.Tracer.StartFieldExecution(ctx, field) defer func() { if r := recover(); r != nil { @@ -3132,7 +3129,7 @@ func (ec *executionContext) _Case2_unexportedEmbeddedPointerExportedMethod(ctx c ec.Tracer.EndFieldExecution(ctx) }() rctx := &graphql.ResolverContext{ - Object: "Case2", + Object: "Circle", Field: field, Args: nil, IsMethod: true, @@ -3141,22 +3138,19 @@ func (ec *executionContext) _Case2_unexportedEmbeddedPointerExportedMethod(ctx c ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.UnexportedEmbeddedPointerExportedMethod(), nil + return obj.Area(), nil }) if resTmp == nil { - if !ec.HasError(rctx) { - ec.Errorf(ctx, "must not be null") - } return graphql.Null } - res := resTmp.(string) + res := resTmp.(float64) rctx.Result = res ctx = ec.Tracer.StartFieldChildExecution(ctx) - return ec.marshalNString2string(ctx, field.Selections, res) + return ec.marshalOFloat2float64(ctx, field.Selections, res) } -func (ec *executionContext) _Circle_radius(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) { +func (ec *executionContext) _Content_Post_foo(ctx context.Context, field graphql.CollectedField, obj *ContentPost) (ret graphql.Marshaler) { ctx = ec.Tracer.StartFieldExecution(ctx, field) defer func() { if r := recover(); r != nil { @@ -3166,7 +3160,7 @@ func (ec *executionContext) _Circle_radius(ctx context.Context, field graphql.Co ec.Tracer.EndFieldExecution(ctx) }() rctx := &graphql.ResolverContext{ - Object: "Circle", + Object: "Content_Post", Field: field, Args: nil, IsMethod: false, @@ -3175,19 +3169,19 @@ func (ec *executionContext) _Circle_radius(ctx context.Context, field graphql.Co ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Radius, nil + return obj.Foo, nil }) if resTmp == nil { return graphql.Null } - res := resTmp.(float64) + res := resTmp.(*string) rctx.Result = res ctx = ec.Tracer.StartFieldChildExecution(ctx) - return ec.marshalOFloat2float64(ctx, field.Selections, res) + return ec.marshalOString2ᚖstring(ctx, field.Selections, res) } -func (ec *executionContext) _Circle_area(ctx context.Context, field graphql.CollectedField, obj *Circle) (ret graphql.Marshaler) { +func (ec *executionContext) _Content_User_foo(ctx context.Context, field graphql.CollectedField, obj *ContentUser) (ret graphql.Marshaler) { ctx = ec.Tracer.StartFieldExecution(ctx, field) defer func() { if r := recover(); r != nil { @@ -3197,28 +3191,28 @@ func (ec *executionContext) _Circle_area(ctx context.Context, field graphql.Coll ec.Tracer.EndFieldExecution(ctx) }() rctx := &graphql.ResolverContext{ - Object: "Circle", + Object: "Content_User", Field: field, Args: nil, - IsMethod: true, + IsMethod: false, } ctx = graphql.WithResolverContext(ctx, rctx) ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Area(), nil + return obj.Foo, nil }) if resTmp == nil { return graphql.Null } - res := resTmp.(float64) + res := resTmp.(*string) rctx.Result = res ctx = ec.Tracer.StartFieldChildExecution(ctx) - return ec.marshalOFloat2float64(ctx, field.Selections, res) + return ec.marshalOString2ᚖstring(ctx, field.Selections, res) } -func (ec *executionContext) _Content_Post_foo(ctx context.Context, field graphql.CollectedField, obj *ContentPost) (ret graphql.Marshaler) { +func (ec *executionContext) _EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx context.Context, field graphql.CollectedField, obj *EmbeddedCase1) (ret graphql.Marshaler) { ctx = ec.Tracer.StartFieldExecution(ctx, field) defer func() { if r := recover(); r != nil { @@ -3228,28 +3222,31 @@ func (ec *executionContext) _Content_Post_foo(ctx context.Context, field graphql ec.Tracer.EndFieldExecution(ctx) }() rctx := &graphql.ResolverContext{ - Object: "Content_Post", + Object: "EmbeddedCase1", Field: field, Args: nil, - IsMethod: false, + IsMethod: true, } ctx = graphql.WithResolverContext(ctx, rctx) ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Foo, nil + return obj.ExportedEmbeddedPointerExportedMethod(), nil }) if resTmp == nil { + if !ec.HasError(rctx) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.(*string) + res := resTmp.(string) rctx.Result = res ctx = ec.Tracer.StartFieldChildExecution(ctx) - return ec.marshalOString2ᚖstring(ctx, field.Selections, res) + return ec.marshalNString2string(ctx, field.Selections, res) } -func (ec *executionContext) _Content_User_foo(ctx context.Context, field graphql.CollectedField, obj *ContentUser) (ret graphql.Marshaler) { +func (ec *executionContext) _EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx context.Context, field graphql.CollectedField, obj *EmbeddedCase2) (ret graphql.Marshaler) { ctx = ec.Tracer.StartFieldExecution(ctx, field) defer func() { if r := recover(); r != nil { @@ -3259,25 +3256,28 @@ func (ec *executionContext) _Content_User_foo(ctx context.Context, field graphql ec.Tracer.EndFieldExecution(ctx) }() rctx := &graphql.ResolverContext{ - Object: "Content_User", + Object: "EmbeddedCase2", Field: field, Args: nil, - IsMethod: false, + IsMethod: true, } ctx = graphql.WithResolverContext(ctx, rctx) ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) resTmp := ec._fieldMiddleware(ctx, obj, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Foo, nil + return obj.UnexportedEmbeddedPointerExportedMethod(), nil }) if resTmp == nil { + if !ec.HasError(rctx) { + ec.Errorf(ctx, "must not be null") + } return graphql.Null } - res := resTmp.(*string) + res := resTmp.(string) rctx.Result = res ctx = ec.Tracer.StartFieldChildExecution(ctx) - return ec.marshalOString2ᚖstring(ctx, field.Selections, res) + return ec.marshalNString2string(ctx, field.Selections, res) } func (ec *executionContext) _EmbeddedDefaultScalar_value(ctx context.Context, field graphql.CollectedField, obj *EmbeddedDefaultScalar) (ret graphql.Marshaler) { @@ -5699,7 +5699,7 @@ func (ec *executionContext) _Query_directiveUnimplemented(ctx context.Context, f return ec.marshalOString2ᚖstring(ctx, field.Selections, res) } -func (ec *executionContext) _Query_case1(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_embeddedCase1(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { ctx = ec.Tracer.StartFieldExecution(ctx, field) defer func() { if r := recover(); r != nil { @@ -5718,19 +5718,19 @@ func (ec *executionContext) _Query_case1(ctx context.Context, field graphql.Coll ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return ec.resolvers.Query().Case1(rctx) + return ec.resolvers.Query().EmbeddedCase1(rctx) }) if resTmp == nil { return graphql.Null } - res := resTmp.(*Case1) + res := resTmp.(*EmbeddedCase1) rctx.Result = res ctx = ec.Tracer.StartFieldChildExecution(ctx) - return ec.marshalOCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐCase1(ctx, field.Selections, res) + return ec.marshalOEmbeddedCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐEmbeddedCase1(ctx, field.Selections, res) } -func (ec *executionContext) _Query_case2(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { +func (ec *executionContext) _Query_embeddedCase2(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { ctx = ec.Tracer.StartFieldExecution(ctx, field) defer func() { if r := recover(); r != nil { @@ -5749,16 +5749,16 @@ func (ec *executionContext) _Query_case2(ctx context.Context, field graphql.Coll ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx) resTmp := ec._fieldMiddleware(ctx, nil, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return ec.resolvers.Query().Case2(rctx) + return ec.resolvers.Query().EmbeddedCase2(rctx) }) if resTmp == nil { return graphql.Null } - res := resTmp.(*Case2) + res := resTmp.(*EmbeddedCase2) rctx.Result = res ctx = ec.Tracer.StartFieldChildExecution(ctx) - return ec.marshalOCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐCase2(ctx, field.Selections, res) + return ec.marshalOEmbeddedCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐEmbeddedCase2(ctx, field.Selections, res) } func (ec *executionContext) _Query_shapes(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { @@ -9106,22 +9106,21 @@ func (ec *executionContext) _B(ctx context.Context, sel ast.SelectionSet, obj *B return out } -var case1Implementors = []string{"Case1"} +var circleImplementors = []string{"Circle", "Shape", "ShapeUnion"} -func (ec *executionContext) _Case1(ctx context.Context, sel ast.SelectionSet, obj *Case1) graphql.Marshaler { - fields := graphql.CollectFields(ec.RequestContext, sel, case1Implementors) +func (ec *executionContext) _Circle(ctx context.Context, sel ast.SelectionSet, obj *Circle) graphql.Marshaler { + fields := graphql.CollectFields(ec.RequestContext, sel, circleImplementors) out := graphql.NewFieldSet(fields) var invalids uint32 for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Case1") - case "exportedEmbeddedPointerExportedMethod": - out.Values[i] = ec._Case1_exportedEmbeddedPointerExportedMethod(ctx, field, obj) - if out.Values[i] == graphql.Null { - invalids++ - } + out.Values[i] = graphql.MarshalString("Circle") + case "radius": + out.Values[i] = ec._Circle_radius(ctx, field, obj) + case "area": + out.Values[i] = ec._Circle_area(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -9133,22 +9132,19 @@ func (ec *executionContext) _Case1(ctx context.Context, sel ast.SelectionSet, ob return out } -var case2Implementors = []string{"Case2"} +var content_PostImplementors = []string{"Content_Post", "Content_Child"} -func (ec *executionContext) _Case2(ctx context.Context, sel ast.SelectionSet, obj *Case2) graphql.Marshaler { - fields := graphql.CollectFields(ec.RequestContext, sel, case2Implementors) +func (ec *executionContext) _Content_Post(ctx context.Context, sel ast.SelectionSet, obj *ContentPost) graphql.Marshaler { + fields := graphql.CollectFields(ec.RequestContext, sel, content_PostImplementors) out := graphql.NewFieldSet(fields) var invalids uint32 for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Case2") - case "unexportedEmbeddedPointerExportedMethod": - out.Values[i] = ec._Case2_unexportedEmbeddedPointerExportedMethod(ctx, field, obj) - if out.Values[i] == graphql.Null { - invalids++ - } + out.Values[i] = graphql.MarshalString("Content_Post") + case "foo": + out.Values[i] = ec._Content_Post_foo(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -9160,21 +9156,19 @@ func (ec *executionContext) _Case2(ctx context.Context, sel ast.SelectionSet, ob return out } -var circleImplementors = []string{"Circle", "Shape", "ShapeUnion"} +var content_UserImplementors = []string{"Content_User", "Content_Child"} -func (ec *executionContext) _Circle(ctx context.Context, sel ast.SelectionSet, obj *Circle) graphql.Marshaler { - fields := graphql.CollectFields(ec.RequestContext, sel, circleImplementors) +func (ec *executionContext) _Content_User(ctx context.Context, sel ast.SelectionSet, obj *ContentUser) graphql.Marshaler { + fields := graphql.CollectFields(ec.RequestContext, sel, content_UserImplementors) out := graphql.NewFieldSet(fields) var invalids uint32 for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Circle") - case "radius": - out.Values[i] = ec._Circle_radius(ctx, field, obj) - case "area": - out.Values[i] = ec._Circle_area(ctx, field, obj) + out.Values[i] = graphql.MarshalString("Content_User") + case "foo": + out.Values[i] = ec._Content_User_foo(ctx, field, obj) default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -9186,19 +9180,22 @@ func (ec *executionContext) _Circle(ctx context.Context, sel ast.SelectionSet, o return out } -var content_PostImplementors = []string{"Content_Post", "Content_Child"} +var embeddedCase1Implementors = []string{"EmbeddedCase1"} -func (ec *executionContext) _Content_Post(ctx context.Context, sel ast.SelectionSet, obj *ContentPost) graphql.Marshaler { - fields := graphql.CollectFields(ec.RequestContext, sel, content_PostImplementors) +func (ec *executionContext) _EmbeddedCase1(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedCase1) graphql.Marshaler { + fields := graphql.CollectFields(ec.RequestContext, sel, embeddedCase1Implementors) out := graphql.NewFieldSet(fields) var invalids uint32 for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Content_Post") - case "foo": - out.Values[i] = ec._Content_Post_foo(ctx, field, obj) + out.Values[i] = graphql.MarshalString("EmbeddedCase1") + case "exportedEmbeddedPointerExportedMethod": + out.Values[i] = ec._EmbeddedCase1_exportedEmbeddedPointerExportedMethod(ctx, field, obj) + if out.Values[i] == graphql.Null { + invalids++ + } default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -9210,19 +9207,22 @@ func (ec *executionContext) _Content_Post(ctx context.Context, sel ast.Selection return out } -var content_UserImplementors = []string{"Content_User", "Content_Child"} +var embeddedCase2Implementors = []string{"EmbeddedCase2"} -func (ec *executionContext) _Content_User(ctx context.Context, sel ast.SelectionSet, obj *ContentUser) graphql.Marshaler { - fields := graphql.CollectFields(ec.RequestContext, sel, content_UserImplementors) +func (ec *executionContext) _EmbeddedCase2(ctx context.Context, sel ast.SelectionSet, obj *EmbeddedCase2) graphql.Marshaler { + fields := graphql.CollectFields(ec.RequestContext, sel, embeddedCase2Implementors) out := graphql.NewFieldSet(fields) var invalids uint32 for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Content_User") - case "foo": - out.Values[i] = ec._Content_User_foo(ctx, field, obj) + out.Values[i] = graphql.MarshalString("EmbeddedCase2") + case "unexportedEmbeddedPointerExportedMethod": + out.Values[i] = ec._EmbeddedCase2_unexportedEmbeddedPointerExportedMethod(ctx, field, obj) + if out.Values[i] == graphql.Null { + invalids++ + } default: panic("unknown field " + strconv.Quote(field.Name)) } @@ -10292,7 +10292,7 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr res = ec._Query_directiveUnimplemented(ctx, field) return res }) - case "case1": + case "embeddedCase1": field := field out.Concurrently(i, func() (res graphql.Marshaler) { defer func() { @@ -10300,10 +10300,10 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Query_case1(ctx, field) + res = ec._Query_embeddedCase1(ctx, field) return res }) - case "case2": + case "embeddedCase2": field := field out.Concurrently(i, func() (res graphql.Marshaler) { defer func() { @@ -10311,7 +10311,7 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr ec.Error(ctx, ec.Recover(ctx, r)) } }() - res = ec._Query_case2(ctx, field) + res = ec._Query_embeddedCase2(ctx, field) return res }) case "shapes": @@ -11918,28 +11918,6 @@ func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast return ec.marshalOBoolean2bool(ctx, sel, *v) } -func (ec *executionContext) marshalOCase12githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐCase1(ctx context.Context, sel ast.SelectionSet, v Case1) graphql.Marshaler { - return ec._Case1(ctx, sel, &v) -} - -func (ec *executionContext) marshalOCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐCase1(ctx context.Context, sel ast.SelectionSet, v *Case1) graphql.Marshaler { - if v == nil { - return graphql.Null - } - return ec._Case1(ctx, sel, v) -} - -func (ec *executionContext) marshalOCase22githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐCase2(ctx context.Context, sel ast.SelectionSet, v Case2) graphql.Marshaler { - return ec._Case2(ctx, sel, &v) -} - -func (ec *executionContext) marshalOCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐCase2(ctx context.Context, sel ast.SelectionSet, v *Case2) graphql.Marshaler { - if v == nil { - return graphql.Null - } - return ec._Case2(ctx, sel, v) -} - func (ec *executionContext) unmarshalOChanges2map(ctx context.Context, v interface{}) (map[string]interface{}, error) { if v == nil { return nil, nil @@ -11981,6 +11959,28 @@ func (ec *executionContext) marshalODefaultScalarImplementation2ᚖstring(ctx co return ec.marshalODefaultScalarImplementation2string(ctx, sel, *v) } +func (ec *executionContext) marshalOEmbeddedCase12githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐEmbeddedCase1(ctx context.Context, sel ast.SelectionSet, v EmbeddedCase1) graphql.Marshaler { + return ec._EmbeddedCase1(ctx, sel, &v) +} + +func (ec *executionContext) marshalOEmbeddedCase12ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐEmbeddedCase1(ctx context.Context, sel ast.SelectionSet, v *EmbeddedCase1) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._EmbeddedCase1(ctx, sel, v) +} + +func (ec *executionContext) marshalOEmbeddedCase22githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐEmbeddedCase2(ctx context.Context, sel ast.SelectionSet, v EmbeddedCase2) graphql.Marshaler { + return ec._EmbeddedCase2(ctx, sel, &v) +} + +func (ec *executionContext) marshalOEmbeddedCase22ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐEmbeddedCase2(ctx context.Context, sel ast.SelectionSet, v *EmbeddedCase2) graphql.Marshaler { + if v == nil { + return graphql.Null + } + return ec._EmbeddedCase2(ctx, sel, v) +} + func (ec *executionContext) marshalOError2githubᚗcomᚋ99designsᚋgqlgenᚋcodegenᚋtestserverᚐError(ctx context.Context, sel ast.SelectionSet, v Error) graphql.Marshaler { return ec._Error(ctx, sel, &v) } diff --git a/codegen/testserver/resolver.go b/codegen/testserver/resolver.go index ba7290f8db8..a4edc9f6afc 100644 --- a/codegen/testserver/resolver.go +++ b/codegen/testserver/resolver.go @@ -179,10 +179,10 @@ func (r *queryResolver) DirectiveDouble(ctx context.Context) (*string, error) { func (r *queryResolver) DirectiveUnimplemented(ctx context.Context) (*string, error) { panic("not implemented") } -func (r *queryResolver) Case1(ctx context.Context) (*Case1, error) { +func (r *queryResolver) EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error) { panic("not implemented") } -func (r *queryResolver) Case2(ctx context.Context) (*Case2, error) { +func (r *queryResolver) EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error) { panic("not implemented") } func (r *queryResolver) Shapes(ctx context.Context) ([]Shape, error) { diff --git a/codegen/testserver/stub.go b/codegen/testserver/stub.go index b31ab8eec0b..0d4d3ee26c7 100644 --- a/codegen/testserver/stub.go +++ b/codegen/testserver/stub.go @@ -63,8 +63,8 @@ type Stub struct { DirectiveField func(ctx context.Context) (*string, error) DirectiveDouble func(ctx context.Context) (*string, error) DirectiveUnimplemented func(ctx context.Context) (*string, error) - Case1 func(ctx context.Context) (*Case1, error) - Case2 func(ctx context.Context) (*Case2, error) + EmbeddedCase1 func(ctx context.Context) (*EmbeddedCase1, error) + EmbeddedCase2 func(ctx context.Context) (*EmbeddedCase2, error) Shapes func(ctx context.Context) ([]Shape, error) NoShape func(ctx context.Context) (Shape, error) MapStringInterface func(ctx context.Context, in map[string]interface{}) (map[string]interface{}, error) @@ -265,11 +265,11 @@ func (r *stubQuery) DirectiveDouble(ctx context.Context) (*string, error) { func (r *stubQuery) DirectiveUnimplemented(ctx context.Context) (*string, error) { return r.QueryResolver.DirectiveUnimplemented(ctx) } -func (r *stubQuery) Case1(ctx context.Context) (*Case1, error) { - return r.QueryResolver.Case1(ctx) +func (r *stubQuery) EmbeddedCase1(ctx context.Context) (*EmbeddedCase1, error) { + return r.QueryResolver.EmbeddedCase1(ctx) } -func (r *stubQuery) Case2(ctx context.Context) (*Case2, error) { - return r.QueryResolver.Case2(ctx) +func (r *stubQuery) EmbeddedCase2(ctx context.Context) (*EmbeddedCase2, error) { + return r.QueryResolver.EmbeddedCase2(ctx) } func (r *stubQuery) Shapes(ctx context.Context) ([]Shape, error) { return r.QueryResolver.Shapes(ctx)