13 "github.com/edwarnicke/exechelper"
14 "github.com/stretchr/testify/assert"
15 "github.com/stretchr/testify/suite"
20 DEFAULT_NETWORK_NUM int = 1
23 var isPersistent = flag.Bool("persist", false, "persists topology config")
24 var isVerbose = flag.Bool("verbose", false, "verbose test output")
25 var isUnconfiguring = flag.Bool("unconfigure", false, "remove topology")
26 var isVppDebug = flag.Bool("debug", false, "attach gdb to vpp")
27 var nConfiguredCpus = flag.Int("cpus", 1, "number of CPUs assigned to vpp")
29 type HstSuite struct {
31 containers map[string]*Container
33 netConfigs []NetConfig
34 netInterfaces map[string]*NetInterface
35 ip4AddrAllocator *Ip4AddressAllocator
36 testIds map[string]string
37 cpuAllocator *CpuAllocatorT
38 cpuContexts []*CpuContext
42 func (s *HstSuite) SetupSuite() {
44 s.cpuAllocator, err = CpuAllocator()
46 s.FailNow("failed to init cpu allocator: %v", err)
48 s.cpuPerVpp = *nConfiguredCpus
51 func (s *HstSuite) AllocateCpus() []int {
52 cpuCtx, err := s.cpuAllocator.Allocate(s.cpuPerVpp)
54 s.AddCpuContext(cpuCtx)
58 func (s *HstSuite) AddCpuContext(cpuCtx *CpuContext) {
59 s.cpuContexts = append(s.cpuContexts, cpuCtx)
62 func (s *HstSuite) TearDownSuite() {
63 s.unconfigureNetworkTopology()
66 func (s *HstSuite) TearDownTest() {
70 for _, c := range s.cpuContexts {
77 func (s *HstSuite) skipIfUnconfiguring() {
79 s.skip("skipping to unconfigure")
83 func (s *HstSuite) SetupTest() {
84 s.skipIfUnconfiguring()
89 func (s *HstSuite) setupVolumes() {
90 for _, volume := range s.volumes {
91 cmd := "docker volume create --name=" + volume
97 func (s *HstSuite) setupContainers() {
98 for _, container := range s.containers {
99 if !container.isOptional {
105 func (s *HstSuite) hstFail() {
109 func (s *HstSuite) assertNil(object interface{}, msgAndArgs ...interface{}) {
110 if !assert.Nil(s.T(), object, msgAndArgs...) {
115 func (s *HstSuite) assertNotNil(object interface{}, msgAndArgs ...interface{}) {
116 if !assert.NotNil(s.T(), object, msgAndArgs...) {
121 func (s *HstSuite) assertEqual(expected, actual interface{}, msgAndArgs ...interface{}) {
122 if !assert.Equal(s.T(), expected, actual, msgAndArgs...) {
127 func (s *HstSuite) assertNotEqual(expected, actual interface{}, msgAndArgs ...interface{}) {
128 if !assert.NotEqual(s.T(), expected, actual, msgAndArgs...) {
133 func (s *HstSuite) assertContains(testString, contains interface{}, msgAndArgs ...interface{}) {
134 if !assert.Contains(s.T(), testString, contains, msgAndArgs...) {
139 func (s *HstSuite) assertNotContains(testString, contains interface{}, msgAndArgs ...interface{}) {
140 if !assert.NotContains(s.T(), testString, contains, msgAndArgs...) {
145 func (s *HstSuite) assertNotEmpty(object interface{}, msgAndArgs ...interface{}) {
146 if !assert.NotEmpty(s.T(), object, msgAndArgs...) {
151 func (s *HstSuite) log(args ...any) {
158 func (s *HstSuite) skip(args ...any) {
163 func (s *HstSuite) SkipIfMultiWorker(args ...any) {
164 if *nConfiguredCpus > 1 {
165 s.skip("test case not supported with multiple vpp workers")
169 func (s *HstSuite) SkipUnlessExtendedTestsBuilt() {
170 imageName := "hs-test/nginx-http3"
172 cmd := exec.Command("docker", "images", imageName)
173 byteOutput, err := cmd.CombinedOutput()
175 s.log("error while searching for docker image")
178 if !strings.Contains(string(byteOutput), imageName) {
179 s.skip("extended tests not built")
183 func (s *HstSuite) resetContainers() {
184 for _, container := range s.containers {
189 func (s *HstSuite) removeVolumes() {
190 for _, volumeName := range s.volumes {
191 cmd := "docker volume rm " + volumeName
193 os.RemoveAll(volumeName)
197 func (s *HstSuite) getContainerByName(name string) *Container {
198 return s.containers[name]
202 * Create a copy and return its address, so that individial tests which call this
203 * are not able to modify the original container and affect other tests by doing that
205 func (s *HstSuite) getTransientContainerByName(name string) *Container {
206 containerCopy := *s.containers[name]
207 return &containerCopy
210 func (s *HstSuite) loadContainerTopology(topologyName string) {
211 data, err := ioutil.ReadFile(containerTopologyDir + topologyName + ".yaml")
213 s.T().Fatalf("read error: %v", err)
215 var yamlTopo YamlTopology
216 err = yaml.Unmarshal(data, &yamlTopo)
218 s.T().Fatalf("unmarshal error: %v", err)
221 for _, elem := range yamlTopo.Volumes {
222 volumeMap := elem["volume"].(VolumeConfig)
223 hostDir := volumeMap["host-dir"].(string)
224 s.volumes = append(s.volumes, hostDir)
227 s.containers = make(map[string]*Container)
228 for _, elem := range yamlTopo.Containers {
229 newContainer, err := newContainer(elem)
230 newContainer.suite = s
232 s.T().Fatalf("container config error: %v", err)
234 s.containers[newContainer.name] = newContainer
238 func (s *HstSuite) loadNetworkTopology(topologyName string) {
239 data, err := ioutil.ReadFile(networkTopologyDir + topologyName + ".yaml")
241 s.T().Fatalf("read error: %v", err)
243 var yamlTopo YamlTopology
244 err = yaml.Unmarshal(data, &yamlTopo)
246 s.T().Fatalf("unmarshal error: %v", err)
249 s.ip4AddrAllocator = NewIp4AddressAllocator()
250 s.netInterfaces = make(map[string]*NetInterface)
251 for _, elem := range yamlTopo.Devices {
252 switch elem["type"].(string) {
255 if namespace, err := newNetNamespace(elem); err == nil {
256 s.netConfigs = append(s.netConfigs, &namespace)
258 s.T().Fatalf("network config error: %v", err)
263 if netIf, err := newNetworkInterface(elem, s.ip4AddrAllocator); err == nil {
264 s.netConfigs = append(s.netConfigs, netIf)
265 s.netInterfaces[netIf.Name()] = netIf
267 s.T().Fatalf("network config error: %v", err)
272 if bridge, err := newBridge(elem); err == nil {
273 s.netConfigs = append(s.netConfigs, &bridge)
275 s.T().Fatalf("network config error: %v", err)
282 func (s *HstSuite) configureNetworkTopology(topologyName string) {
283 s.loadNetworkTopology(topologyName)
285 if *isUnconfiguring {
289 for _, nc := range s.netConfigs {
290 if err := nc.configure(); err != nil {
291 s.T().Fatalf("network config error: %v", err)
296 func (s *HstSuite) unconfigureNetworkTopology() {
300 for _, nc := range s.netConfigs {
305 func (s *HstSuite) getTestId() string {
306 testName := s.T().Name()
308 if s.testIds == nil {
309 s.testIds = map[string]string{}
312 if _, ok := s.testIds[testName]; !ok {
313 s.testIds[testName] = time.Now().Format("2006-01-02_15-04-05")
316 return s.testIds[testName]
319 func (s *HstSuite) startServerApp(running chan error, done chan struct{}, env []string) {
320 cmd := exec.Command("iperf3", "-4", "-s")
327 msg := fmt.Errorf("failed to start iperf server: %v", err)
336 func (s *HstSuite) startClientApp(ipAddress string, env []string, clnCh chan error, clnRes chan string) {
344 cmd := exec.Command("iperf3", "-c", ipAddress, "-u", "-l", "1460", "-b", "10g")
349 o, err := cmd.CombinedOutput()
352 clnCh <- fmt.Errorf("failed to start client app '%s'.\n%s", err, o)
355 time.Sleep(1 * time.Second)
359 clnRes <- fmt.Sprintf("Client output: %s", o)
365 func (s *HstSuite) startHttpServer(running chan struct{}, done chan struct{}, addressPort, netNs string) {
366 cmd := newCommand([]string{"./http_server", addressPort}, netNs)
370 fmt.Println("Failed to start http server")
373 running <- struct{}{}
378 func (s *HstSuite) startWget(finished chan error, server_ip, port, query, netNs string) {
380 finished <- errors.New("wget error")
383 cmd := newCommand([]string{"wget", "--timeout=10", "--no-proxy", "--tries=5", "-O", "/dev/null", server_ip + ":" + port + "/" + query},
386 o, err := cmd.CombinedOutput()
388 finished <- fmt.Errorf("wget error: '%v\n\n%s'", err, o)
390 } else if !strings.Contains(string(o), "200 OK") {
391 finished <- fmt.Errorf("wget error: response not 200 OK")