feat(storage): improve fronius tests

pkg/fronius/configure.go

@@ -1,8 +1,7 @@
 package fronius
 
 import (
-	"fmt"
-
+	"errors"
 	u "sbam/src/utils"
 
 	"github.com/simonvetter/modbus"
@@ -33,7 +32,7 @@ func WriteFroniusModbusRegisters(modbusStorageCfg map[uint16]int16) error {
 		err = modbusClient.WriteRegister(r-1, uint16(v))
 		if err != nil {
 			u.Log.Errorf("Something goes wrong writing the register: %d, value: %d", r, v)
-			panic(err)
+			return err
 		}
 	}
 	return nil
@@ -46,7 +45,7 @@ func ReadFroniusModbusRegisters(modbusStorageCfg map[uint16]int16) ([]int16, err
 		u.Log.Infof("Reading register: %d ; value: %v", r, value)
 		if err != nil {
 			u.Log.Errorf("Something goes wrong reading the register: %d, value: %d", r, v)
-			panic(err)
+			return values, err
 		}
 		values = append(values, int16(value))
 	}
@@ -58,7 +57,7 @@ func ReadFroniusModbusRegister(address uint16) (int16, error) {
 	u.Log.Infof("Reading register: %d ; value: %v", address, value)
 	if err != nil {
 		u.Log.Errorf("Something goes wrong reading the register: %d, value: %d", address, value)
-		panic(err)
+		return int16(value), err
 	}
 	return int16(value), nil
 }
@@ -70,12 +69,28 @@ func Setdefaults(modbus_ip string, port ...string) error {
 	}
 	u.Log.Info("Setting Fronius Storage Defaults start...")
 	regList := mdsc
-	OpenModbusClient(modbus_ip, p)
+	err = OpenModbusClient(modbus_ip, p)
+	if err != nil {
+		u.Log.Errorf("Something goes wrong %s", err)
+		return err
+	}
 
-	ReadFroniusModbusRegisters(regList)
-	WriteFroniusModbusRegisters(regList)
+	_, err = ReadFroniusModbusRegisters(regList)
+	if err != nil {
+		u.Log.Errorf("Something goes wrong %s", err)
+		return err
+	}
+	err = WriteFroniusModbusRegisters(regList)
+	if err != nil {
+		u.Log.Errorf("Something goes wrong %s", err)
+		return err
+	}
 
-	ClosemodbusClient()
+	err = ClosemodbusClient()
+	if err != nil {
+		u.Log.Errorf("Something goes wrong %s", err)
+		return err
+	}
 	u.Log.Info("Setting Fronius Modbus Defaults done.")
 	return nil
 }
@@ -92,16 +107,34 @@ func ForceCharge(modbus_ip string, power_prc int16, port ...string) error {
 		regList[StorCtl_Mod] = 2 // Limit Decharging
 		regList[OutWRte] = -100 * power_prc
 
-		OpenModbusClient(modbus_ip, p)
+		err = OpenModbusClient(modbus_ip, p)
+		if err != nil {
+			u.Log.Errorf("Something goes wrong %s", err)
+			return err
+		}
 
-		ReadFroniusModbusRegisters(regList)
-		WriteFroniusModbusRegisters(regList)
+		_, err = ReadFroniusModbusRegisters(regList)
+		if err != nil {
+			u.Log.Errorf("Something goes wrong %s", err)
+			return err
+		}
+		err = WriteFroniusModbusRegisters(regList)
+		if err != nil {
+			u.Log.Errorf("Something goes wrong %s", err)
+			return err
+		}
 
-		ClosemodbusClient()
+		err = ClosemodbusClient()
+		if err != nil {
+			u.Log.Errorf("Something goes wrong %s", err)
+			return err
+		}
 	} else if power_prc == 0 {
 		Setdefaults(modbus_ip, p)
 	} else {
-		panic(fmt.Errorf("someting goes wrong when force charging, percent of charging is negative: %d", power_prc))
+		err = errors.New("percent of charging is negative")
+		u.Log.Errorf("someting goes wrong when force charging, %s", err)
+		return err
 	}
 	u.Log.Info("Setting Fronius Storage Force Charge done.")
 	return nil

pkg/fronius/fronius_test.go

@@ -79,6 +79,11 @@ func TestSetdefaults(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestSetdefaultsError(t *testing.T) {
+	err := fronius.Setdefaults(modbus_ip, modbus_port)
+	assert.Error(t, err)
+}
+
 func TestForceCharge(t *testing.T) {
 
 	test_power_prc := []int16{
@@ -94,6 +99,32 @@ func TestForceCharge(t *testing.T) {
 	}
 }
 
+func TestForceChargeError(t *testing.T) {
+
+	test_power_prc := []int16{
+		50,
+	}
+
+	for _, power_prc := range test_power_prc {
+		err := fronius.ForceCharge(modbus_ip, power_prc, modbus_port)
+		assert.Error(t, err)
+	}
+}
+
+func TestForceCharge2(t *testing.T) {
+
+	test_power_prc := []int16{
+		-50,
+	}
+
+	for _, power_prc := range test_power_prc {
+		setup()
+		err := fronius.ForceCharge(modbus_ip, power_prc, modbus_port)
+		teardown()
+		assert.Error(t, err)
+	}
+}
+
 func TestHandler(t *testing.T) {
 	assert := assert.New(t)
 	fronius := fronius.New()
@@ -114,6 +145,24 @@ func TestHandler(t *testing.T) {
 	assert.NoError(err, "Handler returned an error")
 }
 
+func TestHandlerError(t *testing.T) {
+	assert := assert.New(t)
+	fronius := fronius.New()
+
+	pwForecast := 1000.0
+	pwBatt2charge := 1000.0
+	pwBattMax := 10000.0
+	pwConsumption := 9000.0
+	maxCharge := 3500.0
+	pw_batt_reserve := 0.0
+	startHr := "09:00"
+	endHr := "17:00"
+
+	_, err := fronius.Handler(pwForecast, pwBatt2charge, pwBattMax, pwConsumption, maxCharge, pw_batt_reserve, startHr, endHr, modbus_ip, modbus_port)
+
+	assert.Error(err, "Handler returned an error")
+}
+
 func TestOpenCloseModbusClient(t *testing.T) {
 	assert := assert.New(t)
 	setup()
@@ -124,6 +173,15 @@ func TestOpenCloseModbusClient(t *testing.T) {
 
 }
 
+func TestOpenClientError(t *testing.T) {
+	assert := assert.New(t)
+	setup()
+	err = fronius.OpenModbusClient("123", modbus_port)
+	teardown()
+	assert.Error(err, "OpenModbusClient returned an error")
+
+}
+
 func TestSetChargePower(t *testing.T) {
 	assert := assert.New(t)
 
@@ -200,3 +258,36 @@ func TestBatteryChargeMode5(t *testing.T) {
 
 	teardown()
 }
+
+func TestBatteryChargeMode6(t *testing.T) {
+	assert := assert.New(t)
+	setup()
+
+	result, err := fronius.SetFroniusChargeBatteryMode(8000, 2000, 11000, 9000, 3500, 0, "00:00", "23:59", modbus_ip, modbus_port)
+	assert.Equal(int16(0), result, "SetFroniusChargeBatteryMode returned wrong value")
+	assert.NoError(err)
+
+	teardown()
+}
+
+func TestBatteryChargeError(t *testing.T) {
+	assert := assert.New(t)
+	setup()
+
+	result, err := fronius.SetFroniusChargeBatteryMode(1000, 11000, 11000, 9000, 3500, 2500, "25:59", "00:00", modbus_ip, modbus_port)
+	assert.Equal(int16(0), result, "SetFroniusChargeBatteryMode returned wrong value")
+	assert.Error(err)
+
+	teardown()
+}
+
+func TestBatteryChargeError2(t *testing.T) {
+	assert := assert.New(t)
+	setup()
+
+	result, err := fronius.SetFroniusChargeBatteryMode(1000, 11000, 11000, 9000, 3500, 2500, "00:00", "25:00", modbus_ip, modbus_port)
+	assert.Equal(int16(0), result, "SetFroniusChargeBatteryMode returned wrong value")
+	assert.Error(err)
+
+	teardown()
+}

pkg/fronius/handler.go

@@ -1,5 +1,7 @@
 package fronius
 
+import u "sbam/src/utils"
+
 func New() *Fronius {
 	return &Fronius{}
 }
@@ -10,7 +12,11 @@ func (fronius *Fronius) Handler(pw_forecast float64, pw_batt2charge float64, pw_
 		p = fronius_port[0]
 	}
 
-	charge_pc, _ := SetFroniusChargeBatteryMode(pw_forecast, pw_batt2charge, pw_batt_max, pw_consumption, max_charge, pw_batt_reserve, start_hr, end_hr, fronius_ip, p)
+	charge_pc, err := SetFroniusChargeBatteryMode(pw_forecast, pw_batt2charge, pw_batt_max, pw_consumption, max_charge, pw_batt_reserve, start_hr, end_hr, fronius_ip, p)
+	if err != nil {
+		u.Log.Errorln("Error setting Fronius Battery charge: %s ", err)
+		return charge_pc, err
+	}
 
 	return charge_pc, nil
 

pkg/fronius/modbus.go

@@ -22,17 +22,17 @@ func OpenModbusClient(url string, port ...string) error {
 	})
 	if err != nil {
 		u.Log.Error("Someting goes wrong configuring Modbus Client")
-		panic(err)
+		return err
 	}
 	err = modbusClient.Open()
 	if err != nil {
 		u.Log.Error("Someting goes wrong opening Modbus Client")
-		panic(err)
+		return err
 	}
 	err = modbusClient.SetUnitId(1)
 	if err != nil {
 		u.Log.Error("Someting goes wrong setting Modbus Client SlaveID")
-		panic(err)
+		return err
 	}
 
 	return nil
@@ -43,7 +43,7 @@ func ClosemodbusClient() error {
 	modbusClient.Close()
 	if err != nil {
 		u.Log.Error("Someting goes wrong closing Modbus Client")
-		panic(err)
+		return err
 	}
 
 	return nil

pkg/fronius/schedule.go

@@ -14,26 +14,50 @@ func SetFroniusChargeBatteryMode(pw_forecast float64, pw_batt2charge float64, pw
 	pw_pv_net := pw_forecast - pw_consumption // Net solar power
 	pw_batt := pw_batt_max - pw_batt2charge   // actual battery power
 
-	time, _ := CheckTimeRange(start_hr, end_hr)
-
+	time, err := CheckTimeRange(start_hr, end_hr)
+	if err != nil {
+		u.Log.Errorln("Error checking time range: %s ", err)
+		return ch_pc, err
+	}
 	switch {
 	case !time: // out of the time range => do not charge
 		u.Log.Infof("Out time range start_time: %s - end_time: %s", start_hr, end_hr)
-		Setdefaults(fronius_ip, p)
+		err = Setdefaults(fronius_ip, p)
+		if err != nil {
+			u.Log.Errorln("Error Setting Defaults: %s ", err)
+			return ch_pc, err
+		}
 	case pw_batt2charge == 0: // battery 100% => do not charge
 		u.Log.Info("Battery is full charged")
-		Setdefaults(fronius_ip, p)
+		err = Setdefaults(fronius_ip, p)
+		if err != nil {
+			u.Log.Errorln("Error Setting Defaults: %s ", err)
+			return ch_pc, err
+		}
 	case pw_batt < pw_batt_reserve: // battery is less than reserve => charge
 		ch_pc = SetChargePower(pw_batt_max, pw_batt_reserve, max_charge)
-		ForceCharge(fronius_ip, ch_pc, p)
+		err = ForceCharge(fronius_ip, ch_pc, p)
+		if err != nil {
+			u.Log.Errorln("Error forcing charge: %s ", err)
+			return ch_pc, err
+		}
 
 	default:
 		pw_grid, charge_enabled := ChargeBattery(pw_pv_net, pw_batt)
+
 		if charge_enabled {
 			ch_pc = SetChargePower(pw_batt_max, -1*pw_grid, max_charge)
-			ForceCharge(fronius_ip, ch_pc, p)
+			err = ForceCharge(fronius_ip, ch_pc, p)
+			if err != nil {
+				u.Log.Errorln("Error forcing charge: %s ", err)
+				return ch_pc, err
+			}
 		} else {
-			Setdefaults(fronius_ip, p)
+			err = Setdefaults(fronius_ip, p)
+			if err != nil {
+				u.Log.Errorln("Error Setting Defaults: %s ", err)
+				return ch_pc, err
+			}
 		}
 
 	}
@@ -73,13 +97,13 @@ func CheckTimeRange(start_hr string, end_hr string) (bool, error) {
 	startTime, err := time.Parse(layout, start_hr)
 	if err != nil {
 		u.Log.Error("Something goes wrong parsing start time")
-		panic(err)
+		return false, err
 	}
 
 	endTime, err := time.Parse(layout, end_hr)
 	if err != nil {
 		u.Log.Error("Something goes wrong parsing end time")
-		panic(err)
+		return false, err
 	}
 
 	// Convert the current time to a time.Time value for today's date with the hour and minute set to the parsed start and end times