gobot.io/x/gobot@v1.16.0/drivers/i2c/blinkm_driver_test.go (about)

     1  package i2c
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"gobot.io/x/gobot"
     8  	"gobot.io/x/gobot/gobottest"
     9  )
    10  
    11  var _ gobot.Driver = (*BlinkMDriver)(nil)
    12  
    13  // --------- HELPERS
    14  func initTestBlinkMDriver() (driver *BlinkMDriver) {
    15  	driver, _ = initTestBlinkDriverWithStubbedAdaptor()
    16  	return
    17  }
    18  
    19  func initTestBlinkDriverWithStubbedAdaptor() (*BlinkMDriver, *i2cTestAdaptor) {
    20  	adaptor := newI2cTestAdaptor()
    21  	return NewBlinkMDriver(adaptor), adaptor
    22  }
    23  
    24  // --------- TESTS
    25  
    26  func TestNewBlinkMDriver(t *testing.T) {
    27  	// Does it return a pointer to an instance of BlinkMDriver?
    28  	var bm interface{} = NewBlinkMDriver(newI2cTestAdaptor())
    29  	_, ok := bm.(*BlinkMDriver)
    30  	if !ok {
    31  		t.Errorf("NewBlinkMDriver() should have returned a *BlinkMDriver")
    32  	}
    33  }
    34  
    35  // Commands
    36  func TestNewBlinkMDriverCommands_Rgb(t *testing.T) {
    37  	blinkM := initTestBlinkMDriver()
    38  
    39  	gobottest.Assert(t, blinkM.Start(), nil)
    40  
    41  	result := blinkM.Command("Rgb")(rgb)
    42  	gobottest.Assert(t, result, nil)
    43  }
    44  
    45  func TestNewBlinkMDriverCommands_Fade(t *testing.T) {
    46  	blinkM := initTestBlinkMDriver()
    47  
    48  	gobottest.Assert(t, blinkM.Start(), nil)
    49  
    50  	result := blinkM.Command("Fade")(rgb)
    51  	gobottest.Assert(t, result, nil)
    52  }
    53  
    54  func TestNewBlinkMDriverCommands_FirmwareVersion(t *testing.T) {
    55  	blinkM, adaptor := initTestBlinkDriverWithStubbedAdaptor()
    56  
    57  	gobottest.Assert(t, blinkM.Start(), nil)
    58  
    59  	param := make(map[string]interface{})
    60  
    61  	// When len(data) is 2
    62  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
    63  		copy(b, []byte{99, 1})
    64  		return 2, nil
    65  	}
    66  
    67  	result := blinkM.Command("FirmwareVersion")(param)
    68  
    69  	version, _ := blinkM.FirmwareVersion()
    70  	gobottest.Assert(t, result.(map[string]interface{})["version"].(string), version)
    71  
    72  	// When len(data) is not 2
    73  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
    74  		copy(b, []byte{99})
    75  		return 1, nil
    76  	}
    77  	result = blinkM.Command("FirmwareVersion")(param)
    78  
    79  	version, _ = blinkM.FirmwareVersion()
    80  	gobottest.Assert(t, result.(map[string]interface{})["version"].(string), version)
    81  }
    82  
    83  func TestNewBlinkMDriverCommands_Color(t *testing.T) {
    84  	blinkM := initTestBlinkMDriver()
    85  
    86  	gobottest.Assert(t, blinkM.Start(), nil)
    87  
    88  	param := make(map[string]interface{})
    89  
    90  	result := blinkM.Command("Color")(param)
    91  
    92  	color, _ := blinkM.Color()
    93  	gobottest.Assert(t, result.(map[string]interface{})["color"].([]byte), color)
    94  }
    95  
    96  // Methods
    97  func TestBlinkMDriver(t *testing.T) {
    98  	blinkM := initTestBlinkMDriver()
    99  
   100  	gobottest.Assert(t, blinkM.Start(), nil)
   101  	gobottest.Refute(t, blinkM.Connection(), nil)
   102  }
   103  
   104  func TestBlinkMDriverStart(t *testing.T) {
   105  	blinkM, adaptor := initTestBlinkDriverWithStubbedAdaptor()
   106  
   107  	gobottest.Assert(t, blinkM.Start(), nil)
   108  
   109  	adaptor.i2cWriteImpl = func([]byte) (int, error) {
   110  		return 0, errors.New("write error")
   111  	}
   112  	gobottest.Assert(t, blinkM.Start(), errors.New("write error"))
   113  }
   114  
   115  func TestBlinkMDriverStartConnectError(t *testing.T) {
   116  	d, adaptor := initTestBlinkDriverWithStubbedAdaptor()
   117  	adaptor.Testi2cConnectErr(true)
   118  	gobottest.Assert(t, d.Start(), errors.New("Invalid i2c connection"))
   119  }
   120  
   121  func TestBlinkMDriverHalt(t *testing.T) {
   122  	blinkM := initTestBlinkMDriver()
   123  	gobottest.Assert(t, blinkM.Halt(), nil)
   124  }
   125  
   126  func TestBlinkMDriverFirmwareVersion(t *testing.T) {
   127  	blinkM, adaptor := initTestBlinkDriverWithStubbedAdaptor()
   128  
   129  	gobottest.Assert(t, blinkM.Start(), nil)
   130  
   131  	// when len(data) is 2
   132  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
   133  		copy(b, []byte{99, 1})
   134  		return 2, nil
   135  	}
   136  
   137  	version, _ := blinkM.FirmwareVersion()
   138  	gobottest.Assert(t, version, "99.1")
   139  
   140  	// when len(data) is not 2
   141  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
   142  		copy(b, []byte{99})
   143  		return 1, nil
   144  	}
   145  
   146  	version, _ = blinkM.FirmwareVersion()
   147  	gobottest.Assert(t, version, "")
   148  
   149  	adaptor.i2cWriteImpl = func([]byte) (int, error) {
   150  		return 0, errors.New("write error")
   151  	}
   152  
   153  	version, err := blinkM.FirmwareVersion()
   154  	gobottest.Assert(t, err, errors.New("write error"))
   155  }
   156  
   157  func TestBlinkMDriverColor(t *testing.T) {
   158  	blinkM, adaptor := initTestBlinkDriverWithStubbedAdaptor()
   159  
   160  	gobottest.Assert(t, blinkM.Start(), nil)
   161  
   162  	// when len(data) is 3
   163  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
   164  		copy(b, []byte{99, 1, 2})
   165  		return 3, nil
   166  	}
   167  
   168  	color, _ := blinkM.Color()
   169  	gobottest.Assert(t, color, []byte{99, 1, 2})
   170  
   171  	// when len(data) is not 3
   172  	adaptor.i2cReadImpl = func(b []byte) (int, error) {
   173  		copy(b, []byte{99})
   174  		return 1, nil
   175  	}
   176  
   177  	color, _ = blinkM.Color()
   178  	gobottest.Assert(t, color, []byte{})
   179  
   180  	adaptor.i2cWriteImpl = func([]byte) (int, error) {
   181  		return 0, errors.New("write error")
   182  	}
   183  
   184  	color, err := blinkM.Color()
   185  	gobottest.Assert(t, err, errors.New("write error"))
   186  
   187  }
   188  
   189  func TestBlinkMDriverFade(t *testing.T) {
   190  	blinkM, adaptor := initTestBlinkDriverWithStubbedAdaptor()
   191  
   192  	gobottest.Assert(t, blinkM.Start(), nil)
   193  
   194  	adaptor.i2cWriteImpl = func([]byte) (int, error) {
   195  		return 0, errors.New("write error")
   196  	}
   197  
   198  	err := blinkM.Fade(100, 100, 100)
   199  	gobottest.Assert(t, err, errors.New("write error"))
   200  
   201  }
   202  
   203  func TestBlinkMDriverRGB(t *testing.T) {
   204  	blinkM, adaptor := initTestBlinkDriverWithStubbedAdaptor()
   205  
   206  	gobottest.Assert(t, blinkM.Start(), nil)
   207  
   208  	adaptor.i2cWriteImpl = func([]byte) (int, error) {
   209  		return 0, errors.New("write error")
   210  	}
   211  
   212  	err := blinkM.Rgb(100, 100, 100)
   213  	gobottest.Assert(t, err, errors.New("write error"))
   214  
   215  }
   216  
   217  func TestBlinkMDriverSetName(t *testing.T) {
   218  	d := initTestBlinkMDriver()
   219  	d.SetName("TESTME")
   220  	gobottest.Assert(t, d.Name(), "TESTME")
   221  }
   222  
   223  func TestBlinkMDriverOptions(t *testing.T) {
   224  	d := NewBlinkMDriver(newI2cTestAdaptor(), WithBus(2))
   225  	gobottest.Assert(t, d.GetBusOrDefault(1), 2)
   226  }