Restructure mocks and fixes

- Fix panic in reporting plan
- Fix infinite loop calling timeseries constraints
- Add another test

emobility/events.go

@@ -140,10 +140,6 @@ func (e *EMobilityImpl) HandleEvent(payload spine.EventPayload) {
 					break
 				}
 
-				if err := e.evTimeSeries.RequestConstraints(); err == nil {
-					break
-				}
-
 				e.evRequestTimeSeriesValues()
 
 			case *model.TimeSeriesListDataType:
@@ -212,17 +208,23 @@ func (e *EMobilityImpl) evRequestTimeSeriesValues() {
 
 // send the ev provided charge plan to the CEM
 func (e *EMobilityImpl) evForwardChargePlanIfProvided() {
+	if data, err := e.evGetTimeSeriesPlanData(); err == nil {
+		e.dataProvider.EVProvideChargePlan(data)
+	}
+}
+
+func (e *EMobilityImpl) evGetTimeSeriesPlanData() ([]EVDurationSlotValue, error) {
 	if e.evTimeSeries == nil || e.dataProvider == nil {
-		return
+		return nil, ErrNotSupported
 	}
 
 	timeSeries, err := e.evTimeSeries.GetValueForType(model.TimeSeriesTypeTypePlan)
 	if err != nil {
-		return
+		return nil, err
 	}
 
 	if len(timeSeries.TimeSeriesSlot) == 0 {
-		return
+		return nil, ErrNotSupported
 	}
 
 	var data []EVDurationSlotValue
@@ -231,18 +233,26 @@ func (e *EMobilityImpl) evForwardChargePlanIfProvided() {
 		duration, err := slot.Duration.GetTimeDuration()
 		if err != nil {
 			logging.Log.Error("ev charge plan contains invalid duration:", err)
-			return
+			return nil, err
+		}
+
+		if slot.MaxValue == nil {
+			continue
 		}
 
 		item := EVDurationSlotValue{
 			Duration: duration,
-			Value:    slot.Value.GetValue(),
+			Value:    slot.MaxValue.GetValue(),
 		}
 
 		data = append(data, item)
 	}
 
-	e.dataProvider.EVProvideChargePlan(data)
+	if len(data) == 0 {
+		return nil, ErrNotSupported
+	}
+
+	return data, nil
 }
 
 // request incentive table values

emobility/events_evGetTimeSeriesPlanData_test.go

@@ -0,0 +1,107 @@
+package emobility
+
+import (
+	"testing"
+
+	"github.com/enbility/eebus-go/spine/model"
+	"github.com/enbility/eebus-go/util"
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_evGetTimeSeriesPlanData(t *testing.T) {
+	emobilty, eebusService := setupEmobility()
+
+	data, err := emobilty.evGetTimeSeriesPlanData()
+	assert.NotNil(t, err)
+	assert.Nil(t, data)
+
+	localDevice, remoteDevice, entites, _ := setupDevices(eebusService)
+	emobilty.evseEntity = entites[0]
+	emobilty.evEntity = entites[1]
+
+	ctrl := gomock.NewController(t)
+
+	dataProviderMock := NewMockEmobilityDataProvider(ctrl)
+	emobilty.dataProvider = dataProviderMock
+
+	data, err = emobilty.evGetTimeSeriesPlanData()
+	assert.NotNil(t, err)
+	assert.Nil(t, data)
+
+	emobilty.evTimeSeries = timeSeriesConfiguration(localDevice, emobilty.evEntity)
+
+	data, err = emobilty.evGetTimeSeriesPlanData()
+	assert.NotNil(t, err)
+	assert.Nil(t, data)
+
+	datagram := datagramForEntityAndFeatures(false, localDevice, emobilty.evEntity, model.FeatureTypeTypeTimeSeries, model.RoleTypeServer, model.RoleTypeClient)
+
+	cmd := []model.CmdType{{
+		TimeSeriesDescriptionListData: &model.TimeSeriesDescriptionListDataType{
+			TimeSeriesDescriptionData: []model.TimeSeriesDescriptionDataType{
+				{
+					TimeSeriesId:        util.Ptr(model.TimeSeriesIdType(1)),
+					TimeSeriesType:      util.Ptr(model.TimeSeriesTypeTypeConstraints),
+					TimeSeriesWriteable: util.Ptr(true),
+					UpdateRequired:      util.Ptr(false),
+					Unit:                util.Ptr(model.UnitOfMeasurementTypeW),
+				},
+				{
+					TimeSeriesId:        util.Ptr(model.TimeSeriesIdType(2)),
+					TimeSeriesType:      util.Ptr(model.TimeSeriesTypeTypePlan),
+					TimeSeriesWriteable: util.Ptr(false),
+					Unit:                util.Ptr(model.UnitOfMeasurementTypeW),
+				},
+				{
+					TimeSeriesId:        util.Ptr(model.TimeSeriesIdType(3)),
+					TimeSeriesType:      util.Ptr(model.TimeSeriesTypeTypeSingleDemand),
+					TimeSeriesWriteable: util.Ptr(false),
+					Unit:                util.Ptr(model.UnitOfMeasurementTypeWh),
+				},
+			},
+		}}}
+
+	datagram.Payload.Cmd = cmd
+
+	err = localDevice.ProcessCmd(datagram, remoteDevice)
+	assert.Nil(t, err)
+
+	data, err = emobilty.evGetTimeSeriesPlanData()
+	assert.NotNil(t, err)
+	assert.Nil(t, data)
+
+	cmd = []model.CmdType{{
+		TimeSeriesListData: &model.TimeSeriesListDataType{
+			TimeSeriesData: []model.TimeSeriesDataType{
+				{
+					TimeSeriesId: util.Ptr(model.TimeSeriesIdType(2)),
+					TimePeriod: &model.TimePeriodType{
+						StartTime: model.NewAbsoluteOrRelativeTimeType("PT0S"),
+					},
+					TimeSeriesSlot: []model.TimeSeriesSlotType{
+						{
+							TimeSeriesSlotId: util.Ptr(model.TimeSeriesSlotIdType(0)),
+							Duration:         util.Ptr(model.DurationType("PT5M36S")),
+							MaxValue:         model.NewScaledNumberType(4201),
+						},
+						{
+							TimeSeriesSlotId: util.Ptr(model.TimeSeriesSlotIdType(1)),
+							Duration:         util.Ptr(model.DurationType("P1D")),
+							MaxValue:         model.NewScaledNumberType(0),
+						},
+					},
+				},
+			},
+		}}}
+
+	datagram.Payload.Cmd = cmd
+
+	err = localDevice.ProcessCmd(datagram, remoteDevice)
+	assert.Nil(t, err)
+
+	data, err = emobilty.evGetTimeSeriesPlanData()
+	assert.Nil(t, err)
+	assert.NotNil(t, data)
+
+}