317 lines
8.0 KiB
Go
317 lines
8.0 KiB
Go
package mqttclient
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"git.coadcorp.com/nathan/invertergui/mk2driver"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
type fakeWriter struct {
|
|
lastKind string
|
|
lastID uint16
|
|
lastValue int16
|
|
lastSwitchState mk2driver.PanelSwitchState
|
|
lastCurrentLimit *float64
|
|
lastStandby *bool
|
|
err error
|
|
}
|
|
|
|
func (f *fakeWriter) WriteRAMVar(id uint16, value int16) error {
|
|
f.lastKind = commandKindRAMVar
|
|
f.lastID = id
|
|
f.lastValue = value
|
|
return f.err
|
|
}
|
|
|
|
func (f *fakeWriter) WriteSetting(id uint16, value int16) error {
|
|
f.lastKind = commandKindSetting
|
|
f.lastID = id
|
|
f.lastValue = value
|
|
return f.err
|
|
}
|
|
|
|
func (f *fakeWriter) SetPanelState(switchState mk2driver.PanelSwitchState, currentLimitA *float64) error {
|
|
f.lastKind = commandKindPanel
|
|
f.lastSwitchState = switchState
|
|
f.lastCurrentLimit = currentLimitA
|
|
return f.err
|
|
}
|
|
|
|
func (f *fakeWriter) SetStandby(standby bool) error {
|
|
f.lastKind = commandKindStandby
|
|
f.lastStandby = &standby
|
|
return f.err
|
|
}
|
|
|
|
func Test_decodeWriteCommand(t *testing.T) {
|
|
currentLimit := 16.5
|
|
tests := []struct {
|
|
name string
|
|
payload string
|
|
check func(*testing.T, writeCommand)
|
|
wantErr string
|
|
}{
|
|
{
|
|
name: "setting",
|
|
payload: `{"request_id":"abc","kind":"setting","id":15,"value":-5}`,
|
|
check: func(t *testing.T, got writeCommand) {
|
|
assert.Equal(t, writeCommand{
|
|
RequestID: "abc",
|
|
Kind: commandKindSetting,
|
|
ID: 15,
|
|
Value: -5,
|
|
}, got)
|
|
},
|
|
},
|
|
{
|
|
name: "ram_var alias from type",
|
|
payload: `{"type":"ramvar","id":2,"value":7}`,
|
|
check: func(t *testing.T, got writeCommand) {
|
|
assert.Equal(t, writeCommand{
|
|
Kind: commandKindRAMVar,
|
|
ID: 2,
|
|
Value: 7,
|
|
}, got)
|
|
},
|
|
},
|
|
{
|
|
name: "panel state",
|
|
payload: `{"kind":"panel_state","switch":"on","current_limit":16.5}`,
|
|
check: func(t *testing.T, got writeCommand) {
|
|
assert.Equal(t, commandKindPanel, got.Kind)
|
|
assert.True(t, got.HasSwitch)
|
|
assert.Equal(t, mk2driver.PanelSwitchOn, got.SwitchState)
|
|
assert.Equal(t, "on", got.SwitchName)
|
|
if assert.NotNil(t, got.CurrentLimitA) {
|
|
assert.Equal(t, currentLimit, *got.CurrentLimitA)
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "panel current limit only",
|
|
payload: `{"kind":"panel_state","current_limit":12.0}`,
|
|
check: func(t *testing.T, got writeCommand) {
|
|
assert.Equal(t, commandKindPanel, got.Kind)
|
|
assert.False(t, got.HasSwitch)
|
|
assert.Nil(t, got.Standby)
|
|
if assert.NotNil(t, got.CurrentLimitA) {
|
|
assert.Equal(t, 12.0, *got.CurrentLimitA)
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "standby bool",
|
|
payload: `{"kind":"standby","standby":true}`,
|
|
check: func(t *testing.T, got writeCommand) {
|
|
assert.Equal(t, commandKindStandby, got.Kind)
|
|
if assert.NotNil(t, got.Standby) {
|
|
assert.True(t, *got.Standby)
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "standby using value string",
|
|
payload: `{"kind":"standby","value":"OFF"}`,
|
|
check: func(t *testing.T, got writeCommand) {
|
|
assert.Equal(t, commandKindStandby, got.Kind)
|
|
if assert.NotNil(t, got.Standby) {
|
|
assert.False(t, *got.Standby)
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: "missing id",
|
|
payload: `{"kind":"setting","value":1}`,
|
|
wantErr: `missing required field "id"`,
|
|
},
|
|
{
|
|
name: "missing panel switch and current limit",
|
|
payload: `{"kind":"panel_state"}`,
|
|
wantErr: `missing required field "switch"`,
|
|
},
|
|
{
|
|
name: "invalid standby",
|
|
payload: `{"kind":"standby","value":"banana"}`,
|
|
wantErr: `field "standby" must be true/false`,
|
|
},
|
|
{
|
|
name: "invalid kind",
|
|
payload: `{"kind":"unknown","id":1,"value":1}`,
|
|
wantErr: `unsupported write command kind "unknown"`,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := decodeWriteCommand([]byte(tt.payload))
|
|
if tt.wantErr != "" {
|
|
assert.Error(t, err)
|
|
assert.ErrorContains(t, err, tt.wantErr)
|
|
return
|
|
}
|
|
|
|
assert.NoError(t, err)
|
|
tt.check(t, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_executeWriteCommand(t *testing.T) {
|
|
limit := 8.0
|
|
standby := true
|
|
tests := []struct {
|
|
name string
|
|
cmd writeCommand
|
|
want string
|
|
}{
|
|
{
|
|
name: "setting",
|
|
cmd: writeCommand{
|
|
Kind: commandKindSetting,
|
|
ID: 9,
|
|
Value: 2,
|
|
},
|
|
want: commandKindSetting,
|
|
},
|
|
{
|
|
name: "ram_var",
|
|
cmd: writeCommand{
|
|
Kind: commandKindRAMVar,
|
|
ID: 3,
|
|
Value: -1,
|
|
},
|
|
want: commandKindRAMVar,
|
|
},
|
|
{
|
|
name: "panel_state",
|
|
cmd: writeCommand{
|
|
Kind: commandKindPanel,
|
|
HasSwitch: true,
|
|
SwitchState: mk2driver.PanelSwitchInverterOnly,
|
|
CurrentLimitA: &limit,
|
|
},
|
|
want: commandKindPanel,
|
|
},
|
|
{
|
|
name: "standby",
|
|
cmd: writeCommand{
|
|
Kind: commandKindStandby,
|
|
Standby: &standby,
|
|
},
|
|
want: commandKindStandby,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
writer := &fakeWriter{}
|
|
err := executeWriteCommand(writer, tt.cmd)
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, tt.want, writer.lastKind)
|
|
switch tt.want {
|
|
case commandKindPanel:
|
|
assert.Equal(t, tt.cmd.SwitchState, writer.lastSwitchState)
|
|
if assert.NotNil(t, writer.lastCurrentLimit) {
|
|
assert.Equal(t, *tt.cmd.CurrentLimitA, *writer.lastCurrentLimit)
|
|
}
|
|
case commandKindStandby:
|
|
if assert.NotNil(t, writer.lastStandby) {
|
|
assert.Equal(t, *tt.cmd.Standby, *writer.lastStandby)
|
|
}
|
|
default:
|
|
assert.Equal(t, tt.cmd.ID, writer.lastID)
|
|
assert.Equal(t, tt.cmd.Value, writer.lastValue)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_buildHADiscoveryDefinitions(t *testing.T) {
|
|
cfg := Config{
|
|
Topic: "invertergui/updates",
|
|
CommandTopic: "invertergui/settings/set",
|
|
HomeAssistant: HomeAssistantConfig{
|
|
Enabled: true,
|
|
DiscoveryPrefix: "homeassistant",
|
|
NodeID: "victron_main",
|
|
DeviceName: "Shed Victron",
|
|
},
|
|
}
|
|
|
|
definitions := buildHADiscoveryDefinitions(cfg)
|
|
assert.NotEmpty(t, definitions)
|
|
|
|
var panelMode *haDiscoveryDefinition
|
|
var panelCurrentLimit *haDiscoveryDefinition
|
|
var panelStandby *haDiscoveryDefinition
|
|
var batteryVoltage *haDiscoveryDefinition
|
|
for i := range definitions {
|
|
def := &definitions[i]
|
|
if def.Component == "select" && def.ObjectID == "remote_panel_mode" {
|
|
panelMode = def
|
|
}
|
|
if def.Component == "number" && def.ObjectID == "remote_panel_current_limit" {
|
|
panelCurrentLimit = def
|
|
}
|
|
if def.Component == "switch" && def.ObjectID == "remote_panel_standby" {
|
|
panelStandby = def
|
|
}
|
|
if def.Component == "sensor" && def.ObjectID == "battery_voltage" {
|
|
batteryVoltage = def
|
|
}
|
|
}
|
|
|
|
if assert.NotNil(t, panelMode) {
|
|
assert.Equal(t, cfg.CommandTopic, panelMode.Config["command_topic"])
|
|
assert.Equal(t, haPanelSwitchStateTopic(cfg), panelMode.Config["state_topic"])
|
|
}
|
|
if assert.NotNil(t, panelCurrentLimit) {
|
|
assert.Equal(t, cfg.CommandTopic, panelCurrentLimit.Config["command_topic"])
|
|
assert.Equal(t, haCurrentLimitStateTopic(cfg), panelCurrentLimit.Config["state_topic"])
|
|
}
|
|
if assert.NotNil(t, panelStandby) {
|
|
assert.Equal(t, cfg.CommandTopic, panelStandby.Config["command_topic"])
|
|
assert.Equal(t, haStandbyStateTopic(cfg), panelStandby.Config["state_topic"])
|
|
}
|
|
if assert.NotNil(t, batteryVoltage) {
|
|
assert.Equal(t, cfg.Topic, batteryVoltage.Config["state_topic"])
|
|
}
|
|
}
|
|
|
|
func Test_panelStateCacheResolvePanelCommand(t *testing.T) {
|
|
cache := &panelStateCache{}
|
|
|
|
_, err := cache.resolvePanelCommand(writeCommand{
|
|
Kind: commandKindPanel,
|
|
CurrentLimitA: float64Ptr(12),
|
|
})
|
|
assert.Error(t, err)
|
|
|
|
cache.remember(writeCommand{
|
|
Kind: commandKindPanel,
|
|
HasSwitch: true,
|
|
SwitchState: mk2driver.PanelSwitchOn,
|
|
SwitchName: "on",
|
|
})
|
|
|
|
resolved, err := cache.resolvePanelCommand(writeCommand{
|
|
Kind: commandKindPanel,
|
|
CurrentLimitA: float64Ptr(10),
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.True(t, resolved.HasSwitch)
|
|
assert.Equal(t, mk2driver.PanelSwitchOn, resolved.SwitchState)
|
|
assert.Equal(t, "on", resolved.SwitchName)
|
|
}
|
|
|
|
func float64Ptr(in float64) *float64 {
|
|
return &in
|
|
}
|
|
|
|
func Test_normalizeID(t *testing.T) {
|
|
assert.Equal(t, "victron_main_01", normalizeID("Victron Main #01"))
|
|
assert.Equal(t, "inverter-gui", normalizeID(" inverter-gui "))
|
|
assert.Equal(t, "", normalizeID(" "))
|
|
}
|