gobot.io/x/gobot/v2@v2.1.0/drivers/spi/mcp3208_test.go (about)

     1  package spi
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  	"testing"
     7  
     8  	"gobot.io/x/gobot/v2"
     9  	"gobot.io/x/gobot/v2/drivers/aio"
    10  	"gobot.io/x/gobot/v2/gobottest"
    11  )
    12  
    13  // this ensures that the implementation is based on spi.Driver, which implements the gobot.Driver
    14  // and tests all implementations, so no further tests needed here for gobot.Driver interface
    15  var _ gobot.Driver = (*MCP3208Driver)(nil)
    16  
    17  // must implement the AnalogReader interface
    18  var _ aio.AnalogReader = (*MCP3208Driver)(nil)
    19  
    20  func initTestMCP3208DriverWithStubbedAdaptor() (*MCP3208Driver, *spiTestAdaptor) {
    21  	a := newSpiTestAdaptor()
    22  	d := NewMCP3208Driver(a)
    23  	if err := d.Start(); err != nil {
    24  		panic(err)
    25  	}
    26  	return d, a
    27  }
    28  
    29  func TestNewMCP3208Driver(t *testing.T) {
    30  	var di interface{} = NewMCP3208Driver(newSpiTestAdaptor())
    31  	d, ok := di.(*MCP3208Driver)
    32  	if !ok {
    33  		t.Errorf("NewMCP3208Driver() should have returned a *MCP3208Driver")
    34  	}
    35  	gobottest.Refute(t, d.Driver, nil)
    36  	gobottest.Assert(t, strings.HasPrefix(d.Name(), "MCP3208"), true)
    37  }
    38  
    39  func TestMCP3208Read(t *testing.T) {
    40  	var tests = map[string]struct {
    41  		chanNum     int
    42  		simRead     []byte
    43  		want        int
    44  		wantWritten []byte
    45  		wantErr     error
    46  	}{
    47  		"number_negative_error": {
    48  			chanNum: -1,
    49  			wantErr: fmt.Errorf("Invalid channel '-1' for read"),
    50  		},
    51  		"number_0_ok": {
    52  			chanNum:     0,
    53  			simRead:     []byte{0xFF, 0xFF, 0xFF},
    54  			wantWritten: []byte{0x06, 0x00, 0x00},
    55  			want:        0x0FFF,
    56  		},
    57  		"number_1_ok": {
    58  			chanNum:     1,
    59  			simRead:     []byte{0xFF, 0xFE, 0xFF},
    60  			wantWritten: []byte{0x06, 0x40, 0x00},
    61  			want:        0x0EFF,
    62  		},
    63  		"number_7_ok": {
    64  			chanNum:     7,
    65  			simRead:     []byte{0xFF, 0xF7, 0x65},
    66  			wantWritten: []byte{0x07, 0xC0, 0x00},
    67  			want:        0x0765,
    68  		},
    69  		"number_8_error": {
    70  			chanNum: 8,
    71  			wantErr: fmt.Errorf("Invalid channel '8' for read"),
    72  		},
    73  	}
    74  	for name, tc := range tests {
    75  		t.Run(name, func(t *testing.T) {
    76  			// arrange
    77  			d, a := initTestMCP3208DriverWithStubbedAdaptor()
    78  			a.spi.SetSimRead(tc.simRead)
    79  			// act
    80  			got, err := d.Read(tc.chanNum)
    81  			// assert
    82  			gobottest.Assert(t, err, tc.wantErr)
    83  			gobottest.Assert(t, got, tc.want)
    84  			gobottest.Assert(t, a.spi.Written(), tc.wantWritten)
    85  		})
    86  	}
    87  }
    88  
    89  func TestMCP3208ReadWithError(t *testing.T) {
    90  	// arrange
    91  	d, a := initTestMCP3208DriverWithStubbedAdaptor()
    92  	a.spi.SetReadError(true)
    93  	// act
    94  	got, err := d.Read(0)
    95  	// assert
    96  	gobottest.Assert(t, err, fmt.Errorf("error while SPI read in mock"))
    97  	gobottest.Assert(t, got, 0)
    98  }