1package graphql
2
3import (
4	"testing"
5)
6
7func TestIsEqualType_SameReferenceAreEqual(t *testing.T) {
8	if !isEqualType(String, String) {
9		t.Fatalf("Expected same reference to be equal")
10	}
11}
12
13func TestIsEqualType_IntAndFloatAreNotEqual(t *testing.T) {
14	if isEqualType(Int, Float) {
15		t.Fatalf("Expected GraphQLInt and GraphQLFloat to not equal")
16	}
17}
18
19func TestIsEqualType_ListsOfSameTypeAreEqual(t *testing.T) {
20	if !isEqualType(NewList(Int), NewList(Int)) {
21		t.Fatalf("Expected lists of same type are equal")
22	}
23}
24
25func TestIsEqualType_ListsAreNotEqualToItem(t *testing.T) {
26	if isEqualType(NewList(Int), Int) {
27		t.Fatalf("Expected lists are not equal to item")
28	}
29}
30
31func TestIsEqualType_NonNullOfSameTypeAreEqual(t *testing.T) {
32	if !isEqualType(NewNonNull(Int), NewNonNull(Int)) {
33		t.Fatalf("Expected non-null of same type are equal")
34	}
35}
36func TestIsEqualType_NonNullIsNotEqualToNullable(t *testing.T) {
37	if isEqualType(NewNonNull(Int), Int) {
38		t.Fatalf("Expected non-null is not equal to nullable")
39	}
40}
41
42func testSchemaForIsTypeSubTypeOfTest(t *testing.T, fields Fields) *Schema {
43	schema, err := NewSchema(SchemaConfig{
44		Query: NewObject(ObjectConfig{
45			Name:   "Query",
46			Fields: fields,
47		}),
48	})
49	if err != nil {
50		t.Fatalf("Invalid schema: %v", err)
51	}
52	return &schema
53}
54
55func TestIsTypeSubTypeOf_SameReferenceIsSubtype(t *testing.T) {
56	schema := testSchemaForIsTypeSubTypeOfTest(t, Fields{
57		"field": &Field{Type: String},
58	})
59	if !isTypeSubTypeOf(schema, String, String) {
60		t.Fatalf("Expected same reference is subtype")
61	}
62}
63func TestIsTypeSubTypeOf_IntIsNotSubtypeOfFloat(t *testing.T) {
64	schema := testSchemaForIsTypeSubTypeOfTest(t, Fields{
65		"field": &Field{Type: String},
66	})
67	if isTypeSubTypeOf(schema, Int, Float) {
68		t.Fatalf("Expected int is not subtype of float")
69	}
70}
71func TestIsTypeSubTypeOf_NonNullIsSubtypeOfNullable(t *testing.T) {
72	schema := testSchemaForIsTypeSubTypeOfTest(t, Fields{
73		"field": &Field{Type: String},
74	})
75	if !isTypeSubTypeOf(schema, NewNonNull(Int), Int) {
76		t.Fatalf("Expected non-null is subtype of nullable")
77	}
78}
79func TestIsTypeSubTypeOf_NullableIsNotSubtypeOfNonNull(t *testing.T) {
80	schema := testSchemaForIsTypeSubTypeOfTest(t, Fields{
81		"field": &Field{Type: String},
82	})
83	if isTypeSubTypeOf(schema, Int, NewNonNull(Int)) {
84		t.Fatalf("Expected nullable is not subtype of non-null")
85	}
86}
87func TestIsTypeSubTypeOf_ItemIsNotSubTypeOfList(t *testing.T) {
88	schema := testSchemaForIsTypeSubTypeOfTest(t, Fields{
89		"field": &Field{Type: String},
90	})
91	if isTypeSubTypeOf(schema, Int, NewList(Int)) {
92		t.Fatalf("Expected item is not subtype of list")
93	}
94}
95func TestIsTypeSubTypeOf_ListIsNotSubtypeOfItem(t *testing.T) {
96	schema := testSchemaForIsTypeSubTypeOfTest(t, Fields{
97		"field": &Field{Type: String},
98	})
99	if isTypeSubTypeOf(schema, NewList(Int), Int) {
100		t.Fatalf("Expected list is not subtype of item")
101	}
102}
103
104func TestIsTypeSubTypeOf_MemberIsSubtypeOfUnion(t *testing.T) {
105	memberType := NewObject(ObjectConfig{
106		Name: "Object",
107		IsTypeOf: func(p IsTypeOfParams) bool {
108			return true
109		},
110		Fields: Fields{
111			"field": &Field{Type: String},
112		},
113	})
114	unionType := NewUnion(UnionConfig{
115		Name:  "Union",
116		Types: []*Object{memberType},
117	})
118	schema := testSchemaForIsTypeSubTypeOfTest(t, Fields{
119		"field": &Field{Type: unionType},
120	})
121	if !isTypeSubTypeOf(schema, memberType, unionType) {
122		t.Fatalf("Expected member is subtype of union")
123	}
124}
125
126func TestIsTypeSubTypeOf_ImplementationIsSubtypeOfInterface(t *testing.T) {
127	ifaceType := NewInterface(InterfaceConfig{
128		Name: "Interface",
129		Fields: Fields{
130			"field": &Field{Type: String},
131		},
132	})
133	implType := NewObject(ObjectConfig{
134		Name: "Object",
135		IsTypeOf: func(p IsTypeOfParams) bool {
136			return true
137		},
138		Interfaces: []*Interface{ifaceType},
139		Fields: Fields{
140			"field": &Field{Type: String},
141		},
142	})
143	schema := testSchemaForIsTypeSubTypeOfTest(t, Fields{
144		"field": &Field{Type: implType},
145	})
146	if !isTypeSubTypeOf(schema, implType, ifaceType) {
147		t.Fatalf("Expected implementation is subtype of interface")
148	}
149}
150