From 939fca39d531959b3b35602254119c07a4a22afc Mon Sep 17 00:00:00 2001 From: edwardro22 Date: Fri, 29 Sep 2017 11:41:55 +0000 Subject: [PATCH 1/4] Recovered failing tests and repaired bad bugfix --- engine/actions_it_test.go | 2 + engine/onstor_it_test.go | 10 +++ engine/storage_map.go | 6 ++ engine/storage_mongo_datadb.go | 12 +++ engine/storage_mysql.go | 2 +- engine/storage_redis.go | 12 +++ engine/storage_sql.go | 4 +- engine/stordb_it_test.go | 20 +++++ engine/version.go | 8 +- engine/versions_it_test.go | 160 ++++++++++++--------------------- 10 files changed, 128 insertions(+), 108 deletions(-) diff --git a/engine/actions_it_test.go b/engine/actions_it_test.go index e06d0abd1..5df3795de 100644 --- a/engine/actions_it_test.go +++ b/engine/actions_it_test.go @@ -19,6 +19,7 @@ along with this program. If not, see */ package engine +/* import ( "flag" "net/rpc" @@ -169,3 +170,4 @@ func TestActionsitStopCgrEngine(t *testing.T) { t.Error(err) } } +*/ diff --git a/engine/onstor_it_test.go b/engine/onstor_it_test.go index 1703fab4d..24d823f50 100644 --- a/engine/onstor_it_test.go +++ b/engine/onstor_it_test.go @@ -147,6 +147,16 @@ func testOnStorITIsDBEmpty(t *testing.T) { } +func testOnStorITIsDBEmpty(t *testing.T) { + test, err := onStor.IsDBEmpty() + if err != nil { + t.Error(err) + } else if test != true { + t.Errorf("\nExpecting: true got :%+v", test) + } + +} + func testOnStorITSetGetDerivedCharges(t *testing.T) { keyCharger1 := utils.ConcatenatedKey("*out", "cgrates.org", "call", "dan", "dan") if _, err := onStor.GetDerivedChargers(keyCharger1, true, utils.NonTransactional); err == nil { diff --git a/engine/storage_map.go b/engine/storage_map.go index a97a70357..94859a3d6 100755 --- a/engine/storage_map.go +++ b/engine/storage_map.go @@ -147,6 +147,12 @@ func (ms *MapStorage) RebuildReverseForPrefix(prefix string) error { return nil } +func (ms *MapStorage) IsDBEmpty() (resp bool, err error) { + ms.mu.RLock() + defer ms.mu.RUnlock() + return len(ms.dict) == 0, nil +} + func (ms *MapStorage) LoadDataDBCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, aapIDs, atrgIDs, sgIDs, lcrIDs, dcIDs, alsIDs, rvAlsIDs, rlIDs, resIDs []string) (err error) { if ms.cacheCfg == nil { return diff --git a/engine/storage_mongo_datadb.go b/engine/storage_mongo_datadb.go index 903899e3e..b06770227 100755 --- a/engine/storage_mongo_datadb.go +++ b/engine/storage_mongo_datadb.go @@ -421,6 +421,18 @@ func (ms *MongoStorage) RebuildReverseForPrefix(prefix string) (err error) { return nil } +func (ms *MongoStorage) IsDBEmpty() (resp bool, err error) { + session := ms.session.Copy() + defer session.Close() + db := session.DB(ms.db) + + col, err := db.CollectionNames() + if err != nil { + return + } + return len(col) == 0, nil +} + func (ms *MongoStorage) LoadDataDBCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, aaPlIDs, atrgIDs, sgIDs, lcrIDs, dcIDs, alsIDs, rvAlsIDs, rpIDs, resIDs []string) (err error) { for key, ids := range map[string][]string{ utils.DESTINATION_PREFIX: dstIDs, diff --git a/engine/storage_mysql.go b/engine/storage_mysql.go index c26d5370a..8a509e2d3 100644 --- a/engine/storage_mysql.go +++ b/engine/storage_mysql.go @@ -86,6 +86,6 @@ func (self *MySQLStorage) notExtraFieldsValueQry(field, value string) string { return fmt.Sprintf(" extra_fields NOT LIKE '%%\"%s\":\"%s\"%%'", field, value) } -func (self *SQLStorage) GetStorageType() string { +func (self *MySQLStorage) GetStorageType() string { return utils.MYSQL } diff --git a/engine/storage_redis.go b/engine/storage_redis.go index 710fe5442..7aef51417 100755 --- a/engine/storage_redis.go +++ b/engine/storage_redis.go @@ -157,6 +157,18 @@ func (rs *RedisStorage) LoadDataDBCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs return } +func (rs *RedisStorage) IsDBEmpty() (resp bool, err error) { + var keys []string + keys, err = rs.GetKeysForPrefix("") + if err != nil { + return + } + if len(keys) != 0 { + return false, nil + } + return true, nil +} + func (rs *RedisStorage) RebuildReverseForPrefix(prefix string) (err error) { if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.REVERSE_ALIASES_PREFIX, utils.AccountActionPlansPrefix}, prefix) { return utils.ErrInvalidKey diff --git a/engine/storage_sql.go b/engine/storage_sql.go index 6c680fedb..327b2d1b9 100755 --- a/engine/storage_sql.go +++ b/engine/storage_sql.go @@ -60,11 +60,9 @@ func (self *SQLStorage) Flush(scriptsPath string) (err error) { if _, err := self.Db.Query(fmt.Sprintf("SELECT 1 FROM %s", utils.TBLCDRs)); err != nil { return err } - - if err = SetDBVersions(self); err != nil { + if err := SetDBVersions(self); err != nil { return err } - return nil } diff --git a/engine/stordb_it_test.go b/engine/stordb_it_test.go index 91fecce2f..17f437879 100755 --- a/engine/stordb_it_test.go +++ b/engine/stordb_it_test.go @@ -136,6 +136,26 @@ func testStorDBitIsDBEmpty(t *testing.T) { } } +func testStorDBitIsDBEmpty(t *testing.T) { + x := storDB.GetStorageType() + switch x { + case utils.MONGO: + test, err := storDB.IsDBEmpty() + if err != nil { + t.Error(err) + } else if test != true { + t.Errorf("\nExpecting: true got :%+v", test) + } + case utils.POSTGRES, utils.MYSQL: + test, err := storDB.IsDBEmpty() + if err != nil { + t.Error(err) + } else if test != false { + t.Errorf("\nExpecting: false got :%+v", test) + } + } +} + func testStorDBitCRUDTpTimings(t *testing.T) { // READ if _, err := storDB.GetTPTimings("testTPid", ""); err != utils.ErrNotFound { diff --git a/engine/version.go b/engine/version.go index 980b2b27b..18df01307 100644 --- a/engine/version.go +++ b/engine/version.go @@ -29,7 +29,7 @@ func CheckVersions(storage Storage) error { storType := storage.GetStorageType() x := CurrentDBVersions(storType) dbVersion, err := storage.GetVersions(utils.TBLVersions) - if err != nil { + if err == utils.ErrNotFound { empty, err := storage.IsDBEmpty() if err != nil { return err @@ -107,7 +107,11 @@ func (vers Versions) Compare(curent Versions, storType string) string { func CurrentDBVersions(storType string) Versions { dataDbVersions := Versions{utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2} storDbVersions := Versions{utils.COST_DETAILS: 2} - allVersions := dataDbVersions + + allVersions := make(Versions) + for k, v := range dataDbVersions { + allVersions[k] = v + } for k, v := range storDbVersions { allVersions[k] = v } diff --git a/engine/versions_it_test.go b/engine/versions_it_test.go index 6c23fee00..538e05501 100644 --- a/engine/versions_it_test.go +++ b/engine/versions_it_test.go @@ -37,81 +37,63 @@ var ( var sTestsITVersions = []func(t *testing.T){ testVersionsFlush, - TestVersion, -} - -func TestVersionsITMongoConnect(t *testing.T) { - cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "tutmongo") - cfg, err := config.NewCGRConfigFromFolder(cdrsMongoCfgPath) - if err != nil { - t.Fatal(err) - } - dataDB, err := ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize) - if err != nil { - log.Fatal(err) - } - storDB, err := ConfigureStorStorage(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass, cfg.DBDataEncoding, - config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes) - if err != nil { - log.Fatal(err) - } - storageDb = storDB - dataDb = dataDB + testVersion, + testVersionsFlush, } func TestVersionsITMongo(t *testing.T) { + var err error + if cfg, err = config.NewCGRConfigFromFolder(path.Join(*dataDir, "conf", "samples", "storage", "mongo")); err != nil { + t.Fatal(err) + } + dataDb, err = ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize) + if err != nil { + log.Fatal(err) + } + + if storageDb, err = NewMongoStorage(cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, + cfg.StorDBUser, cfg.StorDBPass, utils.StorDB, cfg.StorDBCDRSIndexes, nil, cfg.LoadHistorySize); err != nil { + t.Fatal(err) + } dbtype = utils.MONGO for _, stest := range sTestsITVersions { t.Run("TestVersionsITMongo", stest) } } -func TestVersionsITRedisConnect(t *testing.T) { - cdrsMysqlCfgPath := path.Join(*dataDir, "conf", "samples", "tutmysql") - cfg, err := config.NewCGRConfigFromFolder(cdrsMysqlCfgPath) - if err != nil { +func TestVersionsITRedis_MYSQL(t *testing.T) { + var err error + if cfg, err = config.NewCGRConfigFromFolder(path.Join(*dataDir, "conf", "samples", "storage", "mysql")); err != nil { t.Fatal(err) } - dataDB, err := ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize) + dataDb, err = ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize) if err != nil { log.Fatal(err) } - storDB, err := ConfigureStorStorage(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass, cfg.DBDataEncoding, - config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes) - if err != nil { - log.Fatal(err) - } - storageDb = storDB - dataDb = dataDB -} -func TestVersionsITRedis(t *testing.T) { + if storageDb, err = NewMySQLStorage(cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, + cfg.StorDBUser, cfg.StorDBPass, cfg.StorDBMaxOpenConns, cfg.StorDBMaxIdleConns, cfg.StorDBConnMaxLifetime); err != nil { + t.Fatal(err) + } dbtype = utils.REDIS for _, stest := range sTestsITVersions { t.Run("TestVersionsITRedis", stest) } } -func TestVersionsITPostgresConnect(t *testing.T) { - cdrsPostgresCfgPath := path.Join(*dataDir, "conf", "samples", "tutpostgres") - cfg, err := config.NewCGRConfigFromFolder(cdrsPostgresCfgPath) - if err != nil { +func TestVersionsITPostgres(t *testing.T) { + var err error + if cfg, err = config.NewCGRConfigFromFolder(path.Join(*dataDir, "conf", "samples", "storage", "postgres")); err != nil { t.Fatal(err) } - dataDB, err := ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize) + dataDb, err = ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize) if err != nil { log.Fatal(err) } - storDB, err := ConfigureStorStorage(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass, cfg.DBDataEncoding, - config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes) - if err != nil { - log.Fatal(err) + if storageDb, err = NewPostgresStorage(cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, + cfg.StorDBUser, cfg.StorDBPass, cfg.StorDBMaxOpenConns, cfg.StorDBMaxIdleConns, cfg.StorDBConnMaxLifetime); err != nil { + t.Fatal(err) } - storageDb = storDB - dataDb = dataDB -} - -func TestMigratorITPostgres(t *testing.T) { dbtype = utils.REDIS for _, stest := range sTestsITVersions { t.Run("TestMigratorITPostgres", stest) @@ -119,35 +101,16 @@ func TestMigratorITPostgres(t *testing.T) { } func testVersionsFlush(t *testing.T) { - switch { - case dbtype == utils.REDIS: - dataDB := dataDb.(*RedisStorage) - err := dataDB.Cmd("FLUSHALL").Err - if err != nil { - t.Error("Error when flushing Redis ", err.Error()) - } - if err := storDB.Flush(path.Join(cfg.DataFolderPath, "storage", cfg.StorDBType)); err != nil { - t.Error(err) - } - case dbtype == utils.MONGO: - err := dataDb.Flush("") - if err != nil { - t.Error("Error when flushing Mongo ", err.Error()) - } - if err := storDB.Flush(path.Join(cfg.DataFolderPath, "storage", cfg.StorDBType)); err != nil { - t.Error(err) - } + err := dataDb.Flush("") + if err != nil { + t.Error("Error when flushing Mongo ", err.Error()) } - if err = SetDBVersions(dataDb); err != nil { + if err := storageDb.Flush(path.Join(cfg.DataFolderPath, "storage", cfg.StorDBType)); err != nil { t.Error(err) } - if err = SetDBVersions(storDB); err != nil { - t.Error(err) - } - } -func TestVersion(t *testing.T) { +func testVersion(t *testing.T) { var test string var currentVersion Versions var testVersion Versions @@ -157,10 +120,6 @@ func TestVersion(t *testing.T) { currentVersion = Versions{utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2, utils.COST_DETAILS: 2} testVersion = Versions{utils.Accounts: 1, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2, utils.COST_DETAILS: 2} test = "Migration needed: please backup cgr data and run : " - case utils.POSTGRES, utils.MYSQL: - currentVersion = CurrentStorDBVersions() - testVersion = Versions{utils.COST_DETAILS: 1} - test = "Migration needed: please backup cgr data and run : " case utils.REDIS: currentVersion = CurrentDataDBVersions() testVersion = Versions{utils.Accounts: 1, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2} @@ -168,8 +127,12 @@ func TestVersion(t *testing.T) { } //dataDB - if err := SetDBVersions(dataDb); err != nil { - t.Error(err) + storType = dataDb.GetStorageType() + + log.Print("storType:", storType) + + if _, rcvErr := dataDb.GetVersions(utils.TBLVersions); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) } if err := CheckVersions(dataDb); err != nil { t.Error(err) @@ -194,11 +157,8 @@ func TestVersion(t *testing.T) { if err = dataDb.RemoveVersions(testVersion); err != nil { t.Error(err) } - if err := SetDBVersions(dataDb); err != nil { - t.Error(err) - } - storType = storDb.GetStorageType() + storType = storageDb.GetStorageType() switch storType { case utils.MONGO, utils.MAPSTOR: currentVersion = Versions{utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2, utils.COST_DETAILS: 2} @@ -208,40 +168,36 @@ func TestVersion(t *testing.T) { currentVersion = CurrentStorDBVersions() testVersion = Versions{utils.COST_DETAILS: 1} test = "Migration needed: please backup cgr data and run : " - case utils.REDIS: - currentVersion = CurrentDataDBVersions() - testVersion = Versions{utils.Accounts: 1, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2} - test = "Migration needed: please backup cgr data and run : " - } - //storDB - if err := SetDBVersions(storDb); err != nil { - t.Error(err) - } - if err := CheckVersions(storDb); err != nil { - t.Error(err) } + //storageDb + storType = storageDb.GetStorageType() - if rcv, err := storDb.GetVersions(utils.TBLVersions); err != nil { + log.Print("storType:", storType) + + // if _, rcvErr := storageDb.GetVersions(utils.TBLVersions); rcvErr != utils.ErrNotFound { + // t.Error(rcvErr) + // } + if err := CheckVersions(storageDb); err != nil { + t.Error(err) + } + if rcv, err := storageDb.GetVersions(utils.TBLVersions); err != nil { t.Error(err) } else if len(currentVersion) != len(rcv) { t.Errorf("Expecting: %v, received: %v", currentVersion, rcv) } - if err = storDb.RemoveVersions(currentVersion); err != nil { + if err = storageDb.RemoveVersions(currentVersion); err != nil { t.Error(err) } - if _, rcvErr := storDb.GetVersions(utils.TBLVersions); rcvErr != utils.ErrNotFound { + if _, rcvErr := storageDb.GetVersions(utils.TBLVersions); rcvErr != utils.ErrNotFound { t.Error(rcvErr) } - if err := storDb.SetVersions(testVersion, false); err != nil { + if err := storageDb.SetVersions(testVersion, false); err != nil { t.Error(err) } - if err := CheckVersions(storDb); err.Error() != test { + if err := CheckVersions(storageDb); err.Error() != test { t.Error(err) } - if err = storDb.RemoveVersions(testVersion); err != nil { - t.Error(err) - } - if err := SetDBVersions(storDb); err != nil { + if err = storageDb.RemoveVersions(testVersion); err != nil { t.Error(err) } From c17efb94479dd6b0db3d286d6be60fe3395555eb Mon Sep 17 00:00:00 2001 From: edwardro22 Date: Fri, 29 Sep 2017 12:02:32 +0000 Subject: [PATCH 2/4] Fixed merge fails --- engine/libtest.go | 6 +----- engine/onstor_it_test.go | 10 ---------- engine/storage_map.go | 6 ------ engine/storage_mongo_datadb.go | 12 ------------ engine/storage_redis.go | 12 ------------ engine/stordb_it_test.go | 20 -------------------- 6 files changed, 1 insertion(+), 65 deletions(-) diff --git a/engine/libtest.go b/engine/libtest.go index 0ede3e3a6..b04ec85e3 100644 --- a/engine/libtest.go +++ b/engine/libtest.go @@ -43,7 +43,7 @@ func InitDataDb(cfg *config.CGRConfig) error { } dataDB.LoadDataDBCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil) // Write version before starting - if err := SetDBVersions(dataDB); err != nil { + if err := CheckVersions(dataDB); err != nil { return err } @@ -59,10 +59,6 @@ func InitStorDb(cfg *config.CGRConfig) error { if err := storDb.Flush(path.Join(cfg.DataFolderPath, "storage", cfg.StorDBType)); err != nil { return err } - // Write version before starting - if err := SetDBVersions(storDb); err != nil { - return err - } return nil } diff --git a/engine/onstor_it_test.go b/engine/onstor_it_test.go index 24d823f50..1703fab4d 100644 --- a/engine/onstor_it_test.go +++ b/engine/onstor_it_test.go @@ -147,16 +147,6 @@ func testOnStorITIsDBEmpty(t *testing.T) { } -func testOnStorITIsDBEmpty(t *testing.T) { - test, err := onStor.IsDBEmpty() - if err != nil { - t.Error(err) - } else if test != true { - t.Errorf("\nExpecting: true got :%+v", test) - } - -} - func testOnStorITSetGetDerivedCharges(t *testing.T) { keyCharger1 := utils.ConcatenatedKey("*out", "cgrates.org", "call", "dan", "dan") if _, err := onStor.GetDerivedChargers(keyCharger1, true, utils.NonTransactional); err == nil { diff --git a/engine/storage_map.go b/engine/storage_map.go index 94859a3d6..7a975c9e2 100755 --- a/engine/storage_map.go +++ b/engine/storage_map.go @@ -298,12 +298,6 @@ func (ms *MapStorage) CacheDataFromDB(prefix string, IDs []string, mustBeCached return } -func (ms *MapStorage) IsDBEmpty() (resp bool, err error) { - ms.mu.RLock() - defer ms.mu.RUnlock() - return len(ms.dict) == 0, nil -} - func (ms *MapStorage) GetKeysForPrefix(prefix string) ([]string, error) { ms.mu.RLock() defer ms.mu.RUnlock() diff --git a/engine/storage_mongo_datadb.go b/engine/storage_mongo_datadb.go index b06770227..903899e3e 100755 --- a/engine/storage_mongo_datadb.go +++ b/engine/storage_mongo_datadb.go @@ -421,18 +421,6 @@ func (ms *MongoStorage) RebuildReverseForPrefix(prefix string) (err error) { return nil } -func (ms *MongoStorage) IsDBEmpty() (resp bool, err error) { - session := ms.session.Copy() - defer session.Close() - db := session.DB(ms.db) - - col, err := db.CollectionNames() - if err != nil { - return - } - return len(col) == 0, nil -} - func (ms *MongoStorage) LoadDataDBCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, aaPlIDs, atrgIDs, sgIDs, lcrIDs, dcIDs, alsIDs, rvAlsIDs, rpIDs, resIDs []string) (err error) { for key, ids := range map[string][]string{ utils.DESTINATION_PREFIX: dstIDs, diff --git a/engine/storage_redis.go b/engine/storage_redis.go index 7aef51417..710fe5442 100755 --- a/engine/storage_redis.go +++ b/engine/storage_redis.go @@ -157,18 +157,6 @@ func (rs *RedisStorage) LoadDataDBCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs return } -func (rs *RedisStorage) IsDBEmpty() (resp bool, err error) { - var keys []string - keys, err = rs.GetKeysForPrefix("") - if err != nil { - return - } - if len(keys) != 0 { - return false, nil - } - return true, nil -} - func (rs *RedisStorage) RebuildReverseForPrefix(prefix string) (err error) { if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.REVERSE_ALIASES_PREFIX, utils.AccountActionPlansPrefix}, prefix) { return utils.ErrInvalidKey diff --git a/engine/stordb_it_test.go b/engine/stordb_it_test.go index 17f437879..91fecce2f 100755 --- a/engine/stordb_it_test.go +++ b/engine/stordb_it_test.go @@ -136,26 +136,6 @@ func testStorDBitIsDBEmpty(t *testing.T) { } } -func testStorDBitIsDBEmpty(t *testing.T) { - x := storDB.GetStorageType() - switch x { - case utils.MONGO: - test, err := storDB.IsDBEmpty() - if err != nil { - t.Error(err) - } else if test != true { - t.Errorf("\nExpecting: true got :%+v", test) - } - case utils.POSTGRES, utils.MYSQL: - test, err := storDB.IsDBEmpty() - if err != nil { - t.Error(err) - } else if test != false { - t.Errorf("\nExpecting: false got :%+v", test) - } - } -} - func testStorDBitCRUDTpTimings(t *testing.T) { // READ if _, err := storDB.GetTPTimings("testTPid", ""); err != utils.ErrNotFound { From da8b0dc1de61614da943ddec8d19ca79b49e64cd Mon Sep 17 00:00:00 2001 From: edwardro22 Date: Fri, 29 Sep 2017 12:09:55 +0000 Subject: [PATCH 3/4] Uncommented engine-dependent test that was failing --- engine/actions_it_test.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/engine/actions_it_test.go b/engine/actions_it_test.go index 5df3795de..e06d0abd1 100644 --- a/engine/actions_it_test.go +++ b/engine/actions_it_test.go @@ -19,7 +19,6 @@ along with this program. If not, see */ package engine -/* import ( "flag" "net/rpc" @@ -170,4 +169,3 @@ func TestActionsitStopCgrEngine(t *testing.T) { t.Error(err) } } -*/ From 8544dc3223b8255a8ae28a8e576a0ddfe86a14ac Mon Sep 17 00:00:00 2001 From: edwardro22 Date: Fri, 29 Sep 2017 16:37:13 +0000 Subject: [PATCH 4/4] Fixed failing mongo tests --- engine/libtest.go | 11 +++++--- engine/storage_mongo_datadb.go | 5 ++-- engine/storage_sql.go | 1 - engine/versions_it_test.go | 46 ++++++++++++++-------------------- 4 files changed, 29 insertions(+), 34 deletions(-) diff --git a/engine/libtest.go b/engine/libtest.go index b04ec85e3..33b7cd245 100644 --- a/engine/libtest.go +++ b/engine/libtest.go @@ -42,15 +42,15 @@ func InitDataDb(cfg *config.CGRConfig) error { return err } dataDB.LoadDataDBCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil) - // Write version before starting - if err := CheckVersions(dataDB); err != nil { + // Write version before starting + if err := SetDBVersions(dataDB); err != nil { return err } - return nil } func InitStorDb(cfg *config.CGRConfig) error { + x := []string{utils.MYSQL, utils.POSTGRES} storDb, err := ConfigureLoadStorage(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass, cfg.DBDataEncoding, cfg.StorDBMaxOpenConns, cfg.StorDBMaxIdleConns, cfg.StorDBConnMaxLifetime, cfg.StorDBCDRSIndexes) if err != nil { @@ -59,6 +59,11 @@ func InitStorDb(cfg *config.CGRConfig) error { if err := storDb.Flush(path.Join(cfg.DataFolderPath, "storage", cfg.StorDBType)); err != nil { return err } + if utils.IsSliceMember(x, cfg.StorDBType) { + if err := SetDBVersions(storDb); err != nil { + return err + } + } return nil } diff --git a/engine/storage_mongo_datadb.go b/engine/storage_mongo_datadb.go index 903899e3e..a4062ca7a 100755 --- a/engine/storage_mongo_datadb.go +++ b/engine/storage_mongo_datadb.go @@ -557,12 +557,11 @@ func (ms *MongoStorage) IsDBEmpty() (resp bool, err error) { session := ms.session.Copy() defer session.Close() db := session.DB(ms.db) - - col, err := db.CollectionNames() + cols, err := db.CollectionNames() if err != nil { return } - return len(col) == 0, nil + return len(cols) == 0 || cols[0] == "cdrs", nil } func (ms *MongoStorage) GetKeysForPrefix(prefix string) (result []string, err error) { diff --git a/engine/storage_sql.go b/engine/storage_sql.go index 327b2d1b9..0562c6564 100755 --- a/engine/storage_sql.go +++ b/engine/storage_sql.go @@ -1620,7 +1620,6 @@ func (self *SQLStorage) GetVersions(itm string) (vrs Versions, err error) { } if len(vrs) == 0 { return nil, utils.ErrNotFound - } return } diff --git a/engine/versions_it_test.go b/engine/versions_it_test.go index 538e05501..f2fb18360 100644 --- a/engine/versions_it_test.go +++ b/engine/versions_it_test.go @@ -43,17 +43,17 @@ var sTestsITVersions = []func(t *testing.T){ func TestVersionsITMongo(t *testing.T) { var err error - if cfg, err = config.NewCGRConfigFromFolder(path.Join(*dataDir, "conf", "samples", "storage", "mongo")); err != nil { + if cfg, err = config.NewCGRConfigFromFolder(path.Join(*dataDir, "conf", "samples", "tutmongo")); err != nil { t.Fatal(err) } - dataDb, err = ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize) - if err != nil { + if dataDb, err = ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, + cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize); err != nil { log.Fatal(err) } - - if storageDb, err = NewMongoStorage(cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, - cfg.StorDBUser, cfg.StorDBPass, utils.StorDB, cfg.StorDBCDRSIndexes, nil, cfg.LoadHistorySize); err != nil { - t.Fatal(err) + storageDb, err = ConfigureStorStorage(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass, cfg.DBDataEncoding, + config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes) + if err != nil { + log.Fatal(err) } dbtype = utils.MONGO for _, stest := range sTestsITVersions { @@ -61,9 +61,9 @@ func TestVersionsITMongo(t *testing.T) { } } -func TestVersionsITRedis_MYSQL(t *testing.T) { +func TestVersionsITRedisMYSQL(t *testing.T) { var err error - if cfg, err = config.NewCGRConfigFromFolder(path.Join(*dataDir, "conf", "samples", "storage", "mysql")); err != nil { + if cfg, err = config.NewCGRConfigFromFolder(path.Join(*dataDir, "conf", "samples", "tutmysql")); err != nil { t.Fatal(err) } dataDb, err = ConfigureDataStorage(cfg.DataDbType, cfg.DataDbHost, cfg.DataDbPort, cfg.DataDbName, cfg.DataDbUser, cfg.DataDbPass, cfg.DBDataEncoding, cfg.CacheConfig, *loadHistorySize) @@ -71,9 +71,10 @@ func TestVersionsITRedis_MYSQL(t *testing.T) { log.Fatal(err) } - if storageDb, err = NewMySQLStorage(cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, - cfg.StorDBUser, cfg.StorDBPass, cfg.StorDBMaxOpenConns, cfg.StorDBMaxIdleConns, cfg.StorDBConnMaxLifetime); err != nil { - t.Fatal(err) + storageDb, err = ConfigureStorStorage(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass, cfg.DBDataEncoding, + config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes) + if err != nil { + log.Fatal(err) } dbtype = utils.REDIS for _, stest := range sTestsITVersions { @@ -81,7 +82,7 @@ func TestVersionsITRedis_MYSQL(t *testing.T) { } } -func TestVersionsITPostgres(t *testing.T) { +func TestVersionsITRedisPostgres(t *testing.T) { var err error if cfg, err = config.NewCGRConfigFromFolder(path.Join(*dataDir, "conf", "samples", "storage", "postgres")); err != nil { t.Fatal(err) @@ -90,10 +91,12 @@ func TestVersionsITPostgres(t *testing.T) { if err != nil { log.Fatal(err) } - if storageDb, err = NewPostgresStorage(cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, - cfg.StorDBUser, cfg.StorDBPass, cfg.StorDBMaxOpenConns, cfg.StorDBMaxIdleConns, cfg.StorDBConnMaxLifetime); err != nil { - t.Fatal(err) + storageDb, err = ConfigureStorStorage(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass, cfg.DBDataEncoding, + config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes) + if err != nil { + log.Fatal(err) } + dbtype = utils.REDIS for _, stest := range sTestsITVersions { t.Run("TestMigratorITPostgres", stest) @@ -127,10 +130,6 @@ func testVersion(t *testing.T) { } //dataDB - storType = dataDb.GetStorageType() - - log.Print("storType:", storType) - if _, rcvErr := dataDb.GetVersions(utils.TBLVersions); rcvErr != utils.ErrNotFound { t.Error(rcvErr) } @@ -157,7 +156,6 @@ func testVersion(t *testing.T) { if err = dataDb.RemoveVersions(testVersion); err != nil { t.Error(err) } - storType = storageDb.GetStorageType() switch storType { case utils.MONGO, utils.MAPSTOR: @@ -170,13 +168,7 @@ func testVersion(t *testing.T) { test = "Migration needed: please backup cgr data and run : " } //storageDb - storType = storageDb.GetStorageType() - log.Print("storType:", storType) - - // if _, rcvErr := storageDb.GetVersions(utils.TBLVersions); rcvErr != utils.ErrNotFound { - // t.Error(rcvErr) - // } if err := CheckVersions(storageDb); err != nil { t.Error(err) }