Merge b5c60a0 into 8799c5b

factory/api/apiResolverFactory_test.go

@@ -66,7 +66,7 @@ func createMockArgs(t *testing.T) *api.ApiResolverArgs {
 	cryptoComponents := componentsMock.GetCryptoComponents(coreComponents)
 	networkComponents := componentsMock.GetNetworkComponents(cryptoComponents)
 	dataComponents := componentsMock.GetDataComponents(coreComponents, shardCoordinator)
-	stateComponents := componentsMock.GetStateComponents(coreComponents, shardCoordinator)
+	stateComponents := componentsMock.GetStateComponents(coreComponents)
 	processComponents := componentsMock.GetProcessComponents(shardCoordinator, coreComponents, networkComponents, dataComponents, cryptoComponents, stateComponents)
 	argsB := componentsMock.GetBootStrapFactoryArgs()
 

factory/constants.go

@@ -13,8 +13,6 @@ const (
 	CryptoComponentsName = "managedCryptoComponents"
 	// DataComponentsName is the data components identifier
 	DataComponentsName = "managedDataComponents"
-	// HeartbeatComponentsName is the heartbeat components identifier
-	HeartbeatComponentsName = "managedHeartbeatComponents"
 	// HeartbeatV2ComponentsName is the heartbeat V2 components identifier
 	HeartbeatV2ComponentsName = "managedHeartbeatV2Components"
 	// NetworkComponentsName is the network components identifier

factory/heartbeat/heartbeatV2Components.go

@@ -93,25 +93,27 @@ func checkHeartbeatV2FactoryArgs(args ArgHeartbeatV2ComponentsFactory) error {
 	if check.IfNil(args.DataComponents) {
 		return errors.ErrNilDataComponentsHolder
 	}
+	if check.IfNil(args.DataComponents.Datapool()) {
+		return errors.ErrNilDataPoolsHolder
+	}
 	if check.IfNil(args.NetworkComponents) {
 		return errors.ErrNilNetworkComponentsHolder
 	}
+	if check.IfNil(args.NetworkComponents.NetworkMessenger()) {
+		return errors.ErrNilMessenger
+	}
 	if check.IfNil(args.CryptoComponents) {
 		return errors.ErrNilCryptoComponentsHolder
 	}
 	if check.IfNil(args.ProcessComponents) {
 		return errors.ErrNilProcessComponentsHolder
 	}
+	if check.IfNil(args.ProcessComponents.EpochStartTrigger()) {
+		return errors.ErrNilEpochStartTrigger
+	}
 	if check.IfNil(args.StatusCoreComponents) {
 		return errors.ErrNilStatusCoreComponents
 	}
-	if check.IfNil(args.StatusCoreComponents.AppStatusHandler()) {
-		return errors.ErrNilAppStatusHandler
-	}
-	hardforkTrigger := args.ProcessComponents.HardforkTrigger()
-	if check.IfNil(hardforkTrigger) {
-		return errors.ErrNilHardforkTrigger
-	}
 
 	return nil
 }
@@ -238,15 +240,15 @@ func (hcf *heartbeatV2ComponentsFactory) Create() (*heartbeatV2Components, error
 		HeartbeatMonitor:                    heartbeatsMonitor,
 		HeartbeatSenderInfoProvider:         heartbeatV2Sender,
 		AppStatusHandler:                    hcf.statusCoreComponents.AppStatusHandler(),
-		TimeBetweenConnectionsMetricsUpdate: time.Second * time.Duration(hcf.config.HeartbeatV2.TimeBetweenConnectionsMetricsUpdateInSec),
+		TimeBetweenConnectionsMetricsUpdate: time.Second * time.Duration(cfg.TimeBetweenConnectionsMetricsUpdateInSec),
 	}
 	statusHandler, err := status.NewMetricsUpdater(argsMetricsUpdater)
 	if err != nil {
 		return nil, err
 	}
 
 	argsDirectConnectionProcessor := processor.ArgsDirectConnectionProcessor{
-		TimeToReadDirectConnections: time.Second * time.Duration(hcf.config.HeartbeatV2.TimeToReadDirectConnectionsInSec),
+		TimeToReadDirectConnections: time.Second * time.Duration(cfg.TimeToReadDirectConnectionsInSec),
 		Messenger:                   hcf.networkComponents.NetworkMessenger(),
 		PeerShardMapper:             hcf.processComponents.PeerShardMapper(),
 		ShardCoordinator:            hcf.processComponents.ShardCoordinator(),

factory/heartbeat/heartbeatV2ComponentsHandler.go

@@ -65,6 +65,10 @@ func (mhc *managedHeartbeatV2Components) Monitor() factory.HeartbeatV2Monitor {
 	mhc.mutHeartbeatV2Components.Lock()
 	defer mhc.mutHeartbeatV2Components.Unlock()
 
+	if mhc.heartbeatV2Components == nil {
+		return nil
+	}
+
 	return mhc.monitor
 }
 

factory/heartbeat/heartbeatV2ComponentsHandler_test.go

@@ -3,13 +3,13 @@ package heartbeat_test
 import (
 	"testing"
 
-	"github.com/multiversx/mx-chain-core-go/core/check"
-	"github.com/multiversx/mx-chain-go/errors"
+	errorsMx "github.com/multiversx/mx-chain-go/errors"
+	"github.com/multiversx/mx-chain-go/factory"
 	heartbeatComp "github.com/multiversx/mx-chain-go/factory/heartbeat"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestManagedHeartbeatV2Components(t *testing.T) {
+func TestNewManagedHeartbeatV2Components(t *testing.T) {
 	t.Parallel()
 
 	defer func() {
@@ -20,23 +20,87 @@ func TestManagedHeartbeatV2Components(t *testing.T) {
 	}()
 
 	mhc, err := heartbeatComp.NewManagedHeartbeatV2Components(nil)
-	assert.True(t, check.IfNil(mhc))
-	assert.Equal(t, errors.ErrNilHeartbeatV2ComponentsFactory, err)
+	assert.Nil(t, mhc)
+	assert.Equal(t, errorsMx.ErrNilHeartbeatV2ComponentsFactory, err)
 
 	args := createMockHeartbeatV2ComponentsFactoryArgs()
 	hcf, _ := heartbeatComp.NewHeartbeatV2ComponentsFactory(args)
 	mhc, err = heartbeatComp.NewManagedHeartbeatV2Components(hcf)
-	assert.False(t, check.IfNil(mhc))
-	assert.Nil(t, err)
+	assert.NotNil(t, mhc)
+	assert.NoError(t, err)
+}
+
+func TestManagedHeartbeatV2Components_Create(t *testing.T) {
+	t.Parallel()
+
+	t.Run("invalid config should error", func(t *testing.T) {
+		t.Parallel()
+
+		args := createMockHeartbeatV2ComponentsFactoryArgs()
+		args.Config.HeartbeatV2.PeerAuthenticationTimeBetweenSendsInSec = 0 // Create will fail
+		hcf, _ := heartbeatComp.NewHeartbeatV2ComponentsFactory(args)
+		mhc, _ := heartbeatComp.NewManagedHeartbeatV2Components(hcf)
+		assert.NotNil(t, mhc)
+		err := mhc.Create()
+		assert.Error(t, err)
+	})
+	t.Run("should work with getters", func(t *testing.T) {
+		t.Parallel()
+
+		args := createMockHeartbeatV2ComponentsFactoryArgs()
+		hcf, _ := heartbeatComp.NewHeartbeatV2ComponentsFactory(args)
+		mhc, _ := heartbeatComp.NewManagedHeartbeatV2Components(hcf)
+		assert.NotNil(t, mhc)
+		assert.Nil(t, mhc.Monitor())
+
+		err := mhc.Create()
+		assert.NoError(t, err)
+		assert.NotNil(t, mhc.Monitor())
 
-	err = mhc.Create()
-	assert.Nil(t, err)
+		assert.Equal(t, factory.HeartbeatV2ComponentsName, mhc.String())
 
-	err = mhc.CheckSubcomponents()
-	assert.Nil(t, err)
+		assert.NoError(t, mhc.Close())
+	})
+}
 
-	assert.Equal(t, "managedHeartbeatV2Components", mhc.String())
+func TestManagedHeartbeatV2Components_CheckSubcomponents(t *testing.T) {
+	t.Parallel()
 
-	err = mhc.Close()
-	assert.Nil(t, err)
+	args := createMockHeartbeatV2ComponentsFactoryArgs()
+	hcf, _ := heartbeatComp.NewHeartbeatV2ComponentsFactory(args)
+	mhc, _ := heartbeatComp.NewManagedHeartbeatV2Components(hcf)
+	assert.NotNil(t, mhc)
+	assert.Equal(t, errorsMx.ErrNilHeartbeatV2Components, mhc.CheckSubcomponents())
+
+	err := mhc.Create()
+	assert.NoError(t, err)
+	assert.Nil(t, mhc.CheckSubcomponents())
+
+	assert.NoError(t, mhc.Close())
+}
+
+func TestManagedHeartbeatV2Components_Close(t *testing.T) {
+	t.Parallel()
+
+	args := createMockHeartbeatV2ComponentsFactoryArgs()
+	hcf, _ := heartbeatComp.NewHeartbeatV2ComponentsFactory(args)
+	mhc, _ := heartbeatComp.NewManagedHeartbeatV2Components(hcf)
+	assert.NotNil(t, mhc)
+	assert.NoError(t, mhc.Close())
+
+	err := mhc.Create()
+	assert.NoError(t, err)
+	assert.NoError(t, mhc.Close())
+}
+
+func TestManagedHeartbeatV2Components_IsInterfaceNil(t *testing.T) {
+	t.Parallel()
+
+	mhc, _ := heartbeatComp.NewManagedHeartbeatV2Components(nil)
+	assert.True(t, mhc.IsInterfaceNil())
+
+	args := createMockHeartbeatV2ComponentsFactoryArgs()
+	hcf, _ := heartbeatComp.NewHeartbeatV2ComponentsFactory(args)
+	mhc, _ = heartbeatComp.NewManagedHeartbeatV2Components(hcf)
+	assert.False(t, mhc.IsInterfaceNil())
 }