1// Copyright 2021 MongoDB Inc
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//      http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package mongodbatlas
16
17import (
18	"encoding/json"
19	"fmt"
20	"net/http"
21	"testing"
22
23	"github.com/go-test/deep"
24)
25
26func TestPeers_ListPeers(t *testing.T) {
27	client, mux, teardown := setup()
28	defer teardown()
29
30	mux.HandleFunc("/groups/1/peers", func(w http.ResponseWriter, r *http.Request) {
31		testMethod(t, r, http.MethodGet)
32		fmt.Fprint(w, `{
33			"results": [
34				{
35					"containerId": "507f1f77bcf86cd799439011",
36					"gcpProjectId": "my-sample-project-191923",
37					"id": "1112222b3bf99403840e8934",
38					"networkName": "test1",
39					"status": "ADDING_PEER"
40				},
41				{
42					"containerId": "507f1f77bcf86cd799439011",
43					"gcpProjectId": "my-sample-project-191923",
44					"id": "1112222b3bf99403840e8934",
45					"networkName": "test1",
46					"status": "ADDING_PEER"
47				}
48			],
49			"totalCount": 2
50		}`)
51	})
52
53	peers, _, err := client.Peers.List(ctx, "1", nil)
54	if err != nil {
55		t.Fatalf("Peers.List returned error: %v", err)
56	}
57
58	peer := Peer{
59		ContainerID:  "507f1f77bcf86cd799439011",
60		GCPProjectID: "my-sample-project-191923",
61		ID:           "1112222b3bf99403840e8934",
62		NetworkName:  "test1",
63		Status:       "ADDING_PEER",
64	}
65
66	expected := []Peer{peer, peer}
67	if diff := deep.Equal(peers, expected); diff != nil {
68		t.Error(diff)
69	}
70}
71
72func TestPeers_ListPeersMultiplePages(t *testing.T) {
73	client, mux, teardown := setup()
74	defer teardown()
75
76	mux.HandleFunc("/groups/1/peers", func(w http.ResponseWriter, r *http.Request) {
77		testMethod(t, r, http.MethodGet)
78
79		dr := peersResponse{
80			Results: []Peer{
81				{
82					ContainerID:  "507f1f77bcf86cd799439011",
83					GCPProjectID: "my-sample-project-191923",
84					ID:           "1112222b3bf99403840e8934",
85					NetworkName:  "test1",
86					Status:       "ADDING_PEER",
87				},
88				{
89					ContainerID:  "507f1f77bcf86cd799439011",
90					GCPProjectID: "my-sample-project-191923",
91					ID:           "1112222b3bf99403840e8935",
92					NetworkName:  "test1",
93					Status:       "ADDING_PEER",
94				},
95			},
96			Links: []*Link{
97				{Href: "http://example.com/api/atlas/v1.0/groups/1/peers?pageNum=2&itemsPerPage=2", Rel: "self"},
98				{Href: "http://example.com/api/atlas/v1.0/groups/1/peers?pageNum=2&itemsPerPage=2", Rel: "previous"},
99			},
100		}
101
102		b, err := json.Marshal(dr)
103		if err != nil {
104			t.Fatal(err)
105		}
106		fmt.Fprint(w, string(b))
107	})
108
109	_, resp, err := client.Peers.List(ctx, "1", nil)
110	if err != nil {
111		t.Fatal(err)
112	}
113
114	checkCurrentPage(t, resp, 2)
115}
116
117func TestPeers_RetrievePageByNumber(t *testing.T) {
118	client, mux, teardown := setup()
119	defer teardown()
120
121	jBlob := `
122	{
123		"links": [
124			{
125				"href": "http://example.com/api/atlas/v1.0/groups/1/peers?pageNum=1&itemsPerPage=1",
126				"rel": "previous"
127			},
128			{
129				"href": "http://example.com/api/atlas/v1.0/groups/1/peers?pageNum=2&itemsPerPage=1",
130				"rel": "self"
131			},
132			{
133				"href": "http://example.com/api/atlas/v1.0/groups/1/peers?itemsPerPage=3&pageNum=2",
134				"rel": "next"
135			}
136		],
137		"results": [
138			{
139				"containerId": "507f1f77bcf86cd799439011",
140				"gcpProjectId": "my-sample-project-191923",
141				"id": "1112222b3bf99403840e8934",
142				"networkName": "test1",
143				"status": "ADDING_PEER"
144			}
145		],
146		"totalCount": 3
147	}`
148
149	mux.HandleFunc("/groups/1/peers", func(w http.ResponseWriter, r *http.Request) {
150		testMethod(t, r, http.MethodGet)
151		fmt.Fprint(w, jBlob)
152	})
153
154	opt := &ContainersListOptions{
155		ListOptions: ListOptions{
156			PageNum: 2,
157		},
158	}
159	_, resp, err := client.Peers.List(ctx, "1", opt)
160
161	if err != nil {
162		t.Fatal(err)
163	}
164
165	checkCurrentPage(t, resp, 2)
166}
167
168func TestPeers_Create(t *testing.T) {
169	client, mux, teardown := setup()
170	defer teardown()
171
172	groupID := "1"
173
174	createRequest := &Peer{
175		ContainerID:  "507f1f77bcf86cd799439011",
176		GCPProjectID: "my-sample-project-191923",
177		ID:           "1112222b3bf99403840e8934",
178		NetworkName:  "test1",
179		Status:       "ADDING_PEER",
180	}
181
182	mux.HandleFunc(fmt.Sprintf("/groups/%s/peers", groupID), func(w http.ResponseWriter, r *http.Request) {
183		expected := map[string]interface{}{
184			"containerId":  "507f1f77bcf86cd799439011",
185			"gcpProjectId": "my-sample-project-191923",
186			"id":           "1112222b3bf99403840e8934",
187			"networkName":  "test1",
188			"status":       "ADDING_PEER",
189		}
190
191		jsonBlob := `
192		{
193			"containerId":  "507f1f77bcf86cd799439011",
194			"gcpProjectId": "my-sample-project-191923",
195			"id":           "1112222b3bf99403840e8934",
196			"networkName":  "test1",
197			"status":       "ADDING_PEER"
198		}
199		`
200
201		var v map[string]interface{}
202		err := json.NewDecoder(r.Body).Decode(&v)
203		if err != nil {
204			t.Fatalf("decode json: %v", err)
205		}
206		if diff := deep.Equal(v, expected); diff != nil {
207			t.Error(diff)
208		}
209
210		fmt.Fprint(w, jsonBlob)
211	})
212
213	peer, _, err := client.Peers.Create(ctx, groupID, createRequest)
214	if err != nil {
215		t.Fatalf("Peers.Create returned error: %v", err)
216	}
217
218	expectedCID := "507f1f77bcf86cd799439011"
219	expectedGCPID := "my-sample-project-191923"
220
221	if cID := peer.ContainerID; cID != expectedCID {
222		t.Errorf("expected containerId '%s', received '%s'", expectedCID, cID)
223	}
224
225	if id := peer.GCPProjectID; id != expectedGCPID {
226		t.Errorf("expected gcpProjectId '%s', received '%s'", expectedGCPID, id)
227	}
228}
229
230func TestPeers_Update(t *testing.T) {
231	client, mux, teardown := setup()
232	defer teardown()
233
234	groupID := "1"
235	peerID := "1112222b3bf99403840e8934"
236
237	updateRequest := &Peer{
238		ContainerID:  "507f1f77bcf86cd799439011",
239		GCPProjectID: "my-sample-project-191923",
240		ID:           "1112222b3bf99403840e8934",
241		NetworkName:  "test1",
242		Status:       "ADDING_PEER",
243	}
244
245	mux.HandleFunc(fmt.Sprintf("/groups/%s/peers/%s", groupID, peerID), func(w http.ResponseWriter, r *http.Request) {
246		expected := map[string]interface{}{
247			"containerId":  "507f1f77bcf86cd799439011",
248			"gcpProjectId": "my-sample-project-191923",
249			"id":           "1112222b3bf99403840e8934",
250			"networkName":  "test1",
251			"status":       "ADDING_PEER",
252		}
253
254		jsonBlob := `
255		{
256			"containerId":  "507f1f77bcf86cd799439011",
257			"gcpProjectId": "my-sample-project-191923",
258			"id":           "1112222b3bf99403840e8934",
259			"networkName":  "test1",
260			"status":       "ADDING_PEER"
261		}
262		`
263
264		var v map[string]interface{}
265		err := json.NewDecoder(r.Body).Decode(&v)
266		if err != nil {
267			t.Fatalf("decode json: %v", err)
268		}
269
270		if diff := deep.Equal(v, expected); diff != nil {
271			t.Errorf("Peers.Update Request Body = %v", diff)
272		}
273
274		fmt.Fprint(w, jsonBlob)
275	})
276
277	perr, _, err := client.Peers.Update(ctx, groupID, peerID, updateRequest)
278	if err != nil {
279		t.Fatalf("Peers.Update returned error: %v", err)
280	}
281
282	if pID := perr.ID; pID != peerID {
283		t.Errorf("expected peerID '%s', received '%s'", peerID, pID)
284	}
285
286	expectedGCPID := "my-sample-project-191923"
287
288	if id := perr.GCPProjectID; id != expectedGCPID {
289		t.Errorf("expected groupId '%s', received '%s'", expectedGCPID, id)
290	}
291}
292
293func TestPeers_Delete(t *testing.T) {
294	client, mux, teardown := setup()
295	defer teardown()
296
297	groupID := "1"
298	id := "1112222b3bf99403840e8934"
299
300	mux.HandleFunc(fmt.Sprintf("/groups/%s/peers/%s", groupID, id), func(w http.ResponseWriter, r *http.Request) {
301		testMethod(t, r, http.MethodDelete)
302	})
303
304	_, err := client.Peers.Delete(ctx, groupID, id)
305	if err != nil {
306		t.Fatalf("Peer.Delete returned error: %v", err)
307	}
308}
309