1. docker
  2. Commit 8bf62010a4e0167f8f66ff0eda385b2943b37add
Browse code

libnetwork: merge linux-only test-files

Signed-off-by: Sebastiaan van Stijn <github@gone.nl>

Sebastiaan van Stijn authored on 2023/08/10 20:03:01
Showing 2 changed files
libnetwork/libnetwork_linux_test.go
History View file @ 8bf6201
... ... 
@@ -6,8 +6,11 @@ import (
6 6 
 	"encoding/json"
7 7 
 	"fmt"
8 8 
 	"net"
9 
+	"net/http"
10 
+	"net/http/httptest"
9 11 
 	"os"
10 12 
 	"os/exec"
13 
+	"path/filepath"
11 14 
 	"strings"
12 15 
 	"sync"
13 16 
 	"testing"
... ... 
@@ -15,11 +18,15 @@ import (
15 15 
 	"github.com/containerd/containerd/log"
16 16 
 	"github.com/docker/docker/internal/testutils/netnsutils"
17 17 
 	"github.com/docker/docker/libnetwork"
18 
+	"github.com/docker/docker/libnetwork/config"
19 
+	"github.com/docker/docker/libnetwork/datastore"
20 
+	"github.com/docker/docker/libnetwork/driverapi"
18 21 
 	"github.com/docker/docker/libnetwork/ipamapi"
19 22 
 	"github.com/docker/docker/libnetwork/netlabel"
20 23 
 	"github.com/docker/docker/libnetwork/options"
21 24 
 	"github.com/docker/docker/libnetwork/osl"
22 25 
 	"github.com/docker/docker/libnetwork/types"
26 
+	"github.com/docker/docker/pkg/plugins"
23 27 
 	"github.com/docker/docker/pkg/reexec"
24 28 
 	"github.com/pkg/errors"
25 29 
 	"github.com/vishvananda/netlink"
... ... 
@@ -31,6 +38,1236 @@ const (
31 31 
 	bridgeNetType = "bridge"
32 32 
 )
33 33
34 
+func TestMain(m *testing.M) {
35 
+	// Cleanup local datastore file
36 
+	_ = os.Remove(datastore.DefaultScope("").Client.Address)
37 
+
38 
+	os.Exit(m.Run())
39 
+}
40 
+
41 
+func newController(t *testing.T) *libnetwork.Controller {
42 
+	t.Helper()
43 
+	c, err := libnetwork.New(
44 
+		libnetwork.OptionBoltdbWithRandomDBFile(t),
45 
+		config.OptionDriverConfig(bridgeNetType, map[string]interface{}{
46 
+			netlabel.GenericData: options.Generic{
47 
+				"EnableIPForwarding": true,
48 
+			},
49 
+		}),
50 
+	)
51 
+	if err != nil {
52 
+		t.Fatal(err)
53 
+	}
54 
+	t.Cleanup(c.Stop)
55 
+	return c
56 
+}
57 
+
58 
+func createTestNetwork(c *libnetwork.Controller, networkType, networkName string, netOption options.Generic, ipamV4Configs, ipamV6Configs []*libnetwork.IpamConf) (*libnetwork.Network, error) {
59 
+	return c.NewNetwork(networkType, networkName, "",
60 
+		libnetwork.NetworkOptionGeneric(netOption),
61 
+		libnetwork.NetworkOptionIpam(ipamapi.DefaultIPAM, "", ipamV4Configs, ipamV6Configs, nil))
62 
+}
63 
+
64 
+func getEmptyGenericOption() map[string]interface{} {
65 
+	return map[string]interface{}{netlabel.GenericData: map[string]string{}}
66 
+}
67 
+
68 
+func getPortMapping() []types.PortBinding {
69 
+	return []types.PortBinding{
70 
+		{Proto: types.TCP, Port: uint16(230), HostPort: uint16(23000)},
71 
+		{Proto: types.UDP, Port: uint16(200), HostPort: uint16(22000)},
72 
+		{Proto: types.TCP, Port: uint16(120), HostPort: uint16(12000)},
73 
+		{Proto: types.TCP, Port: uint16(320), HostPort: uint16(32000), HostPortEnd: uint16(32999)},
74 
+		{Proto: types.UDP, Port: uint16(420), HostPort: uint16(42000), HostPortEnd: uint16(42001)},
75 
+	}
76 
+}
77 
+
78 
+func isNotFound(err error) bool {
79 
+	_, ok := (err).(types.NotFoundError)
80 
+	return ok
81 
+}
82 
+
83 
+func TestNull(t *testing.T) {
84 
+	defer netnsutils.SetupTestOSContext(t)()
85 
+	controller := newController(t)
86 
+
87 
+	cnt, err := controller.NewSandbox("null_container",
88 
+		libnetwork.OptionHostname("test"),
89 
+		libnetwork.OptionDomainname("example.com"),
90 
+		libnetwork.OptionExtraHost("web", "192.168.0.1"))
91 
+	if err != nil {
92 
+		t.Fatal(err)
93 
+	}
94 
+
95 
+	network, err := createTestNetwork(controller, "null", "testnull", options.Generic{}, nil, nil)
96 
+	if err != nil {
97 
+		t.Fatal(err)
98 
+	}
99 
+
100 
+	ep, err := network.CreateEndpoint("testep")
101 
+	if err != nil {
102 
+		t.Fatal(err)
103 
+	}
104 
+
105 
+	err = ep.Join(cnt)
106 
+	if err != nil {
107 
+		t.Fatal(err)
108 
+	}
109 
+
110 
+	err = ep.Leave(cnt)
111 
+	if err != nil {
112 
+		t.Fatal(err)
113 
+	}
114 
+
115 
+	if err := ep.Delete(false); err != nil {
116 
+		t.Fatal(err)
117 
+	}
118 
+
119 
+	if err := cnt.Delete(); err != nil {
120 
+		t.Fatal(err)
121 
+	}
122 
+
123 
+	// host type is special network. Cannot be removed.
124 
+	err = network.Delete()
125 
+	if err == nil {
126 
+		t.Fatal(err)
127 
+	}
128 
+	if _, ok := err.(types.ForbiddenError); !ok {
129 
+		t.Fatalf("Unexpected error type")
130 
+	}
131 
+}
132 
+
133 
+func TestUnknownDriver(t *testing.T) {
134 
+	defer netnsutils.SetupTestOSContext(t)()
135 
+	controller := newController(t)
136 
+
137 
+	_, err := createTestNetwork(controller, "unknowndriver", "testnetwork", options.Generic{}, nil, nil)
138 
+	if err == nil {
139 
+		t.Fatal("Expected to fail. But instead succeeded")
140 
+	}
141 
+
142 
+	if !isNotFound(err) {
143 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
144 
+	}
145 
+}
146 
+
147 
+func TestNilRemoteDriver(t *testing.T) {
148 
+	defer netnsutils.SetupTestOSContext(t)()
149 
+	controller := newController(t)
150 
+
151 
+	_, err := controller.NewNetwork("framerelay", "dummy", "",
152 
+		libnetwork.NetworkOptionGeneric(getEmptyGenericOption()))
153 
+	if err == nil {
154 
+		t.Fatal("Expected to fail. But instead succeeded")
155 
+	}
156 
+
157 
+	if !isNotFound(err) {
158 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
159 
+	}
160 
+}
161 
+
162 
+func TestNetworkName(t *testing.T) {
163 
+	defer netnsutils.SetupTestOSContext(t)()
164 
+	controller := newController(t)
165 
+
166 
+	netOption := options.Generic{
167 
+		netlabel.GenericData: options.Generic{
168 
+			"BridgeName": "testnetwork",
169 
+		},
170 
+	}
171 
+
172 
+	_, err := createTestNetwork(controller, bridgeNetType, "", netOption, nil, nil)
173 
+	if err == nil {
174 
+		t.Fatal("Expected to fail. But instead succeeded")
175 
+	}
176 
+
177 
+	if _, ok := err.(libnetwork.ErrInvalidName); !ok {
178 
+		t.Fatalf("Expected to fail with ErrInvalidName error. Got %v", err)
179 
+	}
180 
+
181 
+	networkName := "testnetwork"
182 
+	n, err := createTestNetwork(controller, bridgeNetType, networkName, netOption, nil, nil)
183 
+	if err != nil {
184 
+		t.Fatal(err)
185 
+	}
186 
+	defer func() {
187 
+		if err := n.Delete(); err != nil {
188 
+			t.Fatal(err)
189 
+		}
190 
+	}()
191 
+
192 
+	if n.Name() != networkName {
193 
+		t.Fatalf("Expected network name %s, got %s", networkName, n.Name())
194 
+	}
195 
+}
196 
+
197 
+func TestNetworkType(t *testing.T) {
198 
+	defer netnsutils.SetupTestOSContext(t)()
199 
+	controller := newController(t)
200 
+
201 
+	netOption := options.Generic{
202 
+		netlabel.GenericData: options.Generic{
203 
+			"BridgeName": "testnetwork",
204 
+		},
205 
+	}
206 
+
207 
+	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", netOption, nil, nil)
208 
+	if err != nil {
209 
+		t.Fatal(err)
210 
+	}
211 
+	defer func() {
212 
+		if err := n.Delete(); err != nil {
213 
+			t.Fatal(err)
214 
+		}
215 
+	}()
216 
+
217 
+	if n.Type() != bridgeNetType {
218 
+		t.Fatalf("Expected network type %s, got %s", bridgeNetType, n.Type())
219 
+	}
220 
+}
221 
+
222 
+func TestNetworkID(t *testing.T) {
223 
+	defer netnsutils.SetupTestOSContext(t)()
224 
+	controller := newController(t)
225 
+
226 
+	netOption := options.Generic{
227 
+		netlabel.GenericData: options.Generic{
228 
+			"BridgeName": "testnetwork",
229 
+		},
230 
+	}
231 
+
232 
+	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", netOption, nil, nil)
233 
+	if err != nil {
234 
+		t.Fatal(err)
235 
+	}
236 
+	defer func() {
237 
+		if err := n.Delete(); err != nil {
238 
+			t.Fatal(err)
239 
+		}
240 
+	}()
241 
+
242 
+	if n.ID() == "" {
243 
+		t.Fatal("Expected non-empty network id")
244 
+	}
245 
+}
246 
+
247 
+func TestDeleteNetworkWithActiveEndpoints(t *testing.T) {
248 
+	defer netnsutils.SetupTestOSContext(t)()
249 
+	controller := newController(t)
250 
+
251 
+	netOption := options.Generic{
252 
+		"BridgeName": "testnetwork",
253 
+	}
254 
+	option := options.Generic{
255 
+		netlabel.GenericData: netOption,
256 
+	}
257 
+
258 
+	network, err := createTestNetwork(controller, bridgeNetType, "testnetwork", option, nil, nil)
259 
+	if err != nil {
260 
+		t.Fatal(err)
261 
+	}
262 
+
263 
+	ep, err := network.CreateEndpoint("testep")
264 
+	if err != nil {
265 
+		t.Fatal(err)
266 
+	}
267 
+
268 
+	err = network.Delete()
269 
+	if err == nil {
270 
+		t.Fatal("Expected to fail. But instead succeeded")
271 
+	}
272 
+
273 
+	if _, ok := err.(*libnetwork.ActiveEndpointsError); !ok {
274 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
275 
+	}
276 
+
277 
+	// Done testing. Now cleanup.
278 
+	if err := ep.Delete(false); err != nil {
279 
+		t.Fatal(err)
280 
+	}
281 
+
282 
+	if err := network.Delete(); err != nil {
283 
+		t.Fatal(err)
284 
+	}
285 
+}
286 
+
287 
+func TestNetworkConfig(t *testing.T) {
288 
+	defer netnsutils.SetupTestOSContext(t)()
289 
+	controller := newController(t)
290 
+
291 
+	// Verify config network cannot inherit another config network
292 
+	_, err := controller.NewNetwork("bridge", "config_network0", "",
293 
+		libnetwork.NetworkOptionConfigOnly(),
294 
+		libnetwork.NetworkOptionConfigFrom("anotherConfigNw"))
295 
+
296 
+	if err == nil {
297 
+		t.Fatal("Expected to fail. But instead succeeded")
298 
+	}
299 
+	if _, ok := err.(types.ForbiddenError); !ok {
300 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
301 
+	}
302 
+
303 
+	// Create supported config network
304 
+	netOption := options.Generic{
305 
+		"EnableICC": false,
306 
+	}
307 
+	option := options.Generic{
308 
+		netlabel.GenericData: netOption,
309 
+	}
310 
+	ipamV4ConfList := []*libnetwork.IpamConf{{PreferredPool: "192.168.100.0/24", SubPool: "192.168.100.128/25", Gateway: "192.168.100.1"}}
311 
+	ipamV6ConfList := []*libnetwork.IpamConf{{PreferredPool: "2001:db8:abcd::/64", SubPool: "2001:db8:abcd::ef99/80", Gateway: "2001:db8:abcd::22"}}
312 
+
313 
+	netOptions := []libnetwork.NetworkOption{
314 
+		libnetwork.NetworkOptionConfigOnly(),
315 
+		libnetwork.NetworkOptionEnableIPv6(true),
316 
+		libnetwork.NetworkOptionGeneric(option),
317 
+		libnetwork.NetworkOptionIpam("default", "", ipamV4ConfList, ipamV6ConfList, nil),
318 
+	}
319 
+
320 
+	configNetwork, err := controller.NewNetwork(bridgeNetType, "config_network0", "", netOptions...)
321 
+	if err != nil {
322 
+		t.Fatal(err)
323 
+	}
324 
+
325 
+	// Verify a config-only network cannot be created with network operator configurations
326 
+	for i, opt := range []libnetwork.NetworkOption{
327 
+		libnetwork.NetworkOptionInternalNetwork(),
328 
+		libnetwork.NetworkOptionAttachable(true),
329 
+		libnetwork.NetworkOptionIngress(true),
330 
+	} {
331 
+		_, err = controller.NewNetwork(bridgeNetType, "testBR", "",
332 
+			libnetwork.NetworkOptionConfigOnly(), opt)
333 
+		if err == nil {
334 
+			t.Fatalf("Expected to fail. But instead succeeded for option: %d", i)
335 
+		}
336 
+		if _, ok := err.(types.ForbiddenError); !ok {
337 
+			t.Fatalf("Did not fail with expected error. Actual error: %v", err)
338 
+		}
339 
+	}
340 
+
341 
+	// Verify a network cannot be created with both config-from and network specific configurations
342 
+	for i, opt := range []libnetwork.NetworkOption{
343 
+		libnetwork.NetworkOptionEnableIPv6(true),
344 
+		libnetwork.NetworkOptionIpam("my-ipam", "", nil, nil, nil),
345 
+		libnetwork.NetworkOptionIpam("", "", ipamV4ConfList, nil, nil),
346 
+		libnetwork.NetworkOptionIpam("", "", nil, ipamV6ConfList, nil),
347 
+		libnetwork.NetworkOptionLabels(map[string]string{"number": "two"}),
348 
+		libnetwork.NetworkOptionDriverOpts(map[string]string{"com.docker.network.driver.mtu": "1600"}),
349 
+	} {
350 
+		_, err = controller.NewNetwork(bridgeNetType, "testBR", "",
351 
+			libnetwork.NetworkOptionConfigFrom("config_network0"), opt)
352 
+		if err == nil {
353 
+			t.Fatalf("Expected to fail. But instead succeeded for option: %d", i)
354 
+		}
355 
+		if _, ok := err.(types.ForbiddenError); !ok {
356 
+			t.Fatalf("Did not fail with expected error. Actual error: %v", err)
357 
+		}
358 
+	}
359 
+
360 
+	// Create a valid network
361 
+	network, err := controller.NewNetwork(bridgeNetType, "testBR", "",
362 
+		libnetwork.NetworkOptionConfigFrom("config_network0"))
363 
+	if err != nil {
364 
+		t.Fatal(err)
365 
+	}
366 
+
367 
+	// Verify the config network cannot be removed
368 
+	err = configNetwork.Delete()
369 
+	if err == nil {
370 
+		t.Fatal("Expected to fail. But instead succeeded")
371 
+	}
372 
+
373 
+	if _, ok := err.(types.ForbiddenError); !ok {
374 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
375 
+	}
376 
+
377 
+	// Delete network
378 
+	if err := network.Delete(); err != nil {
379 
+		t.Fatal(err)
380 
+	}
381 
+
382 
+	// Verify the config network can now be removed
383 
+	if err := configNetwork.Delete(); err != nil {
384 
+		t.Fatal(err)
385 
+	}
386 
+}
387 
+
388 
+func TestUnknownNetwork(t *testing.T) {
389 
+	defer netnsutils.SetupTestOSContext(t)()
390 
+	controller := newController(t)
391 
+
392 
+	netOption := options.Generic{
393 
+		"BridgeName": "testnetwork",
394 
+	}
395 
+	option := options.Generic{
396 
+		netlabel.GenericData: netOption,
397 
+	}
398 
+
399 
+	network, err := createTestNetwork(controller, bridgeNetType, "testnetwork", option, nil, nil)
400 
+	if err != nil {
401 
+		t.Fatal(err)
402 
+	}
403 
+
404 
+	err = network.Delete()
405 
+	if err != nil {
406 
+		t.Fatal(err)
407 
+	}
408 
+
409 
+	err = network.Delete()
410 
+	if err == nil {
411 
+		t.Fatal("Expected to fail. But instead succeeded")
412 
+	}
413 
+
414 
+	if _, ok := err.(*libnetwork.UnknownNetworkError); !ok {
415 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
416 
+	}
417 
+}
418 
+
419 
+func TestUnknownEndpoint(t *testing.T) {
420 
+	defer netnsutils.SetupTestOSContext(t)()
421 
+	controller := newController(t)
422 
+
423 
+	netOption := options.Generic{
424 
+		"BridgeName": "testnetwork",
425 
+	}
426 
+	option := options.Generic{
427 
+		netlabel.GenericData: netOption,
428 
+	}
429 
+	ipamV4ConfList := []*libnetwork.IpamConf{{PreferredPool: "192.168.100.0/24"}}
430 
+
431 
+	network, err := createTestNetwork(controller, bridgeNetType, "testnetwork", option, ipamV4ConfList, nil)
432 
+	if err != nil {
433 
+		t.Fatal(err)
434 
+	}
435 
+
436 
+	_, err = network.CreateEndpoint("")
437 
+	if err == nil {
438 
+		t.Fatal("Expected to fail. But instead succeeded")
439 
+	}
440 
+	if _, ok := err.(libnetwork.ErrInvalidName); !ok {
441 
+		t.Fatalf("Expected to fail with ErrInvalidName error. Actual error: %v", err)
442 
+	}
443 
+
444 
+	ep, err := network.CreateEndpoint("testep")
445 
+	if err != nil {
446 
+		t.Fatal(err)
447 
+	}
448 
+
449 
+	err = ep.Delete(false)
450 
+	if err != nil {
451 
+		t.Fatal(err)
452 
+	}
453 
+
454 
+	// Done testing. Now cleanup
455 
+	if err := network.Delete(); err != nil {
456 
+		t.Fatal(err)
457 
+	}
458 
+}
459 
+
460 
+func TestNetworkEndpointsWalkers(t *testing.T) {
461 
+	defer netnsutils.SetupTestOSContext(t)()
462 
+	controller := newController(t)
463 
+
464 
+	// Create network 1 and add 2 endpoint: ep11, ep12
465 
+	netOption := options.Generic{
466 
+		netlabel.GenericData: options.Generic{
467 
+			"BridgeName": "network1",
468 
+		},
469 
+	}
470 
+
471 
+	net1, err := createTestNetwork(controller, bridgeNetType, "network1", netOption, nil, nil)
472 
+	if err != nil {
473 
+		t.Fatal(err)
474 
+	}
475 
+	defer func() {
476 
+		if err := net1.Delete(); err != nil {
477 
+			t.Fatal(err)
478 
+		}
479 
+	}()
480 
+
481 
+	ep11, err := net1.CreateEndpoint("ep11")
482 
+	if err != nil {
483 
+		t.Fatal(err)
484 
+	}
485 
+	defer func() {
486 
+		if err := ep11.Delete(false); err != nil {
487 
+			t.Fatal(err)
488 
+		}
489 
+	}()
490 
+
491 
+	ep12, err := net1.CreateEndpoint("ep12")
492 
+	if err != nil {
493 
+		t.Fatal(err)
494 
+	}
495 
+	defer func() {
496 
+		if err := ep12.Delete(false); err != nil {
497 
+			t.Fatal(err)
498 
+		}
499 
+	}()
500 
+
501 
+	// Test list methods on net1
502 
+	epList1 := net1.Endpoints()
503 
+	if len(epList1) != 2 {
504 
+		t.Fatalf("Endpoints() returned wrong number of elements: %d instead of 2", len(epList1))
505 
+	}
506 
+	// endpoint order is not guaranteed
507 
+	for _, e := range epList1 {
508 
+		if e != ep11 && e != ep12 {
509 
+			t.Fatal("Endpoints() did not return all the expected elements")
510 
+		}
511 
+	}
512 
+
513 
+	// Test Endpoint Walk method
514 
+	var epName string
515 
+	var epWanted *libnetwork.Endpoint
516 
+	wlk := func(ep *libnetwork.Endpoint) bool {
517 
+		if ep.Name() == epName {
518 
+			epWanted = ep
519 
+			return true
520 
+		}
521 
+		return false
522 
+	}
523 
+
524 
+	// Look for ep1 on network1
525 
+	epName = "ep11"
526 
+	net1.WalkEndpoints(wlk)
527 
+	if epWanted == nil {
528 
+		t.Fatal(err)
529 
+	}
530 
+	if ep11 != epWanted {
531 
+		t.Fatal(err)
532 
+	}
533 
+
534 
+	current := len(controller.Networks())
535 
+
536 
+	// Create network 2
537 
+	netOption = options.Generic{
538 
+		netlabel.GenericData: options.Generic{
539 
+			"BridgeName": "network2",
540 
+		},
541 
+	}
542 
+
543 
+	net2, err := createTestNetwork(controller, bridgeNetType, "network2", netOption, nil, nil)
544 
+	if err != nil {
545 
+		t.Fatal(err)
546 
+	}
547 
+	defer func() {
548 
+		if err := net2.Delete(); err != nil {
549 
+			t.Fatal(err)
550 
+		}
551 
+	}()
552 
+
553 
+	// Test Networks method
554 
+	if len(controller.Networks()) != current+1 {
555 
+		t.Fatalf("Did not find the expected number of networks")
556 
+	}
557 
+
558 
+	// Test Network Walk method
559 
+	var netName string
560 
+	var netWanted *libnetwork.Network
561 
+	nwWlk := func(nw *libnetwork.Network) bool {
562 
+		if nw.Name() == netName {
563 
+			netWanted = nw
564 
+			return true
565 
+		}
566 
+		return false
567 
+	}
568 
+
569 
+	// Look for network named "network1" and "network2"
570 
+	netName = "network1"
571 
+	controller.WalkNetworks(nwWlk)
572 
+	if netWanted == nil {
573 
+		t.Fatal(err)
574 
+	}
575 
+	if net1.ID() != netWanted.ID() {
576 
+		t.Fatal(err)
577 
+	}
578 
+
579 
+	netName = "network2"
580 
+	controller.WalkNetworks(nwWlk)
581 
+	if netWanted == nil {
582 
+		t.Fatal(err)
583 
+	}
584 
+	if net2.ID() != netWanted.ID() {
585 
+		t.Fatal(err)
586 
+	}
587 
+}
588 
+
589 
+func TestDuplicateEndpoint(t *testing.T) {
590 
+	defer netnsutils.SetupTestOSContext(t)()
591 
+	controller := newController(t)
592 
+
593 
+	netOption := options.Generic{
594 
+		netlabel.GenericData: options.Generic{
595 
+			"BridgeName": "testnetwork",
596 
+		},
597 
+	}
598 
+	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", netOption, nil, nil)
599 
+	if err != nil {
600 
+		t.Fatal(err)
601 
+	}
602 
+	defer func() {
603 
+		if err := n.Delete(); err != nil {
604 
+			t.Fatal(err)
605 
+		}
606 
+	}()
607 
+
608 
+	ep, err := n.CreateEndpoint("ep1")
609 
+	if err != nil {
610 
+		t.Fatal(err)
611 
+	}
612 
+	defer func() {
613 
+		if err := ep.Delete(false); err != nil {
614 
+			t.Fatal(err)
615 
+		}
616 
+	}()
617 
+
618 
+	ep2, err := n.CreateEndpoint("ep1")
619 
+	defer func() {
620 
+		// Cleanup ep2 as well, else network cleanup might fail for failure cases
621 
+		if ep2 != nil {
622 
+			if err := ep2.Delete(false); err != nil {
623 
+				t.Fatal(err)
624 
+			}
625 
+		}
626 
+	}()
627 
+
628 
+	if err == nil {
629 
+		t.Fatal("Expected to fail. But instead succeeded")
630 
+	}
631 
+
632 
+	if _, ok := err.(types.ForbiddenError); !ok {
633 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
634 
+	}
635 
+}
636 
+
637 
+func TestControllerQuery(t *testing.T) {
638 
+	defer netnsutils.SetupTestOSContext(t)()
639 
+	controller := newController(t)
640 
+
641 
+	// Create network 1
642 
+	netOption := options.Generic{
643 
+		netlabel.GenericData: options.Generic{
644 
+			"BridgeName": "network1",
645 
+		},
646 
+	}
647 
+	net1, err := createTestNetwork(controller, bridgeNetType, "network1", netOption, nil, nil)
648 
+	if err != nil {
649 
+		t.Fatal(err)
650 
+	}
651 
+	defer func() {
652 
+		if err := net1.Delete(); err != nil {
653 
+			t.Fatal(err)
654 
+		}
655 
+	}()
656 
+
657 
+	// Create network 2
658 
+	netOption = options.Generic{
659 
+		netlabel.GenericData: options.Generic{
660 
+			"BridgeName": "network2",
661 
+		},
662 
+	}
663 
+	net2, err := createTestNetwork(controller, bridgeNetType, "network2", netOption, nil, nil)
664 
+	if err != nil {
665 
+		t.Fatal(err)
666 
+	}
667 
+	defer func() {
668 
+		if err := net2.Delete(); err != nil {
669 
+			t.Fatal(err)
670 
+		}
671 
+	}()
672 
+
673 
+	_, err = controller.NetworkByName("")
674 
+	if err == nil {
675 
+		t.Fatalf("NetworkByName() succeeded with invalid target name")
676 
+	}
677 
+	if _, ok := err.(libnetwork.ErrInvalidName); !ok {
678 
+		t.Fatalf("Expected NetworkByName() to fail with ErrInvalidName error. Got: %v", err)
679 
+	}
680 
+
681 
+	_, err = controller.NetworkByID("")
682 
+	if err == nil {
683 
+		t.Fatalf("NetworkByID() succeeded with invalid target id")
684 
+	}
685 
+	if _, ok := err.(libnetwork.ErrInvalidID); !ok {
686 
+		t.Fatalf("NetworkByID() failed with unexpected error: %v", err)
687 
+	}
688 
+
689 
+	g, err := controller.NetworkByID("network1")
690 
+	if err == nil {
691 
+		t.Fatalf("Unexpected success for NetworkByID(): %v", g)
692 
+	}
693 
+	if _, ok := err.(libnetwork.ErrNoSuchNetwork); !ok {
694 
+		t.Fatalf("NetworkByID() failed with unexpected error: %v", err)
695 
+	}
696 
+
697 
+	g, err = controller.NetworkByName("network1")
698 
+	if err != nil {
699 
+		t.Fatalf("Unexpected failure for NetworkByName(): %v", err)
700 
+	}
701 
+	if g == nil {
702 
+		t.Fatalf("NetworkByName() did not find the network")
703 
+	}
704 
+
705 
+	if g != net1 {
706 
+		t.Fatalf("NetworkByName() returned the wrong network")
707 
+	}
708 
+
709 
+	g, err = controller.NetworkByID(net1.ID())
710 
+	if err != nil {
711 
+		t.Fatalf("Unexpected failure for NetworkByID(): %v", err)
712 
+	}
713 
+	if net1.ID() != g.ID() {
714 
+		t.Fatalf("NetworkByID() returned unexpected element: %v", g)
715 
+	}
716 
+
717 
+	g, err = controller.NetworkByName("network2")
718 
+	if err != nil {
719 
+		t.Fatalf("Unexpected failure for NetworkByName(): %v", err)
720 
+	}
721 
+	if g == nil {
722 
+		t.Fatalf("NetworkByName() did not find the network")
723 
+	}
724 
+
725 
+	if g != net2 {
726 
+		t.Fatalf("NetworkByName() returned the wrong network")
727 
+	}
728 
+
729 
+	g, err = controller.NetworkByID(net2.ID())
730 
+	if err != nil {
731 
+		t.Fatalf("Unexpected failure for NetworkByID(): %v", err)
732 
+	}
733 
+	if net2.ID() != g.ID() {
734 
+		t.Fatalf("NetworkByID() returned unexpected element: %v", g)
735 
+	}
736 
+}
737 
+
738 
+func TestNetworkQuery(t *testing.T) {
739 
+	defer netnsutils.SetupTestOSContext(t)()
740 
+	controller := newController(t)
741 
+
742 
+	// Create network 1 and add 2 endpoint: ep11, ep12
743 
+	netOption := options.Generic{
744 
+		netlabel.GenericData: options.Generic{
745 
+			"BridgeName": "network1",
746 
+		},
747 
+	}
748 
+	net1, err := createTestNetwork(controller, bridgeNetType, "network1", netOption, nil, nil)
749 
+	if err != nil {
750 
+		t.Fatal(err)
751 
+	}
752 
+	defer func() {
753 
+		if err := net1.Delete(); err != nil {
754 
+			t.Fatal(err)
755 
+		}
756 
+	}()
757 
+
758 
+	ep11, err := net1.CreateEndpoint("ep11")
759 
+	if err != nil {
760 
+		t.Fatal(err)
761 
+	}
762 
+	defer func() {
763 
+		if err := ep11.Delete(false); err != nil {
764 
+			t.Fatal(err)
765 
+		}
766 
+	}()
767 
+
768 
+	ep12, err := net1.CreateEndpoint("ep12")
769 
+	if err != nil {
770 
+		t.Fatal(err)
771 
+	}
772 
+	defer func() {
773 
+		if err := ep12.Delete(false); err != nil {
774 
+			t.Fatal(err)
775 
+		}
776 
+	}()
777 
+
778 
+	e, err := net1.EndpointByName("ep11")
779 
+	if err != nil {
780 
+		t.Fatal(err)
781 
+	}
782 
+	if ep11 != e {
783 
+		t.Fatalf("EndpointByName() returned %v instead of %v", e, ep11)
784 
+	}
785 
+
786 
+	_, err = net1.EndpointByName("")
787 
+	if err == nil {
788 
+		t.Fatalf("EndpointByName() succeeded with invalid target name")
789 
+	}
790 
+	if _, ok := err.(libnetwork.ErrInvalidName); !ok {
791 
+		t.Fatalf("Expected EndpointByName() to fail with ErrInvalidName error. Got: %v", err)
792 
+	}
793 
+
794 
+	e, err = net1.EndpointByName("IamNotAnEndpoint")
795 
+	if err == nil {
796 
+		t.Fatalf("EndpointByName() succeeded with unknown target name")
797 
+	}
798 
+	if _, ok := err.(libnetwork.ErrNoSuchEndpoint); !ok {
799 
+		t.Fatal(err)
800 
+	}
801 
+	if e != nil {
802 
+		t.Fatalf("EndpointByName(): expected nil, got %v", e)
803 
+	}
804 
+
805 
+	e, err = net1.EndpointByID(ep12.ID())
806 
+	if err != nil {
807 
+		t.Fatal(err)
808 
+	}
809 
+	if ep12.ID() != e.ID() {
810 
+		t.Fatalf("EndpointByID() returned %v instead of %v", e, ep12)
811 
+	}
812 
+
813 
+	_, err = net1.EndpointByID("")
814 
+	if err == nil {
815 
+		t.Fatalf("EndpointByID() succeeded with invalid target id")
816 
+	}
817 
+	if _, ok := err.(libnetwork.ErrInvalidID); !ok {
818 
+		t.Fatalf("EndpointByID() failed with unexpected error: %v", err)
819 
+	}
820 
+}
821 
+
822 
+const containerID = "valid_c"
823 
+
824 
+func TestEndpointDeleteWithActiveContainer(t *testing.T) {
825 
+	defer netnsutils.SetupTestOSContext(t)()
826 
+	controller := newController(t)
827 
+
828 
+	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", options.Generic{
829 
+		netlabel.GenericData: options.Generic{
830 
+			"BridgeName": "testnetwork",
831 
+		},
832 
+	}, nil, nil)
833 
+	if err != nil {
834 
+		t.Fatal(err)
835 
+	}
836 
+	defer func() {
837 
+		if err := n.Delete(); err != nil {
838 
+			t.Fatal(err)
839 
+		}
840 
+	}()
841 
+
842 
+	n2, err := createTestNetwork(controller, bridgeNetType, "testnetwork2", options.Generic{
843 
+		netlabel.GenericData: options.Generic{
844 
+			"BridgeName": "testnetwork2",
845 
+		},
846 
+	}, nil, nil)
847 
+	if err != nil {
848 
+		t.Fatal(err)
849 
+	}
850 
+	defer func() {
851 
+		if err := n2.Delete(); err != nil {
852 
+			t.Fatal(err)
853 
+		}
854 
+	}()
855 
+
856 
+	ep, err := n.CreateEndpoint("ep1")
857 
+	if err != nil {
858 
+		t.Fatal(err)
859 
+	}
860 
+	defer func() {
861 
+		err = ep.Delete(false)
862 
+		if err != nil {
863 
+			t.Fatal(err)
864 
+		}
865 
+	}()
866 
+
867 
+	cnt, err := controller.NewSandbox(containerID,
868 
+		libnetwork.OptionHostname("test"),
869 
+		libnetwork.OptionDomainname("example.com"),
870 
+		libnetwork.OptionExtraHost("web", "192.168.0.1"))
871 
+	defer func() {
872 
+		if err := cnt.Delete(); err != nil {
873 
+			t.Fatal(err)
874 
+		}
875 
+	}()
876 
+
877 
+	err = ep.Join(cnt)
878 
+	if err != nil {
879 
+		t.Fatal(err)
880 
+	}
881 
+	defer func() {
882 
+		err = ep.Leave(cnt)
883 
+		if err != nil {
884 
+			t.Fatal(err)
885 
+		}
886 
+	}()
887 
+
888 
+	err = ep.Delete(false)
889 
+	if err == nil {
890 
+		t.Fatal("Expected to fail. But instead succeeded")
891 
+	}
892 
+
893 
+	if _, ok := err.(*libnetwork.ActiveContainerError); !ok {
894 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
895 
+	}
896 
+}
897 
+
898 
+func TestEndpointMultipleJoins(t *testing.T) {
899 
+	defer netnsutils.SetupTestOSContext(t)()
900 
+	controller := newController(t)
901 
+
902 
+	n, err := createTestNetwork(controller, bridgeNetType, "testmultiple", options.Generic{
903 
+		netlabel.GenericData: options.Generic{
904 
+			"BridgeName": "testmultiple",
905 
+		},
906 
+	}, nil, nil)
907 
+	if err != nil {
908 
+		t.Fatal(err)
909 
+	}
910 
+	defer func() {
911 
+		if err := n.Delete(); err != nil {
912 
+			t.Fatal(err)
913 
+		}
914 
+	}()
915 
+
916 
+	ep, err := n.CreateEndpoint("ep1")
917 
+	if err != nil {
918 
+		t.Fatal(err)
919 
+	}
920 
+	defer func() {
921 
+		if err := ep.Delete(false); err != nil {
922 
+			t.Fatal(err)
923 
+		}
924 
+	}()
925 
+
926 
+	sbx1, err := controller.NewSandbox(containerID,
927 
+		libnetwork.OptionHostname("test"),
928 
+		libnetwork.OptionDomainname("example.com"),
929 
+		libnetwork.OptionExtraHost("web", "192.168.0.1"),
930 
+	)
931 
+	if err != nil {
932 
+		t.Fatal(err)
933 
+	}
934 
+	defer func() {
935 
+		if err := sbx1.Delete(); err != nil {
936 
+			t.Fatal(err)
937 
+		}
938 
+	}()
939 
+
940 
+	sbx2, err := controller.NewSandbox("c2")
941 
+	if err != nil {
942 
+		t.Fatal(err)
943 
+	}
944 
+	defer func() {
945 
+		if err := sbx2.Delete(); err != nil {
946 
+			t.Fatal(err)
947 
+		}
948 
+	}()
949 
+
950 
+	err = ep.Join(sbx1)
951 
+	if err != nil {
952 
+		t.Fatal(err)
953 
+	}
954 
+	defer func() {
955 
+		err = ep.Leave(sbx1)
956 
+		if err != nil {
957 
+			t.Fatal(err)
958 
+		}
959 
+	}()
960 
+
961 
+	err = ep.Join(sbx2)
962 
+	if err == nil {
963 
+		t.Fatal("Expected to fail multiple joins for the same endpoint")
964 
+	}
965 
+
966 
+	if _, ok := err.(types.ForbiddenError); !ok {
967 
+		t.Fatalf("Failed with unexpected error type: %T. Desc: %s", err, err.Error())
968 
+	}
969 
+}
970 
+
971 
+func TestLeaveAll(t *testing.T) {
972 
+	defer netnsutils.SetupTestOSContext(t)()
973 
+	controller := newController(t)
974 
+
975 
+	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", options.Generic{
976 
+		netlabel.GenericData: options.Generic{
977 
+			"BridgeName": "testnetwork",
978 
+		},
979 
+	}, nil, nil)
980 
+	if err != nil {
981 
+		t.Fatal(err)
982 
+	}
983 
+	defer func() {
984 
+		// If this goes through, it means cnt.Delete() effectively detached from all the endpoints
985 
+		if err := n.Delete(); err != nil {
986 
+			t.Fatal(err)
987 
+		}
988 
+	}()
989 
+
990 
+	n2, err := createTestNetwork(controller, bridgeNetType, "testnetwork2", options.Generic{
991 
+		netlabel.GenericData: options.Generic{
992 
+			"BridgeName": "testnetwork2",
993 
+		},
994 
+	}, nil, nil)
995 
+	if err != nil {
996 
+		t.Fatal(err)
997 
+	}
998 
+	defer func() {
999 
+		if err := n2.Delete(); err != nil {
1000 
+			t.Fatal(err)
1001 
+		}
1002 
+	}()
1003 
+
1004 
+	ep1, err := n.CreateEndpoint("ep1")
1005 
+	if err != nil {
1006 
+		t.Fatal(err)
1007 
+	}
1008 
+
1009 
+	ep2, err := n2.CreateEndpoint("ep2")
1010 
+	if err != nil {
1011 
+		t.Fatal(err)
1012 
+	}
1013 
+
1014 
+	cnt, err := controller.NewSandbox("leaveall")
1015 
+	if err != nil {
1016 
+		t.Fatal(err)
1017 
+	}
1018 
+
1019 
+	err = ep1.Join(cnt)
1020 
+	if err != nil {
1021 
+		t.Fatalf("Failed to join ep1: %v", err)
1022 
+	}
1023 
+
1024 
+	err = ep2.Join(cnt)
1025 
+	if err != nil {
1026 
+		t.Fatalf("Failed to join ep2: %v", err)
1027 
+	}
1028 
+
1029 
+	err = cnt.Delete()
1030 
+	if err != nil {
1031 
+		t.Fatal(err)
1032 
+	}
1033 
+}
1034 
+
1035 
+func TestContainerInvalidLeave(t *testing.T) {
1036 
+	defer netnsutils.SetupTestOSContext(t)()
1037 
+	controller := newController(t)
1038 
+
1039 
+	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", options.Generic{
1040 
+		netlabel.GenericData: options.Generic{
1041 
+			"BridgeName": "testnetwork",
1042 
+		},
1043 
+	}, nil, nil)
1044 
+	if err != nil {
1045 
+		t.Fatal(err)
1046 
+	}
1047 
+	defer func() {
1048 
+		if err := n.Delete(); err != nil {
1049 
+			t.Fatal(err)
1050 
+		}
1051 
+	}()
1052 
+
1053 
+	ep, err := n.CreateEndpoint("ep1")
1054 
+	if err != nil {
1055 
+		t.Fatal(err)
1056 
+	}
1057 
+	defer func() {
1058 
+		if err := ep.Delete(false); err != nil {
1059 
+			t.Fatal(err)
1060 
+		}
1061 
+	}()
1062 
+
1063 
+	cnt, err := controller.NewSandbox(containerID,
1064 
+		libnetwork.OptionHostname("test"),
1065 
+		libnetwork.OptionDomainname("example.com"),
1066 
+		libnetwork.OptionExtraHost("web", "192.168.0.1"))
1067 
+	if err != nil {
1068 
+		t.Fatal(err)
1069 
+	}
1070 
+	defer func() {
1071 
+		if err := cnt.Delete(); err != nil {
1072 
+			t.Fatal(err)
1073 
+		}
1074 
+	}()
1075 
+
1076 
+	err = ep.Leave(cnt)
1077 
+	if err == nil {
1078 
+		t.Fatal("Expected to fail leave from an endpoint which has no active join")
1079 
+	}
1080 
+	if _, ok := err.(types.ForbiddenError); !ok {
1081 
+		t.Fatalf("Failed with unexpected error type: %T. Desc: %s", err, err.Error())
1082 
+	}
1083 
+
1084 
+	if err = ep.Leave(nil); err == nil {
1085 
+		t.Fatalf("Expected to fail leave nil Sandbox")
1086 
+	}
1087 
+	if _, ok := err.(types.BadRequestError); !ok {
1088 
+		t.Fatalf("Unexpected error type returned: %T. Desc: %s", err, err.Error())
1089 
+	}
1090 
+
1091 
+	fsbx := &libnetwork.Sandbox{}
1092 
+	if err = ep.Leave(fsbx); err == nil {
1093 
+		t.Fatalf("Expected to fail leave with invalid Sandbox")
1094 
+	}
1095 
+	if _, ok := err.(types.BadRequestError); !ok {
1096 
+		t.Fatalf("Unexpected error type returned: %T. Desc: %s", err, err.Error())
1097 
+	}
1098 
+}
1099 
+
1100 
+func TestEndpointUpdateParent(t *testing.T) {
1101 
+	defer netnsutils.SetupTestOSContext(t)()
1102 
+	controller := newController(t)
1103 
+
1104 
+	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", options.Generic{
1105 
+		netlabel.GenericData: options.Generic{
1106 
+			"BridgeName": "testnetwork",
1107 
+		},
1108 
+	}, nil, nil)
1109 
+	if err != nil {
1110 
+		t.Fatal(err)
1111 
+	}
1112 
+	defer func() {
1113 
+		if err := n.Delete(); err != nil {
1114 
+			t.Fatal(err)
1115 
+		}
1116 
+	}()
1117 
+
1118 
+	ep1, err := n.CreateEndpoint("ep1")
1119 
+	if err != nil {
1120 
+		t.Fatal(err)
1121 
+	}
1122 
+
1123 
+	ep2, err := n.CreateEndpoint("ep2")
1124 
+	if err != nil {
1125 
+		t.Fatal(err)
1126 
+	}
1127 
+
1128 
+	sbx1, err := controller.NewSandbox(containerID,
1129 
+		libnetwork.OptionHostname("test"),
1130 
+		libnetwork.OptionDomainname("example.com"),
1131 
+		libnetwork.OptionExtraHost("web", "192.168.0.1"))
1132 
+	if err != nil {
1133 
+		t.Fatal(err)
1134 
+	}
1135 
+	defer func() {
1136 
+		if err := sbx1.Delete(); err != nil {
1137 
+			t.Fatal(err)
1138 
+		}
1139 
+	}()
1140 
+
1141 
+	sbx2, err := controller.NewSandbox("c2",
1142 
+		libnetwork.OptionHostname("test2"),
1143 
+		libnetwork.OptionDomainname("example.com"),
1144 
+		libnetwork.OptionHostsPath("/var/lib/docker/test_network/container2/hosts"),
1145 
+		libnetwork.OptionExtraHost("web", "192.168.0.2"))
1146 
+	if err != nil {
1147 
+		t.Fatal(err)
1148 
+	}
1149 
+	defer func() {
1150 
+		if err := sbx2.Delete(); err != nil {
1151 
+			t.Fatal(err)
1152 
+		}
1153 
+	}()
1154 
+
1155 
+	err = ep1.Join(sbx1)
1156 
+	if err != nil {
1157 
+		t.Fatal(err)
1158 
+	}
1159 
+
1160 
+	err = ep2.Join(sbx2)
1161 
+	if err != nil {
1162 
+		t.Fatal(err)
1163 
+	}
1164 
+}
1165 
+
1166 
+func TestInvalidRemoteDriver(t *testing.T) {
1167 
+	mux := http.NewServeMux()
1168 
+	server := httptest.NewServer(mux)
1169 
+	if server == nil {
1170 
+		t.Fatal("Failed to start an HTTP Server")
1171 
+	}
1172 
+	defer server.Close()
1173 
+
1174 
+	mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {
1175 
+		w.Header().Set("Content-Type", plugins.VersionMimetype)
1176 
+		fmt.Fprintln(w, `{"Implements": ["InvalidDriver"]}`)
1177 
+	})
1178 
+
1179 
+	if err := os.MkdirAll(specPath, 0o755); err != nil {
1180 
+		t.Fatal(err)
1181 
+	}
1182 
+	defer func() {
1183 
+		if err := os.RemoveAll(specPath); err != nil {
1184 
+			t.Fatal(err)
1185 
+		}
1186 
+	}()
1187 
+
1188 
+	if err := os.WriteFile(filepath.Join(specPath, "invalid-network-driver.spec"), []byte(server.URL), 0o644); err != nil {
1189 
+		t.Fatal(err)
1190 
+	}
1191 
+
1192 
+	ctrlr, err := libnetwork.New()
1193 
+	if err != nil {
1194 
+		t.Fatal(err)
1195 
+	}
1196 
+	defer ctrlr.Stop()
1197 
+
1198 
+	_, err = ctrlr.NewNetwork("invalid-network-driver", "dummy", "",
1199 
+		libnetwork.NetworkOptionGeneric(getEmptyGenericOption()))
1200 
+	if err == nil {
1201 
+		t.Fatal("Expected to fail. But instead succeeded")
1202 
+	}
1203 
+
1204 
+	if !errors.Is(err, plugins.ErrNotImplements) {
1205 
+		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
1206 
+	}
1207 
+}
1208 
+
1209 
+func TestValidRemoteDriver(t *testing.T) {
1210 
+	mux := http.NewServeMux()
1211 
+	server := httptest.NewServer(mux)
1212 
+	if server == nil {
1213 
+		t.Fatal("Failed to start an HTTP Server")
1214 
+	}
1215 
+	defer server.Close()
1216 
+
1217 
+	mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {
1218 
+		w.Header().Set("Content-Type", plugins.VersionMimetype)
1219 
+		fmt.Fprintf(w, `{"Implements": ["%s"]}`, driverapi.NetworkPluginEndpointType)
1220 
+	})
1221 
+	mux.HandleFunc(fmt.Sprintf("/%s.GetCapabilities", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
1222 
+		w.Header().Set("Content-Type", plugins.VersionMimetype)
1223 
+		fmt.Fprintf(w, `{"Scope":"local"}`)
1224 
+	})
1225 
+	mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
1226 
+		w.Header().Set("Content-Type", plugins.VersionMimetype)
1227 
+		fmt.Fprintf(w, "null")
1228 
+	})
1229 
+	mux.HandleFunc(fmt.Sprintf("/%s.DeleteNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
1230 
+		w.Header().Set("Content-Type", plugins.VersionMimetype)
1231 
+		fmt.Fprintf(w, "null")
1232 
+	})
1233 
+
1234 
+	if err := os.MkdirAll(specPath, 0o755); err != nil {
1235 
+		t.Fatal(err)
1236 
+	}
1237 
+	defer func() {
1238 
+		if err := os.RemoveAll(specPath); err != nil {
1239 
+			t.Fatal(err)
1240 
+		}
1241 
+	}()
1242 
+
1243 
+	if err := os.WriteFile(filepath.Join(specPath, "valid-network-driver.spec"), []byte(server.URL), 0o644); err != nil {
1244 
+		t.Fatal(err)
1245 
+	}
1246 
+
1247 
+	controller := newController(t)
1248 
+	n, err := controller.NewNetwork("valid-network-driver", "dummy", "",
1249 
+		libnetwork.NetworkOptionGeneric(getEmptyGenericOption()))
1250 
+	if err != nil {
1251 
+		// Only fail if we could not find the plugin driver
1252 
+		if isNotFound(err) {
1253 
+			t.Fatal(err)
1254 
+		}
1255 
+		return
1256 
+	}
1257 
+	defer func() {
1258 
+		if err := n.Delete(); err != nil {
1259 
+			t.Fatal(err)
1260 
+		}
1261 
+	}()
1262 
+}
1263 
+
34 1264 
 func makeTesthostNetwork(t *testing.T, c *libnetwork.Controller) *libnetwork.Network {
35 1265 
 	t.Helper()
36 1266 
 	n, err := createTestNetwork(c, "host", "testhost", options.Generic{}, nil, nil)
libnetwork/libnetwork_test.go
History View file @ 8bf6201
37 1267 
deleted file mode 100644
... ... 
@@ -1,1254 +0,0 @@
1 
-//go:build linux
2 
-
3 
-package libnetwork_test
4 
-
5 
-import (
6 
-	"errors"
7 
-	"fmt"
8 
-	"net/http"
9 
-	"net/http/httptest"
10 
-	"os"
11 
-	"path/filepath"
12 
-	"testing"
13 
-
14 
-	"github.com/docker/docker/internal/testutils/netnsutils"
15 
-	"github.com/docker/docker/libnetwork"
16 
-	"github.com/docker/docker/libnetwork/config"
17 
-	"github.com/docker/docker/libnetwork/datastore"
18 
-	"github.com/docker/docker/libnetwork/driverapi"
19 
-	"github.com/docker/docker/libnetwork/ipamapi"
20 
-	"github.com/docker/docker/libnetwork/netlabel"
21 
-	"github.com/docker/docker/libnetwork/options"
22 
-	"github.com/docker/docker/libnetwork/types"
23 
-	"github.com/docker/docker/pkg/plugins"
24 
-)
25 
-
26 
-func TestMain(m *testing.M) {
27 
-	// Cleanup local datastore file
28 
-	_ = os.Remove(datastore.DefaultScope("").Client.Address)
29 
-
30 
-	os.Exit(m.Run())
31 
-}
32 
-
33 
-func newController(t *testing.T) *libnetwork.Controller {
34 
-	t.Helper()
35 
-	c, err := libnetwork.New(
36 
-		libnetwork.OptionBoltdbWithRandomDBFile(t),
37 
-		config.OptionDriverConfig(bridgeNetType, map[string]interface{}{
38 
-			netlabel.GenericData: options.Generic{
39 
-				"EnableIPForwarding": true,
40 
-			},
41 
-		}),
42 
-	)
43 
-	if err != nil {
44 
-		t.Fatal(err)
45 
-	}
46 
-	t.Cleanup(c.Stop)
47 
-	return c
48 
-}
49 
-
50 
-func createTestNetwork(c *libnetwork.Controller, networkType, networkName string, netOption options.Generic, ipamV4Configs, ipamV6Configs []*libnetwork.IpamConf) (*libnetwork.Network, error) {
51 
-	return c.NewNetwork(networkType, networkName, "",
52 
-		libnetwork.NetworkOptionGeneric(netOption),
53 
-		libnetwork.NetworkOptionIpam(ipamapi.DefaultIPAM, "", ipamV4Configs, ipamV6Configs, nil))
54 
-}
55 
-
56 
-func getEmptyGenericOption() map[string]interface{} {
57 
-	return map[string]interface{}{netlabel.GenericData: map[string]string{}}
58 
-}
59 
-
60 
-func getPortMapping() []types.PortBinding {
61 
-	return []types.PortBinding{
62 
-		{Proto: types.TCP, Port: uint16(230), HostPort: uint16(23000)},
63 
-		{Proto: types.UDP, Port: uint16(200), HostPort: uint16(22000)},
64 
-		{Proto: types.TCP, Port: uint16(120), HostPort: uint16(12000)},
65 
-		{Proto: types.TCP, Port: uint16(320), HostPort: uint16(32000), HostPortEnd: uint16(32999)},
66 
-		{Proto: types.UDP, Port: uint16(420), HostPort: uint16(42000), HostPortEnd: uint16(42001)},
67 
-	}
68 
-}
69 
-
70 
-func isNotFound(err error) bool {
71 
-	_, ok := (err).(types.NotFoundError)
72 
-	return ok
73 
-}
74 
-
75 
-func TestNull(t *testing.T) {
76 
-	defer netnsutils.SetupTestOSContext(t)()
77 
-	controller := newController(t)
78 
-
79 
-	cnt, err := controller.NewSandbox("null_container",
80 
-		libnetwork.OptionHostname("test"),
81 
-		libnetwork.OptionDomainname("example.com"),
82 
-		libnetwork.OptionExtraHost("web", "192.168.0.1"))
83 
-	if err != nil {
84 
-		t.Fatal(err)
85 
-	}
86 
-
87 
-	network, err := createTestNetwork(controller, "null", "testnull", options.Generic{}, nil, nil)
88 
-	if err != nil {
89 
-		t.Fatal(err)
90 
-	}
91 
-
92 
-	ep, err := network.CreateEndpoint("testep")
93 
-	if err != nil {
94 
-		t.Fatal(err)
95 
-	}
96 
-
97 
-	err = ep.Join(cnt)
98 
-	if err != nil {
99 
-		t.Fatal(err)
100 
-	}
101 
-
102 
-	err = ep.Leave(cnt)
103 
-	if err != nil {
104 
-		t.Fatal(err)
105 
-	}
106 
-
107 
-	if err := ep.Delete(false); err != nil {
108 
-		t.Fatal(err)
109 
-	}
110 
-
111 
-	if err := cnt.Delete(); err != nil {
112 
-		t.Fatal(err)
113 
-	}
114 
-
115 
-	// host type is special network. Cannot be removed.
116 
-	err = network.Delete()
117 
-	if err == nil {
118 
-		t.Fatal(err)
119 
-	}
120 
-	if _, ok := err.(types.ForbiddenError); !ok {
121 
-		t.Fatalf("Unexpected error type")
122 
-	}
123 
-}
124 
-
125 
-func TestUnknownDriver(t *testing.T) {
126 
-	defer netnsutils.SetupTestOSContext(t)()
127 
-	controller := newController(t)
128 
-
129 
-	_, err := createTestNetwork(controller, "unknowndriver", "testnetwork", options.Generic{}, nil, nil)
130 
-	if err == nil {
131 
-		t.Fatal("Expected to fail. But instead succeeded")
132 
-	}
133 
-
134 
-	if !isNotFound(err) {
135 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
136 
-	}
137 
-}
138 
-
139 
-func TestNilRemoteDriver(t *testing.T) {
140 
-	defer netnsutils.SetupTestOSContext(t)()
141 
-	controller := newController(t)
142 
-
143 
-	_, err := controller.NewNetwork("framerelay", "dummy", "",
144 
-		libnetwork.NetworkOptionGeneric(getEmptyGenericOption()))
145 
-	if err == nil {
146 
-		t.Fatal("Expected to fail. But instead succeeded")
147 
-	}
148 
-
149 
-	if !isNotFound(err) {
150 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
151 
-	}
152 
-}
153 
-
154 
-func TestNetworkName(t *testing.T) {
155 
-	defer netnsutils.SetupTestOSContext(t)()
156 
-	controller := newController(t)
157 
-
158 
-	netOption := options.Generic{
159 
-		netlabel.GenericData: options.Generic{
160 
-			"BridgeName": "testnetwork",
161 
-		},
162 
-	}
163 
-
164 
-	_, err := createTestNetwork(controller, bridgeNetType, "", netOption, nil, nil)
165 
-	if err == nil {
166 
-		t.Fatal("Expected to fail. But instead succeeded")
167 
-	}
168 
-
169 
-	if _, ok := err.(libnetwork.ErrInvalidName); !ok {
170 
-		t.Fatalf("Expected to fail with ErrInvalidName error. Got %v", err)
171 
-	}
172 
-
173 
-	networkName := "testnetwork"
174 
-	n, err := createTestNetwork(controller, bridgeNetType, networkName, netOption, nil, nil)
175 
-	if err != nil {
176 
-		t.Fatal(err)
177 
-	}
178 
-	defer func() {
179 
-		if err := n.Delete(); err != nil {
180 
-			t.Fatal(err)
181 
-		}
182 
-	}()
183 
-
184 
-	if n.Name() != networkName {
185 
-		t.Fatalf("Expected network name %s, got %s", networkName, n.Name())
186 
-	}
187 
-}
188 
-
189 
-func TestNetworkType(t *testing.T) {
190 
-	defer netnsutils.SetupTestOSContext(t)()
191 
-	controller := newController(t)
192 
-
193 
-	netOption := options.Generic{
194 
-		netlabel.GenericData: options.Generic{
195 
-			"BridgeName": "testnetwork",
196 
-		},
197 
-	}
198 
-
199 
-	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", netOption, nil, nil)
200 
-	if err != nil {
201 
-		t.Fatal(err)
202 
-	}
203 
-	defer func() {
204 
-		if err := n.Delete(); err != nil {
205 
-			t.Fatal(err)
206 
-		}
207 
-	}()
208 
-
209 
-	if n.Type() != bridgeNetType {
210 
-		t.Fatalf("Expected network type %s, got %s", bridgeNetType, n.Type())
211 
-	}
212 
-}
213 
-
214 
-func TestNetworkID(t *testing.T) {
215 
-	defer netnsutils.SetupTestOSContext(t)()
216 
-	controller := newController(t)
217 
-
218 
-	netOption := options.Generic{
219 
-		netlabel.GenericData: options.Generic{
220 
-			"BridgeName": "testnetwork",
221 
-		},
222 
-	}
223 
-
224 
-	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", netOption, nil, nil)
225 
-	if err != nil {
226 
-		t.Fatal(err)
227 
-	}
228 
-	defer func() {
229 
-		if err := n.Delete(); err != nil {
230 
-			t.Fatal(err)
231 
-		}
232 
-	}()
233 
-
234 
-	if n.ID() == "" {
235 
-		t.Fatal("Expected non-empty network id")
236 
-	}
237 
-}
238 
-
239 
-func TestDeleteNetworkWithActiveEndpoints(t *testing.T) {
240 
-	defer netnsutils.SetupTestOSContext(t)()
241 
-	controller := newController(t)
242 
-
243 
-	netOption := options.Generic{
244 
-		"BridgeName": "testnetwork",
245 
-	}
246 
-	option := options.Generic{
247 
-		netlabel.GenericData: netOption,
248 
-	}
249 
-
250 
-	network, err := createTestNetwork(controller, bridgeNetType, "testnetwork", option, nil, nil)
251 
-	if err != nil {
252 
-		t.Fatal(err)
253 
-	}
254 
-
255 
-	ep, err := network.CreateEndpoint("testep")
256 
-	if err != nil {
257 
-		t.Fatal(err)
258 
-	}
259 
-
260 
-	err = network.Delete()
261 
-	if err == nil {
262 
-		t.Fatal("Expected to fail. But instead succeeded")
263 
-	}
264 
-
265 
-	if _, ok := err.(*libnetwork.ActiveEndpointsError); !ok {
266 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
267 
-	}
268 
-
269 
-	// Done testing. Now cleanup.
270 
-	if err := ep.Delete(false); err != nil {
271 
-		t.Fatal(err)
272 
-	}
273 
-
274 
-	if err := network.Delete(); err != nil {
275 
-		t.Fatal(err)
276 
-	}
277 
-}
278 
-
279 
-func TestNetworkConfig(t *testing.T) {
280 
-	defer netnsutils.SetupTestOSContext(t)()
281 
-	controller := newController(t)
282 
-
283 
-	// Verify config network cannot inherit another config network
284 
-	_, err := controller.NewNetwork("bridge", "config_network0", "",
285 
-		libnetwork.NetworkOptionConfigOnly(),
286 
-		libnetwork.NetworkOptionConfigFrom("anotherConfigNw"))
287 
-
288 
-	if err == nil {
289 
-		t.Fatal("Expected to fail. But instead succeeded")
290 
-	}
291 
-	if _, ok := err.(types.ForbiddenError); !ok {
292 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
293 
-	}
294 
-
295 
-	// Create supported config network
296 
-	netOption := options.Generic{
297 
-		"EnableICC": false,
298 
-	}
299 
-	option := options.Generic{
300 
-		netlabel.GenericData: netOption,
301 
-	}
302 
-	ipamV4ConfList := []*libnetwork.IpamConf{{PreferredPool: "192.168.100.0/24", SubPool: "192.168.100.128/25", Gateway: "192.168.100.1"}}
303 
-	ipamV6ConfList := []*libnetwork.IpamConf{{PreferredPool: "2001:db8:abcd::/64", SubPool: "2001:db8:abcd::ef99/80", Gateway: "2001:db8:abcd::22"}}
304 
-
305 
-	netOptions := []libnetwork.NetworkOption{
306 
-		libnetwork.NetworkOptionConfigOnly(),
307 
-		libnetwork.NetworkOptionEnableIPv6(true),
308 
-		libnetwork.NetworkOptionGeneric(option),
309 
-		libnetwork.NetworkOptionIpam("default", "", ipamV4ConfList, ipamV6ConfList, nil),
310 
-	}
311 
-
312 
-	configNetwork, err := controller.NewNetwork(bridgeNetType, "config_network0", "", netOptions...)
313 
-	if err != nil {
314 
-		t.Fatal(err)
315 
-	}
316 
-
317 
-	// Verify a config-only network cannot be created with network operator configurations
318 
-	for i, opt := range []libnetwork.NetworkOption{
319 
-		libnetwork.NetworkOptionInternalNetwork(),
320 
-		libnetwork.NetworkOptionAttachable(true),
321 
-		libnetwork.NetworkOptionIngress(true),
322 
-	} {
323 
-		_, err = controller.NewNetwork(bridgeNetType, "testBR", "",
324 
-			libnetwork.NetworkOptionConfigOnly(), opt)
325 
-		if err == nil {
326 
-			t.Fatalf("Expected to fail. But instead succeeded for option: %d", i)
327 
-		}
328 
-		if _, ok := err.(types.ForbiddenError); !ok {
329 
-			t.Fatalf("Did not fail with expected error. Actual error: %v", err)
330 
-		}
331 
-	}
332 
-
333 
-	// Verify a network cannot be created with both config-from and network specific configurations
334 
-	for i, opt := range []libnetwork.NetworkOption{
335 
-		libnetwork.NetworkOptionEnableIPv6(true),
336 
-		libnetwork.NetworkOptionIpam("my-ipam", "", nil, nil, nil),
337 
-		libnetwork.NetworkOptionIpam("", "", ipamV4ConfList, nil, nil),
338 
-		libnetwork.NetworkOptionIpam("", "", nil, ipamV6ConfList, nil),
339 
-		libnetwork.NetworkOptionLabels(map[string]string{"number": "two"}),
340 
-		libnetwork.NetworkOptionDriverOpts(map[string]string{"com.docker.network.driver.mtu": "1600"}),
341 
-	} {
342 
-		_, err = controller.NewNetwork(bridgeNetType, "testBR", "",
343 
-			libnetwork.NetworkOptionConfigFrom("config_network0"), opt)
344 
-		if err == nil {
345 
-			t.Fatalf("Expected to fail. But instead succeeded for option: %d", i)
346 
-		}
347 
-		if _, ok := err.(types.ForbiddenError); !ok {
348 
-			t.Fatalf("Did not fail with expected error. Actual error: %v", err)
349 
-		}
350 
-	}
351 
-
352 
-	// Create a valid network
353 
-	network, err := controller.NewNetwork(bridgeNetType, "testBR", "",
354 
-		libnetwork.NetworkOptionConfigFrom("config_network0"))
355 
-	if err != nil {
356 
-		t.Fatal(err)
357 
-	}
358 
-
359 
-	// Verify the config network cannot be removed
360 
-	err = configNetwork.Delete()
361 
-	if err == nil {
362 
-		t.Fatal("Expected to fail. But instead succeeded")
363 
-	}
364 
-
365 
-	if _, ok := err.(types.ForbiddenError); !ok {
366 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
367 
-	}
368 
-
369 
-	// Delete network
370 
-	if err := network.Delete(); err != nil {
371 
-		t.Fatal(err)
372 
-	}
373 
-
374 
-	// Verify the config network can now be removed
375 
-	if err := configNetwork.Delete(); err != nil {
376 
-		t.Fatal(err)
377 
-	}
378 
-}
379 
-
380 
-func TestUnknownNetwork(t *testing.T) {
381 
-	defer netnsutils.SetupTestOSContext(t)()
382 
-	controller := newController(t)
383 
-
384 
-	netOption := options.Generic{
385 
-		"BridgeName": "testnetwork",
386 
-	}
387 
-	option := options.Generic{
388 
-		netlabel.GenericData: netOption,
389 
-	}
390 
-
391 
-	network, err := createTestNetwork(controller, bridgeNetType, "testnetwork", option, nil, nil)
392 
-	if err != nil {
393 
-		t.Fatal(err)
394 
-	}
395 
-
396 
-	err = network.Delete()
397 
-	if err != nil {
398 
-		t.Fatal(err)
399 
-	}
400 
-
401 
-	err = network.Delete()
402 
-	if err == nil {
403 
-		t.Fatal("Expected to fail. But instead succeeded")
404 
-	}
405 
-
406 
-	if _, ok := err.(*libnetwork.UnknownNetworkError); !ok {
407 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
408 
-	}
409 
-}
410 
-
411 
-func TestUnknownEndpoint(t *testing.T) {
412 
-	defer netnsutils.SetupTestOSContext(t)()
413 
-	controller := newController(t)
414 
-
415 
-	netOption := options.Generic{
416 
-		"BridgeName": "testnetwork",
417 
-	}
418 
-	option := options.Generic{
419 
-		netlabel.GenericData: netOption,
420 
-	}
421 
-	ipamV4ConfList := []*libnetwork.IpamConf{{PreferredPool: "192.168.100.0/24"}}
422 
-
423 
-	network, err := createTestNetwork(controller, bridgeNetType, "testnetwork", option, ipamV4ConfList, nil)
424 
-	if err != nil {
425 
-		t.Fatal(err)
426 
-	}
427 
-
428 
-	_, err = network.CreateEndpoint("")
429 
-	if err == nil {
430 
-		t.Fatal("Expected to fail. But instead succeeded")
431 
-	}
432 
-	if _, ok := err.(libnetwork.ErrInvalidName); !ok {
433 
-		t.Fatalf("Expected to fail with ErrInvalidName error. Actual error: %v", err)
434 
-	}
435 
-
436 
-	ep, err := network.CreateEndpoint("testep")
437 
-	if err != nil {
438 
-		t.Fatal(err)
439 
-	}
440 
-
441 
-	err = ep.Delete(false)
442 
-	if err != nil {
443 
-		t.Fatal(err)
444 
-	}
445 
-
446 
-	// Done testing. Now cleanup
447 
-	if err := network.Delete(); err != nil {
448 
-		t.Fatal(err)
449 
-	}
450 
-}
451 
-
452 
-func TestNetworkEndpointsWalkers(t *testing.T) {
453 
-	defer netnsutils.SetupTestOSContext(t)()
454 
-	controller := newController(t)
455 
-
456 
-	// Create network 1 and add 2 endpoint: ep11, ep12
457 
-	netOption := options.Generic{
458 
-		netlabel.GenericData: options.Generic{
459 
-			"BridgeName": "network1",
460 
-		},
461 
-	}
462 
-
463 
-	net1, err := createTestNetwork(controller, bridgeNetType, "network1", netOption, nil, nil)
464 
-	if err != nil {
465 
-		t.Fatal(err)
466 
-	}
467 
-	defer func() {
468 
-		if err := net1.Delete(); err != nil {
469 
-			t.Fatal(err)
470 
-		}
471 
-	}()
472 
-
473 
-	ep11, err := net1.CreateEndpoint("ep11")
474 
-	if err != nil {
475 
-		t.Fatal(err)
476 
-	}
477 
-	defer func() {
478 
-		if err := ep11.Delete(false); err != nil {
479 
-			t.Fatal(err)
480 
-		}
481 
-	}()
482 
-
483 
-	ep12, err := net1.CreateEndpoint("ep12")
484 
-	if err != nil {
485 
-		t.Fatal(err)
486 
-	}
487 
-	defer func() {
488 
-		if err := ep12.Delete(false); err != nil {
489 
-			t.Fatal(err)
490 
-		}
491 
-	}()
492 
-
493 
-	// Test list methods on net1
494 
-	epList1 := net1.Endpoints()
495 
-	if len(epList1) != 2 {
496 
-		t.Fatalf("Endpoints() returned wrong number of elements: %d instead of 2", len(epList1))
497 
-	}
498 
-	// endpoint order is not guaranteed
499 
-	for _, e := range epList1 {
500 
-		if e != ep11 && e != ep12 {
501 
-			t.Fatal("Endpoints() did not return all the expected elements")
502 
-		}
503 
-	}
504 
-
505 
-	// Test Endpoint Walk method
506 
-	var epName string
507 
-	var epWanted *libnetwork.Endpoint
508 
-	wlk := func(ep *libnetwork.Endpoint) bool {
509 
-		if ep.Name() == epName {
510 
-			epWanted = ep
511 
-			return true
512 
-		}
513 
-		return false
514 
-	}
515 
-
516 
-	// Look for ep1 on network1
517 
-	epName = "ep11"
518 
-	net1.WalkEndpoints(wlk)
519 
-	if epWanted == nil {
520 
-		t.Fatal(err)
521 
-	}
522 
-	if ep11 != epWanted {
523 
-		t.Fatal(err)
524 
-	}
525 
-
526 
-	current := len(controller.Networks())
527 
-
528 
-	// Create network 2
529 
-	netOption = options.Generic{
530 
-		netlabel.GenericData: options.Generic{
531 
-			"BridgeName": "network2",
532 
-		},
533 
-	}
534 
-
535 
-	net2, err := createTestNetwork(controller, bridgeNetType, "network2", netOption, nil, nil)
536 
-	if err != nil {
537 
-		t.Fatal(err)
538 
-	}
539 
-	defer func() {
540 
-		if err := net2.Delete(); err != nil {
541 
-			t.Fatal(err)
542 
-		}
543 
-	}()
544 
-
545 
-	// Test Networks method
546 
-	if len(controller.Networks()) != current+1 {
547 
-		t.Fatalf("Did not find the expected number of networks")
548 
-	}
549 
-
550 
-	// Test Network Walk method
551 
-	var netName string
552 
-	var netWanted *libnetwork.Network
553 
-	nwWlk := func(nw *libnetwork.Network) bool {
554 
-		if nw.Name() == netName {
555 
-			netWanted = nw
556 
-			return true
557 
-		}
558 
-		return false
559 
-	}
560 
-
561 
-	// Look for network named "network1" and "network2"
562 
-	netName = "network1"
563 
-	controller.WalkNetworks(nwWlk)
564 
-	if netWanted == nil {
565 
-		t.Fatal(err)
566 
-	}
567 
-	if net1.ID() != netWanted.ID() {
568 
-		t.Fatal(err)
569 
-	}
570 
-
571 
-	netName = "network2"
572 
-	controller.WalkNetworks(nwWlk)
573 
-	if netWanted == nil {
574 
-		t.Fatal(err)
575 
-	}
576 
-	if net2.ID() != netWanted.ID() {
577 
-		t.Fatal(err)
578 
-	}
579 
-}
580 
-
581 
-func TestDuplicateEndpoint(t *testing.T) {
582 
-	defer netnsutils.SetupTestOSContext(t)()
583 
-	controller := newController(t)
584 
-
585 
-	netOption := options.Generic{
586 
-		netlabel.GenericData: options.Generic{
587 
-			"BridgeName": "testnetwork",
588 
-		},
589 
-	}
590 
-	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", netOption, nil, nil)
591 
-	if err != nil {
592 
-		t.Fatal(err)
593 
-	}
594 
-	defer func() {
595 
-		if err := n.Delete(); err != nil {
596 
-			t.Fatal(err)
597 
-		}
598 
-	}()
599 
-
600 
-	ep, err := n.CreateEndpoint("ep1")
601 
-	if err != nil {
602 
-		t.Fatal(err)
603 
-	}
604 
-	defer func() {
605 
-		if err := ep.Delete(false); err != nil {
606 
-			t.Fatal(err)
607 
-		}
608 
-	}()
609 
-
610 
-	ep2, err := n.CreateEndpoint("ep1")
611 
-	defer func() {
612 
-		// Cleanup ep2 as well, else network cleanup might fail for failure cases
613 
-		if ep2 != nil {
614 
-			if err := ep2.Delete(false); err != nil {
615 
-				t.Fatal(err)
616 
-			}
617 
-		}
618 
-	}()
619 
-
620 
-	if err == nil {
621 
-		t.Fatal("Expected to fail. But instead succeeded")
622 
-	}
623 
-
624 
-	if _, ok := err.(types.ForbiddenError); !ok {
625 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
626 
-	}
627 
-}
628 
-
629 
-func TestControllerQuery(t *testing.T) {
630 
-	defer netnsutils.SetupTestOSContext(t)()
631 
-	controller := newController(t)
632 
-
633 
-	// Create network 1
634 
-	netOption := options.Generic{
635 
-		netlabel.GenericData: options.Generic{
636 
-			"BridgeName": "network1",
637 
-		},
638 
-	}
639 
-	net1, err := createTestNetwork(controller, bridgeNetType, "network1", netOption, nil, nil)
640 
-	if err != nil {
641 
-		t.Fatal(err)
642 
-	}
643 
-	defer func() {
644 
-		if err := net1.Delete(); err != nil {
645 
-			t.Fatal(err)
646 
-		}
647 
-	}()
648 
-
649 
-	// Create network 2
650 
-	netOption = options.Generic{
651 
-		netlabel.GenericData: options.Generic{
652 
-			"BridgeName": "network2",
653 
-		},
654 
-	}
655 
-	net2, err := createTestNetwork(controller, bridgeNetType, "network2", netOption, nil, nil)
656 
-	if err != nil {
657 
-		t.Fatal(err)
658 
-	}
659 
-	defer func() {
660 
-		if err := net2.Delete(); err != nil {
661 
-			t.Fatal(err)
662 
-		}
663 
-	}()
664 
-
665 
-	_, err = controller.NetworkByName("")
666 
-	if err == nil {
667 
-		t.Fatalf("NetworkByName() succeeded with invalid target name")
668 
-	}
669 
-	if _, ok := err.(libnetwork.ErrInvalidName); !ok {
670 
-		t.Fatalf("Expected NetworkByName() to fail with ErrInvalidName error. Got: %v", err)
671 
-	}
672 
-
673 
-	_, err = controller.NetworkByID("")
674 
-	if err == nil {
675 
-		t.Fatalf("NetworkByID() succeeded with invalid target id")
676 
-	}
677 
-	if _, ok := err.(libnetwork.ErrInvalidID); !ok {
678 
-		t.Fatalf("NetworkByID() failed with unexpected error: %v", err)
679 
-	}
680 
-
681 
-	g, err := controller.NetworkByID("network1")
682 
-	if err == nil {
683 
-		t.Fatalf("Unexpected success for NetworkByID(): %v", g)
684 
-	}
685 
-	if _, ok := err.(libnetwork.ErrNoSuchNetwork); !ok {
686 
-		t.Fatalf("NetworkByID() failed with unexpected error: %v", err)
687 
-	}
688 
-
689 
-	g, err = controller.NetworkByName("network1")
690 
-	if err != nil {
691 
-		t.Fatalf("Unexpected failure for NetworkByName(): %v", err)
692 
-	}
693 
-	if g == nil {
694 
-		t.Fatalf("NetworkByName() did not find the network")
695 
-	}
696 
-
697 
-	if g != net1 {
698 
-		t.Fatalf("NetworkByName() returned the wrong network")
699 
-	}
700 
-
701 
-	g, err = controller.NetworkByID(net1.ID())
702 
-	if err != nil {
703 
-		t.Fatalf("Unexpected failure for NetworkByID(): %v", err)
704 
-	}
705 
-	if net1.ID() != g.ID() {
706 
-		t.Fatalf("NetworkByID() returned unexpected element: %v", g)
707 
-	}
708 
-
709 
-	g, err = controller.NetworkByName("network2")
710 
-	if err != nil {
711 
-		t.Fatalf("Unexpected failure for NetworkByName(): %v", err)
712 
-	}
713 
-	if g == nil {
714 
-		t.Fatalf("NetworkByName() did not find the network")
715 
-	}
716 
-
717 
-	if g != net2 {
718 
-		t.Fatalf("NetworkByName() returned the wrong network")
719 
-	}
720 
-
721 
-	g, err = controller.NetworkByID(net2.ID())
722 
-	if err != nil {
723 
-		t.Fatalf("Unexpected failure for NetworkByID(): %v", err)
724 
-	}
725 
-	if net2.ID() != g.ID() {
726 
-		t.Fatalf("NetworkByID() returned unexpected element: %v", g)
727 
-	}
728 
-}
729 
-
730 
-func TestNetworkQuery(t *testing.T) {
731 
-	defer netnsutils.SetupTestOSContext(t)()
732 
-	controller := newController(t)
733 
-
734 
-	// Create network 1 and add 2 endpoint: ep11, ep12
735 
-	netOption := options.Generic{
736 
-		netlabel.GenericData: options.Generic{
737 
-			"BridgeName": "network1",
738 
-		},
739 
-	}
740 
-	net1, err := createTestNetwork(controller, bridgeNetType, "network1", netOption, nil, nil)
741 
-	if err != nil {
742 
-		t.Fatal(err)
743 
-	}
744 
-	defer func() {
745 
-		if err := net1.Delete(); err != nil {
746 
-			t.Fatal(err)
747 
-		}
748 
-	}()
749 
-
750 
-	ep11, err := net1.CreateEndpoint("ep11")
751 
-	if err != nil {
752 
-		t.Fatal(err)
753 
-	}
754 
-	defer func() {
755 
-		if err := ep11.Delete(false); err != nil {
756 
-			t.Fatal(err)
757 
-		}
758 
-	}()
759 
-
760 
-	ep12, err := net1.CreateEndpoint("ep12")
761 
-	if err != nil {
762 
-		t.Fatal(err)
763 
-	}
764 
-	defer func() {
765 
-		if err := ep12.Delete(false); err != nil {
766 
-			t.Fatal(err)
767 
-		}
768 
-	}()
769 
-
770 
-	e, err := net1.EndpointByName("ep11")
771 
-	if err != nil {
772 
-		t.Fatal(err)
773 
-	}
774 
-	if ep11 != e {
775 
-		t.Fatalf("EndpointByName() returned %v instead of %v", e, ep11)
776 
-	}
777 
-
778 
-	_, err = net1.EndpointByName("")
779 
-	if err == nil {
780 
-		t.Fatalf("EndpointByName() succeeded with invalid target name")
781 
-	}
782 
-	if _, ok := err.(libnetwork.ErrInvalidName); !ok {
783 
-		t.Fatalf("Expected EndpointByName() to fail with ErrInvalidName error. Got: %v", err)
784 
-	}
785 
-
786 
-	e, err = net1.EndpointByName("IamNotAnEndpoint")
787 
-	if err == nil {
788 
-		t.Fatalf("EndpointByName() succeeded with unknown target name")
789 
-	}
790 
-	if _, ok := err.(libnetwork.ErrNoSuchEndpoint); !ok {
791 
-		t.Fatal(err)
792 
-	}
793 
-	if e != nil {
794 
-		t.Fatalf("EndpointByName(): expected nil, got %v", e)
795 
-	}
796 
-
797 
-	e, err = net1.EndpointByID(ep12.ID())
798 
-	if err != nil {
799 
-		t.Fatal(err)
800 
-	}
801 
-	if ep12.ID() != e.ID() {
802 
-		t.Fatalf("EndpointByID() returned %v instead of %v", e, ep12)
803 
-	}
804 
-
805 
-	_, err = net1.EndpointByID("")
806 
-	if err == nil {
807 
-		t.Fatalf("EndpointByID() succeeded with invalid target id")
808 
-	}
809 
-	if _, ok := err.(libnetwork.ErrInvalidID); !ok {
810 
-		t.Fatalf("EndpointByID() failed with unexpected error: %v", err)
811 
-	}
812 
-}
813 
-
814 
-const containerID = "valid_c"
815 
-
816 
-func TestEndpointDeleteWithActiveContainer(t *testing.T) {
817 
-	defer netnsutils.SetupTestOSContext(t)()
818 
-	controller := newController(t)
819 
-
820 
-	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", options.Generic{
821 
-		netlabel.GenericData: options.Generic{
822 
-			"BridgeName": "testnetwork",
823 
-		},
824 
-	}, nil, nil)
825 
-	if err != nil {
826 
-		t.Fatal(err)
827 
-	}
828 
-	defer func() {
829 
-		if err := n.Delete(); err != nil {
830 
-			t.Fatal(err)
831 
-		}
832 
-	}()
833 
-
834 
-	n2, err := createTestNetwork(controller, bridgeNetType, "testnetwork2", options.Generic{
835 
-		netlabel.GenericData: options.Generic{
836 
-			"BridgeName": "testnetwork2",
837 
-		},
838 
-	}, nil, nil)
839 
-	if err != nil {
840 
-		t.Fatal(err)
841 
-	}
842 
-	defer func() {
843 
-		if err := n2.Delete(); err != nil {
844 
-			t.Fatal(err)
845 
-		}
846 
-	}()
847 
-
848 
-	ep, err := n.CreateEndpoint("ep1")
849 
-	if err != nil {
850 
-		t.Fatal(err)
851 
-	}
852 
-	defer func() {
853 
-		err = ep.Delete(false)
854 
-		if err != nil {
855 
-			t.Fatal(err)
856 
-		}
857 
-	}()
858 
-
859 
-	cnt, err := controller.NewSandbox(containerID,
860 
-		libnetwork.OptionHostname("test"),
861 
-		libnetwork.OptionDomainname("example.com"),
862 
-		libnetwork.OptionExtraHost("web", "192.168.0.1"))
863 
-	defer func() {
864 
-		if err := cnt.Delete(); err != nil {
865 
-			t.Fatal(err)
866 
-		}
867 
-	}()
868 
-
869 
-	err = ep.Join(cnt)
870 
-	if err != nil {
871 
-		t.Fatal(err)
872 
-	}
873 
-	defer func() {
874 
-		err = ep.Leave(cnt)
875 
-		if err != nil {
876 
-			t.Fatal(err)
877 
-		}
878 
-	}()
879 
-
880 
-	err = ep.Delete(false)
881 
-	if err == nil {
882 
-		t.Fatal("Expected to fail. But instead succeeded")
883 
-	}
884 
-
885 
-	if _, ok := err.(*libnetwork.ActiveContainerError); !ok {
886 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
887 
-	}
888 
-}
889 
-
890 
-func TestEndpointMultipleJoins(t *testing.T) {
891 
-	defer netnsutils.SetupTestOSContext(t)()
892 
-	controller := newController(t)
893 
-
894 
-	n, err := createTestNetwork(controller, bridgeNetType, "testmultiple", options.Generic{
895 
-		netlabel.GenericData: options.Generic{
896 
-			"BridgeName": "testmultiple",
897 
-		},
898 
-	}, nil, nil)
899 
-	if err != nil {
900 
-		t.Fatal(err)
901 
-	}
902 
-	defer func() {
903 
-		if err := n.Delete(); err != nil {
904 
-			t.Fatal(err)
905 
-		}
906 
-	}()
907 
-
908 
-	ep, err := n.CreateEndpoint("ep1")
909 
-	if err != nil {
910 
-		t.Fatal(err)
911 
-	}
912 
-	defer func() {
913 
-		if err := ep.Delete(false); err != nil {
914 
-			t.Fatal(err)
915 
-		}
916 
-	}()
917 
-
918 
-	sbx1, err := controller.NewSandbox(containerID,
919 
-		libnetwork.OptionHostname("test"),
920 
-		libnetwork.OptionDomainname("example.com"),
921 
-		libnetwork.OptionExtraHost("web", "192.168.0.1"),
922 
-	)
923 
-	if err != nil {
924 
-		t.Fatal(err)
925 
-	}
926 
-	defer func() {
927 
-		if err := sbx1.Delete(); err != nil {
928 
-			t.Fatal(err)
929 
-		}
930 
-	}()
931 
-
932 
-	sbx2, err := controller.NewSandbox("c2")
933 
-	if err != nil {
934 
-		t.Fatal(err)
935 
-	}
936 
-	defer func() {
937 
-		if err := sbx2.Delete(); err != nil {
938 
-			t.Fatal(err)
939 
-		}
940 
-	}()
941 
-
942 
-	err = ep.Join(sbx1)
943 
-	if err != nil {
944 
-		t.Fatal(err)
945 
-	}
946 
-	defer func() {
947 
-		err = ep.Leave(sbx1)
948 
-		if err != nil {
949 
-			t.Fatal(err)
950 
-		}
951 
-	}()
952 
-
953 
-	err = ep.Join(sbx2)
954 
-	if err == nil {
955 
-		t.Fatal("Expected to fail multiple joins for the same endpoint")
956 
-	}
957 
-
958 
-	if _, ok := err.(types.ForbiddenError); !ok {
959 
-		t.Fatalf("Failed with unexpected error type: %T. Desc: %s", err, err.Error())
960 
-	}
961 
-}
962 
-
963 
-func TestLeaveAll(t *testing.T) {
964 
-	defer netnsutils.SetupTestOSContext(t)()
965 
-	controller := newController(t)
966 
-
967 
-	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", options.Generic{
968 
-		netlabel.GenericData: options.Generic{
969 
-			"BridgeName": "testnetwork",
970 
-		},
971 
-	}, nil, nil)
972 
-	if err != nil {
973 
-		t.Fatal(err)
974 
-	}
975 
-	defer func() {
976 
-		// If this goes through, it means cnt.Delete() effectively detached from all the endpoints
977 
-		if err := n.Delete(); err != nil {
978 
-			t.Fatal(err)
979 
-		}
980 
-	}()
981 
-
982 
-	n2, err := createTestNetwork(controller, bridgeNetType, "testnetwork2", options.Generic{
983 
-		netlabel.GenericData: options.Generic{
984 
-			"BridgeName": "testnetwork2",
985 
-		},
986 
-	}, nil, nil)
987 
-	if err != nil {
988 
-		t.Fatal(err)
989 
-	}
990 
-	defer func() {
991 
-		if err := n2.Delete(); err != nil {
992 
-			t.Fatal(err)
993 
-		}
994 
-	}()
995 
-
996 
-	ep1, err := n.CreateEndpoint("ep1")
997 
-	if err != nil {
998 
-		t.Fatal(err)
999 
-	}
1000 
-
1001 
-	ep2, err := n2.CreateEndpoint("ep2")
1002 
-	if err != nil {
1003 
-		t.Fatal(err)
1004 
-	}
1005 
-
1006 
-	cnt, err := controller.NewSandbox("leaveall")
1007 
-	if err != nil {
1008 
-		t.Fatal(err)
1009 
-	}
1010 
-
1011 
-	err = ep1.Join(cnt)
1012 
-	if err != nil {
1013 
-		t.Fatalf("Failed to join ep1: %v", err)
1014 
-	}
1015 
-
1016 
-	err = ep2.Join(cnt)
1017 
-	if err != nil {
1018 
-		t.Fatalf("Failed to join ep2: %v", err)
1019 
-	}
1020 
-
1021 
-	err = cnt.Delete()
1022 
-	if err != nil {
1023 
-		t.Fatal(err)
1024 
-	}
1025 
-}
1026 
-
1027 
-func TestContainerInvalidLeave(t *testing.T) {
1028 
-	defer netnsutils.SetupTestOSContext(t)()
1029 
-	controller := newController(t)
1030 
-
1031 
-	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", options.Generic{
1032 
-		netlabel.GenericData: options.Generic{
1033 
-			"BridgeName": "testnetwork",
1034 
-		},
1035 
-	}, nil, nil)
1036 
-	if err != nil {
1037 
-		t.Fatal(err)
1038 
-	}
1039 
-	defer func() {
1040 
-		if err := n.Delete(); err != nil {
1041 
-			t.Fatal(err)
1042 
-		}
1043 
-	}()
1044 
-
1045 
-	ep, err := n.CreateEndpoint("ep1")
1046 
-	if err != nil {
1047 
-		t.Fatal(err)
1048 
-	}
1049 
-	defer func() {
1050 
-		if err := ep.Delete(false); err != nil {
1051 
-			t.Fatal(err)
1052 
-		}
1053 
-	}()
1054 
-
1055 
-	cnt, err := controller.NewSandbox(containerID,
1056 
-		libnetwork.OptionHostname("test"),
1057 
-		libnetwork.OptionDomainname("example.com"),
1058 
-		libnetwork.OptionExtraHost("web", "192.168.0.1"))
1059 
-	if err != nil {
1060 
-		t.Fatal(err)
1061 
-	}
1062 
-	defer func() {
1063 
-		if err := cnt.Delete(); err != nil {
1064 
-			t.Fatal(err)
1065 
-		}
1066 
-	}()
1067 
-
1068 
-	err = ep.Leave(cnt)
1069 
-	if err == nil {
1070 
-		t.Fatal("Expected to fail leave from an endpoint which has no active join")
1071 
-	}
1072 
-	if _, ok := err.(types.ForbiddenError); !ok {
1073 
-		t.Fatalf("Failed with unexpected error type: %T. Desc: %s", err, err.Error())
1074 
-	}
1075 
-
1076 
-	if err = ep.Leave(nil); err == nil {
1077 
-		t.Fatalf("Expected to fail leave nil Sandbox")
1078 
-	}
1079 
-	if _, ok := err.(types.BadRequestError); !ok {
1080 
-		t.Fatalf("Unexpected error type returned: %T. Desc: %s", err, err.Error())
1081 
-	}
1082 
-
1083 
-	fsbx := &libnetwork.Sandbox{}
1084 
-	if err = ep.Leave(fsbx); err == nil {
1085 
-		t.Fatalf("Expected to fail leave with invalid Sandbox")
1086 
-	}
1087 
-	if _, ok := err.(types.BadRequestError); !ok {
1088 
-		t.Fatalf("Unexpected error type returned: %T. Desc: %s", err, err.Error())
1089 
-	}
1090 
-}
1091 
-
1092 
-func TestEndpointUpdateParent(t *testing.T) {
1093 
-	defer netnsutils.SetupTestOSContext(t)()
1094 
-	controller := newController(t)
1095 
-
1096 
-	n, err := createTestNetwork(controller, bridgeNetType, "testnetwork", options.Generic{
1097 
-		netlabel.GenericData: options.Generic{
1098 
-			"BridgeName": "testnetwork",
1099 
-		},
1100 
-	}, nil, nil)
1101 
-	if err != nil {
1102 
-		t.Fatal(err)
1103 
-	}
1104 
-	defer func() {
1105 
-		if err := n.Delete(); err != nil {
1106 
-			t.Fatal(err)
1107 
-		}
1108 
-	}()
1109 
-
1110 
-	ep1, err := n.CreateEndpoint("ep1")
1111 
-	if err != nil {
1112 
-		t.Fatal(err)
1113 
-	}
1114 
-
1115 
-	ep2, err := n.CreateEndpoint("ep2")
1116 
-	if err != nil {
1117 
-		t.Fatal(err)
1118 
-	}
1119 
-
1120 
-	sbx1, err := controller.NewSandbox(containerID,
1121 
-		libnetwork.OptionHostname("test"),
1122 
-		libnetwork.OptionDomainname("example.com"),
1123 
-		libnetwork.OptionExtraHost("web", "192.168.0.1"))
1124 
-	if err != nil {
1125 
-		t.Fatal(err)
1126 
-	}
1127 
-	defer func() {
1128 
-		if err := sbx1.Delete(); err != nil {
1129 
-			t.Fatal(err)
1130 
-		}
1131 
-	}()
1132 
-
1133 
-	sbx2, err := controller.NewSandbox("c2",
1134 
-		libnetwork.OptionHostname("test2"),
1135 
-		libnetwork.OptionDomainname("example.com"),
1136 
-		libnetwork.OptionHostsPath("/var/lib/docker/test_network/container2/hosts"),
1137 
-		libnetwork.OptionExtraHost("web", "192.168.0.2"))
1138 
-	if err != nil {
1139 
-		t.Fatal(err)
1140 
-	}
1141 
-	defer func() {
1142 
-		if err := sbx2.Delete(); err != nil {
1143 
-			t.Fatal(err)
1144 
-		}
1145 
-	}()
1146 
-
1147 
-	err = ep1.Join(sbx1)
1148 
-	if err != nil {
1149 
-		t.Fatal(err)
1150 
-	}
1151 
-
1152 
-	err = ep2.Join(sbx2)
1153 
-	if err != nil {
1154 
-		t.Fatal(err)
1155 
-	}
1156 
-}
1157 
-
1158 
-func TestInvalidRemoteDriver(t *testing.T) {
1159 
-	mux := http.NewServeMux()
1160 
-	server := httptest.NewServer(mux)
1161 
-	if server == nil {
1162 
-		t.Fatal("Failed to start an HTTP Server")
1163 
-	}
1164 
-	defer server.Close()
1165 
-
1166 
-	mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {
1167 
-		w.Header().Set("Content-Type", plugins.VersionMimetype)
1168 
-		fmt.Fprintln(w, `{"Implements": ["InvalidDriver"]}`)
1169 
-	})
1170 
-
1171 
-	if err := os.MkdirAll(specPath, 0o755); err != nil {
1172 
-		t.Fatal(err)
1173 
-	}
1174 
-	defer func() {
1175 
-		if err := os.RemoveAll(specPath); err != nil {
1176 
-			t.Fatal(err)
1177 
-		}
1178 
-	}()
1179 
-
1180 
-	if err := os.WriteFile(filepath.Join(specPath, "invalid-network-driver.spec"), []byte(server.URL), 0o644); err != nil {
1181 
-		t.Fatal(err)
1182 
-	}
1183 
-
1184 
-	ctrlr, err := libnetwork.New()
1185 
-	if err != nil {
1186 
-		t.Fatal(err)
1187 
-	}
1188 
-	defer ctrlr.Stop()
1189 
-
1190 
-	_, err = ctrlr.NewNetwork("invalid-network-driver", "dummy", "",
1191 
-		libnetwork.NetworkOptionGeneric(getEmptyGenericOption()))
1192 
-	if err == nil {
1193 
-		t.Fatal("Expected to fail. But instead succeeded")
1194 
-	}
1195 
-
1196 
-	if !errors.Is(err, plugins.ErrNotImplements) {
1197 
-		t.Fatalf("Did not fail with expected error. Actual error: %v", err)
1198 
-	}
1199 
-}
1200 
-
1201 
-func TestValidRemoteDriver(t *testing.T) {
1202 
-	mux := http.NewServeMux()
1203 
-	server := httptest.NewServer(mux)
1204 
-	if server == nil {
1205 
-		t.Fatal("Failed to start an HTTP Server")
1206 
-	}
1207 
-	defer server.Close()
1208 
-
1209 
-	mux.HandleFunc("/Plugin.Activate", func(w http.ResponseWriter, r *http.Request) {
1210 
-		w.Header().Set("Content-Type", plugins.VersionMimetype)
1211 
-		fmt.Fprintf(w, `{"Implements": ["%s"]}`, driverapi.NetworkPluginEndpointType)
1212 
-	})
1213 
-	mux.HandleFunc(fmt.Sprintf("/%s.GetCapabilities", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
1214 
-		w.Header().Set("Content-Type", plugins.VersionMimetype)
1215 
-		fmt.Fprintf(w, `{"Scope":"local"}`)
1216 
-	})
1217 
-	mux.HandleFunc(fmt.Sprintf("/%s.CreateNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
1218 
-		w.Header().Set("Content-Type", plugins.VersionMimetype)
1219 
-		fmt.Fprintf(w, "null")
1220 
-	})
1221 
-	mux.HandleFunc(fmt.Sprintf("/%s.DeleteNetwork", driverapi.NetworkPluginEndpointType), func(w http.ResponseWriter, r *http.Request) {
1222 
-		w.Header().Set("Content-Type", plugins.VersionMimetype)
1223 
-		fmt.Fprintf(w, "null")
1224 
-	})
1225 
-
1226 
-	if err := os.MkdirAll(specPath, 0o755); err != nil {
1227 
-		t.Fatal(err)
1228 
-	}
1229 
-	defer func() {
1230 
-		if err := os.RemoveAll(specPath); err != nil {
1231 
-			t.Fatal(err)
1232 
-		}
1233 
-	}()
1234 
-
1235 
-	if err := os.WriteFile(filepath.Join(specPath, "valid-network-driver.spec"), []byte(server.URL), 0o644); err != nil {
1236 
-		t.Fatal(err)
1237 
-	}
1238 
-
1239 
-	controller := newController(t)
1240 
-	n, err := controller.NewNetwork("valid-network-driver", "dummy", "",
1241 
-		libnetwork.NetworkOptionGeneric(getEmptyGenericOption()))
1242 
-	if err != nil {
1243 
-		// Only fail if we could not find the plugin driver
1244 
-		if isNotFound(err) {
1245 
-			t.Fatal(err)
1246 
-		}
1247 
-		return
1248 
-	}
1249 
-	defer func() {
1250 
-		if err := n.Delete(); err != nil {
1251 
-			t.Fatal(err)
1252 
-		}
1253 
-	}()
1254 
-}