github.com/operandinc/gqlgen@v0.16.1/codegen/testserver/followschema/wrapped_type_test.go (about)

     1  package followschema
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/operandinc/gqlgen/client"
     8  	"github.com/operandinc/gqlgen/codegen/testserver/followschema/otherpkg"
     9  	"github.com/operandinc/gqlgen/graphql/handler"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func TestWrappedTypes(t *testing.T) {
    14  	resolvers := &Stub{}
    15  
    16  	c := client.New(handler.NewDefaultServer(NewExecutableSchema(Config{Resolvers: resolvers})))
    17  
    18  	resolvers.QueryResolver.WrappedScalar = func(ctx context.Context) (scalar WrappedScalar, e error) {
    19  		return "hello", nil
    20  	}
    21  
    22  	resolvers.QueryResolver.WrappedStruct = func(ctx context.Context) (wrappedStruct *WrappedStruct, e error) {
    23  		wrapped := WrappedStruct(otherpkg.Struct{
    24  			Name: "hello",
    25  		})
    26  		return &wrapped, nil
    27  	}
    28  
    29  	resolvers.QueryResolver.WrappedMap = func(ctx context.Context) (wrappedMap WrappedMap, e error) {
    30  		wrapped := WrappedMap(map[string]string{
    31  			"name": "hello",
    32  		})
    33  		return wrapped, nil
    34  	}
    35  
    36  	resolvers.QueryResolver.WrappedSlice = func(ctx context.Context) (slice WrappedSlice, err error) {
    37  		wrapped := WrappedSlice([]string{"hello"})
    38  		return wrapped, nil
    39  	}
    40  
    41  	resolvers.WrappedMapResolver.Get = func(ctx context.Context, obj WrappedMap, key string) (s string, err error) {
    42  		return obj[key], nil
    43  	}
    44  
    45  	resolvers.WrappedSliceResolver.Get = func(ctx context.Context, obj WrappedSlice, idx int) (s string, err error) {
    46  		return obj[idx], nil
    47  	}
    48  
    49  	t.Run("wrapped struct", func(t *testing.T) {
    50  		var resp struct {
    51  			WrappedStruct struct {
    52  				Name string
    53  			}
    54  		}
    55  
    56  		err := c.Post(`query { wrappedStruct { name } }`, &resp)
    57  		require.NoError(t, err)
    58  
    59  		require.Equal(t, "hello", resp.WrappedStruct.Name)
    60  	})
    61  
    62  	t.Run("wrapped scalar", func(t *testing.T) {
    63  		var resp struct {
    64  			WrappedScalar string
    65  		}
    66  
    67  		err := c.Post(`query { wrappedScalar }`, &resp)
    68  		require.NoError(t, err)
    69  
    70  		require.Equal(t, "hello", resp.WrappedScalar)
    71  	})
    72  
    73  	t.Run("wrapped map", func(t *testing.T) {
    74  		var resp struct {
    75  			WrappedMap struct {
    76  				Name string
    77  			}
    78  		}
    79  
    80  		err := c.Post(`query { wrappedMap { name: get(key: "name") } }`, &resp)
    81  		require.NoError(t, err)
    82  
    83  		require.Equal(t, "hello", resp.WrappedMap.Name)
    84  	})
    85  
    86  	t.Run("wrapped slice", func(t *testing.T) {
    87  		var resp struct {
    88  			WrappedSlice struct {
    89  				First string
    90  			}
    91  		}
    92  
    93  		err := c.Post(`query { wrappedSlice { first: get(idx: 0) } }`, &resp)
    94  		require.NoError(t, err)
    95  
    96  		require.Equal(t, "hello", resp.WrappedSlice.First)
    97  	})
    98  }