Commit efa083ae authored by Mayuri Shinde's avatar Mayuri Shinde
Browse files

Bolt Db Dal

dal written for boltdb
test cases written(100% coverage)
parent d0bde7ad
Branches
Tags
2 merge requests!34Devbranch to Master,!31Bolt Db Dal
Showing with 208 additions and 0 deletions
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
}
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")
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment