test/xdsserver_test.go

   1 /*
   2  * Copyright (C) 2017-2018 "IoT.bzh"
   3  * Author Clément Bénier <clement.benier@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 package xdsservertest
  18
  19 import (
  20         "io/ioutil"
  21         "log"
  22         "net"
  23         "os"
  24         "os/exec"
  25         "regexp"
  26         "strings"
  27         "testing"
  28         "time"
  29
  30         common "gerrit.automotivelinux.org/gerrit/src/xds/xds-common.git/golib"
  31         "gerrit.automotivelinux.org/gerrit/src/xds/xds-server/lib/xsapiv1"
  32         "github.com/stretchr/testify/assert"
  33 )
  34
  35 //global client
  36 var HTTPCli *common.HTTPClient
  37 var logDir string
  38
  39 func initEnv() {
  40         cmd := exec.Command("killall", "-9", "xds-server")
  41         if err := cmd.Start(); err != nil {
  42                 log.Fatal(err)
  43         }
  44         cmd.Wait()
  45         rootTestLog := "/tmp/xds-server-test"
  46         if err := os.Setenv(envRootCfgDir, rootTestLog); err != nil {
  47                 log.Fatal(err)
  48         }
  49         os.RemoveAll(rootTestLog)
  50         os.MkdirAll(rootTestLog, 0755)
  51         logDir = rootTestLog + "/logs/"
  52         os.MkdirAll(logDir, 0755)
  53 }
  54
  55 func launchXdsServer(proc **os.Process) *os.File {
  56         logFile := logDir + logFileXdsServer
  57         file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY, 0644)
  58         if err != nil {
  59                 log.Fatal(err)
  60         }
  61         tmpProc, err := os.StartProcess(argsProcess[0], argsProcess, &os.ProcAttr{
  62                 Files: []*os.File{os.Stdin, file, file},
  63         })
  64         if err != nil {
  65                 log.Fatal(err)
  66         }
  67         *proc = tmpProc
  68         return file
  69 }
  70
  71 func getHTTPClient(lvl int) (*common.HTTPClient, *os.File) {
  72         logFile := logDir + logFileClient
  73         file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY, 0644)
  74         if err != nil {
  75                 log.Fatal(err)
  76         }
  77         conf := common.HTTPClientConfig{
  78                 URLPrefix:           "/api/v1",
  79                 HeaderClientKeyName: "Xds-Test-Sid",
  80                 CsrfDisable:         true,
  81                 LogOut:              file,
  82                 LogPrefix:           "XDSSERVERTEST: ",
  83                 LogLevel:            lvl,
  84         }
  85         cli, err := common.HTTPNewClient(prefixURL, conf)
  86         if err != nil {
  87                 log.Print(err)
  88         }
  89         return cli, file
  90 }
  91
  92 func TestMain(m *testing.M) {
  93         initEnv()
  94
  95         var proc *os.Process
  96         fileXdsServer := launchXdsServer(&proc)
  97         go func(p *os.Process) {
  98                 if status, err := p.Wait(); err != nil {
  99                         log.Fatalf("status=%v\n err=%v\n", status, err)
 100                 }
 101         }(proc)
 102         time.Sleep(1 * time.Second)
 103
 104         lvl := common.HTTPLogLevelDebug
 105         var fileHTTPClient *os.File
 106         HTTPCli, fileHTTPClient = getHTTPClient(lvl)
 107
 108         if HTTPCli == nil {
 109                 log.Fatal("HTTPCLi is nil")
 110         }
 111         res := m.Run()
 112         proc.Kill()
 113         fileXdsServer.Close()
 114         fileHTTPClient.Close()
 115         os.Exit(res)
 116 }
 117
 118 func init() {
 119 }
 120
 121 func CheckIP(ipconfig string) bool {
 122         ifaces, _ := net.Interfaces()
 123         for _, i := range ifaces {
 124                 addrs, _ := i.Addrs()
 125                 for _, addr := range addrs {
 126                         if strings.HasPrefix(addr.String(), ipconfig) {
 127                                 return true
 128                         }
 129                 }
 130         }
 131         return false
 132 }
 133
 134 func TestVersion(t *testing.T) {
 135         var datVersion map[string]interface{}
 136         assert.Nil(t, HTTPCli.Get("/version", &datVersion))
 137         t.Log(datVersion)
 138
 139         ver, present := datVersion["version"]
 140         assert.True(t, present)
 141         t.Logf("version is %s", ver.(string))
 142         re := regexp.MustCompile("^v*[0-9]+.[0-9]+.[0-9]+$")
 143         assert.True(t, re.MatchString(ver.(string)))
 144 }
 145
 146 func TestConfig(t *testing.T) {
 147         var cfg xsapiv1.APIConfig
 148         assert.Nil(t, HTTPCli.Get("/config", &cfg))
 149
 150         re := regexp.MustCompile("^[0-9a-z]+-[0-9a-z]+-[0-9a-z]+-[0-9a-z]+-[0-9a-z]+$")
 151         assert.True(t, re.MatchString(cfg.ServerUID)) //ID
 152         pathMap, present := cfg.SupportedSharing["PathMap"]
 153         assert.True(t, present)
 154         assert.True(t, pathMap)
 155         assert.True(t, CheckIP(cfg.Builder.IP))
 156 }
 157 func TestFolders(t *testing.T) {
 158         var cfgArray []xsapiv1.FolderConfig
 159         assert.Nil(t, HTTPCli.Get("/folders", &cfgArray))
 160         assert.Equal(t, len(cfgArray), 0)
 161
 162         fPrj := xsapiv1.FolderConfig{
 163                 Label:      "testproject",
 164                 ClientPath: logDir + "testproject",
 165                 Type:       xsapiv1.TypePathMap,
 166                 ClientData: "clientdatatest",
 167                 DataPathMap: xsapiv1.PathMapConfig{
 168                         ServerPath: logDir + "testserverpath",
 169                 },
 170         }
 171         var cfg xsapiv1.FolderConfig
 172         assert.Nil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 173         assert.NotNil(t, cfg)
 174
 175         isCfgPrjMatch := func(fPrj xsapiv1.FolderConfig, cfg xsapiv1.FolderConfig) {
 176                 re := regexp.MustCompile("^[0-9a-z]+-[0-9a-z]+-[0-9a-z]+-[0-9a-z]+-[0-9a-z]+$")
 177                 assert.True(t, re.MatchString(cfg.ID)) //ID
 178                 assert.Equal(t, cfg.Label, fPrj.Label) //Label
 179                 assert.Equal(t, cfg.ClientPath, fPrj.ClientPath)
 180                 assert.Equal(t, cfg.Type, fPrj.Type)
 181                 assert.Equal(t, cfg.Status, "Enable")
 182                 assert.Equal(t, cfg.IsInSync, true)
 183                 assert.Equal(t, len(cfg.DefaultSdk), 0)
 184                 assert.Equal(t, fPrj.ClientData, cfg.ClientData)
 185                 assert.Equal(t, fPrj.DataPathMap.ServerPath, cfg.DataPathMap.ServerPath)
 186         }
 187         isCfgPrjMatch(fPrj, cfg)
 188         var cfg2 xsapiv1.FolderConfig
 189         assert.Nil(t, HTTPCli.Get("/folders/"+cfg.ID, &cfg2))
 190         isCfgPrjMatch(fPrj, cfg2)
 191
 192         assert.Nil(t, HTTPCli.Get("/folders", &cfgArray))
 193         assert.Equal(t, len(cfgArray), 1)
 194
 195         //call with the same uid create error
 196         assert.NotNil(t, HTTPCli.Post("/folders", cfg, &cfg))
 197
 198         /*create/delete folders*/
 199         var cfgArrayBis []xsapiv1.FolderConfig
 200         assert.Nil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 201         assert.Nil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 202         assert.Nil(t, HTTPCli.Get("/folders", &cfgArray))
 203         assert.Equal(t, len(cfgArray), 3)
 204         assert.Nil(t, HTTPCli.Delete("/folders/"+cfgArray[1].ID, &cfg))
 205         assert.Equal(t, cfg, cfgArray[1])
 206         assert.Nil(t, HTTPCli.Get("/folders", &cfgArrayBis))
 207         assert.Equal(t, len(cfgArrayBis), 2)
 208         assert.Nil(t, HTTPCli.Delete("/folders/"+cfgArray[0].ID, &cfg))
 209         assert.Equal(t, cfg, cfgArray[0])
 210         assert.Nil(t, HTTPCli.Get("/folders", &cfgArrayBis))
 211         assert.Equal(t, len(cfgArrayBis), 1)
 212         assert.Nil(t, HTTPCli.Delete("/folders/"+cfgArray[2].ID, &cfg))
 213         assert.Equal(t, cfg, cfgArray[2])
 214         assert.Nil(t, HTTPCli.Get("/folders", &cfgArrayBis))
 215         assert.Equal(t, len(cfgArrayBis), 0)
 216 }
 217
 218 func TestFoldersEmptyValues(t *testing.T) {
 219         fPrj := xsapiv1.FolderConfig{
 220                 Label:      "testproject",
 221                 ClientPath: logDir + "testproject",
 222                 Type:       xsapiv1.TypePathMap,
 223                 ClientData: "clientdatatest",
 224                 DataPathMap: xsapiv1.PathMapConfig{
 225                         ServerPath: "",
 226                 },
 227         }
 228         var cfg xsapiv1.FolderConfig
 229         /*ServerPath is empty*/
 230         assert.NotNil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 231
 232         fPrj.DataPathMap.ServerPath = logDir + "sameserverpath"
 233         fPrj.ClientPath = ""
 234         /*ClientPath is Empty*/
 235         assert.NotNil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 236
 237         fPrj.ClientPath = "logDir"
 238         fPrj.Type = ""
 239         /*Type is empty*/
 240         assert.NotNil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 241
 242         var cfgArray []xsapiv1.FolderConfig
 243         assert.Nil(t, HTTPCli.Get("/folders", &cfgArray))
 244         assert.Equal(t, len(cfgArray), 0)
 245 }
 246
 247 func TestFoldersPathMapConfig(t *testing.T) {
 248         fPrj := xsapiv1.FolderConfig{
 249                 Label:      "testproject",
 250                 ClientPath: logDir + "clientpathtest",
 251                 Type:       xsapiv1.TypePathMap,
 252                 ClientData: "clientdatatest",
 253                 DataPathMap: xsapiv1.PathMapConfig{
 254                         ServerPath: logDir + "serverpath",
 255                         CheckFile:  "checkfile",
 256                 },
 257         }
 258         var cfg xsapiv1.FolderConfig
 259         /*file not present*/
 260         assert.NotNil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 261
 262         var checkFileClient = fPrj.ClientPath + "/checkfile"
 263         var checkFileServer = fPrj.DataPathMap.ServerPath + "/checkfile"
 264
 265         /*create file*/
 266         os.MkdirAll(fPrj.ClientPath, 0755)
 267         fPrj.DataPathMap.CheckFile = checkFileClient
 268         fPrj.DataPathMap.CheckContent = "CheckContent From Client\n"
 269         file, err := os.OpenFile(checkFileClient, os.O_CREATE|os.O_RDWR, 0644)
 270         if err != nil {
 271                 t.Log(err)
 272         }
 273         if err := os.Symlink(checkFileClient, checkFileServer); err != nil {
 274                 t.Log(err)
 275         }
 276         /*file content differ*/
 277         assert.NotNil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 278
 279         /*write same message*/
 280         if _, err := file.WriteString(fPrj.DataPathMap.CheckContent); err != nil {
 281                 t.Log(err)
 282         }
 283         assert.Nil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 284
 285         /*check server msg: ServerUID needed*/
 286         var APIcfg xsapiv1.APIConfig
 287         assert.Nil(t, HTTPCli.Get("/config", &APIcfg))
 288         msg := "Pathmap checked message written by xds-server ID: " + APIcfg.ServerUID + "\n"
 289         data, err := ioutil.ReadAll(file)
 290         if err != nil {
 291                 t.Log(err)
 292         }
 293         assert.Equal(t, msg, string(data))
 294
 295         assert.Nil(t, HTTPCli.Delete("/folders/"+cfg.ID, &cfg))
 296         var cfgArray []xsapiv1.FolderConfig
 297         assert.Nil(t, HTTPCli.Get("/folders", &cfgArray))
 298         assert.Equal(t, len(cfgArray), 0)
 299 }