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