1 package integration_test
2
3 import (
4 "fmt"
5
6 "github.com/udacity/graphb"
7
8 "edge-infra.dev/pkg/edge/api/graph/model"
9 sqlquery "edge-infra.dev/pkg/edge/api/sql"
10 "edge-infra.dev/test/framework/integration"
11 )
12
13 func (s *Suite) TestCreateNamespace() {
14 integration.SkipIf(s.Framework)
15 var response struct{ CreateNamespace *model.Namespace }
16
17 createNamespace := model.NamespaceCreateInput{
18 BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102",
19 Name: "test-namespace-A",
20 Workload: model.WorkloadTypeTenant,
21 }
22
23 mutation := createNamespaceMutation(&createNamespace)
24
25 err := ResolverClient.Post(mutation, &response)
26 s.NoErrorf(err, "error resolving namespace mutation")
27
28 s.NotNilf(response.CreateNamespace, "returned namespace is null")
29 namespace := response.CreateNamespace
30 s.Equal(createNamespace.BannerEdgeID, namespace.BannerEdgeID)
31 s.Equal(createNamespace.Name, namespace.Name)
32 s.Equal(createNamespace.Workload, namespace.Workload)
33
34 args := []interface{}{
35 createNamespace.BannerEdgeID,
36 createNamespace.Name,
37 }
38 _, err = s.DB.Exec(sqlquery.NamespaceDeleteQuery, args...)
39 s.NoError(err)
40 }
41
42 func (s *Suite) TestCreateNamespaceInvalidBanner() {
43 integration.SkipIf(s.Framework)
44 var response struct{ CreateNamespace *model.Namespace }
45
46 createNamespace := model.NamespaceCreateInput{
47 BannerEdgeID: "banner",
48 Name: "some-namespace",
49 Workload: model.WorkloadTypeTenant,
50 }
51
52 mutation := createNamespaceMutation(&createNamespace)
53
54 err := ResolverClient.Post(mutation, &response)
55 s.Errorf(err, "no error resolving namespace mutation")
56 s.Nilf(response.CreateNamespace, "returned namespace is not null")
57 }
58
59 func (s *Suite) TestCreateNamespaceInvalidName() {
60 integration.SkipIf(s.Framework)
61 var response struct{ CreateNamespace *model.Namespace }
62
63 createNamespace := model.NamespaceCreateInput{
64 BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102",
65 Name: "",
66 Workload: model.WorkloadTypeTenant,
67 }
68
69 mutation := createNamespaceMutation(&createNamespace)
70
71 err := ResolverClient.Post(mutation, &response)
72 s.Errorf(err, "no error resolving namespace mutation")
73 s.Nilf(response.CreateNamespace, "returned namespace is not null")
74 }
75
76 func (s *Suite) TestCreateNamespaceExistingNameOnBanner() {
77 integration.SkipIf(s.Framework)
78 var response struct{ CreateNamespace *model.Namespace }
79
80 createNamespace := model.NamespaceCreateInput{
81 BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101",
82 Name: "test-namespace",
83 Workload: model.WorkloadTypeTenant,
84 }
85
86 mutation := createNamespaceMutation(&createNamespace)
87
88 err := ResolverClient.Post(mutation, &response)
89 s.Errorf(err, "no error resolving namespace mutation")
90 s.Nilf(response.CreateNamespace, "returned namespace is not null")
91 }
92
93 func (s *Suite) TestDeleteNamespace() {
94 integration.SkipIf(s.Framework)
95 var response struct{ DeleteNamespace bool }
96 bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
97 name := "delete-namespace"
98 mutation := deleteNamespaceMutation(bannerEdgeID, name)
99 err := ResolverClient.Post(mutation, &response)
100 s.NoErrorf(err, "resolver failed for delete namespace")
101 s.Truef(response.DeleteNamespace, "resolver returned false for delete namespace")
102 }
103
104
105 func (s *Suite) TestDeleteNamespaceInUse() {
106 integration.SkipIf(s.Framework)
107 var response struct{ DeleteNamespace bool }
108 bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
109 name := "delete-namespace-1"
110 mutation := deleteNamespaceMutation(bannerEdgeID, name)
111 err := ResolverClient.Post(mutation, &response)
112 s.Errorf(err, "resolver didn't fail for delete namespace")
113 s.Falsef(response.DeleteNamespace, "resolver didn't return false for delete namespace")
114 }
115
116
117 func (s *Suite) TestDeleteNamespaceFakeOne() {
118 integration.SkipIf(s.Framework)
119 var response struct{ DeleteNamespace bool }
120 bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
121 name := "fake-namespace"
122 mutation := deleteNamespaceMutation(bannerEdgeID, name)
123 err := ResolverClient.Post(mutation, &response)
124 s.Errorf(err, "resolver didn't fail for delete namespace (1)")
125 s.False(response.DeleteNamespace, "resolver didn't return false for delete namespace (1)")
126 }
127
128
129 func (s *Suite) TestDeleteNamespaceFakeTwo() {
130 integration.SkipIf(s.Framework)
131 var response struct{ DeleteNamespace bool }
132 bannerEdgeID := "ff2874b4-b9b1-4514-a2b0-58482f3d54fa"
133 name := "delete-namespace"
134 mutation := deleteNamespaceMutation(bannerEdgeID, name)
135 err := ResolverClient.Post(mutation, &response)
136 s.Errorf(err, "resolver didn't fail for delete namespace (2)")
137 s.Falsef(response.DeleteNamespace, "resolver didn't return false for delete namespace (2)")
138 }
139
140
141 func (s *Suite) TestGetBannerNamespaces() {
142 integration.SkipIf(s.Framework)
143 var response struct{ BannerNamespaces []*model.Namespace }
144 bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
145 name := "test-namespace"
146 query := getBannerNamespacesQuery(bannerEdgeID, &name)
147 err := ResolverClient.Post(query, &response)
148
149 s.NoErrorf(err, "resolver failed for get namespaces by bannerEdgeID and name")
150 s.NotNilf(response.BannerNamespaces, "resolver response nil for get namespaces by bannerEdgeID and name")
151 s.Equalf(1, len(response.BannerNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID and name")
152 s.Equalf("31d51d8c-b580-4e1a-94f6-a970bae8c132", response.BannerNamespaces[0].NamespaceEdgeID, "returned namespaceEdgeId incorrect")
153 }
154
155
156 func (s *Suite) TestGetAllBannerNamespaces() {
157 integration.SkipIf(s.Framework)
158 var response struct{ BannerNamespaces []*model.Namespace }
159 bannerEdgeID := "98ef1fcb-dc88-4c9f-9980-c09a04564a48"
160 query := getBannerNamespacesQuery(bannerEdgeID, nil)
161 err := ResolverClient.Post(query, &response)
162
163 s.NoErrorf(err, "resolver failed for get namespaces by bannerEdgeID")
164 s.NotNilf(response.BannerNamespaces, "resolver response nil for get namespaces by bannerEdgeID")
165 s.Equalf(2, len(response.BannerNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID")
166 }
167
168
169 func (s *Suite) TestGetClusterNamespaces() {
170 integration.SkipIf(s.Framework)
171 var response struct{ ClusterNamespaces []*model.Namespace }
172 clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
173 name := "test-namespace"
174 query := getClusterNamespacesQuery(clusterEdgeID, &name)
175 err := ResolverClient.Post(query, &response)
176
177 s.NoErrorf(err, "resolver failed for get namespaces by clusterEdgeID and name")
178 s.NotNilf(response.ClusterNamespaces, "resolver response nil for get namespaces by clusterEdgeID and name")
179 s.Equalf(1, len(response.ClusterNamespaces), "resolver response != 1 for get namespaces by clusterEdgeID and name")
180 s.Equalf("31d51d8c-b580-4e1a-94f6-a970bae8c132", response.ClusterNamespaces[0].NamespaceEdgeID, "returned clusterNamespaceEdgeId incorrect")
181 }
182
183
184 func (s *Suite) TestGetAllClusterNamespaces() {
185 integration.SkipIf(s.Framework)
186 var response struct{ ClusterNamespaces []*model.Namespace }
187 clusterEdgeID := "6e04c043-89ca-4dc2-a2ea-4605dbdd4c65"
188 query := getClusterNamespacesQuery(clusterEdgeID, nil)
189 err := ResolverClient.Post(query, &response)
190
191 s.NoErrorf(err, "resolver failed for get namespaces by clusterEdgeID")
192 s.NotNilf(response.ClusterNamespaces, "resolver response nil for get namespaces by bannerEdgeID")
193 s.Equalf(2, len(response.ClusterNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID")
194 }
195
196 func createNamespaceMutation(createNamespace *model.NamespaceCreateInput) string {
197 return fmt.Sprintf(
198 "mutation{createNamespace(createNamespace:{bannerEdgeId:\"%s\",name:\"%s\",workload:%s}){namespaceEdgeId,bannerEdgeId,name,workload}}",
199 createNamespace.BannerEdgeID, createNamespace.Name, createNamespace.Workload.String(),
200 )
201 }
202
203 func deleteNamespaceMutation(bannerEdgeID string, name string) string {
204 return MustParse(graphb.Query{
205 Type: graphb.TypeMutation,
206 Fields: []*graphb.Field{
207 {
208 Name: "deleteNamespace",
209 Arguments: []graphb.Argument{
210 graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
211 graphb.ArgumentString("name", name),
212 },
213 },
214 },
215 })
216 }
217
218 func getBannerNamespacesQuery(bannerEdgeID string, name *string) string {
219 getNamespacesArg := []graphb.Argument{
220 graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
221 }
222 if name != nil {
223 getNamespacesArg = append(getNamespacesArg, graphb.ArgumentString("name", *name))
224 }
225 return MustParse(graphb.Query{
226 Type: graphb.TypeQuery,
227 Fields: []*graphb.Field{
228 {
229 Name: "bannerNamespaces",
230 Arguments: getNamespacesArg,
231 Fields: namespaceFields,
232 },
233 },
234 })
235 }
236
237 func getClusterNamespacesQuery(clusterEdgeID string, name *string) string {
238 getClusterNamespacesArg := []graphb.Argument{
239 graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
240 }
241 if name != nil {
242 getClusterNamespacesArg = append(getClusterNamespacesArg, graphb.ArgumentString("name", *name))
243 }
244 return MustParse(graphb.Query{
245 Type: graphb.TypeQuery,
246 Fields: []*graphb.Field{
247 {
248 Name: "clusterNamespaces",
249 Arguments: getClusterNamespacesArg,
250 Fields: namespaceFields,
251 },
252 },
253 })
254 }
255
256 var namespaceFields = []*graphb.Field{
257 {
258 Name: "namespaceEdgeId",
259 },
260 {
261 Name: "bannerEdgeId",
262 },
263 {
264 Name: "name",
265 },
266 {
267 Name: "workload",
268 },
269 }
270
View as plain text