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 TestTarget(t *testing.T) {
 104         chTarget := make(chan xsapiv1.TargetConfig)
 105         defer close(chTarget)
 106         ConnectTargetEvents(t, chTarget)
 107
 108         chTermEvt := make(chan xsapiv1.TerminalConfig)
 109         defer close(chTermEvt)
 110         ConnectTermEvents(t, chTermEvt)
 111
 112         var targetArray []xsapiv1.TargetConfig
 113         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 114         assert.Equal(t, len(targetArray), 0)
 115
 116         target := xsapiv1.TargetConfig{
 117                 Name: "fakeTarget",
 118                 Type: xsapiv1.TypeTgtStandard,
 119                 IP:   "127.0.0.1",
 120         }
 121         var targetRes, targetResBis xsapiv1.TargetConfig
 122         assert.Nil(t, HTTPCli.Post("/targets", target, &targetRes))
 123         targetEvt := <-chTarget
 124         assert.Equal(t, targetRes.ID, targetEvt.ID)
 125         target.Name = "fakeTargetBis"
 126         assert.Nil(t, HTTPCli.Post("/targets", target, &targetResBis))
 127         targetEvt = <-chTarget
 128         assert.Equal(t, targetResBis.ID, targetEvt.ID)
 129         assert.Equal(t, targetRes.Status, "Enable")
 130         assert.Equal(t, targetResBis.Status, "Enable")
 131
 132         term := xsapiv1.TerminalConfig{
 133                 Name: "terminal",
 134                 Type: xsapiv1.TypeTermSSH,
 135         }
 136         var termRes, termResBis xsapiv1.TerminalConfig
 137         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 138         termEvt := <-chTermEvt
 139         assert.Equal(t, termRes.ID, termEvt.ID)
 140         term.Name = "terminalBis"
 141         assert.Nil(t, HTTPCli.Post("/targets/"+targetResBis.ID+"/terminals", term, &termResBis))
 142         termEvt = <-chTermEvt
 143         assert.Equal(t, termResBis.ID, termEvt.ID)
 144         assert.Equal(t, termRes.Status, "Enable")
 145         assert.Equal(t, termResBis.Status, "Enable")
 146
 147         chTerm := make(chan xsapiv1.TerminalOutMsg)
 148         defer close(chTerm)
 149
 150         sCli.Conn.On(xsapiv1.TerminalOutEvent, func(ev xsapiv1.TerminalOutMsg) {
 151                 chTerm <- ev
 152         })
 153
 154         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals/"+termRes.ID+"/open", termRes, &termRes))
 155         termEvt = <-chTermEvt
 156         assert.Equal(t, termRes.ID, termEvt.ID)
 157         assert.Equal(t, termEvt.Status, "Open")
 158         assert.Nil(t, HTTPCli.Post("/targets/"+targetResBis.ID+"/terminals/"+termResBis.ID+"/open", termResBis, &termResBis))
 159         termEvt = <-chTermEvt
 160         assert.Equal(t, termResBis.ID, termEvt.ID)
 161         assert.Equal(t, termEvt.Status, "Open")
 162         assert.Equal(t, termRes.Status, "Open")
 163         assert.Equal(t, termResBis.Status, "Open")
 164
 165         termOut := <-chTerm
 166         flushChannelTerm(chTerm, 50)
 167         stdoutMsg := string(termOut.Stdout)
 168         if strings.Contains(stdoutMsg, "Connection refused") {
 169                 t.Fatalf("%vYou may have to launch ssh server", stdoutMsg)
 170         } else if strings.Contains(stdoutMsg, "password") {
 171                 t.Fatalf("%vcopy your pub key in authorized_keys\ncat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys", stdoutMsg)
 172         }
 173         assert.True(t, strings.Contains(stdoutMsg, "Last login"))
 174
 175         rootCfgDir := os.Getenv(envRootCfgDir)
 176         totoFile := path.Join(rootCfgDir, "toto")
 177
 178         /*test with 2 terminals*/
 179         for i := 0; i < 2; i++ {
 180                 totoFileCurrent := totoFile + strconv.Itoa(i)
 181                 /*send cmd though term*/
 182                 data := []byte("echo helloWorld" + strconv.Itoa(i) + " >> " + totoFileCurrent + "\n")
 183
 184                 assert.Nil(t, sCli.Conn.Emit(xsapiv1.TerminalInEvent, data))
 185                 flushChannelTerm(chTerm, 50)
 186
 187                 /*check that toto file is created*/
 188                 _, err := os.Stat(totoFileCurrent)
 189                 assert.Nil(t, err)
 190
 191                 data = []byte("cat " + totoFileCurrent + "\n")
 192                 assert.Nil(t, sCli.Conn.Emit(xsapiv1.TerminalInEvent, data))
 193
 194                 <-chTerm           //cmd sent
 195                 termOut = <-chTerm //result of cat cmd
 196                 flushChannelTerm(chTerm, 50)
 197                 assert.Equal(t, string(termOut.Stdout), "helloWorld"+strconv.Itoa(i)+"\r\n")
 198         }
 199
 200         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals/"+termRes.ID+"/close", termRes, &termRes))
 201         termEvt = <-chTermEvt
 202         assert.Equal(t, termRes.ID, termEvt.ID)
 203         assert.Equal(t, termEvt.Status, "Close")
 204         assert.Nil(t, HTTPCli.Post("/targets/"+targetResBis.ID+"/terminals/"+termResBis.ID+"/close", termResBis, &termResBis))
 205         termEvt = <-chTermEvt
 206         assert.Equal(t, termResBis.ID, termEvt.ID)
 207         assert.Equal(t, termEvt.Status, "Close")
 208         assert.Equal(t, termRes.Status, "Close")
 209         assert.Equal(t, termResBis.Status, "Close")
 210
 211         /*remove targets and terms*/
 212         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 213         for i := 0; i < len(targetArray); i++ {
 214                 var termArray []xsapiv1.TerminalConfig
 215                 assert.Nil(t, HTTPCli.Get("/targets/"+targetArray[i].ID+"/terminals", &termArray))
 216                 for j := 0; j < len(termArray); j++ {
 217                         assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 218                         termEvt = <-chTermEvt
 219                         assert.Equal(t, termRes.ID, termEvt.ID)
 220                         assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 221                 }
 222                 var tgtRes xsapiv1.TargetConfig
 223                 assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 224                 targetEvt = <-chTarget
 225                 assert.Equal(t, tgtRes.ID, targetEvt.ID)
 226                 assert.Equal(t, targetArray[i].ID, tgtRes.ID)
 227         }
 228         DisconnectTargetEvents(t)
 229         DisconnectTermEvents(t)
 230 }
 231
 232 func TestTargetErrors(t *testing.T) {
 233         target := xsapiv1.TargetConfig{}
 234         var targetRes xsapiv1.TargetConfig
 235         assert.NotNil(t, HTTPCli.Post("/targets", target, &targetRes))
 236         target.Type = xsapiv1.TypeTgtStandard
 237         assert.NotNil(t, HTTPCli.Post("/targets", target, &targetRes))
 238         target.IP = "127.0.0.1"
 239         assert.Nil(t, HTTPCli.Post("/targets", target, &targetRes))
 240
 241         term := xsapiv1.TerminalConfig{}
 242         var termRes xsapiv1.TerminalConfig
 243         assert.NotNil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 244         term.Type = xsapiv1.TypeTermSSH
 245         assert.NotNil(t, HTTPCli.Post("/targets/"+"1010"+"/terminals", term, &termRes))
 246         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 247         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 248         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 249         assert.Nil(t, HTTPCli.Post("/targets/"+targetRes.ID+"/terminals", term, &termRes))
 250
 251         /*remove targets and terms*/
 252         var targetArray []xsapiv1.TargetConfig
 253         assert.Nil(t, HTTPCli.Get("/targets", &targetArray))
 254         for i := 0; i < len(targetArray); i++ {
 255                 var termArray []xsapiv1.TerminalConfig
 256                 assert.Nil(t, HTTPCli.Get("/targets/"+targetArray[i].ID+"/terminals", &termArray))
 257                 for j := 0; j < len(termArray); j++ {
 258                         assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 259                         assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID+"/terminals/"+termArray[j].ID, &termRes))
 260                 }
 261                 var tgtRes xsapiv1.TargetConfig
 262                 assert.Nil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 263                 assert.Equal(t, targetArray[i].ID, tgtRes.ID)
 264                 assert.NotNil(t, HTTPCli.Delete("/targets/"+targetArray[i].ID, &tgtRes))
 265         }
 266 }