github.com/containers/podman/v4@v4.9.4/pkg/bindings/test/networks_test.go (about) 1 package bindings_test 2 3 import ( 4 "context" 5 "fmt" 6 "net/http" 7 "time" 8 9 "github.com/containers/common/libnetwork/types" 10 "github.com/containers/podman/v4/pkg/bindings" 11 "github.com/containers/podman/v4/pkg/bindings/containers" 12 "github.com/containers/podman/v4/pkg/bindings/network" 13 . "github.com/onsi/ginkgo/v2" 14 . "github.com/onsi/gomega" 15 "github.com/onsi/gomega/gexec" 16 ) 17 18 var _ = Describe("Podman networks", func() { 19 var ( 20 bt *bindingTest 21 s *gexec.Session 22 connText context.Context 23 err error 24 ) 25 26 BeforeEach(func() { 27 28 bt = newBindingTest() 29 bt.RestoreImagesFromCache() 30 s = bt.startAPIService() 31 time.Sleep(1 * time.Second) 32 connText, err = bindings.NewConnection(context.Background(), bt.sock) 33 Expect(err).ToNot(HaveOccurred()) 34 _, err = network.Prune(connText, &network.PruneOptions{}) 35 Expect(err).ToNot(HaveOccurred()) 36 }) 37 38 AfterEach(func() { 39 s.Kill() 40 bt.cleanup() 41 }) 42 43 It("podman prune unused networks with filters", func() { 44 name := "foobar" 45 net := types.Network{ 46 Name: name, 47 } 48 _, err = network.Create(connText, &net) 49 Expect(err).ToNot(HaveOccurred()) 50 51 // Invalid filters should return error 52 filtersIncorrect := map[string][]string{ 53 "status": {"dummy"}, 54 } 55 _, err = network.Prune(connText, new(network.PruneOptions).WithFilters(filtersIncorrect)) 56 Expect(err).To(HaveOccurred()) 57 58 // List filter params should not work with prune. 59 filtersIncorrect = map[string][]string{ 60 "name": {name}, 61 } 62 _, err = network.Prune(connText, new(network.PruneOptions).WithFilters(filtersIncorrect)) 63 Expect(err).To(HaveOccurred()) 64 65 // Mismatched label, correct filter params => no network should be pruned. 66 filtersIncorrect = map[string][]string{ 67 "label": {"xyz"}, 68 } 69 pruneResponse, err := network.Prune(connText, new(network.PruneOptions).WithFilters(filtersIncorrect)) 70 Expect(err).ToNot(HaveOccurred()) 71 Expect(pruneResponse).To(BeEmpty()) 72 73 // Mismatched until, correct filter params => no network should be pruned. 74 filters := map[string][]string{ 75 "until": {"50"}, // January 1, 1970 76 } 77 pruneResponse, err = network.Prune(connText, new(network.PruneOptions).WithFilters(filters)) 78 Expect(err).ToNot(HaveOccurred()) 79 Expect(pruneResponse).To(BeEmpty()) 80 81 // Valid filter params => network should be pruned now. 82 filters = map[string][]string{ 83 "until": {"5000000000"}, // June 11, 2128 84 } 85 pruneResponse, err = network.Prune(connText, new(network.PruneOptions).WithFilters(filters)) 86 Expect(err).ToNot(HaveOccurred()) 87 Expect(pruneResponse).To(HaveLen(1)) 88 }) 89 90 It("create network", func() { 91 // create a network with blank config should work 92 _, err = network.Create(connText, nil) 93 Expect(err).ToNot(HaveOccurred()) 94 95 name := "foobar" 96 net := types.Network{ 97 Name: name, 98 } 99 100 report, err := network.Create(connText, &net) 101 Expect(err).ToNot(HaveOccurred()) 102 Expect(report.Name).To(Equal(name)) 103 104 // create network with same name should 409 105 _, err = network.Create(connText, &net) 106 Expect(err).To(HaveOccurred()) 107 code, _ := bindings.CheckResponseCode(err) 108 Expect(code).To(BeNumerically("==", http.StatusConflict)) 109 110 // create network with same name and ignore false should 409 111 options := new(network.ExtraCreateOptions).WithIgnoreIfExists(false) 112 _, err = network.CreateWithOptions(connText, &net, options) 113 Expect(err).To(HaveOccurred()) 114 code, _ = bindings.CheckResponseCode(err) 115 Expect(code).To(BeNumerically("==", http.StatusConflict)) 116 117 // create network with same name and ignore true succeed 118 options = new(network.ExtraCreateOptions).WithIgnoreIfExists(true) 119 report, err = network.CreateWithOptions(connText, &net, options) 120 Expect(err).ToNot(HaveOccurred()) 121 Expect(report.Name).To(Equal(name)) 122 }) 123 124 It("inspect network", func() { 125 name := "foobar" 126 net := types.Network{ 127 Name: name, 128 } 129 _, err = network.Create(connText, &net) 130 Expect(err).ToNot(HaveOccurred()) 131 data, err := network.Inspect(connText, name, nil) 132 Expect(err).ToNot(HaveOccurred()) 133 Expect(data.Name).To(Equal(name)) 134 }) 135 136 It("list networks", func() { 137 // create a bunch of named networks and make verify with list 138 netNames := []string{"homer", "bart", "lisa", "maggie", "marge"} 139 for i := 0; i < 5; i++ { 140 net := types.Network{ 141 Name: netNames[i], 142 } 143 _, err = network.Create(connText, &net) 144 Expect(err).ToNot(HaveOccurred()) 145 } 146 list, err := network.List(connText, nil) 147 Expect(err).ToNot(HaveOccurred()) 148 Expect(len(list)).To(BeNumerically(">=", 5)) 149 for _, n := range list { 150 if n.Name != "podman" { 151 Expect(StringInSlice(n.Name, netNames)).To(BeTrue()) 152 } 153 } 154 155 // list with bad filter should be 500 156 filters := make(map[string][]string) 157 filters["foobar"] = []string{"1234"} 158 options := new(network.ListOptions).WithFilters(filters) 159 _, err = network.List(connText, options) 160 Expect(err).To(HaveOccurred()) 161 code, _ := bindings.CheckResponseCode(err) 162 Expect(code).To(BeNumerically("==", http.StatusInternalServerError)) 163 164 // filter list with success 165 filters = make(map[string][]string) 166 filters["name"] = []string{"homer"} 167 options = new(network.ListOptions).WithFilters(filters) 168 list, err = network.List(connText, options) 169 Expect(err).ToNot(HaveOccurred()) 170 Expect(list).To(HaveLen(1)) 171 Expect(list[0].Name).To(Equal("homer")) 172 }) 173 174 It("remove network", func() { 175 // removing a noName network should result in 404 176 _, err := network.Remove(connText, "noName", nil) 177 code, err := bindings.CheckResponseCode(err) 178 Expect(err).ToNot(HaveOccurred()) 179 Expect(code).To(BeNumerically("==", http.StatusNotFound)) 180 181 // Removing an unused network should work 182 name := "unused" 183 net := types.Network{ 184 Name: name, 185 } 186 _, err = network.Create(connText, &net) 187 Expect(err).ToNot(HaveOccurred()) 188 report, err := network.Remove(connText, name, nil) 189 Expect(err).ToNot(HaveOccurred()) 190 Expect(report[0].Name).To(Equal(name)) 191 192 // Removing a network that is being used without force should be 500 193 name = "used" 194 net = types.Network{ 195 Name: name, 196 } 197 _, err = network.Create(connText, &net) 198 Expect(err).ToNot(HaveOccurred()) 199 200 // Start container and wait 201 container := "ntest" 202 session := bt.runPodman([]string{"run", "-dt", fmt.Sprintf("--network=%s", name), "--name", container, alpine.name, "top"}) 203 session.Wait(45) 204 Expect(session.ExitCode()).To(BeZero()) 205 206 _, err = network.Remove(connText, name, nil) 207 code, err = bindings.CheckResponseCode(err) 208 Expect(err).ToNot(HaveOccurred()) 209 Expect(code).To(BeNumerically("==", http.StatusInternalServerError)) 210 211 // Removing with a network in use with force should work with a stopped container 212 err = containers.Stop(connText, container, new(containers.StopOptions).WithTimeout(0)) 213 Expect(err).ToNot(HaveOccurred()) 214 options := new(network.RemoveOptions).WithForce(true) 215 report, err = network.Remove(connText, name, options) 216 Expect(err).ToNot(HaveOccurred()) 217 Expect(report[0].Name).To(Equal(name)) 218 }) 219 })