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         "log"
  21         "net"
  22         "os"
  23         "regexp"
  24         "strings"
  25         "testing"
  26         "time"
  27
  28         common "gerrit.automotivelinux.org/gerrit/src/xds/xds-common.git/golib"
  29         "gerrit.automotivelinux.org/gerrit/src/xds/xds-server/lib/xsapiv1"
  30         "github.com/stretchr/testify/assert"
  31 )
  32
  33 //global client
  34 var HTTPCli *common.HTTPClient
  35 var logDir string
  36
  37 func initEnv() {
  38         rootTestLog := "/tmp/xds-server-test"
  39         if err := os.Setenv(envRootCfgDir, rootTestLog); err != nil {
  40                 log.Fatal(err)
  41         }
  42         os.RemoveAll(rootTestLog)
  43         os.MkdirAll(rootTestLog, 0755)
  44         logDir = rootTestLog + "/logs/"
  45         os.MkdirAll(logDir, 0755)
  46 }
  47
  48 func launchXdsServer(proc **os.Process) *os.File {
  49         logFile := logDir + logFileXdsServer
  50         file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY, 0644)
  51         if err != nil {
  52                 log.Fatal(err)
  53         }
  54         tmpProc, err := os.StartProcess(argsProcess[0], argsProcess, &os.ProcAttr{
  55                 Files: []*os.File{os.Stdin, file, file},
  56         })
  57         if err != nil {
  58                 log.Fatal(err)
  59         }
  60         *proc = tmpProc
  61         return file
  62 }
  63
  64 func getHTTPClient(lvl int) (*common.HTTPClient, *os.File) {
  65         logFile := logDir + logFileClient
  66         file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY, 0644)
  67         if err != nil {
  68                 log.Fatal(err)
  69         }
  70         conf := common.HTTPClientConfig{
  71                 URLPrefix:           "/api/v1",
  72                 HeaderClientKeyName: "Xds-Test-Sid",
  73                 CsrfDisable:         true,
  74                 LogOut:              file,
  75                 LogPrefix:           "XDSSERVERTEST: ",
  76                 LogLevel:            lvl,
  77         }
  78         cli, err := common.HTTPNewClient(prefixURL, conf)
  79         if err != nil {
  80                 log.Print(err)
  81         }
  82         return cli, file
  83 }
  84
  85 func TestMain(m *testing.M) {
  86         initEnv()
  87
  88         var proc *os.Process
  89         fileXdsServer := launchXdsServer(&proc)
  90         go func(p *os.Process) {
  91                 if status, err := p.Wait(); err != nil {
  92                         log.Fatalf("status=%v\n err=%v\n", status, err)
  93                 }
  94         }(proc)
  95         time.Sleep(1 * time.Second)
  96
  97         lvl := common.HTTPLogLevelDebug
  98         var fileHTTPClient *os.File
  99         HTTPCli, fileHTTPClient = getHTTPClient(lvl)
 100
 101         if HTTPCli == nil {
 102                 log.Fatal("HTTPCLi is nil")
 103         }
 104         res := m.Run()
 105         proc.Kill()
 106         fileXdsServer.Close()
 107         fileHTTPClient.Close()
 108         os.Exit(res)
 109 }
 110
 111 func init() {
 112 }
 113
 114 func CheckIP(ipconfig string) bool {
 115         ifaces, _ := net.Interfaces()
 116         for _, i := range ifaces {
 117                 addrs, _ := i.Addrs()
 118                 for _, addr := range addrs {
 119                         if strings.HasPrefix(addr.String(), ipconfig) {
 120                                 return true
 121                         }
 122                 }
 123         }
 124         return false
 125 }
 126
 127 func TestVersion(t *testing.T) {
 128         var datVersion map[string]interface{}
 129         assert.Nil(t, HTTPCli.Get("/version", &datVersion))
 130         t.Log(datVersion)
 131
 132         ver, present := datVersion["version"]
 133         assert.True(t, present)
 134         t.Logf("version is %s", ver.(string))
 135         re := regexp.MustCompile("^v*[0-9]+.[0-9]+.[0-9]+$")
 136         assert.True(t, re.MatchString(ver.(string)))
 137 }
 138
 139 func TestConfig(t *testing.T) {
 140         var datConfig map[string]interface{}
 141         assert.Nil(t, HTTPCli.Get("/config", &datConfig))
 142
 143         builder, present := datConfig["builder"].(map[string]interface{})
 144         assert.True(t, present)
 145         ip, present := builder["ip"]
 146         assert.True(t, present)
 147         assert.True(t, CheckIP(ip.(string)))
 148 }
 149 func TestFolders(t *testing.T) {
 150         var datFolder []interface{}
 151         assert.Nil(t, HTTPCli.Get("/folders", &datFolder))
 152         t.Log(datFolder)
 153         assert.Equal(t, len(datFolder), 0)
 154
 155         fPrj := xsapiv1.FolderConfig{
 156                 Label:      "testproject",
 157                 ClientPath: logDir + "testproject",
 158                 Type:       xsapiv1.TypePathMap,
 159                 ClientData: "clientdatatest",
 160                 DataPathMap: xsapiv1.PathMapConfig{
 161                         ServerPath: logDir + "testserverpath",
 162                 },
 163         }
 164         var cfg xsapiv1.FolderConfig
 165         assert.Nil(t, HTTPCli.Post("/folders", fPrj, &cfg))
 166         assert.NotNil(t, cfg)
 167         t.Log(cfg)
 168
 169         isCfgPrjMatch := func(fPrj xsapiv1.FolderConfig, cfg xsapiv1.FolderConfig) {
 170                 re := regexp.MustCompile("^[0-9a-z]+-[0-9a-z]+-[0-9a-z]+-[0-9a-z]+-[0-9a-z]+$")
 171                 assert.True(t, re.MatchString(cfg.ID)) //ID
 172                 assert.Equal(t, cfg.Label, fPrj.Label) //Label
 173                 assert.Equal(t, cfg.ClientPath, fPrj.ClientPath)
 174                 assert.Equal(t, cfg.Type, fPrj.Type)
 175                 assert.Equal(t, cfg.Status, "Enable")
 176                 assert.Equal(t, cfg.IsInSync, true)
 177                 assert.Equal(t, len(cfg.DefaultSdk), 0)
 178                 assert.Equal(t, fPrj.ClientData, cfg.ClientData)
 179                 assert.Equal(t, fPrj.DataPathMap.ServerPath, cfg.DataPathMap.ServerPath)
 180         }
 181         isCfgPrjMatch(fPrj, cfg)
 182         var cfg2 xsapiv1.FolderConfig
 183         assert.Nil(t, HTTPCli.Get("/folders/"+cfg.ID, &cfg2))
 184         t.Log(cfg2)
 185         isCfgPrjMatch(fPrj, cfg2)
 186
 187         //call with the same uid create error
 188         assert.NotNil(t, HTTPCli.Post("/folders", cfg, &cfg))
 189
 190         //assert.Equal(t, cfg.DefaultSdk, "true")
 191         //call with the same uid
 192         //serverpath nil
 193         //serverpath already exists
 194 }
 195
 196 //func TestRegister(t *testing.T) {
 197 //      var client := common.HTTPClient
 198 //      client.Get("/folders", folders)
 199 //}