extras/hs-test/hst_suite.go

   1 package main
   2
   3 import (
   4         "flag"
   5         "fmt"
   6         "io/ioutil"
   7         "os"
   8         "time"
   9
  10         "github.com/edwarnicke/exechelper"
  11         "github.com/stretchr/testify/assert"
  12         "github.com/stretchr/testify/suite"
  13         "gopkg.in/yaml.v3"
  14 )
  15
  16 const (
  17         defaultNetworkNumber int = 1
  18 )
  19
  20 var IsPersistent = flag.Bool("persist", false, "persists topology config")
  21 var IsVerbose = flag.Bool("verbose", false, "verbose test output")
  22 var IsUnconfiguring = flag.Bool("unconfigure", false, "remove topology")
  23
  24 type HstSuite struct {
  25         suite.Suite
  26         containers    map[string]*Container
  27         volumes       []string
  28         netConfigs    []NetConfig
  29         netInterfaces map[string]*NetInterface
  30         addresser     *Addresser
  31         testIds       map[string]string
  32 }
  33
  34 func (s *HstSuite) TearDownSuite() {
  35         s.unconfigureNetworkTopology()
  36 }
  37
  38 func (s *HstSuite) TearDownTest() {
  39         if *IsPersistent {
  40                 return
  41         }
  42         s.ResetContainers()
  43         s.RemoveVolumes()
  44 }
  45
  46 func (s *HstSuite) skipIfUnconfiguring() {
  47         if *IsUnconfiguring {
  48                 s.skip("skipping to unconfigure")
  49         }
  50 }
  51
  52 func (s *HstSuite) SetupTest() {
  53         s.skipIfUnconfiguring()
  54         s.SetupVolumes()
  55         s.SetupContainers()
  56 }
  57
  58 func (s *HstSuite) SetupVolumes() {
  59         for _, volume := range s.volumes {
  60                 cmd := "docker volume create --name=" + volume
  61                 s.log(cmd)
  62                 exechelper.Run(cmd)
  63         }
  64 }
  65
  66 func (s *HstSuite) SetupContainers() {
  67         for _, container := range s.containers {
  68                 if container.isOptional == false {
  69                         container.run()
  70                 }
  71         }
  72 }
  73
  74 func (s *HstSuite) hstFail() {
  75         s.T().FailNow()
  76 }
  77
  78 func (s *HstSuite) assertNil(object interface{}, msgAndArgs ...interface{}) {
  79         if !assert.Nil(s.T(), object, msgAndArgs...) {
  80                 s.hstFail()
  81         }
  82 }
  83
  84 func (s *HstSuite) assertNotNil(object interface{}, msgAndArgs ...interface{}) {
  85         if !assert.NotNil(s.T(), object, msgAndArgs...) {
  86                 s.hstFail()
  87         }
  88 }
  89
  90 func (s *HstSuite) assertEqual(expected, actual interface{}, msgAndArgs ...interface{}) {
  91         if !assert.Equal(s.T(), expected, actual, msgAndArgs...) {
  92                 s.hstFail()
  93         }
  94 }
  95
  96 func (s *HstSuite) assertNotEqual(expected, actual interface{}, msgAndArgs ...interface{}) {
  97         if !assert.NotEqual(s.T(), expected, actual, msgAndArgs...) {
  98                 s.hstFail()
  99         }
 100 }
 101
 102 func (s *HstSuite) assertContains(testString, contains interface{}, msgAndArgs ...interface{}) {
 103         if !assert.Contains(s.T(), testString, contains, msgAndArgs...) {
 104                 s.hstFail()
 105         }
 106 }
 107
 108 func (s *HstSuite) assertNotContains(testString, contains interface{}, msgAndArgs ...interface{}) {
 109         if !assert.NotContains(s.T(), testString, contains, msgAndArgs...) {
 110                 s.hstFail()
 111         }
 112 }
 113
 114 func (s *HstSuite) assertNotEmpty(object interface{}, msgAndArgs ...interface{}) {
 115         if !assert.NotEmpty(s.T(), object, msgAndArgs...) {
 116                 s.hstFail()
 117         }
 118 }
 119
 120 func (s *HstSuite) log(args ...any) {
 121         if *IsVerbose {
 122                 s.T().Helper()
 123                 s.T().Log(args...)
 124         }
 125 }
 126
 127 func (s *HstSuite) skip(args ...any) {
 128         s.log(args...)
 129         s.T().SkipNow()
 130 }
 131
 132 func (s *HstSuite) ResetContainers() {
 133         for _, container := range s.containers {
 134                 container.stop()
 135         }
 136 }
 137
 138 func (s *HstSuite) RemoveVolumes() {
 139         for _, volumeName := range s.volumes {
 140                 cmd := "docker volume rm " + volumeName
 141                 exechelper.Run(cmd)
 142                 os.RemoveAll(volumeName)
 143         }
 144 }
 145
 146 func (s *HstSuite) getContainerByName(name string) *Container {
 147         return s.containers[name]
 148 }
 149
 150 /*
 151  * Create a copy and return its address, so that individial tests which call this
 152  * are not able to modify the original container and affect other tests by doing that
 153  */
 154 func (s *HstSuite) getTransientContainerByName(name string) *Container {
 155         containerCopy := *s.containers[name]
 156         return &containerCopy
 157 }
 158
 159 func (s *HstSuite) loadContainerTopology(topologyName string) {
 160         data, err := ioutil.ReadFile(ContainerTopologyDir + topologyName + ".yaml")
 161         if err != nil {
 162                 s.T().Fatalf("read error: %v", err)
 163         }
 164         var yamlTopo YamlTopology
 165         err = yaml.Unmarshal(data, &yamlTopo)
 166         if err != nil {
 167                 s.T().Fatalf("unmarshal error: %v", err)
 168         }
 169
 170         for _, elem := range yamlTopo.Volumes {
 171                 volumeMap := elem["volume"].(VolumeConfig)
 172                 hostDir := volumeMap["host-dir"].(string)
 173                 s.volumes = append(s.volumes, hostDir)
 174         }
 175
 176         s.containers = make(map[string]*Container)
 177         for _, elem := range yamlTopo.Containers {
 178                 newContainer, err := NewContainer(elem)
 179                 newContainer.suite = s
 180                 if err != nil {
 181                         s.T().Fatalf("container config error: %v", err)
 182                 }
 183                 s.containers[newContainer.name] = newContainer
 184         }
 185 }
 186
 187 func (s *HstSuite) loadNetworkTopology(topologyName string) {
 188         data, err := ioutil.ReadFile(NetworkTopologyDir + topologyName + ".yaml")
 189         if err != nil {
 190                 s.T().Fatalf("read error: %v", err)
 191         }
 192         var yamlTopo YamlTopology
 193         err = yaml.Unmarshal(data, &yamlTopo)
 194         if err != nil {
 195                 s.T().Fatalf("unmarshal error: %v", err)
 196         }
 197
 198         s.addresser = NewAddresser(s)
 199         s.netInterfaces = make(map[string]*NetInterface)
 200         for _, elem := range yamlTopo.Devices {
 201                 switch elem["type"].(string) {
 202                 case NetNs:
 203                         {
 204                                 if namespace, err := NewNetNamespace(elem); err == nil {
 205                                         s.netConfigs = append(s.netConfigs, &namespace)
 206                                 } else {
 207                                         s.T().Fatalf("network config error: %v", err)
 208                                 }
 209                         }
 210                 case Veth, Tap:
 211                         {
 212                                 if netIf, err := NewNetworkInterface(elem, s.addresser); err == nil {
 213                                         s.netConfigs = append(s.netConfigs, netIf)
 214                                         s.netInterfaces[netIf.Name()] = netIf
 215                                 } else {
 216                                         s.T().Fatalf("network config error: %v", err)
 217                                 }
 218                         }
 219                 case Bridge:
 220                         {
 221                                 if bridge, err := NewBridge(elem); err == nil {
 222                                         s.netConfigs = append(s.netConfigs, &bridge)
 223                                 } else {
 224                                         s.T().Fatalf("network config error: %v", err)
 225                                 }
 226                         }
 227                 }
 228         }
 229 }
 230
 231 func (s *HstSuite) configureNetworkTopology(topologyName string) {
 232         s.loadNetworkTopology(topologyName)
 233
 234         if *IsUnconfiguring {
 235                 return
 236         }
 237
 238         for _, nc := range s.netConfigs {
 239                 if err := nc.Configure(); err != nil {
 240                         s.T().Fatalf("network config error: %v", err)
 241                 }
 242         }
 243 }
 244
 245 func (s *HstSuite) unconfigureNetworkTopology() {
 246         if *IsPersistent {
 247                 return
 248         }
 249         for _, nc := range s.netConfigs {
 250                 nc.Unconfigure()
 251         }
 252 }
 253
 254 func (s *HstSuite) getTestId() string {
 255         testName := s.T().Name()
 256
 257         if s.testIds == nil {
 258                 s.testIds = map[string]string{}
 259         }
 260
 261         if _, ok := s.testIds[testName]; !ok {
 262                 s.testIds[testName] = time.Now().Format(time.RFC3339)
 263         }
 264
 265         return s.testIds[testName]
 266 }
 267
 268 type AddressCounter = int
 269
 270 type Addresser struct {
 271         networks map[int]AddressCounter
 272         suite    *HstSuite
 273 }
 274
 275 func (a *Addresser) AddNetwork(networkNumber int) {
 276         a.networks[networkNumber] = 1
 277 }
 278
 279 func (a *Addresser) NewIp4Address(inputNetworkNumber ...int) (string, error) {
 280         var networkNumber int = 0
 281         if len(inputNetworkNumber) > 0 {
 282                 networkNumber = inputNetworkNumber[0]
 283         }
 284
 285         if _, ok := a.networks[networkNumber]; !ok {
 286                 a.AddNetwork(networkNumber)
 287         }
 288
 289         numberOfAddresses := a.networks[networkNumber]
 290
 291         if numberOfAddresses == 254 {
 292                 return "", fmt.Errorf("no available IPv4 addresses")
 293         }
 294
 295         address := fmt.Sprintf("10.10.%v.%v/24", networkNumber, numberOfAddresses)
 296         a.networks[networkNumber] = numberOfAddresses + 1
 297
 298         return address, nil
 299 }
 300
 301 func NewAddresser(suite *HstSuite) *Addresser {
 302         var addresser = new(Addresser)
 303         addresser.suite = suite
 304         addresser.networks = make(map[int]AddressCounter)
 305         addresser.AddNetwork(0)
 306         return addresser
 307 }