Bolt Db Dal

dal written for boltdb
test cases written(100% coverage)

dalmdl/boltdb/boltdb.go

+package boltdb
+
+import (
+	"encoding/json"
+
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"
+	"github.com/boltdb/bolt"
+)
+
+//InitDB - To create database and bucket
+func InitDB(boltDatabasePath, bucketName string) (*bolt.DB, error) {
+	db, err := bolt.Open(boltDatabasePath, 0777, nil)
+	if errormdl.CheckErr(err) != nil {
+		return nil, errormdl.CheckErr(err)
+	}
+	err = db.Update(func(tx *bolt.Tx) error {
+		_, bktErr := tx.CreateBucketIfNotExists([]byte(bucketName))
+		if errormdl.CheckErr1(bktErr) != nil {
+			return errormdl.CheckErr1(bktErr)
+		}
+		return nil
+	})
+	if errormdl.CheckErr(err) != nil {
+		return nil, errormdl.Wrap("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))
+	})
+}
+
+// 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))
+	})
+}
+
+// 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)
+		}
+		byteData = bkt.Get([]byte(key))
+		return nil
+	})
+	if errormdl.CheckErr(err) != nil {
+		return nil, errormdl.CheckErr(err)
+	}
+	return byteData, nil
+}
+
+//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)
+		}
+		return nil
+	})
+	return errormdl.CheckErr(err)
+}
+
+// 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)
+			}
+			bucketData = append(bucketData, interfaceObj)
+		}
+		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)
+	}
+	return byteData, nil
+}

dalmdl/boltdb/boltdb_test.go

+package boltdb
+
+import (
+	"testing"
+
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	bucketName  = "test"
+	dbPathWrong = "C:/test/test.db"
+)
+
+func TestInitDB(t *testing.T) {
+	_, err := InitDB("C:/test.db", bucketName)
+	assert.NoError(t, err, "This should not return error")
+}
+func TestInitDBOpenDbError(t *testing.T) {
+	errormdl.IsTestingNegetiveCaseOn = true
+	_, err := InitDB(dbPathWrong, bucketName)
+	errormdl.IsTestingNegetiveCaseOn = false
+	assert.Error(t, err, "This should return error")
+}
+func TestInitDBBktError(t *testing.T) {
+	errormdl.IsTestingNegetiveCaseOn1 = true
+	_, err := InitDB("C:/test1.db", bucketName)
+	errormdl.IsTestingNegetiveCaseOn1 = 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 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 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 TestGetKeyBktErr(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test5.db", bucketName)
+	_, err := GetKey(dbIntsance, "mdasda", "testKey")
+	assert.Error(t, err, "This should return error")
+}
+
+type BucketData struct {
+	Name string `json:"name"`
+}
+
+func TestAddRecord(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test6.db", bucketName)
+	bucketData := BucketData{}
+	bucketData.Name = "test"
+	err := AddRecord(dbIntsance, "myname", bucketData, bucketName)
+	assert.NoError(t, err, "This should not 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)
+	errormdl.IsTestingNegetiveCaseOn = false
+	assert.Error(t, err, "This should return error")
+}
+func TestAddRecordError1(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test8.db", bucketName)
+	bucketData := BucketData{}
+	bucketData.Name = "test"
+	errormdl.IsTestingNegetiveCaseOn1 = true
+	err := AddRecord(dbIntsance, "myname", bucketData, bucketName)
+	errormdl.IsTestingNegetiveCaseOn1 = 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)
+	_, err2 := GetRecord(dbIntsance, bucketName)
+	assert.NoError(t, err2, "This should not 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")
+}
+
+func TestGetRecordError1(t *testing.T) {
+	dbIntsance, _ := InitDB("C:/test11.db", bucketName)
+	errormdl.IsTestingNegetiveCaseOn1 = true
+	_, err2 := GetRecord(dbIntsance, bucketName)
+	errormdl.IsTestingNegetiveCaseOn1 = false
+	assert.Error(t, err2, "This should return error")
+}