1package testing
2
3import (
4	"testing"
5
6	"github.com/gophercloud/gophercloud/openstack/compute/v2/extensions/secgroups"
7	"github.com/gophercloud/gophercloud/pagination"
8	th "github.com/gophercloud/gophercloud/testhelper"
9	"github.com/gophercloud/gophercloud/testhelper/client"
10)
11
12const (
13	serverID = "{serverID}"
14	groupID  = "{groupID}"
15	ruleID   = "{ruleID}"
16)
17
18func TestList(t *testing.T) {
19	th.SetupHTTP()
20	defer th.TeardownHTTP()
21
22	mockListGroupsResponse(t)
23
24	count := 0
25
26	err := secgroups.List(client.ServiceClient()).EachPage(func(page pagination.Page) (bool, error) {
27		count++
28		actual, err := secgroups.ExtractSecurityGroups(page)
29		if err != nil {
30			t.Errorf("Failed to extract users: %v", err)
31			return false, err
32		}
33
34		expected := []secgroups.SecurityGroup{
35			{
36				ID:          groupID,
37				Description: "default",
38				Name:        "default",
39				Rules:       []secgroups.Rule{},
40				TenantID:    "openstack",
41			},
42		}
43
44		th.CheckDeepEquals(t, expected, actual)
45
46		return true, nil
47	})
48
49	th.AssertNoErr(t, err)
50	th.AssertEquals(t, 1, count)
51}
52
53func TestListByServer(t *testing.T) {
54	th.SetupHTTP()
55	defer th.TeardownHTTP()
56
57	mockListGroupsByServerResponse(t, serverID)
58
59	count := 0
60
61	err := secgroups.ListByServer(client.ServiceClient(), serverID).EachPage(func(page pagination.Page) (bool, error) {
62		count++
63		actual, err := secgroups.ExtractSecurityGroups(page)
64		if err != nil {
65			t.Errorf("Failed to extract users: %v", err)
66			return false, err
67		}
68
69		expected := []secgroups.SecurityGroup{
70			{
71				ID:          groupID,
72				Description: "default",
73				Name:        "default",
74				Rules:       []secgroups.Rule{},
75				TenantID:    "openstack",
76			},
77		}
78
79		th.CheckDeepEquals(t, expected, actual)
80
81		return true, nil
82	})
83
84	th.AssertNoErr(t, err)
85	th.AssertEquals(t, 1, count)
86}
87
88func TestCreate(t *testing.T) {
89	th.SetupHTTP()
90	defer th.TeardownHTTP()
91
92	mockCreateGroupResponse(t)
93
94	opts := secgroups.CreateOpts{
95		Name:        "test",
96		Description: "something",
97	}
98
99	group, err := secgroups.Create(client.ServiceClient(), opts).Extract()
100	th.AssertNoErr(t, err)
101
102	expected := &secgroups.SecurityGroup{
103		ID:          groupID,
104		Name:        "test",
105		Description: "something",
106		TenantID:    "openstack",
107		Rules:       []secgroups.Rule{},
108	}
109	th.AssertDeepEquals(t, expected, group)
110}
111
112func TestUpdate(t *testing.T) {
113	th.SetupHTTP()
114	defer th.TeardownHTTP()
115
116	mockUpdateGroupResponse(t, groupID)
117
118	description := "new_desc"
119	opts := secgroups.UpdateOpts{
120		Name:        "new_name",
121		Description: &description,
122	}
123
124	group, err := secgroups.Update(client.ServiceClient(), groupID, opts).Extract()
125	th.AssertNoErr(t, err)
126
127	expected := &secgroups.SecurityGroup{
128		ID:          groupID,
129		Name:        "new_name",
130		Description: "something",
131		TenantID:    "openstack",
132		Rules:       []secgroups.Rule{},
133	}
134	th.AssertDeepEquals(t, expected, group)
135}
136
137func TestGet(t *testing.T) {
138	th.SetupHTTP()
139	defer th.TeardownHTTP()
140
141	mockGetGroupsResponse(t, groupID)
142
143	group, err := secgroups.Get(client.ServiceClient(), groupID).Extract()
144	th.AssertNoErr(t, err)
145
146	expected := &secgroups.SecurityGroup{
147		ID:          groupID,
148		Description: "default",
149		Name:        "default",
150		TenantID:    "openstack",
151		Rules: []secgroups.Rule{
152			{
153				FromPort:      80,
154				ToPort:        85,
155				IPProtocol:    "TCP",
156				IPRange:       secgroups.IPRange{CIDR: "0.0.0.0"},
157				Group:         secgroups.Group{TenantID: "openstack", Name: "default"},
158				ParentGroupID: groupID,
159				ID:            ruleID,
160			},
161		},
162	}
163
164	th.AssertDeepEquals(t, expected, group)
165}
166
167func TestGetNumericID(t *testing.T) {
168	th.SetupHTTP()
169	defer th.TeardownHTTP()
170
171	numericGroupID := 12345
172
173	mockGetNumericIDGroupResponse(t, numericGroupID)
174
175	group, err := secgroups.Get(client.ServiceClient(), "12345").Extract()
176	th.AssertNoErr(t, err)
177
178	expected := &secgroups.SecurityGroup{ID: "12345"}
179	th.AssertDeepEquals(t, expected, group)
180}
181
182func TestGetNumericRuleID(t *testing.T) {
183	th.SetupHTTP()
184	defer th.TeardownHTTP()
185
186	numericGroupID := 12345
187
188	mockGetNumericIDGroupRuleResponse(t, numericGroupID)
189
190	group, err := secgroups.Get(client.ServiceClient(), "12345").Extract()
191	th.AssertNoErr(t, err)
192
193	expected := &secgroups.SecurityGroup{
194		ID: "12345",
195		Rules: []secgroups.Rule{
196			{
197				ParentGroupID: "12345",
198				ID:            "12345",
199			},
200		},
201	}
202	th.AssertDeepEquals(t, expected, group)
203}
204
205func TestDelete(t *testing.T) {
206	th.SetupHTTP()
207	defer th.TeardownHTTP()
208
209	mockDeleteGroupResponse(t, groupID)
210
211	err := secgroups.Delete(client.ServiceClient(), groupID).ExtractErr()
212	th.AssertNoErr(t, err)
213}
214
215func TestAddRule(t *testing.T) {
216	th.SetupHTTP()
217	defer th.TeardownHTTP()
218
219	mockAddRuleResponse(t)
220
221	opts := secgroups.CreateRuleOpts{
222		ParentGroupID: groupID,
223		FromPort:      22,
224		ToPort:        22,
225		IPProtocol:    "TCP",
226		CIDR:          "0.0.0.0/0",
227	}
228
229	rule, err := secgroups.CreateRule(client.ServiceClient(), opts).Extract()
230	th.AssertNoErr(t, err)
231
232	expected := &secgroups.Rule{
233		FromPort:      22,
234		ToPort:        22,
235		Group:         secgroups.Group{},
236		IPProtocol:    "TCP",
237		ParentGroupID: groupID,
238		IPRange:       secgroups.IPRange{CIDR: "0.0.0.0/0"},
239		ID:            ruleID,
240	}
241
242	th.AssertDeepEquals(t, expected, rule)
243}
244
245func TestAddRuleICMPZero(t *testing.T) {
246	th.SetupHTTP()
247	defer th.TeardownHTTP()
248
249	mockAddRuleResponseICMPZero(t)
250
251	opts := secgroups.CreateRuleOpts{
252		ParentGroupID: groupID,
253		FromPort:      0,
254		ToPort:        0,
255		IPProtocol:    "ICMP",
256		CIDR:          "0.0.0.0/0",
257	}
258
259	rule, err := secgroups.CreateRule(client.ServiceClient(), opts).Extract()
260	th.AssertNoErr(t, err)
261
262	expected := &secgroups.Rule{
263		FromPort:      0,
264		ToPort:        0,
265		Group:         secgroups.Group{},
266		IPProtocol:    "ICMP",
267		ParentGroupID: groupID,
268		IPRange:       secgroups.IPRange{CIDR: "0.0.0.0/0"},
269		ID:            ruleID,
270	}
271
272	th.AssertDeepEquals(t, expected, rule)
273}
274
275func TestDeleteRule(t *testing.T) {
276	th.SetupHTTP()
277	defer th.TeardownHTTP()
278
279	mockDeleteRuleResponse(t, ruleID)
280
281	err := secgroups.DeleteRule(client.ServiceClient(), ruleID).ExtractErr()
282	th.AssertNoErr(t, err)
283}
284
285func TestAddServer(t *testing.T) {
286	th.SetupHTTP()
287	defer th.TeardownHTTP()
288
289	mockAddServerToGroupResponse(t, serverID)
290
291	err := secgroups.AddServer(client.ServiceClient(), serverID, "test").ExtractErr()
292	th.AssertNoErr(t, err)
293}
294
295func TestRemoveServer(t *testing.T) {
296	th.SetupHTTP()
297	defer th.TeardownHTTP()
298
299	mockRemoveServerFromGroupResponse(t, serverID)
300
301	err := secgroups.RemoveServer(client.ServiceClient(), serverID, "test").ExtractErr()
302	th.AssertNoErr(t, err)
303}
304