1
2 package federation
3
4 import (
5 "testing"
6
7 "github.com/stretchr/testify/require"
8
9 "github.com/99designs/gqlgen/client"
10 "github.com/99designs/gqlgen/graphql/handler"
11 "github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires"
12 "github.com/99designs/gqlgen/plugin/federation/testdata/explicitrequires/generated"
13 )
14
15 func TestExplicitRequires(t *testing.T) {
16 c := client.New(handler.NewDefaultServer(
17 generated.NewExecutableSchema(generated.Config{
18 Resolvers: &explicitrequires.Resolver{},
19 }),
20 ))
21
22 t.Run("PlanetRequires entities with requires directive", func(t *testing.T) {
23 representations := []map[string]interface{}{
24 {
25 "__typename": "PlanetRequires",
26 "name": "earth",
27 "diameter": 12,
28 }, {
29 "__typename": "PlanetRequires",
30 "name": "mars",
31 "diameter": 10,
32 },
33 }
34
35 var resp struct {
36 Entities []struct {
37 Name string `json:"name"`
38 Diameter int `json:"diameter"`
39 } `json:"_entities"`
40 }
41
42 err := c.Post(
43 entityQuery([]string{
44 "PlanetRequires {name, diameter}",
45 }),
46 &resp,
47 client.Var("representations", representations),
48 )
49
50 require.NoError(t, err)
51 require.Equal(t, resp.Entities[0].Name, "earth")
52 require.Equal(t, resp.Entities[0].Diameter, 12)
53 require.Equal(t, resp.Entities[1].Name, "mars")
54 require.Equal(t, resp.Entities[1].Diameter, 10)
55 })
56
57 t.Run("PlanetRequires entities with multiple required fields directive", func(t *testing.T) {
58 representations := []map[string]interface{}{
59 {
60 "__typename": "PlanetMultipleRequires",
61 "name": "earth",
62 "density": 800,
63 "diameter": 12,
64 }, {
65 "__typename": "PlanetMultipleRequires",
66 "name": "mars",
67 "density": 850,
68 "diameter": 10,
69 },
70 }
71
72 var resp struct {
73 Entities []struct {
74 Name string `json:"name"`
75 Density int `json:"density"`
76 Diameter int `json:"diameter"`
77 } `json:"_entities"`
78 }
79
80 err := c.Post(
81 entityQuery([]string{
82 "PlanetMultipleRequires {name, diameter, density}",
83 }),
84 &resp,
85 client.Var("representations", representations),
86 )
87
88 require.NoError(t, err)
89 require.Equal(t, resp.Entities[0].Name, "earth")
90 require.Equal(t, resp.Entities[0].Diameter, 12)
91 require.Equal(t, resp.Entities[0].Density, 800)
92 require.Equal(t, resp.Entities[1].Name, "mars")
93 require.Equal(t, resp.Entities[1].Diameter, 10)
94 require.Equal(t, resp.Entities[1].Density, 850)
95 })
96
97 t.Run("PlanetRequiresNested entities with requires directive having nested field", func(t *testing.T) {
98 representations := []map[string]interface{}{
99 {
100 "__typename": "PlanetRequiresNested",
101 "name": "earth",
102 "world": map[string]interface{}{
103 "foo": "A",
104 },
105 }, {
106 "__typename": "PlanetRequiresNested",
107 "name": "mars",
108 "world": map[string]interface{}{
109 "foo": "B",
110 },
111 },
112 }
113
114 var resp struct {
115 Entities []struct {
116 Name string `json:"name"`
117 World struct {
118 Foo string `json:"foo"`
119 } `json:"world"`
120 } `json:"_entities"`
121 }
122
123 err := c.Post(
124 entityQuery([]string{
125 "PlanetRequiresNested {name, world { foo }}",
126 }),
127 &resp,
128 client.Var("representations", representations),
129 )
130
131 require.NoError(t, err)
132 require.Equal(t, resp.Entities[0].Name, "earth")
133 require.Equal(t, resp.Entities[0].World.Foo, "A")
134 require.Equal(t, resp.Entities[1].Name, "mars")
135 require.Equal(t, resp.Entities[1].World.Foo, "B")
136 })
137 }
138
139 func TestMultiExplicitRequires(t *testing.T) {
140 c := client.New(handler.NewDefaultServer(
141 generated.NewExecutableSchema(generated.Config{
142 Resolvers: &explicitrequires.Resolver{},
143 }),
144 ))
145
146 t.Run("MultiHelloRequires entities with requires directive", func(t *testing.T) {
147 representations := []map[string]interface{}{
148 {
149 "__typename": "MultiHelloRequires",
150 "name": "first name - 1",
151 "key1": "key1 - 1",
152 }, {
153 "__typename": "MultiHelloRequires",
154 "name": "first name - 2",
155 "key1": "key1 - 2",
156 },
157 }
158
159 var resp struct {
160 Entities []struct {
161 Name string `json:"name"`
162 Key1 string `json:"key1"`
163 } `json:"_entities"`
164 }
165
166 err := c.Post(
167 entityQuery([]string{
168 "MultiHelloRequires {name, key1}",
169 }),
170 &resp,
171 client.Var("representations", representations),
172 )
173
174 require.NoError(t, err)
175 require.Equal(t, resp.Entities[0].Name, "first name - 1")
176 require.Equal(t, resp.Entities[0].Key1, "key1 - 1")
177 require.Equal(t, resp.Entities[1].Name, "first name - 2")
178 require.Equal(t, resp.Entities[1].Key1, "key1 - 2")
179 })
180
181 t.Run("MultiHelloMultipleRequires entities with multiple required fields", func(t *testing.T) {
182 representations := []map[string]interface{}{
183 {
184 "__typename": "MultiHelloMultipleRequires",
185 "name": "first name - 1",
186 "key1": "key1 - 1",
187 "key2": "key2 - 1",
188 }, {
189 "__typename": "MultiHelloMultipleRequires",
190 "name": "first name - 2",
191 "key1": "key1 - 2",
192 "key2": "key2 - 2",
193 },
194 }
195
196 var resp struct {
197 Entities []struct {
198 Name string `json:"name"`
199 Key1 string `json:"key1"`
200 Key2 string `json:"key2"`
201 } `json:"_entities"`
202 }
203
204 err := c.Post(
205 entityQuery([]string{
206 "MultiHelloMultipleRequires {name, key1, key2}",
207 }),
208 &resp,
209 client.Var("representations", representations),
210 )
211
212 require.NoError(t, err)
213 require.Equal(t, resp.Entities[0].Name, "first name - 1")
214 require.Equal(t, resp.Entities[0].Key1, "key1 - 1")
215 require.Equal(t, resp.Entities[0].Key2, "key2 - 1")
216 require.Equal(t, resp.Entities[1].Name, "first name - 2")
217 require.Equal(t, resp.Entities[1].Key1, "key1 - 2")
218 require.Equal(t, resp.Entities[1].Key2, "key2 - 2")
219 })
220
221 t.Run("MultiPlanetRequiresNested entities with requires directive having nested field", func(t *testing.T) {
222 representations := []map[string]interface{}{
223 {
224 "__typename": "MultiPlanetRequiresNested",
225 "name": "earth",
226 "world": map[string]interface{}{
227 "foo": "A",
228 },
229 }, {
230 "__typename": "MultiPlanetRequiresNested",
231 "name": "mars",
232 "world": map[string]interface{}{
233 "foo": "B",
234 },
235 },
236 }
237
238 var resp struct {
239 Entities []struct {
240 Name string `json:"name"`
241 World struct {
242 Foo string `json:"foo"`
243 } `json:"world"`
244 } `json:"_entities"`
245 }
246
247 err := c.Post(
248 entityQuery([]string{
249 "MultiPlanetRequiresNested {name, world { foo }}",
250 }),
251 &resp,
252 client.Var("representations", representations),
253 )
254
255 require.NoError(t, err)
256 require.Equal(t, resp.Entities[0].Name, "earth")
257 require.Equal(t, resp.Entities[0].World.Foo, "A")
258 require.Equal(t, resp.Entities[1].Name, "mars")
259 require.Equal(t, resp.Entities[1].World.Foo, "B")
260 })
261 }
262
View as plain text