1package api
2
3import (
4	"testing"
5
6	"github.com/stretchr/testify/require"
7)
8
9func TestAPI_ConfigEntries_IngressGateway(t *testing.T) {
10	t.Parallel()
11	c, s := makeClient(t)
12	defer s.Stop()
13
14	config_entries := c.ConfigEntries()
15
16	ingress1 := &IngressGatewayConfigEntry{
17		Kind: IngressGateway,
18		Name: "foo",
19		Meta: map[string]string{
20			"foo": "bar",
21			"gir": "zim",
22		},
23	}
24
25	ingress2 := &IngressGatewayConfigEntry{
26		Kind: IngressGateway,
27		Name: "bar",
28		TLS: GatewayTLSConfig{
29			Enabled: true,
30		},
31	}
32
33	global := &ProxyConfigEntry{
34		Kind: ProxyDefaults,
35		Name: ProxyConfigGlobal,
36		Config: map[string]interface{}{
37			"protocol": "http",
38		},
39	}
40	// set default protocol to http so that ingress gateways pass validation
41	_, wm, err := config_entries.Set(global, nil)
42	require.NoError(t, err)
43	require.NotNil(t, wm)
44	require.NotEqual(t, 0, wm.RequestTime)
45
46	// set it
47	_, wm, err = config_entries.Set(ingress1, nil)
48	require.NoError(t, err)
49	require.NotNil(t, wm)
50	require.NotEqual(t, 0, wm.RequestTime)
51
52	// also set the second one
53	_, wm, err = config_entries.Set(ingress2, nil)
54	require.NoError(t, err)
55	require.NotNil(t, wm)
56	require.NotEqual(t, 0, wm.RequestTime)
57
58	// get it
59	entry, qm, err := config_entries.Get(IngressGateway, "foo", nil)
60	require.NoError(t, err)
61	require.NotNil(t, qm)
62	require.NotEqual(t, 0, qm.RequestTime)
63
64	// verify it
65	readIngress, ok := entry.(*IngressGatewayConfigEntry)
66	require.True(t, ok)
67	require.Equal(t, ingress1.Kind, readIngress.Kind)
68	require.Equal(t, ingress1.Name, readIngress.Name)
69	require.Equal(t, ingress1.Meta, readIngress.Meta)
70	require.Equal(t, ingress1.Meta, readIngress.GetMeta())
71
72	// update it
73	ingress1.Listeners = []IngressListener{
74		{
75			Port:     2222,
76			Protocol: "http",
77			Services: []IngressService{
78				{
79					Name:  "asdf",
80					Hosts: []string{"test.example.com"},
81				},
82			},
83		},
84	}
85
86	// CAS fail
87	written, _, err := config_entries.CAS(ingress1, 0, nil)
88	require.NoError(t, err)
89	require.False(t, written)
90
91	// CAS success
92	written, wm, err = config_entries.CAS(ingress1, readIngress.ModifyIndex, nil)
93	require.NoError(t, err)
94	require.NotNil(t, wm)
95	require.NotEqual(t, 0, wm.RequestTime)
96	require.True(t, written)
97
98	// update no cas
99	ingress2.Listeners = []IngressListener{
100		{
101			Port:     3333,
102			Protocol: "http",
103			Services: []IngressService{
104				{
105					Name: "qwer",
106				},
107			},
108		},
109	}
110	_, wm, err = config_entries.Set(ingress2, nil)
111	require.NoError(t, err)
112	require.NotNil(t, wm)
113	require.NotEqual(t, 0, wm.RequestTime)
114
115	// list them
116	entries, qm, err := config_entries.List(IngressGateway, nil)
117	require.NoError(t, err)
118	require.NotNil(t, qm)
119	require.NotEqual(t, 0, qm.RequestTime)
120	require.Len(t, entries, 2)
121
122	for _, entry = range entries {
123		switch entry.GetName() {
124		case "foo":
125			// this also verifies that the update value was persisted and
126			// the updated values are seen
127			readIngress, ok = entry.(*IngressGatewayConfigEntry)
128			require.True(t, ok)
129			require.Equal(t, ingress1.Kind, readIngress.Kind)
130			require.Equal(t, ingress1.Name, readIngress.Name)
131
132			require.Len(t, readIngress.Listeners, 1)
133			require.Len(t, readIngress.Listeners[0].Services, 1)
134			// Set namespace to blank so that OSS and ent can utilize the same tests
135			readIngress.Listeners[0].Services[0].Namespace = ""
136
137			require.Equal(t, ingress1.Listeners, readIngress.Listeners)
138		case "bar":
139			readIngress, ok = entry.(*IngressGatewayConfigEntry)
140			require.True(t, ok)
141			require.Equal(t, ingress2.Kind, readIngress.Kind)
142			require.Equal(t, ingress2.Name, readIngress.Name)
143			require.Len(t, readIngress.Listeners, 1)
144			require.Len(t, readIngress.Listeners[0].Services, 1)
145			// Set namespace to blank so that OSS and ent can utilize the same tests
146			readIngress.Listeners[0].Services[0].Namespace = ""
147
148			require.Equal(t, ingress2.Listeners, readIngress.Listeners)
149		}
150	}
151
152	// delete it
153	wm, err = config_entries.Delete(IngressGateway, "foo", nil)
154	require.NoError(t, err)
155	require.NotNil(t, wm)
156	require.NotEqual(t, 0, wm.RequestTime)
157
158	// verify deletion
159	_, _, err = config_entries.Get(IngressGateway, "foo", nil)
160	require.Error(t, err)
161}
162
163func TestAPI_ConfigEntries_TerminatingGateway(t *testing.T) {
164	t.Parallel()
165	c, s := makeClient(t)
166	defer s.Stop()
167
168	configEntries := c.ConfigEntries()
169
170	terminating1 := &TerminatingGatewayConfigEntry{
171		Kind: TerminatingGateway,
172		Name: "foo",
173		Meta: map[string]string{
174			"foo": "bar",
175			"gir": "zim",
176		},
177	}
178
179	terminating2 := &TerminatingGatewayConfigEntry{
180		Kind: TerminatingGateway,
181		Name: "bar",
182	}
183
184	// set it
185	_, wm, err := configEntries.Set(terminating1, nil)
186	require.NoError(t, err)
187	require.NotNil(t, wm)
188	require.NotEqual(t, 0, wm.RequestTime)
189
190	// also set the second one
191	_, wm, err = configEntries.Set(terminating2, nil)
192	require.NoError(t, err)
193	require.NotNil(t, wm)
194	require.NotEqual(t, 0, wm.RequestTime)
195
196	// get it
197	entry, qm, err := configEntries.Get(TerminatingGateway, "foo", nil)
198	require.NoError(t, err)
199	require.NotNil(t, qm)
200	require.NotEqual(t, 0, qm.RequestTime)
201
202	// verify it
203	readTerminating, ok := entry.(*TerminatingGatewayConfigEntry)
204	require.True(t, ok)
205	require.Equal(t, terminating1.Kind, readTerminating.Kind)
206	require.Equal(t, terminating1.Name, readTerminating.Name)
207	require.Equal(t, terminating1.Meta, readTerminating.Meta)
208	require.Equal(t, terminating1.Meta, readTerminating.GetMeta())
209
210	// update it
211	terminating1.Services = []LinkedService{
212		{
213			Name:     "web",
214			CAFile:   "/etc/web/ca.crt",
215			CertFile: "/etc/web/client.crt",
216			KeyFile:  "/etc/web/tls.key",
217			SNI:      "mydomain",
218		},
219	}
220
221	// CAS fail
222	written, _, err := configEntries.CAS(terminating1, 0, nil)
223	require.NoError(t, err)
224	require.False(t, written)
225
226	// CAS success
227	written, wm, err = configEntries.CAS(terminating1, readTerminating.ModifyIndex, nil)
228	require.NoError(t, err)
229	require.NotNil(t, wm)
230	require.NotEqual(t, 0, wm.RequestTime)
231	require.True(t, written)
232
233	// re-setting should not yield an error
234	_, wm, err = configEntries.Set(terminating1, nil)
235	require.NoError(t, err)
236	require.NotNil(t, wm)
237	require.NotEqual(t, 0, wm.RequestTime)
238
239	terminating2.Services = []LinkedService{
240		{
241			Name:     "*",
242			CAFile:   "/etc/certs/ca.crt",
243			CertFile: "/etc/certs/client.crt",
244			KeyFile:  "/etc/certs/tls.key",
245			SNI:      "mydomain",
246		},
247	}
248	_, wm, err = configEntries.Set(terminating2, nil)
249	require.NoError(t, err)
250	require.NotNil(t, wm)
251	require.NotEqual(t, 0, wm.RequestTime)
252
253	// list them
254	entries, qm, err := configEntries.List(TerminatingGateway, nil)
255	require.NoError(t, err)
256	require.NotNil(t, qm)
257	require.NotEqual(t, 0, qm.RequestTime)
258	require.Len(t, entries, 2)
259
260	for _, entry = range entries {
261		switch entry.GetName() {
262		case "foo":
263			// this also verifies that the update value was persisted and
264			// the updated values are seen
265			readTerminating, ok = entry.(*TerminatingGatewayConfigEntry)
266			require.True(t, ok)
267			require.Equal(t, terminating1.Kind, readTerminating.Kind)
268			require.Equal(t, terminating1.Name, readTerminating.Name)
269			require.Len(t, readTerminating.Services, 1)
270			// Set namespace to blank so that OSS and ent can utilize the same tests
271			readTerminating.Services[0].Namespace = ""
272
273			require.Equal(t, terminating1.Services, readTerminating.Services)
274		case "bar":
275			readTerminating, ok = entry.(*TerminatingGatewayConfigEntry)
276			require.True(t, ok)
277			require.Equal(t, terminating2.Kind, readTerminating.Kind)
278			require.Equal(t, terminating2.Name, readTerminating.Name)
279			require.Len(t, readTerminating.Services, 1)
280			// Set namespace to blank so that OSS and ent can utilize the same tests
281			readTerminating.Services[0].Namespace = ""
282
283			require.Equal(t, terminating2.Services, readTerminating.Services)
284		}
285	}
286
287	// delete it
288	wm, err = configEntries.Delete(TerminatingGateway, "foo", nil)
289	require.NoError(t, err)
290	require.NotNil(t, wm)
291	require.NotEqual(t, 0, wm.RequestTime)
292
293	// verify deletion
294	_, _, err = configEntries.Get(TerminatingGateway, "foo", nil)
295	require.Error(t, err)
296}
297