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