1package testing
2
3import (
4	"fmt"
5	"net/http"
6	"testing"
7
8	fake "github.com/gophercloud/gophercloud/openstack/networking/v2/common"
9	"github.com/gophercloud/gophercloud/openstack/networking/v2/subnets"
10	"github.com/gophercloud/gophercloud/pagination"
11	th "github.com/gophercloud/gophercloud/testhelper"
12)
13
14func TestList(t *testing.T) {
15	th.SetupHTTP()
16	defer th.TeardownHTTP()
17
18	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
19		th.TestMethod(t, r, "GET")
20		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
21
22		w.Header().Add("Content-Type", "application/json")
23		w.WriteHeader(http.StatusOK)
24
25		fmt.Fprintf(w, SubnetListResult)
26	})
27
28	count := 0
29
30	subnets.List(fake.ServiceClient(), subnets.ListOpts{}).EachPage(func(page pagination.Page) (bool, error) {
31		count++
32		actual, err := subnets.ExtractSubnets(page)
33		if err != nil {
34			t.Errorf("Failed to extract subnets: %v", err)
35			return false, nil
36		}
37
38		expected := []subnets.Subnet{
39			Subnet1,
40			Subnet2,
41			Subnet3,
42			Subnet4,
43		}
44
45		th.CheckDeepEquals(t, expected, actual)
46
47		return true, nil
48	})
49
50	if count != 1 {
51		t.Errorf("Expected 1 page, got %d", count)
52	}
53}
54
55func TestGet(t *testing.T) {
56	th.SetupHTTP()
57	defer th.TeardownHTTP()
58
59	th.Mux.HandleFunc("/v2.0/subnets/54d6f61d-db07-451c-9ab3-b9609b6b6f0b", func(w http.ResponseWriter, r *http.Request) {
60		th.TestMethod(t, r, "GET")
61		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
62
63		w.Header().Add("Content-Type", "application/json")
64		w.WriteHeader(http.StatusOK)
65
66		fmt.Fprintf(w, SubnetGetResult)
67	})
68
69	s, err := subnets.Get(fake.ServiceClient(), "54d6f61d-db07-451c-9ab3-b9609b6b6f0b").Extract()
70	th.AssertNoErr(t, err)
71
72	th.AssertEquals(t, s.Name, "my_subnet")
73	th.AssertEquals(t, s.EnableDHCP, true)
74	th.AssertEquals(t, s.NetworkID, "d32019d3-bc6e-4319-9c1d-6722fc136a22")
75	th.AssertEquals(t, s.TenantID, "4fd44f30292945e481c7b8a0c8908869")
76	th.AssertDeepEquals(t, s.DNSNameservers, []string{})
77	th.AssertDeepEquals(t, s.AllocationPools, []subnets.AllocationPool{
78		{
79			Start: "192.0.0.2",
80			End:   "192.255.255.254",
81		},
82	})
83	th.AssertDeepEquals(t, s.HostRoutes, []subnets.HostRoute{})
84	th.AssertEquals(t, s.IPVersion, 4)
85	th.AssertEquals(t, s.GatewayIP, "192.0.0.1")
86	th.AssertEquals(t, s.CIDR, "192.0.0.0/8")
87	th.AssertEquals(t, s.ID, "54d6f61d-db07-451c-9ab3-b9609b6b6f0b")
88	th.AssertEquals(t, s.SubnetPoolID, "b80340c7-9960-4f67-a99c-02501656284b")
89}
90
91func TestCreate(t *testing.T) {
92	th.SetupHTTP()
93	defer th.TeardownHTTP()
94
95	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
96		th.TestMethod(t, r, "POST")
97		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
98		th.TestHeader(t, r, "Content-Type", "application/json")
99		th.TestHeader(t, r, "Accept", "application/json")
100		th.TestJSONRequest(t, r, SubnetCreateRequest)
101
102		w.Header().Add("Content-Type", "application/json")
103		w.WriteHeader(http.StatusCreated)
104
105		fmt.Fprintf(w, SubnetCreateResult)
106	})
107
108	var gatewayIP = "192.168.199.1"
109	opts := subnets.CreateOpts{
110		NetworkID: "d32019d3-bc6e-4319-9c1d-6722fc136a22",
111		IPVersion: 4,
112		CIDR:      "192.168.199.0/24",
113		GatewayIP: &gatewayIP,
114		AllocationPools: []subnets.AllocationPool{
115			{
116				Start: "192.168.199.2",
117				End:   "192.168.199.254",
118			},
119		},
120		DNSNameservers: []string{"foo"},
121		HostRoutes: []subnets.HostRoute{
122			{NextHop: "bar"},
123		},
124		SubnetPoolID: "b80340c7-9960-4f67-a99c-02501656284b",
125	}
126	s, err := subnets.Create(fake.ServiceClient(), opts).Extract()
127	th.AssertNoErr(t, err)
128
129	th.AssertEquals(t, s.Name, "")
130	th.AssertEquals(t, s.EnableDHCP, true)
131	th.AssertEquals(t, s.NetworkID, "d32019d3-bc6e-4319-9c1d-6722fc136a22")
132	th.AssertEquals(t, s.TenantID, "4fd44f30292945e481c7b8a0c8908869")
133	th.AssertDeepEquals(t, s.DNSNameservers, []string{})
134	th.AssertDeepEquals(t, s.AllocationPools, []subnets.AllocationPool{
135		{
136			Start: "192.168.199.2",
137			End:   "192.168.199.254",
138		},
139	})
140	th.AssertDeepEquals(t, s.HostRoutes, []subnets.HostRoute{})
141	th.AssertEquals(t, s.IPVersion, 4)
142	th.AssertEquals(t, s.GatewayIP, "192.168.199.1")
143	th.AssertEquals(t, s.CIDR, "192.168.199.0/24")
144	th.AssertEquals(t, s.ID, "3b80198d-4f7b-4f77-9ef5-774d54e17126")
145	th.AssertEquals(t, s.SubnetPoolID, "b80340c7-9960-4f67-a99c-02501656284b")
146}
147
148func TestCreateNoGateway(t *testing.T) {
149	th.SetupHTTP()
150	defer th.TeardownHTTP()
151
152	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
153		th.TestMethod(t, r, "POST")
154		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
155		th.TestHeader(t, r, "Content-Type", "application/json")
156		th.TestHeader(t, r, "Accept", "application/json")
157		th.TestJSONRequest(t, r, SubnetCreateWithNoGatewayRequest)
158
159		w.Header().Add("Content-Type", "application/json")
160		w.WriteHeader(http.StatusCreated)
161
162		fmt.Fprintf(w, SubnetCreateWithNoGatewayResponse)
163	})
164
165	var noGateway = ""
166	opts := subnets.CreateOpts{
167		NetworkID: "d32019d3-bc6e-4319-9c1d-6722fc136a23",
168		IPVersion: 4,
169		CIDR:      "192.168.1.0/24",
170		GatewayIP: &noGateway,
171		AllocationPools: []subnets.AllocationPool{
172			{
173				Start: "192.168.1.2",
174				End:   "192.168.1.254",
175			},
176		},
177		DNSNameservers: []string{},
178	}
179	s, err := subnets.Create(fake.ServiceClient(), opts).Extract()
180	th.AssertNoErr(t, err)
181
182	th.AssertEquals(t, s.Name, "")
183	th.AssertEquals(t, s.EnableDHCP, true)
184	th.AssertEquals(t, s.NetworkID, "d32019d3-bc6e-4319-9c1d-6722fc136a23")
185	th.AssertEquals(t, s.TenantID, "4fd44f30292945e481c7b8a0c8908869")
186	th.AssertDeepEquals(t, s.AllocationPools, []subnets.AllocationPool{
187		{
188			Start: "192.168.1.2",
189			End:   "192.168.1.254",
190		},
191	})
192	th.AssertDeepEquals(t, s.HostRoutes, []subnets.HostRoute{})
193	th.AssertEquals(t, s.IPVersion, 4)
194	th.AssertEquals(t, s.GatewayIP, "")
195	th.AssertEquals(t, s.CIDR, "192.168.1.0/24")
196	th.AssertEquals(t, s.ID, "54d6f61d-db07-451c-9ab3-b9609b6b6f0c")
197}
198
199func TestCreateDefaultGateway(t *testing.T) {
200	th.SetupHTTP()
201	defer th.TeardownHTTP()
202
203	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
204		th.TestMethod(t, r, "POST")
205		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
206		th.TestHeader(t, r, "Content-Type", "application/json")
207		th.TestHeader(t, r, "Accept", "application/json")
208		th.TestJSONRequest(t, r, SubnetCreateWithDefaultGatewayRequest)
209
210		w.Header().Add("Content-Type", "application/json")
211		w.WriteHeader(http.StatusCreated)
212
213		fmt.Fprintf(w, SubnetCreateWithDefaultGatewayResponse)
214	})
215
216	opts := subnets.CreateOpts{
217		NetworkID: "d32019d3-bc6e-4319-9c1d-6722fc136a23",
218		IPVersion: 4,
219		CIDR:      "192.168.1.0/24",
220		AllocationPools: []subnets.AllocationPool{
221			{
222				Start: "192.168.1.2",
223				End:   "192.168.1.254",
224			},
225		},
226		DNSNameservers: []string{},
227	}
228	s, err := subnets.Create(fake.ServiceClient(), opts).Extract()
229	th.AssertNoErr(t, err)
230
231	th.AssertEquals(t, s.Name, "")
232	th.AssertEquals(t, s.EnableDHCP, true)
233	th.AssertEquals(t, s.NetworkID, "d32019d3-bc6e-4319-9c1d-6722fc136a23")
234	th.AssertEquals(t, s.TenantID, "4fd44f30292945e481c7b8a0c8908869")
235	th.AssertDeepEquals(t, s.AllocationPools, []subnets.AllocationPool{
236		{
237			Start: "192.168.1.2",
238			End:   "192.168.1.254",
239		},
240	})
241	th.AssertDeepEquals(t, s.HostRoutes, []subnets.HostRoute{})
242	th.AssertEquals(t, s.IPVersion, 4)
243	th.AssertEquals(t, s.GatewayIP, "192.168.1.1")
244	th.AssertEquals(t, s.CIDR, "192.168.1.0/24")
245	th.AssertEquals(t, s.ID, "54d6f61d-db07-451c-9ab3-b9609b6b6f0c")
246}
247
248func TestCreateIPv6RaAddressMode(t *testing.T) {
249	th.SetupHTTP()
250	defer th.TeardownHTTP()
251
252	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
253		th.TestMethod(t, r, "POST")
254		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
255		th.TestHeader(t, r, "Content-Type", "application/json")
256		th.TestHeader(t, r, "Accept", "application/json")
257		th.TestJSONRequest(t, r, SubnetCreateWithIPv6RaAddressModeRequest)
258
259		w.Header().Add("Content-Type", "application/json")
260		w.WriteHeader(http.StatusCreated)
261
262		fmt.Fprintf(w, SubnetCreateWithIPv6RaAddressModeResponse)
263	})
264
265	var gatewayIP = "2001:db8:0:a::1"
266	opts := subnets.CreateOpts{
267		NetworkID:       "d32019d3-bc6e-4319-9c1d-6722fc136a22",
268		IPVersion:       6,
269		CIDR:            "2001:db8:0:a:0:0:0:0/64",
270		GatewayIP:       &gatewayIP,
271		IPv6AddressMode: "slaac",
272		IPv6RAMode:      "slaac",
273	}
274	s, err := subnets.Create(fake.ServiceClient(), opts).Extract()
275	th.AssertNoErr(t, err)
276
277	th.AssertEquals(t, s.Name, "")
278	th.AssertEquals(t, s.EnableDHCP, true)
279	th.AssertEquals(t, s.NetworkID, "d32019d3-bc6e-4319-9c1d-6722fc136a22")
280	th.AssertEquals(t, s.TenantID, "4fd44f30292945e481c7b8a0c8908869")
281	th.AssertEquals(t, s.IPVersion, 6)
282	th.AssertEquals(t, s.GatewayIP, "2001:db8:0:a::1")
283	th.AssertEquals(t, s.CIDR, "2001:db8:0:a:0:0:0:0/64")
284	th.AssertEquals(t, s.ID, "3b80198d-4f7b-4f77-9ef5-774d54e17126")
285	th.AssertEquals(t, s.IPv6AddressMode, "slaac")
286	th.AssertEquals(t, s.IPv6RAMode, "slaac")
287}
288
289func TestCreateWithNoCIDR(t *testing.T) {
290	th.SetupHTTP()
291	defer th.TeardownHTTP()
292
293	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
294		th.TestMethod(t, r, "POST")
295		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
296		th.TestHeader(t, r, "Content-Type", "application/json")
297		th.TestHeader(t, r, "Accept", "application/json")
298		th.TestJSONRequest(t, r, SubnetCreateRequestWithNoCIDR)
299
300		w.Header().Add("Content-Type", "application/json")
301		w.WriteHeader(http.StatusCreated)
302
303		fmt.Fprintf(w, SubnetCreateResult)
304	})
305
306	opts := subnets.CreateOpts{
307		NetworkID:      "d32019d3-bc6e-4319-9c1d-6722fc136a22",
308		IPVersion:      4,
309		DNSNameservers: []string{"foo"},
310		HostRoutes: []subnets.HostRoute{
311			{NextHop: "bar"},
312		},
313		SubnetPoolID: "b80340c7-9960-4f67-a99c-02501656284b",
314	}
315	s, err := subnets.Create(fake.ServiceClient(), opts).Extract()
316	th.AssertNoErr(t, err)
317
318	th.AssertEquals(t, s.Name, "")
319	th.AssertEquals(t, s.EnableDHCP, true)
320	th.AssertEquals(t, s.NetworkID, "d32019d3-bc6e-4319-9c1d-6722fc136a22")
321	th.AssertEquals(t, s.TenantID, "4fd44f30292945e481c7b8a0c8908869")
322	th.AssertDeepEquals(t, s.DNSNameservers, []string{})
323	th.AssertDeepEquals(t, s.AllocationPools, []subnets.AllocationPool{
324		{
325			Start: "192.168.199.2",
326			End:   "192.168.199.254",
327		},
328	})
329	th.AssertDeepEquals(t, s.HostRoutes, []subnets.HostRoute{})
330	th.AssertEquals(t, s.IPVersion, 4)
331	th.AssertEquals(t, s.GatewayIP, "192.168.199.1")
332	th.AssertEquals(t, s.CIDR, "192.168.199.0/24")
333	th.AssertEquals(t, s.ID, "3b80198d-4f7b-4f77-9ef5-774d54e17126")
334	th.AssertEquals(t, s.SubnetPoolID, "b80340c7-9960-4f67-a99c-02501656284b")
335}
336
337func TestCreateWithPrefixlen(t *testing.T) {
338	th.SetupHTTP()
339	defer th.TeardownHTTP()
340
341	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
342		th.TestMethod(t, r, "POST")
343		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
344		th.TestHeader(t, r, "Content-Type", "application/json")
345		th.TestHeader(t, r, "Accept", "application/json")
346		th.TestJSONRequest(t, r, SubnetCreateRequestWithPrefixlen)
347
348		w.Header().Add("Content-Type", "application/json")
349		w.WriteHeader(http.StatusCreated)
350
351		fmt.Fprintf(w, SubnetCreateResult)
352	})
353
354	opts := subnets.CreateOpts{
355		NetworkID:      "d32019d3-bc6e-4319-9c1d-6722fc136a22",
356		IPVersion:      4,
357		DNSNameservers: []string{"foo"},
358		HostRoutes: []subnets.HostRoute{
359			{NextHop: "bar"},
360		},
361		SubnetPoolID: "b80340c7-9960-4f67-a99c-02501656284b",
362		Prefixlen:    12,
363	}
364	s, err := subnets.Create(fake.ServiceClient(), opts).Extract()
365	th.AssertNoErr(t, err)
366
367	th.AssertEquals(t, s.Name, "")
368	th.AssertEquals(t, s.EnableDHCP, true)
369	th.AssertEquals(t, s.NetworkID, "d32019d3-bc6e-4319-9c1d-6722fc136a22")
370	th.AssertEquals(t, s.TenantID, "4fd44f30292945e481c7b8a0c8908869")
371	th.AssertDeepEquals(t, s.DNSNameservers, []string{})
372	th.AssertDeepEquals(t, s.AllocationPools, []subnets.AllocationPool{
373		{
374			Start: "192.168.199.2",
375			End:   "192.168.199.254",
376		},
377	})
378	th.AssertDeepEquals(t, s.HostRoutes, []subnets.HostRoute{})
379	th.AssertEquals(t, s.IPVersion, 4)
380	th.AssertEquals(t, s.GatewayIP, "192.168.199.1")
381	th.AssertEquals(t, s.CIDR, "192.168.199.0/24")
382	th.AssertEquals(t, s.ID, "3b80198d-4f7b-4f77-9ef5-774d54e17126")
383	th.AssertEquals(t, s.SubnetPoolID, "b80340c7-9960-4f67-a99c-02501656284b")
384}
385
386func TestRequiredCreateOpts(t *testing.T) {
387	res := subnets.Create(fake.ServiceClient(), subnets.CreateOpts{})
388	if res.Err == nil {
389		t.Fatalf("Expected error, got none")
390	}
391
392	res = subnets.Create(fake.ServiceClient(), subnets.CreateOpts{NetworkID: "foo"})
393	if res.Err == nil {
394		t.Fatalf("Expected error, got none")
395	}
396
397	res = subnets.Create(fake.ServiceClient(), subnets.CreateOpts{NetworkID: "foo", CIDR: "bar", IPVersion: 40})
398	if res.Err == nil {
399		t.Fatalf("Expected error, got none")
400	}
401}
402
403func TestUpdate(t *testing.T) {
404	th.SetupHTTP()
405	defer th.TeardownHTTP()
406
407	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
408		th.TestMethod(t, r, "PUT")
409		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
410		th.TestHeader(t, r, "Content-Type", "application/json")
411		th.TestHeader(t, r, "Accept", "application/json")
412		th.TestJSONRequest(t, r, SubnetUpdateRequest)
413
414		w.Header().Add("Content-Type", "application/json")
415		w.WriteHeader(http.StatusCreated)
416
417		fmt.Fprintf(w, SubnetUpdateResponse)
418	})
419
420	dnsNameservers := []string{"foo"}
421	name := "my_new_subnet"
422	opts := subnets.UpdateOpts{
423		Name:           &name,
424		DNSNameservers: &dnsNameservers,
425		HostRoutes: &[]subnets.HostRoute{
426			{NextHop: "bar"},
427		},
428	}
429	s, err := subnets.Update(fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
430	th.AssertNoErr(t, err)
431
432	th.AssertEquals(t, s.Name, "my_new_subnet")
433	th.AssertEquals(t, s.ID, "08eae331-0402-425a-923c-34f7cfe39c1b")
434}
435
436func TestUpdateGateway(t *testing.T) {
437	th.SetupHTTP()
438	defer th.TeardownHTTP()
439
440	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
441		th.TestMethod(t, r, "PUT")
442		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
443		th.TestHeader(t, r, "Content-Type", "application/json")
444		th.TestHeader(t, r, "Accept", "application/json")
445		th.TestJSONRequest(t, r, SubnetUpdateGatewayRequest)
446
447		w.Header().Add("Content-Type", "application/json")
448		w.WriteHeader(http.StatusCreated)
449
450		fmt.Fprintf(w, SubnetUpdateGatewayResponse)
451	})
452
453	var gatewayIP = "10.0.0.1"
454	name := "my_new_subnet"
455	opts := subnets.UpdateOpts{
456		Name:      &name,
457		GatewayIP: &gatewayIP,
458	}
459	s, err := subnets.Update(fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
460	th.AssertNoErr(t, err)
461
462	th.AssertEquals(t, s.Name, "my_new_subnet")
463	th.AssertEquals(t, s.ID, "08eae331-0402-425a-923c-34f7cfe39c1b")
464	th.AssertEquals(t, s.GatewayIP, "10.0.0.1")
465}
466
467func TestUpdateRemoveGateway(t *testing.T) {
468	th.SetupHTTP()
469	defer th.TeardownHTTP()
470
471	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
472		th.TestMethod(t, r, "PUT")
473		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
474		th.TestHeader(t, r, "Content-Type", "application/json")
475		th.TestHeader(t, r, "Accept", "application/json")
476		th.TestJSONRequest(t, r, SubnetUpdateRemoveGatewayRequest)
477
478		w.Header().Add("Content-Type", "application/json")
479		w.WriteHeader(http.StatusCreated)
480
481		fmt.Fprintf(w, SubnetUpdateRemoveGatewayResponse)
482	})
483
484	var noGateway = ""
485	name := "my_new_subnet"
486	opts := subnets.UpdateOpts{
487		Name:      &name,
488		GatewayIP: &noGateway,
489	}
490	s, err := subnets.Update(fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
491	th.AssertNoErr(t, err)
492
493	th.AssertEquals(t, s.Name, "my_new_subnet")
494	th.AssertEquals(t, s.ID, "08eae331-0402-425a-923c-34f7cfe39c1b")
495	th.AssertEquals(t, s.GatewayIP, "")
496}
497
498func TestUpdateHostRoutes(t *testing.T) {
499	th.SetupHTTP()
500	defer th.TeardownHTTP()
501
502	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
503		th.TestMethod(t, r, "PUT")
504		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
505		th.TestHeader(t, r, "Content-Type", "application/json")
506		th.TestHeader(t, r, "Accept", "application/json")
507		th.TestJSONRequest(t, r, SubnetUpdateHostRoutesRequest)
508
509		w.Header().Add("Content-Type", "application/json")
510		w.WriteHeader(http.StatusCreated)
511
512		fmt.Fprintf(w, SubnetUpdateHostRoutesResponse)
513	})
514
515	HostRoutes := []subnets.HostRoute{
516		{
517			DestinationCIDR: "192.168.1.1/24",
518			NextHop:         "bar",
519		},
520	}
521
522	name := "my_new_subnet"
523	opts := subnets.UpdateOpts{
524		Name:       &name,
525		HostRoutes: &HostRoutes,
526	}
527	s, err := subnets.Update(fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
528	th.AssertNoErr(t, err)
529
530	th.AssertEquals(t, s.Name, "my_new_subnet")
531	th.AssertEquals(t, s.ID, "08eae331-0402-425a-923c-34f7cfe39c1b")
532	th.AssertDeepEquals(t, s.HostRoutes, HostRoutes)
533}
534
535func TestUpdateRemoveHostRoutes(t *testing.T) {
536	th.SetupHTTP()
537	defer th.TeardownHTTP()
538
539	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
540		th.TestMethod(t, r, "PUT")
541		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
542		th.TestHeader(t, r, "Content-Type", "application/json")
543		th.TestHeader(t, r, "Accept", "application/json")
544		th.TestJSONRequest(t, r, SubnetUpdateRemoveHostRoutesRequest)
545
546		w.Header().Add("Content-Type", "application/json")
547		w.WriteHeader(http.StatusCreated)
548
549		fmt.Fprintf(w, SubnetUpdateRemoveHostRoutesResponse)
550	})
551
552	noHostRoutes := []subnets.HostRoute{}
553	opts := subnets.UpdateOpts{
554		HostRoutes: &noHostRoutes,
555	}
556	s, err := subnets.Update(fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
557	th.AssertNoErr(t, err)
558
559	th.AssertEquals(t, s.Name, "my_new_subnet")
560	th.AssertEquals(t, s.ID, "08eae331-0402-425a-923c-34f7cfe39c1b")
561	th.AssertDeepEquals(t, s.HostRoutes, noHostRoutes)
562}
563
564func TestUpdateAllocationPool(t *testing.T) {
565	th.SetupHTTP()
566	defer th.TeardownHTTP()
567
568	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
569		th.TestMethod(t, r, "PUT")
570		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
571		th.TestHeader(t, r, "Content-Type", "application/json")
572		th.TestHeader(t, r, "Accept", "application/json")
573		th.TestJSONRequest(t, r, SubnetUpdateAllocationPoolRequest)
574
575		w.Header().Add("Content-Type", "application/json")
576		w.WriteHeader(http.StatusCreated)
577
578		fmt.Fprintf(w, SubnetUpdateAllocationPoolResponse)
579	})
580
581	name := "my_new_subnet"
582	opts := subnets.UpdateOpts{
583		Name: &name,
584		AllocationPools: []subnets.AllocationPool{
585			{
586				Start: "10.1.0.2",
587				End:   "10.1.0.254",
588			},
589		},
590	}
591	s, err := subnets.Update(fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
592	th.AssertNoErr(t, err)
593
594	th.AssertEquals(t, s.Name, "my_new_subnet")
595	th.AssertEquals(t, s.ID, "08eae331-0402-425a-923c-34f7cfe39c1b")
596	th.AssertDeepEquals(t, s.AllocationPools, []subnets.AllocationPool{
597		{
598			Start: "10.1.0.2",
599			End:   "10.1.0.254",
600		},
601	})
602}
603
604func TestDelete(t *testing.T) {
605	th.SetupHTTP()
606	defer th.TeardownHTTP()
607
608	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
609		th.TestMethod(t, r, "DELETE")
610		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
611		w.WriteHeader(http.StatusNoContent)
612	})
613
614	res := subnets.Delete(fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b")
615	th.AssertNoErr(t, res.Err)
616}
617