func TestObjectIdentification_TestFetching_CorrectlyRefetchesTheEmpire(t *testing.T) {
query := `
query EmpireRefetchQuery {
node(id: "RmFjdGlvbjoy") {
id
... on Faction {
name
}
}
}
`
expected := &graphql.Result{
Data: map[string]interface{}{
"node": map[string]interface{}{
"id": "RmFjdGlvbjoy",
"name": "Galactic Empire",
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: starwars.Schema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestGlobalIDFields_RefetchesTheIDs(t *testing.T) {
query := `{
user: node(id: "VXNlcjox") {
id
... on User {
name
}
},
photo: node(id: "UGhvdG86MQ==") {
id
... on Photo {
width
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"user": map[string]interface{}{
"id": "VXNlcjox",
"name": "John Doe",
},
"photo": map[string]interface{}{
"id": "UGhvdG86MQ==",
"width": 300,
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: globalIDTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestObjectIdentification_TestFetching_CorrectlyFetchesTheIDAndTheNameOfTheRebels(t *testing.T) {
query := `
query RebelsQuery {
rebels {
id
name
}
}
`
expected := &graphql.Result{
Data: map[string]interface{}{
"rebels": map[string]interface{}{
"id": "RmFjdGlvbjox",
"name": "Alliance to Restore the Republic",
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: starwars.Schema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestGlobalIDFields_GivesDifferentIDs(t *testing.T) {
query := `{
allObjects {
id
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"allObjects": []interface{}{
map[string]interface{}{
"id": "VXNlcjox",
},
map[string]interface{}{
"id": "VXNlcjoy",
},
map[string]interface{}{
"id": "UGhvdG86MQ==",
},
map[string]interface{}{
"id": "UGhvdG86Mg==",
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: globalIDTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestPluralIdentifyingRootField_AllowsFetching(t *testing.T) {
query := `{
usernames(usernames:["dschafer", "leebyron", "schrockn"]) {
username
url
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"usernames": []interface{}{
map[string]interface{}{
"username": "******",
"url": "www.facebook.com/dschafer",
},
map[string]interface{}{
"username": "******",
"url": "www.facebook.com/leebyron",
},
map[string]interface{}{
"username": "******",
"url": "www.facebook.com/schrockn",
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: pluralTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnection_TestFetching_CorrectlyFetchesNoShipsOfTheRebelsAtTheEndOfTheConnection(t *testing.T) {
query := `
query RebelsQuery {
rebels {
name,
ships(first: 3 after: "YXJyYXljb25uZWN0aW9uOjQ=") {
edges {
cursor,
node {
name
}
}
}
}
}
`
expected := &graphql.Result{
Data: map[string]interface{}{
"rebels": map[string]interface{}{
"name": "Alliance to Restore the Republic",
"ships": map[string]interface{}{
"edges": []interface{}{},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: starwars.Schema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestNodeInterfaceAndFields_AllowsRefetching_GetsTheCorrectWidthForPhotos(t *testing.T) {
query := `{
node(id: "4") {
id
... on Photo {
width
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"node": map[string]interface{}{
"id": "4",
"width": 400,
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: nodeTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func main() {
// Save JSON of full schema introspection for Babel Relay Plugin to use
result := graphql.Graphql(graphql.Params{
Schema: data.Schema,
RequestString: testutil.IntrospectionQuery,
})
if result.HasErrors() {
log.Fatalf("ERROR introspecting schema: %v", result.Errors)
return
} else {
b, err := json.MarshalIndent(result, "", " ")
if err != nil {
log.Fatalf("ERROR: %v", err)
}
err = ioutil.WriteFile("../data/schema.json", b, os.ModePerm)
if err != nil {
log.Fatalf("ERROR: %v", err)
}
}
// TODO: Save user readable type system shorthand of schema
// pending implementation of printSchema
/*
fs.writeFileSync(
path.join(__dirname, '../data/schema.graphql'),
printSchema(Schema)
);
*/
}
func TestMutation_WithClientMutationId_BehavesCorrectly_ReturnsTheSameClientMutationId(t *testing.T) {
query := `
mutation M {
simpleMutation(input: {clientMutationId: "abc"}) {
result
clientMutationId
}
}
`
expected := &graphql.Result{
Data: map[string]interface{}{
"simpleMutation": map[string]interface{}{
"result": 1,
"clientMutationId": "abc",
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: mutationTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestObjectIdentification_TestFetching_CorrectlyRefetchesTheXWing(t *testing.T) {
query := `
query XWingRefetchQuery {
node(id: "U2hpcDox") {
id
... on Ship {
name
}
}
}
`
expected := &graphql.Result{
Data: map[string]interface{}{
"node": map[string]interface{}{
"id": "U2hpcDox",
"name": "X-Wing",
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: starwars.Schema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestNodeInterfaceAndFields_AllowsRefetching_GetsTheCorrectNameForUsers(t *testing.T) {
query := `{
node(id: "1") {
id
... on User {
name
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"node": map[string]interface{}{
"id": "1",
"name": "John Doe",
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: nodeTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func testGraphql(test T, p graphql.Params, t *testing.T) {
result := graphql.Graphql(p)
if len(result.Errors) > 0 {
t.Fatalf("wrong result, unexpected errors: %v", result.Errors)
}
if !reflect.DeepEqual(result, test.Expected) {
t.Fatalf("wrong result, query: %v, graphql result diff: %v", test.Query, testutil.Diff(test.Expected, result))
}
}
func executeQuery(query string, schema graphql.Schema) *graphql.Result {
result := graphql.Graphql(graphql.Params{
Schema: schema,
RequestString: query,
})
if len(result.Errors) > 0 {
fmt.Println("wrong result, unexpected errors: %v", result.Errors)
}
return result
}
func TestMutation_IntrospectsCorrectly_ContainsCorrectPayload(t *testing.T) {
query := `{
__type(name: "SimpleMutationPayload") {
name
kind
fields {
name
type {
name
kind
ofType {
name
kind
}
}
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"__type": map[string]interface{}{
"name": "SimpleMutationPayload",
"kind": "OBJECT",
"fields": []interface{}{
map[string]interface{}{
"name": "result",
"type": map[string]interface{}{
"name": "Int",
"kind": "SCALAR",
"ofType": nil,
},
},
map[string]interface{}{
"name": "clientMutationId",
"type": map[string]interface{}{
"name": nil,
"kind": "NON_NULL",
"ofType": map[string]interface{}{
"name": "String",
"kind": "SCALAR",
},
},
},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: mutationTestSchema,
RequestString: query,
})
if !testutil.ContainSubset(result.Data.(map[string]interface{}), expected.Data.(map[string]interface{})) {
t.Fatalf("unexpected, result does not contain subset of expected data")
}
}
func TestConnection_TestFetching_CorrectlyFetchesTheNextThreeShipsOfTheRebelsWithACursor(t *testing.T) {
query := `
query EndOfRebelShipsQuery {
rebels {
name,
ships(first: 3 after: "YXJyYXljb25uZWN0aW9uOjE=") {
edges {
cursor,
node {
name
}
}
}
}
}
`
expected := &graphql.Result{
Data: map[string]interface{}{
"rebels": map[string]interface{}{
"name": "Alliance to Restore the Republic",
"ships": map[string]interface{}{
"edges": []interface{}{
map[string]interface{}{
"cursor": "YXJyYXljb25uZWN0aW9uOjI=",
"node": map[string]interface{}{
"name": "A-Wing",
},
},
map[string]interface{}{
"cursor": "YXJyYXljb25uZWN0aW9uOjM=",
"node": map[string]interface{}{
"name": "Millenium Falcon",
},
},
map[string]interface{}{
"cursor": "YXJyYXljb25uZWN0aW9uOjQ=",
"node": map[string]interface{}{
"name": "Home One",
},
},
},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: starwars.Schema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestConnectionDefinition_IncludesConnectionAndEdgeFields(t *testing.T) {
query := `
query FriendsQuery {
user {
friends(first: 2) {
totalCount
edges {
friendshipTime
node {
name
}
}
}
}
}
`
expected := &graphql.Result{
Data: map[string]interface{}{
"user": map[string]interface{}{
"friends": map[string]interface{}{
"totalCount": 5,
"edges": []interface{}{
map[string]interface{}{
"friendshipTime": "Yesterday",
"node": map[string]interface{}{
"name": "Dan",
},
},
map[string]interface{}{
"friendshipTime": "Yesterday",
"node": map[string]interface{}{
"name": "Nick",
},
},
},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: connectionTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestMutation_IntrospectsCorrectly_ContainsCorrectInput(t *testing.T) {
query := `{
__type(name: "SimpleMutationInput") {
name
kind
inputFields {
name
type {
name
kind
ofType {
name
kind
}
}
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"__type": map[string]interface{}{
"name": "SimpleMutationInput",
"kind": "INPUT_OBJECT",
"inputFields": []interface{}{
map[string]interface{}{
"name": "clientMutationId",
"type": map[string]interface{}{
"name": nil,
"kind": "NON_NULL",
"ofType": map[string]interface{}{
"name": "String",
"kind": "SCALAR",
},
},
},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: mutationTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
// ServeHTTP provides an entry point into executing graphQL queries
func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// get query
opts := getRequestOptions(r)
// execute graphql query
params := graphql.Params{
Schema: *h.Schema,
RequestString: opts.Query,
VariableValues: opts.Variables,
OperationName: opts.OperationName,
}
result := graphql.Graphql(params)
// render result
h.render.JSON(w, http.StatusOK, result)
}
func TestMutation_CorrectlyMutatesTheDataSet(t *testing.T) {
query := `
mutation AddBWingQuery($input: IntroduceShipInput!) {
introduceShip(input: $input) {
ship {
id
name
}
faction {
name
}
clientMutationId
}
}
`
params := map[string]interface{}{
"input": map[string]interface{}{
"shipName": "B-Wing",
"factionId": "1",
"clientMutationId": "abcde",
},
}
expected := &graphql.Result{
Data: map[string]interface{}{
"introduceShip": map[string]interface{}{
"ship": map[string]interface{}{
"id": "U2hpcDoxMA==",
"name": "B-Wing",
},
"faction": map[string]interface{}{
"name": "Alliance to Restore the Republic",
},
"clientMutationId": "abcde",
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: starwars.Schema,
RequestString: query,
VariableValues: params,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestNodeInterfaceAndFields_CorrectlyIntrospects_HasCorrectNodeInterface(t *testing.T) {
query := `{
__type(name: "Node") {
name
kind
fields {
name
type {
kind
ofType {
name
kind
}
}
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"__type": map[string]interface{}{
"name": "Node",
"kind": "INTERFACE",
"fields": []interface{}{
map[string]interface{}{
"name": "id",
"type": map[string]interface{}{
"kind": "NON_NULL",
"ofType": map[string]interface{}{
"name": "ID",
"kind": "SCALAR",
},
},
},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: nodeTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestNodeInterfaceAndFields_AllowsRefetching_ReturnsNullForBadIDs(t *testing.T) {
query := `{
node(id: "5") {
id
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"node": nil,
},
}
result := graphql.Graphql(graphql.Params{
Schema: nodeTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestPluralIdentifyingRootField_Configuration_ArgNames_WrongArgNameSpecified(t *testing.T) {
query := `{
usernames(usernamesMisspelled:["dschafer", "leebyron", "schrockn"]) {
username
url
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"usernames": nil,
},
}
result := graphql.Graphql(graphql.Params{
Schema: pluralTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestBasicGraphQLExample(t *testing.T) {
// taken from `graphql-js` README
helloFieldResolved := func(p graphql.GQLFRParams) interface{} {
return "world"
}
schema, err := graphql.NewSchema(graphql.SchemaConfig{
Query: graphql.NewObject(graphql.ObjectConfig{
Name: "RootQueryType",
Fields: graphql.FieldConfigMap{
"hello": &graphql.FieldConfig{
Description: "Returns `world`",
Type: graphql.String,
Resolve: helloFieldResolved,
},
},
}),
})
if err != nil {
t.Fatalf("wrong result, unexpected errors: %v", err.Error())
}
query := "{ hello }"
var expected interface{}
expected = map[string]interface{}{
"hello": "world",
}
result := graphql.Graphql(graphql.Params{
Schema: schema,
RequestString: query,
})
if len(result.Errors) > 0 {
t.Fatalf("wrong result, unexpected errors: %v", result.Errors)
}
if !reflect.DeepEqual(result.Data, expected) {
t.Fatalf("wrong result, query: %v, graphql result diff: %v", query, testutil.Diff(expected, result))
}
}
func TestConnection_TestFetching_CorrectlyFetchesTheFirstShipOfTheRebels(t *testing.T) {
query := `
query RebelsShipsQuery {
rebels {
name,
ships(first: 1) {
edges {
node {
name
}
}
}
}
}
`
expected := &graphql.Result{
Data: map[string]interface{}{
"rebels": map[string]interface{}{
"name": "Alliance to Restore the Republic",
"ships": map[string]interface{}{
"edges": []interface{}{
map[string]interface{}{
"node": map[string]interface{}{
"name": "X-Wing",
},
},
},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: starwars.Schema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestPluralIdentifyingRootField_Configuration_ResolveSingleInputIsNil(t *testing.T) {
var pluralTestQueryType = graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: graphql.FieldConfigMap{
"usernames": relay.PluralIdentifyingRootField(relay.PluralIdentifyingRootFieldConfig{
ArgName: "usernames",
Description: "Map from a username to the user",
InputType: graphql.String,
OutputType: pluralTestUserType,
}),
},
})
var pluralTestSchema, _ = graphql.NewSchema(graphql.SchemaConfig{
Query: pluralTestQueryType,
})
query := `{
usernames(usernames:["dschafer", "leebyron", "schrockn"]) {
username
url
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"usernames": nil,
},
}
result := graphql.Graphql(graphql.Params{
Schema: pluralTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestMutation_WithClientMutationId_BehavesCorrectly_RequiresAnArgument(t *testing.T) {
t.Skipf("Pending `validator` implementation")
query := `
mutation M {
simpleMutation {
result
}
}
`
expected := &graphql.Result{
Errors: []gqlerrors.FormattedError{
gqlerrors.FormattedError{
Message: `Field "simpleMutation" argument "input" of type "SimpleMutationInput!" is required but not provided.`,
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: mutationTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}
func TestResolveTypeOnUnionYieldsUsefulError(t *testing.T) {
humanType := graphql.NewObject(graphql.ObjectConfig{
Name: "Human",
Fields: graphql.FieldConfigMap{
"name": &graphql.FieldConfig{
Type: graphql.String,
Resolve: func(p graphql.GQLFRParams) interface{} {
if human, ok := p.Source.(*testHuman); ok {
return human.Name
}
return nil
},
},
},
})
dogType := graphql.NewObject(graphql.ObjectConfig{
Name: "Dog",
IsTypeOf: func(value interface{}, info graphql.ResolveInfo) bool {
_, ok := value.(*testDog)
return ok
},
Fields: graphql.FieldConfigMap{
"name": &graphql.FieldConfig{
Type: graphql.String,
Resolve: func(p graphql.GQLFRParams) interface{} {
if dog, ok := p.Source.(*testDog); ok {
return dog.Name
}
return nil
},
},
"woofs": &graphql.FieldConfig{
Type: graphql.Boolean,
Resolve: func(p graphql.GQLFRParams) interface{} {
if dog, ok := p.Source.(*testDog); ok {
return dog.Woofs
}
return nil
},
},
},
})
catType := graphql.NewObject(graphql.ObjectConfig{
Name: "Cat",
IsTypeOf: func(value interface{}, info graphql.ResolveInfo) bool {
_, ok := value.(*testCat)
return ok
},
Fields: graphql.FieldConfigMap{
"name": &graphql.FieldConfig{
Type: graphql.String,
Resolve: func(p graphql.GQLFRParams) interface{} {
if cat, ok := p.Source.(*testCat); ok {
return cat.Name
}
return nil
},
},
"meows": &graphql.FieldConfig{
Type: graphql.Boolean,
Resolve: func(p graphql.GQLFRParams) interface{} {
if cat, ok := p.Source.(*testCat); ok {
return cat.Meows
}
return nil
},
},
},
})
petType := graphql.NewUnion(graphql.UnionConfig{
Name: "Pet",
Types: []*graphql.Object{
dogType, catType,
},
ResolveType: func(value interface{}, info graphql.ResolveInfo) *graphql.Object {
if _, ok := value.(*testCat); ok {
return catType
}
if _, ok := value.(*testDog); ok {
return dogType
}
if _, ok := value.(*testHuman); ok {
return humanType
}
return nil
},
})
schema, err := graphql.NewSchema(graphql.SchemaConfig{
Query: graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: graphql.FieldConfigMap{
"pets": &graphql.FieldConfig{
Type: graphql.NewList(petType),
Resolve: func(p graphql.GQLFRParams) interface{} {
return []interface{}{
&testDog{"Odie", true},
&testCat{"Garfield", false},
&testHuman{"Jon"},
}
},
},
},
}),
})
if err != nil {
t.Fatalf("Error in schema %v", err.Error())
}
query := `{
pets {
name
... on Dog {
woofs
}
... on Cat {
meows
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"pets": []interface{}{
map[string]interface{}{
"name": "Odie",
"woofs": bool(true),
},
map[string]interface{}{
"name": "Garfield",
"meows": bool(false),
},
nil,
},
},
Errors: []gqlerrors.FormattedError{
gqlerrors.FormattedError{
Message: `Runtime Object type "Human" is not a possible type for "Pet".`,
Locations: []location.SourceLocation{},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: schema,
RequestString: query,
})
if len(result.Errors) == 0 {
t.Fatalf("wrong result, expected errors: %v, got: %v", len(expected.Errors), len(result.Errors))
}
if !reflect.DeepEqual(expected, result) {
t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(expected, result))
}
}
func TestIsTypeOfUsedToResolveRuntimeTypeForInterface(t *testing.T) {
petType := graphql.NewInterface(graphql.InterfaceConfig{
Name: "Pet",
Fields: graphql.FieldConfigMap{
"name": &graphql.FieldConfig{
Type: graphql.String,
},
},
})
// ie declare that Dog belongs to Pet interface
_ = graphql.NewObject(graphql.ObjectConfig{
Name: "Dog",
Interfaces: []*graphql.Interface{
petType,
},
IsTypeOf: func(value interface{}, info graphql.ResolveInfo) bool {
_, ok := value.(*testDog)
return ok
},
Fields: graphql.FieldConfigMap{
"name": &graphql.FieldConfig{
Type: graphql.String,
Resolve: func(p graphql.GQLFRParams) interface{} {
if dog, ok := p.Source.(*testDog); ok {
return dog.Name
}
return nil
},
},
"woofs": &graphql.FieldConfig{
Type: graphql.Boolean,
Resolve: func(p graphql.GQLFRParams) interface{} {
if dog, ok := p.Source.(*testDog); ok {
return dog.Woofs
}
return nil
},
},
},
})
// ie declare that Cat belongs to Pet interface
_ = graphql.NewObject(graphql.ObjectConfig{
Name: "Cat",
Interfaces: []*graphql.Interface{
petType,
},
IsTypeOf: func(value interface{}, info graphql.ResolveInfo) bool {
_, ok := value.(*testCat)
return ok
},
Fields: graphql.FieldConfigMap{
"name": &graphql.FieldConfig{
Type: graphql.String,
Resolve: func(p graphql.GQLFRParams) interface{} {
if cat, ok := p.Source.(*testCat); ok {
return cat.Name
}
return nil
},
},
"meows": &graphql.FieldConfig{
Type: graphql.Boolean,
Resolve: func(p graphql.GQLFRParams) interface{} {
if cat, ok := p.Source.(*testCat); ok {
return cat.Meows
}
return nil
},
},
},
})
schema, err := graphql.NewSchema(graphql.SchemaConfig{
Query: graphql.NewObject(graphql.ObjectConfig{
Name: "Query",
Fields: graphql.FieldConfigMap{
"pets": &graphql.FieldConfig{
Type: graphql.NewList(petType),
Resolve: func(p graphql.GQLFRParams) interface{} {
return []interface{}{
&testDog{"Odie", true},
&testCat{"Garfield", false},
}
},
},
},
}),
})
if err != nil {
t.Fatalf("Error in schema %v", err.Error())
}
query := `{
pets {
name
... on Dog {
woofs
}
... on Cat {
meows
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"pets": []interface{}{
map[string]interface{}{
"name": "Odie",
"woofs": bool(true),
},
map[string]interface{}{
"name": "Garfield",
"meows": bool(false),
},
},
},
Errors: nil,
}
result := graphql.Graphql(graphql.Params{
Schema: schema,
RequestString: query,
})
if len(result.Errors) != 0 {
t.Fatalf("wrong result, unexpected errors: %v", result.Errors)
}
if !reflect.DeepEqual(expected, result) {
t.Fatalf("Unexpected result, Diff: %v", testutil.Diff(expected, result))
}
}
func TestMutation_IntrospectsCorrectly_ContainsCorrectField(t *testing.T) {
query := `{
__schema {
mutationType {
fields {
name
args {
name
type {
name
kind
ofType {
name
kind
}
}
}
type {
name
kind
}
}
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"__schema": map[string]interface{}{
"mutationType": map[string]interface{}{
"fields": []interface{}{
map[string]interface{}{
"name": "simpleMutation",
"args": []interface{}{
map[string]interface{}{
"name": "input",
"type": map[string]interface{}{
"name": nil,
"kind": "NON_NULL",
"ofType": map[string]interface{}{
"name": "SimpleMutationInput",
"kind": "INPUT_OBJECT",
},
},
},
},
"type": map[string]interface{}{
"name": "SimpleMutationPayload",
"kind": "OBJECT",
},
},
map[string]interface{}{
"name": "simplePromiseMutation",
"args": []interface{}{
map[string]interface{}{
"name": "input",
"type": map[string]interface{}{
"name": nil,
"kind": "NON_NULL",
"ofType": map[string]interface{}{
"name": "SimplePromiseMutationInput",
"kind": "INPUT_OBJECT",
},
},
},
},
"type": map[string]interface{}{
"name": "SimplePromiseMutationPayload",
"kind": "OBJECT",
},
},
},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: mutationTestSchema,
RequestString: query,
})
if !testutil.ContainSubset(result.Data.(map[string]interface{}), expected.Data.(map[string]interface{})) {
t.Fatalf("unexpected, result does not contain subset of expected data")
}
}
func TestPluralIdentifyingRootField_CorrectlyIntrospects(t *testing.T) {
query := `{
__schema {
queryType {
fields {
name
args {
name
type {
kind
ofType {
kind
ofType {
kind
ofType {
name
kind
}
}
}
}
}
type {
kind
ofType {
name
kind
}
}
}
}
}
}`
expected := &graphql.Result{
Data: map[string]interface{}{
"__schema": map[string]interface{}{
"queryType": map[string]interface{}{
"fields": []interface{}{
map[string]interface{}{
"name": "usernames",
"args": []interface{}{
map[string]interface{}{
"name": "usernames",
"type": map[string]interface{}{
"kind": "NON_NULL",
"ofType": map[string]interface{}{
"kind": "LIST",
"ofType": map[string]interface{}{
"kind": "NON_NULL",
"ofType": map[string]interface{}{
"name": "String",
"kind": "SCALAR",
},
},
},
},
},
},
"type": map[string]interface{}{
"kind": "LIST",
"ofType": map[string]interface{}{
"name": "User",
"kind": "OBJECT",
},
},
},
},
},
},
},
}
result := graphql.Graphql(graphql.Params{
Schema: pluralTestSchema,
RequestString: query,
})
if !reflect.DeepEqual(result, expected) {
t.Fatalf("wrong result, graphql result diff: %v", testutil.Diff(expected, result))
}
}