From df51a93d93a8f810fcb6ee8c64f9dd3ce942c9eb Mon Sep 17 00:00:00 2001 From: jules01 Date: Thu, 30 Mar 2023 20:15:45 +0300 Subject: [PATCH 1/4] - minor refactoring in storage package - added unit tests --- storage/cache/cache_test.go | 165 ++++++ storage/database/db_test.go | 73 +++ .../directoryhandler/directoryReader_test.go | 178 ++++-- storage/disabled/errorDisabledPersister.go | 57 ++ .../disabled/errorDisabledPersister_test.go | 91 +++ storage/factory/disabledPersister.go | 52 -- storage/factory/openStorage_test.go | 47 ++ storage/factory/persisterFactory.go | 3 +- storage/factory/persisterFactory_test.go | 90 +++ ...rerFactory.go => storageServiceFactory.go} | 52 +- storage/factory/storageServiceFactory_test.go | 528 ++++++++++++++++++ storage/latestData/latestDataProvider_test.go | 8 + storage/mock/storedDataFactoryStub.go | 20 + storage/pathmanager/pathManager_test.go | 33 +- storage/pruning/pruningStorer_test.go | 164 ++++++ storage/pruning/triePruningStorer_test.go | 31 + storage/storageunit/storageunit_test.go | 173 ++++++ storage/txcache/txcache_test.go | 97 ++++ 18 files changed, 1728 insertions(+), 134 deletions(-) create mode 100644 storage/cache/cache_test.go create mode 100644 storage/database/db_test.go create mode 100644 storage/disabled/errorDisabledPersister.go create mode 100644 storage/disabled/errorDisabledPersister_test.go delete mode 100644 storage/factory/disabledPersister.go create mode 100644 storage/factory/persisterFactory_test.go rename storage/factory/{pruningStorerFactory.go => storageServiceFactory.go} (93%) create mode 100644 storage/factory/storageServiceFactory_test.go create mode 100644 storage/mock/storedDataFactoryStub.go create mode 100644 storage/storageunit/storageunit_test.go create mode 100644 storage/txcache/txcache_test.go diff --git a/storage/cache/cache_test.go b/storage/cache/cache_test.go new file mode 100644 index 00000000000..99a1731e5cb --- /dev/null +++ b/storage/cache/cache_test.go @@ -0,0 +1,165 @@ +package cache + +import ( + "testing" + "time" + + "github.com/multiversx/mx-chain-go/testscommon" + "github.com/stretchr/testify/assert" +) + +func TestNewTimeCache_ShouldWork(t *testing.T) { + t.Parallel() + + instance := NewTimeCache(0) + assert.NotNil(t, instance) +} + +func TestNewTimeCacher(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + args := ArgTimeCacher{ + DefaultSpan: time.Second - time.Nanosecond, + CacheExpiry: time.Second, + } + + instance, err := NewTimeCacher(args) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + args := ArgTimeCacher{ + DefaultSpan: time.Second, + CacheExpiry: time.Second, + } + + instance, err := NewTimeCacher(args) + assert.NotNil(t, instance) + assert.Nil(t, err) + }) +} + +func TestNewLRUCache(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + instance, err := NewLRUCache(0) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + instance, err := NewLRUCache(1) + assert.NotNil(t, instance) + assert.Nil(t, err) + }) +} + +func TestNewPeerTimeCache(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + instance, err := NewPeerTimeCache(nil) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + instance, err := NewPeerTimeCache(&testscommon.TimeCacheStub{}) + assert.NotNil(t, instance) + assert.Nil(t, err) + }) +} + +func TestNewCapacityLRU(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + instance, err := NewCapacityLRU(0, 1) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + instance, err := NewCapacityLRU(1, 1) + assert.NotNil(t, instance) + assert.Nil(t, err) + }) +} + +func TestNewLRUCacheWithEviction(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + instance, err := NewLRUCacheWithEviction(0, nil) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + t.Run("nil handler should work", func(t *testing.T) { + t.Parallel() + + instance, err := NewLRUCacheWithEviction(1, nil) + assert.NotNil(t, instance) + assert.Nil(t, err) + }) + t.Run("with handler should work", func(t *testing.T) { + t.Parallel() + + instance, err := NewLRUCacheWithEviction(1, func(key interface{}, value interface{}) {}) + assert.NotNil(t, instance) + assert.Nil(t, err) + }) + }) +} + +func TestNewImmunityCache(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + config := CacheConfig{ + MaxNumBytes: 0, + MaxNumItems: 0, + NumChunks: 0, + Name: "test", + NumItemsToPreemptivelyEvict: 0, + } + instance, err := NewImmunityCache(config) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + config := CacheConfig{ + MaxNumBytes: 4, + MaxNumItems: 4, + NumChunks: 1, + Name: "test", + NumItemsToPreemptivelyEvict: 1, + } + instance, err := NewImmunityCache(config) + assert.NotNil(t, instance) + assert.Nil(t, err) + }) +} diff --git a/storage/database/db_test.go b/storage/database/db_test.go new file mode 100644 index 00000000000..d04aaa2a78d --- /dev/null +++ b/storage/database/db_test.go @@ -0,0 +1,73 @@ +package database + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestNewMemDB(t *testing.T) { + t.Parallel() + + instance := NewMemDB() + assert.NotNil(t, instance) +} + +func TestNewlruDB(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + instance, err := NewlruDB(0) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + instance, err := NewlruDB(1) + assert.NotNil(t, instance) + assert.Nil(t, err) + }) +} + +func TestNewLevelDB(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + instance, err := NewLevelDB(t.TempDir(), 0, 0, 0) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + instance, err := NewLevelDB(t.TempDir(), 1, 1, 1) + assert.NotNil(t, instance) + assert.Nil(t, err) + _ = instance.Close() + }) +} + +func TestNewSerialDB(t *testing.T) { + t.Parallel() + + t.Run("invalid argument should error", func(t *testing.T) { + t.Parallel() + + instance, err := NewSerialDB(t.TempDir(), 0, 0, 0) + assert.Nil(t, instance) + assert.NotNil(t, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + instance, err := NewSerialDB(t.TempDir(), 1, 1, 1) + assert.NotNil(t, instance) + assert.Nil(t, err) + _ = instance.Close() + }) +} diff --git a/storage/directoryhandler/directoryReader_test.go b/storage/directoryhandler/directoryReader_test.go index 36be200c69d..f3a66a30529 100644 --- a/storage/directoryhandler/directoryReader_test.go +++ b/storage/directoryhandler/directoryReader_test.go @@ -1,74 +1,158 @@ package directoryhandler import ( + "fmt" "os" "path/filepath" "testing" + "github.com/multiversx/mx-chain-core-go/core/check" "github.com/stretchr/testify/assert" ) -func TestDirectoryReaderListFilesAsString(t *testing.T) { - t.Parallel() +const invalidPath = "\\/\\/\\/\\/" - dirName := t.TempDir() +func TestNewDirectoryReader(t *testing.T) { + t.Parallel() - file1 := "file1" - file2 := "file2" - dir1 := "dir1" - _, _ = os.Create(filepath.Join(dirName, file1)) - _, _ = os.Create(filepath.Join(dirName, file2)) - _ = os.Mkdir(filepath.Join(dirName, dir1), os.ModePerm) + instance := NewDirectoryReader() + assert.NotNil(t, instance) + assert.False(t, check.IfNil(instance)) +} - dirReader := NewDirectoryReader() +func TestDirectoryReaderListFilesAsString(t *testing.T) { + t.Parallel() - filesName, err := dirReader.ListFilesAsString(dirName) - assert.Nil(t, err) - assert.Equal(t, 2, len(filesName)) - assert.True(t, contains(filesName, file1)) - assert.True(t, contains(filesName, file2)) + t.Run("invalid path should error", func(t *testing.T) { + t.Parallel() + + dirReader := NewDirectoryReader() + + filesName, err := dirReader.ListFilesAsString(invalidPath) + assert.NotNil(t, err) + assert.Equal(t, "*fs.PathError", fmt.Sprintf("%T", err)) + assert.Nil(t, filesName) + }) + t.Run("empty directory should error", func(t *testing.T) { + t.Parallel() + + dirReader := NewDirectoryReader() + + filesName, err := dirReader.ListFilesAsString(t.TempDir()) + expectedErrorString := "no file in provided directory" + assert.Equal(t, expectedErrorString, err.Error()) + assert.Nil(t, filesName) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + dirName := t.TempDir() + + file1 := "file1" + file2 := "file2" + dir1 := "dir1" + _, _ = os.Create(filepath.Join(dirName, file1)) + _, _ = os.Create(filepath.Join(dirName, file2)) + _ = os.Mkdir(filepath.Join(dirName, dir1), os.ModePerm) + + dirReader := NewDirectoryReader() + + filesName, err := dirReader.ListFilesAsString(dirName) + assert.Nil(t, err) + assert.Equal(t, 2, len(filesName)) + assert.True(t, contains(filesName, file1)) + assert.True(t, contains(filesName, file2)) + }) } func TestDirectoryReaderListDirectoriesAsString(t *testing.T) { t.Parallel() - dirName := t.TempDir() - - file1 := "file1" - file2 := "file2" - dir1 := "dir1" - _, _ = os.Create(filepath.Join(dirName, file1)) - _, _ = os.Create(filepath.Join(dirName, file2)) - _ = os.Mkdir(filepath.Join(dirName, dir1), os.ModePerm) - - dirReader := NewDirectoryReader() - - directoriesNames, err := dirReader.ListDirectoriesAsString(dirName) - assert.Nil(t, err) - assert.Equal(t, 1, len(directoriesNames)) - assert.True(t, contains(directoriesNames, dir1)) + t.Run("invalid path should error", func(t *testing.T) { + t.Parallel() + + dirReader := NewDirectoryReader() + + directoriesNames, err := dirReader.ListDirectoriesAsString(invalidPath) + assert.NotNil(t, err) + assert.Equal(t, "*fs.PathError", fmt.Sprintf("%T", err)) + assert.Nil(t, directoriesNames) + }) + t.Run("empty directory should error", func(t *testing.T) { + t.Parallel() + + dirReader := NewDirectoryReader() + + directoriesNames, err := dirReader.ListDirectoriesAsString(t.TempDir()) + expectedErrorString := "no sub-directory in provided directory" + assert.Equal(t, expectedErrorString, err.Error()) + assert.Nil(t, directoriesNames) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + dirName := t.TempDir() + + file1 := "file1" + file2 := "file2" + dir1 := "dir1" + _, _ = os.Create(filepath.Join(dirName, file1)) + _, _ = os.Create(filepath.Join(dirName, file2)) + _ = os.Mkdir(filepath.Join(dirName, dir1), os.ModePerm) + + dirReader := NewDirectoryReader() + + directoriesNames, err := dirReader.ListDirectoriesAsString(dirName) + assert.Nil(t, err) + assert.Equal(t, 1, len(directoriesNames)) + assert.True(t, contains(directoriesNames, dir1)) + }) } func TestDirectoryReaderListAllAsString(t *testing.T) { t.Parallel() - dirName := t.TempDir() - - file1 := "file1" - file2 := "file2" - dir1 := "dir1" - _, _ = os.Create(filepath.Join(dirName, file1)) - _, _ = os.Create(filepath.Join(dirName, file2)) - _ = os.Mkdir(filepath.Join(dirName, dir1), os.ModePerm) - - dirReader := NewDirectoryReader() - - allNames, err := dirReader.ListAllAsString(dirName) - assert.Nil(t, err) - assert.Equal(t, 3, len(allNames)) - assert.True(t, contains(allNames, file1)) - assert.True(t, contains(allNames, file2)) - assert.True(t, contains(allNames, dir1)) + t.Run("invalid path should error", func(t *testing.T) { + t.Parallel() + + dirReader := NewDirectoryReader() + + allNames, err := dirReader.ListAllAsString(invalidPath) + assert.NotNil(t, err) + assert.Equal(t, "*fs.PathError", fmt.Sprintf("%T", err)) + assert.Nil(t, allNames) + }) + t.Run("empty directory should error", func(t *testing.T) { + t.Parallel() + + dirReader := NewDirectoryReader() + + allNames, err := dirReader.ListAllAsString(t.TempDir()) + expectedErrorString := "no file or directory in provided directory" + assert.Equal(t, expectedErrorString, err.Error()) + assert.Nil(t, allNames) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + dirName := t.TempDir() + + file1 := "file1" + file2 := "file2" + dir1 := "dir1" + _, _ = os.Create(filepath.Join(dirName, file1)) + _, _ = os.Create(filepath.Join(dirName, file2)) + _ = os.Mkdir(filepath.Join(dirName, dir1), os.ModePerm) + + dirReader := NewDirectoryReader() + + allNames, err := dirReader.ListAllAsString(dirName) + assert.Nil(t, err) + assert.Equal(t, 3, len(allNames)) + assert.True(t, contains(allNames, file1)) + assert.True(t, contains(allNames, file2)) + assert.True(t, contains(allNames, dir1)) + }) } func contains(s []string, e string) bool { diff --git a/storage/disabled/errorDisabledPersister.go b/storage/disabled/errorDisabledPersister.go new file mode 100644 index 00000000000..5ea67e4bfb0 --- /dev/null +++ b/storage/disabled/errorDisabledPersister.go @@ -0,0 +1,57 @@ +package disabled + +import ( + "fmt" +) + +type errorDisabledPersister struct { +} + +// NewErrorDisabledPersister returns a new instance of this disabled persister that errors on all operations +func NewErrorDisabledPersister() *errorDisabledPersister { + return &errorDisabledPersister{} +} + +// Put returns error +func (disabled *errorDisabledPersister) Put(_, _ []byte) error { + return fmt.Errorf("disabledPersister.Put") +} + +// Get returns error +func (disabled *errorDisabledPersister) Get(_ []byte) ([]byte, error) { + return nil, fmt.Errorf("disabledPersister.Get") +} + +// Has returns error +func (disabled *errorDisabledPersister) Has(_ []byte) error { + return fmt.Errorf("disabledPersister.Has") +} + +// Close returns error +func (disabled *errorDisabledPersister) Close() error { + return fmt.Errorf("disabledPersister.Close") +} + +// Remove returns error +func (disabled *errorDisabledPersister) Remove(_ []byte) error { + return fmt.Errorf("disabledPersister.Remove") +} + +// Destroy does nothing +func (disabled *errorDisabledPersister) Destroy() error { + return fmt.Errorf("disabledPersister.Destroy") +} + +// DestroyClosed returns error +func (disabled *errorDisabledPersister) DestroyClosed() error { + return fmt.Errorf("disabledPersister.DestroyClosed") +} + +// RangeKeys does nothing +func (disabled *errorDisabledPersister) RangeKeys(_ func(key []byte, val []byte) bool) { +} + +// IsInterfaceNil returns true if there is no value under the interface +func (disabled *errorDisabledPersister) IsInterfaceNil() bool { + return disabled == nil +} diff --git a/storage/disabled/errorDisabledPersister_test.go b/storage/disabled/errorDisabledPersister_test.go new file mode 100644 index 00000000000..1e429091026 --- /dev/null +++ b/storage/disabled/errorDisabledPersister_test.go @@ -0,0 +1,91 @@ +package disabled + +import "github.com/multiversx/mx-chain-core-go/core/check" + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestNewErrorDisabledPersister(t *testing.T) { + t.Parallel() + + disabled := NewErrorDisabledPersister() + assert.False(t, check.IfNil(disabled)) +} + +func TestErrorDisabledPersister_MethodsShouldError(t *testing.T) { + t.Parallel() + + disabled := NewErrorDisabledPersister() + t.Run("Put should error", func(t *testing.T) { + t.Parallel() + + expectedErrorString := "disabledPersister.Put" + err := disabled.Put(nil, nil) + assert.Equal(t, expectedErrorString, err.Error()) + }) + t.Run("Get should error", func(t *testing.T) { + t.Parallel() + + expectedErrorString := "disabledPersister.Get" + value, err := disabled.Get(nil) + assert.Equal(t, expectedErrorString, err.Error()) + assert.Nil(t, value) + }) + t.Run("Has should error", func(t *testing.T) { + t.Parallel() + + expectedErrorString := "disabledPersister.Has" + err := disabled.Has(nil) + assert.Equal(t, expectedErrorString, err.Error()) + }) + t.Run("Close should error", func(t *testing.T) { + t.Parallel() + + expectedErrorString := "disabledPersister.Close" + err := disabled.Close() + assert.Equal(t, expectedErrorString, err.Error()) + }) + t.Run("Remove should error", func(t *testing.T) { + t.Parallel() + + expectedErrorString := "disabledPersister.Remove" + err := disabled.Remove(nil) + assert.Equal(t, expectedErrorString, err.Error()) + }) + t.Run("Destroy should error", func(t *testing.T) { + t.Parallel() + + expectedErrorString := "disabledPersister.Destroy" + err := disabled.Destroy() + assert.Equal(t, expectedErrorString, err.Error()) + }) + t.Run("DestroyClosed should error", func(t *testing.T) { + t.Parallel() + + expectedErrorString := "disabledPersister.DestroyClosed" + err := disabled.DestroyClosed() + assert.Equal(t, expectedErrorString, err.Error()) + }) +} + +func TestErrorDisabledPersister_RangeKeys(t *testing.T) { + t.Parallel() + + disabled := NewErrorDisabledPersister() + t.Run("nil handler should not panic", func(t *testing.T) { + t.Parallel() + + assert.NotPanics(t, func() { + disabled.RangeKeys(nil) + }) + }) + t.Run("handler should not be called", func(t *testing.T) { + disabled.RangeKeys(func(key []byte, val []byte) bool { + assert.Fail(t, "should have not called the handler") + return false + }) + }) +} diff --git a/storage/factory/disabledPersister.go b/storage/factory/disabledPersister.go deleted file mode 100644 index 66a6390387b..00000000000 --- a/storage/factory/disabledPersister.go +++ /dev/null @@ -1,52 +0,0 @@ -package factory - -import ( - "fmt" -) - -type disabledPersister struct { -} - -// Put returns error -func (dp *disabledPersister) Put(_, _ []byte) error { - return fmt.Errorf("disabledPersister.Put") -} - -// Get returns error -func (dp *disabledPersister) Get(_ []byte) ([]byte, error) { - return nil, fmt.Errorf("disabledPersister.Get") -} - -// Has returns error -func (dp *disabledPersister) Has(_ []byte) error { - return fmt.Errorf("disabledPersister.Has") -} - -// Close returns error -func (dp *disabledPersister) Close() error { - return fmt.Errorf("disabledPersister.Close") -} - -// Remove returns error -func (dp *disabledPersister) Remove(_ []byte) error { - return fmt.Errorf("disabledPersister.Remove") -} - -// Destroy does nothing -func (dp *disabledPersister) Destroy() error { - return fmt.Errorf("disabledPersister.Destroy") -} - -// DestroyClosed returns error -func (dp *disabledPersister) DestroyClosed() error { - return fmt.Errorf("disabledPersister.DestroyClosed") -} - -// RangeKeys does nothing -func (dp *disabledPersister) RangeKeys(_ func(key []byte, val []byte) bool) { -} - -// IsInterfaceNil returns true if there is no value under the interface -func (dp *disabledPersister) IsInterfaceNil() bool { - return dp == nil -} diff --git a/storage/factory/openStorage_test.go b/storage/factory/openStorage_test.go index 8340db9c563..147772885b1 100644 --- a/storage/factory/openStorage_test.go +++ b/storage/factory/openStorage_test.go @@ -140,5 +140,52 @@ func TestGetMostRecentBootstrapStorageUnit(t *testing.T) { storer, err := suoh.GetMostRecentStorageUnit(generalConfig.BootstrapStorage.DB) assert.NoError(t, err) assert.NotNil(t, storer) +} + +func TestStorageUnitOpenHandler_OpenDB(t *testing.T) { + t.Parallel() + + tempDir := t.TempDir() + args := createMockArgsOpenStorageUnits() + args.LatestStorageDataProvider = &mock.LatestStorageDataProviderStub{ + GetParentDirectoryCalled: func() string { + return tempDir + }, + } + suoh, _ := NewStorageUnitOpenHandler(args) + + // do not run these in parallel as they are using the same temp dir + t.Run("create DB fails, should error", func(t *testing.T) { + dbConfig := config.DBConfig{ + FilePath: "Test", + Type: "invalid DB type", + BatchDelaySeconds: 5, + MaxBatchSize: 100, + MaxOpenFiles: 10, + UseTmpAsFilePath: false, + } + + storerInstance, err := suoh.OpenDB(dbConfig, 0, 0) + assert.NotNil(t, err) + expectedErrorString := "not supported db type" + assert.Equal(t, expectedErrorString, err.Error()) + assert.True(t, check.IfNil(storerInstance)) + }) + t.Run("should work", func(t *testing.T) { + dbConfig := config.DBConfig{ + FilePath: "Test", + Type: "LvlDBSerial", + BatchDelaySeconds: 5, + MaxBatchSize: 100, + MaxOpenFiles: 10, + UseTmpAsFilePath: false, + } + + storerInstance, err := suoh.OpenDB(dbConfig, 0, 0) + assert.Nil(t, err) + assert.False(t, check.IfNil(storerInstance)) + + _ = storerInstance.Close() + }) } diff --git a/storage/factory/persisterFactory.go b/storage/factory/persisterFactory.go index 7bfb8cee594..55b3d45806a 100644 --- a/storage/factory/persisterFactory.go +++ b/storage/factory/persisterFactory.go @@ -6,6 +6,7 @@ import ( "github.com/multiversx/mx-chain-go/config" "github.com/multiversx/mx-chain-go/storage" "github.com/multiversx/mx-chain-go/storage/database" + "github.com/multiversx/mx-chain-go/storage/disabled" "github.com/multiversx/mx-chain-go/storage/storageunit" ) @@ -47,7 +48,7 @@ func (pf *PersisterFactory) Create(path string) (storage.Persister, error) { // CreateDisabled will return a new disabled persister func (pf *PersisterFactory) CreateDisabled() storage.Persister { - return &disabledPersister{} + return disabled.NewErrorDisabledPersister() } // IsInterfaceNil returns true if there is no value under the interface diff --git a/storage/factory/persisterFactory_test.go b/storage/factory/persisterFactory_test.go new file mode 100644 index 00000000000..3443c5941fe --- /dev/null +++ b/storage/factory/persisterFactory_test.go @@ -0,0 +1,90 @@ +package factory + +import ( + "fmt" + "testing" + + "github.com/multiversx/mx-chain-core-go/core/check" + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/storage" + "github.com/stretchr/testify/assert" +) + +func createDBConfig(dbType string) config.DBConfig { + return config.DBConfig{ + FilePath: "TEST", + Type: dbType, + BatchDelaySeconds: 5, + MaxBatchSize: 100, + MaxOpenFiles: 10, + UseTmpAsFilePath: false, + } +} + +func TestNewPersisterFactory(t *testing.T) { + t.Parallel() + + factoryInstance := NewPersisterFactory(createDBConfig("LvlDB")) + assert.False(t, check.IfNil(factoryInstance)) +} + +func TestPersisterFactory_Create(t *testing.T) { + t.Parallel() + + t.Run("empty path should error", func(t *testing.T) { + t.Parallel() + + factoryInstance := NewPersisterFactory(createDBConfig("LvlDB")) + persisterInstance, err := factoryInstance.Create("") + assert.True(t, check.IfNil(persisterInstance)) + expectedErrString := "invalid file path" + assert.Equal(t, expectedErrString, err.Error()) + }) + t.Run("unknown type should error", func(t *testing.T) { + t.Parallel() + + factoryInstance := NewPersisterFactory(createDBConfig("invalid type")) + persisterInstance, err := factoryInstance.Create(t.TempDir()) + assert.True(t, check.IfNil(persisterInstance)) + assert.Equal(t, storage.ErrNotSupportedDBType, err) + }) + t.Run("for LvlDB should work", func(t *testing.T) { + t.Parallel() + + factoryInstance := NewPersisterFactory(createDBConfig("LvlDB")) + persisterInstance, err := factoryInstance.Create(t.TempDir()) + assert.Nil(t, err) + assert.False(t, check.IfNil(persisterInstance)) + assert.Equal(t, "*leveldb.DB", fmt.Sprintf("%T", persisterInstance)) + _ = persisterInstance.Close() + }) + t.Run("for LvlDBSerial should work", func(t *testing.T) { + t.Parallel() + + factoryInstance := NewPersisterFactory(createDBConfig("LvlDBSerial")) + persisterInstance, err := factoryInstance.Create(t.TempDir()) + assert.Nil(t, err) + assert.False(t, check.IfNil(persisterInstance)) + assert.Equal(t, "*leveldb.SerialDB", fmt.Sprintf("%T", persisterInstance)) + _ = persisterInstance.Close() + }) + t.Run("for MemoryDB should work", func(t *testing.T) { + t.Parallel() + + factoryInstance := NewPersisterFactory(createDBConfig("MemoryDB")) + persisterInstance, err := factoryInstance.Create(t.TempDir()) + assert.Nil(t, err) + assert.False(t, check.IfNil(persisterInstance)) + assert.Equal(t, "*memorydb.DB", fmt.Sprintf("%T", persisterInstance)) + _ = persisterInstance.Close() + }) +} + +func TestPersisterFactory_CreateDisabled(t *testing.T) { + t.Parallel() + + factoryInstance := NewPersisterFactory(createDBConfig("LvlDB")) + persisterInstance := factoryInstance.CreateDisabled() + assert.False(t, check.IfNil(persisterInstance)) + assert.Equal(t, "*disabled.errorDisabledPersister", fmt.Sprintf("%T", persisterInstance)) +} diff --git a/storage/factory/pruningStorerFactory.go b/storage/factory/storageServiceFactory.go similarity index 93% rename from storage/factory/pruningStorerFactory.go rename to storage/factory/storageServiceFactory.go index 34293aaf9f3..7e0d89399b1 100644 --- a/storage/factory/pruningStorerFactory.go +++ b/storage/factory/storageServiceFactory.go @@ -121,56 +121,56 @@ func (psf *StorageServiceFactory) createAndAddBaseStorageUnits( txUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.TxStorage, disabledCustomDatabaseRemover) txUnit, err := psf.createPruningPersister(txUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for TxStorage", err) } store.AddStorer(dataRetriever.TransactionUnit, txUnit) unsignedTxUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.UnsignedTransactionStorage, disabledCustomDatabaseRemover) unsignedTxUnit, err := psf.createPruningPersister(unsignedTxUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for UnsignedTransactionStorage", err) } store.AddStorer(dataRetriever.UnsignedTransactionUnit, unsignedTxUnit) rewardTxUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.RewardTxStorage, disabledCustomDatabaseRemover) rewardTxUnit, err := psf.createPruningPersister(rewardTxUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for RewardTxStorage", err) } store.AddStorer(dataRetriever.RewardTransactionUnit, rewardTxUnit) receiptsUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.ReceiptsStorage, disabledCustomDatabaseRemover) receiptsUnit, err := psf.createPruningPersister(receiptsUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for ReceiptsStorage", err) } store.AddStorer(dataRetriever.ReceiptsUnit, receiptsUnit) scheduledSCRsUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.ScheduledSCRsStorage, disabledCustomDatabaseRemover) scheduledSCRsUnit, err := psf.createPruningPersister(scheduledSCRsUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for ScheduledSCRsStorage", err) } store.AddStorer(dataRetriever.ScheduledSCRsUnit, scheduledSCRsUnit) bootstrapUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.BootstrapStorage, disabledCustomDatabaseRemover) bootstrapUnit, err := psf.createPruningPersister(bootstrapUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for BootstrapStorage", err) } store.AddStorer(dataRetriever.BootstrapUnit, bootstrapUnit) miniBlockUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.MiniBlocksStorage, disabledCustomDatabaseRemover) miniBlockUnit, err := psf.createPruningPersister(miniBlockUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for MiniBlocksStorage", err) } store.AddStorer(dataRetriever.MiniBlockUnit, miniBlockUnit) metaBlockUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.MetaBlockStorage, disabledCustomDatabaseRemover) metaBlockUnit, err := psf.createPruningPersister(metaBlockUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for MetaBlockStorage", err) } store.AddStorer(dataRetriever.MetaBlockUnit, metaBlockUnit) @@ -182,34 +182,34 @@ func (psf *StorageServiceFactory) createAndAddBaseStorageUnits( GetCacherFromConfig(psf.generalConfig.MetaHdrNonceHashStorage.Cache), metaHdrHashNonceUnitConfig) if err != nil { - return err + return fmt.Errorf("%w for MetaHdrNonceHashStorage", err) } store.AddStorer(dataRetriever.MetaHdrNonceHashDataUnit, metaHdrHashNonceUnit) headerUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.BlockHeaderStorage, disabledCustomDatabaseRemover) headerUnit, err := psf.createPruningPersister(headerUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for BlockHeaderStorage", err) } store.AddStorer(dataRetriever.BlockHeaderUnit, headerUnit) userAccountsUnit, err := psf.createTriePruningStorer(psf.generalConfig.AccountsTrieStorage, customDatabaseRemover) if err != nil { - return err + return fmt.Errorf("%w for AccountsTrieStorage", err) } store.AddStorer(dataRetriever.UserAccountsUnit, userAccountsUnit) userAccountsCheckpointsUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.AccountsTrieCheckpointsStorage, disabledCustomDatabaseRemover) userAccountsCheckpointsUnit, err := psf.createPruningPersister(userAccountsCheckpointsUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for AccountsTrieCheckpointsStorage", err) } store.AddStorer(dataRetriever.UserAccountsCheckpointsUnit, userAccountsCheckpointsUnit) peerAccountsCheckpointsUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.PeerAccountsTrieCheckpointsStorage, disabledCustomDatabaseRemover) peerAccountsCheckpointsUnit, err := psf.createPruningPersister(peerAccountsCheckpointsUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for PeerAccountsTrieCheckpointsStorage", err) } store.AddStorer(dataRetriever.PeerAccountsCheckpointsUnit, peerAccountsCheckpointsUnit) @@ -221,7 +221,7 @@ func (psf *StorageServiceFactory) createAndAddBaseStorageUnits( GetCacherFromConfig(psf.generalConfig.StatusMetricsStorage.Cache), statusMetricsDbConfig) if err != nil { - return err + return fmt.Errorf("%w for StatusMetricsStorage", err) } store.AddStorer(dataRetriever.StatusMetricsUnit, statusMetricsStorageUnit) @@ -255,7 +255,7 @@ func (psf *StorageServiceFactory) CreateForShard() (dataRetriever.StorageService GetCacherFromConfig(psf.generalConfig.ShardHdrNonceHashStorage.Cache), shardHdrHashNonceConfig) if err != nil { - return nil, err + return nil, fmt.Errorf("%w for ShardHdrNonceHashStorage", err) } store := dataRetriever.NewChainStorer() @@ -267,14 +267,14 @@ func (psf *StorageServiceFactory) CreateForShard() (dataRetriever.StorageService peerAccountsUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.PeerAccountsTrieStorage, customDatabaseRemover) peerAccountsUnit, err := psf.createTrieUnit(psf.generalConfig.PeerAccountsTrieStorage, peerAccountsUnitArgs) if err != nil { - return nil, err + return nil, fmt.Errorf("%w for PeerAccountsTrieStorage", err) } store.AddStorer(dataRetriever.PeerAccountsUnit, peerAccountsUnit) peerBlockUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.PeerBlockBodyStorage, disabledCustomDatabaseRemover) peerBlockUnit, err := psf.createPruningPersister(peerBlockUnitArgs) if err != nil { - return nil, err + return nil, fmt.Errorf("%w for PeerBlockBodyStorage", err) } store.AddStorer(dataRetriever.PeerChangesUnit, peerBlockUnit) @@ -320,7 +320,7 @@ func (psf *StorageServiceFactory) CreateForMeta() (dataRetriever.StorageService, GetCacherFromConfig(psf.generalConfig.ShardHdrNonceHashStorage.Cache), shardHdrHashNonceConfig) if err != nil { - return nil, err + return nil, fmt.Errorf("%w for ShardHdrNonceHashStorage on shard %d", err, i) } } @@ -395,7 +395,7 @@ func (psf *StorageServiceFactory) setupLogsAndEventsStorer(chainStorer *dataRetr txLogsUnitArgs := psf.createPruningStorerArgs(psf.generalConfig.LogsAndEvents.TxLogsStorage, disabled.NewDisabledCustomDatabaseRemover()) txLogsUnit, err = psf.createPruningPersister(txLogsUnitArgs) if err != nil { - return err + return fmt.Errorf("%w for LogsAndEvents.TxLogsStorage", err) } } @@ -416,7 +416,7 @@ func (psf *StorageServiceFactory) setupDbLookupExtensions(chainStorer *dataRetri eventsHashesByTxHashStorerArgs := psf.createPruningStorerArgs(eventsHashesByTxHashConfig, disabled.NewDisabledCustomDatabaseRemover()) eventsHashesByTxHashPruningStorer, err := psf.createPruningPersister(eventsHashesByTxHashStorerArgs) if err != nil { - return err + return fmt.Errorf("%w for DbLookupExtensions.ResultsHashesByTxHashStorageConfig", err) } chainStorer.AddStorer(dataRetriever.ResultsHashesByTxHashUnit, eventsHashesByTxHashPruningStorer) @@ -426,7 +426,7 @@ func (psf *StorageServiceFactory) setupDbLookupExtensions(chainStorer *dataRetri miniblocksMetadataPruningStorerArgs := psf.createPruningStorerArgs(miniblocksMetadataConfig, disabled.NewDisabledCustomDatabaseRemover()) miniblocksMetadataPruningStorer, err := psf.createPruningPersister(miniblocksMetadataPruningStorerArgs) if err != nil { - return err + return fmt.Errorf("%w for DbLookupExtensions.MiniblocksMetadataStorageConfig", err) } chainStorer.AddStorer(dataRetriever.MiniblocksMetadataUnit, miniblocksMetadataPruningStorer) @@ -438,7 +438,7 @@ func (psf *StorageServiceFactory) setupDbLookupExtensions(chainStorer *dataRetri miniblockHashByTxHashCacherConfig := GetCacherFromConfig(miniblockHashByTxHashConfig.Cache) miniblockHashByTxHashUnit, err := storageunit.NewStorageUnitFromConf(miniblockHashByTxHashCacherConfig, miniblockHashByTxHashDbConfig) if err != nil { - return err + return fmt.Errorf("%w for DbLookupExtensions.MiniblockHashByTxHashStorageConfig", err) } chainStorer.AddStorer(dataRetriever.MiniblockHashByTxHashUnit, miniblockHashByTxHashUnit) @@ -450,7 +450,7 @@ func (psf *StorageServiceFactory) setupDbLookupExtensions(chainStorer *dataRetri blockHashByRoundCacherConfig := GetCacherFromConfig(blockHashByRoundConfig.Cache) blockHashByRoundUnit, err := storageunit.NewStorageUnitFromConf(blockHashByRoundCacherConfig, blockHashByRoundDBConfig) if err != nil { - return err + return fmt.Errorf("%w for DbLookupExtensions.RoundHashStorageConfig", err) } chainStorer.AddStorer(dataRetriever.RoundHdrHashDataUnit, blockHashByRoundUnit) @@ -462,7 +462,7 @@ func (psf *StorageServiceFactory) setupDbLookupExtensions(chainStorer *dataRetri epochByHashCacherConfig := GetCacherFromConfig(epochByHashConfig.Cache) epochByHashUnit, err := storageunit.NewStorageUnitFromConf(epochByHashCacherConfig, epochByHashDbConfig) if err != nil { - return err + return fmt.Errorf("%w for DbLookupExtensions.EpochByHashStorageConfig", err) } chainStorer.AddStorer(dataRetriever.EpochByHashUnit, epochByHashUnit) @@ -473,7 +473,7 @@ func (psf *StorageServiceFactory) setupDbLookupExtensions(chainStorer *dataRetri esdtSuppliesCacherConfig := GetCacherFromConfig(esdtSuppliesConfig.Cache) esdtSuppliesUnit, err := storageunit.NewStorageUnitFromConf(esdtSuppliesCacherConfig, esdtSuppliesDbConfig) if err != nil { - return err + return fmt.Errorf("%w for DbLookupExtensions.ESDTSuppliesStorageConfig", err) } chainStorer.AddStorer(dataRetriever.ESDTSuppliesUnit, esdtSuppliesUnit) @@ -528,7 +528,7 @@ func (psf *StorageServiceFactory) createTrieEpochRootHashStorerIfNeeded() (stora GetCacherFromConfig(psf.generalConfig.TrieEpochRootHashStorage.Cache), trieEpochRootHashDbConfig) if err != nil { - return nil, err + return nil, fmt.Errorf("%w for TrieEpochRootHashStorage", err) } return trieEpochRootHashStorageUnit, nil diff --git a/storage/factory/storageServiceFactory_test.go b/storage/factory/storageServiceFactory_test.go new file mode 100644 index 00000000000..cda7e0c408a --- /dev/null +++ b/storage/factory/storageServiceFactory_test.go @@ -0,0 +1,528 @@ +package factory + +import ( + "testing" + + "github.com/multiversx/mx-chain-core-go/core" + "github.com/multiversx/mx-chain-core-go/core/check" + "github.com/multiversx/mx-chain-go/config" + "github.com/multiversx/mx-chain-go/storage" + "github.com/multiversx/mx-chain-go/storage/mock" + "github.com/multiversx/mx-chain-go/testscommon/nodeTypeProviderMock" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func createMockArgument(t *testing.T) StorageServiceFactoryArgs { + pathMan, err := CreatePathManagerFromSinglePathString(t.TempDir()) + require.Nil(t, err) + + return StorageServiceFactoryArgs{ + Config: config.Config{ + StateTriesConfig: config.StateTriesConfig{ + SnapshotsEnabled: true, + }, + StoragePruning: config.StoragePruningConfig{ + Enabled: true, + NumActivePersisters: 3, + NumEpochsToKeep: 4, + ObserverCleanOldEpochsData: true, + }, + ShardHdrNonceHashStorage: createMockStorageConfig("ShardHdrNonceHashStorage"), + TxStorage: createMockStorageConfig("TxStorage"), + UnsignedTransactionStorage: createMockStorageConfig("UnsignedTransactionStorage"), + RewardTxStorage: createMockStorageConfig("RewardTxStorage"), + ReceiptsStorage: createMockStorageConfig("ReceiptsStorage"), + ScheduledSCRsStorage: createMockStorageConfig("ScheduledSCRsStorage"), + BootstrapStorage: createMockStorageConfig("BootstrapStorage"), + MiniBlocksStorage: createMockStorageConfig("MiniBlocksStorage"), + MetaBlockStorage: createMockStorageConfig("MetaBlockStorage"), + MetaHdrNonceHashStorage: createMockStorageConfig("MetaHdrNonceHashStorage"), + BlockHeaderStorage: createMockStorageConfig("BlockHeaderStorage"), + AccountsTrieStorage: createMockStorageConfig("AccountsTrieStorage"), + AccountsTrieCheckpointsStorage: createMockStorageConfig("AccountsTrieCheckpointsStorage"), + PeerAccountsTrieStorage: createMockStorageConfig("PeerAccountsTrieStorage"), + PeerAccountsTrieCheckpointsStorage: createMockStorageConfig("PeerAccountsTrieCheckpointsStorage"), + StatusMetricsStorage: createMockStorageConfig("StatusMetricsStorage"), + PeerBlockBodyStorage: createMockStorageConfig("PeerBlockBodyStorage"), + TrieEpochRootHashStorage: createMockStorageConfig("TrieEpochRootHashStorage"), + DbLookupExtensions: config.DbLookupExtensionsConfig{ + Enabled: true, + DbLookupMaxActivePersisters: 10, + MiniblocksMetadataStorageConfig: createMockStorageConfig("MiniblocksMetadataStorage"), + MiniblockHashByTxHashStorageConfig: createMockStorageConfig("MiniblockHashByTxHashStorage"), + EpochByHashStorageConfig: createMockStorageConfig("EpochByHashStorage"), + ResultsHashesByTxHashStorageConfig: createMockStorageConfig("ResultsHashesByTxHashStorage"), + ESDTSuppliesStorageConfig: createMockStorageConfig("ESDTSuppliesStorage"), + RoundHashStorageConfig: createMockStorageConfig("RoundHashStorage"), + }, + LogsAndEvents: config.LogsAndEventsConfig{ + SaveInStorageEnabled: true, + TxLogsStorage: createMockStorageConfig("TxLogsStorage"), + }, + }, + PrefsConfig: config.PreferencesConfig{}, + ShardCoordinator: &mock.ShardCoordinatorMock{ + NumShards: 3, + }, + PathManager: pathMan, + EpochStartNotifier: &mock.EpochStartNotifierStub{}, + NodeTypeProvider: &nodeTypeProviderMock.NodeTypeProviderStub{ + GetTypeCalled: func() core.NodeType { + return core.NodeTypeObserver + }, + }, + StorageType: ProcessStorageService, + CurrentEpoch: 0, + CreateTrieEpochRootHashStorer: true, + } +} + +func createMockStorageConfig(dbName string) config.StorageConfig { + return config.StorageConfig{ + Cache: config.CacheConfig{ + Type: "LRU", + Capacity: 1000, + }, + DB: config.DBConfig{ + FilePath: dbName, + Type: "LvlDBSerial", + BatchDelaySeconds: 5, + MaxBatchSize: 100, + MaxOpenFiles: 10, + }, + } +} + +func TestNewStorageServiceFactory(t *testing.T) { + t.Parallel() + + t.Run("invalid StoragePruning.NumActivePersisters should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.StoragePruning.NumActivePersisters = 0 + storageServiceFactory, err := NewStorageServiceFactory(args) + assert.Equal(t, storage.ErrInvalidNumberOfActivePersisters, err) + assert.Nil(t, storageServiceFactory) + }) + t.Run("nil shard coordinator should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.ShardCoordinator = nil + storageServiceFactory, err := NewStorageServiceFactory(args) + assert.Equal(t, storage.ErrNilShardCoordinator, err) + assert.Nil(t, storageServiceFactory) + }) + t.Run("nil path manager should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.PathManager = nil + storageServiceFactory, err := NewStorageServiceFactory(args) + assert.Equal(t, storage.ErrNilPathManager, err) + assert.Nil(t, storageServiceFactory) + }) + t.Run("nil epoch start notifier should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.EpochStartNotifier = nil + storageServiceFactory, err := NewStorageServiceFactory(args) + assert.Equal(t, storage.ErrNilEpochStartNotifier, err) + assert.Nil(t, storageServiceFactory) + }) + t.Run("invalid number of epochs to save should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.StoragePruning.NumEpochsToKeep = 1 + storageServiceFactory, err := NewStorageServiceFactory(args) + assert.Equal(t, storage.ErrInvalidNumberOfEpochsToSave, err) + assert.Nil(t, storageServiceFactory) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + storageServiceFactory, err := NewStorageServiceFactory(args) + assert.Nil(t, err) + assert.NotNil(t, storageServiceFactory) + }) +} + +func TestStorageServiceFactory_CreateForShard(t *testing.T) { + t.Parallel() + + expectedErrForCacheString := "not supported cache type" + + t.Run("wrong config for ShardHdrNonceHashStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.ShardHdrNonceHashStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for ShardHdrNonceHashStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for TxStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.TxStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for TxStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for UnsignedTransactionStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.UnsignedTransactionStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for UnsignedTransactionStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for RewardTxStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.RewardTxStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for RewardTxStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for ReceiptsStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.ReceiptsStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for ReceiptsStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for ScheduledSCRsStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.ScheduledSCRsStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for ScheduledSCRsStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for BootstrapStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.BootstrapStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for BootstrapStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for MiniBlocksStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.MiniBlocksStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for MiniBlocksStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for MetaBlockStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.MetaBlockStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for MetaBlockStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for MetaHdrNonceHashStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.MetaHdrNonceHashStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for MetaHdrNonceHashStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for BlockHeaderStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.BlockHeaderStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for BlockHeaderStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for AccountsTrieStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.AccountsTrieStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for AccountsTrieStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for AccountsTrieCheckpointsStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.AccountsTrieCheckpointsStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for AccountsTrieCheckpointsStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for PeerAccountsTrieStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.PeerAccountsTrieStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for PeerAccountsTrieStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for PeerAccountsTrieCheckpointsStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.PeerAccountsTrieCheckpointsStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for PeerAccountsTrieCheckpointsStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for StatusMetricsStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.StatusMetricsStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for StatusMetricsStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for PeerBlockBodyStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.PeerBlockBodyStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for PeerBlockBodyStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for TrieEpochRootHashStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.TrieEpochRootHashStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for TrieEpochRootHashStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for DbLookupExtensions.MiniblocksMetadataStorageConfig should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.DbLookupExtensions.MiniblocksMetadataStorageConfig.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for DbLookupExtensions.MiniblocksMetadataStorageConfig", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for DbLookupExtensions.MiniblockHashByTxHashStorageConfig should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.DbLookupExtensions.MiniblockHashByTxHashStorageConfig.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for DbLookupExtensions.MiniblockHashByTxHashStorageConfig", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for DbLookupExtensions.EpochByHashStorageConfig should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.DbLookupExtensions.EpochByHashStorageConfig.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for DbLookupExtensions.EpochByHashStorageConfig", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for DbLookupExtensions.ResultsHashesByTxHashStorageConfig should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.DbLookupExtensions.ResultsHashesByTxHashStorageConfig.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for DbLookupExtensions.ResultsHashesByTxHashStorageConfig", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for DbLookupExtensions.ESDTSuppliesStorageConfig should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.DbLookupExtensions.ESDTSuppliesStorageConfig.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for DbLookupExtensions.ESDTSuppliesStorageConfig", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for DbLookupExtensions.RoundHashStorageConfig should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.DbLookupExtensions.RoundHashStorageConfig.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for DbLookupExtensions.RoundHashStorageConfig", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for LogsAndEvents.TxLogsStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.LogsAndEvents.TxLogsStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Equal(t, expectedErrForCacheString+" for LogsAndEvents.TxLogsStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Nil(t, err) + assert.False(t, check.IfNil(storageService)) + allStorers := storageService.GetAllStorers() + expectedStorers := 25 + assert.Equal(t, expectedStorers, len(allStorers)) + _ = storageService.CloseAll() + }) + t.Run("should work without DbLookupExtensions", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.DbLookupExtensions.Enabled = false + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Nil(t, err) + assert.False(t, check.IfNil(storageService)) + allStorers := storageService.GetAllStorers() + numDBLookupExtensionUnits := 6 + expectedStorers := 25 - numDBLookupExtensionUnits + assert.Equal(t, expectedStorers, len(allStorers)) + _ = storageService.CloseAll() + }) + t.Run("should work without TrieEpochRootHashStorage", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.CreateTrieEpochRootHashStorer = false + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Nil(t, err) + assert.False(t, check.IfNil(storageService)) + allStorers := storageService.GetAllStorers() + expectedStorers := 25 // we still have a storer for trie epoch root hash + assert.Equal(t, expectedStorers, len(allStorers)) + _ = storageService.CloseAll() + }) + t.Run("should work if the snapshots are not enabled", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.StateTriesConfig.SnapshotsEnabled = false + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForShard() + assert.Nil(t, err) + assert.False(t, check.IfNil(storageService)) + allStorers := storageService.GetAllStorers() + expectedStorers := 25 + assert.Equal(t, expectedStorers, len(allStorers)) + _ = storageService.CloseAll() + }) +} + +func TestStorageServiceFactory_CreateForMeta(t *testing.T) { + t.Parallel() + + expectedErrForCacheString := "not supported cache type" + + t.Run("wrong config for ShardHdrNonceHashStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.ShardHdrNonceHashStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForMeta() + assert.Equal(t, expectedErrForCacheString+" for ShardHdrNonceHashStorage on shard 0", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for AccountsTrieStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.AccountsTrieStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForMeta() + assert.Equal(t, expectedErrForCacheString+" for AccountsTrieStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for DbLookupExtensions.RoundHashStorageConfig should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.DbLookupExtensions.RoundHashStorageConfig.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForMeta() + assert.Equal(t, expectedErrForCacheString+" for DbLookupExtensions.RoundHashStorageConfig", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("wrong config for LogsAndEvents.TxLogsStorage should error", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + args.Config.LogsAndEvents.TxLogsStorage.Cache.Type = "" + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForMeta() + assert.Equal(t, expectedErrForCacheString+" for LogsAndEvents.TxLogsStorage", err.Error()) + assert.True(t, check.IfNil(storageService)) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + args := createMockArgument(t) + storageServiceFactory, _ := NewStorageServiceFactory(args) + storageService, err := storageServiceFactory.CreateForMeta() + assert.Nil(t, err) + assert.False(t, check.IfNil(storageService)) + allStorers := storageService.GetAllStorers() + missingStorers := 2 // PeerChangesUnit and ShardHdrNonceHashDataUnit + numShardHdrStorage := 3 + expectedStorers := 25 - missingStorers + numShardHdrStorage + assert.Equal(t, expectedStorers, len(allStorers)) + _ = storageService.CloseAll() + }) +} diff --git a/storage/latestData/latestDataProvider_test.go b/storage/latestData/latestDataProvider_test.go index ebdbc31d178..8494f2257a2 100644 --- a/storage/latestData/latestDataProvider_test.go +++ b/storage/latestData/latestDataProvider_test.go @@ -28,6 +28,14 @@ func TestNewLatestDataProvider_ShouldWork(t *testing.T) { require.NoError(t, err) } +func TestLatestDataProvider_GetParentDirectory(t *testing.T) { + t.Parallel() + + args := getLatestDataProviderArgs() + ldp, _ := NewLatestDataProvider(args) + assert.Equal(t, args.ParentDir, ldp.GetParentDirectory()) +} + func TestGetShardsFromDirectory(t *testing.T) { t.Parallel() diff --git a/storage/mock/storedDataFactoryStub.go b/storage/mock/storedDataFactoryStub.go new file mode 100644 index 00000000000..1716f67b461 --- /dev/null +++ b/storage/mock/storedDataFactoryStub.go @@ -0,0 +1,20 @@ +package mock + +// StoredDataFactoryStub - +type StoredDataFactoryStub struct { + CreateEmptyCalled func() interface{} +} + +// CreateEmpty - +func (sdf *StoredDataFactoryStub) CreateEmpty() interface{} { + if sdf.CreateEmptyCalled != nil { + return sdf.CreateEmptyCalled() + } + + return nil +} + +// IsInterfaceNil - +func (sdf *StoredDataFactoryStub) IsInterfaceNil() bool { + return sdf == nil +} diff --git a/storage/pathmanager/pathManager_test.go b/storage/pathmanager/pathManager_test.go index 061b536ffd1..ae50921a106 100644 --- a/storage/pathmanager/pathManager_test.go +++ b/storage/pathmanager/pathManager_test.go @@ -3,6 +3,7 @@ package pathmanager_test import ( "testing" + "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/storage/pathmanager" "github.com/stretchr/testify/assert" ) @@ -11,7 +12,7 @@ func TestNewPathManager_EmptyPruningPathTemplateShouldErr(t *testing.T) { t.Parallel() pm, err := pathmanager.NewPathManager("", "shard_[S]/[I]", "db") - assert.Nil(t, pm) + assert.True(t, check.IfNil(pm)) assert.Equal(t, pathmanager.ErrEmptyPruningPathTemplate, err) } @@ -19,15 +20,23 @@ func TestNewPathManager_EmptyStaticPathTemplateShouldErr(t *testing.T) { t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "", "db") - assert.Nil(t, pm) + assert.True(t, check.IfNil(pm)) assert.Equal(t, pathmanager.ErrEmptyStaticPathTemplate, err) } +func TestNewPathManager_EmptyDBPathTemplateShouldErr(t *testing.T) { + t.Parallel() + + pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]/[I]", "") + assert.True(t, check.IfNil(pm)) + assert.Equal(t, pathmanager.ErrInvalidDatabasePath, err) +} + func TestNewPathManager_InvalidPruningPathTemplate_NoShardPlaceholder_ShouldErr(t *testing.T) { t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard/[I]", "shard_[S]/[I]", "db") - assert.Nil(t, pm) + assert.True(t, check.IfNil(pm)) assert.Equal(t, pathmanager.ErrInvalidPruningPathTemplate, err) } @@ -35,7 +44,7 @@ func TestNewPathManager_InvalidPruningPathTemplate_NoEpochPlaceholder_ShouldErr( t.Parallel() pm, err := pathmanager.NewPathManager("epoch/shard_[S]/[I]", "shard_[S]/[I]", "db") - assert.Nil(t, pm) + assert.True(t, check.IfNil(pm)) assert.Equal(t, pathmanager.ErrInvalidPruningPathTemplate, err) } @@ -43,7 +52,7 @@ func TestNewPathManager_InvalidPathPruningTemplate_NoIdentifierPlaceholder_Shoul t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]", "shard_[S]/[I]", "db") - assert.Nil(t, pm) + assert.True(t, check.IfNil(pm)) assert.Equal(t, pathmanager.ErrInvalidPruningPathTemplate, err) } @@ -51,7 +60,7 @@ func TestNewPathManager_InvalidStaticPathTemplate_NoShardPlaceholder_ShouldErr(t t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard/[I]", "db") - assert.Nil(t, pm) + assert.True(t, check.IfNil(pm)) assert.Equal(t, pathmanager.ErrInvalidStaticPathTemplate, err) } @@ -59,7 +68,7 @@ func TestNewPathManager_InvalidStaticPathTemplate_NoIdentifierPlaceholder_Should t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]", "db") - assert.Nil(t, pm) + assert.True(t, check.IfNil(pm)) assert.Equal(t, pathmanager.ErrInvalidStaticPathTemplate, err) } @@ -67,10 +76,18 @@ func TestNewPathManager_OkValsShouldWork(t *testing.T) { t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]/[I]", "db") - assert.NotNil(t, pm) + assert.False(t, check.IfNil(pm)) assert.Nil(t, err) } +func TestPathManager_DatabasePath(t *testing.T) { + t.Parallel() + + dbPath := "db" + pm, _ := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]/[I]", dbPath) + assert.Equal(t, dbPath, pm.DatabasePath()) +} + func TestPathManager_PathForEpoch(t *testing.T) { t.Parallel() diff --git a/storage/pruning/pruningStorer_test.go b/storage/pruning/pruningStorer_test.go index 0ac4f7cf71f..7b2b9ae47bc 100644 --- a/storage/pruning/pruningStorer_test.go +++ b/storage/pruning/pruningStorer_test.go @@ -1148,3 +1148,167 @@ func TestPruningStorer_ConcurrentOperations(t *testing.T) { // if the "resource temporary unavailable" occurs, this test will take longer than this to execute require.True(t, elapsedTime < 100*time.Second) } + +func TestPruningStorer_RangeKeys(t *testing.T) { + t.Parallel() + + args := getDefaultArgs() + ps, _ := pruning.NewPruningStorer(args) + + t.Run("should not panic with nil handler", func(t *testing.T) { + t.Parallel() + + assert.NotPanics(t, func() { + ps.RangeKeys(nil) + }) + }) + t.Run("should not call handler", func(t *testing.T) { + t.Parallel() + + ps.RangeKeys(func(key []byte, val []byte) bool { + assert.Fail(t, "should not have called handler") + return false + }) + }) +} + +func TestPruningStorer_GetOldestEpoch(t *testing.T) { + t.Parallel() + + t.Run("should return error if no persisters are found", func(t *testing.T) { + t.Parallel() + + epochsData := pruning.EpochArgs{ + NumOfEpochsToKeep: 0, + NumOfActivePersisters: 0, + } + + args := getDefaultArgs() + args.PersistersTracker = pruning.NewPersistersTracker(epochsData) + ps, _ := pruning.NewPruningStorer(args) + + epoch, err := ps.GetOldestEpoch() + assert.NotNil(t, err) + assert.Zero(t, epoch) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + epochsData := pruning.EpochArgs{ + NumOfEpochsToKeep: 2, + NumOfActivePersisters: 2, + StartingEpoch: 5, + } + + args := getDefaultArgs() + args.PersistersTracker = pruning.NewPersistersTracker(epochsData) + args.EpochsData = epochsData + ps, _ := pruning.NewPruningStorer(args) + + epoch, err := ps.GetOldestEpoch() + assert.Nil(t, err) + expectedEpoch := uint32(4) // 5 and 4 are the active epochs + assert.Equal(t, expectedEpoch, epoch) + }) +} + +func TestPruningStorer_PutInEpoch(t *testing.T) { + t.Parallel() + + epochsData := pruning.EpochArgs{ + NumOfEpochsToKeep: 2, + NumOfActivePersisters: 2, + StartingEpoch: 5, + } + args := getDefaultArgs() + args.PersistersTracker = pruning.NewPersistersTracker(epochsData) + args.EpochsData = epochsData + ps, _ := pruning.NewPruningStorer(args) + + t.Run("if the epoch is not handled, should error", func(t *testing.T) { + t.Parallel() + + err := ps.PutInEpoch([]byte("key"), []byte("value"), 3) // only 4 and 5 are handled + expectedErrorString := "put in epoch: persister for epoch 3 not found" + assert.Equal(t, expectedErrorString, err.Error()) + }) + t.Run("put in existing epochs", func(t *testing.T) { + t.Parallel() + + key4 := []byte("key4") + value4 := []byte("value4") + key5 := []byte("key5") + value5 := []byte("value5") + + err := ps.PutInEpoch(key4, value4, 4) + assert.Nil(t, err) + + err = ps.PutInEpoch(key5, value5, 5) + assert.Nil(t, err) + + t.Run("get from their respective epochs should work", func(t *testing.T) { + ps.ClearCache() + recovered4, errGet := ps.GetFromEpoch(key4, 4) + assert.Nil(t, errGet) + assert.Equal(t, value4, recovered4) + + ps.ClearCache() + recovered5, errGet := ps.GetFromEpoch(key5, 5) + assert.Nil(t, errGet) + assert.Equal(t, value5, recovered5) + }) + t.Run("get from wrong epochs should error", func(t *testing.T) { + ps.ClearCache() + result, errGet := ps.GetFromEpoch(key4, 3) + expectedErrorString := fmt.Sprintf("key %x not found in id", key4) + assert.Equal(t, expectedErrorString, errGet.Error()) + assert.Nil(t, result) + + ps.ClearCache() + result, errGet = ps.GetFromEpoch(key4, 5) + expectedErrorString = fmt.Sprintf("key %x not found in id", key4) + assert.Equal(t, expectedErrorString, errGet.Error()) + assert.Nil(t, result) + }) + }) +} + +func TestPruningStorer_RemoveFromCurrentEpoch(t *testing.T) { + t.Parallel() + + epochsData := pruning.EpochArgs{ + NumOfEpochsToKeep: 2, + NumOfActivePersisters: 2, + StartingEpoch: 5, + } + args := getDefaultArgs() + args.PersistersTracker = pruning.NewPersistersTracker(epochsData) + args.EpochsData = epochsData + ps, _ := pruning.NewPruningStorer(args) + + // current epoch is 5 + key := []byte("key") + value := []byte("value") + + // put in epoch 4 + _ = ps.PutInEpoch(key, value, 4) + // put in epoch 5 + _ = ps.PutInEpoch(key, value, 5) + + // remove from epoch 5 + err := ps.RemoveFromCurrentEpoch(key) + assert.Nil(t, err) + + // get from epoch 5 should error + ps.ClearCache() + result, errGet := ps.GetFromEpoch(key, 5) + expectedErrorString := fmt.Sprintf("key %x not found in id", key) + assert.Equal(t, expectedErrorString, errGet.Error()) + assert.Nil(t, result) + + // get from epoch 4 should work + ps.ClearCache() + recovered, errGet := ps.GetFromEpoch(key, 4) + assert.Nil(t, errGet) + assert.Equal(t, value, recovered) +} diff --git a/storage/pruning/triePruningStorer_test.go b/storage/pruning/triePruningStorer_test.go index dad280f364d..c4b04f02f5b 100644 --- a/storage/pruning/triePruningStorer_test.go +++ b/storage/pruning/triePruningStorer_test.go @@ -350,3 +350,34 @@ func TestTriePruningStorer_KeepMoreDbsOpenIfNecessary(t *testing.T) { err = tps.Close() assert.Nil(t, err) } + +func TestTriePruningStorer_GetLatestStorageEpoch(t *testing.T) { + t.Parallel() + + epochsData := pruning.EpochArgs{ + NumOfEpochsToKeep: 2, + NumOfActivePersisters: 2, + StartingEpoch: 5, + } + args := getDefaultArgs() + args.PersistersTracker = pruning.NewPersistersTracker(epochsData) + + t.Run("no active db should error", func(t *testing.T) { + t.Parallel() + + tps, _ := pruning.NewTriePruningStorer(args) + latestEpoch, err := tps.GetLatestStorageEpoch() + expectedErrString := "there are no active persisters" + assert.Equal(t, expectedErrString, err.Error()) + assert.Zero(t, latestEpoch) + }) + t.Run("no active db should error", func(t *testing.T) { + t.Parallel() + + tps, _ := pruning.NewTriePruningStorer(args) + _ = tps.ChangeEpochSimple(5) + latestEpoch, err := tps.GetLatestStorageEpoch() + assert.Nil(t, err) + assert.Equal(t, uint32(5), latestEpoch) + }) +} diff --git a/storage/storageunit/storageunit_test.go b/storage/storageunit/storageunit_test.go new file mode 100644 index 00000000000..d66669dc5c9 --- /dev/null +++ b/storage/storageunit/storageunit_test.go @@ -0,0 +1,173 @@ +package storageunit_test + +import ( + "path" + "testing" + + "github.com/multiversx/mx-chain-core-go/core/check" + "github.com/multiversx/mx-chain-go/storage/mock" + "github.com/multiversx/mx-chain-go/storage/storageunit" + "github.com/multiversx/mx-chain-storage-go/common" + + "github.com/multiversx/mx-chain-go/testscommon" + "github.com/stretchr/testify/assert" +) + +func TestNewStorageUnit(t *testing.T) { + t.Parallel() + + cacher := &testscommon.CacherStub{} + persister := &mock.PersisterStub{} + + t.Run("nil cacher should error", func(t *testing.T) { + t.Parallel() + + unit, err := storageunit.NewStorageUnit(nil, persister) + assert.True(t, check.IfNil(unit)) + assert.Equal(t, common.ErrNilCacher, err) + }) + t.Run("nil persister should error", func(t *testing.T) { + t.Parallel() + + unit, err := storageunit.NewStorageUnit(cacher, nil) + assert.True(t, check.IfNil(unit)) + assert.Equal(t, common.ErrNilPersister, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + unit, err := storageunit.NewStorageUnit(cacher, persister) + assert.False(t, check.IfNil(unit)) + assert.Nil(t, err) + }) +} + +func TestNewCache(t *testing.T) { + t.Parallel() + + t.Run("wrong config should error", func(t *testing.T) { + t.Parallel() + + cfg := storageunit.CacheConfig{ + Type: "invalid type", + Capacity: 100, + } + cache, err := storageunit.NewCache(cfg) + assert.True(t, check.IfNil(cache)) + assert.Equal(t, common.ErrNotSupportedCacheType, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + cfg := storageunit.CacheConfig{ + Type: "LRU", + Capacity: 100, + } + cache, err := storageunit.NewCache(cfg) + assert.False(t, check.IfNil(cache)) + assert.Nil(t, err) + }) +} + +func TestNewDB(t *testing.T) { + t.Parallel() + + t.Run("wrong config should error", func(t *testing.T) { + t.Parallel() + + args := storageunit.ArgDB{ + DBType: "invalid type", + Path: "TEST", + BatchDelaySeconds: 5, + MaxBatchSize: 10, + MaxOpenFiles: 10, + } + db, err := storageunit.NewDB(args) + assert.True(t, check.IfNil(db)) + assert.Equal(t, common.ErrNotSupportedDBType, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + args := storageunit.ArgDB{ + DBType: "LvlDBSerial", + Path: path.Join(t.TempDir(), "TEST"), + BatchDelaySeconds: 5, + MaxBatchSize: 10, + MaxOpenFiles: 10, + } + db, err := storageunit.NewDB(args) + assert.False(t, check.IfNil(db)) + assert.Nil(t, err) + _ = db.Close() + }) +} + +func TestNewStorageUnitFromConf(t *testing.T) { + t.Parallel() + + dbConfig := storageunit.DBConfig{ + FilePath: path.Join(t.TempDir(), "TEST"), + Type: "LvlDBSerial", + BatchDelaySeconds: 5, + MaxBatchSize: 10, + MaxOpenFiles: 10, + } + + t.Run("invalid config should error", func(t *testing.T) { + t.Parallel() + + cacheConfig := storageunit.CacheConfig{ + Type: "invalid type", + Capacity: 100, + } + + unit, err := storageunit.NewStorageUnitFromConf(cacheConfig, dbConfig) + assert.True(t, check.IfNil(unit)) + assert.Equal(t, common.ErrNotSupportedCacheType, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + cacheConfig := storageunit.CacheConfig{ + Type: "LRU", + Capacity: 100, + } + + unit, err := storageunit.NewStorageUnitFromConf(cacheConfig, dbConfig) + assert.False(t, check.IfNil(unit)) + assert.Nil(t, err) + _ = unit.Close() + }) +} + +func TestNewNilStorer(t *testing.T) { + t.Parallel() + + unit := storageunit.NewNilStorer() + assert.False(t, check.IfNil(unit)) +} + +func TestNewStorageCacherAdapter(t *testing.T) { + t.Parallel() + + cacher := &mock.AdaptedSizedLruCacheStub{} + db := &mock.PersisterStub{} + storedDataFactory := &mock.StoredDataFactoryStub{} + marshaller := &testscommon.MarshalizerStub{} + + t.Run("nil parameter should error", func(t *testing.T) { + t.Parallel() + + adaptor, err := storageunit.NewStorageCacherAdapter(nil, db, storedDataFactory, marshaller) + assert.True(t, check.IfNil(adaptor)) + assert.Equal(t, common.ErrNilCacher, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + adaptor, err := storageunit.NewStorageCacherAdapter(cacher, db, storedDataFactory, marshaller) + assert.False(t, check.IfNil(adaptor)) + assert.Nil(t, err) + }) +} diff --git a/storage/txcache/txcache_test.go b/storage/txcache/txcache_test.go new file mode 100644 index 00000000000..574b6bd3b7d --- /dev/null +++ b/storage/txcache/txcache_test.go @@ -0,0 +1,97 @@ +package txcache + +import ( + "strings" + "testing" + + "github.com/multiversx/mx-chain-core-go/core/check" + "github.com/multiversx/mx-chain-go/testscommon/txcachemocks" + "github.com/multiversx/mx-chain-storage-go/common" + "github.com/stretchr/testify/assert" +) + +func TestNewTxCache(t *testing.T) { + t.Parallel() + + t.Run("nil parameter should error", func(t *testing.T) { + t.Parallel() + + cfg := ConfigSourceMe{ + Name: "test", + NumChunks: 1, + NumBytesThreshold: 1000, + NumBytesPerSenderThreshold: 100, + CountThreshold: 10, + CountPerSenderThreshold: 100, + NumSendersToPreemptivelyEvict: 1, + } + + cache, err := NewTxCache(cfg, nil) + assert.True(t, check.IfNil(cache)) + assert.Equal(t, common.ErrNilTxGasHandler, err) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + cfg := ConfigSourceMe{ + Name: "test", + NumChunks: 1, + NumBytesThreshold: 1000, + NumBytesPerSenderThreshold: 100, + CountThreshold: 10, + CountPerSenderThreshold: 100, + NumSendersToPreemptivelyEvict: 1, + } + + cache, err := NewTxCache(cfg, &txcachemocks.TxGasHandlerMock{ + GasProcessingDivisor: 1, + MinimumGasPrice: 1, + MinimumGasMove: 1, + }) + assert.False(t, check.IfNil(cache)) + assert.Nil(t, err) + }) +} + +func TestNewDisabledCache(t *testing.T) { + t.Parallel() + + cache := NewDisabledCache() + assert.False(t, check.IfNil(cache)) +} + +func TestNewCrossTxCache(t *testing.T) { + t.Parallel() + + t.Run("invalid config should error", func(t *testing.T) { + t.Parallel() + + cfg := ConfigDestinationMe{ + Name: "", + NumChunks: 1, + MaxNumItems: 100, + MaxNumBytes: 1000, + NumItemsToPreemptivelyEvict: 1, + } + + cache, err := NewCrossTxCache(cfg) + assert.True(t, check.IfNil(cache)) + assert.ErrorIs(t, err, common.ErrInvalidConfig) + assert.True(t, strings.Contains(err.Error(), "config.Name is invalid")) + }) + t.Run("should work", func(t *testing.T) { + t.Parallel() + + cfg := ConfigDestinationMe{ + Name: "test", + NumChunks: 1, + MaxNumItems: 100, + MaxNumBytes: 1000, + NumItemsToPreemptivelyEvict: 1, + } + + cache, err := NewCrossTxCache(cfg) + assert.False(t, check.IfNil(cache)) + assert.Nil(t, err) + }) +} From a378c74146c735647ad8c302c4f56095bc58e5be Mon Sep 17 00:00:00 2001 From: jules01 Date: Fri, 31 Mar 2023 16:48:42 +0300 Subject: [PATCH 2/4] fix after review: - minor refactoring in storage package - reworked the IsInterfaceNil tests - moved stub, fixed comments & tests --- factory/bootstrap/bootstrapComponents.go | 7 ++-- storage/clean/oldDataCleanerProvider_test.go | 14 ++++++-- storage/clean/oldDatabaseCleaner_test.go | 21 ++++++++---- .../customDatabaseRemover_test.go | 12 ++++++- .../directoryhandler/directoryReader_test.go | 13 +++++++- storage/disabled/errorDisabledPersister.go | 2 +- .../disabled/errorDisabledPersister_test.go | 18 ++++++++-- storage/factory/bootstrapDataProvider_test.go | 14 ++++++-- storage/factory/openStorage.go | 4 +-- storage/factory/openStorage_test.go | 33 ++++++++++++------- storage/factory/persisterFactory_test.go | 15 +++++++-- storage/latestData/latestDataProvider_test.go | 12 ++++++- storage/pathmanager/pathManager_test.go | 29 +++++++++++----- .../pruning/fullHistoryPruningStorer_test.go | 17 +++++++++- .../pruning/fullHistoryTriePruningStorer.go | 5 +++ .../fullHistoryTriePruningStorer_test.go | 18 +++++++++- storage/pruning/persistersTracker_test.go | 13 +++++++- storage/pruning/pruningStorer_test.go | 33 ++++++++++++------- storage/pruning/triePersistersTracker_test.go | 13 +++++++- storage/pruning/triePruningStorer_test.go | 15 +++++++-- storage/storageunit/storageunit_test.go | 15 +++++---- storage/txcache/txcache_test.go | 11 +++---- .../storage}/storedDataFactoryStub.go | 2 +- 23 files changed, 257 insertions(+), 79 deletions(-) rename {storage/mock => testscommon/storage}/storedDataFactoryStub.go (95%) diff --git a/factory/bootstrap/bootstrapComponents.go b/factory/bootstrap/bootstrapComponents.go index e0f6ae2b110..98ce0bab147 100644 --- a/factory/bootstrap/bootstrapComponents.go +++ b/factory/bootstrap/bootstrapComponents.go @@ -162,15 +162,12 @@ func (bcf *bootstrapComponentsFactory) Create() (*bootstrapComponents, error) { return nil, err } - unitOpener, err := createUnitOpener( + unitOpener := createUnitOpener( bootstrapDataProvider, latestStorageDataProvider, storage.DefaultEpochString, storage.DefaultShardString, ) - if err != nil { - return nil, err - } dataSyncerFactory := bootstrap.NewScheduledDataSyncerFactory() @@ -329,7 +326,7 @@ func createUnitOpener( latestDataFromStorageProvider storage.LatestStorageDataProviderHandler, defaultEpochString string, defaultShardString string, -) (storage.UnitOpenerHandler, error) { +) storage.UnitOpenerHandler { argsStorageUnitOpener := storageFactory.ArgsNewOpenStorageUnits{ BootstrapDataProvider: bootstrapDataProvider, LatestStorageDataProvider: latestDataFromStorageProvider, diff --git a/storage/clean/oldDataCleanerProvider_test.go b/storage/clean/oldDataCleanerProvider_test.go index 8bd4f873556..288c18f57a8 100644 --- a/storage/clean/oldDataCleanerProvider_test.go +++ b/storage/clean/oldDataCleanerProvider_test.go @@ -15,7 +15,7 @@ func TestNewOldDataCleanerProvider_NilNodeTypeProviderShouldErr(t *testing.T) { t.Parallel() odcp, err := NewOldDataCleanerProvider(nil, config.StoragePruningConfig{}) - require.True(t, check.IfNil(odcp)) + require.Nil(t, odcp) require.Equal(t, storage.ErrNilNodeTypeProvider, err) } @@ -24,7 +24,7 @@ func TestNewOldDataCleanerProvider_ShouldWork(t *testing.T) { odcp, err := NewOldDataCleanerProvider(&nodeTypeProviderMock.NodeTypeProviderStub{}, config.StoragePruningConfig{}) require.NoError(t, err) - require.False(t, check.IfNil(odcp)) + require.NotNil(t, odcp) } func TestOldDataCleanerProvider_ShouldCleanShouldReturnObserverIfInvalidNodeType(t *testing.T) { @@ -70,3 +70,13 @@ func TestOldDataCleanerProvider_ShouldClean(t *testing.T) { } require.False(t, odcp.ShouldClean()) } + +func TestOldDataCleanerProvider_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var odcp *oldDataCleanerProvider + require.True(t, check.IfNil(odcp)) + + odcp, _ = NewOldDataCleanerProvider(&nodeTypeProviderMock.NodeTypeProviderStub{}, config.StoragePruningConfig{}) + require.False(t, check.IfNil(odcp)) +} diff --git a/storage/clean/oldDatabaseCleaner_test.go b/storage/clean/oldDatabaseCleaner_test.go index b839bf3dca3..108b8c3d5dc 100644 --- a/storage/clean/oldDatabaseCleaner_test.go +++ b/storage/clean/oldDatabaseCleaner_test.go @@ -12,6 +12,7 @@ import ( "github.com/multiversx/mx-chain-go/storage/mock" "github.com/multiversx/mx-chain-go/testscommon" storageStubs "github.com/multiversx/mx-chain-go/testscommon/storage" + "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -68,9 +69,9 @@ func TestNewOldDatabaseCleaner(t *testing.T) { odc, err := NewOldDatabaseCleaner(args) require.Equal(t1, tt.expectedErr, err) if err == nil { - require.False(t1, check.IfNil(odc)) + assert.NotNil(t1, odc) } else { - require.True(t1, check.IfNil(odc)) + assert.Nil(t1, odc) } }) } @@ -100,7 +101,6 @@ func TestOldDatabaseCleaner_EpochChangeShouldErrIfOldestEpochComputationFails(t odc, _ := NewOldDatabaseCleaner(args) odc.pathRemover = fileRemover odc.directoryReader = directoryReader - require.False(t, check.IfNil(odc)) handlerFunc.EpochStartAction(&block.Header{Epoch: 5}) require.False(t, fileRemoverWasCalled) @@ -132,7 +132,6 @@ func TestOldDatabaseCleaner_EpochChangeDirectoryReadFailsShouldNotRemove(t *test odc, _ := NewOldDatabaseCleaner(args) odc.pathRemover = fileRemover odc.directoryReader = directoryReader - require.False(t, check.IfNil(odc)) handlerFunc.EpochStartAction(&block.Header{Epoch: 5}) require.False(t, fileRemoverWasCalled) @@ -164,7 +163,6 @@ func TestOldDatabaseCleaner_EpochChangeNoEpochDirectory(t *testing.T) { odc, _ := NewOldDatabaseCleaner(args) odc.pathRemover = fileRemover odc.directoryReader = directoryReader - require.False(t, check.IfNil(odc)) handlerFunc.EpochStartAction(&block.Header{Epoch: 5}) require.False(t, fileRemoverWasCalled) @@ -199,7 +197,6 @@ func TestOldDatabaseCleaner_EpochChangeShouldNotRemoveIfNewOldestEpochIsOlder(t odc, _ := NewOldDatabaseCleaner(args) odc.pathRemover = fileRemover odc.directoryReader = directoryReader - require.False(t, check.IfNil(odc)) handlerFunc.EpochStartAction(&block.Header{Epoch: 5}) require.Empty(t, removedFiles) @@ -243,7 +240,6 @@ func TestOldDatabaseCleaner_EpochChange(t *testing.T) { odc, _ := NewOldDatabaseCleaner(args) odc.pathRemover = fileRemover odc.directoryReader = directoryReader - require.False(t, check.IfNil(odc)) handlerFunc.EpochStartAction(&block.Header{Epoch: 5}) require.Empty(t, removedFiles) @@ -283,3 +279,14 @@ func createMockArgs() ArgsOldDatabaseCleaner { OldDataCleanerProvider: &testscommon.OldDataCleanerProviderStub{}, } } + +func TestOldDatabaseCleaner_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var odc *oldDatabaseCleaner + require.True(t, check.IfNil(odc)) + + args := createMockArgs() + odc, _ = NewOldDatabaseCleaner(args) + require.False(t, check.IfNil(odc)) +} diff --git a/storage/databaseremover/customDatabaseRemover_test.go b/storage/databaseremover/customDatabaseRemover_test.go index 0ff730c4583..8e5f4d75a68 100644 --- a/storage/databaseremover/customDatabaseRemover_test.go +++ b/storage/databaseremover/customDatabaseRemover_test.go @@ -26,7 +26,7 @@ func TestCustomDatabaseRemover(t *testing.T) { cdr, err := NewCustomDatabaseRemover(createCfgWithPattern(",")) require.True(t, errors.Is(err, errEmptyPatternArgument)) - require.True(t, check.IfNil(cdr)) + require.Nil(t, cdr) }) t.Run("invalid pattern argument, should error", func(t *testing.T) { @@ -89,3 +89,13 @@ func createCfgWithPattern(pattern string) config.StoragePruningConfig { AccountsTrieSkipRemovalCustomPattern: pattern, } } + +func TestCustomDatabaseRemover_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var cdr *customDatabaseRemover + require.True(t, check.IfNil(cdr)) + + cdr, _ = NewCustomDatabaseRemover(createCfgWithPattern("%2,%3")) + require.False(t, check.IfNil(cdr)) +} diff --git a/storage/directoryhandler/directoryReader_test.go b/storage/directoryhandler/directoryReader_test.go index f3a66a30529..425be4462ef 100644 --- a/storage/directoryhandler/directoryReader_test.go +++ b/storage/directoryhandler/directoryReader_test.go @@ -8,6 +8,7 @@ import ( "github.com/multiversx/mx-chain-core-go/core/check" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) const invalidPath = "\\/\\/\\/\\/" @@ -17,7 +18,7 @@ func TestNewDirectoryReader(t *testing.T) { instance := NewDirectoryReader() assert.NotNil(t, instance) - assert.False(t, check.IfNil(instance)) + assert.NotNil(t, instance) } func TestDirectoryReaderListFilesAsString(t *testing.T) { @@ -155,6 +156,16 @@ func TestDirectoryReaderListAllAsString(t *testing.T) { }) } +func TestDirectoryReader_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var dr *directoryReader + require.True(t, check.IfNil(dr)) + + dr = NewDirectoryReader() + require.False(t, check.IfNil(dr)) +} + func contains(s []string, e string) bool { for _, a := range s { if a == e { diff --git a/storage/disabled/errorDisabledPersister.go b/storage/disabled/errorDisabledPersister.go index 5ea67e4bfb0..9877bc01899 100644 --- a/storage/disabled/errorDisabledPersister.go +++ b/storage/disabled/errorDisabledPersister.go @@ -37,7 +37,7 @@ func (disabled *errorDisabledPersister) Remove(_ []byte) error { return fmt.Errorf("disabledPersister.Remove") } -// Destroy does nothing +// Destroy returns error func (disabled *errorDisabledPersister) Destroy() error { return fmt.Errorf("disabledPersister.Destroy") } diff --git a/storage/disabled/errorDisabledPersister_test.go b/storage/disabled/errorDisabledPersister_test.go index 1e429091026..5d05d3401e2 100644 --- a/storage/disabled/errorDisabledPersister_test.go +++ b/storage/disabled/errorDisabledPersister_test.go @@ -1,18 +1,18 @@ package disabled -import "github.com/multiversx/mx-chain-core-go/core/check" - import ( "testing" + "github.com/multiversx/mx-chain-core-go/core/check" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestNewErrorDisabledPersister(t *testing.T) { t.Parallel() disabled := NewErrorDisabledPersister() - assert.False(t, check.IfNil(disabled)) + assert.NotNil(t, disabled) } func TestErrorDisabledPersister_MethodsShouldError(t *testing.T) { @@ -83,9 +83,21 @@ func TestErrorDisabledPersister_RangeKeys(t *testing.T) { }) }) t.Run("handler should not be called", func(t *testing.T) { + t.Parallel() + disabled.RangeKeys(func(key []byte, val []byte) bool { assert.Fail(t, "should have not called the handler") return false }) }) } + +func TestErrorDisabledPersister_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var edp *errorDisabledPersister + require.True(t, check.IfNil(edp)) + + edp = NewErrorDisabledPersister() + require.False(t, check.IfNil(edp)) +} diff --git a/storage/factory/bootstrapDataProvider_test.go b/storage/factory/bootstrapDataProvider_test.go index 22564130082..6f28356f234 100644 --- a/storage/factory/bootstrapDataProvider_test.go +++ b/storage/factory/bootstrapDataProvider_test.go @@ -18,7 +18,7 @@ func TestNewBootstrapDataProvider_NilMarshalizerShouldErr(t *testing.T) { t.Parallel() bdp, err := NewBootstrapDataProvider(nil) - require.True(t, check.IfNil(bdp)) + require.Nil(t, bdp) require.Equal(t, storage.ErrNilMarshalizer, err) } @@ -26,7 +26,7 @@ func TestNewBootstrapDataProvider_OkValuesShouldWork(t *testing.T) { t.Parallel() bdp, err := NewBootstrapDataProvider(&mock.MarshalizerMock{}) - require.False(t, check.IfNil(bdp)) + require.NotNil(t, bdp) require.NoError(t, err) } @@ -93,3 +93,13 @@ func TestBootstrapDataProvider_LoadForPath_ShouldWork(t *testing.T) { require.NotNil(t, storer) require.Equal(t, expectedBD, bootstrapData) } + +func TestBootstrapDataProvider_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var bdp *bootstrapDataProvider + require.True(t, check.IfNil(bdp)) + + bdp, _ = NewBootstrapDataProvider(&mock.MarshalizerMock{}) + require.False(t, check.IfNil(bdp)) +} diff --git a/storage/factory/openStorage.go b/storage/factory/openStorage.go index cfd0e9e3c5b..1d4aa93fe9c 100644 --- a/storage/factory/openStorage.go +++ b/storage/factory/openStorage.go @@ -30,7 +30,7 @@ type openStorageUnits struct { } // NewStorageUnitOpenHandler creates an openStorageUnits component -func NewStorageUnitOpenHandler(args ArgsNewOpenStorageUnits) (*openStorageUnits, error) { +func NewStorageUnitOpenHandler(args ArgsNewOpenStorageUnits) *openStorageUnits { o := &openStorageUnits{ defaultEpochString: args.DefaultEpochString, defaultShardString: args.DefaultShardString, @@ -38,7 +38,7 @@ func NewStorageUnitOpenHandler(args ArgsNewOpenStorageUnits) (*openStorageUnits, latestStorageDataProvider: args.LatestStorageDataProvider, } - return o, nil + return o } // GetMostRecentStorageUnit will open bootstrap storage unit diff --git a/storage/factory/openStorage_test.go b/storage/factory/openStorage_test.go index 147772885b1..195708fee87 100644 --- a/storage/factory/openStorage_test.go +++ b/storage/factory/openStorage_test.go @@ -11,6 +11,7 @@ import ( "github.com/multiversx/mx-chain-go/storage" "github.com/multiversx/mx-chain-go/storage/mock" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func createMockArgsOpenStorageUnits() ArgsNewOpenStorageUnits { @@ -25,10 +26,8 @@ func createMockArgsOpenStorageUnits() ArgsNewOpenStorageUnits { func TestNewStorageUnitOpenHandler(t *testing.T) { t.Parallel() - suoh, err := NewStorageUnitOpenHandler(createMockArgsOpenStorageUnits()) - - assert.NoError(t, err) - assert.False(t, check.IfNil(suoh)) + suoh := NewStorageUnitOpenHandler(createMockArgsOpenStorageUnits()) + assert.NotNil(t, suoh) } func TestGetMostUpToDateDirectory(t *testing.T) { @@ -47,7 +46,7 @@ func TestGetMostUpToDateDirectory(t *testing.T) { } }, } - suoh, _ := NewStorageUnitOpenHandler(args) + suoh := NewStorageUnitOpenHandler(args) shardIDsStr := []string{"0", "1"} path := "currPath" @@ -66,7 +65,7 @@ func TestGetMostRecentBootstrapStorageUnit_GetShardsFromDirectoryErr(t *testing. return nil, localErr }, } - suoh, _ := NewStorageUnitOpenHandler(args) + suoh := NewStorageUnitOpenHandler(args) storer, err := suoh.GetMostRecentStorageUnit(config.DBConfig{}) assert.Nil(t, storer) @@ -82,7 +81,7 @@ func TestGetMostRecentBootstrapStorageUnit_CannotGetMostUpToDateDirectory(t *tes return []string{"0", "1"}, nil }, } - suoh, _ := NewStorageUnitOpenHandler(args) + suoh := NewStorageUnitOpenHandler(args) storer, err := suoh.GetMostRecentStorageUnit(config.DBConfig{}) assert.Nil(t, storer) @@ -109,7 +108,7 @@ func TestGetMostRecentBootstrapStorageUnit_CannotCreatePersister(t *testing.T) { }, nil, nil }, } - suoh, _ := NewStorageUnitOpenHandler(args) + suoh := NewStorageUnitOpenHandler(args) storer, err := suoh.GetMostRecentStorageUnit(config.DBConfig{}) assert.Nil(t, storer) @@ -135,7 +134,7 @@ func TestGetMostRecentBootstrapStorageUnit(t *testing.T) { }, nil, nil }, } - suoh, _ := NewStorageUnitOpenHandler(args) + suoh := NewStorageUnitOpenHandler(args) storer, err := suoh.GetMostRecentStorageUnit(generalConfig.BootstrapStorage.DB) assert.NoError(t, err) @@ -152,7 +151,7 @@ func TestStorageUnitOpenHandler_OpenDB(t *testing.T) { return tempDir }, } - suoh, _ := NewStorageUnitOpenHandler(args) + suoh := NewStorageUnitOpenHandler(args) // do not run these in parallel as they are using the same temp dir t.Run("create DB fails, should error", func(t *testing.T) { @@ -169,7 +168,7 @@ func TestStorageUnitOpenHandler_OpenDB(t *testing.T) { assert.NotNil(t, err) expectedErrorString := "not supported db type" assert.Equal(t, expectedErrorString, err.Error()) - assert.True(t, check.IfNil(storerInstance)) + assert.Nil(t, storerInstance) }) t.Run("should work", func(t *testing.T) { dbConfig := config.DBConfig{ @@ -183,9 +182,19 @@ func TestStorageUnitOpenHandler_OpenDB(t *testing.T) { storerInstance, err := suoh.OpenDB(dbConfig, 0, 0) assert.Nil(t, err) - assert.False(t, check.IfNil(storerInstance)) + assert.NotNil(t, storerInstance) _ = storerInstance.Close() }) } + +func TestOldDataCleanerProvider_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var osu *openStorageUnits + require.True(t, check.IfNil(osu)) + + osu = NewStorageUnitOpenHandler(createMockArgsOpenStorageUnits()) + require.False(t, check.IfNil(osu)) +} diff --git a/storage/factory/persisterFactory_test.go b/storage/factory/persisterFactory_test.go index 3443c5941fe..6b373032622 100644 --- a/storage/factory/persisterFactory_test.go +++ b/storage/factory/persisterFactory_test.go @@ -8,6 +8,7 @@ import ( "github.com/multiversx/mx-chain-go/config" "github.com/multiversx/mx-chain-go/storage" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func createDBConfig(dbType string) config.DBConfig { @@ -25,7 +26,7 @@ func TestNewPersisterFactory(t *testing.T) { t.Parallel() factoryInstance := NewPersisterFactory(createDBConfig("LvlDB")) - assert.False(t, check.IfNil(factoryInstance)) + assert.NotNil(t, check.IfNil(factoryInstance)) } func TestPersisterFactory_Create(t *testing.T) { @@ -85,6 +86,16 @@ func TestPersisterFactory_CreateDisabled(t *testing.T) { factoryInstance := NewPersisterFactory(createDBConfig("LvlDB")) persisterInstance := factoryInstance.CreateDisabled() - assert.False(t, check.IfNil(persisterInstance)) + assert.NotNil(t, persisterInstance) assert.Equal(t, "*disabled.errorDisabledPersister", fmt.Sprintf("%T", persisterInstance)) } + +func TestPersisterFactory_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var pf *PersisterFactory + require.True(t, check.IfNil(pf)) + + pf = NewPersisterFactory(config.DBConfig{}) + require.False(t, check.IfNil(pf)) +} diff --git a/storage/latestData/latestDataProvider_test.go b/storage/latestData/latestDataProvider_test.go index 8494f2257a2..181deb707e1 100644 --- a/storage/latestData/latestDataProvider_test.go +++ b/storage/latestData/latestDataProvider_test.go @@ -24,7 +24,7 @@ func TestNewLatestDataProvider_ShouldWork(t *testing.T) { t.Parallel() ldp, err := NewLatestDataProvider(getLatestDataProviderArgs()) - require.False(t, check.IfNil(ldp)) + require.NotNil(t, ldp) require.NoError(t, err) } @@ -374,3 +374,13 @@ func TestFullHistoryLoadEpochStartRoundMetachain(t *testing.T) { assert.NoError(t, err) assert.Equal(t, startRound, round) } + +func TestLatestDataProvider_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var ldp *latestDataProvider + require.True(t, check.IfNil(ldp)) + + ldp, _ = NewLatestDataProvider(getLatestDataProviderArgs()) + require.False(t, check.IfNil(ldp)) +} diff --git a/storage/pathmanager/pathManager_test.go b/storage/pathmanager/pathManager_test.go index ae50921a106..9c1e4e92857 100644 --- a/storage/pathmanager/pathManager_test.go +++ b/storage/pathmanager/pathManager_test.go @@ -6,13 +6,14 @@ import ( "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/storage/pathmanager" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestNewPathManager_EmptyPruningPathTemplateShouldErr(t *testing.T) { t.Parallel() pm, err := pathmanager.NewPathManager("", "shard_[S]/[I]", "db") - assert.True(t, check.IfNil(pm)) + assert.Nil(t, pm) assert.Equal(t, pathmanager.ErrEmptyPruningPathTemplate, err) } @@ -20,7 +21,7 @@ func TestNewPathManager_EmptyStaticPathTemplateShouldErr(t *testing.T) { t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "", "db") - assert.True(t, check.IfNil(pm)) + assert.Nil(t, pm) assert.Equal(t, pathmanager.ErrEmptyStaticPathTemplate, err) } @@ -28,7 +29,7 @@ func TestNewPathManager_EmptyDBPathTemplateShouldErr(t *testing.T) { t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]/[I]", "") - assert.True(t, check.IfNil(pm)) + assert.Nil(t, pm) assert.Equal(t, pathmanager.ErrInvalidDatabasePath, err) } @@ -36,7 +37,7 @@ func TestNewPathManager_InvalidPruningPathTemplate_NoShardPlaceholder_ShouldErr( t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard/[I]", "shard_[S]/[I]", "db") - assert.True(t, check.IfNil(pm)) + assert.Nil(t, pm) assert.Equal(t, pathmanager.ErrInvalidPruningPathTemplate, err) } @@ -44,7 +45,7 @@ func TestNewPathManager_InvalidPruningPathTemplate_NoEpochPlaceholder_ShouldErr( t.Parallel() pm, err := pathmanager.NewPathManager("epoch/shard_[S]/[I]", "shard_[S]/[I]", "db") - assert.True(t, check.IfNil(pm)) + assert.Nil(t, pm) assert.Equal(t, pathmanager.ErrInvalidPruningPathTemplate, err) } @@ -52,7 +53,7 @@ func TestNewPathManager_InvalidPathPruningTemplate_NoIdentifierPlaceholder_Shoul t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]", "shard_[S]/[I]", "db") - assert.True(t, check.IfNil(pm)) + assert.Nil(t, pm) assert.Equal(t, pathmanager.ErrInvalidPruningPathTemplate, err) } @@ -60,7 +61,7 @@ func TestNewPathManager_InvalidStaticPathTemplate_NoShardPlaceholder_ShouldErr(t t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard/[I]", "db") - assert.True(t, check.IfNil(pm)) + assert.Nil(t, pm) assert.Equal(t, pathmanager.ErrInvalidStaticPathTemplate, err) } @@ -68,7 +69,7 @@ func TestNewPathManager_InvalidStaticPathTemplate_NoIdentifierPlaceholder_Should t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]", "db") - assert.True(t, check.IfNil(pm)) + assert.Nil(t, pm) assert.Equal(t, pathmanager.ErrInvalidStaticPathTemplate, err) } @@ -76,7 +77,7 @@ func TestNewPathManager_OkValsShouldWork(t *testing.T) { t.Parallel() pm, err := pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]/[I]", "db") - assert.False(t, check.IfNil(pm)) + assert.NotNil(t, pm) assert.Nil(t, err) } @@ -168,3 +169,13 @@ func TestPathManager_PathForStatic(t *testing.T) { }) } } + +func TestPathManager_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var pm *pathmanager.PathManager + require.True(t, check.IfNil(pm)) + + pm, _ = pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]/[I]", "db") + require.False(t, check.IfNil(pm)) +} diff --git a/storage/pruning/fullHistoryPruningStorer_test.go b/storage/pruning/fullHistoryPruningStorer_test.go index 24adc389f9b..f86b118e1fe 100644 --- a/storage/pruning/fullHistoryPruningStorer_test.go +++ b/storage/pruning/fullHistoryPruningStorer_test.go @@ -34,7 +34,7 @@ func TestNewFullHistoryPruningStorer_OkValsShouldWork(t *testing.T) { } fhps, err := pruning.NewFullHistoryPruningStorer(fhArgs) - assert.False(t, check.IfNil(fhps)) + assert.NotNil(t, fhps) assert.Nil(t, err) } @@ -383,3 +383,18 @@ func TestFullHistoryPruningStorer_ConcurrentOperations(t *testing.T) { // if the "resource temporary unavailable" occurs, this test will take longer than this to execute require.True(t, elapsedTime < 100*time.Second) } + +func TestFullHistoryPruningStorer_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var fhps *pruning.FullHistoryPruningStorer + require.True(t, check.IfNil(fhps)) + + args := getDefaultArgs() + fhArgs := pruning.FullHistoryStorerArgs{ + StorerArgs: args, + NumOfOldActivePersisters: 10, + } + fhps, _ = pruning.NewFullHistoryPruningStorer(fhArgs) + require.False(t, check.IfNil(fhps)) +} diff --git a/storage/pruning/fullHistoryTriePruningStorer.go b/storage/pruning/fullHistoryTriePruningStorer.go index 092e9aaa1b1..63a0d9f1ba6 100644 --- a/storage/pruning/fullHistoryTriePruningStorer.go +++ b/storage/pruning/fullHistoryTriePruningStorer.go @@ -55,3 +55,8 @@ func (fhtps *fullHistoryTriePruningStorer) PutInEpoch(key []byte, data []byte, e func (fhtps *fullHistoryTriePruningStorer) Close() error { return fhtps.storerWithEpochOperations.Close() } + +// IsInterfaceNil returns true if there is no value under the interface +func (fhtps *fullHistoryTriePruningStorer) IsInterfaceNil() bool { + return fhtps == nil +} diff --git a/storage/pruning/fullHistoryTriePruningStorer_test.go b/storage/pruning/fullHistoryTriePruningStorer_test.go index e9f2196c93d..094cf96ea61 100644 --- a/storage/pruning/fullHistoryTriePruningStorer_test.go +++ b/storage/pruning/fullHistoryTriePruningStorer_test.go @@ -8,6 +8,7 @@ import ( "github.com/multiversx/mx-chain-go/storage/pruning" "github.com/multiversx/mx-chain-go/testscommon/storage" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestNewFullHistoryTriePruningStorer(t *testing.T) { @@ -20,7 +21,7 @@ func TestNewFullHistoryTriePruningStorer(t *testing.T) { } fhps, err := pruning.NewFullHistoryTriePruningStorer(fhArgs) assert.Nil(t, err) - assert.False(t, check.IfNil(fhps)) + assert.NotNil(t, fhps) } func TestFullHistoryTriePruningStorer_CallsMethodsFromUndelyingFHPS(t *testing.T) { @@ -118,3 +119,18 @@ func TestFullHistoryTriePruningStorer_CallsMethodsFromUndelyingFHPS(t *testing.T assert.True(t, closeCalled) }) } + +func TestFullHistoryTriePruningStorer_IsInterfaceNil(t *testing.T) { + t.Parallel() + + fhtps, _ := pruning.NewFullHistoryTriePruningStorer(pruning.FullHistoryStorerArgs{}) + require.True(t, check.IfNil(fhtps)) + + args := getDefaultArgs() + fhArgs := pruning.FullHistoryStorerArgs{ + StorerArgs: args, + NumOfOldActivePersisters: 10, + } + fhtps, _ = pruning.NewFullHistoryTriePruningStorer(fhArgs) + require.False(t, check.IfNil(fhtps)) +} diff --git a/storage/pruning/persistersTracker_test.go b/storage/pruning/persistersTracker_test.go index 7c19c61f8a1..c524e7e2ce2 100644 --- a/storage/pruning/persistersTracker_test.go +++ b/storage/pruning/persistersTracker_test.go @@ -5,6 +5,7 @@ import ( "github.com/multiversx/mx-chain-core-go/core/check" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func getArgs() EpochArgs { @@ -19,7 +20,7 @@ func TestNewPersistersTracker(t *testing.T) { t.Parallel() pt := NewPersistersTracker(getArgs()) - assert.False(t, check.IfNil(pt)) + assert.NotNil(t, pt) assert.Equal(t, int64(7), pt.oldestEpochKeep) assert.Equal(t, int64(8), pt.oldestEpochActive) } @@ -43,3 +44,13 @@ func TestPersistersTracker_ShouldClosePersister(t *testing.T) { assert.False(t, pt.ShouldClosePersister(8)) assert.True(t, pt.ShouldClosePersister(7)) } + +func TestPersistersTracker_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var npt *normalPersistersTracker + require.True(t, check.IfNil(npt)) + + npt = NewPersistersTracker(getArgs()) + require.False(t, check.IfNil(npt)) +} diff --git a/storage/pruning/pruningStorer_test.go b/storage/pruning/pruningStorer_test.go index 7b2b9ae47bc..f46cb0cabcd 100644 --- a/storage/pruning/pruningStorer_test.go +++ b/storage/pruning/pruningStorer_test.go @@ -132,7 +132,7 @@ func TestNewPruningStorer_InvalidNumberOfActivePersistersShouldErr(t *testing.T) ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrInvalidNumberOfPersisters, err) } @@ -144,7 +144,7 @@ func TestNewPruningStorer_NilPersistersTrackerShouldErr(t *testing.T) { ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrNilPersistersTracker, err) } @@ -157,7 +157,7 @@ func TestNewPruningStorer_NumEpochKeepLowerThanNumActiveShouldErr(t *testing.T) ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrEpochKeepIsLowerThanNumActive, err) } @@ -168,7 +168,7 @@ func TestNewPruningStorer_NilEpochStartHandlerShouldErr(t *testing.T) { args.Notifier = nil ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrNilEpochStartNotifier, err) } @@ -179,7 +179,7 @@ func TestNewPruningStorer_NilShardCoordinatorShouldErr(t *testing.T) { args.ShardCoordinator = nil ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrNilShardCoordinator, err) } @@ -190,7 +190,7 @@ func TestNewPruningStorer_NilPathManagerShouldErr(t *testing.T) { args.PathManager = nil ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrNilPathManager, err) } @@ -201,7 +201,7 @@ func TestNewPruningStorer_NilOldDataCleanerProviderShouldErr(t *testing.T) { args.OldDataCleanerProvider = nil ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrNilOldDataCleanerProvider, err) } @@ -212,7 +212,7 @@ func TestNewPruningStorer_NilCustomDatabaseRemoverProviderShouldErr(t *testing.T args.CustomDatabaseRemover = nil ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrNilCustomDatabaseRemover, err) } @@ -223,7 +223,7 @@ func TestNewPruningStorer_NilPersisterFactoryShouldErr(t *testing.T) { args.PersisterFactory = nil ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrNilPersisterFactory, err) } @@ -234,7 +234,7 @@ func TestNewPruningStorer_CacheSizeLowerThanBatchSizeShouldErr(t *testing.T) { args.MaxBatchSize = 11 ps, err := pruning.NewPruningStorer(args) - assert.True(t, check.IfNil(ps)) + assert.Nil(t, ps) assert.Equal(t, storage.ErrCacheSizeIsLowerThanBatchSize, err) } @@ -244,7 +244,7 @@ func TestNewPruningStorer_OkValsShouldWork(t *testing.T) { args := getDefaultArgs() ps, err := pruning.NewPruningStorer(args) - assert.False(t, check.IfNil(ps)) + assert.NotNil(t, ps) assert.Nil(t, err) assert.False(t, ps.IsInterfaceNil()) } @@ -1312,3 +1312,14 @@ func TestPruningStorer_RemoveFromCurrentEpoch(t *testing.T) { assert.Nil(t, errGet) assert.Equal(t, value, recovered) } + +func TestPruningStorer_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var ps *pruning.PruningStorer + require.True(t, check.IfNil(ps)) + + args := getDefaultArgs() + ps, _ = pruning.NewPruningStorer(args) + require.False(t, check.IfNil(ps)) +} diff --git a/storage/pruning/triePersistersTracker_test.go b/storage/pruning/triePersistersTracker_test.go index 08b379188ca..89beb2a5da7 100644 --- a/storage/pruning/triePersistersTracker_test.go +++ b/storage/pruning/triePersistersTracker_test.go @@ -8,13 +8,14 @@ import ( "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/storage/mock" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestNewTriePersistersTracker(t *testing.T) { t.Parallel() pt := NewTriePersisterTracker(getArgs()) - assert.False(t, check.IfNil(pt)) + assert.NotNil(t, pt) assert.Equal(t, int64(7), pt.oldestEpochKeep) assert.Equal(t, int64(8), pt.oldestEpochActive) assert.Equal(t, 0, pt.numDbsMarkedAsActive) @@ -137,3 +138,13 @@ func TestTriePersistersTracker_ShouldClosePersister(t *testing.T) { assert.False(t, pt.ShouldClosePersister(8)) } + +func TestTriePersistersTracker_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var tpt *triePersistersTracker + require.True(t, check.IfNil(tpt)) + + tpt = NewTriePersisterTracker(getArgs()) + require.False(t, check.IfNil(tpt)) +} diff --git a/storage/pruning/triePruningStorer_test.go b/storage/pruning/triePruningStorer_test.go index c4b04f02f5b..4e1829e0768 100644 --- a/storage/pruning/triePruningStorer_test.go +++ b/storage/pruning/triePruningStorer_test.go @@ -27,7 +27,7 @@ func TestNewTriePruningStorer(t *testing.T) { emptyAndInvalidConfig := pruning.StorerArgs{} tps, err := pruning.NewTriePruningStorer(emptyAndInvalidConfig) require.Error(t, err) - require.True(t, check.IfNil(tps)) + require.Nil(t, tps) }) t.Run("should work", func(t *testing.T) { @@ -36,7 +36,7 @@ func TestNewTriePruningStorer(t *testing.T) { args := getDefaultArgs() ps, err := pruning.NewTriePruningStorer(args) require.NoError(t, err) - require.False(t, check.IfNil(ps)) + require.NotNil(t, ps) }) } @@ -381,3 +381,14 @@ func TestTriePruningStorer_GetLatestStorageEpoch(t *testing.T) { assert.Equal(t, uint32(5), latestEpoch) }) } + +func TestTriePruningStorer_IsInterfaceNil(t *testing.T) { + t.Parallel() + + tps, _ := pruning.NewTriePruningStorer(pruning.StorerArgs{}) + require.True(t, check.IfNil(tps)) + + args := getDefaultArgs() + tps, _ = pruning.NewTriePruningStorer(args) + require.False(t, check.IfNil(tps)) +} diff --git a/storage/storageunit/storageunit_test.go b/storage/storageunit/storageunit_test.go index d66669dc5c9..9b9b125fa7e 100644 --- a/storage/storageunit/storageunit_test.go +++ b/storage/storageunit/storageunit_test.go @@ -7,6 +7,7 @@ import ( "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/storage/mock" "github.com/multiversx/mx-chain-go/storage/storageunit" + "github.com/multiversx/mx-chain-go/testscommon/storage" "github.com/multiversx/mx-chain-storage-go/common" "github.com/multiversx/mx-chain-go/testscommon" @@ -23,21 +24,21 @@ func TestNewStorageUnit(t *testing.T) { t.Parallel() unit, err := storageunit.NewStorageUnit(nil, persister) - assert.True(t, check.IfNil(unit)) + assert.Nil(t, unit) assert.Equal(t, common.ErrNilCacher, err) }) t.Run("nil persister should error", func(t *testing.T) { t.Parallel() unit, err := storageunit.NewStorageUnit(cacher, nil) - assert.True(t, check.IfNil(unit)) + assert.Nil(t, unit) assert.Equal(t, common.ErrNilPersister, err) }) t.Run("should work", func(t *testing.T) { t.Parallel() unit, err := storageunit.NewStorageUnit(cacher, persister) - assert.False(t, check.IfNil(unit)) + assert.NotNil(t, unit) assert.Nil(t, err) }) } @@ -123,7 +124,7 @@ func TestNewStorageUnitFromConf(t *testing.T) { } unit, err := storageunit.NewStorageUnitFromConf(cacheConfig, dbConfig) - assert.True(t, check.IfNil(unit)) + assert.Nil(t, unit) assert.Equal(t, common.ErrNotSupportedCacheType, err) }) t.Run("should work", func(t *testing.T) { @@ -135,7 +136,7 @@ func TestNewStorageUnitFromConf(t *testing.T) { } unit, err := storageunit.NewStorageUnitFromConf(cacheConfig, dbConfig) - assert.False(t, check.IfNil(unit)) + assert.NotNil(t, unit) assert.Nil(t, err) _ = unit.Close() }) @@ -145,7 +146,7 @@ func TestNewNilStorer(t *testing.T) { t.Parallel() unit := storageunit.NewNilStorer() - assert.False(t, check.IfNil(unit)) + assert.NotNil(t, unit) } func TestNewStorageCacherAdapter(t *testing.T) { @@ -153,7 +154,7 @@ func TestNewStorageCacherAdapter(t *testing.T) { cacher := &mock.AdaptedSizedLruCacheStub{} db := &mock.PersisterStub{} - storedDataFactory := &mock.StoredDataFactoryStub{} + storedDataFactory := &storage.StoredDataFactoryStub{} marshaller := &testscommon.MarshalizerStub{} t.Run("nil parameter should error", func(t *testing.T) { diff --git a/storage/txcache/txcache_test.go b/storage/txcache/txcache_test.go index 574b6bd3b7d..cd0ded4f133 100644 --- a/storage/txcache/txcache_test.go +++ b/storage/txcache/txcache_test.go @@ -4,7 +4,6 @@ import ( "strings" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/testscommon/txcachemocks" "github.com/multiversx/mx-chain-storage-go/common" "github.com/stretchr/testify/assert" @@ -27,7 +26,7 @@ func TestNewTxCache(t *testing.T) { } cache, err := NewTxCache(cfg, nil) - assert.True(t, check.IfNil(cache)) + assert.Nil(t, cache) assert.Equal(t, common.ErrNilTxGasHandler, err) }) t.Run("should work", func(t *testing.T) { @@ -48,7 +47,7 @@ func TestNewTxCache(t *testing.T) { MinimumGasPrice: 1, MinimumGasMove: 1, }) - assert.False(t, check.IfNil(cache)) + assert.NotNil(t, cache) assert.Nil(t, err) }) } @@ -57,7 +56,7 @@ func TestNewDisabledCache(t *testing.T) { t.Parallel() cache := NewDisabledCache() - assert.False(t, check.IfNil(cache)) + assert.NotNil(t, cache) } func TestNewCrossTxCache(t *testing.T) { @@ -75,7 +74,7 @@ func TestNewCrossTxCache(t *testing.T) { } cache, err := NewCrossTxCache(cfg) - assert.True(t, check.IfNil(cache)) + assert.Nil(t, cache) assert.ErrorIs(t, err, common.ErrInvalidConfig) assert.True(t, strings.Contains(err.Error(), "config.Name is invalid")) }) @@ -91,7 +90,7 @@ func TestNewCrossTxCache(t *testing.T) { } cache, err := NewCrossTxCache(cfg) - assert.False(t, check.IfNil(cache)) + assert.NotNil(t, cache) assert.Nil(t, err) }) } diff --git a/storage/mock/storedDataFactoryStub.go b/testscommon/storage/storedDataFactoryStub.go similarity index 95% rename from storage/mock/storedDataFactoryStub.go rename to testscommon/storage/storedDataFactoryStub.go index 1716f67b461..ef4d7f91902 100644 --- a/storage/mock/storedDataFactoryStub.go +++ b/testscommon/storage/storedDataFactoryStub.go @@ -1,4 +1,4 @@ -package mock +package storage // StoredDataFactoryStub - type StoredDataFactoryStub struct { From a42b0a66bb9ca260645dcc51d3679e5f0e4e7448 Mon Sep 17 00:00:00 2001 From: jules01 Date: Fri, 31 Mar 2023 20:38:32 +0300 Subject: [PATCH 3/4] refactor part 2 for the IsInterfaceNil tests --- storage/clean/oldDataCleanerProvider_test.go | 5 ++--- storage/clean/oldDatabaseCleaner_test.go | 5 ++--- storage/databaseremover/customDatabaseRemover_test.go | 5 ++--- storage/directoryhandler/directoryReader_test.go | 5 ++--- storage/disabled/errorDisabledPersister_test.go | 5 ++--- storage/disabled/persister_test.go | 3 +-- storage/disabled/storer_test.go | 3 +-- storage/factory/bootstrapDataProvider_test.go | 5 ++--- storage/factory/openStorage_test.go | 5 ++--- storage/factory/persisterFactory_test.go | 6 +++--- storage/latestData/latestDataProvider_test.go | 5 ++--- storage/pathmanager/pathManager_test.go | 5 ++--- storage/pruning/fullHistoryPruningStorer_test.go | 5 ++--- storage/pruning/fullHistoryTriePruningStorer_test.go | 5 ++--- storage/pruning/persistersTracker_test.go | 5 ++--- storage/pruning/pruningStorer_test.go | 5 ++--- storage/pruning/triePersistersTracker_test.go | 5 ++--- storage/pruning/triePruningStorer_test.go | 5 ++--- 18 files changed, 35 insertions(+), 52 deletions(-) diff --git a/storage/clean/oldDataCleanerProvider_test.go b/storage/clean/oldDataCleanerProvider_test.go index 288c18f57a8..9f6b8443de7 100644 --- a/storage/clean/oldDataCleanerProvider_test.go +++ b/storage/clean/oldDataCleanerProvider_test.go @@ -4,7 +4,6 @@ import ( "testing" "github.com/multiversx/mx-chain-core-go/core" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/config" "github.com/multiversx/mx-chain-go/storage" "github.com/multiversx/mx-chain-go/testscommon/nodeTypeProviderMock" @@ -75,8 +74,8 @@ func TestOldDataCleanerProvider_IsInterfaceNil(t *testing.T) { t.Parallel() var odcp *oldDataCleanerProvider - require.True(t, check.IfNil(odcp)) + require.True(t, odcp.IsInterfaceNil()) odcp, _ = NewOldDataCleanerProvider(&nodeTypeProviderMock.NodeTypeProviderStub{}, config.StoragePruningConfig{}) - require.False(t, check.IfNil(odcp)) + require.False(t, odcp.IsInterfaceNil()) } diff --git a/storage/clean/oldDatabaseCleaner_test.go b/storage/clean/oldDatabaseCleaner_test.go index 108b8c3d5dc..85736c33b18 100644 --- a/storage/clean/oldDatabaseCleaner_test.go +++ b/storage/clean/oldDatabaseCleaner_test.go @@ -4,7 +4,6 @@ import ( "errors" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-core-go/data/block" "github.com/multiversx/mx-chain-go/dataRetriever" "github.com/multiversx/mx-chain-go/epochStart" @@ -284,9 +283,9 @@ func TestOldDatabaseCleaner_IsInterfaceNil(t *testing.T) { t.Parallel() var odc *oldDatabaseCleaner - require.True(t, check.IfNil(odc)) + require.True(t, odc.IsInterfaceNil()) args := createMockArgs() odc, _ = NewOldDatabaseCleaner(args) - require.False(t, check.IfNil(odc)) + require.False(t, odc.IsInterfaceNil()) } diff --git a/storage/databaseremover/customDatabaseRemover_test.go b/storage/databaseremover/customDatabaseRemover_test.go index 8e5f4d75a68..907508d6a89 100644 --- a/storage/databaseremover/customDatabaseRemover_test.go +++ b/storage/databaseremover/customDatabaseRemover_test.go @@ -4,7 +4,6 @@ import ( "errors" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/config" "github.com/stretchr/testify/require" ) @@ -94,8 +93,8 @@ func TestCustomDatabaseRemover_IsInterfaceNil(t *testing.T) { t.Parallel() var cdr *customDatabaseRemover - require.True(t, check.IfNil(cdr)) + require.True(t, cdr.IsInterfaceNil()) cdr, _ = NewCustomDatabaseRemover(createCfgWithPattern("%2,%3")) - require.False(t, check.IfNil(cdr)) + require.False(t, cdr.IsInterfaceNil()) } diff --git a/storage/directoryhandler/directoryReader_test.go b/storage/directoryhandler/directoryReader_test.go index 425be4462ef..fb4a6a077c6 100644 --- a/storage/directoryhandler/directoryReader_test.go +++ b/storage/directoryhandler/directoryReader_test.go @@ -6,7 +6,6 @@ import ( "path/filepath" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -160,10 +159,10 @@ func TestDirectoryReader_IsInterfaceNil(t *testing.T) { t.Parallel() var dr *directoryReader - require.True(t, check.IfNil(dr)) + require.True(t, dr.IsInterfaceNil()) dr = NewDirectoryReader() - require.False(t, check.IfNil(dr)) + require.False(t, dr.IsInterfaceNil()) } func contains(s []string, e string) bool { diff --git a/storage/disabled/errorDisabledPersister_test.go b/storage/disabled/errorDisabledPersister_test.go index 5d05d3401e2..407f7ea4ddd 100644 --- a/storage/disabled/errorDisabledPersister_test.go +++ b/storage/disabled/errorDisabledPersister_test.go @@ -3,7 +3,6 @@ package disabled import ( "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -96,8 +95,8 @@ func TestErrorDisabledPersister_IsInterfaceNil(t *testing.T) { t.Parallel() var edp *errorDisabledPersister - require.True(t, check.IfNil(edp)) + require.True(t, edp.IsInterfaceNil()) edp = NewErrorDisabledPersister() - require.False(t, check.IfNil(edp)) + require.False(t, edp.IsInterfaceNil()) } diff --git a/storage/disabled/persister_test.go b/storage/disabled/persister_test.go index aee9666f98e..2b8e53d5ef1 100644 --- a/storage/disabled/persister_test.go +++ b/storage/disabled/persister_test.go @@ -4,7 +4,6 @@ import ( "fmt" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/storage" "github.com/stretchr/testify/assert" ) @@ -20,7 +19,7 @@ func TestPersister_MethodsDoNotPanic(t *testing.T) { }() p := NewPersister() - assert.False(t, check.IfNil(p)) + assert.False(t, p.IsInterfaceNil()) assert.Nil(t, p.Put(nil, nil)) assert.Equal(t, storage.ErrKeyNotFound, p.Has(nil)) assert.Nil(t, p.Close()) diff --git a/storage/disabled/storer_test.go b/storage/disabled/storer_test.go index f7dd2a8a840..95fb7811fad 100644 --- a/storage/disabled/storer_test.go +++ b/storage/disabled/storer_test.go @@ -4,7 +4,6 @@ import ( "fmt" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-storage-go/common" "github.com/stretchr/testify/assert" ) @@ -20,7 +19,7 @@ func TestStorer_MethodsDoNotPanic(t *testing.T) { }() s := NewStorer() - assert.False(t, check.IfNil(s)) + assert.False(t, s.IsInterfaceNil()) assert.Nil(t, s.Put(nil, nil)) assert.Nil(t, s.PutInEpoch(nil, nil, 0)) assert.Nil(t, s.Has(nil)) diff --git a/storage/factory/bootstrapDataProvider_test.go b/storage/factory/bootstrapDataProvider_test.go index 6f28356f234..46e622fa980 100644 --- a/storage/factory/bootstrapDataProvider_test.go +++ b/storage/factory/bootstrapDataProvider_test.go @@ -5,7 +5,6 @@ import ( "strconv" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/process/block/bootstrapStorage" "github.com/multiversx/mx-chain-go/storage" @@ -98,8 +97,8 @@ func TestBootstrapDataProvider_IsInterfaceNil(t *testing.T) { t.Parallel() var bdp *bootstrapDataProvider - require.True(t, check.IfNil(bdp)) + require.True(t, bdp.IsInterfaceNil()) bdp, _ = NewBootstrapDataProvider(&mock.MarshalizerMock{}) - require.False(t, check.IfNil(bdp)) + require.False(t, bdp.IsInterfaceNil()) } diff --git a/storage/factory/openStorage_test.go b/storage/factory/openStorage_test.go index 195708fee87..78bee78c57e 100644 --- a/storage/factory/openStorage_test.go +++ b/storage/factory/openStorage_test.go @@ -5,7 +5,6 @@ import ( "strings" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/config" "github.com/multiversx/mx-chain-go/process/block/bootstrapStorage" "github.com/multiversx/mx-chain-go/storage" @@ -193,8 +192,8 @@ func TestOldDataCleanerProvider_IsInterfaceNil(t *testing.T) { t.Parallel() var osu *openStorageUnits - require.True(t, check.IfNil(osu)) + require.True(t, osu.IsInterfaceNil()) osu = NewStorageUnitOpenHandler(createMockArgsOpenStorageUnits()) - require.False(t, check.IfNil(osu)) + require.False(t, osu.IsInterfaceNil()) } diff --git a/storage/factory/persisterFactory_test.go b/storage/factory/persisterFactory_test.go index 6b373032622..3aee6a0132e 100644 --- a/storage/factory/persisterFactory_test.go +++ b/storage/factory/persisterFactory_test.go @@ -26,7 +26,7 @@ func TestNewPersisterFactory(t *testing.T) { t.Parallel() factoryInstance := NewPersisterFactory(createDBConfig("LvlDB")) - assert.NotNil(t, check.IfNil(factoryInstance)) + assert.NotNil(t, factoryInstance) } func TestPersisterFactory_Create(t *testing.T) { @@ -94,8 +94,8 @@ func TestPersisterFactory_IsInterfaceNil(t *testing.T) { t.Parallel() var pf *PersisterFactory - require.True(t, check.IfNil(pf)) + require.True(t, pf.IsInterfaceNil()) pf = NewPersisterFactory(config.DBConfig{}) - require.False(t, check.IfNil(pf)) + require.False(t, pf.IsInterfaceNil()) } diff --git a/storage/latestData/latestDataProvider_test.go b/storage/latestData/latestDataProvider_test.go index 181deb707e1..035a521b8a2 100644 --- a/storage/latestData/latestDataProvider_test.go +++ b/storage/latestData/latestDataProvider_test.go @@ -8,7 +8,6 @@ import ( "testing" "github.com/multiversx/mx-chain-core-go/core" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-core-go/data/block" "github.com/multiversx/mx-chain-core-go/marshal" "github.com/multiversx/mx-chain-go/config" @@ -379,8 +378,8 @@ func TestLatestDataProvider_IsInterfaceNil(t *testing.T) { t.Parallel() var ldp *latestDataProvider - require.True(t, check.IfNil(ldp)) + require.True(t, ldp.IsInterfaceNil()) ldp, _ = NewLatestDataProvider(getLatestDataProviderArgs()) - require.False(t, check.IfNil(ldp)) + require.False(t, ldp.IsInterfaceNil()) } diff --git a/storage/pathmanager/pathManager_test.go b/storage/pathmanager/pathManager_test.go index 9c1e4e92857..c29c9f01b2c 100644 --- a/storage/pathmanager/pathManager_test.go +++ b/storage/pathmanager/pathManager_test.go @@ -3,7 +3,6 @@ package pathmanager_test import ( "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/storage/pathmanager" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -174,8 +173,8 @@ func TestPathManager_IsInterfaceNil(t *testing.T) { t.Parallel() var pm *pathmanager.PathManager - require.True(t, check.IfNil(pm)) + require.True(t, pm.IsInterfaceNil()) pm, _ = pathmanager.NewPathManager("epoch_[E]/shard_[S]/[I]", "shard_[S]/[I]", "db") - require.False(t, check.IfNil(pm)) + require.False(t, pm.IsInterfaceNil()) } diff --git a/storage/pruning/fullHistoryPruningStorer_test.go b/storage/pruning/fullHistoryPruningStorer_test.go index f86b118e1fe..62c2d0c3b8c 100644 --- a/storage/pruning/fullHistoryPruningStorer_test.go +++ b/storage/pruning/fullHistoryPruningStorer_test.go @@ -10,7 +10,6 @@ import ( "testing" "time" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-core-go/core/random" storageCore "github.com/multiversx/mx-chain-core-go/storage" "github.com/multiversx/mx-chain-go/config" @@ -388,7 +387,7 @@ func TestFullHistoryPruningStorer_IsInterfaceNil(t *testing.T) { t.Parallel() var fhps *pruning.FullHistoryPruningStorer - require.True(t, check.IfNil(fhps)) + require.True(t, fhps.IsInterfaceNil()) args := getDefaultArgs() fhArgs := pruning.FullHistoryStorerArgs{ @@ -396,5 +395,5 @@ func TestFullHistoryPruningStorer_IsInterfaceNil(t *testing.T) { NumOfOldActivePersisters: 10, } fhps, _ = pruning.NewFullHistoryPruningStorer(fhArgs) - require.False(t, check.IfNil(fhps)) + require.False(t, fhps.IsInterfaceNil()) } diff --git a/storage/pruning/fullHistoryTriePruningStorer_test.go b/storage/pruning/fullHistoryTriePruningStorer_test.go index 094cf96ea61..9994c35c464 100644 --- a/storage/pruning/fullHistoryTriePruningStorer_test.go +++ b/storage/pruning/fullHistoryTriePruningStorer_test.go @@ -3,7 +3,6 @@ package pruning_test import ( "testing" - "github.com/multiversx/mx-chain-core-go/core/check" storageCore "github.com/multiversx/mx-chain-core-go/storage" "github.com/multiversx/mx-chain-go/storage/pruning" "github.com/multiversx/mx-chain-go/testscommon/storage" @@ -124,7 +123,7 @@ func TestFullHistoryTriePruningStorer_IsInterfaceNil(t *testing.T) { t.Parallel() fhtps, _ := pruning.NewFullHistoryTriePruningStorer(pruning.FullHistoryStorerArgs{}) - require.True(t, check.IfNil(fhtps)) + require.True(t, fhtps.IsInterfaceNil()) args := getDefaultArgs() fhArgs := pruning.FullHistoryStorerArgs{ @@ -132,5 +131,5 @@ func TestFullHistoryTriePruningStorer_IsInterfaceNil(t *testing.T) { NumOfOldActivePersisters: 10, } fhtps, _ = pruning.NewFullHistoryTriePruningStorer(fhArgs) - require.False(t, check.IfNil(fhtps)) + require.False(t, fhtps.IsInterfaceNil()) } diff --git a/storage/pruning/persistersTracker_test.go b/storage/pruning/persistersTracker_test.go index c524e7e2ce2..0c19e51ce8a 100644 --- a/storage/pruning/persistersTracker_test.go +++ b/storage/pruning/persistersTracker_test.go @@ -3,7 +3,6 @@ package pruning import ( "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) @@ -49,8 +48,8 @@ func TestPersistersTracker_IsInterfaceNil(t *testing.T) { t.Parallel() var npt *normalPersistersTracker - require.True(t, check.IfNil(npt)) + require.True(t, npt.IsInterfaceNil()) npt = NewPersistersTracker(getArgs()) - require.False(t, check.IfNil(npt)) + require.False(t, npt.IsInterfaceNil()) } diff --git a/storage/pruning/pruningStorer_test.go b/storage/pruning/pruningStorer_test.go index f46cb0cabcd..113eaf6ab26 100644 --- a/storage/pruning/pruningStorer_test.go +++ b/storage/pruning/pruningStorer_test.go @@ -15,7 +15,6 @@ import ( "testing" "time" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-core-go/core/random" "github.com/multiversx/mx-chain-core-go/data/block" "github.com/multiversx/mx-chain-go/config" @@ -1317,9 +1316,9 @@ func TestPruningStorer_IsInterfaceNil(t *testing.T) { t.Parallel() var ps *pruning.PruningStorer - require.True(t, check.IfNil(ps)) + require.True(t, ps.IsInterfaceNil()) args := getDefaultArgs() ps, _ = pruning.NewPruningStorer(args) - require.False(t, check.IfNil(ps)) + require.False(t, ps.IsInterfaceNil()) } diff --git a/storage/pruning/triePersistersTracker_test.go b/storage/pruning/triePersistersTracker_test.go index 89beb2a5da7..a813b4c4d77 100644 --- a/storage/pruning/triePersistersTracker_test.go +++ b/storage/pruning/triePersistersTracker_test.go @@ -4,7 +4,6 @@ import ( "bytes" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/storage/mock" "github.com/stretchr/testify/assert" @@ -143,8 +142,8 @@ func TestTriePersistersTracker_IsInterfaceNil(t *testing.T) { t.Parallel() var tpt *triePersistersTracker - require.True(t, check.IfNil(tpt)) + require.True(t, tpt.IsInterfaceNil()) tpt = NewTriePersisterTracker(getArgs()) - require.False(t, check.IfNil(tpt)) + require.False(t, tpt.IsInterfaceNil()) } diff --git a/storage/pruning/triePruningStorer_test.go b/storage/pruning/triePruningStorer_test.go index 4e1829e0768..e5544fd4147 100644 --- a/storage/pruning/triePruningStorer_test.go +++ b/storage/pruning/triePruningStorer_test.go @@ -4,7 +4,6 @@ import ( "strings" "testing" - "github.com/multiversx/mx-chain-core-go/core/check" "github.com/multiversx/mx-chain-go/common" "github.com/multiversx/mx-chain-go/storage" "github.com/multiversx/mx-chain-go/storage/mock" @@ -386,9 +385,9 @@ func TestTriePruningStorer_IsInterfaceNil(t *testing.T) { t.Parallel() tps, _ := pruning.NewTriePruningStorer(pruning.StorerArgs{}) - require.True(t, check.IfNil(tps)) + require.True(t, tps.IsInterfaceNil()) args := getDefaultArgs() tps, _ = pruning.NewTriePruningStorer(args) - require.False(t, check.IfNil(tps)) + require.False(t, tps.IsInterfaceNil()) } From a709d26a7783097664b42ba914213de61c5856b0 Mon Sep 17 00:00:00 2001 From: jules01 Date: Mon, 3 Apr 2023 10:32:11 +0300 Subject: [PATCH 4/4] - fixed test name --- storage/pruning/triePruningStorer_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/storage/pruning/triePruningStorer_test.go b/storage/pruning/triePruningStorer_test.go index e5544fd4147..b3deebb98c2 100644 --- a/storage/pruning/triePruningStorer_test.go +++ b/storage/pruning/triePruningStorer_test.go @@ -370,7 +370,7 @@ func TestTriePruningStorer_GetLatestStorageEpoch(t *testing.T) { assert.Equal(t, expectedErrString, err.Error()) assert.Zero(t, latestEpoch) }) - t.Run("no active db should error", func(t *testing.T) { + t.Run("with at least one active DB should work", func(t *testing.T) { t.Parallel() tps, _ := pruning.NewTriePruningStorer(args)