diff --git a/api/api.go b/api/api.go index c9647f7b..d89e7b3e 100644 --- a/api/api.go +++ b/api/api.go @@ -28,7 +28,7 @@ type ServiceInterface interface { IsRunning() bool // add a use case to the service - AddUseCase(useCase UseCaseInterface) + AddUseCase(useCase UseCaseInterface) error // set logging interface SetLogging(logger logging.LoggingInterface) diff --git a/api/usecases.go b/api/usecases.go index bb120ee7..b5660055 100644 --- a/api/usecases.go +++ b/api/usecases.go @@ -57,5 +57,5 @@ type UseCaseInterface interface { UseCaseBaseInterface // add the features - AddFeatures() + AddFeatures() error } diff --git a/examples/ced/main.go b/examples/ced/main.go index 978b3271..bd9d9436 100644 --- a/examples/ced/main.go +++ b/examples/ced/main.go @@ -99,12 +99,18 @@ func (h *controlbox) run() { localEntity := h.myService.LocalDevice().EntityForType(model.EntityTypeTypeGridGuard) h.uclpc = lpc.NewLPC(localEntity, h.OnLPCEvent) - h.myService.AddUseCase(h.uclpc) + err = h.myService.AddUseCase(h.uclpc) + if err != nil { + log.Fatal(err) + } // h.uclpp = lpp.NewLPP(localEntity, h.OnLPPEvent) // h.myService.AddUseCase(h.uclpp) h.ucmpc = mpc.NewMPC(localEntity, h.OnMPCEvent) - h.myService.AddUseCase(h.ucmpc) + err = h.myService.AddUseCase(h.ucmpc) + if err != nil { + log.Fatal(err) + } if len(remoteSki) == 0 { os.Exit(0) diff --git a/examples/controlbox/main.go b/examples/controlbox/main.go index 9965915d..2c8050bf 100644 --- a/examples/controlbox/main.go +++ b/examples/controlbox/main.go @@ -95,10 +95,16 @@ func (h *controlbox) run() { localEntity := h.myService.LocalDevice().EntityForType(model.EntityTypeTypeGridGuard) h.uclpc = lpc.NewLPC(localEntity, h.OnLPCEvent) - h.myService.AddUseCase(h.uclpc) + err = h.myService.AddUseCase(h.uclpc) + if err != nil { + log.Fatal(err) + } h.uclpp = lpp.NewLPP(localEntity, h.OnLPPEvent) - h.myService.AddUseCase(h.uclpp) + err = h.myService.AddUseCase(h.uclpp) + if err != nil { + log.Fatal(err) + } if len(remoteSki) == 0 { os.Exit(0) diff --git a/examples/evse/main.go b/examples/evse/main.go index 8dc17592..60bf8a9a 100644 --- a/examples/evse/main.go +++ b/examples/evse/main.go @@ -92,7 +92,10 @@ func (h *evse) run() { localEntity := h.myService.LocalDevice().EntityForType(model.EntityTypeTypeEVSE) h.uclpc = lpc.NewLPC(localEntity, h.OnLPCEvent) - h.myService.AddUseCase(h.uclpc) + err = h.myService.AddUseCase(h.uclpc) + if err != nil { + log.Fatal(err) + } // Initialize local server data _ = h.uclpc.SetConsumptionNominalMax(32000) diff --git a/examples/hems/main.go b/examples/hems/main.go index 4c6e2a4f..b7b47e3b 100644 --- a/examples/hems/main.go +++ b/examples/hems/main.go @@ -102,19 +102,46 @@ func (h *hems) run() { localEntity := h.myService.LocalDevice().EntityForType(model.EntityTypeTypeCEM) h.uccslpc = cslpc.NewLPC(localEntity, h.OnLPCEvent) - h.myService.AddUseCase(h.uccslpc) + err = h.myService.AddUseCase(h.uccslpc) + if err != nil { + log.Fatal(err) + } + h.uccslpp = cslpp.NewLPP(localEntity, h.OnLPPEvent) - h.myService.AddUseCase(h.uccslpp) + err = h.myService.AddUseCase(h.uccslpp) + if err != nil { + log.Fatal(err) + } + h.uceglpc = eglpc.NewLPC(localEntity, nil) - h.myService.AddUseCase(h.uceglpc) + err = h.myService.AddUseCase(h.uceglpc) + if err != nil { + log.Fatal(err) + } + h.uceglpp = eglpp.NewLPP(localEntity, nil) - h.myService.AddUseCase(h.uceglpp) + err = h.myService.AddUseCase(h.uceglpp) + if err != nil { + log.Fatal(err) + } + h.ucmamgcp = mgcp.NewMGCP(localEntity, h.OnMGCPEvent) - h.myService.AddUseCase(h.ucmamgcp) + err = h.myService.AddUseCase(h.ucmamgcp) + if err != nil { + log.Fatal(err) + } + h.uccemvabd = vabd.NewVABD(localEntity, h.OnVABDEvent) - h.myService.AddUseCase(h.uccemvabd) + err = h.myService.AddUseCase(h.uccemvabd) + if err != nil { + log.Fatal(err) + } + h.uccemvapd = vapd.NewVAPD(localEntity, h.OnVAPDEvent) - h.myService.AddUseCase(h.uccemvapd) + err = h.myService.AddUseCase(h.uccemvapd) + if err != nil { + log.Fatal(err) + } // Initialize local server data _ = h.uccslpc.SetConsumptionNominalMax(32000) diff --git a/examples/remote/ucs.go b/examples/remote/ucs.go index d1eead23..92e7069e 100644 --- a/examples/remote/ucs.go +++ b/examples/remote/ucs.go @@ -3,6 +3,7 @@ package main import ( "context" "fmt" + "log" "github.com/enbility/eebus-go/api" spineapi "github.com/enbility/spine-go/api" @@ -31,7 +32,10 @@ func (r *Remote) RegisterUseCase(entityType model.EntityTypeType, usecaseId stri ) { r.PropagateEvent(identifier, ski, device, entity, event) }) - r.service.AddUseCase(uc) + err := r.service.AddUseCase(uc) + if err != nil { + log.Fatal(err) + } return r.registerStaticReceiverProxy(usecaseId, uc) } diff --git a/features/server/electricalconnection.go b/features/server/electricalconnection.go index 44d3885c..80035f5a 100644 --- a/features/server/electricalconnection.go +++ b/features/server/electricalconnection.go @@ -31,6 +31,48 @@ func NewElectricalConnection(localEntity spineapi.EntityLocalInterface) (*Electr return ec, nil } +func (e *ElectricalConnection) GetOrAddIdForDescription( + electricalConnectionDescription model.ElectricalConnectionDescriptionDataType, +) (*model.ElectricalConnectionIdType, error) { + electricalConnectionId := (*model.ElectricalConnectionIdType)(nil) + highestExistingElectricalConnectionId := model.ElectricalConnectionIdType(0) + + descriptionData := e.featureLocal.DataCopy(model.FunctionTypeElectricalConnectionDescriptionListData).(*model.ElectricalConnectionDescriptionListDataType) + + if descriptionData != nil && descriptionData.ElectricalConnectionDescriptionData != nil { + for _, description := range descriptionData.ElectricalConnectionDescriptionData { + if description.ElectricalConnectionId != nil && + description.PowerSupplyType == electricalConnectionDescription.PowerSupplyType && + description.AcConnectedPhases == electricalConnectionDescription.AcConnectedPhases && + description.AcRmsPeriodDuration == electricalConnectionDescription.AcRmsPeriodDuration && + description.PositiveEnergyDirection == electricalConnectionDescription.PositiveEnergyDirection && + description.ScopeType == electricalConnectionDescription.ScopeType && + description.Label == electricalConnectionDescription.Label && + description.Description == electricalConnectionDescription.Description { + electricalConnectionId = description.ElectricalConnectionId + break + } else if description.ElectricalConnectionId != nil { + if *description.ElectricalConnectionId > highestExistingElectricalConnectionId { + highestExistingElectricalConnectionId = *description.ElectricalConnectionId + } + } + } + } + + if electricalConnectionId == nil { + electricalConnectionId = util.Ptr(highestExistingElectricalConnectionId + 1) + description := electricalConnectionDescription + description.ElectricalConnectionId = electricalConnectionId + if errType := e.featureLocal.UpdateData(model.FunctionTypeElectricalConnectionDescriptionListData, &model.ElectricalConnectionDescriptionListDataType{ + ElectricalConnectionDescriptionData: []model.ElectricalConnectionDescriptionDataType{description}, + }, model.NewFilterTypePartial(), nil); errType != nil { + return nil, errors.New("could not add description data") + } + } + + return electricalConnectionId, nil +} + // Add a new description data set // // NOTE: the electricalConnectionId has to be provided diff --git a/features/server/electricalconnection_test.go b/features/server/electricalconnection_test.go index b89e4172..c84ca1fd 100644 --- a/features/server/electricalconnection_test.go +++ b/features/server/electricalconnection_test.go @@ -119,6 +119,40 @@ func (s *ElectricalConnectionSuite) Test_Description() { assert.NotNil(s.T(), data) } +func (s *ElectricalConnectionSuite) Test_GetOrAddIdForDescription() { + filter := model.ElectricalConnectionDescriptionDataType{} + + data, err := s.sut.GetDescriptionsForFilter(filter) + assert.NotNil(s.T(), err) + assert.Nil(s.T(), data) + + desc1 := model.ElectricalConnectionDescriptionDataType{ + PowerSupplyType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeDc), + ScopeType: util.Ptr(model.ScopeTypeTypeACPowerTotal), + } + + eConnectionId, err := s.sut.GetOrAddIdForDescription(desc1) + assert.Nil(s.T(), err) + assert.Equal(s.T(), model.ElectricalConnectionIdType(1), *eConnectionId) + + eConnectionId, err = s.sut.GetOrAddIdForDescription(desc1) + assert.Nil(s.T(), err) + assert.Equal(s.T(), model.ElectricalConnectionIdType(1), *eConnectionId) + + desc2 := model.ElectricalConnectionDescriptionDataType{ + PowerSupplyType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + ScopeType: util.Ptr(model.ScopeTypeTypeACPowerTotal), + } + + eConnectionId2, err := s.sut.GetOrAddIdForDescription(desc2) + assert.Nil(s.T(), err) + assert.Equal(s.T(), model.ElectricalConnectionIdType(2), *eConnectionId2) + + eConnectionId, err = s.sut.GetOrAddIdForDescription(desc1) + assert.Nil(s.T(), err) + assert.Equal(s.T(), model.ElectricalConnectionIdType(1), *eConnectionId) +} + func (s *ElectricalConnectionSuite) Test_ParameterDescription() { filter := model.ElectricalConnectionParameterDescriptionDataType{} diff --git a/mocks/DeviceClassificationClientInterface.go b/mocks/DeviceClassificationClientInterface.go index 567c8b6e..254176b4 100644 --- a/mocks/DeviceClassificationClientInterface.go +++ b/mocks/DeviceClassificationClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/DeviceClassificationCommonInterface.go b/mocks/DeviceClassificationCommonInterface.go index 19b8b339..e98a3f96 100644 --- a/mocks/DeviceClassificationCommonInterface.go +++ b/mocks/DeviceClassificationCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/DeviceClassificationServerInterface.go b/mocks/DeviceClassificationServerInterface.go index a072e4b4..c79d8620 100644 --- a/mocks/DeviceClassificationServerInterface.go +++ b/mocks/DeviceClassificationServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/DeviceConfigurationClientInterface.go b/mocks/DeviceConfigurationClientInterface.go index a55ed0f3..6374f9a3 100644 --- a/mocks/DeviceConfigurationClientInterface.go +++ b/mocks/DeviceConfigurationClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -21,7 +21,7 @@ func (_m *DeviceConfigurationClientInterface) EXPECT() *DeviceConfigurationClien } // CheckEventPayloadDataForFilter provides a mock function with given fields: payloadData, filter -func (_m *DeviceConfigurationClientInterface) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) bool { +func (_m *DeviceConfigurationClientInterface) CheckEventPayloadDataForFilter(payloadData any, filter any) bool { ret := _m.Called(payloadData, filter) if len(ret) == 0 { @@ -29,7 +29,7 @@ func (_m *DeviceConfigurationClientInterface) CheckEventPayloadDataForFilter(pay } var r0 bool - if rf, ok := ret.Get(0).(func(interface{}, interface{}) bool); ok { + if rf, ok := ret.Get(0).(func(any, any) bool); ok { r0 = rf(payloadData, filter) } else { r0 = ret.Get(0).(bool) @@ -44,15 +44,15 @@ type DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call stru } // CheckEventPayloadDataForFilter is a helper method to define mock.On call -// - payloadData interface{} -// - filter interface{} +// - payloadData any +// - filter any func (_e *DeviceConfigurationClientInterface_Expecter) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call { return &DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call{Call: _e.mock.On("CheckEventPayloadDataForFilter", payloadData, filter)} } -func (_c *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData interface{}, filter interface{})) *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call { +func (_c *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData any, filter any)) *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}), args[1].(interface{})) + run(args[0].(any), args[1].(any)) }) return _c } @@ -62,7 +62,7 @@ func (_c *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call return _c } -func (_c *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(interface{}, interface{}) bool) *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call { +func (_c *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(any, any) bool) *DeviceConfigurationClientInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Return(run) return _c } diff --git a/mocks/DeviceConfigurationCommonInterface.go b/mocks/DeviceConfigurationCommonInterface.go index e10b3e7a..181919f0 100644 --- a/mocks/DeviceConfigurationCommonInterface.go +++ b/mocks/DeviceConfigurationCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -21,7 +21,7 @@ func (_m *DeviceConfigurationCommonInterface) EXPECT() *DeviceConfigurationCommo } // CheckEventPayloadDataForFilter provides a mock function with given fields: payloadData, filter -func (_m *DeviceConfigurationCommonInterface) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) bool { +func (_m *DeviceConfigurationCommonInterface) CheckEventPayloadDataForFilter(payloadData any, filter any) bool { ret := _m.Called(payloadData, filter) if len(ret) == 0 { @@ -29,7 +29,7 @@ func (_m *DeviceConfigurationCommonInterface) CheckEventPayloadDataForFilter(pay } var r0 bool - if rf, ok := ret.Get(0).(func(interface{}, interface{}) bool); ok { + if rf, ok := ret.Get(0).(func(any, any) bool); ok { r0 = rf(payloadData, filter) } else { r0 = ret.Get(0).(bool) @@ -44,15 +44,15 @@ type DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call stru } // CheckEventPayloadDataForFilter is a helper method to define mock.On call -// - payloadData interface{} -// - filter interface{} +// - payloadData any +// - filter any func (_e *DeviceConfigurationCommonInterface_Expecter) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call { return &DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call{Call: _e.mock.On("CheckEventPayloadDataForFilter", payloadData, filter)} } -func (_c *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData interface{}, filter interface{})) *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData any, filter any)) *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}), args[1].(interface{})) + run(args[0].(any), args[1].(any)) }) return _c } @@ -62,7 +62,7 @@ func (_c *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call return _c } -func (_c *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(interface{}, interface{}) bool) *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(any, any) bool) *DeviceConfigurationCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Return(run) return _c } diff --git a/mocks/DeviceConfigurationServerInterface.go b/mocks/DeviceConfigurationServerInterface.go index ad7a0972..06b26c16 100644 --- a/mocks/DeviceConfigurationServerInterface.go +++ b/mocks/DeviceConfigurationServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -69,7 +69,7 @@ func (_c *DeviceConfigurationServerInterface_AddKeyValueDescription_Call) RunAnd } // CheckEventPayloadDataForFilter provides a mock function with given fields: payloadData, filter -func (_m *DeviceConfigurationServerInterface) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) bool { +func (_m *DeviceConfigurationServerInterface) CheckEventPayloadDataForFilter(payloadData any, filter any) bool { ret := _m.Called(payloadData, filter) if len(ret) == 0 { @@ -77,7 +77,7 @@ func (_m *DeviceConfigurationServerInterface) CheckEventPayloadDataForFilter(pay } var r0 bool - if rf, ok := ret.Get(0).(func(interface{}, interface{}) bool); ok { + if rf, ok := ret.Get(0).(func(any, any) bool); ok { r0 = rf(payloadData, filter) } else { r0 = ret.Get(0).(bool) @@ -92,15 +92,15 @@ type DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call stru } // CheckEventPayloadDataForFilter is a helper method to define mock.On call -// - payloadData interface{} -// - filter interface{} +// - payloadData any +// - filter any func (_e *DeviceConfigurationServerInterface_Expecter) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call { return &DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call{Call: _e.mock.On("CheckEventPayloadDataForFilter", payloadData, filter)} } -func (_c *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData interface{}, filter interface{})) *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call { +func (_c *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData any, filter any)) *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}), args[1].(interface{})) + run(args[0].(any), args[1].(any)) }) return _c } @@ -110,7 +110,7 @@ func (_c *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call return _c } -func (_c *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(interface{}, interface{}) bool) *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call { +func (_c *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(any, any) bool) *DeviceConfigurationServerInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Return(run) return _c } diff --git a/mocks/DeviceDiagnosisClientInterface.go b/mocks/DeviceDiagnosisClientInterface.go index f2096d22..58f5b614 100644 --- a/mocks/DeviceDiagnosisClientInterface.go +++ b/mocks/DeviceDiagnosisClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/DeviceDiagnosisCommonInterface.go b/mocks/DeviceDiagnosisCommonInterface.go index c5c71233..ba52ef8f 100644 --- a/mocks/DeviceDiagnosisCommonInterface.go +++ b/mocks/DeviceDiagnosisCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/DeviceDiagnosisServerInterface.go b/mocks/DeviceDiagnosisServerInterface.go index 382080b5..e3356cb9 100644 --- a/mocks/DeviceDiagnosisServerInterface.go +++ b/mocks/DeviceDiagnosisServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/ElectricalConnectionClientInterface.go b/mocks/ElectricalConnectionClientInterface.go index b6605ccd..6df3bf35 100644 --- a/mocks/ElectricalConnectionClientInterface.go +++ b/mocks/ElectricalConnectionClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/ElectricalConnectionCommonInterface.go b/mocks/ElectricalConnectionCommonInterface.go index 6fb44028..c1acb9cb 100644 --- a/mocks/ElectricalConnectionCommonInterface.go +++ b/mocks/ElectricalConnectionCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -68,7 +68,7 @@ func (_c *ElectricalConnectionCommonInterface_AdjustValueToBeWithinPermittedValu } // CheckEventPayloadDataForFilter provides a mock function with given fields: payloadData, filter -func (_m *ElectricalConnectionCommonInterface) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) bool { +func (_m *ElectricalConnectionCommonInterface) CheckEventPayloadDataForFilter(payloadData any, filter any) bool { ret := _m.Called(payloadData, filter) if len(ret) == 0 { @@ -76,7 +76,7 @@ func (_m *ElectricalConnectionCommonInterface) CheckEventPayloadDataForFilter(pa } var r0 bool - if rf, ok := ret.Get(0).(func(interface{}, interface{}) bool); ok { + if rf, ok := ret.Get(0).(func(any, any) bool); ok { r0 = rf(payloadData, filter) } else { r0 = ret.Get(0).(bool) @@ -91,15 +91,15 @@ type ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call str } // CheckEventPayloadDataForFilter is a helper method to define mock.On call -// - payloadData interface{} -// - filter interface{} +// - payloadData any +// - filter any func (_e *ElectricalConnectionCommonInterface_Expecter) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call { return &ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call{Call: _e.mock.On("CheckEventPayloadDataForFilter", payloadData, filter)} } -func (_c *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData interface{}, filter interface{})) *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData any, filter any)) *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}), args[1].(interface{})) + run(args[0].(any), args[1].(any)) }) return _c } @@ -109,7 +109,7 @@ func (_c *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Cal return _c } -func (_c *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(interface{}, interface{}) bool) *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(any, any) bool) *ElectricalConnectionCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Return(run) return _c } diff --git a/mocks/ElectricalConnectionServerInterface.go b/mocks/ElectricalConnectionServerInterface.go index 54f21735..5ec2bed3 100644 --- a/mocks/ElectricalConnectionServerInterface.go +++ b/mocks/ElectricalConnectionServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -222,7 +222,7 @@ func (_c *ElectricalConnectionServerInterface_AdjustValueToBeWithinPermittedValu } // CheckEventPayloadDataForFilter provides a mock function with given fields: payloadData, filter -func (_m *ElectricalConnectionServerInterface) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) bool { +func (_m *ElectricalConnectionServerInterface) CheckEventPayloadDataForFilter(payloadData any, filter any) bool { ret := _m.Called(payloadData, filter) if len(ret) == 0 { @@ -230,7 +230,7 @@ func (_m *ElectricalConnectionServerInterface) CheckEventPayloadDataForFilter(pa } var r0 bool - if rf, ok := ret.Get(0).(func(interface{}, interface{}) bool); ok { + if rf, ok := ret.Get(0).(func(any, any) bool); ok { r0 = rf(payloadData, filter) } else { r0 = ret.Get(0).(bool) @@ -245,15 +245,15 @@ type ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call str } // CheckEventPayloadDataForFilter is a helper method to define mock.On call -// - payloadData interface{} -// - filter interface{} +// - payloadData any +// - filter any func (_e *ElectricalConnectionServerInterface_Expecter) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call { return &ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call{Call: _e.mock.On("CheckEventPayloadDataForFilter", payloadData, filter)} } -func (_c *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData interface{}, filter interface{})) *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call { +func (_c *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData any, filter any)) *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}), args[1].(interface{})) + run(args[0].(any), args[1].(any)) }) return _c } @@ -263,7 +263,7 @@ func (_c *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Cal return _c } -func (_c *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(interface{}, interface{}) bool) *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call { +func (_c *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(any, any) bool) *ElectricalConnectionServerInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Return(run) return _c } diff --git a/mocks/EntityEventCallback.go b/mocks/EntityEventCallback.go index 042ca199..c1b5b914 100644 --- a/mocks/EntityEventCallback.go +++ b/mocks/EntityEventCallback.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/FeatureClientInterface.go b/mocks/FeatureClientInterface.go index d6ac99b1..77edda79 100644 --- a/mocks/FeatureClientInterface.go +++ b/mocks/FeatureClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/FeatureServerInterface.go b/mocks/FeatureServerInterface.go index 32cf51d9..6598e318 100644 --- a/mocks/FeatureServerInterface.go +++ b/mocks/FeatureServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/IdentificationClientInterface.go b/mocks/IdentificationClientInterface.go index a58d983d..d7b15179 100644 --- a/mocks/IdentificationClientInterface.go +++ b/mocks/IdentificationClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/IdentificationCommonInterface.go b/mocks/IdentificationCommonInterface.go index fa18d8ae..3a3494dc 100644 --- a/mocks/IdentificationCommonInterface.go +++ b/mocks/IdentificationCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -21,7 +21,7 @@ func (_m *IdentificationCommonInterface) EXPECT() *IdentificationCommonInterface } // CheckEventPayloadDataForFilter provides a mock function with given fields: payloadData -func (_m *IdentificationCommonInterface) CheckEventPayloadDataForFilter(payloadData interface{}) bool { +func (_m *IdentificationCommonInterface) CheckEventPayloadDataForFilter(payloadData any) bool { ret := _m.Called(payloadData) if len(ret) == 0 { @@ -29,7 +29,7 @@ func (_m *IdentificationCommonInterface) CheckEventPayloadDataForFilter(payloadD } var r0 bool - if rf, ok := ret.Get(0).(func(interface{}) bool); ok { + if rf, ok := ret.Get(0).(func(any) bool); ok { r0 = rf(payloadData) } else { r0 = ret.Get(0).(bool) @@ -44,14 +44,14 @@ type IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call struct { } // CheckEventPayloadDataForFilter is a helper method to define mock.On call -// - payloadData interface{} +// - payloadData any func (_e *IdentificationCommonInterface_Expecter) CheckEventPayloadDataForFilter(payloadData interface{}) *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call { return &IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call{Call: _e.mock.On("CheckEventPayloadDataForFilter", payloadData)} } -func (_c *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData interface{})) *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData any)) *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{})) + run(args[0].(any)) }) return _c } @@ -61,7 +61,7 @@ func (_c *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call) Ret return _c } -func (_c *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(interface{}) bool) *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(any) bool) *IdentificationCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Return(run) return _c } diff --git a/mocks/IdentificationServerInterface.go b/mocks/IdentificationServerInterface.go index 19acc2b2..199be57a 100644 --- a/mocks/IdentificationServerInterface.go +++ b/mocks/IdentificationServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/IncentiveTableClientInterface.go b/mocks/IncentiveTableClientInterface.go index a392e228..2e3d8447 100644 --- a/mocks/IncentiveTableClientInterface.go +++ b/mocks/IncentiveTableClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/IncentiveTableCommonInterface.go b/mocks/IncentiveTableCommonInterface.go index f792f67e..676dd655 100644 --- a/mocks/IncentiveTableCommonInterface.go +++ b/mocks/IncentiveTableCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/IncentiveTableServerInterface.go b/mocks/IncentiveTableServerInterface.go index c5dc48fc..ec5d6019 100644 --- a/mocks/IncentiveTableServerInterface.go +++ b/mocks/IncentiveTableServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/LoadControlClientInterface.go b/mocks/LoadControlClientInterface.go index 74a5bfc3..39ad5f31 100644 --- a/mocks/LoadControlClientInterface.go +++ b/mocks/LoadControlClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/LoadControlCommonInterface.go b/mocks/LoadControlCommonInterface.go index 6796a96a..920dd722 100644 --- a/mocks/LoadControlCommonInterface.go +++ b/mocks/LoadControlCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -21,7 +21,7 @@ func (_m *LoadControlCommonInterface) EXPECT() *LoadControlCommonInterface_Expec } // CheckEventPayloadDataForFilter provides a mock function with given fields: payloadData, filter -func (_m *LoadControlCommonInterface) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) bool { +func (_m *LoadControlCommonInterface) CheckEventPayloadDataForFilter(payloadData any, filter any) bool { ret := _m.Called(payloadData, filter) if len(ret) == 0 { @@ -29,7 +29,7 @@ func (_m *LoadControlCommonInterface) CheckEventPayloadDataForFilter(payloadData } var r0 bool - if rf, ok := ret.Get(0).(func(interface{}, interface{}) bool); ok { + if rf, ok := ret.Get(0).(func(any, any) bool); ok { r0 = rf(payloadData, filter) } else { r0 = ret.Get(0).(bool) @@ -44,15 +44,15 @@ type LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call struct { } // CheckEventPayloadDataForFilter is a helper method to define mock.On call -// - payloadData interface{} -// - filter interface{} +// - payloadData any +// - filter any func (_e *LoadControlCommonInterface_Expecter) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call { return &LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call{Call: _e.mock.On("CheckEventPayloadDataForFilter", payloadData, filter)} } -func (_c *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData interface{}, filter interface{})) *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData any, filter any)) *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}), args[1].(interface{})) + run(args[0].(any), args[1].(any)) }) return _c } @@ -62,7 +62,7 @@ func (_c *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call) Return return _c } -func (_c *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(interface{}, interface{}) bool) *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(any, any) bool) *LoadControlCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Return(run) return _c } diff --git a/mocks/LoadControlServerInterface.go b/mocks/LoadControlServerInterface.go index 7094c30a..25baa8cb 100644 --- a/mocks/LoadControlServerInterface.go +++ b/mocks/LoadControlServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/MeasurementClientInterface.go b/mocks/MeasurementClientInterface.go index 82c85af8..33d63220 100644 --- a/mocks/MeasurementClientInterface.go +++ b/mocks/MeasurementClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/MeasurementCommonInterface.go b/mocks/MeasurementCommonInterface.go index ab2ee75e..18113462 100644 --- a/mocks/MeasurementCommonInterface.go +++ b/mocks/MeasurementCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -21,7 +21,7 @@ func (_m *MeasurementCommonInterface) EXPECT() *MeasurementCommonInterface_Expec } // CheckEventPayloadDataForFilter provides a mock function with given fields: payloadData, filter -func (_m *MeasurementCommonInterface) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) bool { +func (_m *MeasurementCommonInterface) CheckEventPayloadDataForFilter(payloadData any, filter any) bool { ret := _m.Called(payloadData, filter) if len(ret) == 0 { @@ -29,7 +29,7 @@ func (_m *MeasurementCommonInterface) CheckEventPayloadDataForFilter(payloadData } var r0 bool - if rf, ok := ret.Get(0).(func(interface{}, interface{}) bool); ok { + if rf, ok := ret.Get(0).(func(any, any) bool); ok { r0 = rf(payloadData, filter) } else { r0 = ret.Get(0).(bool) @@ -44,15 +44,15 @@ type MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call struct { } // CheckEventPayloadDataForFilter is a helper method to define mock.On call -// - payloadData interface{} -// - filter interface{} +// - payloadData any +// - filter any func (_e *MeasurementCommonInterface_Expecter) CheckEventPayloadDataForFilter(payloadData interface{}, filter interface{}) *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call { return &MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call{Call: _e.mock.On("CheckEventPayloadDataForFilter", payloadData, filter)} } -func (_c *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData interface{}, filter interface{})) *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call) Run(run func(payloadData any, filter any)) *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}), args[1].(interface{})) + run(args[0].(any), args[1].(any)) }) return _c } @@ -62,7 +62,7 @@ func (_c *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call) Return return _c } -func (_c *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(interface{}, interface{}) bool) *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call { +func (_c *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call) RunAndReturn(run func(any, any) bool) *MeasurementCommonInterface_CheckEventPayloadDataForFilter_Call { _c.Call.Return(run) return _c } diff --git a/mocks/MeasurementServerInterface.go b/mocks/MeasurementServerInterface.go index 37c64d3e..1812a765 100644 --- a/mocks/MeasurementServerInterface.go +++ b/mocks/MeasurementServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/ServiceInterface.go b/mocks/ServiceInterface.go index 868ead26..df78013f 100644 --- a/mocks/ServiceInterface.go +++ b/mocks/ServiceInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -27,8 +27,21 @@ func (_m *ServiceInterface) EXPECT() *ServiceInterface_Expecter { } // AddUseCase provides a mock function with given fields: useCase -func (_m *ServiceInterface) AddUseCase(useCase api.UseCaseInterface) { - _m.Called(useCase) +func (_m *ServiceInterface) AddUseCase(useCase api.UseCaseInterface) error { + ret := _m.Called(useCase) + + if len(ret) == 0 { + panic("no return value specified for AddUseCase") + } + + var r0 error + if rf, ok := ret.Get(0).(func(api.UseCaseInterface) error); ok { + r0 = rf(useCase) + } else { + r0 = ret.Error(0) + } + + return r0 } // ServiceInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase' @@ -49,12 +62,12 @@ func (_c *ServiceInterface_AddUseCase_Call) Run(run func(useCase api.UseCaseInte return _c } -func (_c *ServiceInterface_AddUseCase_Call) Return() *ServiceInterface_AddUseCase_Call { - _c.Call.Return() +func (_c *ServiceInterface_AddUseCase_Call) Return(_a0 error) *ServiceInterface_AddUseCase_Call { + _c.Call.Return(_a0) return _c } -func (_c *ServiceInterface_AddUseCase_Call) RunAndReturn(run func(api.UseCaseInterface)) *ServiceInterface_AddUseCase_Call { +func (_c *ServiceInterface_AddUseCase_Call) RunAndReturn(run func(api.UseCaseInterface) error) *ServiceInterface_AddUseCase_Call { _c.Call.Return(run) return _c } diff --git a/mocks/ServiceReaderInterface.go b/mocks/ServiceReaderInterface.go index 7aaa7d2d..a5e75953 100644 --- a/mocks/ServiceReaderInterface.go +++ b/mocks/ServiceReaderInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/SmartEnergyManagementPsClientInterface.go b/mocks/SmartEnergyManagementPsClientInterface.go index ab3f15b5..47f64e51 100644 --- a/mocks/SmartEnergyManagementPsClientInterface.go +++ b/mocks/SmartEnergyManagementPsClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/SmartEnergyManagementPsCommonInterface.go b/mocks/SmartEnergyManagementPsCommonInterface.go index e77ecd67..a0b6a2ae 100644 --- a/mocks/SmartEnergyManagementPsCommonInterface.go +++ b/mocks/SmartEnergyManagementPsCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/SmartEnergyManagementPsServerInterface.go b/mocks/SmartEnergyManagementPsServerInterface.go index d311565a..bec16a96 100644 --- a/mocks/SmartEnergyManagementPsServerInterface.go +++ b/mocks/SmartEnergyManagementPsServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/TimeSeriesClientInterface.go b/mocks/TimeSeriesClientInterface.go index c5498cb8..65fd8c00 100644 --- a/mocks/TimeSeriesClientInterface.go +++ b/mocks/TimeSeriesClientInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/TimeSeriesCommonInterface.go b/mocks/TimeSeriesCommonInterface.go index 667242a5..e845f24e 100644 --- a/mocks/TimeSeriesCommonInterface.go +++ b/mocks/TimeSeriesCommonInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/TimeSeriesServerInterface.go b/mocks/TimeSeriesServerInterface.go index e9de6a82..247d75dc 100644 --- a/mocks/TimeSeriesServerInterface.go +++ b/mocks/TimeSeriesServerInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/UseCaseBaseInterface.go b/mocks/UseCaseBaseInterface.go index db3fe67b..7ebe1cab 100644 --- a/mocks/UseCaseBaseInterface.go +++ b/mocks/UseCaseBaseInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks diff --git a/mocks/UseCaseInterface.go b/mocks/UseCaseInterface.go index c7136f66..2f3a6128 100644 --- a/mocks/UseCaseInterface.go +++ b/mocks/UseCaseInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -23,8 +23,21 @@ func (_m *UseCaseInterface) EXPECT() *UseCaseInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *UseCaseInterface) AddFeatures() { - _m.Called() +func (_m *UseCaseInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // UseCaseInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -44,12 +57,12 @@ func (_c *UseCaseInterface_AddFeatures_Call) Run(run func()) *UseCaseInterface_A return _c } -func (_c *UseCaseInterface_AddFeatures_Call) Return() *UseCaseInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *UseCaseInterface_AddFeatures_Call) Return(_a0 error) *UseCaseInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *UseCaseInterface_AddFeatures_Call) RunAndReturn(run func()) *UseCaseInterface_AddFeatures_Call { +func (_c *UseCaseInterface_AddFeatures_Call) RunAndReturn(run func() error) *UseCaseInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/service/service.go b/service/service.go index 7542250a..3c03e972 100644 --- a/service/service.go +++ b/service/service.go @@ -193,11 +193,16 @@ func (s *Service) IsRunning() bool { } // add a use case to the service -func (s *Service) AddUseCase(useCase api.UseCaseInterface) { +func (s *Service) AddUseCase(useCase api.UseCaseInterface) error { s.usecases = append(s.usecases, useCase) - useCase.AddFeatures() + err := useCase.AddFeatures() + if err != nil { + return err + } useCase.AddUseCase() + + return nil } func (s *Service) Configuration() *api.Configuration { diff --git a/service/service_test.go b/service/service_test.go index fa64e8da..cd225c0f 100644 --- a/service/service_test.go +++ b/service/service_test.go @@ -63,7 +63,7 @@ func (s *ServiceSuite) BeforeTest(suiteName, testName string) { func (s *ServiceSuite) Test_AddUseCase() { ucMock := mocks.NewUseCaseInterface(s.T()) - ucMock.EXPECT().AddFeatures().Return().Once() + ucMock.EXPECT().AddFeatures().Return(nil).Once() ucMock.EXPECT().AddUseCase().Return().Once() s.sut.AddUseCase(ucMock) diff --git a/usecases/README.md b/usecases/README.md index 47a977b1..88166c85 100644 --- a/usecases/README.md +++ b/usecases/README.md @@ -34,3 +34,8 @@ Actors: Use Cases: - `mpc`: Monitoring of Power Consumption - `mgcp`: Monitoring of Grid Connection Point + +- `mu`: Monitored Unit + + Use Cases: + - `mpc`: Monitoring of Power Consumption diff --git a/usecases/api/mu_mpc.go b/usecases/api/mu_mpc.go new file mode 100644 index 00000000..8d687580 --- /dev/null +++ b/usecases/api/mu_mpc.go @@ -0,0 +1,205 @@ +package api + +import ( + "github.com/enbility/eebus-go/api" + "github.com/enbility/spine-go/model" + "time" +) + +// Actor: Monitoring Unit +// UseCase: Monitoring of Power Consumption +type MuMPCInterface interface { + // ------------------------- Getters ------------------------- // + + // Scenario 1 + + // get the momentary active power consumption or production + // + // possible errors: + // - ErrMissingData if the id is not available + // - and others + Power() (float64, error) + + // get the momentary active power consumption or production per phase + // + // possible errors: + // - ErrMissingData if the id is not available + // - and others + PowerPerPhase() ([]float64, error) + + // Scenario 2 + + // get the total feed in energy + // + // - negative values are used for production + // + // possible errors: + // - ErrMissingData if the id is not available + // - and others + EnergyProduced() (float64, error) + + // get the total feed in energy + // + // - negative values are used for production + // + // possible errors: + // - ErrMissingData if the id is not available + // - and others + EnergyConsumed() (float64, error) + + // Scenario 3 + + // get the momentary phase specific current consumption or production + // + // - positive values are used for consumption + // - negative values are used for production + // + // possible errors: + // - ErrMissingData if the id is not available + // - and others + CurrentPerPhase() ([]float64, error) + + // Scenario 4 + + // get the phase specific voltage details + // + // possible errors: + // - ErrMissingData if the id is not available + // - and others + VoltagePerPhase() ([]float64, error) + + // Scenario 5 + + // get frequency + // + // possible errors: + // - ErrMissingData if the id is not available + // - and others + Frequency() (float64, error) + + // ------------------------- Setters ------------------------- // + + // use Update to update the measurement data + // use it like this: + // + // mpc.Update( + // mpc.UpdateDataPowerTotal(1000, nil, nil), + // mpc.UpdateDataPowerPhaseA(500, nil, nil), + // ... + // ) + // + // possible errors: + // - ErrMissingData if the id is not available + // - and others + Update(data ...UpdateData) error + + // Scenario 1 + + // use UpdateDataPowerTotal in Update to set the momentary active power consumption or production + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataPowerTotal(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataPowerPhaseA in Update to set the momentary active power consumption or production per phase + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataPowerPhaseA(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataPowerPhaseB in Update to set the momentary active power consumption or production per phase + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataPowerPhaseB(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataPowerPhaseC in Update to set the momentary active power consumption or production per phase + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataPowerPhaseC(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // Scenario 2 + + // use UpdateDataEnergyConsumed in Update to set the total feed in energy + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + // The evaluationStart and End are optional and can be nil (both must be set to be used) + UpdateDataEnergyConsumed( + value float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, + evaluationStart *time.Time, + evaluationEnd *time.Time, + ) UpdateData + + // use UpdateDataEnergyProduced in Update to set the total feed in energy + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + // The evaluationStart and End are optional and can be nil (both must be set to be used) + UpdateDataEnergyProduced( + value float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, + evaluationStart *time.Time, + evaluationEnd *time.Time, + ) UpdateData + + // Scenario 3 + + // use UpdateDataCurrentPhaseA in Update to set the momentary phase specific current consumption or production + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataCurrentPhaseA(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataCurrentPhaseB in Update to set the momentary phase specific current consumption or production + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataCurrentPhaseB(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataCurrentPhaseC in Update to set the momentary phase specific current consumption or production + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataCurrentPhaseC(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // Scenario 4 + + // use UpdateDataVoltagePhaseA in Update to set the phase specific voltage details + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataVoltagePhaseA(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataVoltagePhaseB in Update to set the phase specific voltage details + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataVoltagePhaseB(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataVoltagePhaseC in Update to set the phase specific voltage details + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataVoltagePhaseC(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataVoltagePhaseAToB in Update to set the phase specific voltage details + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataVoltagePhaseAToB(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataVoltagePhaseBToC in Update to set the phase specific voltage details + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataVoltagePhaseBToC(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // use UpdateDataVoltagePhaseCToA in Update to set the phase specific voltage details + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataVoltagePhaseCToA(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData + + // Scenario 5 + + // use AcFrequency in Update to set the frequency + // The timestamp is optional and can be nil + // The valueState shall be set if it differs from the normal valueState otherwise it can be nil + UpdateDataFrequency(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) UpdateData +} + +type UpdateData interface { + Supported() bool + NotSupportedError() error + MeasurementData() api.MeasurementDataForID +} diff --git a/usecases/cem/cevc/testhelper_test.go b/usecases/cem/cevc/testhelper_test.go index 1c05a410..26c8931c 100644 --- a/usecases/cem/cevc/testhelper_test.go +++ b/usecases/cem/cevc/testhelper_test.go @@ -75,7 +75,7 @@ func (s *CemCEVCSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewCEVC(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() var entities []spineapi.EntityRemoteInterface diff --git a/usecases/cem/cevc/usecase.go b/usecases/cem/cevc/usecase.go index 56c61c81..a06446cf 100644 --- a/usecases/cem/cevc/usecase.go +++ b/usecases/cem/cevc/usecase.go @@ -70,6 +70,7 @@ func NewCEVC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &CEVC{ @@ -81,7 +82,7 @@ func NewCEVC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC return uc } -func (e *CEVC) AddFeatures() { +func (e *CEVC) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeDeviceConfiguration, @@ -97,4 +98,6 @@ func (e *CEVC) AddFeatures() { f := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeServer) f.AddFunctionType(model.FunctionTypeDeviceDiagnosisStateData, true, false) f.AddFunctionType(model.FunctionTypeDeviceDiagnosisHeartbeatData, true, false) + + return nil } diff --git a/usecases/cem/evcc/usecase.go b/usecases/cem/evcc/usecase.go index 1612522f..3d9cb7f4 100644 --- a/usecases/cem/evcc/usecase.go +++ b/usecases/cem/evcc/usecase.go @@ -83,6 +83,7 @@ func NewEVCC( UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &EVCC{ @@ -95,7 +96,7 @@ func NewEVCC( return uc } -func (e *EVCC) AddFeatures() { +func (e *EVCC) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeDeviceConfiguration, @@ -108,4 +109,6 @@ func (e *EVCC) AddFeatures() { f := e.LocalEntity.GetOrAddFeature(feature, model.RoleTypeClient) f.AddResultCallback(e.HandleResponse) } + + return nil } diff --git a/usecases/cem/evcem/testhelper_test.go b/usecases/cem/evcem/testhelper_test.go index 7e469bc7..ea5fc254 100644 --- a/usecases/cem/evcem/testhelper_test.go +++ b/usecases/cem/evcem/testhelper_test.go @@ -70,7 +70,7 @@ func (s *CemEVCEMSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewEVCEM(s.service, localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() var entities []spineapi.EntityRemoteInterface diff --git a/usecases/cem/evcem/usecase.go b/usecases/cem/evcem/usecase.go index 42491c4a..0df08616 100644 --- a/usecases/cem/evcem/usecase.go +++ b/usecases/cem/evcem/usecase.go @@ -69,7 +69,9 @@ func NewEVCEM( eventCB, UseCaseSupportUpdate, validActorTypes, - validEntityTypes) + validEntityTypes, + false, + ) uc := &EVCEM{ UseCaseBase: usecase, @@ -81,7 +83,7 @@ func NewEVCEM( return uc } -func (e *EVCEM) AddFeatures() { +func (e *EVCEM) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeElectricalConnection, @@ -90,4 +92,6 @@ func (e *EVCEM) AddFeatures() { for _, feature := range clientFeatures { _ = e.LocalEntity.GetOrAddFeature(feature, model.RoleTypeClient) } + + return nil } diff --git a/usecases/cem/evsecc/testhelper_test.go b/usecases/cem/evsecc/testhelper_test.go index 0093606c..ed5aa168 100644 --- a/usecases/cem/evsecc/testhelper_test.go +++ b/usecases/cem/evsecc/testhelper_test.go @@ -73,7 +73,7 @@ func (s *CemEVSECCSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewEVSECC(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() var entities []spineapi.EntityRemoteInterface diff --git a/usecases/cem/evsecc/usecase.go b/usecases/cem/evsecc/usecase.go index d96ee92b..255bf374 100644 --- a/usecases/cem/evsecc/usecase.go +++ b/usecases/cem/evsecc/usecase.go @@ -51,7 +51,9 @@ func NewEVSECC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEven eventCB, UseCaseSupportUpdate, validActorTypes, - validEntityTypes) + validEntityTypes, + false, + ) uc := &EVSECC{ UseCaseBase: usecase, @@ -62,7 +64,7 @@ func NewEVSECC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEven return uc } -func (e *EVSECC) AddFeatures() { +func (e *EVSECC) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeDeviceClassification, @@ -72,4 +74,6 @@ func (e *EVSECC) AddFeatures() { for _, feature := range clientFeatures { _ = e.LocalEntity.GetOrAddFeature(feature, model.RoleTypeClient) } + + return nil } diff --git a/usecases/cem/evsoc/testhelper_test.go b/usecases/cem/evsoc/testhelper_test.go index bd36782a..e5ed4b42 100644 --- a/usecases/cem/evsoc/testhelper_test.go +++ b/usecases/cem/evsoc/testhelper_test.go @@ -73,7 +73,7 @@ func (s *CemEVSOCSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewEVSOC(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() var entities []spineapi.EntityRemoteInterface diff --git a/usecases/cem/evsoc/usecase.go b/usecases/cem/evsoc/usecase.go index 32df9b0c..63bb978d 100644 --- a/usecases/cem/evsoc/usecase.go +++ b/usecases/cem/evsoc/usecase.go @@ -47,6 +47,7 @@ func NewEVSOC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEvent UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &EVSOC{ @@ -58,7 +59,7 @@ func NewEVSOC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEvent return uc } -func (e *EVSOC) AddFeatures() { +func (e *EVSOC) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeElectricalConnection, @@ -67,6 +68,8 @@ func (e *EVSOC) AddFeatures() { for _, feature := range clientFeatures { _ = e.LocalEntity.GetOrAddFeature(feature, model.RoleTypeClient) } + + return nil } func (e *EVSOC) UpdateUseCaseAvailability(available bool) { diff --git a/usecases/cem/opev/testhelper_test.go b/usecases/cem/opev/testhelper_test.go index d69dbb64..4cc4cbe8 100644 --- a/usecases/cem/opev/testhelper_test.go +++ b/usecases/cem/opev/testhelper_test.go @@ -73,7 +73,7 @@ func (s *CemOPEVSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewOPEV(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() var clientFeatures = []model.FeatureTypeType{ diff --git a/usecases/cem/opev/usecase.go b/usecases/cem/opev/usecase.go index 40937b25..bbe3ca28 100644 --- a/usecases/cem/opev/usecase.go +++ b/usecases/cem/opev/usecase.go @@ -58,6 +58,7 @@ func NewOPEV(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &OPEV{ @@ -69,7 +70,7 @@ func NewOPEV(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC return uc } -func (e *OPEV) AddFeatures() { +func (e *OPEV) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeLoadControl, @@ -83,4 +84,6 @@ func (e *OPEV) AddFeatures() { f := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeServer) f.AddFunctionType(model.FunctionTypeDeviceDiagnosisStateData, true, false) f.AddFunctionType(model.FunctionTypeDeviceDiagnosisHeartbeatData, true, false) + + return nil } diff --git a/usecases/cem/oscev/testhelper_test.go b/usecases/cem/oscev/testhelper_test.go index 163e4640..f441e18c 100644 --- a/usecases/cem/oscev/testhelper_test.go +++ b/usecases/cem/oscev/testhelper_test.go @@ -72,7 +72,7 @@ func (s *CemOSCEVSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewOSCEV(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() var clientFeatures = []model.FeatureTypeType{ diff --git a/usecases/cem/oscev/usecase.go b/usecases/cem/oscev/usecase.go index 75fc3e2a..cc18fb1c 100644 --- a/usecases/cem/oscev/usecase.go +++ b/usecases/cem/oscev/usecase.go @@ -58,6 +58,7 @@ func NewOSCEV(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEvent UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &OSCEV{ @@ -69,7 +70,7 @@ func NewOSCEV(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEvent return uc } -func (e *OSCEV) AddFeatures() { +func (e *OSCEV) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeLoadControl, @@ -83,4 +84,6 @@ func (e *OSCEV) AddFeatures() { f := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeServer) f.AddFunctionType(model.FunctionTypeDeviceDiagnosisStateData, true, false) f.AddFunctionType(model.FunctionTypeDeviceDiagnosisHeartbeatData, true, false) + + return nil } diff --git a/usecases/cem/vabd/testhelper_test.go b/usecases/cem/vabd/testhelper_test.go index e067e486..69b566e5 100644 --- a/usecases/cem/vabd/testhelper_test.go +++ b/usecases/cem/vabd/testhelper_test.go @@ -73,7 +73,7 @@ func (s *CemVABDSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewVABD(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() s.remoteDevice, s.batteryEntity = setupDevices(s.service, s.T()) diff --git a/usecases/cem/vabd/usecase.go b/usecases/cem/vabd/usecase.go index c28ed5d3..faf7ef6b 100644 --- a/usecases/cem/vabd/usecase.go +++ b/usecases/cem/vabd/usecase.go @@ -72,6 +72,7 @@ func NewVABD(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &VABD{ @@ -83,7 +84,7 @@ func NewVABD(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC return uc } -func (e *VABD) AddFeatures() { +func (e *VABD) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeDeviceConfiguration, @@ -93,4 +94,6 @@ func (e *VABD) AddFeatures() { for _, feature := range clientFeatures { _ = e.LocalEntity.GetOrAddFeature(feature, model.RoleTypeClient) } + + return nil } diff --git a/usecases/cem/vapd/testhelper_test.go b/usecases/cem/vapd/testhelper_test.go index 6fc95e79..07e02ad3 100644 --- a/usecases/cem/vapd/testhelper_test.go +++ b/usecases/cem/vapd/testhelper_test.go @@ -73,7 +73,7 @@ func (s *CemVAPDSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewVAPD(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() s.remoteDevice, s.pvEntity = setupDevices(s.service, s.T()) diff --git a/usecases/cem/vapd/usecase.go b/usecases/cem/vapd/usecase.go index 50578d1b..302b68c4 100644 --- a/usecases/cem/vapd/usecase.go +++ b/usecases/cem/vapd/usecase.go @@ -63,6 +63,7 @@ func NewVAPD(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &VAPD{ @@ -74,7 +75,7 @@ func NewVAPD(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC return uc } -func (e *VAPD) AddFeatures() { +func (e *VAPD) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeDeviceConfiguration, @@ -84,4 +85,6 @@ func (e *VAPD) AddFeatures() { for _, feature := range clientFeatures { _ = e.LocalEntity.GetOrAddFeature(feature, model.RoleTypeClient) } + + return nil } diff --git a/usecases/cs/lpc/testhelper_test.go b/usecases/cs/lpc/testhelper_test.go index 9a06e053..f48a8878 100644 --- a/usecases/cs/lpc/testhelper_test.go +++ b/usecases/cs/lpc/testhelper_test.go @@ -16,6 +16,7 @@ import ( "github.com/enbility/spine-go/model" "github.com/enbility/spine-go/spine" "github.com/enbility/spine-go/util" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/suite" ) @@ -76,7 +77,7 @@ func (s *CsLPCSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewLPC(localEntity, s.Event) - s.sut.AddFeatures() + assert.Nil(s.T(), s.sut.AddFeatures()) s.sut.AddUseCase() s.loadControlFeature = localEntity.FeatureOfTypeAndRole(model.FeatureTypeTypeLoadControl, model.RoleTypeServer) diff --git a/usecases/cs/lpc/usecase.go b/usecases/cs/lpc/usecase.go index 5b6d3608..b23f0d29 100644 --- a/usecases/cs/lpc/usecase.go +++ b/usecases/cs/lpc/usecase.go @@ -71,6 +71,7 @@ func NewLPC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventCa UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &LPC{ @@ -172,7 +173,7 @@ func (e *LPC) loadControlWriteCB(msg *spineapi.Message) { go e.approveOrDenyConsumptionLimit(msg, true, "") } -func (e *LPC) AddFeatures() { +func (e *LPC) AddFeatures() error { // client features _ = e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeClient) @@ -180,7 +181,10 @@ func (e *LPC) AddFeatures() { f := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeLoadControl, model.RoleTypeServer) f.AddFunctionType(model.FunctionTypeLoadControlLimitDescriptionListData, true, false) f.AddFunctionType(model.FunctionTypeLoadControlLimitListData, true, true) - _ = f.AddWriteApprovalCallback(e.loadControlWriteCB) + err := f.AddWriteApprovalCallback(e.loadControlWriteCB) + if err != nil { + return err + } newLimitDesc := model.LoadControlLimitDescriptionDataType{ LimitType: util.Ptr(model.LoadControlLimitTypeTypeSignDependentAbsValueLimit), @@ -204,6 +208,8 @@ func (e *LPC) AddFeatures() { }, } _ = lc.UpdateLimitDataForIds(newLimiData) + } else { + return err } f = e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceConfiguration, model.RoleTypeServer) @@ -235,7 +241,7 @@ func (e *LPC) AddFeatures() { value := &model.DeviceConfigurationKeyValueValueType{ ScaledNumber: model.NewScaledNumberType(0), } - _ = dcs.UpdateKeyValueDataForFilter( + err1 := dcs.UpdateKeyValueDataForFilter( model.DeviceConfigurationKeyValueDataType{ Value: value, IsValueChangeable: util.Ptr(true), @@ -245,11 +251,14 @@ func (e *LPC) AddFeatures() { KeyName: util.Ptr(model.DeviceConfigurationKeyNameTypeFailsafeConsumptionActivePowerLimit), }, ) + if err1 != nil { + return err1 + } value = &model.DeviceConfigurationKeyValueValueType{ Duration: model.NewDurationType(0), } - _ = dcs.UpdateKeyValueDataForFilter( + err1 = dcs.UpdateKeyValueDataForFilter( model.DeviceConfigurationKeyValueDataType{ Value: value, IsValueChangeable: util.Ptr(true), @@ -259,6 +268,11 @@ func (e *LPC) AddFeatures() { KeyName: util.Ptr(model.DeviceConfigurationKeyNameTypeFailsafeDurationMinimum), }, ) + if err1 != nil { + return err1 + } + } else { + return err } f = e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeServer) @@ -278,5 +292,9 @@ func (e *LPC) AddFeatures() { Unit: util.Ptr(model.UnitOfMeasurementTypeW), } _, _ = ec.AddCharacteristic(newCharData) + } else { + return err } + + return nil } diff --git a/usecases/cs/lpp/testhelper_test.go b/usecases/cs/lpp/testhelper_test.go index 6a0920ba..0bad0a4e 100644 --- a/usecases/cs/lpp/testhelper_test.go +++ b/usecases/cs/lpp/testhelper_test.go @@ -16,6 +16,7 @@ import ( "github.com/enbility/spine-go/model" "github.com/enbility/spine-go/spine" "github.com/enbility/spine-go/util" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" "github.com/stretchr/testify/suite" ) @@ -76,7 +77,7 @@ func (s *CsLPPSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewLPP(localEntity, s.Event) - s.sut.AddFeatures() + assert.Nil(s.T(), s.sut.AddFeatures()) s.sut.AddUseCase() s.loadControlFeature = localEntity.FeatureOfTypeAndRole(model.FeatureTypeTypeLoadControl, model.RoleTypeServer) diff --git a/usecases/cs/lpp/usecase.go b/usecases/cs/lpp/usecase.go index 8b859f98..642932d1 100644 --- a/usecases/cs/lpp/usecase.go +++ b/usecases/cs/lpp/usecase.go @@ -70,6 +70,7 @@ func NewLPP(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventCa UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &LPP{ @@ -172,7 +173,7 @@ func (e *LPP) loadControlWriteCB(msg *spineapi.Message) { go e.approveOrDenyProductionLimit(msg, true, "") } -func (e *LPP) AddFeatures() { +func (e *LPP) AddFeatures() error { // client features _ = e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeClient) @@ -180,7 +181,10 @@ func (e *LPP) AddFeatures() { f := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeLoadControl, model.RoleTypeServer) f.AddFunctionType(model.FunctionTypeLoadControlLimitDescriptionListData, true, false) f.AddFunctionType(model.FunctionTypeLoadControlLimitListData, true, true) - _ = f.AddWriteApprovalCallback(e.loadControlWriteCB) + err := f.AddWriteApprovalCallback(e.loadControlWriteCB) + if err != nil { + return err + } newLimitDesc := model.LoadControlLimitDescriptionDataType{ LimitType: util.Ptr(model.LoadControlLimitTypeTypeSignDependentAbsValueLimit), @@ -204,6 +208,8 @@ func (e *LPP) AddFeatures() { }, } _ = lc.UpdateLimitDataForIds(newLimiData) + } else { + return err } f = e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceConfiguration, model.RoleTypeServer) @@ -235,7 +241,7 @@ func (e *LPP) AddFeatures() { value := &model.DeviceConfigurationKeyValueValueType{ ScaledNumber: model.NewScaledNumberType(0), } - _ = dcs.UpdateKeyValueDataForFilter( + err1 := dcs.UpdateKeyValueDataForFilter( model.DeviceConfigurationKeyValueDataType{ Value: value, IsValueChangeable: util.Ptr(true), @@ -245,11 +251,14 @@ func (e *LPP) AddFeatures() { KeyName: util.Ptr(model.DeviceConfigurationKeyNameTypeFailsafeProductionActivePowerLimit), }, ) + if err1 != nil { + return err1 + } value = &model.DeviceConfigurationKeyValueValueType{ Duration: model.NewDurationType(0), } - _ = dcs.UpdateKeyValueDataForFilter( + err1 = dcs.UpdateKeyValueDataForFilter( model.DeviceConfigurationKeyValueDataType{ Value: value, IsValueChangeable: util.Ptr(true), @@ -259,6 +268,11 @@ func (e *LPP) AddFeatures() { KeyName: util.Ptr(model.DeviceConfigurationKeyNameTypeFailsafeDurationMinimum), }, ) + if err1 != nil { + return err1 + } + } else { + return err } f = e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeServer) @@ -277,6 +291,13 @@ func (e *LPP) AddFeatures() { CharacteristicType: util.Ptr(e.characteristicType()), Unit: util.Ptr(model.UnitOfMeasurementTypeW), } - _, _ = ec.AddCharacteristic(newCharData) + _, err1 := ec.AddCharacteristic(newCharData) + if err1 != nil { + return err1 + } + } else { + return err } + + return nil } diff --git a/usecases/eg/lpc/usecase.go b/usecases/eg/lpc/usecase.go index 84c3c5d3..ed4f3f7b 100644 --- a/usecases/eg/lpc/usecase.go +++ b/usecases/eg/lpc/usecase.go @@ -66,6 +66,7 @@ func NewLPC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventCa UseCaseSupportUpdate, validActorTypes, validEntityTypes, + false, ) uc := &LPC{ @@ -77,7 +78,7 @@ func NewLPC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventCa return uc } -func (e *LPC) AddFeatures() { +func (e *LPC) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeDeviceDiagnosis, @@ -92,4 +93,6 @@ func (e *LPC) AddFeatures() { // server features f := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeServer) f.AddFunctionType(model.FunctionTypeDeviceDiagnosisHeartbeatData, true, false) + + return nil } diff --git a/usecases/eg/lpp/testhelper_test.go b/usecases/eg/lpp/testhelper_test.go index 3e3efff0..8ea3ed5d 100644 --- a/usecases/eg/lpp/testhelper_test.go +++ b/usecases/eg/lpp/testhelper_test.go @@ -73,7 +73,7 @@ func (s *EgLPPSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewLPP(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() s.remoteDevice, s.monitoredEntity = setupDevices(s.service, s.T()) diff --git a/usecases/eg/lpp/usecase.go b/usecases/eg/lpp/usecase.go index c68a5b74..3dbd51ad 100644 --- a/usecases/eg/lpp/usecase.go +++ b/usecases/eg/lpp/usecase.go @@ -63,7 +63,9 @@ func NewLPP(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventCa eventCB, UseCaseSupportUpdate, validActorTypes, - validEntityTypes) + validEntityTypes, + false, + ) uc := &LPP{ UseCaseBase: usecase, @@ -74,7 +76,7 @@ func NewLPP(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventCa return uc } -func (e *LPP) AddFeatures() { +func (e *LPP) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeDeviceDiagnosis, @@ -89,6 +91,8 @@ func (e *LPP) AddFeatures() { // server features f := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeDeviceDiagnosis, model.RoleTypeServer) f.AddFunctionType(model.FunctionTypeDeviceDiagnosisHeartbeatData, true, false) + + return nil } func (e *LPP) UpdateUseCaseAvailability(available bool) { diff --git a/usecases/ma/mgcp/testhelper_test.go b/usecases/ma/mgcp/testhelper_test.go index 2af4484f..784441dd 100644 --- a/usecases/ma/mgcp/testhelper_test.go +++ b/usecases/ma/mgcp/testhelper_test.go @@ -73,7 +73,7 @@ func (s *GcpMGCPSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewMGCP(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() s.remoteDevice, s.smgwEntity = setupDevices(s.service, s.T()) diff --git a/usecases/ma/mgcp/usecase.go b/usecases/ma/mgcp/usecase.go index 6f6988d2..30a3e77d 100644 --- a/usecases/ma/mgcp/usecase.go +++ b/usecases/ma/mgcp/usecase.go @@ -93,7 +93,9 @@ func NewMGCP(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC eventCB, UseCaseSupportUpdate, validActorTypes, - validEntityTypes) + validEntityTypes, + false, + ) uc := &MGCP{ UseCaseBase: usecase, @@ -104,7 +106,7 @@ func NewMGCP(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventC return uc } -func (e *MGCP) AddFeatures() { +func (e *MGCP) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeDeviceConfiguration, @@ -114,4 +116,6 @@ func (e *MGCP) AddFeatures() { for _, feature := range clientFeatures { _ = e.LocalEntity.GetOrAddFeature(feature, model.RoleTypeClient) } + + return nil } diff --git a/usecases/ma/mpc/testhelper_test.go b/usecases/ma/mpc/testhelper_test.go index c24338b7..6b850cc9 100644 --- a/usecases/ma/mpc/testhelper_test.go +++ b/usecases/ma/mpc/testhelper_test.go @@ -73,7 +73,7 @@ func (s *MaMPCSuite) BeforeTest(suiteName, testName string) { localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeCEM) s.sut = NewMPC(localEntity, s.Event) - s.sut.AddFeatures() + _ = s.sut.AddFeatures() s.sut.AddUseCase() s.remoteDevice, s.monitoredEntity = setupDevices(s.service, s.T()) diff --git a/usecases/ma/mpc/usecase.go b/usecases/ma/mpc/usecase.go index 8e23395b..d2a1ddf9 100644 --- a/usecases/ma/mpc/usecase.go +++ b/usecases/ma/mpc/usecase.go @@ -85,7 +85,9 @@ func NewMPC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventCa eventCB, UseCaseSupportUpdate, validActorTypes, - validEntityTypes) + validEntityTypes, + false, + ) uc := &MPC{ UseCaseBase: usecase, @@ -96,7 +98,7 @@ func NewMPC(localEntity spineapi.EntityLocalInterface, eventCB api.EntityEventCa return uc } -func (e *MPC) AddFeatures() { +func (e *MPC) AddFeatures() error { // client features var clientFeatures = []model.FeatureTypeType{ model.FeatureTypeTypeElectricalConnection, @@ -105,4 +107,6 @@ func (e *MPC) AddFeatures() { for _, feature := range clientFeatures { _ = e.LocalEntity.GetOrAddFeature(feature, model.RoleTypeClient) } + + return nil } diff --git a/usecases/mocks/CemCEVCInterface.go b/usecases/mocks/CemCEVCInterface.go index 3954e533..8877b864 100644 --- a/usecases/mocks/CemCEVCInterface.go +++ b/usecases/mocks/CemCEVCInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -25,8 +25,21 @@ func (_m *CemCEVCInterface) EXPECT() *CemCEVCInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemCEVCInterface) AddFeatures() { - _m.Called() +func (_m *CemCEVCInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemCEVCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -46,12 +59,12 @@ func (_c *CemCEVCInterface_AddFeatures_Call) Run(run func()) *CemCEVCInterface_A return _c } -func (_c *CemCEVCInterface_AddFeatures_Call) Return() *CemCEVCInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemCEVCInterface_AddFeatures_Call) Return(_a0 error) *CemCEVCInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemCEVCInterface_AddFeatures_Call) RunAndReturn(run func()) *CemCEVCInterface_AddFeatures_Call { +func (_c *CemCEVCInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemCEVCInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CemEVCCInterface.go b/usecases/mocks/CemEVCCInterface.go index 4ba5ea83..75fad2bd 100644 --- a/usecases/mocks/CemEVCCInterface.go +++ b/usecases/mocks/CemEVCCInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -27,8 +27,21 @@ func (_m *CemEVCCInterface) EXPECT() *CemEVCCInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemEVCCInterface) AddFeatures() { - _m.Called() +func (_m *CemEVCCInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemEVCCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -48,12 +61,12 @@ func (_c *CemEVCCInterface_AddFeatures_Call) Run(run func()) *CemEVCCInterface_A return _c } -func (_c *CemEVCCInterface_AddFeatures_Call) Return() *CemEVCCInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemEVCCInterface_AddFeatures_Call) Return(_a0 error) *CemEVCCInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemEVCCInterface_AddFeatures_Call) RunAndReturn(run func()) *CemEVCCInterface_AddFeatures_Call { +func (_c *CemEVCCInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemEVCCInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CemEVCEMInterface.go b/usecases/mocks/CemEVCEMInterface.go index ae4fa5b0..f1f81fe0 100644 --- a/usecases/mocks/CemEVCEMInterface.go +++ b/usecases/mocks/CemEVCEMInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -23,8 +23,21 @@ func (_m *CemEVCEMInterface) EXPECT() *CemEVCEMInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemEVCEMInterface) AddFeatures() { - _m.Called() +func (_m *CemEVCEMInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemEVCEMInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -44,12 +57,12 @@ func (_c *CemEVCEMInterface_AddFeatures_Call) Run(run func()) *CemEVCEMInterface return _c } -func (_c *CemEVCEMInterface_AddFeatures_Call) Return() *CemEVCEMInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemEVCEMInterface_AddFeatures_Call) Return(_a0 error) *CemEVCEMInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemEVCEMInterface_AddFeatures_Call) RunAndReturn(run func()) *CemEVCEMInterface_AddFeatures_Call { +func (_c *CemEVCEMInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemEVCEMInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CemEVSECCInterface.go b/usecases/mocks/CemEVSECCInterface.go index 6650e628..2b000512 100644 --- a/usecases/mocks/CemEVSECCInterface.go +++ b/usecases/mocks/CemEVSECCInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -27,8 +27,21 @@ func (_m *CemEVSECCInterface) EXPECT() *CemEVSECCInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemEVSECCInterface) AddFeatures() { - _m.Called() +func (_m *CemEVSECCInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemEVSECCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -48,12 +61,12 @@ func (_c *CemEVSECCInterface_AddFeatures_Call) Run(run func()) *CemEVSECCInterfa return _c } -func (_c *CemEVSECCInterface_AddFeatures_Call) Return() *CemEVSECCInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemEVSECCInterface_AddFeatures_Call) Return(_a0 error) *CemEVSECCInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemEVSECCInterface_AddFeatures_Call) RunAndReturn(run func()) *CemEVSECCInterface_AddFeatures_Call { +func (_c *CemEVSECCInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemEVSECCInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CemEVSOCInterface.go b/usecases/mocks/CemEVSOCInterface.go index cdbfcd6c..4643a892 100644 --- a/usecases/mocks/CemEVSOCInterface.go +++ b/usecases/mocks/CemEVSOCInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -23,8 +23,21 @@ func (_m *CemEVSOCInterface) EXPECT() *CemEVSOCInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemEVSOCInterface) AddFeatures() { - _m.Called() +func (_m *CemEVSOCInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemEVSOCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -44,12 +57,12 @@ func (_c *CemEVSOCInterface_AddFeatures_Call) Run(run func()) *CemEVSOCInterface return _c } -func (_c *CemEVSOCInterface_AddFeatures_Call) Return() *CemEVSOCInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemEVSOCInterface_AddFeatures_Call) Return(_a0 error) *CemEVSOCInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemEVSOCInterface_AddFeatures_Call) RunAndReturn(run func()) *CemEVSOCInterface_AddFeatures_Call { +func (_c *CemEVSOCInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemEVSOCInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CemOPEVInterface.go b/usecases/mocks/CemOPEVInterface.go index 50b42384..b2371c81 100644 --- a/usecases/mocks/CemOPEVInterface.go +++ b/usecases/mocks/CemOPEVInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -27,8 +27,21 @@ func (_m *CemOPEVInterface) EXPECT() *CemOPEVInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemOPEVInterface) AddFeatures() { - _m.Called() +func (_m *CemOPEVInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemOPEVInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -48,12 +61,12 @@ func (_c *CemOPEVInterface_AddFeatures_Call) Run(run func()) *CemOPEVInterface_A return _c } -func (_c *CemOPEVInterface_AddFeatures_Call) Return() *CemOPEVInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemOPEVInterface_AddFeatures_Call) Return(_a0 error) *CemOPEVInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemOPEVInterface_AddFeatures_Call) RunAndReturn(run func()) *CemOPEVInterface_AddFeatures_Call { +func (_c *CemOPEVInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemOPEVInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CemOSCEVInterface.go b/usecases/mocks/CemOSCEVInterface.go index 60636687..4e8f0457 100644 --- a/usecases/mocks/CemOSCEVInterface.go +++ b/usecases/mocks/CemOSCEVInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -27,8 +27,21 @@ func (_m *CemOSCEVInterface) EXPECT() *CemOSCEVInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemOSCEVInterface) AddFeatures() { - _m.Called() +func (_m *CemOSCEVInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemOSCEVInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -48,12 +61,12 @@ func (_c *CemOSCEVInterface_AddFeatures_Call) Run(run func()) *CemOSCEVInterface return _c } -func (_c *CemOSCEVInterface_AddFeatures_Call) Return() *CemOSCEVInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemOSCEVInterface_AddFeatures_Call) Return(_a0 error) *CemOSCEVInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemOSCEVInterface_AddFeatures_Call) RunAndReturn(run func()) *CemOSCEVInterface_AddFeatures_Call { +func (_c *CemOSCEVInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemOSCEVInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CemVABDInterface.go b/usecases/mocks/CemVABDInterface.go index f84ed25c..62deda9f 100644 --- a/usecases/mocks/CemVABDInterface.go +++ b/usecases/mocks/CemVABDInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -23,8 +23,21 @@ func (_m *CemVABDInterface) EXPECT() *CemVABDInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemVABDInterface) AddFeatures() { - _m.Called() +func (_m *CemVABDInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemVABDInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -44,12 +57,12 @@ func (_c *CemVABDInterface_AddFeatures_Call) Run(run func()) *CemVABDInterface_A return _c } -func (_c *CemVABDInterface_AddFeatures_Call) Return() *CemVABDInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemVABDInterface_AddFeatures_Call) Return(_a0 error) *CemVABDInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemVABDInterface_AddFeatures_Call) RunAndReturn(run func()) *CemVABDInterface_AddFeatures_Call { +func (_c *CemVABDInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemVABDInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CemVAPDInterface.go b/usecases/mocks/CemVAPDInterface.go index 65c3af91..5c9a1f22 100644 --- a/usecases/mocks/CemVAPDInterface.go +++ b/usecases/mocks/CemVAPDInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -23,8 +23,21 @@ func (_m *CemVAPDInterface) EXPECT() *CemVAPDInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CemVAPDInterface) AddFeatures() { - _m.Called() +func (_m *CemVAPDInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CemVAPDInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -44,12 +57,12 @@ func (_c *CemVAPDInterface_AddFeatures_Call) Run(run func()) *CemVAPDInterface_A return _c } -func (_c *CemVAPDInterface_AddFeatures_Call) Return() *CemVAPDInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CemVAPDInterface_AddFeatures_Call) Return(_a0 error) *CemVAPDInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CemVAPDInterface_AddFeatures_Call) RunAndReturn(run func()) *CemVAPDInterface_AddFeatures_Call { +func (_c *CemVAPDInterface_AddFeatures_Call) RunAndReturn(run func() error) *CemVAPDInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CsLPCInterface.go b/usecases/mocks/CsLPCInterface.go index c8e1ac4a..5e17dbdf 100644 --- a/usecases/mocks/CsLPCInterface.go +++ b/usecases/mocks/CsLPCInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -29,8 +29,21 @@ func (_m *CsLPCInterface) EXPECT() *CsLPCInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CsLPCInterface) AddFeatures() { - _m.Called() +func (_m *CsLPCInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CsLPCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -50,12 +63,12 @@ func (_c *CsLPCInterface_AddFeatures_Call) Run(run func()) *CsLPCInterface_AddFe return _c } -func (_c *CsLPCInterface_AddFeatures_Call) Return() *CsLPCInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CsLPCInterface_AddFeatures_Call) Return(_a0 error) *CsLPCInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CsLPCInterface_AddFeatures_Call) RunAndReturn(run func()) *CsLPCInterface_AddFeatures_Call { +func (_c *CsLPCInterface_AddFeatures_Call) RunAndReturn(run func() error) *CsLPCInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/CsLPPInterface.go b/usecases/mocks/CsLPPInterface.go index c2b07f16..95d2356b 100644 --- a/usecases/mocks/CsLPPInterface.go +++ b/usecases/mocks/CsLPPInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -29,8 +29,21 @@ func (_m *CsLPPInterface) EXPECT() *CsLPPInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *CsLPPInterface) AddFeatures() { - _m.Called() +func (_m *CsLPPInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // CsLPPInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -50,12 +63,12 @@ func (_c *CsLPPInterface_AddFeatures_Call) Run(run func()) *CsLPPInterface_AddFe return _c } -func (_c *CsLPPInterface_AddFeatures_Call) Return() *CsLPPInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *CsLPPInterface_AddFeatures_Call) Return(_a0 error) *CsLPPInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *CsLPPInterface_AddFeatures_Call) RunAndReturn(run func()) *CsLPPInterface_AddFeatures_Call { +func (_c *CsLPPInterface_AddFeatures_Call) RunAndReturn(run func() error) *CsLPPInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/EgLPCInterface.go b/usecases/mocks/EgLPCInterface.go index d4f6f349..6574df1d 100644 --- a/usecases/mocks/EgLPCInterface.go +++ b/usecases/mocks/EgLPCInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -29,8 +29,21 @@ func (_m *EgLPCInterface) EXPECT() *EgLPCInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *EgLPCInterface) AddFeatures() { - _m.Called() +func (_m *EgLPCInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // EgLPCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -50,12 +63,12 @@ func (_c *EgLPCInterface_AddFeatures_Call) Run(run func()) *EgLPCInterface_AddFe return _c } -func (_c *EgLPCInterface_AddFeatures_Call) Return() *EgLPCInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *EgLPCInterface_AddFeatures_Call) Return(_a0 error) *EgLPCInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *EgLPCInterface_AddFeatures_Call) RunAndReturn(run func()) *EgLPCInterface_AddFeatures_Call { +func (_c *EgLPCInterface_AddFeatures_Call) RunAndReturn(run func() error) *EgLPCInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/EgLPPInterface.go b/usecases/mocks/EgLPPInterface.go index b18ea631..5449a4b6 100644 --- a/usecases/mocks/EgLPPInterface.go +++ b/usecases/mocks/EgLPPInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.45.0. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -29,8 +29,21 @@ func (_m *EgLPPInterface) EXPECT() *EgLPPInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *EgLPPInterface) AddFeatures() { - _m.Called() +func (_m *EgLPPInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // EgLPPInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -50,12 +63,12 @@ func (_c *EgLPPInterface_AddFeatures_Call) Run(run func()) *EgLPPInterface_AddFe return _c } -func (_c *EgLPPInterface_AddFeatures_Call) Return() *EgLPPInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *EgLPPInterface_AddFeatures_Call) Return(_a0 error) *EgLPPInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *EgLPPInterface_AddFeatures_Call) RunAndReturn(run func()) *EgLPPInterface_AddFeatures_Call { +func (_c *EgLPPInterface_AddFeatures_Call) RunAndReturn(run func() error) *EgLPPInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/MaMGCPInterface.go b/usecases/mocks/MaMGCPInterface.go index bc4ea319..a53b0962 100644 --- a/usecases/mocks/MaMGCPInterface.go +++ b/usecases/mocks/MaMGCPInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -23,8 +23,21 @@ func (_m *MaMGCPInterface) EXPECT() *MaMGCPInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *MaMGCPInterface) AddFeatures() { - _m.Called() +func (_m *MaMGCPInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // MaMGCPInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -44,12 +57,12 @@ func (_c *MaMGCPInterface_AddFeatures_Call) Run(run func()) *MaMGCPInterface_Add return _c } -func (_c *MaMGCPInterface_AddFeatures_Call) Return() *MaMGCPInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *MaMGCPInterface_AddFeatures_Call) Return(_a0 error) *MaMGCPInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *MaMGCPInterface_AddFeatures_Call) RunAndReturn(run func()) *MaMGCPInterface_AddFeatures_Call { +func (_c *MaMGCPInterface_AddFeatures_Call) RunAndReturn(run func() error) *MaMGCPInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/MaMPCInterface.go b/usecases/mocks/MaMPCInterface.go index a3e5b8f4..3a1baa21 100644 --- a/usecases/mocks/MaMPCInterface.go +++ b/usecases/mocks/MaMPCInterface.go @@ -1,4 +1,4 @@ -// Code generated by mockery v2.43.2. DO NOT EDIT. +// Code generated by mockery v2.46.3. DO NOT EDIT. package mocks @@ -23,8 +23,21 @@ func (_m *MaMPCInterface) EXPECT() *MaMPCInterface_Expecter { } // AddFeatures provides a mock function with given fields: -func (_m *MaMPCInterface) AddFeatures() { - _m.Called() +func (_m *MaMPCInterface) AddFeatures() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AddFeatures") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 } // MaMPCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures' @@ -44,12 +57,12 @@ func (_c *MaMPCInterface_AddFeatures_Call) Run(run func()) *MaMPCInterface_AddFe return _c } -func (_c *MaMPCInterface_AddFeatures_Call) Return() *MaMPCInterface_AddFeatures_Call { - _c.Call.Return() +func (_c *MaMPCInterface_AddFeatures_Call) Return(_a0 error) *MaMPCInterface_AddFeatures_Call { + _c.Call.Return(_a0) return _c } -func (_c *MaMPCInterface_AddFeatures_Call) RunAndReturn(run func()) *MaMPCInterface_AddFeatures_Call { +func (_c *MaMPCInterface_AddFeatures_Call) RunAndReturn(run func() error) *MaMPCInterface_AddFeatures_Call { _c.Call.Return(run) return _c } diff --git a/usecases/mocks/MuMPCInterface.go b/usecases/mocks/MuMPCInterface.go new file mode 100644 index 00000000..3c8e8fc1 --- /dev/null +++ b/usecases/mocks/MuMPCInterface.go @@ -0,0 +1,1293 @@ +// Code generated by mockery v2.46.3. DO NOT EDIT. + +package mocks + +import ( + api "github.com/enbility/eebus-go/usecases/api" + mock "github.com/stretchr/testify/mock" + + model "github.com/enbility/spine-go/model" + + time "time" +) + +// MuMPCInterface is an autogenerated mock type for the MuMPCInterface type +type MuMPCInterface struct { + mock.Mock +} + +type MuMPCInterface_Expecter struct { + mock *mock.Mock +} + +func (_m *MuMPCInterface) EXPECT() *MuMPCInterface_Expecter { + return &MuMPCInterface_Expecter{mock: &_m.Mock} +} + +// CurrentPerPhase provides a mock function with given fields: +func (_m *MuMPCInterface) CurrentPerPhase() ([]float64, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for CurrentPerPhase") + } + + var r0 []float64 + var r1 error + if rf, ok := ret.Get(0).(func() ([]float64, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []float64); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]float64) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MuMPCInterface_CurrentPerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentPerPhase' +type MuMPCInterface_CurrentPerPhase_Call struct { + *mock.Call +} + +// CurrentPerPhase is a helper method to define mock.On call +func (_e *MuMPCInterface_Expecter) CurrentPerPhase() *MuMPCInterface_CurrentPerPhase_Call { + return &MuMPCInterface_CurrentPerPhase_Call{Call: _e.mock.On("CurrentPerPhase")} +} + +func (_c *MuMPCInterface_CurrentPerPhase_Call) Run(run func()) *MuMPCInterface_CurrentPerPhase_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MuMPCInterface_CurrentPerPhase_Call) Return(_a0 []float64, _a1 error) *MuMPCInterface_CurrentPerPhase_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MuMPCInterface_CurrentPerPhase_Call) RunAndReturn(run func() ([]float64, error)) *MuMPCInterface_CurrentPerPhase_Call { + _c.Call.Return(run) + return _c +} + +// EnergyConsumed provides a mock function with given fields: +func (_m *MuMPCInterface) EnergyConsumed() (float64, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for EnergyConsumed") + } + + var r0 float64 + var r1 error + if rf, ok := ret.Get(0).(func() (float64, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() float64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(float64) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MuMPCInterface_EnergyConsumed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyConsumed' +type MuMPCInterface_EnergyConsumed_Call struct { + *mock.Call +} + +// EnergyConsumed is a helper method to define mock.On call +func (_e *MuMPCInterface_Expecter) EnergyConsumed() *MuMPCInterface_EnergyConsumed_Call { + return &MuMPCInterface_EnergyConsumed_Call{Call: _e.mock.On("EnergyConsumed")} +} + +func (_c *MuMPCInterface_EnergyConsumed_Call) Run(run func()) *MuMPCInterface_EnergyConsumed_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MuMPCInterface_EnergyConsumed_Call) Return(_a0 float64, _a1 error) *MuMPCInterface_EnergyConsumed_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MuMPCInterface_EnergyConsumed_Call) RunAndReturn(run func() (float64, error)) *MuMPCInterface_EnergyConsumed_Call { + _c.Call.Return(run) + return _c +} + +// EnergyProduced provides a mock function with given fields: +func (_m *MuMPCInterface) EnergyProduced() (float64, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for EnergyProduced") + } + + var r0 float64 + var r1 error + if rf, ok := ret.Get(0).(func() (float64, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() float64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(float64) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MuMPCInterface_EnergyProduced_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyProduced' +type MuMPCInterface_EnergyProduced_Call struct { + *mock.Call +} + +// EnergyProduced is a helper method to define mock.On call +func (_e *MuMPCInterface_Expecter) EnergyProduced() *MuMPCInterface_EnergyProduced_Call { + return &MuMPCInterface_EnergyProduced_Call{Call: _e.mock.On("EnergyProduced")} +} + +func (_c *MuMPCInterface_EnergyProduced_Call) Run(run func()) *MuMPCInterface_EnergyProduced_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MuMPCInterface_EnergyProduced_Call) Return(_a0 float64, _a1 error) *MuMPCInterface_EnergyProduced_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MuMPCInterface_EnergyProduced_Call) RunAndReturn(run func() (float64, error)) *MuMPCInterface_EnergyProduced_Call { + _c.Call.Return(run) + return _c +} + +// Frequency provides a mock function with given fields: +func (_m *MuMPCInterface) Frequency() (float64, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Frequency") + } + + var r0 float64 + var r1 error + if rf, ok := ret.Get(0).(func() (float64, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() float64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(float64) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MuMPCInterface_Frequency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Frequency' +type MuMPCInterface_Frequency_Call struct { + *mock.Call +} + +// Frequency is a helper method to define mock.On call +func (_e *MuMPCInterface_Expecter) Frequency() *MuMPCInterface_Frequency_Call { + return &MuMPCInterface_Frequency_Call{Call: _e.mock.On("Frequency")} +} + +func (_c *MuMPCInterface_Frequency_Call) Run(run func()) *MuMPCInterface_Frequency_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MuMPCInterface_Frequency_Call) Return(_a0 float64, _a1 error) *MuMPCInterface_Frequency_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MuMPCInterface_Frequency_Call) RunAndReturn(run func() (float64, error)) *MuMPCInterface_Frequency_Call { + _c.Call.Return(run) + return _c +} + +// Power provides a mock function with given fields: +func (_m *MuMPCInterface) Power() (float64, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Power") + } + + var r0 float64 + var r1 error + if rf, ok := ret.Get(0).(func() (float64, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() float64); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(float64) + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MuMPCInterface_Power_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Power' +type MuMPCInterface_Power_Call struct { + *mock.Call +} + +// Power is a helper method to define mock.On call +func (_e *MuMPCInterface_Expecter) Power() *MuMPCInterface_Power_Call { + return &MuMPCInterface_Power_Call{Call: _e.mock.On("Power")} +} + +func (_c *MuMPCInterface_Power_Call) Run(run func()) *MuMPCInterface_Power_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MuMPCInterface_Power_Call) Return(_a0 float64, _a1 error) *MuMPCInterface_Power_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MuMPCInterface_Power_Call) RunAndReturn(run func() (float64, error)) *MuMPCInterface_Power_Call { + _c.Call.Return(run) + return _c +} + +// PowerPerPhase provides a mock function with given fields: +func (_m *MuMPCInterface) PowerPerPhase() ([]float64, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for PowerPerPhase") + } + + var r0 []float64 + var r1 error + if rf, ok := ret.Get(0).(func() ([]float64, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []float64); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]float64) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MuMPCInterface_PowerPerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PowerPerPhase' +type MuMPCInterface_PowerPerPhase_Call struct { + *mock.Call +} + +// PowerPerPhase is a helper method to define mock.On call +func (_e *MuMPCInterface_Expecter) PowerPerPhase() *MuMPCInterface_PowerPerPhase_Call { + return &MuMPCInterface_PowerPerPhase_Call{Call: _e.mock.On("PowerPerPhase")} +} + +func (_c *MuMPCInterface_PowerPerPhase_Call) Run(run func()) *MuMPCInterface_PowerPerPhase_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MuMPCInterface_PowerPerPhase_Call) Return(_a0 []float64, _a1 error) *MuMPCInterface_PowerPerPhase_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MuMPCInterface_PowerPerPhase_Call) RunAndReturn(run func() ([]float64, error)) *MuMPCInterface_PowerPerPhase_Call { + _c.Call.Return(run) + return _c +} + +// Update provides a mock function with given fields: data +func (_m *MuMPCInterface) Update(data ...api.UpdateData) error { + _va := make([]interface{}, len(data)) + for _i := range data { + _va[_i] = data[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Update") + } + + var r0 error + if rf, ok := ret.Get(0).(func(...api.UpdateData) error); ok { + r0 = rf(data...) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MuMPCInterface_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update' +type MuMPCInterface_Update_Call struct { + *mock.Call +} + +// Update is a helper method to define mock.On call +// - data ...api.UpdateData +func (_e *MuMPCInterface_Expecter) Update(data ...interface{}) *MuMPCInterface_Update_Call { + return &MuMPCInterface_Update_Call{Call: _e.mock.On("Update", + append([]interface{}{}, data...)...)} +} + +func (_c *MuMPCInterface_Update_Call) Run(run func(data ...api.UpdateData)) *MuMPCInterface_Update_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]api.UpdateData, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(api.UpdateData) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MuMPCInterface_Update_Call) Return(_a0 error) *MuMPCInterface_Update_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_Update_Call) RunAndReturn(run func(...api.UpdateData) error) *MuMPCInterface_Update_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataCurrentPhaseA provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataCurrentPhaseA(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataCurrentPhaseA") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataCurrentPhaseA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataCurrentPhaseA' +type MuMPCInterface_UpdateDataCurrentPhaseA_Call struct { + *mock.Call +} + +// UpdateDataCurrentPhaseA is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataCurrentPhaseA(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataCurrentPhaseA_Call { + return &MuMPCInterface_UpdateDataCurrentPhaseA_Call{Call: _e.mock.On("UpdateDataCurrentPhaseA", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseA_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataCurrentPhaseA_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseA_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataCurrentPhaseA_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseA_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataCurrentPhaseA_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataCurrentPhaseB provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataCurrentPhaseB(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataCurrentPhaseB") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataCurrentPhaseB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataCurrentPhaseB' +type MuMPCInterface_UpdateDataCurrentPhaseB_Call struct { + *mock.Call +} + +// UpdateDataCurrentPhaseB is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataCurrentPhaseB(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataCurrentPhaseB_Call { + return &MuMPCInterface_UpdateDataCurrentPhaseB_Call{Call: _e.mock.On("UpdateDataCurrentPhaseB", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseB_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataCurrentPhaseB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseB_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataCurrentPhaseB_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseB_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataCurrentPhaseB_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataCurrentPhaseC provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataCurrentPhaseC(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataCurrentPhaseC") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataCurrentPhaseC_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataCurrentPhaseC' +type MuMPCInterface_UpdateDataCurrentPhaseC_Call struct { + *mock.Call +} + +// UpdateDataCurrentPhaseC is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataCurrentPhaseC(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataCurrentPhaseC_Call { + return &MuMPCInterface_UpdateDataCurrentPhaseC_Call{Call: _e.mock.On("UpdateDataCurrentPhaseC", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseC_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataCurrentPhaseC_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseC_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataCurrentPhaseC_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataCurrentPhaseC_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataCurrentPhaseC_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataEnergyConsumed provides a mock function with given fields: value, timestamp, valueState, evaluationStart, evaluationEnd +func (_m *MuMPCInterface) UpdateDataEnergyConsumed(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType, evaluationStart *time.Time, evaluationEnd *time.Time) api.UpdateData { + ret := _m.Called(value, timestamp, valueState, evaluationStart, evaluationEnd) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataEnergyConsumed") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType, *time.Time, *time.Time) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState, evaluationStart, evaluationEnd) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataEnergyConsumed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataEnergyConsumed' +type MuMPCInterface_UpdateDataEnergyConsumed_Call struct { + *mock.Call +} + +// UpdateDataEnergyConsumed is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +// - evaluationStart *time.Time +// - evaluationEnd *time.Time +func (_e *MuMPCInterface_Expecter) UpdateDataEnergyConsumed(value interface{}, timestamp interface{}, valueState interface{}, evaluationStart interface{}, evaluationEnd interface{}) *MuMPCInterface_UpdateDataEnergyConsumed_Call { + return &MuMPCInterface_UpdateDataEnergyConsumed_Call{Call: _e.mock.On("UpdateDataEnergyConsumed", value, timestamp, valueState, evaluationStart, evaluationEnd)} +} + +func (_c *MuMPCInterface_UpdateDataEnergyConsumed_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType, evaluationStart *time.Time, evaluationEnd *time.Time)) *MuMPCInterface_UpdateDataEnergyConsumed_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType), args[3].(*time.Time), args[4].(*time.Time)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataEnergyConsumed_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataEnergyConsumed_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataEnergyConsumed_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType, *time.Time, *time.Time) api.UpdateData) *MuMPCInterface_UpdateDataEnergyConsumed_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataEnergyProduced provides a mock function with given fields: value, timestamp, valueState, evaluationStart, evaluationEnd +func (_m *MuMPCInterface) UpdateDataEnergyProduced(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType, evaluationStart *time.Time, evaluationEnd *time.Time) api.UpdateData { + ret := _m.Called(value, timestamp, valueState, evaluationStart, evaluationEnd) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataEnergyProduced") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType, *time.Time, *time.Time) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState, evaluationStart, evaluationEnd) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataEnergyProduced_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataEnergyProduced' +type MuMPCInterface_UpdateDataEnergyProduced_Call struct { + *mock.Call +} + +// UpdateDataEnergyProduced is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +// - evaluationStart *time.Time +// - evaluationEnd *time.Time +func (_e *MuMPCInterface_Expecter) UpdateDataEnergyProduced(value interface{}, timestamp interface{}, valueState interface{}, evaluationStart interface{}, evaluationEnd interface{}) *MuMPCInterface_UpdateDataEnergyProduced_Call { + return &MuMPCInterface_UpdateDataEnergyProduced_Call{Call: _e.mock.On("UpdateDataEnergyProduced", value, timestamp, valueState, evaluationStart, evaluationEnd)} +} + +func (_c *MuMPCInterface_UpdateDataEnergyProduced_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType, evaluationStart *time.Time, evaluationEnd *time.Time)) *MuMPCInterface_UpdateDataEnergyProduced_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType), args[3].(*time.Time), args[4].(*time.Time)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataEnergyProduced_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataEnergyProduced_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataEnergyProduced_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType, *time.Time, *time.Time) api.UpdateData) *MuMPCInterface_UpdateDataEnergyProduced_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataFrequency provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataFrequency(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataFrequency") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataFrequency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataFrequency' +type MuMPCInterface_UpdateDataFrequency_Call struct { + *mock.Call +} + +// UpdateDataFrequency is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataFrequency(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataFrequency_Call { + return &MuMPCInterface_UpdateDataFrequency_Call{Call: _e.mock.On("UpdateDataFrequency", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataFrequency_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataFrequency_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataFrequency_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataFrequency_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataFrequency_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataFrequency_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataPowerPhaseA provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataPowerPhaseA(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataPowerPhaseA") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataPowerPhaseA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataPowerPhaseA' +type MuMPCInterface_UpdateDataPowerPhaseA_Call struct { + *mock.Call +} + +// UpdateDataPowerPhaseA is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataPowerPhaseA(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataPowerPhaseA_Call { + return &MuMPCInterface_UpdateDataPowerPhaseA_Call{Call: _e.mock.On("UpdateDataPowerPhaseA", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseA_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataPowerPhaseA_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseA_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataPowerPhaseA_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseA_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataPowerPhaseA_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataPowerPhaseB provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataPowerPhaseB(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataPowerPhaseB") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataPowerPhaseB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataPowerPhaseB' +type MuMPCInterface_UpdateDataPowerPhaseB_Call struct { + *mock.Call +} + +// UpdateDataPowerPhaseB is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataPowerPhaseB(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataPowerPhaseB_Call { + return &MuMPCInterface_UpdateDataPowerPhaseB_Call{Call: _e.mock.On("UpdateDataPowerPhaseB", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseB_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataPowerPhaseB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseB_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataPowerPhaseB_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseB_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataPowerPhaseB_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataPowerPhaseC provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataPowerPhaseC(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataPowerPhaseC") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataPowerPhaseC_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataPowerPhaseC' +type MuMPCInterface_UpdateDataPowerPhaseC_Call struct { + *mock.Call +} + +// UpdateDataPowerPhaseC is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataPowerPhaseC(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataPowerPhaseC_Call { + return &MuMPCInterface_UpdateDataPowerPhaseC_Call{Call: _e.mock.On("UpdateDataPowerPhaseC", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseC_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataPowerPhaseC_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseC_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataPowerPhaseC_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataPowerPhaseC_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataPowerPhaseC_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataPowerTotal provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataPowerTotal(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataPowerTotal") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataPowerTotal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataPowerTotal' +type MuMPCInterface_UpdateDataPowerTotal_Call struct { + *mock.Call +} + +// UpdateDataPowerTotal is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataPowerTotal(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataPowerTotal_Call { + return &MuMPCInterface_UpdateDataPowerTotal_Call{Call: _e.mock.On("UpdateDataPowerTotal", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataPowerTotal_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataPowerTotal_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataPowerTotal_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataPowerTotal_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataPowerTotal_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataPowerTotal_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataVoltagePhaseA provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataVoltagePhaseA(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataVoltagePhaseA") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataVoltagePhaseA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataVoltagePhaseA' +type MuMPCInterface_UpdateDataVoltagePhaseA_Call struct { + *mock.Call +} + +// UpdateDataVoltagePhaseA is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataVoltagePhaseA(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataVoltagePhaseA_Call { + return &MuMPCInterface_UpdateDataVoltagePhaseA_Call{Call: _e.mock.On("UpdateDataVoltagePhaseA", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseA_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataVoltagePhaseA_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseA_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseA_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseA_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseA_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataVoltagePhaseAToB provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataVoltagePhaseAToB(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataVoltagePhaseAToB") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataVoltagePhaseAToB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataVoltagePhaseAToB' +type MuMPCInterface_UpdateDataVoltagePhaseAToB_Call struct { + *mock.Call +} + +// UpdateDataVoltagePhaseAToB is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataVoltagePhaseAToB(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataVoltagePhaseAToB_Call { + return &MuMPCInterface_UpdateDataVoltagePhaseAToB_Call{Call: _e.mock.On("UpdateDataVoltagePhaseAToB", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseAToB_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataVoltagePhaseAToB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseAToB_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseAToB_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseAToB_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseAToB_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataVoltagePhaseB provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataVoltagePhaseB(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataVoltagePhaseB") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataVoltagePhaseB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataVoltagePhaseB' +type MuMPCInterface_UpdateDataVoltagePhaseB_Call struct { + *mock.Call +} + +// UpdateDataVoltagePhaseB is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataVoltagePhaseB(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataVoltagePhaseB_Call { + return &MuMPCInterface_UpdateDataVoltagePhaseB_Call{Call: _e.mock.On("UpdateDataVoltagePhaseB", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseB_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataVoltagePhaseB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseB_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseB_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseB_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseB_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataVoltagePhaseBToC provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataVoltagePhaseBToC(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataVoltagePhaseBToC") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataVoltagePhaseBToC_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataVoltagePhaseBToC' +type MuMPCInterface_UpdateDataVoltagePhaseBToC_Call struct { + *mock.Call +} + +// UpdateDataVoltagePhaseBToC is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataVoltagePhaseBToC(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataVoltagePhaseBToC_Call { + return &MuMPCInterface_UpdateDataVoltagePhaseBToC_Call{Call: _e.mock.On("UpdateDataVoltagePhaseBToC", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseBToC_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataVoltagePhaseBToC_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseBToC_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseBToC_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseBToC_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseBToC_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataVoltagePhaseC provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataVoltagePhaseC(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataVoltagePhaseC") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataVoltagePhaseC_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataVoltagePhaseC' +type MuMPCInterface_UpdateDataVoltagePhaseC_Call struct { + *mock.Call +} + +// UpdateDataVoltagePhaseC is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataVoltagePhaseC(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataVoltagePhaseC_Call { + return &MuMPCInterface_UpdateDataVoltagePhaseC_Call{Call: _e.mock.On("UpdateDataVoltagePhaseC", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseC_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataVoltagePhaseC_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseC_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseC_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseC_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseC_Call { + _c.Call.Return(run) + return _c +} + +// UpdateDataVoltagePhaseCToA provides a mock function with given fields: value, timestamp, valueState +func (_m *MuMPCInterface) UpdateDataVoltagePhaseCToA(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType) api.UpdateData { + ret := _m.Called(value, timestamp, valueState) + + if len(ret) == 0 { + panic("no return value specified for UpdateDataVoltagePhaseCToA") + } + + var r0 api.UpdateData + if rf, ok := ret.Get(0).(func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData); ok { + r0 = rf(value, timestamp, valueState) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(api.UpdateData) + } + } + + return r0 +} + +// MuMPCInterface_UpdateDataVoltagePhaseCToA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataVoltagePhaseCToA' +type MuMPCInterface_UpdateDataVoltagePhaseCToA_Call struct { + *mock.Call +} + +// UpdateDataVoltagePhaseCToA is a helper method to define mock.On call +// - value float64 +// - timestamp *time.Time +// - valueState *model.MeasurementValueStateType +func (_e *MuMPCInterface_Expecter) UpdateDataVoltagePhaseCToA(value interface{}, timestamp interface{}, valueState interface{}) *MuMPCInterface_UpdateDataVoltagePhaseCToA_Call { + return &MuMPCInterface_UpdateDataVoltagePhaseCToA_Call{Call: _e.mock.On("UpdateDataVoltagePhaseCToA", value, timestamp, valueState)} +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseCToA_Call) Run(run func(value float64, timestamp *time.Time, valueState *model.MeasurementValueStateType)) *MuMPCInterface_UpdateDataVoltagePhaseCToA_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(float64), args[1].(*time.Time), args[2].(*model.MeasurementValueStateType)) + }) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseCToA_Call) Return(_a0 api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseCToA_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MuMPCInterface_UpdateDataVoltagePhaseCToA_Call) RunAndReturn(run func(float64, *time.Time, *model.MeasurementValueStateType) api.UpdateData) *MuMPCInterface_UpdateDataVoltagePhaseCToA_Call { + _c.Call.Return(run) + return _c +} + +// VoltagePerPhase provides a mock function with given fields: +func (_m *MuMPCInterface) VoltagePerPhase() ([]float64, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for VoltagePerPhase") + } + + var r0 []float64 + var r1 error + if rf, ok := ret.Get(0).(func() ([]float64, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []float64); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]float64) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MuMPCInterface_VoltagePerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VoltagePerPhase' +type MuMPCInterface_VoltagePerPhase_Call struct { + *mock.Call +} + +// VoltagePerPhase is a helper method to define mock.On call +func (_e *MuMPCInterface_Expecter) VoltagePerPhase() *MuMPCInterface_VoltagePerPhase_Call { + return &MuMPCInterface_VoltagePerPhase_Call{Call: _e.mock.On("VoltagePerPhase")} +} + +func (_c *MuMPCInterface_VoltagePerPhase_Call) Run(run func()) *MuMPCInterface_VoltagePerPhase_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MuMPCInterface_VoltagePerPhase_Call) Return(_a0 []float64, _a1 error) *MuMPCInterface_VoltagePerPhase_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MuMPCInterface_VoltagePerPhase_Call) RunAndReturn(run func() ([]float64, error)) *MuMPCInterface_VoltagePerPhase_Call { + _c.Call.Return(run) + return _c +} + +// NewMuMPCInterface creates a new instance of MuMPCInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMuMPCInterface(t interface { + mock.TestingT + Cleanup(func()) +}) *MuMPCInterface { + mock := &MuMPCInterface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/usecases/mocks/UpdateData.go b/usecases/mocks/UpdateData.go new file mode 100644 index 00000000..81914ed3 --- /dev/null +++ b/usecases/mocks/UpdateData.go @@ -0,0 +1,170 @@ +// Code generated by mockery v2.46.3. DO NOT EDIT. + +package mocks + +import ( + api "github.com/enbility/eebus-go/api" + mock "github.com/stretchr/testify/mock" +) + +// UpdateData is an autogenerated mock type for the UpdateData type +type UpdateData struct { + mock.Mock +} + +type UpdateData_Expecter struct { + mock *mock.Mock +} + +func (_m *UpdateData) EXPECT() *UpdateData_Expecter { + return &UpdateData_Expecter{mock: &_m.Mock} +} + +// MeasurementData provides a mock function with given fields: +func (_m *UpdateData) MeasurementData() api.MeasurementDataForID { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for MeasurementData") + } + + var r0 api.MeasurementDataForID + if rf, ok := ret.Get(0).(func() api.MeasurementDataForID); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(api.MeasurementDataForID) + } + + return r0 +} + +// UpdateData_MeasurementData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MeasurementData' +type UpdateData_MeasurementData_Call struct { + *mock.Call +} + +// MeasurementData is a helper method to define mock.On call +func (_e *UpdateData_Expecter) MeasurementData() *UpdateData_MeasurementData_Call { + return &UpdateData_MeasurementData_Call{Call: _e.mock.On("MeasurementData")} +} + +func (_c *UpdateData_MeasurementData_Call) Run(run func()) *UpdateData_MeasurementData_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateData_MeasurementData_Call) Return(_a0 api.MeasurementDataForID) *UpdateData_MeasurementData_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateData_MeasurementData_Call) RunAndReturn(run func() api.MeasurementDataForID) *UpdateData_MeasurementData_Call { + _c.Call.Return(run) + return _c +} + +// NotSupportedError provides a mock function with given fields: +func (_m *UpdateData) NotSupportedError() error { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for NotSupportedError") + } + + var r0 error + if rf, ok := ret.Get(0).(func() error); ok { + r0 = rf() + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// UpdateData_NotSupportedError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotSupportedError' +type UpdateData_NotSupportedError_Call struct { + *mock.Call +} + +// NotSupportedError is a helper method to define mock.On call +func (_e *UpdateData_Expecter) NotSupportedError() *UpdateData_NotSupportedError_Call { + return &UpdateData_NotSupportedError_Call{Call: _e.mock.On("NotSupportedError")} +} + +func (_c *UpdateData_NotSupportedError_Call) Run(run func()) *UpdateData_NotSupportedError_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateData_NotSupportedError_Call) Return(_a0 error) *UpdateData_NotSupportedError_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateData_NotSupportedError_Call) RunAndReturn(run func() error) *UpdateData_NotSupportedError_Call { + _c.Call.Return(run) + return _c +} + +// Supported provides a mock function with given fields: +func (_m *UpdateData) Supported() bool { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Supported") + } + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + +// UpdateData_Supported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Supported' +type UpdateData_Supported_Call struct { + *mock.Call +} + +// Supported is a helper method to define mock.On call +func (_e *UpdateData_Expecter) Supported() *UpdateData_Supported_Call { + return &UpdateData_Supported_Call{Call: _e.mock.On("Supported")} +} + +func (_c *UpdateData_Supported_Call) Run(run func()) *UpdateData_Supported_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *UpdateData_Supported_Call) Return(_a0 bool) *UpdateData_Supported_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *UpdateData_Supported_Call) RunAndReturn(run func() bool) *UpdateData_Supported_Call { + _c.Call.Return(run) + return _c +} + +// NewUpdateData creates a new instance of UpdateData. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewUpdateData(t interface { + mock.TestingT + Cleanup(func()) +}) *UpdateData { + mock := &UpdateData{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/usecases/mu/mpc/config.go b/usecases/mu/mpc/config.go new file mode 100644 index 00000000..9b5314c1 --- /dev/null +++ b/usecases/mu/mpc/config.go @@ -0,0 +1,100 @@ +package mpc + +import ( + "strings" + + "github.com/enbility/spine-go/model" +) + +type ConnectedPhases string + +const ( + ConnectedPhasesA ConnectedPhases = "a" + ConnectedPhasesB ConnectedPhases = "b" + ConnectedPhasesC ConnectedPhases = "c" + ConnectedPhasesAB ConnectedPhases = "ab" + ConnectedPhasesBC ConnectedPhases = "bc" + ConnectedPhasesCA ConnectedPhases = "ac" + ConnectedPhasesABC ConnectedPhases = "abc" +) + +// MonitorPowerConfig is the configuration for the monitor use case +// This config is required by the mpc use case and must be used in mpc.NewMPC +type MonitorPowerConfig struct { + ConnectedPhases ConnectedPhases // The phases that are measured + + ValueSourceTotal *model.MeasurementValueSourceType // The source of the values from the acPowerTotal (required) + ValueSourcePhaseA *model.MeasurementValueSourceType // The source of the values from the acPower for phase A (required if the phase is supported) + ValueSourcePhaseB *model.MeasurementValueSourceType // The source of the values from the acPower for phase B (required if the phase is supported) + ValueSourcePhaseC *model.MeasurementValueSourceType // The source of the values from the acPower for phase C (required if the phase is supported) + + ValueConstraintsTotal *model.MeasurementConstraintsDataType // The constraints for the acPowerTotal (optional can be nil) + ValueConstraintsPhaseA *model.MeasurementConstraintsDataType // The constraints for the acPower for phase A (optional can be nil) + ValueConstraintsPhaseB *model.MeasurementConstraintsDataType // The constraints for the acPower for phase B (optional can be nil) + ValueConstraintsPhaseC *model.MeasurementConstraintsDataType // The constraints for the acPower for phase C (optional can be nil) +} + +// MonitorEnergyConfig is the configuration for the monitor use case +// If this config is passed via NewMPC, the use case will support energy monitoring as specified +type MonitorEnergyConfig struct { + ValueSourceProduction *model.MeasurementValueSourceType // The source of the production values (if this is set, the use case will support production) (optional can be nil) + ValueConstraintsProduction *model.MeasurementConstraintsDataType // The constraints for the production values (optional can be nil) (requires ProductionValueSource to be set) + + ValueSourceConsumption *model.MeasurementValueSourceType // The source of the consumption values (if this is set, the use case will support consumption) (optional can be nil) + ValueConstraintsConsumption *model.MeasurementConstraintsDataType // The constraints for the consumption values (optional can be nil) (requires ConsumptionValueSource to be set) +} + +// MonitorCurrentConfig is the configuration for the monitor use case +// If this config is passed via NewMPC, the use case will support current monitoring +// The current phases will be the same as specified in MonitorPowerConfig +type MonitorCurrentConfig struct { + ValueSourcePhaseA *model.MeasurementValueSourceType // The source of the values for phase A (required if the phase is supported) + ValueSourcePhaseB *model.MeasurementValueSourceType // The source of the values for phase B (required if the phase is supported) + ValueSourcePhaseC *model.MeasurementValueSourceType // The source of the values for phase C (required if the phase is supported) + + ValueConstraintsPhaseA *model.MeasurementConstraintsDataType // The constraints for the current for phase A (optional can be nil) (requires ValueSourcePhaseA to be set) + ValueConstraintsPhaseB *model.MeasurementConstraintsDataType // The constraints for the current for phase B (optional can be nil) (requires ValueSourcePhaseB to be set) + ValueConstraintsPhaseC *model.MeasurementConstraintsDataType // The constraints for the current for phase C (optional can be nil) (requires ValueSourcePhaseC to be set) +} + +// MonitorVoltageConfig is the configuration for the monitor use case +// If this config is passed via NewMPC, the use case will support voltage monitoring +// The voltage phases will be the same as specified in MonitorPowerConfig +type MonitorVoltageConfig struct { + ValueSourcePhaseA *model.MeasurementValueSourceType // The source of the values for phase A (required if the phase is supported) + ValueSourcePhaseB *model.MeasurementValueSourceType // The source of the values for phase B (required if the phase is supported) + ValueSourcePhaseC *model.MeasurementValueSourceType // The source of the values for phase C (required if the phase is supported) + + ValueConstraintsPhaseA *model.MeasurementConstraintsDataType // The constraints for the voltage for phase A (optional can be nil) (requires ValueSourcePhaseA to be set) + ValueConstraintsPhaseB *model.MeasurementConstraintsDataType // The constraints for the voltage for phase B (optional can be nil) (requires ValueSourcePhaseB to be set) + ValueConstraintsPhaseC *model.MeasurementConstraintsDataType // The constraints for the voltage for phase C (optional can be nil) (requires ValueSourcePhaseC to be set) + + SupportPhaseToPhase bool // Set to true if the use case supports phase to phase voltage monitoring + ValueSourcePhaseAToB *model.MeasurementValueSourceType // The source of the values for phase A to B (required if the phases are supported and SupportPhaseToPhase is true) + ValueSourcePhaseBToC *model.MeasurementValueSourceType // The source of the values for phase B to C (required if the phases are supported and SupportPhaseToPhase is true) + ValueSourcePhaseCToA *model.MeasurementValueSourceType // The source of the values for phase C to A (required if the phases are supported and SupportPhaseToPhase is true) + + ValueConstraintsPhaseAToB *model.MeasurementConstraintsDataType // The constraints for the voltage for phase A to B (optional can be nil) (requires ValueSourcePhaseAToB to be set) + ValueConstraintsPhaseBToC *model.MeasurementConstraintsDataType // The constraints for the voltage for phase B to C (optional can be nil) (requires ValueSourcePhaseBToC to be set) + ValueConstraintsPhaseCToA *model.MeasurementConstraintsDataType // The constraints for the voltage for phase C to A (optional can be nil) (requires ValueSourcePhaseCToA to be set) +} + +// MonitorFrequencyConfig is the configuration for the monitor use case +type MonitorFrequencyConfig struct { + ValueSource *model.MeasurementValueSourceType // The source of the values (required) + ValueConstraints *model.MeasurementConstraintsDataType // The constraints for the frequency values (optional can be nil) +} + +// SupportsPhases checks if the config supports the given phases +// e.g. SupportsPhases([]string{"a", "B"}) will return true if the config has ConnectedPhases set to "ab" or "abc" +func (c *MonitorPowerConfig) SupportsPhases(phase []string) bool { + phasesString := string(c.ConnectedPhases) + supports := true + for _, p := range phase { + if !strings.Contains(strings.ToLower(phasesString), strings.ToLower(p)) { + supports = false + break + } + } + return supports +} diff --git a/usecases/mu/mpc/config_test.go b/usecases/mu/mpc/config_test.go new file mode 100644 index 00000000..10d04777 --- /dev/null +++ b/usecases/mu/mpc/config_test.go @@ -0,0 +1,46 @@ +package mpc + +import ( + "github.com/stretchr/testify/assert" +) + +func (s *MuMPCSuite) Test_SupportsPhases() { + allowedConstellations := map[ConnectedPhases][][]string{ + ConnectedPhasesA: {{"a"}}, + ConnectedPhasesB: {{"b"}}, + ConnectedPhasesC: {{"C"}}, + ConnectedPhasesAB: {{"a"}, {"b"}, {"a", "b"}}, + ConnectedPhasesBC: {{"b"}, {"c"}, {"B", "c"}}, + ConnectedPhasesCA: {{"a"}, {"c"}, {"A", "C"}}, + ConnectedPhasesABC: {{"a"}, {"b"}, {"c"}, {"a", "b"}, {"b", "c"}, {"a", "c"}, {"A", "b", "c"}}, + } + + for constellation, phases := range allowedConstellations { + config := MonitorPowerConfig{ + ConnectedPhases: constellation, + } + + for _, phase := range phases { + assert.True(s.T(), config.SupportsPhases(phase)) + } + } + + notAllowedConstellations := map[ConnectedPhases][]string{ + ConnectedPhasesA: {"b", "c", "ab", "bc", "ac", "abc"}, + ConnectedPhasesB: {"a", "c", "ab", "bc", "ac", "abc"}, + ConnectedPhasesC: {"a", "b", "ab", "bc", "ac", "abc"}, + ConnectedPhasesAB: {"c", "ac", "abc"}, + ConnectedPhasesBC: {"a", "ab", "abc"}, + ConnectedPhasesCA: {"b", "bc", "abc"}, + } + + for constellation, notSupportedPhases := range notAllowedConstellations { + config := MonitorPowerConfig{ + ConnectedPhases: constellation, + } + + for _, phase := range notSupportedPhases { + assert.False(s.T(), config.SupportsPhases([]string{phase})) + } + } +} diff --git a/usecases/mu/mpc/events.go b/usecases/mu/mpc/events.go new file mode 100644 index 00000000..c05e05aa --- /dev/null +++ b/usecases/mu/mpc/events.go @@ -0,0 +1,10 @@ +package mpc + +import ( + spineapi "github.com/enbility/spine-go/api" +) + +// handle SPINE events +func (e *MPC) HandleEvent(payload spineapi.EventPayload) { + // No events supported +} diff --git a/usecases/mu/mpc/public.go b/usecases/mu/mpc/public.go new file mode 100644 index 00000000..2be81e7b --- /dev/null +++ b/usecases/mu/mpc/public.go @@ -0,0 +1,544 @@ +package mpc + +import ( + "github.com/enbility/eebus-go/api" + "github.com/enbility/eebus-go/features/server" + usecaseapi "github.com/enbility/eebus-go/usecases/api" + "github.com/enbility/spine-go/model" + "time" +) + +// ------------------------- Getters ------------------------- // + +// Scenario 1 + +// get the momentary active power consumption or production +// +// possible errors: +// - ErrMissingData if the id is not available +// - and others +func (e *MPC) Power() (float64, error) { + if e.acPowerTotal == nil { + return 0, api.ErrMissingData + } + + return e.getMeasurementDataForId(e.acPowerTotal) +} + +// get the momentary active power consumption or production per phase +// +// possible errors: +// - ErrMissingData if the id is not available +// - and others +func (e *MPC) PowerPerPhase() ([]float64, error) { + powerPerPhase := make([]float64, 0) + + for _, id := range e.acPower { + if id != nil { + power, err := e.getMeasurementDataForId(id) + if err != nil { + return nil, err + } + powerPerPhase = append(powerPerPhase, power) + } + } + + return powerPerPhase, nil +} + +// Scenario 2 + +// get the total feed in energy +// +// - negative values are used for production +// +// possible errors: +// - ErrMissingData if the id is not available +// - and others +func (e *MPC) EnergyConsumed() (float64, error) { + if e.acEnergyConsumed == nil { + return 0, api.ErrMissingData + } + + return e.getMeasurementDataForId(e.acEnergyConsumed) +} + +// get the total feed in energy +// +// - negative values are used for production +// +// possible errors: +// - ErrMissingData if the id is not available +// - and others +func (e *MPC) EnergyProduced() (float64, error) { + if e.acEnergyProduced == nil { + return 0, api.ErrMissingData + } + + return e.getMeasurementDataForId(e.acEnergyProduced) +} + +// Scenario 3 + +// get the momentary phase specific current consumption or production +// +// - positive values are used for consumption +// - negative values are used for production +// +// possible errors: +// - ErrMissingData if the id is not available +// - and others +func (e *MPC) CurrentPerPhase() ([]float64, error) { + currentPerPhase := make([]float64, 0) + + for _, id := range e.acCurrent { + if id != nil { + current, err := e.getMeasurementDataForId(id) + if err != nil { + return nil, err + } + currentPerPhase = append(currentPerPhase, current) + } + } + + return currentPerPhase, nil +} + +// Scenario 4 + +// get the phase specific voltage details +// +// possible errors: +// - ErrMissingData if the id is not available +// - and others +func (e *MPC) VoltagePerPhase() ([]float64, error) { + voltagePerPhase := make([]float64, 0) + + for _, id := range e.acVoltage { + if id != nil { + voltage, err := e.getMeasurementDataForId(id) + if err != nil { + return nil, err + } + voltagePerPhase = append(voltagePerPhase, voltage) + } + } + + return voltagePerPhase, nil +} + +// Scenario 5 + +// get frequency +// +// possible errors: +// - ErrMissingData if the id is not available +// - and others +func (e *MPC) Frequency() (float64, error) { + if e.acFrequency == nil { + return 0, api.ErrMissingData + } + + return e.getMeasurementDataForId(e.acFrequency) +} + +// ------------------------- Setters ------------------------- // + +// use MPC.Update to update the measurement data +// use it like this: +// +// mpc.Update( +// mpc.UpdateDataPowerTotal(1000, nil, nil), +// mpc.UpdateDataPowerPhaseA(500, nil, nil), +// ... +// ) +// +// possible errors: +// - ErrMissingData if the id is not available +// - and others +func (e *MPC) Update(updateData ...usecaseapi.UpdateData) error { + measurements, err := server.NewMeasurement(e.LocalEntity) + if err != nil { + return err + } + + measurementDataForIds := make([]api.MeasurementDataForID, 0) + + for _, measurementDataForId := range updateData { + if !measurementDataForId.Supported() { + return measurementDataForId.NotSupportedError() + } else { + measurementDataForIds = append(measurementDataForIds, measurementDataForId.MeasurementData()) + } + } + + return measurements.UpdateDataForIds(measurementDataForIds) +} + +// Scenario 1 + +// use MPC.UpdateDataPowerTotal in MPC.Update to set the momentary active power consumption or production +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataPowerTotal( + acPowerTotal float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acPowerTotal is not supported, please check the configuration", + e.acPowerTotal, + measurementData( + acPowerTotal, + timestamp, + e.powerConfig.ValueSourceTotal, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataPowerPhaseA in MPC.Update to set the momentary active power consumption or production per phase +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataPowerPhaseA( + acPowerPhaseA float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acPowerPhaseA is not supported, please check the configuration", + e.acPower[0], + measurementData( + acPowerPhaseA, + timestamp, + e.powerConfig.ValueSourcePhaseA, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataPowerPhaseB in MPC.Update to set the momentary active power consumption or production per phase +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataPowerPhaseB( + acPowerPhaseB float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acPowerPhaseB is not supported, please check the configuration", + e.acPower[1], + measurementData( + acPowerPhaseB, + timestamp, + e.powerConfig.ValueSourcePhaseB, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataPowerPhaseC in MPC.Update to set the momentary active power consumption or production per phase +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataPowerPhaseC( + acPowerPhaseC float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acPowerPhaseC is not supported, please check the configuration", + e.acPower[2], + measurementData( + acPowerPhaseC, + timestamp, + e.powerConfig.ValueSourcePhaseC, + valueState, + nil, + nil, + ), + ) +} + +// Scenario 2 + +// use MPC.UpdateDataEnergyConsumed in MPC.Update to set the total feed in energy +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +// The evaluationStart and End are optional and can be nil (both must be set to be used) +func (e *MPC) UpdateDataEnergyConsumed( + energyConsumed float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, + evaluationStart *time.Time, + evaluationEnd *time.Time, +) usecaseapi.UpdateData { + return newUpdateData( + "acEnergyConsumed is not supported, please check the configuration", + e.acEnergyConsumed, + measurementData( + energyConsumed, + timestamp, + e.energyConfig.ValueSourceConsumption, + valueState, + evaluationStart, + evaluationEnd, + ), + ) +} + +// use MPC.MeasuredUpdateDataEnergyProduced in MPC.Update to set the total feed in energy +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +// The evaluationStart and End are optional and can be nil (both must be set to be used) +func (e *MPC) UpdateDataEnergyProduced( + energyProduced float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, + evaluationStart *time.Time, + evaluationEnd *time.Time, +) usecaseapi.UpdateData { + return newUpdateData( + "acEnergyProduced is not supported, please check the configuration", + e.acEnergyProduced, + measurementData( + energyProduced, + timestamp, + e.energyConfig.ValueSourceProduction, + valueState, + evaluationStart, + evaluationEnd, + ), + ) +} + +// Scenario 3 + +// use MPC.UpdateDataCurrentPhaseA in MPC.Update to set the momentary phase specific current consumption or production +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataCurrentPhaseA( + acCurrentPhaseA float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acCurrentPhaseA is not supported, please check the configuration", + e.acCurrent[0], + measurementData( + acCurrentPhaseA, + timestamp, + e.currentConfig.ValueSourcePhaseA, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataCurrentPhaseB in MPC.Update to set the momentary phase specific current consumption or production +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataCurrentPhaseB( + acCurrentPhaseB float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acCurrentPhaseB is not supported, please check the configuration", + e.acCurrent[1], + measurementData( + acCurrentPhaseB, + timestamp, + e.currentConfig.ValueSourcePhaseB, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataCurrentPhaseC in MPC.Update to set the momentary phase specific current consumption or production +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataCurrentPhaseC( + acCurrentPhaseC float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acCurrentPhaseC is not supported, please check the configuration", + e.acCurrent[2], + measurementData( + acCurrentPhaseC, + timestamp, + e.currentConfig.ValueSourcePhaseC, + valueState, + nil, + nil, + ), + ) +} + +// Scenario 4 + +// use MPC.UpdateDataVoltagePhaseA in MPC.Update to set the phase specific voltage details +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataVoltagePhaseA( + voltagePhaseA float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acVoltagePhaseA is not supported, please check the configuration", + e.acVoltage[0], + measurementData( + voltagePhaseA, + timestamp, + e.voltageConfig.ValueSourcePhaseA, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataVoltagePhaseB in MPC.Update to set the phase specific voltage details +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataVoltagePhaseB( + voltagePhaseB float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acVoltagePhaseB is not supported, please check the configuration", + e.acVoltage[1], + measurementData( + voltagePhaseB, + timestamp, + e.voltageConfig.ValueSourcePhaseB, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataVoltagePhaseC in MPC.Update to set the phase specific voltage details +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataVoltagePhaseC( + voltagePhaseC float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acVoltagePhaseC is not supported, please check the configuration", + e.acVoltage[2], + measurementData( + voltagePhaseC, + timestamp, + e.voltageConfig.ValueSourcePhaseC, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataVoltagePhaseAToB in MPC.Update to set the phase specific voltage details +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataVoltagePhaseAToB( + voltagePhaseAToB float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acVoltagePhaseAToB is not supported, please check the configuration", + e.acVoltage[3], + measurementData( + voltagePhaseAToB, + timestamp, + e.voltageConfig.ValueSourcePhaseAToB, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataVoltagePhaseBToC in MPC.Update to set the phase specific voltage details +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataVoltagePhaseBToC( + voltagePhaseBToC float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acVoltagePhaseBToC is not supported, please check the configuration", + e.acVoltage[4], + measurementData( + voltagePhaseBToC, + timestamp, + e.voltageConfig.ValueSourcePhaseBToC, + valueState, + nil, + nil, + ), + ) +} + +// use MPC.UpdateDataVoltagePhaseCToA in MPC.Update to set the phase specific voltage details +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataVoltagePhaseCToA( + voltagePhaseCToA float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acVoltagePhaseCToA is not supported, please check the configuration", + e.acVoltage[5], + measurementData( + voltagePhaseCToA, + timestamp, + e.voltageConfig.ValueSourcePhaseCToA, + valueState, + nil, + nil, + ), + ) +} + +// Scenario 5 + +// use MPC.UpdateDataFrequency in MPC.Update to set the frequency +// The timestamp is optional and can be nil +// The valueState shall be set if it differs from the normal valueState otherwise it can be nil +func (e *MPC) UpdateDataFrequency( + frequency float64, + timestamp *time.Time, + valueState *model.MeasurementValueStateType, +) usecaseapi.UpdateData { + return newUpdateData( + "acFrequency is not supported, please check the configuration", + e.acFrequency, + measurementData( + frequency, + timestamp, + e.frequencyConfig.ValueSource, + valueState, + nil, + nil, + ), + ) +} diff --git a/usecases/mu/mpc/public_abc_test.go b/usecases/mu/mpc/public_abc_test.go new file mode 100644 index 00000000..dc1cc3e1 --- /dev/null +++ b/usecases/mu/mpc/public_abc_test.go @@ -0,0 +1,226 @@ +package mpc + +import ( + "github.com/enbility/eebus-go/features/server" + ucapi "github.com/enbility/eebus-go/usecases/api" + "github.com/enbility/spine-go/model" + "github.com/enbility/spine-go/util" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" + "testing" + "time" +) + +type MuMpcAbcSuite struct { + suite.Suite + *MuMPCSuite +} + +func TestMuMpcAbcSuite(t *testing.T) { + suite.Run(t, new(MuMpcAbcSuite)) +} + +func (s *MuMpcAbcSuite) BeforeTest(suiteName, testName string) { + s.MuMPCSuite = NewMuMPCSuite( + &s.Suite, + &MonitorPowerConfig{ + ConnectedPhases: ConnectedPhasesABC, + ValueSourceTotal: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + }, + &MonitorEnergyConfig{ + ValueSourceProduction: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourceConsumption: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + }, + &MonitorCurrentConfig{ + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + }, + &MonitorVoltageConfig{ + SupportPhaseToPhase: true, + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseAToB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseBToC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseCToA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + }, + &MonitorFrequencyConfig{ + ValueSource: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueConstraints: util.Ptr(model.MeasurementConstraintsDataType{ + ValueRangeMin: model.NewScaledNumberType(0), + ValueRangeMax: model.NewScaledNumberType(100), + ValueStepSize: model.NewScaledNumberType(1), + }), + }, + ) + s.MuMPCSuite.BeforeTest(suiteName, testName) +} + +func (s *MuMpcAbcSuite) Test_Power() { + err := s.sut.Update( + s.sut.UpdateDataPowerTotal(5.0, util.Ptr(time.Now()), nil), + ) + assert.Nil(s.T(), err) + + power, err := s.sut.Power() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.0, power) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypePower), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACPowerTotal), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, model.EnergyDirectionTypeConsume, nil) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.0}, values) +} + +func (s *MuMpcAbcSuite) Test_PowerPerPhase() { + err := s.sut.Update( + s.sut.UpdateDataPowerPhaseA(5.0, util.Ptr(time.Now()), nil), + s.sut.UpdateDataPowerPhaseB(6.0, util.Ptr(time.Now()), nil), + s.sut.UpdateDataPowerPhaseC(7.0, util.Ptr(time.Now()), util.Ptr(model.MeasurementValueStateTypeError)), + ) + assert.Nil(s.T(), err) + + powerPerPhases, err := s.sut.PowerPerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.0, 6.0, 7.0}, powerPerPhases) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypePower), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACPower), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, model.EnergyDirectionTypeConsume, ucapi.PhaseNameMapping) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.0, 6.0, 7.0}, values) +} + +func (s *MuMpcAbcSuite) Test_EnergyConsumed() { + err := s.sut.Update( + s.sut.UpdateDataEnergyConsumed(5.0, util.Ptr(time.Now()), nil, util.Ptr(time.Now()), util.Ptr(time.Now())), + ) + assert.Nil(s.T(), err) + + energyConsumed, err := s.sut.EnergyConsumed() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.0, energyConsumed) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeEnergy), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACEnergyConsumed), + } + measurement, err := server.NewMeasurement(s.sut.LocalEntity) + assert.Nil(s.T(), err) + values, err := measurement.GetDataForFilter(filter) + assert.Nil(s.T(), err) + assert.Equal(s.T(), 1, len(values)) + assert.Equal(s.T(), 5.0, (*values[0].Value).GetValue()) +} + +func (s *MuMpcAbcSuite) Test_EnergyProduced() { + err := s.sut.Update( + s.sut.UpdateDataEnergyProduced(5.0, nil, nil, nil, nil), + ) + assert.Nil(s.T(), err) + + energyProduced, err := s.sut.EnergyProduced() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.0, energyProduced) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeEnergy), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACEnergyProduced), + } + measurement, err := server.NewMeasurement(s.sut.LocalEntity) + assert.Nil(s.T(), err) + values, err := measurement.GetDataForFilter(filter) + assert.Nil(s.T(), err) + assert.Equal(s.T(), 1, len(values)) + assert.Equal(s.T(), 5.0, (*values[0].Value).GetValue()) +} + +func (s *MuMpcAbcSuite) Test_CurrentPerPhase() { + err := s.sut.Update( + s.sut.UpdateDataCurrentPhaseA(5.0, nil, nil), + s.sut.UpdateDataCurrentPhaseB(3.0, nil, nil), + s.sut.UpdateDataCurrentPhaseC(1.0, nil, nil), + ) + assert.Nil(s.T(), err) + + currentPerPhases, err := s.sut.CurrentPerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.0, 3.0, 1.0}, currentPerPhases) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeCurrent), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACCurrent), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, model.EnergyDirectionTypeConsume, ucapi.PhaseNameMapping) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.0, 3.0, 1.0}, values) +} + +func (s *MuMpcAbcSuite) Test_VoltagePerPhase() { + err := s.sut.Update( + s.sut.UpdateDataVoltagePhaseA(5.0, nil, nil), + s.sut.UpdateDataVoltagePhaseB(6.0, nil, nil), + s.sut.UpdateDataVoltagePhaseC(7.0, nil, nil), + s.sut.UpdateDataVoltagePhaseAToB(8.0, nil, nil), + s.sut.UpdateDataVoltagePhaseBToC(9.0, nil, nil), + s.sut.UpdateDataVoltagePhaseCToA(10.0, nil, nil), + ) + assert.Nil(s.T(), err) + + voltagePerPhases, err := s.sut.VoltagePerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.0, 6.0, 7.0, 8.0, 9.0, 10.0}, voltagePerPhases) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeVoltage), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACVoltage), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, "", ucapi.PhaseNameMapping) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.0, 6.0, 7.0, 8.0, 9.0, 10.0}, values) +} + +func (s *MuMpcAbcSuite) Test_Frequency() { + err := s.sut.Update( + s.sut.UpdateDataFrequency(5.0, nil, nil), + ) + assert.Nil(s.T(), err) + + frequency, err := s.sut.Frequency() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.0, frequency) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeFrequency), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACFrequency), + } + measurements, err := server.NewMeasurement(s.sut.LocalEntity) + assert.Nil(s.T(), err) + values, err := measurements.GetDataForFilter(filter) + assert.Nil(s.T(), err) + assert.Equal(s.T(), 1, len(values)) + assert.Equal(s.T(), 5.0, (*values[0].Value).GetValue()) +} diff --git a/usecases/mu/mpc/public_bc_test.go b/usecases/mu/mpc/public_bc_test.go new file mode 100644 index 00000000..cbefdc5b --- /dev/null +++ b/usecases/mu/mpc/public_bc_test.go @@ -0,0 +1,181 @@ +package mpc + +import ( + ucapi "github.com/enbility/eebus-go/usecases/api" + "github.com/enbility/spine-go/model" + "github.com/enbility/spine-go/util" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" + "testing" + "time" +) + +type MuMpcBcSuite struct { + suite.Suite + *MuMPCSuite +} + +func TestMuMpcAbSuite(t *testing.T) { + suite.Run(t, new(MuMpcBcSuite)) +} + +func (s *MuMpcBcSuite) BeforeTest(suiteName, testName string) { + s.MuMPCSuite = NewMuMPCSuite( + &s.Suite, + &MonitorPowerConfig{ + ConnectedPhases: ConnectedPhasesBC, + ValueSourceTotal: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + }, + &MonitorEnergyConfig{ + ValueSourceProduction: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourceConsumption: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + }, + &MonitorCurrentConfig{ + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + }, + &MonitorVoltageConfig{ + SupportPhaseToPhase: true, + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseBToC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + }, + &MonitorFrequencyConfig{ + ValueSource: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueConstraints: util.Ptr(model.MeasurementConstraintsDataType{ + ValueRangeMin: model.NewScaledNumberType(0), + ValueRangeMax: model.NewScaledNumberType(100), + ValueStepSize: model.NewScaledNumberType(1), + }), + }, + ) + s.MuMPCSuite.BeforeTest(suiteName, testName) +} + +func (s *MuMpcBcSuite) Test_Power() { + err := s.sut.Update( + s.sut.UpdateDataPowerTotal(5.0, util.Ptr(time.Now()), nil), + ) + assert.Nil(s.T(), err) + + power, err := s.sut.Power() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.0, power) +} + +func (s *MuMpcBcSuite) Test_PowerPerPhase() { + err := s.sut.Update( + s.sut.UpdateDataPowerPhaseB(6.0, util.Ptr(time.Now()), nil), + s.sut.UpdateDataPowerPhaseC(7.0, util.Ptr(time.Now()), util.Ptr(model.MeasurementValueStateTypeError)), + ) + assert.Nil(s.T(), err) + + powerPerPhases, err := s.sut.PowerPerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{6.0, 7.0}, powerPerPhases) + + err = s.sut.Update( + s.sut.UpdateDataPowerPhaseA(5.0, util.Ptr(time.Now()), nil), + ) + assert.NotNil(s.T(), err) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypePower), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACPower), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, model.EnergyDirectionTypeConsume, ucapi.PhaseNameMapping) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{6.0, 7.0}, values) +} + +func (s *MuMpcBcSuite) Test_EnergyConsumed() { + err := s.sut.Update( + s.sut.UpdateDataEnergyConsumed(5.0, util.Ptr(time.Now()), nil, util.Ptr(time.Now()), util.Ptr(time.Now())), + ) + assert.Nil(s.T(), err) + + energyConsumed, err := s.sut.EnergyConsumed() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.0, energyConsumed) +} + +func (s *MuMpcBcSuite) Test_EnergyProduced() { + err := s.sut.Update( + s.sut.UpdateDataEnergyProduced(5.0, nil, nil, nil, nil), + ) + assert.Nil(s.T(), err) + + energyProduced, err := s.sut.EnergyProduced() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.0, energyProduced) +} + +func (s *MuMpcBcSuite) Test_CurrentPerPhase() { + err := s.sut.Update( + s.sut.UpdateDataCurrentPhaseB(3.0, nil, nil), + s.sut.UpdateDataCurrentPhaseC(1.0, nil, nil), + ) + assert.Nil(s.T(), err) + + currentPerPhases, err := s.sut.CurrentPerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{3.0, 1.0}, currentPerPhases) + + err = s.sut.Update( + s.sut.UpdateDataCurrentPhaseA(5.0, nil, nil), + ) + assert.NotNil(s.T(), err) +} + +func (s *MuMpcBcSuite) Test_VoltagePerPhase() { + err := s.sut.Update( + s.sut.UpdateDataVoltagePhaseB(6.0, nil, nil), + s.sut.UpdateDataVoltagePhaseC(7.0, nil, nil), + s.sut.UpdateDataVoltagePhaseBToC(9.0, nil, nil), + ) + assert.Nil(s.T(), err) + + voltagePerPhases, err := s.sut.VoltagePerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{6.0, 7.0, 9.0}, voltagePerPhases) + + err = s.sut.Update( + s.sut.UpdateDataVoltagePhaseA(5.0, nil, nil), + ) + assert.NotNil(s.T(), err) + + err = s.sut.Update( + s.sut.UpdateDataVoltagePhaseAToB(5.0, nil, nil), + ) + assert.NotNil(s.T(), err) + + err = s.sut.Update( + s.sut.UpdateDataVoltagePhaseCToA(5.0, nil, nil), + ) + assert.NotNil(s.T(), err) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeVoltage), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACVoltage), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, "", ucapi.PhaseNameMapping) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{6.0, 7.0, 9.0}, values) +} + +func (s *MuMpcBcSuite) Test_Frequency() { + err := s.sut.Update( + s.sut.UpdateDataFrequency(5.0, nil, nil), + ) + assert.Nil(s.T(), err) + + frequency, err := s.sut.Frequency() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.0, frequency) +} diff --git a/usecases/mu/mpc/public_constraint_test.go b/usecases/mu/mpc/public_constraint_test.go new file mode 100644 index 00000000..2c9f35f3 --- /dev/null +++ b/usecases/mu/mpc/public_constraint_test.go @@ -0,0 +1,225 @@ +package mpc + +import ( + "testing" + "time" + + "github.com/enbility/eebus-go/features/server" + ucapi "github.com/enbility/eebus-go/usecases/api" + "github.com/enbility/spine-go/model" + "github.com/enbility/spine-go/util" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" +) + +type MuMpcConstraintSuite struct { + suite.Suite + *MuMPCSuite +} + +func TestMuMpcConstraintSuite(t *testing.T) { + suite.Run(t, new(MuMpcConstraintSuite)) +} + +func (s *MuMpcConstraintSuite) BeforeTest(suiteName, testName string) { + s.MuMPCSuite = NewMuMPCSuite( + &s.Suite, + &MonitorPowerConfig{ + ConnectedPhases: ConnectedPhasesA, + ValueSourceTotal: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueConstraintsTotal: util.Ptr(model.MeasurementConstraintsDataType{ + ValueRangeMin: model.NewScaledNumberType(0), + ValueStepSize: model.NewScaledNumberType(0.1), + }), + ValueConstraintsPhaseA: util.Ptr(model.MeasurementConstraintsDataType{ + ValueRangeMin: model.NewScaledNumberType(0), + ValueStepSize: model.NewScaledNumberType(0.1), + }), + }, + &MonitorEnergyConfig{ + ValueSourceConsumption: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueConstraintsConsumption: util.Ptr(model.MeasurementConstraintsDataType{ + ValueRangeMin: model.NewScaledNumberType(0), + ValueStepSize: model.NewScaledNumberType(100), + }), + }, + &MonitorCurrentConfig{ + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueConstraintsPhaseA: util.Ptr(model.MeasurementConstraintsDataType{ + ValueRangeMin: model.NewScaledNumberType(0), + ValueRangeMax: model.NewScaledNumberType(32), + ValueStepSize: model.NewScaledNumberType(0.1), + }), + }, + &MonitorVoltageConfig{ + SupportPhaseToPhase: false, + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueConstraintsPhaseA: util.Ptr(model.MeasurementConstraintsDataType{ + ValueStepSize: model.NewScaledNumberType(0.1), + }), + }, + &MonitorFrequencyConfig{ + ValueSource: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueConstraints: util.Ptr(model.MeasurementConstraintsDataType{ + ValueRangeMin: model.NewScaledNumberType(40), + ValueRangeMax: model.NewScaledNumberType(60), + ValueStepSize: model.NewScaledNumberType(0.01), + }), + }, + ) + s.MuMPCSuite.BeforeTest(suiteName, testName) +} + +func (s *MuMpcConstraintSuite) Test_Power() { + err := s.sut.Update( + s.sut.UpdateDataPowerTotal(5.7, util.Ptr(time.Now()), nil), + ) + assert.Nil(s.T(), err) + + power, err := s.sut.Power() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 5.7, power) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypePower), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACPowerTotal), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, model.EnergyDirectionTypeConsume, nil) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.7}, values) +} + +func (s *MuMpcConstraintSuite) Test_PowerPerPhase() { + err := s.sut.Update( + s.sut.UpdateDataPowerPhaseA(5.7, util.Ptr(time.Now()), nil), + ) + assert.Nil(s.T(), err) + + powerPerPhases, err := s.sut.PowerPerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.7}, powerPerPhases) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypePower), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACPower), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, model.EnergyDirectionTypeConsume, ucapi.PhaseNameMapping) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{5.7}, values) +} + +func (s *MuMpcConstraintSuite) Test_EnergyConsumed() { + err := s.sut.Update( + s.sut.UpdateDataEnergyConsumed(570, util.Ptr(time.Now()), nil, util.Ptr(time.Now()), util.Ptr(time.Now())), + ) + assert.Nil(s.T(), err) + + energyConsumed, err := s.sut.EnergyConsumed() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 570.0, energyConsumed) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeEnergy), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACEnergyConsumed), + } + measurement, err := server.NewMeasurement(s.sut.LocalEntity) + assert.Nil(s.T(), err) + values, err := measurement.GetDataForFilter(filter) + assert.Nil(s.T(), err) + assert.Equal(s.T(), 1, len(values)) + assert.Equal(s.T(), 570.0, (*values[0].Value).GetValue()) +} + +func (s *MuMpcConstraintSuite) Test_EnergyProduced() { + err := s.sut.Update( + s.sut.UpdateDataEnergyProduced(5.0, nil, nil, nil, nil), + ) + assert.NotNil(s.T(), err) + + _, err = s.sut.EnergyProduced() + assert.NotNil(s.T(), err) + + // Check if the client filter works (it shouldn't) + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeEnergy), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACEnergyProduced), + } + measurement, err := server.NewMeasurement(s.sut.LocalEntity) + assert.Nil(s.T(), err) + _, err = measurement.GetDataForFilter(filter) + assert.NotNil(s.T(), err) +} + +func (s *MuMpcConstraintSuite) Test_CurrentPerPhase() { + err := s.sut.Update( + s.sut.UpdateDataCurrentPhaseA(0.1, nil, nil), + ) + assert.Nil(s.T(), err) + + currentPerPhases, err := s.sut.CurrentPerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{0.1}, currentPerPhases) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeCurrent), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACCurrent), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, model.EnergyDirectionTypeConsume, ucapi.PhaseNameMapping) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{0.1}, values) +} + +func (s *MuMpcConstraintSuite) Test_VoltagePerPhase() { + err := s.sut.Update( + s.sut.UpdateDataVoltagePhaseA(230, nil, nil), + ) + assert.Nil(s.T(), err) + + voltagePerPhases, err := s.sut.VoltagePerPhase() + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{230}, voltagePerPhases) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeVoltage), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACVoltage), + } + values, err := s.measurementPhaseSpecificDataForFilter(filter, "", ucapi.PhaseNameMapping) + assert.Nil(s.T(), err) + assert.Equal(s.T(), []float64{230}, values) +} + +func (s *MuMpcConstraintSuite) Test_Frequency() { + err := s.sut.Update( + s.sut.UpdateDataFrequency(50, nil, nil), + ) + assert.Nil(s.T(), err) + + frequency, err := s.sut.Frequency() + assert.Nil(s.T(), err) + assert.Equal(s.T(), 50.0, frequency) + + // Check if the client filter works + filter := model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeFrequency), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + ScopeType: util.Ptr(model.ScopeTypeTypeACFrequency), + } + measurements, err := server.NewMeasurement(s.sut.LocalEntity) + assert.Nil(s.T(), err) + values, err := measurements.GetDataForFilter(filter) + assert.Nil(s.T(), err) + assert.Equal(s.T(), 1, len(values)) + assert.Equal(s.T(), 50.0, (*values[0].Value).GetValue()) +} diff --git a/usecases/mu/mpc/testhelper_test.go b/usecases/mu/mpc/testhelper_test.go new file mode 100644 index 00000000..2e503215 --- /dev/null +++ b/usecases/mu/mpc/testhelper_test.go @@ -0,0 +1,147 @@ +package mpc + +import ( + "slices" + "time" + + "github.com/enbility/eebus-go/features/server" + + "github.com/enbility/eebus-go/api" + "github.com/enbility/eebus-go/mocks" + "github.com/enbility/eebus-go/service" + shipapi "github.com/enbility/ship-go/api" + "github.com/enbility/ship-go/cert" + spineapi "github.com/enbility/spine-go/api" + "github.com/enbility/spine-go/model" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/suite" +) + +const remoteSki string = "testremoteski" + +type MuMPCSuite struct { + *suite.Suite + + powerConfig *MonitorPowerConfig + energyConfig *MonitorEnergyConfig + currentConfig *MonitorCurrentConfig + voltageConfig *MonitorVoltageConfig + frequencyConfig *MonitorFrequencyConfig + sut *MPC + + service api.ServiceInterface +} + +func NewMuMPCSuite( + suite *suite.Suite, + powerConfig *MonitorPowerConfig, + energyConfig *MonitorEnergyConfig, + currentConfig *MonitorCurrentConfig, + voltageConfig *MonitorVoltageConfig, + frequencyConfig *MonitorFrequencyConfig, +) *MuMPCSuite { + return &MuMPCSuite{ + Suite: suite, + powerConfig: powerConfig, + energyConfig: energyConfig, + currentConfig: currentConfig, + voltageConfig: voltageConfig, + frequencyConfig: frequencyConfig, + } +} + +func (s *MuMPCSuite) Event(_ string, _ spineapi.DeviceRemoteInterface, _ spineapi.EntityRemoteInterface, _ api.EventType) { +} + +func (s *MuMPCSuite) BeforeTest(_, _ string) { + cert, _ := cert.CreateCertificate("test", "test", "DE", "test") + configuration, _ := api.NewConfiguration( + "test", "test", "test", "test", + []shipapi.DeviceCategoryType{shipapi.DeviceCategoryTypeEnergyManagementSystem}, + model.DeviceTypeTypeEnergyManagementSystem, + []model.EntityTypeType{model.EntityTypeTypeInverter}, + 9999, cert, time.Second*4) + + serviceHandler := mocks.NewServiceReaderInterface(s.T()) + serviceHandler.EXPECT().ServicePairingDetailUpdate(mock.Anything, mock.Anything).Return().Maybe() + + s.service = service.NewService(configuration, serviceHandler) + _ = s.service.Setup() + + localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeInverter) + s.sut, _ = NewMPC( + localEntity, + s.Event, + s.powerConfig, + s.energyConfig, + s.currentConfig, + s.voltageConfig, + s.frequencyConfig, + ) + + assert.Nil(s.T(), s.sut.AddFeatures()) + s.sut.AddUseCase() +} + +func (s *MuMPCSuite) measurementPhaseSpecificDataForFilter( + measurementFilter model.MeasurementDescriptionDataType, + energyDirection model.EnergyDirectionType, + validPhaseNameTypes []model.ElectricalConnectionPhaseNameType, +) ([]float64, error) { + measurements, err := server.NewMeasurement(s.sut.LocalEntity) + if err != nil { + return nil, err + } + + electricalConnection, err := server.NewElectricalConnection(s.sut.LocalEntity) + if err != nil { + return nil, err + } + + data, err := measurements.GetDataForFilter(measurementFilter) + if err != nil || len(data) == 0 { + return nil, api.ErrDataNotAvailable + } + + var result []float64 + + for _, item := range data { + if item.Value == nil || item.MeasurementId == nil { + continue + } + + if validPhaseNameTypes != nil { + filter := model.ElectricalConnectionParameterDescriptionDataType{ + MeasurementId: item.MeasurementId, + } + param, err := electricalConnection.GetParameterDescriptionsForFilter(filter) + if err != nil || len(param) == 0 || + param[0].AcMeasuredPhases == nil || + !slices.Contains(validPhaseNameTypes, *param[0].AcMeasuredPhases) { + continue + } + } + + if energyDirection != "" { + filter := model.ElectricalConnectionParameterDescriptionDataType{ + MeasurementId: item.MeasurementId, + } + desc, err := electricalConnection.GetDescriptionForParameterDescriptionFilter(filter) + if err != nil || desc == nil { + continue + } + + // if energy direction is not consume + if desc.PositiveEnergyDirection == nil || *desc.PositiveEnergyDirection != energyDirection { + return nil, err + } + } + + value := item.Value.GetValue() + + result = append(result, value) + } + + return result, nil +} diff --git a/usecases/mu/mpc/types.go b/usecases/mu/mpc/types.go new file mode 100644 index 00000000..67f2d3f0 --- /dev/null +++ b/usecases/mu/mpc/types.go @@ -0,0 +1,10 @@ +package mpc + +import "github.com/enbility/eebus-go/api" + +const ( + // Update of the list of remote entities supporting the Use Case + // + // Use `RemoteEntities` to get the current data + UseCaseSupportUpdate api.EventType = "mu-mpc-UseCaseSupportUpdate" +) diff --git a/usecases/mu/mpc/update_helper.go b/usecases/mu/mpc/update_helper.go new file mode 100644 index 00000000..279f03bc --- /dev/null +++ b/usecases/mu/mpc/update_helper.go @@ -0,0 +1,77 @@ +package mpc + +import ( + "errors" + "github.com/enbility/eebus-go/api" + "github.com/enbility/spine-go/model" + "github.com/enbility/spine-go/util" + "time" +) + +type UpdateData struct { + supported bool + notSupportedError error + measurementData api.MeasurementDataForID +} + +func (u *UpdateData) Supported() bool { + return u.supported +} + +func (u *UpdateData) NotSupportedError() error { + return u.notSupportedError +} + +func (u *UpdateData) MeasurementData() api.MeasurementDataForID { + return u.measurementData +} + +func newUpdateData( + errorString string, + id *model.MeasurementIdType, + data *model.MeasurementDataType, +) *UpdateData { + if id == nil || data == nil { + return &UpdateData{ + supported: false, + notSupportedError: errors.New(errorString), + } + } else { + return &UpdateData{ + supported: true, + measurementData: api.MeasurementDataForID{ + Id: *id, + Data: *data, + }, + } + } +} + +func measurementData( + value float64, + timestamp *time.Time, + valueSource *model.MeasurementValueSourceType, + valueState *model.MeasurementValueStateType, + evaluationStart *time.Time, + evaluationEnd *time.Time, +) *model.MeasurementDataType { + measurement := model.MeasurementDataType{ + ValueType: util.Ptr(model.MeasurementValueTypeTypeValue), + Value: model.NewScaledNumberType(value), + ValueSource: valueSource, + ValueState: valueState, + } + + if timestamp != nil { + measurement.Timestamp = model.NewAbsoluteOrRelativeTimeTypeFromTime(*timestamp) + } + + if evaluationStart != nil && evaluationEnd != nil { + measurement.EvaluationPeriod = &model.TimePeriodType{ + StartTime: model.NewAbsoluteOrRelativeTimeTypeFromTime(*evaluationStart), + EndTime: model.NewAbsoluteOrRelativeTimeTypeFromTime(*evaluationEnd), + } + } + + return &measurement +} diff --git a/usecases/mu/mpc/usecase.go b/usecases/mu/mpc/usecase.go new file mode 100644 index 00000000..1a0e11b4 --- /dev/null +++ b/usecases/mu/mpc/usecase.go @@ -0,0 +1,541 @@ +package mpc + +import ( + "errors" + "github.com/enbility/eebus-go/api" + "github.com/enbility/eebus-go/features/server" + "github.com/enbility/eebus-go/usecases/usecase" + spineapi "github.com/enbility/spine-go/api" + "github.com/enbility/spine-go/model" + "github.com/enbility/spine-go/spine" + "github.com/enbility/spine-go/util" +) + +type MPC struct { + *usecase.UseCaseBase + + powerConfig *MonitorPowerConfig + energyConfig *MonitorEnergyConfig + currentConfig *MonitorCurrentConfig + voltageConfig *MonitorVoltageConfig + frequencyConfig *MonitorFrequencyConfig + + acPowerTotal *model.MeasurementIdType + acPower [3]*model.MeasurementIdType + acEnergyConsumed *model.MeasurementIdType + acEnergyProduced *model.MeasurementIdType + acCurrent [3]*model.MeasurementIdType + acVoltage [6]*model.MeasurementIdType // Phase to phase voltages are not supported (yet) + acFrequency *model.MeasurementIdType +} + +// creates a new MPC usecase instance for a MonitoredUnit entity +// +// parameters: +// - localEntity: the local entity for which to construct an MPC instance +// - eventCB: the callback to notify about events for this usecase +// - monitorPowerConfig: (required) configuration parameters for MPC scenario 1 +// - monitorEnergyConfig: (optional) configuration parameters for MPC scenario 2, nil if not supported +// - monitorCurrentConfig: (optional) configuration parameters for MPC scenario 3, nil if not supported +// - monitorVoltageConfig: (optional) configuration parameters for MPC scenario 4, nil if not supported +// - monitorFrequencyConfig: (optional) configuration parameters for MPC scenario, nil if not supported +// +// possible errors: +// - if required fields in parameters are unset +func NewMPC( + localEntity spineapi.EntityLocalInterface, + eventCB api.EntityEventCallback, + monitorPowerConfig *MonitorPowerConfig, + monitorEnergyConfig *MonitorEnergyConfig, + monitorCurrentConfig *MonitorCurrentConfig, + monitorVoltageConfig *MonitorVoltageConfig, + monitorFrequencyConfig *MonitorFrequencyConfig, +) (*MPC, error) { + if monitorPowerConfig == nil { + return nil, errors.New("the monitor power config for the MPC-Use-Case must not be nil") + } + + validActorTypes := []model.UseCaseActorType{model.UseCaseActorTypeMonitoringAppliance} + useCaseScenarios := []api.UseCaseScenario{ + { + Scenario: model.UseCaseScenarioSupportType(1), + Mandatory: true, + ServerFeatures: []model.FeatureTypeType{ + model.FeatureTypeTypeElectricalConnection, + model.FeatureTypeTypeMeasurement, + }, + }, + } + + if monitorEnergyConfig != nil { + useCaseScenarios = append(useCaseScenarios, api.UseCaseScenario{ + Scenario: model.UseCaseScenarioSupportType(2), + Mandatory: false, + ServerFeatures: []model.FeatureTypeType{ + model.FeatureTypeTypeElectricalConnection, + model.FeatureTypeTypeMeasurement, + }, + }) + } + + if monitorCurrentConfig != nil { + useCaseScenarios = append(useCaseScenarios, api.UseCaseScenario{ + Scenario: model.UseCaseScenarioSupportType(3), + Mandatory: false, + ServerFeatures: []model.FeatureTypeType{ + model.FeatureTypeTypeElectricalConnection, + model.FeatureTypeTypeMeasurement, + }, + }) + } + + if monitorVoltageConfig != nil { + useCaseScenarios = append(useCaseScenarios, api.UseCaseScenario{ + Scenario: model.UseCaseScenarioSupportType(4), + Mandatory: false, + ServerFeatures: []model.FeatureTypeType{ + model.FeatureTypeTypeElectricalConnection, + model.FeatureTypeTypeMeasurement, + }, + }) + } + + if monitorFrequencyConfig != nil { + useCaseScenarios = append(useCaseScenarios, api.UseCaseScenario{ + Scenario: model.UseCaseScenarioSupportType(5), + Mandatory: false, + ServerFeatures: []model.FeatureTypeType{ + model.FeatureTypeTypeElectricalConnection, + model.FeatureTypeTypeMeasurement, + }, + }) + } + + u := usecase.NewUseCaseBase( + localEntity, + model.UseCaseActorTypeMonitoredUnit, + model.UseCaseNameTypeMonitoringOfPowerConsumption, + "1.0.0", + "release", + useCaseScenarios, + eventCB, + UseCaseSupportUpdate, + validActorTypes, + nil, + true, + ) + + uc := &MPC{ + UseCaseBase: u, + powerConfig: monitorPowerConfig, + energyConfig: monitorEnergyConfig, + currentConfig: monitorCurrentConfig, + voltageConfig: monitorVoltageConfig, + frequencyConfig: monitorFrequencyConfig, + } + + _ = spine.Events.Subscribe(uc) + + return uc, nil +} + +func (e *MPC) AddFeatures() error { + // server features + electricalConnectionFeature := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeElectricalConnection, model.RoleTypeServer) + electricalConnectionFeature.AddFunctionType(model.FunctionTypeElectricalConnectionDescriptionListData, true, false) + electricalConnectionFeature.AddFunctionType(model.FunctionTypeElectricalConnectionParameterDescriptionListData, true, false) + + measurementFeature := e.LocalEntity.GetOrAddFeature(model.FeatureTypeTypeMeasurement, model.RoleTypeServer) + measurementFeature.AddFunctionType(model.FunctionTypeMeasurementDescriptionListData, true, false) + measurementFeature.AddFunctionType(model.FunctionTypeMeasurementConstraintsListData, true, false) + measurementFeature.AddFunctionType(model.FunctionTypeMeasurementListData, true, false) + + measurements, err := server.NewMeasurement(e.LocalEntity) + if err != nil { + return err + } + + electricalConnection, err := server.NewElectricalConnection(e.LocalEntity) + if err != nil { + return err + } + + electricalConnectionId, err := electricalConnection.GetOrAddIdForDescription(model.ElectricalConnectionDescriptionDataType{ + PowerSupplyType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + PositiveEnergyDirection: util.Ptr(model.EnergyDirectionTypeConsume), + }) + if err != nil { + return err + } + + constraints := make([]model.MeasurementConstraintsDataType, 0) + + configMethods := []func( + measurements *server.Measurement, + electricalConnection *server.ElectricalConnection, + electricalConnectionId *model.ElectricalConnectionIdType, + measurementsConstraintData *[]model.MeasurementConstraintsDataType, + ) error{ + e.configureMonitorPower, + e.configureMonitorEnergy, + e.configureMonitorCurrent, + e.configureMonitorVoltage, + e.configureMonitorFrequency, + } + + for _, configMethod := range configMethods { + if err := configMethod(measurements, electricalConnection, electricalConnectionId, &constraints); err != nil { + return err + } + } + + if len(constraints) > 0 { + measurementFeature.UpdateData( + model.FunctionTypeMeasurementConstraintsListData, + &model.MeasurementConstraintsListDataType{ + MeasurementConstraintsData: constraints, + }, nil, nil, + ) + } + + return nil +} + +func (e *MPC) configureMonitorPower( + measurements *server.Measurement, + electricalConnection *server.ElectricalConnection, + electricalConnectionId *model.ElectricalConnectionIdType, + measurementsConstraintData *[]model.MeasurementConstraintsDataType, +) error { + if e.powerConfig == nil { + return errors.New("mpc monitoring power must be configured") + } + + e.acPowerTotal = measurements.AddDescription(model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypePower), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + Unit: util.Ptr(model.UnitOfMeasurementTypeW), + ScopeType: util.Ptr(model.ScopeTypeTypeACPowerTotal), + }) + + if e.powerConfig.ValueConstraintsTotal != nil { + e.powerConfig.ValueConstraintsTotal.MeasurementId = e.acPowerTotal + *measurementsConstraintData = append(*measurementsConstraintData, *e.powerConfig.ValueConstraintsTotal) + } + + parameterDescription := model.ElectricalConnectionParameterDescriptionDataType{ + ElectricalConnectionId: electricalConnectionId, + MeasurementId: e.acPowerTotal, + VoltageType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + AcMeasuredPhases: util.Ptr(model.ElectricalConnectionPhaseNameType(e.powerConfig.ConnectedPhases)), + AcMeasuredInReferenceTo: util.Ptr(model.ElectricalConnectionPhaseNameTypeNeutral), + AcMeasurementType: util.Ptr(model.ElectricalConnectionAcMeasurementTypeTypeReal), + AcMeasurementVariant: util.Ptr(model.ElectricalConnectionMeasurandVariantTypeRms), + } + + parameterDescriptionId := electricalConnection.AddParameterDescription(parameterDescription) + if parameterDescriptionId == nil { + return errors.New("could not add parameter description") + } + + acPowerConstraints := []*model.MeasurementConstraintsDataType{ + e.powerConfig.ValueConstraintsPhaseA, + e.powerConfig.ValueConstraintsPhaseB, + e.powerConfig.ValueConstraintsPhaseC, + } + + acMeasuredPhases := []*model.ElectricalConnectionPhaseNameType{ + util.Ptr(model.ElectricalConnectionPhaseNameTypeA), + util.Ptr(model.ElectricalConnectionPhaseNameTypeB), + util.Ptr(model.ElectricalConnectionPhaseNameTypeC), + } + + for id := 0; id < len(e.acPower); id++ { + if e.powerConfig.SupportsPhases(phases[id]) { + e.acPower[id] = measurements.AddDescription(model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypePower), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + Unit: util.Ptr(model.UnitOfMeasurementTypeW), + ScopeType: util.Ptr(model.ScopeTypeTypeACPower), + }) + + if acPowerConstraints[id] != nil { + acPowerConstraints[id].MeasurementId = e.acPower[id] + *measurementsConstraintData = append(*measurementsConstraintData, *acPowerConstraints[id]) + } + + parameterDescription := model.ElectricalConnectionParameterDescriptionDataType{ + ElectricalConnectionId: electricalConnectionId, + MeasurementId: e.acPower[id], + VoltageType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + AcMeasuredPhases: acMeasuredPhases[id], + AcMeasuredInReferenceTo: util.Ptr(model.ElectricalConnectionPhaseNameTypeNeutral), + AcMeasurementType: util.Ptr(model.ElectricalConnectionAcMeasurementTypeTypeReal), + AcMeasurementVariant: util.Ptr(model.ElectricalConnectionMeasurandVariantTypeRms), + } + + parameterDescriptionId := electricalConnection.AddParameterDescription(parameterDescription) + if parameterDescriptionId == nil { + return errors.New("could not add parameter description") + } + } + } + + return nil +} + +func (e *MPC) configureMonitorEnergy( + measurements *server.Measurement, + electricalConnection *server.ElectricalConnection, + electricalConnectionId *model.ElectricalConnectionIdType, + measurementsConstraintData *[]model.MeasurementConstraintsDataType, +) error { + if e.energyConfig == nil { + return nil + } + + if e.energyConfig.ValueSourceConsumption != nil { + e.acEnergyConsumed = measurements.AddDescription(model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeEnergy), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + Unit: util.Ptr(model.UnitOfMeasurementTypeWh), + ScopeType: util.Ptr(model.ScopeTypeTypeACEnergyConsumed), + }) + if e.energyConfig.ValueConstraintsConsumption != nil { + e.energyConfig.ValueConstraintsConsumption.MeasurementId = e.acEnergyConsumed + *measurementsConstraintData = append(*measurementsConstraintData, *e.energyConfig.ValueConstraintsConsumption) + } + + parameterDescription := model.ElectricalConnectionParameterDescriptionDataType{ + ElectricalConnectionId: electricalConnectionId, + MeasurementId: e.acEnergyConsumed, + VoltageType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + AcMeasurementType: util.Ptr(model.ElectricalConnectionAcMeasurementTypeTypeReal), + } + + parameterDescriptionId := electricalConnection.AddParameterDescription(parameterDescription) + if parameterDescriptionId == nil { + return errors.New("could not add parameter description") + } + } + + if e.energyConfig.ValueSourceProduction != nil { + e.acEnergyProduced = measurements.AddDescription(model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeEnergy), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + Unit: util.Ptr(model.UnitOfMeasurementTypeWh), + ScopeType: util.Ptr(model.ScopeTypeTypeACEnergyProduced), + }) + + if e.energyConfig.ValueConstraintsProduction != nil { + e.energyConfig.ValueConstraintsProduction.MeasurementId = e.acEnergyProduced + *measurementsConstraintData = append(*measurementsConstraintData, *e.energyConfig.ValueConstraintsProduction) + } + + p4 := model.ElectricalConnectionParameterDescriptionDataType{ + ElectricalConnectionId: electricalConnectionId, + MeasurementId: e.acEnergyProduced, + VoltageType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + AcMeasurementType: util.Ptr(model.ElectricalConnectionAcMeasurementTypeTypeReal), + } + idP4 := electricalConnection.AddParameterDescription(p4) + if idP4 == nil { + return errors.New("could not add parameter description") + } + } + + return nil +} + +func (e *MPC) configureMonitorCurrent( + measurements *server.Measurement, + electricalConnection *server.ElectricalConnection, + electricalConnectionId *model.ElectricalConnectionIdType, + measurementsConstraintData *[]model.MeasurementConstraintsDataType, +) error { + if e.currentConfig == nil { + return nil + } + + acCurrentConstraints := []*model.MeasurementConstraintsDataType{ + e.currentConfig.ValueConstraintsPhaseA, + e.currentConfig.ValueConstraintsPhaseB, + e.currentConfig.ValueConstraintsPhaseC, + } + + acMeasuredPhases := []*model.ElectricalConnectionPhaseNameType{ + util.Ptr(model.ElectricalConnectionPhaseNameTypeA), + util.Ptr(model.ElectricalConnectionPhaseNameTypeB), + util.Ptr(model.ElectricalConnectionPhaseNameTypeC), + } + + for id := 0; id < len(e.acCurrent); id++ { + if e.powerConfig.SupportsPhases(phases[id]) { + e.acCurrent[id] = measurements.AddDescription(model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeCurrent), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + Unit: util.Ptr(model.UnitOfMeasurementTypeA), + ScopeType: util.Ptr(model.ScopeTypeTypeACCurrent), + }) + + if acCurrentConstraints[id] != nil { + acCurrentConstraints[id].MeasurementId = e.acCurrent[id] + *measurementsConstraintData = append(*measurementsConstraintData, *acCurrentConstraints[id]) + } + + parameterDescription := model.ElectricalConnectionParameterDescriptionDataType{ + ElectricalConnectionId: electricalConnectionId, + MeasurementId: e.acCurrent[id], + VoltageType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + AcMeasuredPhases: acMeasuredPhases[id], + AcMeasurementType: util.Ptr(model.ElectricalConnectionAcMeasurementTypeTypeReal), + AcMeasurementVariant: util.Ptr(model.ElectricalConnectionMeasurandVariantTypeRms), + } + + parameterDescriptionId := electricalConnection.AddParameterDescription(parameterDescription) + if parameterDescriptionId == nil { + return errors.New("could not add parameter description") + } + } + } + + return nil +} + +func (e *MPC) configureMonitorVoltage( + measurements *server.Measurement, + electricalConnection *server.ElectricalConnection, + electricalConnectionId *model.ElectricalConnectionIdType, + measurementsConstraintData *[]model.MeasurementConstraintsDataType, +) error { + if e.voltageConfig == nil { + return nil + } + + acVoltagePhasesFrom := []*model.ElectricalConnectionPhaseNameType{ + util.Ptr(model.ElectricalConnectionPhaseNameTypeA), + util.Ptr(model.ElectricalConnectionPhaseNameTypeB), + util.Ptr(model.ElectricalConnectionPhaseNameTypeC), + util.Ptr(model.ElectricalConnectionPhaseNameTypeA), + util.Ptr(model.ElectricalConnectionPhaseNameTypeB), + util.Ptr(model.ElectricalConnectionPhaseNameTypeC), + } + + acVoltagePhasesTo := []*model.ElectricalConnectionPhaseNameType{ + util.Ptr(model.ElectricalConnectionPhaseNameTypeNeutral), + util.Ptr(model.ElectricalConnectionPhaseNameTypeNeutral), + util.Ptr(model.ElectricalConnectionPhaseNameTypeNeutral), + util.Ptr(model.ElectricalConnectionPhaseNameTypeB), + util.Ptr(model.ElectricalConnectionPhaseNameTypeC), + util.Ptr(model.ElectricalConnectionPhaseNameTypeA), + } + + acVoltageConstraints := []*model.MeasurementConstraintsDataType{ + e.voltageConfig.ValueConstraintsPhaseA, + e.voltageConfig.ValueConstraintsPhaseB, + e.voltageConfig.ValueConstraintsPhaseC, + e.voltageConfig.ValueConstraintsPhaseAToB, + e.voltageConfig.ValueConstraintsPhaseBToC, + e.voltageConfig.ValueConstraintsPhaseCToA, + } + + for id := 0; id < len(e.acVoltage); id++ { + if e.powerConfig.SupportsPhases(phases[id]) { + if len(phases[id]) == 2 && !e.voltageConfig.SupportPhaseToPhase { + continue + } + + e.acVoltage[id] = measurements.AddDescription(model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeVoltage), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + Unit: util.Ptr(model.UnitOfMeasurementTypeV), + ScopeType: util.Ptr(model.ScopeTypeTypeACVoltage), + }) + + if acVoltageConstraints[id] != nil { + acVoltageConstraints[id].MeasurementId = e.acVoltage[id] + *measurementsConstraintData = append(*measurementsConstraintData, *acVoltageConstraints[id]) + } + + parameterDescription := model.ElectricalConnectionParameterDescriptionDataType{ + ElectricalConnectionId: electricalConnectionId, + MeasurementId: e.acVoltage[id], + VoltageType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + AcMeasuredPhases: acVoltagePhasesFrom[id], + AcMeasuredInReferenceTo: acVoltagePhasesTo[id], + AcMeasurementType: util.Ptr(model.ElectricalConnectionAcMeasurementTypeTypeApparent), + AcMeasurementVariant: util.Ptr(model.ElectricalConnectionMeasurandVariantTypeRms), + } + + parameterDescriptionId := electricalConnection.AddParameterDescription(parameterDescription) + if parameterDescriptionId == nil { + return errors.New("could not add parameter description") + } + } + } + + return nil +} + +func (e *MPC) configureMonitorFrequency( + measurements *server.Measurement, + electricalConnection *server.ElectricalConnection, + electricalConnectionId *model.ElectricalConnectionIdType, + measurementsConstraintData *[]model.MeasurementConstraintsDataType, +) error { + if e.frequencyConfig == nil { + return nil + } + + e.acFrequency = measurements.AddDescription(model.MeasurementDescriptionDataType{ + MeasurementType: util.Ptr(model.MeasurementTypeTypeFrequency), + CommodityType: util.Ptr(model.CommodityTypeTypeElectricity), + Unit: util.Ptr(model.UnitOfMeasurementTypeHz), + ScopeType: util.Ptr(model.ScopeTypeTypeACFrequency), + }) + + if e.frequencyConfig.ValueConstraints != nil { + e.frequencyConfig.ValueConstraints.MeasurementId = e.acFrequency + *measurementsConstraintData = append(*measurementsConstraintData, *e.frequencyConfig.ValueConstraints) + } + + parameterDescription := model.ElectricalConnectionParameterDescriptionDataType{ + ElectricalConnectionId: electricalConnectionId, + MeasurementId: e.acFrequency, + VoltageType: util.Ptr(model.ElectricalConnectionVoltageTypeTypeAc), + } + + parameterDescriptionId := electricalConnection.AddParameterDescription(parameterDescription) + if parameterDescriptionId == nil { + return errors.New("could not add parameter description") + } + + return nil +} + +func (e *MPC) getMeasurementDataForId(id *model.MeasurementIdType) (float64, error) { + measurements, err := server.NewMeasurement(e.LocalEntity) + if err != nil { + return 0, err + } + + data, err := measurements.GetDataForId(*id) + if err != nil { + return 0, err + } + + if data == nil { + return 0, api.ErrDataNotAvailable + } + + return data.Value.GetValue(), nil +} + +var phases = [][]string{ + {"a"}, + {"b"}, + {"c"}, + {"a", "b"}, + {"b", "c"}, + {"c", "a"}, +} diff --git a/usecases/mu/mpc/usecase_test.go b/usecases/mu/mpc/usecase_test.go new file mode 100644 index 00000000..fb7404f3 --- /dev/null +++ b/usecases/mu/mpc/usecase_test.go @@ -0,0 +1,152 @@ +package mpc + +import ( + "testing" + "time" + + "github.com/enbility/eebus-go/api" + "github.com/enbility/eebus-go/mocks" + "github.com/enbility/eebus-go/service" + shipapi "github.com/enbility/ship-go/api" + "github.com/enbility/ship-go/cert" + spineapi "github.com/enbility/spine-go/api" + spinemocks "github.com/enbility/spine-go/mocks" + "github.com/enbility/spine-go/model" + "github.com/enbility/spine-go/util" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/stretchr/testify/suite" +) + +func TestBasicSuite(t *testing.T) { + suite.Run(t, new(BasicSuite)) +} + +type BasicSuite struct { + suite.Suite + + service api.ServiceInterface + + remoteDevice spineapi.DeviceRemoteInterface + mockRemoteEntity *spinemocks.EntityRemoteInterface + monitoredEntity spineapi.EntityRemoteInterface + loadControlFeature, + deviceDiagnosisFeature, + deviceConfigurationFeature spineapi.FeatureLocalInterface + + eventCalled bool +} + +func (s *BasicSuite) Event(ski string, device spineapi.DeviceRemoteInterface, entity spineapi.EntityRemoteInterface, event api.EventType) { + s.eventCalled = true +} + +func (s *BasicSuite) BeforeTest(suiteName, testName string) { + s.eventCalled = false + cert, _ := cert.CreateCertificate("test", "test", "DE", "test") + configuration, _ := api.NewConfiguration( + "test", "test", "test", "test", + []shipapi.DeviceCategoryType{shipapi.DeviceCategoryTypeEnergyManagementSystem}, + model.DeviceTypeTypeEnergyManagementSystem, + []model.EntityTypeType{model.EntityTypeTypeInverter}, + 9999, cert, time.Second*4) + + serviceHandler := mocks.NewServiceReaderInterface(s.T()) + serviceHandler.EXPECT().ServicePairingDetailUpdate(mock.Anything, mock.Anything).Return().Maybe() + + s.service = service.NewService(configuration, serviceHandler) + _ = s.service.Setup() + + mockRemoteDevice := spinemocks.NewDeviceRemoteInterface(s.T()) + s.mockRemoteEntity = spinemocks.NewEntityRemoteInterface(s.T()) + mockRemoteFeature := spinemocks.NewFeatureRemoteInterface(s.T()) + mockRemoteDevice.EXPECT().FeatureByEntityTypeAndRole(mock.Anything, mock.Anything, mock.Anything).Return(mockRemoteFeature).Maybe() + mockRemoteDevice.EXPECT().Ski().Return(remoteSki).Maybe() + s.mockRemoteEntity.EXPECT().Device().Return(mockRemoteDevice).Maybe() + s.mockRemoteEntity.EXPECT().EntityType().Return(mock.Anything).Maybe() + entityAddress := &model.EntityAddressType{} + s.mockRemoteEntity.EXPECT().Address().Return(entityAddress).Maybe() + mockRemoteFeature.EXPECT().DataCopy(mock.Anything).Return(mock.Anything).Maybe() + mockRemoteFeature.EXPECT().Address().Return(&model.FeatureAddressType{}).Maybe() + mockRemoteFeature.EXPECT().Operations().Return(nil).Maybe() +} + +func (s *BasicSuite) Test_MpcOptionalParameters() { + localEntity := s.service.LocalDevice().EntityForType(model.EntityTypeTypeInverter) + + // required + var monitorPowerConfig = MonitorPowerConfig{ + ConnectedPhases: ConnectedPhasesABC, + ValueSourceTotal: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + } + + // the following 4 parameters are optional and can be nil + var monitorEnergyConfig = MonitorEnergyConfig{ + ValueSourceProduction: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourceConsumption: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + } + var monitorCurrentConfig = MonitorCurrentConfig{ + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + } + var monitorVoltageConfig = MonitorVoltageConfig{ + SupportPhaseToPhase: true, + ValueSourcePhaseA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseAToB: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseBToC: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueSourcePhaseCToA: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + } + var monitorFrequencyConfig = MonitorFrequencyConfig{ + ValueSource: util.Ptr(model.MeasurementValueSourceTypeMeasuredValue), + ValueConstraints: util.Ptr(model.MeasurementConstraintsDataType{ + ValueRangeMin: model.NewScaledNumberType(0), + ValueRangeMax: model.NewScaledNumberType(100), + ValueStepSize: model.NewScaledNumberType(1), + }), + } + + numOptionalParams := 4 + + // iterate over all permutations of nil/set + for i := 0; i < (1 << numOptionalParams); i++ { + // Determine which parameters to set + var optEnergyConfig *MonitorEnergyConfig + var optCurrentConfig *MonitorCurrentConfig + var optVoltageConfig *MonitorVoltageConfig + var optFrequencyConfig *MonitorFrequencyConfig + if i&1 != 0 { + optEnergyConfig = &monitorEnergyConfig + } + if i&2 != 0 { + optCurrentConfig = &monitorCurrentConfig + } + if i&4 != 0 { + optVoltageConfig = &monitorVoltageConfig + } + if i&8 != 0 { + optFrequencyConfig = &monitorFrequencyConfig + } + + mpc, err := NewMPC( + localEntity, + s.Event, + &monitorPowerConfig, + optEnergyConfig, + optCurrentConfig, + optVoltageConfig, + optFrequencyConfig, + ) + + assert.Nil(s.T(), err) + + err = mpc.AddFeatures() + assert.Nil(s.T(), err) + mpc.AddUseCase() + } +} diff --git a/usecases/usecase/events.go b/usecases/usecase/events.go index 0bab5b49..a879f8ed 100644 --- a/usecases/usecase/events.go +++ b/usecases/usecase/events.go @@ -81,7 +81,7 @@ func (u *UseCaseBase) useCaseDataUpdate( } for _, entity := range entitiesToCheck { - if !slices.Contains(u.validEntityTypes, entity.EntityType()) { + if !u.allEntityTypesValid && !slices.Contains(u.validEntityTypes, entity.EntityType()) { continue } diff --git a/usecases/usecase/testhelper_test.go b/usecases/usecase/testhelper_test.go index 77df868c..6ecaf71f 100644 --- a/usecases/usecase/testhelper_test.go +++ b/usecases/usecase/testhelper_test.go @@ -110,6 +110,7 @@ func (s *UseCaseSuite) BeforeTest(suiteName, testName string) { useCaseUpdateEvent, validActorTypes, validEntityTypes, + false, ) } diff --git a/usecases/usecase/usecase.go b/usecases/usecase/usecase.go index 17d58e36..0ebdb5b7 100644 --- a/usecases/usecase/usecase.go +++ b/usecases/usecase/usecase.go @@ -25,8 +25,9 @@ type UseCaseBase struct { availableEntityScenarios []api.RemoteEntityScenarios // map of scenarios and their availability for each compatible remote entity - validActorTypes []model.UseCaseActorType // valid remote actor types for this use case - validEntityTypes []model.EntityTypeType // valid remote entity types for this use case + validActorTypes []model.UseCaseActorType // valid remote actor types for this use case + validEntityTypes []model.EntityTypeType // valid remote entity types for this use case + allEntityTypesValid bool mux sync.Mutex } @@ -57,6 +58,7 @@ func NewUseCaseBase( useCaseUpdateEvent api.EventType, validActorTypes []model.UseCaseActorType, validEntityTypes []model.EntityTypeType, + allEntityTypesValid bool, ) *UseCaseBase { ucb := &UseCaseBase{ LocalEntity: localEntity, @@ -69,6 +71,7 @@ func NewUseCaseBase( useCaseUpdateEvent: useCaseUpdateEvent, validActorTypes: validActorTypes, validEntityTypes: validEntityTypes, + allEntityTypesValid: allEntityTypesValid, } _ = spine.Events.Subscribe(ucb) @@ -114,6 +117,10 @@ func (u *UseCaseBase) IsCompatibleEntityType(entity spineapi.EntityRemoteInterfa return false } + if u.allEntityTypesValid { + return true + } + return slices.Contains(u.validEntityTypes, entity.EntityType()) }