fixes after merge

state/syncer/baseAccoutnsSyncer_test.go

@@ -9,16 +9,15 @@ import (
 	"github.com/multiversx/mx-chain-go/testscommon"
 	"github.com/multiversx/mx-chain-go/testscommon/hashingMocks"
 	"github.com/multiversx/mx-chain-go/testscommon/statusHandler"
-	"github.com/multiversx/mx-chain-go/trie/storageMarker"
+	"github.com/multiversx/mx-chain-go/testscommon/storageManager"
 	"github.com/stretchr/testify/require"
 )
 
 func getDefaultBaseAccSyncerArgs() syncer.ArgsNewBaseAccountsSyncer {
 	return syncer.ArgsNewBaseAccountsSyncer{
 		Hasher:                            &hashingMocks.HasherMock{},
 		Marshalizer:                       testscommon.MarshalizerMock{},
-		TrieStorageManager:                &testscommon.StorageManagerStub{},
-		StorageMarker:                     storageMarker.NewDisabledStorageMarker(),
+		TrieStorageManager:                &storageManager.StorageManagerStub{},
 		RequestHandler:                    &testscommon.RequestHandlerStub{},
 		Timeout:                           time.Second,
 		Cacher:                            testscommon.NewCacherMock(),

state/syncer/export_test.go

@@ -1,6 +1,5 @@
 package syncer
 
-<<<<<<< HEAD
 import (
 	"context"
 
@@ -24,9 +23,9 @@ func (u *userAccountsSyncer) SyncAccountDataTries(
 	ctx context.Context,
 ) error {
 	return u.syncAccountDataTries(leavesChannels, ctx)
-=======
+}
+
 // GetNumHandlers -
 func (mtnn *missingTrieNodesNotifier) GetNumHandlers() int {
 	return len(mtnn.handlers)
->>>>>>> rc/v1.6.0
 }

state/syncer/userAccountsSyncer.go

@@ -150,13 +150,9 @@ func (u *userAccountsSyncer) SyncAccounts(rootHash []byte, storageMarker common.
 		return err
 	}
 
-<<<<<<< HEAD
-	u.storageMarker.MarkStorerAsSyncedAndActive(u.trieStorageManager)
+	storageMarker.MarkStorerAsSyncedAndActive(u.trieStorageManager)
 
 	log.Debug("main trie and data tries synced", "main trie root hash", rootHash, "num data tries", len(u.dataTries))
-=======
-	storageMarker.MarkStorerAsSyncedAndActive(mainTrie.GetStorageManager())
->>>>>>> rc/v1.6.0
 
 	return nil
 }
@@ -198,12 +194,8 @@ func (u *userAccountsSyncer) createAndStartSyncer(
 		TrieSyncStatistics:        u.userAccountsSyncStatisticsHandler,
 		TimeoutHandler:            u.timeoutHandler,
 		MaxHardCapForMissingNodes: u.maxHardCapForMissingNodes,
-<<<<<<< HEAD
-		CheckNodesOnDisk:          u.checkNodesOnDisk,
-		LeavesChan:                nil, // not used for data tries
-=======
 		CheckNodesOnDisk:          checkNodesOnDisk,
->>>>>>> rc/v1.6.0
+		LeavesChan:                nil, // not used for data tries
 	}
 	trieSyncer, err := trie.CreateTrieSyncer(arg, u.trieSyncerVersion)
 	if err != nil {

state/syncer/userAccountsSyncer_test.go

@@ -17,9 +17,11 @@ import (
 	"github.com/multiversx/mx-chain-go/state"
 	"github.com/multiversx/mx-chain-go/state/syncer"
 	"github.com/multiversx/mx-chain-go/testscommon"
+	"github.com/multiversx/mx-chain-go/testscommon/storageManager"
 	"github.com/multiversx/mx-chain-go/trie"
 	"github.com/multiversx/mx-chain-go/trie/hashesHolder"
 	"github.com/multiversx/mx-chain-go/trie/keyBuilder"
+	"github.com/multiversx/mx-chain-go/trie/storageMarker"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -96,7 +98,7 @@ func getSerializedTrieNode(
 	hasher hashing.Hasher,
 ) []byte {
 	var serializedLeafNode []byte
-	tsm := &testscommon.StorageManagerStub{
+	tsm := &storageManager.StorageManagerStub{
 		PutCalled: func(key []byte, val []byte) error {
 			serializedLeafNode = val
 			return nil
@@ -113,29 +115,45 @@ func getSerializedTrieNode(
 func TestUserAccountsSyncer_SyncAccounts(t *testing.T) {
 	t.Parallel()
 
-	args := getDefaultUserAccountsSyncerArgs()
-	args.Timeout = 5 * time.Second
+	t.Run("nil storage marker", func(t *testing.T) {
+		t.Parallel()
 
-	key := []byte("rootHash")
-	serializedLeafNode := getSerializedTrieNode(key, args.Marshalizer, args.Hasher)
-	itn, err := trie.NewInterceptedTrieNode(serializedLeafNode, args.Hasher)
-	require.Nil(t, err)
+		args := getDefaultUserAccountsSyncerArgs()
+		s, err := syncer.NewUserAccountsSyncer(args)
+		assert.Nil(t, err)
+		assert.NotNil(t, s)
 
-	args.TrieStorageManager = &testscommon.StorageManagerStub{
-		GetCalled: func(b []byte) ([]byte, error) {
-			return serializedLeafNode, nil
-		},
-	}
+		err = s.SyncAccounts([]byte("rootHash"), nil)
+		assert.Equal(t, syncer.ErrNilStorageMarker, err)
+	})
 
-	cacher := testscommon.NewCacherMock()
-	cacher.Put(key, itn, 0)
-	args.Cacher = cacher
+	t.Run("should work", func(t *testing.T) {
+		t.Parallel()
 
-	s, err := syncer.NewUserAccountsSyncer(args)
-	require.Nil(t, err)
+		args := getDefaultUserAccountsSyncerArgs()
+		args.Timeout = 5 * time.Second
 
-	err = s.SyncAccounts(key)
-	require.Nil(t, err)
+		key := []byte("rootHash")
+		serializedLeafNode := getSerializedTrieNode(key, args.Marshalizer, args.Hasher)
+		itn, err := trie.NewInterceptedTrieNode(serializedLeafNode, args.Hasher)
+		require.Nil(t, err)
+
+		args.TrieStorageManager = &storageManager.StorageManagerStub{
+			GetCalled: func(b []byte) ([]byte, error) {
+				return serializedLeafNode, nil
+			},
+		}
+
+		cacher := testscommon.NewCacherMock()
+		cacher.Put(key, itn, 0)
+		args.Cacher = cacher
+
+		s, err := syncer.NewUserAccountsSyncer(args)
+		require.Nil(t, err)
+
+		err = s.SyncAccounts(key, storageMarker.NewDisabledStorageMarker())
+		require.Nil(t, err)
+	})
 }
 
 func getDefaultTrieParameters() (common.StorageManager, marshal.Marshalizer, hashing.Hasher, uint) {
@@ -156,6 +174,7 @@ func getDefaultTrieParameters() (common.StorageManager, marshal.Marshalizer, has
 		GeneralConfig:          generalCfg,
 		CheckpointHashesHolder: hashesHolder.NewCheckpointHashesHolder(10000000, testscommon.HashSize),
 		IdleProvider:           &testscommon.ProcessStatusHandlerStub{},
+		Identifier:             "identifier",
 	}
 
 	trieStorageManager, _ := trie.NewTrieStorageManager(args)
@@ -195,7 +214,7 @@ func TestUserAccountsSyncer_SyncAccountDataTries(t *testing.T) {
 		itn, err := trie.NewInterceptedTrieNode(serializedLeafNode, args.Hasher)
 		require.Nil(t, err)
 
-		args.TrieStorageManager = &testscommon.StorageManagerStub{
+		args.TrieStorageManager = &storageManager.StorageManagerStub{
 			GetCalled: func(b []byte) ([]byte, error) {
 				return serializedLeafNode, nil
 			},
@@ -257,7 +276,7 @@ func TestUserAccountsSyncer_SyncAccountDataTries(t *testing.T) {
 		itn, err := trie.NewInterceptedTrieNode(serializedLeafNode, args.Hasher)
 		require.Nil(t, err)
 
-		args.TrieStorageManager = &testscommon.StorageManagerStub{
+		args.TrieStorageManager = &storageManager.StorageManagerStub{
 			GetCalled: func(b []byte) ([]byte, error) {
 				return serializedLeafNode, nil
 			},
@@ -301,6 +320,66 @@ func TestUserAccountsSyncer_SyncAccountDataTries(t *testing.T) {
 	})
 }
 
+func TestUserAccountsSyncer_MissingDataTrieNodeFound(t *testing.T) {
+	t.Parallel()
+
+	numNodesSynced := 0
+	numProcessedCalled := 0
+	setNumMissingCalled := 0
+	args := syncer.ArgsNewUserAccountsSyncer{
+		ArgsNewBaseAccountsSyncer: getDefaultBaseAccSyncerArgs(),
+		ShardId:                   0,
+		Throttler:                 &mock.ThrottlerStub{},
+		AddressPubKeyConverter:    &testscommon.PubkeyConverterStub{},
+	}
+	args.TrieStorageManager = &storageManager.StorageManagerStub{
+		PutInEpochCalled: func(_ []byte, _ []byte, _ uint32) error {
+			numNodesSynced++
+			return nil
+		},
+	}
+	args.UserAccountsSyncStatisticsHandler = &testscommon.SizeSyncStatisticsHandlerStub{
+		AddNumProcessedCalled: func(value int) {
+			numProcessedCalled++
+		},
+		SetNumMissingCalled: func(rootHash []byte, value int) {
+			setNumMissingCalled++
+			assert.Equal(t, 0, value)
+		},
+	}
+
+	var serializedLeafNode []byte
+	tsm := &storageManager.StorageManagerStub{
+		PutCalled: func(key []byte, val []byte) error {
+			serializedLeafNode = val
+			return nil
+		},
+	}
+
+	tr, _ := trie.NewTrie(tsm, args.Marshalizer, args.Hasher, 5)
+	key := []byte("key")
+	value := []byte("value")
+	_ = tr.Update(key, value)
+	rootHash, _ := tr.RootHash()
+	_ = tr.Commit()
+
+	args.Cacher = &testscommon.CacherStub{
+		GetCalled: func(key []byte) (value interface{}, ok bool) {
+			interceptedNode, _ := trie.NewInterceptedTrieNode(serializedLeafNode, args.Hasher)
+			return interceptedNode, true
+		},
+	}
+
+	syncer, _ := syncer.NewUserAccountsSyncer(args)
+	// test that timeout watchdog is reset
+	time.Sleep(args.Timeout * 2)
+	syncer.MissingDataTrieNodeFound(rootHash)
+
+	assert.Equal(t, 1, numNodesSynced)
+	assert.Equal(t, 1, numProcessedCalled)
+	assert.Equal(t, 1, setNumMissingCalled)
+}
+
 func TestUserAccountsSyncer_IsInterfaceNil(t *testing.T) {
 	t.Parallel()
 

state/syncer/validatorAccountsSyncer.go

@@ -88,11 +88,7 @@ func (v *validatorAccountsSyncer) SyncAccounts(rootHash []byte, storageMarker co
 		return err
 	}
 
-<<<<<<< HEAD
-	v.storageMarker.MarkStorerAsSyncedAndActive(v.trieStorageManager)
-=======
-	storageMarker.MarkStorerAsSyncedAndActive(mainTrie.GetStorageManager())
->>>>>>> rc/v1.6.0
+	storageMarker.MarkStorerAsSyncedAndActive(v.trieStorageManager)
 
 	return nil
 }