Nil value and exception handling changes

dalmdl/boltdb/boltdb.go

@@ -20,81 +20,111 @@ func InitDB(boltDatabasePath, bucketName string) (*bolt.DB, error) {
 		}
 		return nil
 	})
-	if errormdl.CheckErr(err) != nil {
-		return nil, errormdl.Wrap("Could not set up bucket: " + bucketName)
+	if errormdl.CheckErr2(err) != nil {
+		return nil, errormdl.Wrap("ERROR: Could not set up bucket " + bucketName)
 	}
 	return db, nil
 }
 
 // AddKey - To add key into bucket
 func AddKey(db *bolt.DB, bucket string, key string, val string) error {
-	return db.Update(func(tx *bolt.Tx) error {
-		return tx.Bucket([]byte(bucket)).Put([]byte(key), []byte(val))
-	})
+	if db != nil {
+		return db.Update(func(tx *bolt.Tx) error {
+			_, bktErr := tx.CreateBucketIfNotExists([]byte(bucket))
+			if errormdl.CheckErr(bktErr) != nil {
+				return errormdl.CheckErr(bktErr)
+			}
+			return tx.Bucket([]byte(bucket)).Put([]byte(key), []byte(val))
+		})
+	}
+	return errormdl.Wrap("ERROR: Could not Add key in nil db instance")
 }
 
 // RemoveKey - To remove key from bucket
 func RemoveKey(db *bolt.DB, bucket, key string) error {
-	return db.Update(func(tx *bolt.Tx) error {
-		return tx.Bucket([]byte(bucket)).Delete([]byte(key))
-	})
+	if db != nil {
+		return db.Update(func(tx *bolt.Tx) error {
+			bkt := tx.Bucket([]byte(bucket))
+			if bkt == nil {
+				return errormdl.Wrap("Bucket not found: " + bucket)
+			}
+			return bkt.Delete([]byte(key))
+		})
+	}
+	return errormdl.Wrap("ERROR: Could not Delete key in nil db instance")
 }
 
 // GetKey - To get data in bucket of given key
 func GetKey(db *bolt.DB, bucket, key string) ([]byte, error) {
-	var byteData []byte
-	err := db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket([]byte(bucket))
-		if bkt == nil {
-			return errormdl.Wrap("Bucket not found: " + bucket)
+	if db != nil {
+		var byteData []byte
+		err := db.View(func(tx *bolt.Tx) error {
+			bkt := tx.Bucket([]byte(bucket))
+			if bkt == nil {
+				return errormdl.Wrap("Bucket not found: " + bucket)
+			}
+			byteData = bkt.Get([]byte(key))
+			return nil
+		})
+		if errormdl.CheckErr(err) != nil {
+			return nil, errormdl.CheckErr(err)
 		}
-		byteData = bkt.Get([]byte(key))
-		return nil
-	})
-	if errormdl.CheckErr(err) != nil {
-		return nil, errormdl.CheckErr(err)
+		return byteData, nil
 	}
-	return byteData, nil
+	return nil, errormdl.Wrap("ERROR: Could not Get key in nil db instance")
 }
 
 //AddRecord - To Add,append or update data into a bucket
-func AddRecord(db *bolt.DB, key string, data interface{}, bucket string) error {
-	entryBytes, err := json.Marshal(data)
-	if errormdl.CheckErr(err) != nil {
-		return errormdl.Wrap("Could not marshal entry json")
-	}
-	err = db.Update(func(tx *bolt.Tx) error {
-		err = tx.Bucket([]byte(bucket)).Put([]byte(key), entryBytes)
-		if errormdl.CheckErr1(err) != nil {
-			return errormdl.CheckErr1(err)
+func AddRecord(db *bolt.DB, bucket string, key string, data interface{}) error {
+	if db != nil {
+		entryBytes, err := json.Marshal(data)
+		if errormdl.CheckErr(err) != nil {
+			return errormdl.Wrap("Could not marshal entry json")
 		}
-		return nil
-	})
-	return errormdl.CheckErr(err)
+		err = db.Update(func(tx *bolt.Tx) error {
+			_, bktErr := tx.CreateBucketIfNotExists([]byte(bucket))
+			if errormdl.CheckErr1(bktErr) != nil {
+				return errormdl.CheckErr1(bktErr)
+			}
+			tx.Bucket([]byte(bucket)).Put([]byte(key), entryBytes)
+			if errormdl.CheckErr2(err) != nil {
+				return errormdl.CheckErr2(err)
+			}
+			return nil
+		})
+		return errormdl.CheckErr3(err)
+	}
+	return errormdl.Wrap("ERROR: Could not AddRecord in nil db instance")
 }
 
 // GetRecord - To get all data in bucket
 func GetRecord(db *bolt.DB, bucket string) ([]byte, error) {
-	var bucketData []interface{}
-	err := db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket([]byte(bucket))
-		cursor := bkt.Cursor()
-		for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
-			var interfaceObj interface{}
-			unmarshallErr := json.Unmarshal(v, &interfaceObj)
-			if errormdl.CheckErr(unmarshallErr) != nil {
-				return errormdl.CheckErr(unmarshallErr)
+	if db != nil {
+		var bucketData []interface{}
+		err := db.View(func(tx *bolt.Tx) error {
+			bkt := tx.Bucket([]byte(bucket))
+			if bkt == nil {
+				return errormdl.Wrap("Bucket not found: " + bucket)
+			}
+			cursor := bkt.Cursor()
+			for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
+				var interfaceObj interface{}
+				unmarshallErr := json.Unmarshal(v, &interfaceObj)
+				if errormdl.CheckErr(unmarshallErr) != nil {
+					return errormdl.CheckErr(unmarshallErr)
+				}
+				bucketData = append(bucketData, interfaceObj)
 			}
-			bucketData = append(bucketData, interfaceObj)
+			return nil
+		})
+		if errormdl.CheckErr1(err) != nil {
+			return nil, errormdl.CheckErr1(err)
 		}
-		return nil
-	})
-	if errormdl.CheckErr(err) != nil {
-		return nil, errormdl.CheckErr(err)
-	}
-	byteData, marshallErr := json.Marshal(bucketData)
-	if errormdl.CheckErr1(marshallErr) != nil {
-		return nil, errormdl.CheckErr1(marshallErr)
+		byteData, marshallErr := json.Marshal(bucketData)
+		if errormdl.CheckErr2(marshallErr) != nil {
+			return nil, errormdl.CheckErr2(marshallErr)
+		}
+		return byteData, nil
 	}
-	return byteData, nil
+	return nil, errormdl.Wrap("ERROR: Could not AddRecord in nil db instance")
 }

dalmdl/boltdb/boltdb_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"
+	"github.com/boltdb/bolt"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -28,24 +29,61 @@ func TestInitDBBktError(t *testing.T) {
 	errormdl.IsTestingNegetiveCaseOn1 = false
 	assert.Error(t, err, "This should return error")
 }
+func TestInitDBBktError2(t *testing.T) {
+	errormdl.IsTestingNegetiveCaseOn2 = true
+	_, err := InitDB("C:/test111.db", bucketName)
+	errormdl.IsTestingNegetiveCaseOn2 = false
+	assert.Error(t, err, "This should return error")
+}
 func TestAddKey(t *testing.T) {
 	dbIntsance, _ := InitDB("C:/test2.db", bucketName)
 	err2 := AddKey(dbIntsance, bucketName, "testKey", "testValue")
 	assert.NoError(t, err2, "This should not return error")
 }
 
+func TestAddKeyDbnil(t *testing.T) {
+	var dbIntsance *bolt.DB
+	err2 := AddKey(dbIntsance, bucketName, "testKey", "testValue")
+	assert.Error(t, err2, "This should return error")
+}
+func TestAddKeyError(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test22.db", bucketName)
+	errormdl.IsTestingNegetiveCaseOn = true
+	err2 := AddKey(dbIntsance, bucketName, "testKey", "testValue")
+	errormdl.IsTestingNegetiveCaseOn = false
+	assert.Error(t, err2, "This should return error")
+}
+
 func TestRemoveKey(t *testing.T) {
 	dbIntsance, _ := InitDB("C:/test3.db", bucketName)
 	AddKey(dbIntsance, bucketName, "testKey", "testValue")
 	err3 := RemoveKey(dbIntsance, bucketName, "testKey")
 	assert.NoError(t, err3, "This should not return error")
 }
+func TestRemoveKeyDbNil(t *testing.T) {
+	var dbIntsance *bolt.DB
+	AddKey(dbIntsance, bucketName, "testKey", "testValue")
+	err3 := RemoveKey(dbIntsance, "bktnil", "testKey")
+	assert.Error(t, err3, "This should return error")
+}
+func TestRemoveKeyBktNil(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test31.db", bucketName)
+	AddKey(dbIntsance, bucketName, "testKey", "testValue")
+	err3 := RemoveKey(dbIntsance, "bktnil", "testKey")
+	assert.Error(t, err3, "This should return error")
+}
 func TestGetKey(t *testing.T) {
 	dbIntsance, _ := InitDB("C:/test4.db", bucketName)
 	AddKey(dbIntsance, bucketName, "testKey", "testValue")
 	_, err := GetKey(dbIntsance, bucketName, "testKey")
 	assert.NoError(t, err, "This should not return error")
 }
+func TestGetKeyDbNil(t *testing.T) {
+	var dbIntsance *bolt.DB
+	AddKey(dbIntsance, bucketName, "testKey", "testValue")
+	_, err := GetKey(dbIntsance, bucketName, "testKey")
+	assert.Error(t, err, "This should return error")
+}
 
 func TestGetKeyBktErr(t *testing.T) {
 	dbIntsance, _ := InitDB("C:/test5.db", bucketName)
@@ -61,16 +99,23 @@ func TestAddRecord(t *testing.T) {
 	dbIntsance, _ := InitDB("C:/test6.db", bucketName)
 	bucketData := BucketData{}
 	bucketData.Name = "test"
-	err := AddRecord(dbIntsance, "myname", bucketData, bucketName)
+	err := AddRecord(dbIntsance, bucketName, "myname", bucketData)
 	assert.NoError(t, err, "This should not return error")
 }
+func TestAddRecordDbNil(t *testing.T) {
+	var dbIntsance *bolt.DB
+	bucketData := BucketData{}
+	bucketData.Name = "test"
+	err := AddRecord(dbIntsance, bucketName, "myname", bucketData)
+	assert.Error(t, err, "This should return error")
+}
 
 func TestAddRecordError(t *testing.T) {
 	dbIntsance, _ := InitDB("C:/test7.db", bucketName)
 	bucketData := BucketData{}
 	bucketData.Name = "test"
 	errormdl.IsTestingNegetiveCaseOn = true
-	err := AddRecord(dbIntsance, "myname", bucketData, bucketName)
+	err := AddRecord(dbIntsance, bucketName, "myname", bucketData)
 	errormdl.IsTestingNegetiveCaseOn = false
 	assert.Error(t, err, "This should return error")
 }
@@ -79,24 +124,50 @@ func TestAddRecordError1(t *testing.T) {
 	bucketData := BucketData{}
 	bucketData.Name = "test"
 	errormdl.IsTestingNegetiveCaseOn1 = true
-	err := AddRecord(dbIntsance, "myname", bucketData, bucketName)
+	err := AddRecord(dbIntsance, bucketName, "myname", bucketData)
 	errormdl.IsTestingNegetiveCaseOn1 = false
 	assert.Error(t, err, "This should return error")
 }
+func TestAddRecordError2(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test81.db", bucketName)
+	bucketData := BucketData{}
+	bucketData.Name = "test"
+	errormdl.IsTestingNegetiveCaseOn2 = true
+	err := AddRecord(dbIntsance, bucketName, "myname", bucketData)
+	errormdl.IsTestingNegetiveCaseOn2 = false
+	assert.Error(t, err, "This should return error")
+}
 func TestGetRecord(t *testing.T) {
 	dbIntsance, _ := InitDB("C:/test9.db", bucketName)
 	bucketData := BucketData{}
 	bucketData.Name = "test"
-	AddRecord(dbIntsance, "myname", bucketData, bucketName)
+	AddRecord(dbIntsance, bucketName, "myname", bucketData)
 	_, err2 := GetRecord(dbIntsance, bucketName)
 	assert.NoError(t, err2, "This should not return error")
 }
+func TestGetRecordDbNil(t *testing.T) {
+	var dbIntsance *bolt.DB
+	bucketData := BucketData{}
+	bucketData.Name = "test"
+	AddRecord(dbIntsance, bucketName, "myname", bucketData)
+	_, err2 := GetRecord(dbIntsance, bucketName)
+	assert.Error(t, err2, "This should return error")
+}
+func TestGetRecordBktNil(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test91.db", bucketName)
+	bucketData := BucketData{}
+	bucketData.Name = "test"
+	AddRecord(dbIntsance, "nilBkt", "myname", bucketData)
+	_, err2 := GetRecord(dbIntsance, "bktNil")
+	assert.Error(t, err2, "This should return error")
+}
+
 func TestGetRecordError(t *testing.T) {
 	dbIntsance, _ := InitDB("C:/test10.db", bucketName)
 	errormdl.IsTestingNegetiveCaseOn = true
 	_, err2 := GetRecord(dbIntsance, bucketName)
 	errormdl.IsTestingNegetiveCaseOn = false
-	assert.Error(t, err2, "This should return error")
+	assert.NoError(t, err2, "This should not return error")
 }
 
 func TestGetRecordError1(t *testing.T) {
@@ -106,3 +177,11 @@ func TestGetRecordError1(t *testing.T) {
 	errormdl.IsTestingNegetiveCaseOn1 = false
 	assert.Error(t, err2, "This should return error")
 }
+
+func TestGetRecordError2(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test12.db", bucketName)
+	errormdl.IsTestingNegetiveCaseOn2 = true
+	_, err2 := GetRecord(dbIntsance, bucketName)
+	errormdl.IsTestingNegetiveCaseOn2 = false
+	assert.Error(t, err2, "This should return error")
+}