hs-test: refactor test cases from no-topo suite
[vpp.git] / 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) log(args ...any) {
109         if IsVerbose() {
110                 s.T().Log(args...)
111         }
112 }
113
114 func (s *HstSuite) skip(args ...any) {
115         s.log(args...)
116         s.T().SkipNow()
117 }
118
119 func (s *HstSuite) ResetContainers() {
120         for _, container := range s.containers {
121                 container.stop()
122         }
123 }
124
125 func (s *HstSuite) RemoveVolumes() {
126         for _, volumeName := range s.volumes {
127                 cmd := "docker volume rm " + volumeName
128                 exechelper.Run(cmd)
129                 os.RemoveAll(volumeName)
130         }
131 }
132
133 func (s *HstSuite) getContainerByName(name string) *Container {
134         return s.containers[name]
135 }
136
137 /*
138  * Create a copy and return its address, so that individial tests which call this
139  * are not able to modify the original container and affect other tests by doing that
140  */
141 func (s *HstSuite) getTransientContainerByName(name string) *Container {
142         containerCopy := *s.containers[name]
143         return &containerCopy
144 }
145
146 func (s *HstSuite) loadContainerTopology(topologyName string) {
147         data, err := ioutil.ReadFile(ContainerTopologyDir + topologyName + ".yaml")
148         if err != nil {
149                 s.T().Fatalf("read error: %v", err)
150         }
151         var yamlTopo YamlTopology
152         err = yaml.Unmarshal(data, &yamlTopo)
153         if err != nil {
154                 s.T().Fatalf("unmarshal error: %v", err)
155         }
156
157         for _, elem := range yamlTopo.Volumes {
158                 volumeMap := elem["volume"].(VolumeConfig)
159                 hostDir := volumeMap["host-dir"].(string)
160                 s.volumes = append(s.volumes, hostDir)
161         }
162
163         s.containers = make(map[string]*Container)
164         for _, elem := range yamlTopo.Containers {
165                 newContainer, err := NewContainer(elem)
166                 newContainer.suite = s
167                 if err != nil {
168                         s.T().Fatalf("container config error: %v", err)
169                 }
170                 s.log(newContainer.getRunCommand())
171                 s.containers[newContainer.name] = newContainer
172         }
173 }
174
175 func (s *HstSuite) loadNetworkTopology(topologyName string) {
176         data, err := ioutil.ReadFile(NetworkTopologyDir + topologyName + ".yaml")
177         if err != nil {
178                 s.T().Fatalf("read error: %v", err)
179         }
180         var yamlTopo YamlTopology
181         err = yaml.Unmarshal(data, &yamlTopo)
182         if err != nil {
183                 s.T().Fatalf("unmarshal error: %v", err)
184         }
185
186         s.addresser = NewAddresser(s)
187         s.netInterfaces = make(map[string]NetInterface)
188         for _, elem := range yamlTopo.Devices {
189                 switch elem["type"].(string) {
190                 case NetNs:
191                         {
192                                 if namespace, err := NewNetNamespace(elem); err == nil {
193                                         s.netConfigs = append(s.netConfigs, &namespace)
194                                 } else {
195                                         s.T().Fatalf("network config error: %v", err)
196                                 }
197                         }
198                 case Veth:
199                         {
200                                 if veth, err := NewVeth(elem, s.addresser); err == nil {
201                                         s.netConfigs = append(s.netConfigs, &veth)
202                                         s.netInterfaces[veth.Name()] = &veth
203                                 } else {
204                                         s.T().Fatalf("network config error: %v", err)
205                                 }
206                         }
207                 case Tap:
208                         {
209                                 if tap, err := NewTap(elem, s.addresser); err == nil {
210                                         s.netConfigs = append(s.netConfigs, &tap)
211                                         s.netInterfaces[tap.Name()] = &tap
212                                 } else {
213                                         s.T().Fatalf("network config error: %v", err)
214                                 }
215                         }
216                 case Bridge:
217                         {
218                                 if bridge, err := NewBridge(elem); err == nil {
219                                         s.netConfigs = append(s.netConfigs, &bridge)
220                                 } else {
221                                         s.T().Fatalf("network config error: %v", err)
222                                 }
223                         }
224                 }
225         }
226 }
227
228 func (s *HstSuite) configureNetworkTopology(topologyName string) {
229         s.loadNetworkTopology(topologyName)
230
231         for _, nc := range s.netConfigs {
232                 if err := nc.Configure(); err != nil {
233                         s.T().Fatalf("network config error: %v", err)
234                 }
235         }
236 }
237
238 func (s *HstSuite) unconfigureNetworkTopology() {
239         if IsPersistent() {
240                 return
241         }
242         for _, nc := range s.netConfigs {
243                 nc.Unconfigure()
244         }
245 }
246
247 type NamespaceAddresses struct {
248         namespace         string
249         numberOfAddresses int
250 }
251
252 type Addresser struct {
253         namespaces []*NamespaceAddresses
254         suite      *HstSuite
255 }
256
257 func (a *Addresser) AddNamespace(name string) {
258         var newNamespace = &NamespaceAddresses{
259                 namespace:         name,
260                 numberOfAddresses: 0,
261         }
262         a.namespaces = append(a.namespaces, newNamespace)
263 }
264
265 func (a *Addresser) NewIp4Address() (string, error) {
266         return a.NewIp4AddressWithNamespace(defaultNamespaceName)
267 }
268
269 func (a *Addresser) NewIp4AddressWithNamespace(namespace string) (string, error) {
270         for i, val := range a.namespaces {
271                 if val.namespace != namespace {
272                         continue
273                 }
274                 if val.numberOfAddresses == 255 {
275                         return "", fmt.Errorf("no available IPv4 addresses")
276                 }
277                 address := fmt.Sprintf("10.10.%v.%v/24", i, val.numberOfAddresses+1)
278                 val.numberOfAddresses++
279                 return address, nil
280         }
281         a.AddNamespace(namespace)
282         return a.NewIp4AddressWithNamespace(namespace)
283 }
284
285 func NewAddresser(suite *HstSuite) *Addresser {
286         var addresser = new(Addresser)
287         addresser.suite = suite
288         addresser.AddNamespace(defaultNamespaceName)
289         return addresser
290 }