gobot.io/x/gobot@v1.16.0/platforms/dji/tello/driver_test.go (about)

     1  package tello
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/binary"
     6  	"fmt"
     7  	"io"
     8  	"testing"
     9  	"time"
    10  
    11  	"gobot.io/x/gobot"
    12  	"gobot.io/x/gobot/gobottest"
    13  )
    14  
    15  var _ gobot.Driver = (*Driver)(nil)
    16  
    17  func TestTelloDriver(t *testing.T) {
    18  	d := NewDriver("8888")
    19  
    20  	gobottest.Assert(t, d.respPort, "8888")
    21  }
    22  
    23  func statusMessage(msgType uint16, msgAfter7 ...byte) []byte {
    24  	msg := make([]byte, 7, len(msgAfter7)+7)
    25  	msg[0] = messageStart
    26  	binary.LittleEndian.PutUint16(msg[5:7], msgType)
    27  	msg = append(msg, msgAfter7...)
    28  	return msg
    29  }
    30  
    31  func TestHandleResponse(t *testing.T) {
    32  	cc := []struct {
    33  		name   string
    34  		msg    io.Reader
    35  		events []gobot.Event
    36  		err    error
    37  	}{
    38  		{
    39  			name: "[empty messsage]",
    40  			msg:  bytes.NewReader(nil),
    41  			err:  io.EOF,
    42  		},
    43  		{
    44  			name:   "wifiMessage",
    45  			msg:    bytes.NewReader(statusMessage(wifiMessage)),
    46  			events: []gobot.Event{{Name: WifiDataEvent}},
    47  		},
    48  		{
    49  			name:   "lightMessage",
    50  			msg:    bytes.NewReader(statusMessage(lightMessage)),
    51  			events: []gobot.Event{{Name: LightStrengthEvent}},
    52  		},
    53  		{
    54  			name:   "logMessage",
    55  			msg:    bytes.NewReader(statusMessage(logMessage)),
    56  			events: []gobot.Event{{Name: LogEvent}},
    57  		},
    58  		{
    59  			name:   "timeCommand",
    60  			msg:    bytes.NewReader(statusMessage(timeCommand)),
    61  			events: []gobot.Event{{Name: TimeEvent}},
    62  		},
    63  		{
    64  			name:   "bounceCommand",
    65  			msg:    bytes.NewReader(statusMessage(bounceCommand)),
    66  			events: []gobot.Event{{Name: BounceEvent}},
    67  		},
    68  		{
    69  			name:   "takeoffCommand",
    70  			msg:    bytes.NewReader(statusMessage(takeoffCommand)),
    71  			events: []gobot.Event{{Name: TakeoffEvent}},
    72  		},
    73  		{
    74  			name:   "landCommand",
    75  			msg:    bytes.NewReader(statusMessage(landCommand)),
    76  			events: []gobot.Event{{Name: LandingEvent}},
    77  		},
    78  		{
    79  			name:   "palmLandCommand",
    80  			msg:    bytes.NewReader(statusMessage(palmLandCommand)),
    81  			events: []gobot.Event{{Name: PalmLandingEvent}},
    82  		},
    83  		{
    84  			name:   "flipCommand",
    85  			msg:    bytes.NewReader(statusMessage(flipCommand)),
    86  			events: []gobot.Event{{Name: FlipEvent}},
    87  		},
    88  		{
    89  			name:   "flightMessage",
    90  			msg:    bytes.NewReader(statusMessage(flightMessage)),
    91  			events: []gobot.Event{{Name: FlightDataEvent}},
    92  		},
    93  		{
    94  			name:   "exposureCommand",
    95  			msg:    bytes.NewReader(statusMessage(exposureCommand)),
    96  			events: []gobot.Event{{Name: SetExposureEvent}},
    97  		},
    98  		{
    99  			name:   "videoEncoderRateCommand",
   100  			msg:    bytes.NewReader(statusMessage(videoEncoderRateCommand)),
   101  			events: []gobot.Event{{Name: SetVideoEncoderRateEvent}},
   102  		},
   103  		{
   104  			name:   "ConnectedEvent",
   105  			msg:    bytes.NewReader([]byte{0x63, 0x6f, 0x6e}),
   106  			events: []gobot.Event{{Name: ConnectedEvent}},
   107  		},
   108  	}
   109  
   110  	for _, c := range cc {
   111  		t.Run(c.name, func(t *testing.T) {
   112  			d := NewDriver("8888")
   113  			events := d.Subscribe()
   114  			err := d.handleResponse(c.msg)
   115  			if c.err != err {
   116  				t.Errorf("expected '%v' error, got: %v", c.err, err)
   117  			}
   118  			for i, cev := range c.events {
   119  				t.Run(fmt.Sprintf("event %d", i), func(t *testing.T) {
   120  					t.Logf("expect: %#v", cev)
   121  					select {
   122  					case ev, ok := <-events:
   123  						if !ok {
   124  							t.Error("subscription channel is closed")
   125  						}
   126  						if ev.Name != cev.Name {
   127  							t.Errorf("got: %s", ev.Name)
   128  						}
   129  					case <-time.After(time.Millisecond):
   130  						t.Error("subscription channel seems empty")
   131  					}
   132  				})
   133  			}
   134  		})
   135  	}
   136  }