extras/hs-test/hst_suite.go

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