salman-rb
39a980ab4e
Current implementation always uses POST as the transport mechanism. Adding GET support enables usage of GET queries for caching simply via URL. Some notes: - I left the existing API for creating a new client as is, but the implementation could be much cleaner by introducing some sort of configuration struct when creating a new client - The construction of the query parameters follows the logic from Apollo's client implementation, which can be found here https://github.com/apollographql/apollo-client/blob/8beb4820edc6352996e08f7f73bde3573f1eb666/src/link/http/rewriteURIForGET.ts - Updated integration tests to use both sets of clients. Updating the tests to use a test suite would be cleaner
742 lines
21 KiB
Go
742 lines
21 KiB
Go
// Package integration contains genqlient's integration tests, which run
|
|
// against a real server (defined in internal/integration/server/server.go).
|
|
//
|
|
// These are especially important for cases where we generate nontrivial logic,
|
|
// such as JSON-unmarshaling.
|
|
package integration
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/Khan/genqlient/graphql"
|
|
"github.com/Khan/genqlient/internal/integration/server"
|
|
)
|
|
|
|
func TestSimpleQuery(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query simpleQuery { me { id name luckyNumber } }`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := simpleQuery(ctx, client)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "1", resp.Me.Id)
|
|
assert.Equal(t, "Yours Truly", resp.Me.Name)
|
|
assert.Equal(t, 17, resp.Me.LuckyNumber)
|
|
}
|
|
}
|
|
|
|
func TestMutation(t *testing.T) {
|
|
_ = `# @genqlient
|
|
mutation createUser($user: NewUser!) { createUser(input: $user) { id name } }`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
postClient := newRoundtripClient(t, server.URL)
|
|
getClient := newRoundtripGetClient(t, server.URL)
|
|
|
|
resp, _, err := createUser(ctx, postClient, NewUser{Name: "Jack"})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "5", resp.CreateUser.Id)
|
|
assert.Equal(t, "Jack", resp.CreateUser.Name)
|
|
|
|
_, _, err = createUser(ctx, getClient, NewUser{Name: "Jill"})
|
|
require.Errorf(t, err, "client does not support mutations")
|
|
}
|
|
|
|
func TestServerError(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query failingQuery { fail me { id } }`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := failingQuery(ctx, client)
|
|
// As long as we get some response back, we should still return a full
|
|
// response -- and indeed in this case it should even have another field
|
|
// (which didn't err) set.
|
|
assert.Error(t, err)
|
|
assert.NotNil(t, resp)
|
|
assert.Equal(t, "1", resp.Me.Id)
|
|
}
|
|
}
|
|
|
|
func TestNetworkError(t *testing.T) {
|
|
ctx := context.Background()
|
|
clients := newRoundtripClients(t, "https://nothing.invalid/graphql")
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := failingQuery(ctx, client)
|
|
// As we guarantee in the README, even on network error you always get a
|
|
// non-nil response; this is so you can write e.g.
|
|
// resp, err := failingQuery(ctx)
|
|
// return resp.Me.Id, err
|
|
// without a bunch of extra ceremony.
|
|
assert.Error(t, err)
|
|
assert.NotNil(t, resp)
|
|
assert.Equal(t, new(failingQueryResponse), resp)
|
|
}
|
|
}
|
|
|
|
func TestVariables(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query queryWithVariables($id: ID!) { user(id: $id) { id name luckyNumber } }`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
// This doesn't roundtrip successfully because the zero user gets marshaled
|
|
// as {"id": "", "name": "", ...}, not null. There's really no way to do
|
|
// this right in Go (without adding `pointer: true` just for this purpose),
|
|
// and unmarshal(marshal(resp)) == resp should still hold, so we don't
|
|
// worry about it.
|
|
clients := []graphql.Client{
|
|
graphql.NewClient(server.URL, http.DefaultClient),
|
|
graphql.NewClientUsingGet(server.URL, http.DefaultClient),
|
|
}
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithVariables(ctx, client, "2")
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "2", resp.User.Id)
|
|
assert.Equal(t, "Raven", resp.User.Name)
|
|
assert.Equal(t, -1, resp.User.LuckyNumber)
|
|
|
|
resp, _, err = queryWithVariables(ctx, client, "374892379482379")
|
|
require.NoError(t, err)
|
|
|
|
assert.Zero(t, resp.User)
|
|
}
|
|
}
|
|
|
|
func TestExtensions(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query simpleQueryExt { me { id name luckyNumber } }`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
_, extensions, err := simpleQueryExt(ctx, client)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, extensions)
|
|
assert.Equal(t, extensions["foobar"], "test")
|
|
}
|
|
}
|
|
|
|
func TestOmitempty(t *testing.T) {
|
|
_ = `# @genqlient(omitempty: true)
|
|
query queryWithOmitempty($id: ID) {
|
|
user(id: $id) { id name luckyNumber }
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithOmitempty(ctx, client, "2")
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "2", resp.User.Id)
|
|
assert.Equal(t, "Raven", resp.User.Name)
|
|
assert.Equal(t, -1, resp.User.LuckyNumber)
|
|
|
|
// should return default user, not the user with ID ""
|
|
resp, _, err = queryWithOmitempty(ctx, client, "")
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, "1", resp.User.Id)
|
|
assert.Equal(t, "Yours Truly", resp.User.Name)
|
|
assert.Equal(t, 17, resp.User.LuckyNumber)
|
|
}
|
|
}
|
|
|
|
func TestCustomMarshal(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query queryWithCustomMarshal($date: Date!) {
|
|
usersBornOn(date: $date) { id name birthdate }
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithCustomMarshal(ctx, client,
|
|
time.Date(2025, time.January, 1, 12, 34, 56, 789, time.UTC))
|
|
require.NoError(t, err)
|
|
|
|
assert.Len(t, resp.UsersBornOn, 1)
|
|
user := resp.UsersBornOn[0]
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, "Yours Truly", user.Name)
|
|
assert.Equal(t,
|
|
time.Date(2025, time.January, 1, 0, 0, 0, 0, time.UTC),
|
|
user.Birthdate)
|
|
|
|
resp, _, err = queryWithCustomMarshal(ctx, client,
|
|
time.Date(2021, time.January, 1, 12, 34, 56, 789, time.UTC))
|
|
require.NoError(t, err)
|
|
assert.Len(t, resp.UsersBornOn, 0)
|
|
}
|
|
}
|
|
|
|
func TestCustomMarshalSlice(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query queryWithCustomMarshalSlice($dates: [Date!]!) {
|
|
usersBornOnDates(dates: $dates) { id name birthdate }
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithCustomMarshalSlice(ctx, client,
|
|
[]time.Time{time.Date(2025, time.January, 1, 12, 34, 56, 789, time.UTC)})
|
|
require.NoError(t, err)
|
|
|
|
assert.Len(t, resp.UsersBornOnDates, 1)
|
|
user := resp.UsersBornOnDates[0]
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, "Yours Truly", user.Name)
|
|
assert.Equal(t,
|
|
time.Date(2025, time.January, 1, 0, 0, 0, 0, time.UTC),
|
|
user.Birthdate)
|
|
|
|
resp, _, err = queryWithCustomMarshalSlice(ctx, client,
|
|
[]time.Time{time.Date(2021, time.January, 1, 12, 34, 56, 789, time.UTC)})
|
|
require.NoError(t, err)
|
|
assert.Len(t, resp.UsersBornOnDates, 0)
|
|
}
|
|
}
|
|
|
|
func TestCustomMarshalOptional(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query queryWithCustomMarshalOptional(
|
|
# @genqlient(pointer: true)
|
|
$date: Date,
|
|
# @genqlient(pointer: true)
|
|
$id: ID,
|
|
) {
|
|
userSearch(birthdate: $date, id: $id) { id name birthdate }
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
date := time.Date(2025, time.January, 1, 12, 34, 56, 789, time.UTC)
|
|
resp, _, err := queryWithCustomMarshalOptional(ctx, client, &date, nil)
|
|
require.NoError(t, err)
|
|
|
|
assert.Len(t, resp.UserSearch, 1)
|
|
user := resp.UserSearch[0]
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, "Yours Truly", user.Name)
|
|
assert.Equal(t,
|
|
time.Date(2025, time.January, 1, 0, 0, 0, 0, time.UTC),
|
|
user.Birthdate)
|
|
|
|
id := "2"
|
|
resp, _, err = queryWithCustomMarshalOptional(ctx, client, nil, &id)
|
|
require.NoError(t, err)
|
|
assert.Len(t, resp.UserSearch, 1)
|
|
user = resp.UserSearch[0]
|
|
assert.Equal(t, "2", user.Id)
|
|
assert.Equal(t, "Raven", user.Name)
|
|
assert.Zero(t, user.Birthdate)
|
|
}
|
|
}
|
|
|
|
func TestInterfaceNoFragments(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query queryWithInterfaceNoFragments($id: ID!) {
|
|
being(id: $id) { id name }
|
|
me { id name }
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithInterfaceNoFragments(ctx, client, "1")
|
|
require.NoError(t, err)
|
|
|
|
// We should get the following response:
|
|
// me: User{Id: 1, Name: "Yours Truly"},
|
|
// being: User{Id: 1, Name: "Yours Truly"},
|
|
|
|
assert.Equal(t, "1", resp.Me.Id)
|
|
assert.Equal(t, "Yours Truly", resp.Me.Name)
|
|
|
|
// Check fields both via interface and via type-assertion:
|
|
assert.Equal(t, "User", resp.Being.GetTypename())
|
|
assert.Equal(t, "1", resp.Being.GetId())
|
|
assert.Equal(t, "Yours Truly", resp.Being.GetName())
|
|
|
|
user, ok := resp.Being.(*queryWithInterfaceNoFragmentsBeingUser)
|
|
require.Truef(t, ok, "got %T, not User", resp.Being)
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, "Yours Truly", user.Name)
|
|
|
|
resp, _, err = queryWithInterfaceNoFragments(ctx, client, "3")
|
|
require.NoError(t, err)
|
|
|
|
// We should get the following response:
|
|
// me: User{Id: 1, Name: "Yours Truly"},
|
|
// being: Animal{Id: 3, Name: "Fido"},
|
|
|
|
assert.Equal(t, "1", resp.Me.Id)
|
|
assert.Equal(t, "Yours Truly", resp.Me.Name)
|
|
|
|
assert.Equal(t, "Animal", resp.Being.GetTypename())
|
|
assert.Equal(t, "3", resp.Being.GetId())
|
|
assert.Equal(t, "Fido", resp.Being.GetName())
|
|
|
|
animal, ok := resp.Being.(*queryWithInterfaceNoFragmentsBeingAnimal)
|
|
require.Truef(t, ok, "got %T, not Animal", resp.Being)
|
|
assert.Equal(t, "3", animal.Id)
|
|
assert.Equal(t, "Fido", animal.Name)
|
|
|
|
resp, _, err = queryWithInterfaceNoFragments(ctx, client, "4757233945723")
|
|
require.NoError(t, err)
|
|
|
|
// We should get the following response:
|
|
// me: User{Id: 1, Name: "Yours Truly"},
|
|
// being: null
|
|
|
|
assert.Equal(t, "1", resp.Me.Id)
|
|
assert.Equal(t, "Yours Truly", resp.Me.Name)
|
|
|
|
assert.Nil(t, resp.Being)
|
|
}
|
|
}
|
|
|
|
func TestInterfaceListField(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query queryWithInterfaceListField($ids: [ID!]!) {
|
|
beings(ids: $ids) { id name }
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithInterfaceListField(ctx, client,
|
|
[]string{"1", "3", "12847394823"})
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, resp.Beings, 3)
|
|
|
|
// We should get the following three beings:
|
|
// User{Id: 1, Name: "Yours Truly"},
|
|
// Animal{Id: 3, Name: "Fido"},
|
|
// null
|
|
|
|
// Check fields both via interface and via type-assertion:
|
|
assert.Equal(t, "User", resp.Beings[0].GetTypename())
|
|
assert.Equal(t, "1", resp.Beings[0].GetId())
|
|
assert.Equal(t, "Yours Truly", resp.Beings[0].GetName())
|
|
|
|
user, ok := resp.Beings[0].(*queryWithInterfaceListFieldBeingsUser)
|
|
require.Truef(t, ok, "got %T, not User", resp.Beings[0])
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, "Yours Truly", user.Name)
|
|
|
|
assert.Equal(t, "Animal", resp.Beings[1].GetTypename())
|
|
assert.Equal(t, "3", resp.Beings[1].GetId())
|
|
assert.Equal(t, "Fido", resp.Beings[1].GetName())
|
|
|
|
animal, ok := resp.Beings[1].(*queryWithInterfaceListFieldBeingsAnimal)
|
|
require.Truef(t, ok, "got %T, not Animal", resp.Beings[1])
|
|
assert.Equal(t, "3", animal.Id)
|
|
assert.Equal(t, "Fido", animal.Name)
|
|
|
|
assert.Nil(t, resp.Beings[2])
|
|
}
|
|
}
|
|
|
|
func TestInterfaceListPointerField(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query queryWithInterfaceListPointerField($ids: [ID!]!) {
|
|
# @genqlient(pointer: true)
|
|
beings(ids: $ids) {
|
|
__typename id name
|
|
}
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithInterfaceListPointerField(ctx, client,
|
|
[]string{"1", "3", "12847394823"})
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, resp.Beings, 3)
|
|
|
|
// Check fields both via interface and via type-assertion:
|
|
assert.Equal(t, "User", (*resp.Beings[0]).GetTypename())
|
|
assert.Equal(t, "1", (*resp.Beings[0]).GetId())
|
|
assert.Equal(t, "Yours Truly", (*resp.Beings[0]).GetName())
|
|
|
|
user, ok := (*resp.Beings[0]).(*queryWithInterfaceListPointerFieldBeingsUser)
|
|
require.Truef(t, ok, "got %T, not User", *resp.Beings[0])
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, "Yours Truly", user.Name)
|
|
|
|
assert.Equal(t, "Animal", (*resp.Beings[1]).GetTypename())
|
|
assert.Equal(t, "3", (*resp.Beings[1]).GetId())
|
|
assert.Equal(t, "Fido", (*resp.Beings[1]).GetName())
|
|
|
|
animal, ok := (*resp.Beings[1]).(*queryWithInterfaceListPointerFieldBeingsAnimal)
|
|
require.Truef(t, ok, "got %T, not Animal", resp.Beings[1])
|
|
assert.Equal(t, "3", animal.Id)
|
|
assert.Equal(t, "Fido", animal.Name)
|
|
|
|
assert.Nil(t, resp.Beings[2])
|
|
}
|
|
}
|
|
|
|
func TestFragments(t *testing.T) {
|
|
_ = `# @genqlient
|
|
query queryWithFragments($ids: [ID!]!) {
|
|
beings(ids: $ids) {
|
|
__typename id
|
|
... on Being { id name }
|
|
... on Animal {
|
|
id
|
|
hair { hasHair }
|
|
species
|
|
owner {
|
|
id
|
|
... on Being { name }
|
|
... on User { luckyNumber }
|
|
}
|
|
}
|
|
... on Lucky { luckyNumber }
|
|
... on User { hair { color } }
|
|
}
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithFragments(ctx, client, []string{"1", "3", "12847394823"})
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, resp.Beings, 3)
|
|
|
|
// We should get the following three beings:
|
|
// User{Id: 1, Name: "Yours Truly"},
|
|
// Animal{Id: 3, Name: "Fido"},
|
|
// null
|
|
|
|
// Check fields both via interface and via type-assertion when possible
|
|
// User has, in total, the fields: __typename id name luckyNumber.
|
|
assert.Equal(t, "User", resp.Beings[0].GetTypename())
|
|
assert.Equal(t, "1", resp.Beings[0].GetId())
|
|
assert.Equal(t, "Yours Truly", resp.Beings[0].GetName())
|
|
// (hair and luckyNumber we need to cast for)
|
|
|
|
user, ok := resp.Beings[0].(*queryWithFragmentsBeingsUser)
|
|
require.Truef(t, ok, "got %T, not User", resp.Beings[0])
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, "Yours Truly", user.Name)
|
|
assert.Equal(t, "Black", user.Hair.Color)
|
|
assert.Equal(t, 17, user.LuckyNumber)
|
|
|
|
// Animal has, in total, the fields:
|
|
// __typename
|
|
// id
|
|
// species
|
|
// owner {
|
|
// id
|
|
// name
|
|
// ... on User { luckyNumber }
|
|
// }
|
|
assert.Equal(t, "Animal", resp.Beings[1].GetTypename())
|
|
assert.Equal(t, "3", resp.Beings[1].GetId())
|
|
// (hair, species, and owner.* we have to cast for)
|
|
|
|
animal, ok := resp.Beings[1].(*queryWithFragmentsBeingsAnimal)
|
|
require.Truef(t, ok, "got %T, not Animal", resp.Beings[1])
|
|
assert.Equal(t, "3", animal.Id)
|
|
assert.Equal(t, SpeciesDog, animal.Species)
|
|
assert.True(t, animal.Hair.HasHair)
|
|
|
|
assert.Equal(t, "1", animal.Owner.GetId())
|
|
assert.Equal(t, "Yours Truly", animal.Owner.GetName())
|
|
// (luckyNumber we have to cast for, again)
|
|
|
|
owner, ok := animal.Owner.(*queryWithFragmentsBeingsAnimalOwnerUser)
|
|
require.Truef(t, ok, "got %T, not User", animal.Owner)
|
|
assert.Equal(t, "1", owner.Id)
|
|
assert.Equal(t, "Yours Truly", owner.Name)
|
|
assert.Equal(t, 17, owner.LuckyNumber)
|
|
|
|
assert.Nil(t, resp.Beings[2])
|
|
}
|
|
}
|
|
|
|
func TestNamedFragments(t *testing.T) {
|
|
_ = `# @genqlient
|
|
fragment AnimalFields on Animal {
|
|
id
|
|
hair { hasHair }
|
|
owner { id ...UserFields ...LuckyFields }
|
|
}
|
|
|
|
fragment MoreUserFields on User {
|
|
id
|
|
hair { color }
|
|
}
|
|
|
|
fragment LuckyFields on Lucky {
|
|
...MoreUserFields
|
|
luckyNumber
|
|
}
|
|
|
|
fragment UserFields on User {
|
|
id
|
|
...LuckyFields
|
|
...MoreUserFields
|
|
}
|
|
|
|
query queryWithNamedFragments($ids: [ID!]!) {
|
|
beings(ids: $ids) {
|
|
__typename id
|
|
...AnimalFields
|
|
...UserFields
|
|
}
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithNamedFragments(ctx, client, []string{"1", "3", "12847394823"})
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, resp.Beings, 3)
|
|
|
|
// We should get the following three beings:
|
|
// User{Id: 1, Name: "Yours Truly"},
|
|
// Animal{Id: 3, Name: "Fido"},
|
|
// null
|
|
|
|
// Check fields both via interface and via type-assertion when possible
|
|
// User has, in total, the fields: __typename id luckyNumber.
|
|
assert.Equal(t, "User", resp.Beings[0].GetTypename())
|
|
assert.Equal(t, "1", resp.Beings[0].GetId())
|
|
// (luckyNumber, hair we need to cast for)
|
|
|
|
user, ok := resp.Beings[0].(*queryWithNamedFragmentsBeingsUser)
|
|
require.Truef(t, ok, "got %T, not User", resp.Beings[0])
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, "1", user.UserFields.Id)
|
|
assert.Equal(t, "1", user.UserFields.MoreUserFields.Id)
|
|
assert.Equal(t, "1", user.UserFields.LuckyFieldsUser.MoreUserFields.Id)
|
|
// on UserFields, but we should be able to access directly via embedding:
|
|
assert.Equal(t, 17, user.LuckyNumber)
|
|
assert.Equal(t, "Black", user.Hair.Color)
|
|
assert.Equal(t, "Black", user.UserFields.MoreUserFields.Hair.Color)
|
|
assert.Equal(t, "Black", user.UserFields.LuckyFieldsUser.MoreUserFields.Hair.Color)
|
|
|
|
// Animal has, in total, the fields:
|
|
// __typename
|
|
// id
|
|
// hair { hasHair }
|
|
// owner { id luckyNumber }
|
|
assert.Equal(t, "Animal", resp.Beings[1].GetTypename())
|
|
assert.Equal(t, "3", resp.Beings[1].GetId())
|
|
// (hair.* and owner.* we have to cast for)
|
|
|
|
animal, ok := resp.Beings[1].(*queryWithNamedFragmentsBeingsAnimal)
|
|
require.Truef(t, ok, "got %T, not Animal", resp.Beings[1])
|
|
// Check that we filled in *both* ID fields:
|
|
assert.Equal(t, "3", animal.Id)
|
|
assert.Equal(t, "3", animal.AnimalFields.Id)
|
|
// on AnimalFields:
|
|
assert.True(t, animal.Hair.HasHair)
|
|
assert.Equal(t, "1", animal.Owner.GetId())
|
|
// (luckyNumber we have to cast for, again)
|
|
|
|
owner, ok := animal.Owner.(*AnimalFieldsOwnerUser)
|
|
require.Truef(t, ok, "got %T, not User", animal.Owner)
|
|
// Check that we filled in *both* ID fields:
|
|
assert.Equal(t, "1", owner.Id)
|
|
assert.Equal(t, "1", owner.UserFields.Id)
|
|
assert.Equal(t, "1", owner.UserFields.MoreUserFields.Id)
|
|
assert.Equal(t, "1", owner.UserFields.LuckyFieldsUser.MoreUserFields.Id)
|
|
// on UserFields:
|
|
assert.Equal(t, 17, owner.LuckyNumber)
|
|
assert.Equal(t, "Black", owner.UserFields.MoreUserFields.Hair.Color)
|
|
assert.Equal(t, "Black", owner.UserFields.LuckyFieldsUser.MoreUserFields.Hair.Color)
|
|
|
|
// Lucky-based fields we can also get by casting to the fragment-interface.
|
|
luckyOwner, ok := animal.Owner.(LuckyFields)
|
|
require.Truef(t, ok, "got %T, not Lucky", animal.Owner)
|
|
assert.Equal(t, 17, luckyOwner.GetLuckyNumber())
|
|
|
|
assert.Nil(t, resp.Beings[2])
|
|
}
|
|
}
|
|
|
|
func TestFlatten(t *testing.T) {
|
|
_ = `# @genqlient
|
|
# @genqlient(flatten: true)
|
|
fragment BeingFields on Being {
|
|
...InnerBeingFields
|
|
}
|
|
|
|
fragment InnerBeingFields on Being {
|
|
id
|
|
name
|
|
... on User {
|
|
# @genqlient(flatten: true)
|
|
friends {
|
|
...FriendsFields
|
|
}
|
|
}
|
|
}
|
|
|
|
fragment FriendsFields on User {
|
|
id
|
|
name
|
|
}
|
|
|
|
# @genqlient(flatten: true)
|
|
fragment FlattenedUserFields on User {
|
|
...FlattenedLuckyFields
|
|
}
|
|
|
|
# @genqlient(flatten: true)
|
|
fragment FlattenedLuckyFields on Lucky {
|
|
...InnerLuckyFields
|
|
}
|
|
|
|
fragment InnerLuckyFields on Lucky {
|
|
luckyNumber
|
|
}
|
|
|
|
fragment QueryFragment on Query {
|
|
beings(ids: $ids) {
|
|
__typename id
|
|
...FlattenedUserFields
|
|
... on Animal {
|
|
# @genqlient(flatten: true)
|
|
owner {
|
|
...BeingFields
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# @genqlient(flatten: true)
|
|
query queryWithFlatten(
|
|
$ids: [ID!]!,
|
|
) {
|
|
...QueryFragment
|
|
}`
|
|
|
|
ctx := context.Background()
|
|
server := server.RunServer()
|
|
defer server.Close()
|
|
clients := newRoundtripClients(t, server.URL)
|
|
|
|
for _, client := range clients {
|
|
resp, _, err := queryWithFlatten(ctx, client, []string{"1", "3", "12847394823"})
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, resp.Beings, 3)
|
|
|
|
// We should get the following three beings:
|
|
// User{Id: 1, Name: "Yours Truly"},
|
|
// Animal{Id: 3, Name: "Fido"},
|
|
// null
|
|
|
|
// Check fields both via interface and via type-assertion when possible
|
|
// User has, in total, the fields: __typename id luckyNumber.
|
|
assert.Equal(t, "User", resp.Beings[0].GetTypename())
|
|
assert.Equal(t, "1", resp.Beings[0].GetId())
|
|
// (luckyNumber we need to cast for)
|
|
|
|
user, ok := resp.Beings[0].(*QueryFragmentBeingsUser)
|
|
require.Truef(t, ok, "got %T, not User", resp.Beings[0])
|
|
assert.Equal(t, "1", user.Id)
|
|
assert.Equal(t, 17, user.InnerLuckyFieldsUser.LuckyNumber)
|
|
|
|
// Animal has, in total, the fields:
|
|
// __typename
|
|
// id
|
|
// owner { id name ... on User { friends { id name } } }
|
|
assert.Equal(t, "Animal", resp.Beings[1].GetTypename())
|
|
assert.Equal(t, "3", resp.Beings[1].GetId())
|
|
// (owner.* we have to cast for)
|
|
|
|
animal, ok := resp.Beings[1].(*QueryFragmentBeingsAnimal)
|
|
require.Truef(t, ok, "got %T, not Animal", resp.Beings[1])
|
|
assert.Equal(t, "3", animal.Id)
|
|
// on AnimalFields:
|
|
assert.Equal(t, "1", animal.Owner.GetId())
|
|
assert.Equal(t, "Yours Truly", animal.Owner.GetName())
|
|
// (friends.* we have to cast for, again)
|
|
|
|
owner, ok := animal.Owner.(*InnerBeingFieldsUser)
|
|
require.Truef(t, ok, "got %T, not User", animal.Owner)
|
|
assert.Equal(t, "1", owner.Id)
|
|
assert.Equal(t, "Yours Truly", owner.Name)
|
|
assert.Len(t, owner.Friends, 1)
|
|
assert.Equal(t, "2", owner.Friends[0].Id)
|
|
assert.Equal(t, "Raven", owner.Friends[0].Name)
|
|
|
|
assert.Nil(t, resp.Beings[2])
|
|
}
|
|
}
|
|
|
|
func TestGeneratedCode(t *testing.T) {
|
|
// TODO(benkraft): Check that gqlgen is up to date too. In practice that's
|
|
// less likely to be a problem, since it should only change if you update
|
|
// the schema, likely too add something new, in which case you'll notice.
|
|
RunGenerateTest(t, "internal/integration/genqlient.yaml")
|
|
}
|
|
|
|
//go:generate go run github.com/Khan/genqlient genqlient.yaml
|