test/target_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         "strconv"
  21         "strings"
  22         "testing"
  23         "time"
  24
  25         "gerrit.automotivelinux.org/gerrit/src/xds/xds-server/lib/xsapiv1"
  26         "github.com/stretchr/testify/assert"
  27 )
  28
  29 /*flush channel with timeout*/
  30 func flushChannelTerm(channel chan xsapiv1.TerminalOutMsg, ms time.Duration) {
  31         timeoutB := false
  32         for !timeoutB {
  33                 select {
  34                 case <-channel:
  35                 case <-time.After(ms * time.Millisecond):
  36                         timeoutB = true
  37                 }
  38         }
  39 }
  40
  41 func ConnectTargetEvents(t *testing.T, channel chan xsapiv1.TargetConfig) {
  42         sCli.Conn.On(xsapiv1.EVTTargetAdd, func(e xsapiv1.EventMsg) {
  43                 target, _ := e.DecodeTargetEvent()
  44                 channel <- target
  45         })
  46
  47         args := xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetAdd}
  48         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  49
  50         sCli.Conn.On(xsapiv1.EVTTargetRemove, func(e xsapiv1.EventMsg) {
  51                 target, _ := e.DecodeTargetEvent()
  52                 channel <- target
  53         })
  54
  55         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetRemove}
  56         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  57 }
  58
  59 func DisconnectTargetEvents(t *testing.T) {
  60         args := xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetAdd}
  61         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  62         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetRemove}
  63         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  64 }
  65
  66 func ConnectTermEvents(t *testing.T, channel chan xsapiv1.TerminalConfig) {
  67         sCli.Conn.On(xsapiv1.EVTTargetTerminalAdd, func(e xsapiv1.EventMsg) {
  68                 termEvt, _ := e.DecodeTerminalEvent()
  69                 channel <- termEvt
  70         })
  71
  72         args := xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalAdd}
  73         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  74
  75         sCli.Conn.On(xsapiv1.EVTTargetTerminalStateChange, func(e xsapiv1.EventMsg) {
  76                 termEvt, _ := e.DecodeTerminalEvent()
  77                 channel <- termEvt
  78         })
  79
  80         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalStateChange}
  81         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  82
  83         sCli.Conn.On(xsapiv1.EVTTargetTerminalRemove, func(e xsapiv1.EventMsg) {
  84                 termEvt, _ := e.DecodeTerminalEvent()
  85                 channel <- termEvt
  86         })
  87
  88         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalRemove}
  89         assert.Nil(t, HTTPCli.Post("/events/register", args, nil))
  90 }
  91
  92 func DisconnectTermEvents(t *testing.T) {
  93         args := xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalAdd}
  94         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  95         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalStateChange}
  96         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  97         args = xsapiv1.EventRegisterArgs{Name: xsapiv1.EVTTargetTerminalRemove}
  98         assert.Nil(t, HTTPCli.Post("/events/unregister", args, nil))
  99 }
 100
 101 func AddTargets(t *testing.T, nbTargets int, chTarget chan xsapiv1.TargetConfig) []string {
 102         listID := make([]string, nbTargets)
 103         for i := 0; i < nbTargets; i++ {
 104                 /*target is local*/
 105                 target := xsapiv1.TargetConfig{
 106                         Name: "fakeTarget" + strconv.Itoa(i),
 107                         Type: xsapiv1.TypeTgtStandard,
 108                         IP:   "127.0.0.1",
 109                 }
 110                 /*add target*/
 111                 assert.Nil(t, HTTPCli.Post("/targets", target, &target))
 112                 Debugf(t, "add target %v", target.Name)
 113                 targetEvt := <-chTarget //waiting for event targetAdd
 114                 assert.Equal(t, target.ID, targetEvt.ID)
 115                 listID[i] = target.ID
 116         }
 117         for i := 0; i < nbTargets; i++ {
 118                 var target xsapiv1.TargetConfig
 119                 assert.Nil(t, HTTPCli.Get("/targets/"+listID[i], &target))
 120                 assert.Equal(t, target.Status, "Enable")
 121         }
 122         return listID
 123 }
 124
 125 func AddTerms(t *testing.T, nbTerms int, listID []string, chTermEvt chan xsapiv1.TerminalConfig) {
 126         for j := 0; j < len(listID); j++ {
 127                 listTermsID := make([]string, nbTerms)
 128                 for i := 0; i < nbTerms; i++ {
 129                         term := xsapiv1.TerminalConfig{
 130                                 Name: "terminal" + strconv.Itoa(i),
 131                                 Type: xsapiv1.TypeTermSSH,
 132                         }
 133                         /*add terminal on target*/
 134                         assert.Nil(t, HTTPCli.Post("/targets/"+listID[j]+"/terminals", term, &term))
 135                         Debugf(t, "add terminal %v", term.Name)
 136                         termEvt := <-chTermEvt //waiting for event terminalAdd*/
 137                         assert.Equal(t, term.ID, termEvt.ID)
 138                         listTermsID[i] = term.ID
 139                 }
 140                 assert.Equal(t, len(listTermsID), nbTerms)
 141                 for i := 0; i < nbTerms; i++ {
 142                         var term xsapiv1.TerminalConfig
 143                         assert.Nil(t, HTTPCli.Get("/targets/"+listID[j]+"/terminals/"+listTermsID[i], &term))
 144                         assert.Equal(t, term.Status, "Close")
 145                 }
 146         }
 147 }
 148
 149 func PostTerms(t *testing.T, post string, chTermEvt chan xsapiv1.TerminalConfig) {
 150         var status string
 151         switch post {
 152         case "open":
 153                 status = "Open"
 154         case "close":
 155                 status = "Closing"
 156         }
 157         var targets []xsapiv1.TargetConfig
 158         assert.Nil(t, HTTPCli.Get("/targets", &targets))
 159         for i := 0; i < len(targets); i++ {
 160                 var terms []xsapiv1.TerminalConfig
 161                 assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals", &terms))
 162                 listTermsID := make([]string, len(terms))
 163                 for j := 0; j < len(terms); j++ {
 164                         var term xsapiv1.TerminalConfig
 165                         /*post action on term*/
 166                         assert.Nil(t, HTTPCli.Post("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID+"/"+post, terms[j], &term))
 167                         Debugf(t, "%v terminal %v", post, term.Name)
 168                         termEvt := <-chTermEvt //waiting for event terminalStateChange
 169                         assert.Equal(t, term.ID, termEvt.ID)
 170                         assert.Equal(t, term.Status, status)
 171                         assert.Equal(t, termEvt.Status, status)
 172                         listTermsID[i] = term.ID
 173                 }
 174                 time.Sleep(10 * time.Millisecond)
 175                 for j := 0; j < len(listTermsID); j++ {
 176                         var term xsapiv1.TerminalConfig
 177                         assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals/"+listTermsID[i], &term))
 178                         assert.True(t, strings.EqualFold(term.Status, post))
 179                         Debugf(t, "check that term status %v is %v", term.Name, post)
 180                 }
 181         }
 182 }
 183
 184 func RemoveTermsTargets(t *testing.T, chTarget chan xsapiv1.TargetConfig, chTermEvt chan xsapiv1.TerminalConfig) {
 185         var targets []xsapiv1.TargetConfig
 186         assert.Nil(t, HTTPCli.Get("/targets", &targets))
 187         for i := 0; i < len(targets); i++ {
 188                 var terms []xsapiv1.TerminalConfig
 189                 assert.Nil(t, HTTPCli.Get("/targets/"+targets[i].ID+"/terminals", &terms))
 190                 for j := 0; j < len(terms); j++ {
 191                         var term xsapiv1.TerminalConfig
 192                         assert.Nil(t, HTTPCli.Delete("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID, &term))
 193                         termEvt := <-chTermEvt
 194                         assert.Equal(t, term.ID, termEvt.ID)
 195                         assert.NotNil(t, HTTPCli.Delete("/targets/"+targets[i].ID+"/terminals/"+terms[j].ID, &term))
 196                         Debugf(t, "remove terminal %v", term.Name)
 197                 }
 198                 var tgtRes xsapiv1.TargetConfig
 199                 assert.Nil(t, HTTPCli.Delete("/targets/"+targets[i].ID, &tgtRes))
 200                 targetEvt := <-chTarget //waiting for remove terminal event
 201                 assert.Equal(t, tgtRes.ID, targetEvt.ID)
 202                 assert.Equal(t, targets[i].ID, tgtRes.ID)
 203         }
 204 }
 205 func TestTarget(t *testing.T) {
 206         nbTargets := 3
 207         nbTermsByTarget := 3
 208         /*channel for target events*/
 209         chTarget := make(chan xsapiv1.TargetConfig)
 210         defer close(chTarget)
 211         ConnectTargetEvents(t, chTarget)
 212
 213         /*channel for terminal events*/
 214         chTermEvt := make(chan xsapiv1.TerminalConfig)
 215         defer close(chTermEvt)
 216         ConnectTermEvents(t, chTermEvt)
 217
 218         /*check that targetArray is empty at startup*/
 219         var targetArray []xsapiv1.TargetConfig
 220         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 221         assert.Equal(t, len(targetArray), 0)
 222
 223         listID := AddTargets(t, nbTargets, chTarget)
 224         AddTerms(t, nbTermsByTarget, listID, chTermEvt)
 225
 226         ///*channel for TerminalOutMsg*/
 227         //chTerm := make(chan xsapiv1.TerminalOutMsg)
 228         //defer close(chTerm)
 229
 230         ///*connect on terminalOutMsg event*/
 231         //sCli.Conn.On(xsapiv1.TerminalOutEvent, func(ev xsapiv1.TerminalOutMsg) {
 232         //      chTerm <- ev
 233         //})
 234
 235         ///*just for the first term*/
 236         //var terms []xsapiv1.TerminalConfig
 237         //var term xsapiv1.TerminalConfig
 238         //assert.Nil(t, HTTPCli.Get("/targets/"+listID[0]+"/terminals", &terms))
 239         //assert.Nil(t, HTTPCli.Post("/targets/"+listID[0]+"/terminals/"+terms[0].ID+"/open", terms[0], &term))
 240         //<-chTermEvt                  //waiting for event terminalStateChange
 241         //termOut := <-chTerm          //waiting for terminalOutMsg
 242         //flushChannelTerm(chTerm, 50) //flushing all terminalOutMsg
 243         //stdoutMsg := string(termOut.Stdout)
 244         //if strings.Contains(stdoutMsg, "Connection refused") {
 245         //      t.Fatalf("%vYou may have to launch ssh server", stdoutMsg)
 246         //} else if strings.Contains(stdoutMsg, "password") {
 247         //      t.Fatalf("%vcopy your pub key in authorized_keys\ncat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys", stdoutMsg)
 248         //}
 249         //assert.True(t, strings.Contains(stdoutMsg, "Last login")) //first terminal msg should be Last Login
 250         //assert.Nil(t, HTTPCli.Post("/targets/"+listID[0]+"/terminals/"+terms[0].ID+"/close", terms[0], &term))
 251         //<-chTermEvt //waiting for event terminalStateChange
 252
 253         ///*open terminals*/
 254         //PostTerms(t, "open", chTermEvt)
 255         //termOut = <-chTerm           //waiting for terminalOutMsg
 256         //flushChannelTerm(chTerm, 50) //flushing all terminalOutMsg
 257         //stdoutMsg = string(termOut.Stdout)
 258         //if strings.Contains(stdoutMsg, "Connection refused") {
 259         //      t.Fatalf("%vYou may have to launch ssh server", stdoutMsg)
 260         //} else if strings.Contains(stdoutMsg, "password") {
 261         //      t.Fatalf("%vcopy your pub key in authorized_keys\ncat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys", stdoutMsg)
 262         //}
 263         //assert.True(t, strings.Contains(stdoutMsg, "Last login")) //first terminal msg should be Last Login
 264
 265         ///*create toto file through terminals*/
 266         //rootCfgDir := os.Getenv(envRootCfgDir)
 267         //totoFile := path.Join(rootCfgDir, "toto")
 268
 269         ///*test with 2 terminals*/
 270         //for i := 0; i < 2; i++ {
 271         //      totoFileCurrent := totoFile + strconv.Itoa(i)
 272         //      /*send cmd though term*/
 273         //      data := []byte("echo helloWorld" + strconv.Itoa(i) + " >> " + totoFileCurrent + "\n")
 274         //      Debugf(t, "send following command through terminal: %v", string(data))
 275         //      assert.Nil(t, sCli.Conn.Emit(xsapiv1.TerminalInEvent, data))
 276         //      flushChannelTerm(chTerm, 50) //waiting for terminal msg
 277
 278         //      /*check that toto file is created*/
 279         //      _, err := os.Stat(totoFileCurrent)
 280         //      assert.Nil(t, err)
 281
 282         //      /*send cmd though term*/
 283         //      data = []byte("cat " + totoFileCurrent + "\n")
 284         //      Debugf(t, "send following command through terminal: %v", string(data))
 285         //      assert.Nil(t, sCli.Conn.Emit(xsapiv1.TerminalInEvent, data))
 286
 287         //      <-chTerm                     //cmd sent
 288         //      termOut = <-chTerm           //result of cat cmd
 289         //      flushChannelTerm(chTerm, 50) //flushing what remains
 290         //      /*check that terminal msg is what was written before*/
 291         //      assert.Equal(t, string(termOut.Stdout), "helloWorld"+strconv.Itoa(i)+"\r\n")
 292         //      Debugf(t, "check terminal output msg: %v", string(termOut.Stdout))
 293         //}
 294
 295         //PostTerms(t, "close", chTermEvt)
 296
 297         /*remove targets and terms*/
 298         RemoveTermsTargets(t, chTarget, chTermEvt)
 299         DisconnectTargetEvents(t)
 300         DisconnectTermEvents(t)
 301 }
 302
 303 func TestTargetErrors(t *testing.T) {
 304         /*cannot create empty target*/
 305         target := xsapiv1.TargetConfig{}
 306         var targetRes xsapiv1.TargetConfig
 307         assert.NotNil(t, HTTPCli.Post("/targets", target, &targetRes))
 308         Debugf(t, "error while creating empty target")
 309         /*check cannot create target with no IP*/
 310         target.Type = xsapiv1.TypeTgtStandard
 311         assert.NotNil(t, HTTPCli.Post("/targets", target, &targetRes))
 312         Debugf(t, "error while creating target without IP")
 313         target.IP = "127.0.0.1"
 314         assert.Nil(t, HTTPCli.Post("/targets", target, &targetRes))
 315         Debugf(t, "create target %v", targetRes.Name)
 316
 317         /*cannot create empty terminal*/
 318         term := xsapiv1.TerminalConfig{}
 319         var termRes xsapiv1.TerminalConfig
 320         assert.NotNil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 321         Debugf(t, "error while creating empty terminal")
 322         term.Type = xsapiv1.TypeTermSSH
 323         assert.NotNil(t, HTTPCli.Post("/targets/"+"1010"+"/terminals", term, &termRes))
 324         Debugf(t, "error while creating terminal on an non existing target")
 325         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 326         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 327         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 328         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 329         Debugf(t, "create several terminals")
 330
 331         /*remove targets and terms*/
 332         var targetArray []xsapiv1.TargetConfig
 333         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 334         for i := 0; i < len(targetArray); i++ {
 335                 var termArray []xsapiv1.TerminalConfig
 336                 assert.Nil(t, HTTPCli.Get("/targets/"+targetArray[i].ID+"/terminals", &termArray))
 337                 for j := 0; j < len(termArray); j++ {
 338                         assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 339                         Debugf(t, "delete terminal %v", termRes.Name)
 340                         assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 341                         Debugf(t, "error while deleting an already deleted terminal %v", termRes.Name)
 342                 }
 343                 var tgtRes xsapiv1.TargetConfig
 344                 assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 345                 Debugf(t, "delete target %v", tgtRes.Name)
 346                 assert.Equal(t, targetArray[i].ID, tgtRes.ID)
 347                 assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 348                 Debugf(t, "error while deleting an already deleted target %v", tgtRes.Name)
 349         }
 350 }