gobot.io/x/gobot@v1.16.0/master_test.go (about)

     1  package gobot
     2  
     3  import (
     4  	"errors"
     5  	"log"
     6  	"os"
     7  	"testing"
     8  	"time"
     9  
    10  	multierror "github.com/hashicorp/go-multierror"
    11  	"gobot.io/x/gobot/gobottest"
    12  )
    13  
    14  func initTestMaster() *Master {
    15  	log.SetOutput(&NullReadWriteCloser{})
    16  	g := NewMaster()
    17  	g.trap = func(c chan os.Signal) {
    18  		c <- os.Interrupt
    19  	}
    20  	g.AddRobot(newTestRobot("Robot1"))
    21  	g.AddRobot(newTestRobot("Robot2"))
    22  	g.AddRobot(newTestRobot(""))
    23  	return g
    24  }
    25  
    26  func initTestMaster1Robot() *Master {
    27  	log.SetOutput(&NullReadWriteCloser{})
    28  	g := NewMaster()
    29  	g.trap = func(c chan os.Signal) {
    30  		c <- os.Interrupt
    31  	}
    32  	g.AddRobot(newTestRobot("Robot99"))
    33  
    34  	return g
    35  }
    36  
    37  func TestVersion(t *testing.T) {
    38  	gobottest.Assert(t, version, Version())
    39  }
    40  
    41  func TestNullReadWriteCloser(t *testing.T) {
    42  	n := &NullReadWriteCloser{}
    43  	i, _ := n.Write([]byte{1, 2, 3})
    44  	gobottest.Assert(t, i, 3)
    45  	i, _ = n.Read(make([]byte, 10))
    46  	gobottest.Assert(t, i, 10)
    47  	gobottest.Assert(t, n.Close(), nil)
    48  }
    49  
    50  func TestMasterRobot(t *testing.T) {
    51  	g := initTestMaster()
    52  	gobottest.Assert(t, g.Robot("Robot1").Name, "Robot1")
    53  	gobottest.Assert(t, g.Robot("Robot4"), (*Robot)(nil))
    54  	gobottest.Assert(t, g.Robot("Robot4").Device("Device1"), (Device)(nil))
    55  	gobottest.Assert(t, g.Robot("Robot4").Connection("Connection1"), (Connection)(nil))
    56  	gobottest.Assert(t, g.Robot("Robot1").Device("Device4"), (Device)(nil))
    57  	gobottest.Assert(t, g.Robot("Robot1").Device("Device1").Name(), "Device1")
    58  	gobottest.Assert(t, g.Robot("Robot1").Devices().Len(), 3)
    59  	gobottest.Assert(t, g.Robot("Robot1").Connection("Connection4"), (Connection)(nil))
    60  	gobottest.Assert(t, g.Robot("Robot1").Connections().Len(), 3)
    61  }
    62  
    63  func TestMasterToJSON(t *testing.T) {
    64  	g := initTestMaster()
    65  	g.AddCommand("test_function", func(params map[string]interface{}) interface{} {
    66  		return nil
    67  	})
    68  	json := NewJSONMaster(g)
    69  	gobottest.Assert(t, len(json.Robots), g.Robots().Len())
    70  	gobottest.Assert(t, len(json.Commands), len(g.Commands()))
    71  }
    72  
    73  func TestMasterStart(t *testing.T) {
    74  	g := initTestMaster()
    75  	gobottest.Assert(t, g.Start(), nil)
    76  	gobottest.Assert(t, g.Stop(), nil)
    77  	gobottest.Assert(t, g.Running(), false)
    78  }
    79  
    80  func TestMasterStartAutoRun(t *testing.T) {
    81  	g := NewMaster()
    82  	g.AddRobot(newTestRobot("Robot99"))
    83  	go g.Start()
    84  	time.Sleep(10 * time.Millisecond)
    85  	gobottest.Assert(t, g.Running(), true)
    86  
    87  	// stop it
    88  	gobottest.Assert(t, g.Stop(), nil)
    89  	gobottest.Assert(t, g.Running(), false)
    90  }
    91  
    92  func TestMasterStartDriverErrors(t *testing.T) {
    93  	g := initTestMaster1Robot()
    94  	e := errors.New("driver start error 1")
    95  	testDriverStart = func() (err error) {
    96  		return e
    97  	}
    98  
    99  	var expected error
   100  	expected = multierror.Append(expected, e)
   101  	expected = multierror.Append(expected, e)
   102  	expected = multierror.Append(expected, e)
   103  
   104  	gobottest.Assert(t, g.Start(), expected)
   105  	gobottest.Assert(t, g.Stop(), nil)
   106  
   107  	testDriverStart = func() (err error) { return }
   108  }
   109  
   110  func TestMasterHaltFromRobotDriverErrors(t *testing.T) {
   111  	g := initTestMaster1Robot()
   112  	e := errors.New("driver halt error 1")
   113  	testDriverHalt = func() (err error) {
   114  		return e
   115  	}
   116  
   117  	var expected error
   118  	expected = multierror.Append(expected, e)
   119  	expected = multierror.Append(expected, e)
   120  	expected = multierror.Append(expected, e)
   121  
   122  	gobottest.Assert(t, g.Start(), nil)
   123  	gobottest.Assert(t, g.Stop(), expected)
   124  
   125  	testDriverHalt = func() (err error) { return }
   126  }
   127  
   128  func TestMasterStartRobotAdaptorErrors(t *testing.T) {
   129  	g := initTestMaster1Robot()
   130  	e := errors.New("adaptor start error 1")
   131  
   132  	testAdaptorConnect = func() (err error) {
   133  		return e
   134  	}
   135  
   136  	var expected error
   137  	expected = multierror.Append(expected, e)
   138  	expected = multierror.Append(expected, e)
   139  	expected = multierror.Append(expected, e)
   140  
   141  	gobottest.Assert(t, g.Start(), expected)
   142  	gobottest.Assert(t, g.Stop(), nil)
   143  
   144  	testAdaptorConnect = func() (err error) { return }
   145  }
   146  
   147  func TestMasterFinalizeErrors(t *testing.T) {
   148  	g := initTestMaster1Robot()
   149  	e := errors.New("adaptor finalize error 2")
   150  
   151  	testAdaptorFinalize = func() (err error) {
   152  		return e
   153  	}
   154  
   155  	var expected error
   156  	expected = multierror.Append(expected, e)
   157  	expected = multierror.Append(expected, e)
   158  	expected = multierror.Append(expected, e)
   159  
   160  	gobottest.Assert(t, g.Start(), nil)
   161  	gobottest.Assert(t, g.Stop(), expected)
   162  
   163  	testAdaptorFinalize = func() (err error) {
   164  		return nil
   165  	}
   166  }