From 0578744ac3f5c17b5e1b22d04a1a22d6fc8c49ae Mon Sep 17 00:00:00 2001 From: Sorin Stanculeanu Date: Wed, 2 Feb 2022 17:47:21 +0200 Subject: [PATCH 1/2] added factories --- .../factory/argInterceptedDataFactory.go | 29 ++-- .../interceptedHeartbeatDataFactory.go | 50 +++++++ .../interceptedHeartbeatDataFactory_test.go | 81 ++++++++++++ .../interceptedMetaHeaderDataFactory_test.go | 27 ++-- ...nterceptedPeerAuthenticationDataFactory.go | 73 +++++++++++ ...eptedPeerAuthenticationDataFactory_test.go | 124 ++++++++++++++++++ 6 files changed, 361 insertions(+), 23 deletions(-) create mode 100644 process/interceptors/factory/interceptedHeartbeatDataFactory.go create mode 100644 process/interceptors/factory/interceptedHeartbeatDataFactory_test.go create mode 100644 process/interceptors/factory/interceptedPeerAuthenticationDataFactory.go create mode 100644 process/interceptors/factory/interceptedPeerAuthenticationDataFactory_test.go diff --git a/process/interceptors/factory/argInterceptedDataFactory.go b/process/interceptors/factory/argInterceptedDataFactory.go index 0dfa47118fa..7e4ed46ff32 100644 --- a/process/interceptors/factory/argInterceptedDataFactory.go +++ b/process/interceptors/factory/argInterceptedDataFactory.go @@ -7,6 +7,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/marshal" "github.com/ElrondNetwork/elrond-go-crypto" "github.com/ElrondNetwork/elrond-go/process" + "github.com/ElrondNetwork/elrond-go/process/heartbeat" "github.com/ElrondNetwork/elrond-go/sharding" ) @@ -39,16 +40,20 @@ type interceptedDataCryptoComponentsHolder interface { // ArgInterceptedDataFactory holds all dependencies required by the shard and meta intercepted data factory in order to create // new instances type ArgInterceptedDataFactory struct { - CoreComponents interceptedDataCoreComponentsHolder - CryptoComponents interceptedDataCryptoComponentsHolder - ShardCoordinator sharding.Coordinator - NodesCoordinator sharding.NodesCoordinator - FeeHandler process.FeeHandler - WhiteListerVerifiedTxs process.WhiteListHandler - HeaderSigVerifier process.InterceptedHeaderSigVerifier - ValidityAttester process.ValidityAttester - HeaderIntegrityVerifier process.HeaderIntegrityVerifier - EpochStartTrigger process.EpochStartTriggerHandler - ArgsParser process.ArgumentsParser - EnableSignTxWithHashEpoch uint32 + CoreComponents interceptedDataCoreComponentsHolder + CryptoComponents interceptedDataCryptoComponentsHolder + ShardCoordinator sharding.Coordinator + NodesCoordinator sharding.NodesCoordinator + FeeHandler process.FeeHandler + WhiteListerVerifiedTxs process.WhiteListHandler + HeaderSigVerifier process.InterceptedHeaderSigVerifier + ValidityAttester process.ValidityAttester + HeaderIntegrityVerifier process.HeaderIntegrityVerifier + EpochStartTrigger process.EpochStartTriggerHandler + ArgsParser process.ArgumentsParser + EnableSignTxWithHashEpoch uint32 + PeerSignatureHandler crypto.PeerSignatureHandler + SignaturesHandler heartbeat.SignaturesHandler + HeartbeatExpiryTimespanInSec int64 + PeerID core.PeerID } diff --git a/process/interceptors/factory/interceptedHeartbeatDataFactory.go b/process/interceptors/factory/interceptedHeartbeatDataFactory.go new file mode 100644 index 00000000000..b2082671cde --- /dev/null +++ b/process/interceptors/factory/interceptedHeartbeatDataFactory.go @@ -0,0 +1,50 @@ +package factory + +import ( + "github.com/ElrondNetwork/elrond-go-core/core" + "github.com/ElrondNetwork/elrond-go-core/core/check" + "github.com/ElrondNetwork/elrond-go-core/marshal" + "github.com/ElrondNetwork/elrond-go/process" + "github.com/ElrondNetwork/elrond-go/process/heartbeat" +) + +type interceptedHeartbeatDataFactory struct { + marshalizer marshal.Marshalizer + peerID core.PeerID +} + +// NewInterceptedHeartbeatDataFactory creates an instance of interceptedHeartbeatDataFactory +func NewInterceptedHeartbeatDataFactory(arg *ArgInterceptedDataFactory) (*interceptedHeartbeatDataFactory, error) { + if arg == nil { + return nil, process.ErrNilArgumentStruct + } + if check.IfNil(arg.CoreComponents.InternalMarshalizer()) { + return nil, process.ErrNilMarshalizer + } + if len(arg.PeerID) == 0 { + return nil, process.ErrEmptyPeerID + } + + return &interceptedHeartbeatDataFactory{ + marshalizer: arg.CoreComponents.InternalMarshalizer(), + peerID: arg.PeerID, + }, nil +} + +// Create creates instances of InterceptedData by unmarshalling provided buffer +func (ihdf *interceptedHeartbeatDataFactory) Create(buff []byte) (process.InterceptedData, error) { + arg := heartbeat.ArgInterceptedHeartbeat{ + ArgBaseInterceptedHeartbeat: heartbeat.ArgBaseInterceptedHeartbeat{ + DataBuff: buff, + Marshalizer: ihdf.marshalizer, + }, + PeerId: ihdf.peerID, + } + + return heartbeat.NewInterceptedHeartbeat(arg) +} + +// IsInterfaceNil returns true if there is no value under the interface +func (ihdf *interceptedHeartbeatDataFactory) IsInterfaceNil() bool { + return ihdf == nil +} diff --git a/process/interceptors/factory/interceptedHeartbeatDataFactory_test.go b/process/interceptors/factory/interceptedHeartbeatDataFactory_test.go new file mode 100644 index 00000000000..e0e8063e8ff --- /dev/null +++ b/process/interceptors/factory/interceptedHeartbeatDataFactory_test.go @@ -0,0 +1,81 @@ +package factory + +import ( + "fmt" + "strings" + "testing" + "time" + + "github.com/ElrondNetwork/elrond-go/heartbeat" + "github.com/ElrondNetwork/elrond-go/process" + "github.com/ElrondNetwork/elrond-go/process/mock" + "github.com/stretchr/testify/assert" +) + +func TestNewInterceptedHeartbeatDataFactory(t *testing.T) { + t.Parallel() + + t.Run("nil arg should error", func(t *testing.T) { + t.Parallel() + + ihdf, err := NewInterceptedHeartbeatDataFactory(nil) + assert.Nil(t, ihdf) + assert.Equal(t, process.ErrNilArgumentStruct, err) + }) + t.Run("nil InternalMarshalizer should error", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + coreComp.IntMarsh = nil + arg := createMockArgument(coreComp, cryptoComp) + + ihdf, err := NewInterceptedHeartbeatDataFactory(arg) + assert.Nil(t, ihdf) + assert.Equal(t, process.ErrNilMarshalizer, err) + }) + t.Run("empty peer id should error", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + arg := createMockArgument(coreComp, cryptoComp) + arg.PeerID = "" + + ihdf, err := NewInterceptedHeartbeatDataFactory(arg) + assert.Nil(t, ihdf) + assert.Equal(t, process.ErrEmptyPeerID, err) + }) + t.Run("should work and create", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + arg := createMockArgument(coreComp, cryptoComp) + + ihdf, err := NewInterceptedHeartbeatDataFactory(arg) + assert.False(t, ihdf.IsInterfaceNil()) + assert.Nil(t, err) + + payload := &heartbeat.Payload{ + Timestamp: time.Now().Unix(), + HardforkMessage: "hardfork message", + } + marshalizer := mock.MarshalizerMock{} + payloadBytes, err := marshalizer.Marshal(payload) + assert.Nil(t, err) + + peerAuthentication := &heartbeat.HeartbeatV2{ + Payload: payloadBytes, + VersionNumber: "version number", + NodeDisplayName: "node display name", + Identity: "identity", + Nonce: 10, + PeerSubType: 0, + } + marshalizedPAMessage, err := marshalizer.Marshal(peerAuthentication) + assert.Nil(t, err) + + interceptedData, err := ihdf.Create(marshalizedPAMessage) + assert.NotNil(t, interceptedData) + assert.Nil(t, err) + assert.True(t, strings.Contains(fmt.Sprintf("%T", interceptedData), "*heartbeat.interceptedHeartbeat")) + }) +} diff --git a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go index 799d19bda33..42aba1bb6f2 100644 --- a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go +++ b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go @@ -13,6 +13,7 @@ import ( "github.com/ElrondNetwork/elrond-go/process" "github.com/ElrondNetwork/elrond-go/process/block/interceptedBlocks" "github.com/ElrondNetwork/elrond-go/process/mock" + processMocks "github.com/ElrondNetwork/elrond-go/process/mock" "github.com/ElrondNetwork/elrond-go/testscommon" "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" "github.com/ElrondNetwork/elrond-go/testscommon/epochNotifier" @@ -85,17 +86,21 @@ func createMockArgument( cryptoComponents *mock.CryptoComponentsMock, ) *ArgInterceptedDataFactory { return &ArgInterceptedDataFactory{ - CoreComponents: coreComponents, - CryptoComponents: cryptoComponents, - ShardCoordinator: mock.NewOneShardCoordinatorMock(), - NodesCoordinator: mock.NewNodesCoordinatorMock(), - FeeHandler: createMockFeeHandler(), - HeaderSigVerifier: &mock.HeaderSigVerifierStub{}, - HeaderIntegrityVerifier: &mock.HeaderIntegrityVerifierStub{}, - ValidityAttester: &mock.ValidityAttesterStub{}, - EpochStartTrigger: &mock.EpochStartTriggerStub{}, - WhiteListerVerifiedTxs: &testscommon.WhiteListHandlerStub{}, - ArgsParser: &mock.ArgumentParserMock{}, + CoreComponents: coreComponents, + CryptoComponents: cryptoComponents, + ShardCoordinator: mock.NewOneShardCoordinatorMock(), + NodesCoordinator: mock.NewNodesCoordinatorMock(), + FeeHandler: createMockFeeHandler(), + WhiteListerVerifiedTxs: &testscommon.WhiteListHandlerStub{}, + HeaderSigVerifier: &mock.HeaderSigVerifierStub{}, + ValidityAttester: &mock.ValidityAttesterStub{}, + HeaderIntegrityVerifier: &mock.HeaderIntegrityVerifierStub{}, + EpochStartTrigger: &mock.EpochStartTriggerStub{}, + ArgsParser: &mock.ArgumentParserMock{}, + PeerSignatureHandler: &processMocks.PeerSignatureHandlerStub{}, + SignaturesHandler: &processMocks.SignaturesHandlerStub{}, + HeartbeatExpiryTimespanInSec: 30, + PeerID: "pid", } } diff --git a/process/interceptors/factory/interceptedPeerAuthenticationDataFactory.go b/process/interceptors/factory/interceptedPeerAuthenticationDataFactory.go new file mode 100644 index 00000000000..7df7bdaf2bc --- /dev/null +++ b/process/interceptors/factory/interceptedPeerAuthenticationDataFactory.go @@ -0,0 +1,73 @@ +package factory + +import ( + "github.com/ElrondNetwork/elrond-go-core/core/check" + "github.com/ElrondNetwork/elrond-go-core/marshal" + crypto "github.com/ElrondNetwork/elrond-go-crypto" + "github.com/ElrondNetwork/elrond-go/process" + "github.com/ElrondNetwork/elrond-go/process/heartbeat" +) + +const minDurationInSec = 10 + +type interceptedPeerAuthenticationDataFactory struct { + marshalizer marshal.Marshalizer + nodesCoordinator heartbeat.NodesCoordinator + signaturesHandler heartbeat.SignaturesHandler + peerSignatureHandler crypto.PeerSignatureHandler + ExpiryTimespanInSec int64 +} + +// NewInterceptedPeerAuthenticationDataFactory creates an instance of interceptedPeerAuthenticationDataFactory +func NewInterceptedPeerAuthenticationDataFactory(arg *ArgInterceptedDataFactory) (*interceptedPeerAuthenticationDataFactory, error) { + if arg == nil { + return nil, process.ErrNilArgumentStruct + } + if check.IfNil(arg.CoreComponents) { + return nil, process.ErrNilCoreComponentsHolder + } + if check.IfNil(arg.CoreComponents.InternalMarshalizer()) { + return nil, process.ErrNilMarshalizer + } + if check.IfNil(arg.NodesCoordinator) { + return nil, process.ErrNilNodesCoordinator + } + if check.IfNil(arg.SignaturesHandler) { + return nil, process.ErrNilSignaturesHandler + } + if check.IfNil(arg.PeerSignatureHandler) { + return nil, process.ErrNilPeerSignatureHandler + } + if arg.HeartbeatExpiryTimespanInSec < minDurationInSec { + return nil, process.ErrInvalidExpiryTimespan + } + + return &interceptedPeerAuthenticationDataFactory{ + marshalizer: arg.CoreComponents.InternalMarshalizer(), + nodesCoordinator: arg.NodesCoordinator, + signaturesHandler: arg.SignaturesHandler, + peerSignatureHandler: arg.PeerSignatureHandler, + ExpiryTimespanInSec: arg.HeartbeatExpiryTimespanInSec, + }, nil +} + +// Create creates instances of InterceptedData by unmarshalling provided buffer +func (ipadf *interceptedPeerAuthenticationDataFactory) Create(buff []byte) (process.InterceptedData, error) { + arg := heartbeat.ArgInterceptedPeerAuthentication{ + ArgBaseInterceptedHeartbeat: heartbeat.ArgBaseInterceptedHeartbeat{ + DataBuff: buff, + Marshalizer: ipadf.marshalizer, + }, + NodesCoordinator: ipadf.nodesCoordinator, + SignaturesHandler: ipadf.signaturesHandler, + PeerSignatureHandler: ipadf.peerSignatureHandler, + ExpiryTimespanInSec: ipadf.ExpiryTimespanInSec, + } + + return heartbeat.NewInterceptedPeerAuthentication(arg) +} + +// IsInterfaceNil returns true if there is no value under the interface +func (ipadf *interceptedPeerAuthenticationDataFactory) IsInterfaceNil() bool { + return ipadf == nil +} diff --git a/process/interceptors/factory/interceptedPeerAuthenticationDataFactory_test.go b/process/interceptors/factory/interceptedPeerAuthenticationDataFactory_test.go new file mode 100644 index 00000000000..98fc3286da6 --- /dev/null +++ b/process/interceptors/factory/interceptedPeerAuthenticationDataFactory_test.go @@ -0,0 +1,124 @@ +package factory + +import ( + "fmt" + "strings" + "testing" + "time" + + "github.com/ElrondNetwork/elrond-go/heartbeat" + "github.com/ElrondNetwork/elrond-go/process" + "github.com/ElrondNetwork/elrond-go/process/mock" + "github.com/stretchr/testify/assert" +) + +func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { + t.Parallel() + + t.Run("nil arg should error", func(t *testing.T) { + t.Parallel() + + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(nil) + assert.Nil(t, ipadf) + assert.Equal(t, process.ErrNilArgumentStruct, err) + }) + t.Run("nil CoreComponents should error", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + arg := createMockArgument(coreComp, cryptoComp) + arg.CoreComponents = nil + + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + assert.Nil(t, ipadf) + assert.Equal(t, process.ErrNilCoreComponentsHolder, err) + }) + t.Run("nil InternalMarshalizer should error", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + coreComp.IntMarsh = nil + arg := createMockArgument(coreComp, cryptoComp) + + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + assert.Nil(t, ipadf) + assert.Equal(t, process.ErrNilMarshalizer, err) + }) + t.Run("nil NodesCoordinator should error", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + arg := createMockArgument(coreComp, cryptoComp) + arg.NodesCoordinator = nil + + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + assert.Nil(t, ipadf) + assert.Equal(t, process.ErrNilNodesCoordinator, err) + }) + t.Run("nil SignaturesHandler should error", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + arg := createMockArgument(coreComp, cryptoComp) + arg.SignaturesHandler = nil + + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + assert.Nil(t, ipadf) + assert.Equal(t, process.ErrNilSignaturesHandler, err) + }) + t.Run("nil PeerSignatureHandler should error", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + arg := createMockArgument(coreComp, cryptoComp) + arg.PeerSignatureHandler = nil + + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + assert.Nil(t, ipadf) + assert.Equal(t, process.ErrNilPeerSignatureHandler, err) + }) + t.Run("invalid expiry timespan should error", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + arg := createMockArgument(coreComp, cryptoComp) + arg.HeartbeatExpiryTimespanInSec = 1 + + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + assert.Nil(t, ipadf) + assert.Equal(t, process.ErrInvalidExpiryTimespan, err) + }) + t.Run("should work and create", func(t *testing.T) { + t.Parallel() + + coreComp, cryptoComp := createMockComponentHolders() + arg := createMockArgument(coreComp, cryptoComp) + + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + assert.False(t, ipadf.IsInterfaceNil()) + assert.Nil(t, err) + + payload := &heartbeat.Payload{ + Timestamp: time.Now().Unix(), + HardforkMessage: "hardfork message", + } + marshalizer := mock.MarshalizerMock{} + payloadBytes, err := marshalizer.Marshal(payload) + assert.Nil(t, err) + + peerAuthentication := &heartbeat.PeerAuthentication{ + Pubkey: []byte("public key"), + Signature: []byte("signature"), + Pid: []byte("peer id"), + Payload: payloadBytes, + PayloadSignature: []byte("payload signature"), + } + marshalizedPAMessage, err := marshalizer.Marshal(peerAuthentication) + assert.Nil(t, err) + + interceptedData, err := ipadf.Create(marshalizedPAMessage) + assert.NotNil(t, interceptedData) + assert.Nil(t, err) + assert.True(t, strings.Contains(fmt.Sprintf("%T", interceptedData), "*heartbeat.interceptedPeerAuthentication")) + }) +} From 54f65aaa5d28f9dba4cc3cb7f21482b86f326e77 Mon Sep 17 00:00:00 2001 From: Sorin Stanculeanu Date: Wed, 2 Feb 2022 18:33:09 +0200 Subject: [PATCH 2/2] fixes after review --- .../interceptedHeartbeatDataFactory.go | 5 +--- .../interceptedHeartbeatDataFactory_test.go | 19 +++++--------- ...nterceptedPeerAuthenticationDataFactory.go | 5 +--- ...eptedPeerAuthenticationDataFactory_test.go | 25 +++++++------------ 4 files changed, 17 insertions(+), 37 deletions(-) diff --git a/process/interceptors/factory/interceptedHeartbeatDataFactory.go b/process/interceptors/factory/interceptedHeartbeatDataFactory.go index b2082671cde..48aa472a16a 100644 --- a/process/interceptors/factory/interceptedHeartbeatDataFactory.go +++ b/process/interceptors/factory/interceptedHeartbeatDataFactory.go @@ -14,10 +14,7 @@ type interceptedHeartbeatDataFactory struct { } // NewInterceptedHeartbeatDataFactory creates an instance of interceptedHeartbeatDataFactory -func NewInterceptedHeartbeatDataFactory(arg *ArgInterceptedDataFactory) (*interceptedHeartbeatDataFactory, error) { - if arg == nil { - return nil, process.ErrNilArgumentStruct - } +func NewInterceptedHeartbeatDataFactory(arg ArgInterceptedDataFactory) (*interceptedHeartbeatDataFactory, error) { if check.IfNil(arg.CoreComponents.InternalMarshalizer()) { return nil, process.ErrNilMarshalizer } diff --git a/process/interceptors/factory/interceptedHeartbeatDataFactory_test.go b/process/interceptors/factory/interceptedHeartbeatDataFactory_test.go index e0e8063e8ff..202422eaf96 100644 --- a/process/interceptors/factory/interceptedHeartbeatDataFactory_test.go +++ b/process/interceptors/factory/interceptedHeartbeatDataFactory_test.go @@ -15,13 +15,6 @@ import ( func TestNewInterceptedHeartbeatDataFactory(t *testing.T) { t.Parallel() - t.Run("nil arg should error", func(t *testing.T) { - t.Parallel() - - ihdf, err := NewInterceptedHeartbeatDataFactory(nil) - assert.Nil(t, ihdf) - assert.Equal(t, process.ErrNilArgumentStruct, err) - }) t.Run("nil InternalMarshalizer should error", func(t *testing.T) { t.Parallel() @@ -29,7 +22,7 @@ func TestNewInterceptedHeartbeatDataFactory(t *testing.T) { coreComp.IntMarsh = nil arg := createMockArgument(coreComp, cryptoComp) - ihdf, err := NewInterceptedHeartbeatDataFactory(arg) + ihdf, err := NewInterceptedHeartbeatDataFactory(*arg) assert.Nil(t, ihdf) assert.Equal(t, process.ErrNilMarshalizer, err) }) @@ -40,7 +33,7 @@ func TestNewInterceptedHeartbeatDataFactory(t *testing.T) { arg := createMockArgument(coreComp, cryptoComp) arg.PeerID = "" - ihdf, err := NewInterceptedHeartbeatDataFactory(arg) + ihdf, err := NewInterceptedHeartbeatDataFactory(*arg) assert.Nil(t, ihdf) assert.Equal(t, process.ErrEmptyPeerID, err) }) @@ -50,7 +43,7 @@ func TestNewInterceptedHeartbeatDataFactory(t *testing.T) { coreComp, cryptoComp := createMockComponentHolders() arg := createMockArgument(coreComp, cryptoComp) - ihdf, err := NewInterceptedHeartbeatDataFactory(arg) + ihdf, err := NewInterceptedHeartbeatDataFactory(*arg) assert.False(t, ihdf.IsInterfaceNil()) assert.Nil(t, err) @@ -62,7 +55,7 @@ func TestNewInterceptedHeartbeatDataFactory(t *testing.T) { payloadBytes, err := marshalizer.Marshal(payload) assert.Nil(t, err) - peerAuthentication := &heartbeat.HeartbeatV2{ + hb := &heartbeat.HeartbeatV2{ Payload: payloadBytes, VersionNumber: "version number", NodeDisplayName: "node display name", @@ -70,10 +63,10 @@ func TestNewInterceptedHeartbeatDataFactory(t *testing.T) { Nonce: 10, PeerSubType: 0, } - marshalizedPAMessage, err := marshalizer.Marshal(peerAuthentication) + marshaledHeartbeat, err := marshalizer.Marshal(hb) assert.Nil(t, err) - interceptedData, err := ihdf.Create(marshalizedPAMessage) + interceptedData, err := ihdf.Create(marshaledHeartbeat) assert.NotNil(t, interceptedData) assert.Nil(t, err) assert.True(t, strings.Contains(fmt.Sprintf("%T", interceptedData), "*heartbeat.interceptedHeartbeat")) diff --git a/process/interceptors/factory/interceptedPeerAuthenticationDataFactory.go b/process/interceptors/factory/interceptedPeerAuthenticationDataFactory.go index 7df7bdaf2bc..1267e526672 100644 --- a/process/interceptors/factory/interceptedPeerAuthenticationDataFactory.go +++ b/process/interceptors/factory/interceptedPeerAuthenticationDataFactory.go @@ -19,10 +19,7 @@ type interceptedPeerAuthenticationDataFactory struct { } // NewInterceptedPeerAuthenticationDataFactory creates an instance of interceptedPeerAuthenticationDataFactory -func NewInterceptedPeerAuthenticationDataFactory(arg *ArgInterceptedDataFactory) (*interceptedPeerAuthenticationDataFactory, error) { - if arg == nil { - return nil, process.ErrNilArgumentStruct - } +func NewInterceptedPeerAuthenticationDataFactory(arg ArgInterceptedDataFactory) (*interceptedPeerAuthenticationDataFactory, error) { if check.IfNil(arg.CoreComponents) { return nil, process.ErrNilCoreComponentsHolder } diff --git a/process/interceptors/factory/interceptedPeerAuthenticationDataFactory_test.go b/process/interceptors/factory/interceptedPeerAuthenticationDataFactory_test.go index 98fc3286da6..93da4fa6475 100644 --- a/process/interceptors/factory/interceptedPeerAuthenticationDataFactory_test.go +++ b/process/interceptors/factory/interceptedPeerAuthenticationDataFactory_test.go @@ -15,13 +15,6 @@ import ( func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { t.Parallel() - t.Run("nil arg should error", func(t *testing.T) { - t.Parallel() - - ipadf, err := NewInterceptedPeerAuthenticationDataFactory(nil) - assert.Nil(t, ipadf) - assert.Equal(t, process.ErrNilArgumentStruct, err) - }) t.Run("nil CoreComponents should error", func(t *testing.T) { t.Parallel() @@ -29,7 +22,7 @@ func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { arg := createMockArgument(coreComp, cryptoComp) arg.CoreComponents = nil - ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(*arg) assert.Nil(t, ipadf) assert.Equal(t, process.ErrNilCoreComponentsHolder, err) }) @@ -40,7 +33,7 @@ func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { coreComp.IntMarsh = nil arg := createMockArgument(coreComp, cryptoComp) - ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(*arg) assert.Nil(t, ipadf) assert.Equal(t, process.ErrNilMarshalizer, err) }) @@ -51,7 +44,7 @@ func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { arg := createMockArgument(coreComp, cryptoComp) arg.NodesCoordinator = nil - ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(*arg) assert.Nil(t, ipadf) assert.Equal(t, process.ErrNilNodesCoordinator, err) }) @@ -62,7 +55,7 @@ func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { arg := createMockArgument(coreComp, cryptoComp) arg.SignaturesHandler = nil - ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(*arg) assert.Nil(t, ipadf) assert.Equal(t, process.ErrNilSignaturesHandler, err) }) @@ -73,7 +66,7 @@ func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { arg := createMockArgument(coreComp, cryptoComp) arg.PeerSignatureHandler = nil - ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(*arg) assert.Nil(t, ipadf) assert.Equal(t, process.ErrNilPeerSignatureHandler, err) }) @@ -84,7 +77,7 @@ func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { arg := createMockArgument(coreComp, cryptoComp) arg.HeartbeatExpiryTimespanInSec = 1 - ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(*arg) assert.Nil(t, ipadf) assert.Equal(t, process.ErrInvalidExpiryTimespan, err) }) @@ -94,7 +87,7 @@ func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { coreComp, cryptoComp := createMockComponentHolders() arg := createMockArgument(coreComp, cryptoComp) - ipadf, err := NewInterceptedPeerAuthenticationDataFactory(arg) + ipadf, err := NewInterceptedPeerAuthenticationDataFactory(*arg) assert.False(t, ipadf.IsInterfaceNil()) assert.Nil(t, err) @@ -113,10 +106,10 @@ func TestNewInterceptedPeerAuthenticationDataFactory(t *testing.T) { Payload: payloadBytes, PayloadSignature: []byte("payload signature"), } - marshalizedPAMessage, err := marshalizer.Marshal(peerAuthentication) + marshaledPeerAuthentication, err := marshalizer.Marshal(peerAuthentication) assert.Nil(t, err) - interceptedData, err := ipadf.Create(marshalizedPAMessage) + interceptedData, err := ipadf.Create(marshaledPeerAuthentication) assert.NotNil(t, interceptedData) assert.Nil(t, err) assert.True(t, strings.Contains(fmt.Sprintf("%T", interceptedData), "*heartbeat.interceptedPeerAuthentication"))