Merge "Remove unused mongo db methods from emco code"

4 files changed, 0 insertions, 634 deletions

diff --git a/src/orchestrator/pkg/infra/db/mock.go b/src/orchestrator/pkg/infra/db/mock.go
index e43be8fb..cc3af718 100644
--- a/src/orchestrator/pkg/infra/db/mock.go
+++ b/src/orchestrator/pkg/infra/db/mock.go
@@ -41,18 +41,10 @@ func (m *MockDB) HealthCheck() error {
 	return m.Err
 }
 
-func (m *MockDB) Create(table string, key Key, tag string, data interface{}) error {
-	return m.Err
-}
-
 func (m *MockDB) Insert(table string, key Key, query interface{}, tag string, data interface{}) error {
 	return m.Err
 }
 
-func (m *MockDB) Update(table string, key Key, tag string, data interface{}) error {
-	return m.Err
-}
-
 // MockDB uses simple JSON and not BSON
 func (m *MockDB) Unmarshal(inp []byte, out interface{}) error {
 	err := json.Unmarshal(inp, out)
@@ -62,21 +54,6 @@ func (m *MockDB) Unmarshal(inp []byte, out interface{}) error {
 	return nil
 }
 
-func (m *MockDB) Read(table string, key Key, tag string) ([]byte, error) {
-	if m.Err != nil {
-		return nil, m.Err
-	}
-
-	str := fmt.Sprintf("%v", key)
-	for k, v := range m.Items {
-		if k == str {
-			return v[tag], nil
-		}
-	}
-
-	return nil, m.Err
-}
-
 func (m *MockDB) Find(table string, key Key, tag string) ([][]byte, error) {
 	if m.Err != nil {
 		return nil, m.Err
@@ -93,10 +70,6 @@ func (m *MockDB) Find(table string, key Key, tag string) ([][]byte, error) {
 	return nil, m.Err
 }
 
-func (m *MockDB) Delete(table string, key Key, tag string) error {
-	return m.Err
-}
-
 func (m *MockDB) Remove(table string, key Key) error {
 	return m.Err
 }
diff --git a/src/orchestrator/pkg/infra/db/mongo.go b/src/orchestrator/pkg/infra/db/mongo.go
index a3fdc570..cae57e1d 100644
--- a/src/orchestrator/pkg/infra/db/mongo.go
+++ b/src/orchestrator/pkg/infra/db/mongo.go
@@ -18,7 +18,6 @@ package db
 
 import (
 	"encoding/json"
-	"log"
 	"sort"
 
 	"golang.org/x/net/context"
@@ -135,88 +134,6 @@ func (m *MongoStore) validateParams(args ...interface{}) bool {
 	return true
 }
 
-// Create is used to create a DB entry
-func (m *MongoStore) Create(coll string, key Key, tag string, data interface{}) error {
-	if data == nil || !m.validateParams(coll, key, tag) {
-		return pkgerrors.New("No Data to store")
-	}
-
-	c := getCollection(coll, m)
-	ctx := context.Background()
-
-	//Insert the data and then add the objectID to the masterTable
-	res, err := c.InsertOne(ctx, bson.D{
-		{tag, data},
-	})
-	if err != nil {
-		return pkgerrors.Errorf("Error inserting into database: %s", err.Error())
-	}
-
-	//Add objectID of created data to masterKey document
-	//Create masterkey document if it does not exist
-	filter := bson.D{{"key", key}}
-
-	_, err = decodeBytes(
-		c.FindOneAndUpdate(
-			ctx,
-			filter,
-			bson.D{
-				{"$set", bson.D{
-					{tag, res.InsertedID},
-				}},
-			},
-			options.FindOneAndUpdate().SetUpsert(true).SetReturnDocument(options.After)))
-
-	if err != nil {
-		return pkgerrors.Errorf("Error updating master table: %s", err.Error())
-	}
-
-	return nil
-}
-
-// Update is used to update a DB entry
-func (m *MongoStore) Update(coll string, key Key, tag string, data interface{}) error {
-	if data == nil || !m.validateParams(coll, key, tag) {
-		return pkgerrors.New("No Data to update")
-	}
-
-	c := getCollection(coll, m)
-	ctx := context.Background()
-
-	//Get the masterkey document based on given key
-	filter := bson.D{{"key", key}}
-	keydata, err := decodeBytes(c.FindOne(context.Background(), filter))
-	if err != nil {
-		return pkgerrors.Errorf("Error finding master table: %s", err.Error())
-	}
-
-	//Read the tag objectID from document
-	tagoid, ok := keydata.Lookup(tag).ObjectIDOK()
-	if !ok {
-		return pkgerrors.Errorf("Error finding objectID for tag %s", tag)
-	}
-
-	//Update the document with new data
-	filter = bson.D{{"_id", tagoid}}
-
-	_, err = decodeBytes(
-		c.FindOneAndUpdate(
-			ctx,
-			filter,
-			bson.D{
-				{"$set", bson.D{
-					{tag, data},
-				}},
-			},
-			options.FindOneAndUpdate().SetReturnDocument(options.After)))
-
-	if err != nil {
-		return pkgerrors.Errorf("Error updating record: %s", err.Error())
-	}
-
-	return nil
-}
-
 // Unmarshal implements an unmarshaler for bson data that
 // is produced from the mongo database
 func (m *MongoStore) Unmarshal(inp []byte, out interface{}) error {
@@ -227,126 +144,6 @@ func (m *MongoStore) Unmarshal(inp []byte, out interface{}) error {
 	return nil
 }
 
-// Read method returns the data stored for this key and for this particular tag
-func (m *MongoStore) Read(coll string, key Key, tag string) ([]byte, error) {
-	if !m.validateParams(coll, key, tag) {
-		return nil, pkgerrors.New("Mandatory fields are missing")
-	}
-
-	c := getCollection(coll, m)
-	ctx := context.Background()
-
-	//Get the masterkey document based on given key
-	filter := bson.D{{"key", key}}
-	keydata, err := decodeBytes(c.FindOne(context.Background(), filter))
-	if err != nil {
-		return nil, pkgerrors.Errorf("Error finding master table: %s", err.Error())
-	}
-
-	//Read the tag objectID from document
-	tagoid, ok := keydata.Lookup(tag).ObjectIDOK()
-	if !ok {
-		return nil, pkgerrors.Errorf("Error finding objectID for tag %s", tag)
-	}
-
-	//Use tag objectID to read the data from store
-	filter = bson.D{{"_id", tagoid}}
-	tagdata, err := decodeBytes(c.FindOne(ctx, filter))
-	if err != nil {
-		return nil, pkgerrors.Errorf("Error reading found object: %s", err.Error())
-	}
-
-	//Return the data as a byte array
-	//Convert string data to byte array using the built-in functions
-	switch tagdata.Lookup(tag).Type {
-	case bson.TypeString:
-		return []byte(tagdata.Lookup(tag).StringValue()), nil
-	default:
-		return tagdata.Lookup(tag).Value, nil
-	}
-}
-
-// Helper function that deletes an object by its ID
-func (m *MongoStore) deleteObjectByID(coll string, objID primitive.ObjectID) error {
-
-	c := getCollection(coll, m)
-	ctx := context.Background()
-
-	_, err := c.DeleteOne(ctx, bson.D{{"_id", objID}})
-	if err != nil {
-		return pkgerrors.Errorf("Error Deleting from database: %s", err.Error())
-	}
-
-	log.Printf("Deleted Obj with ID %s", objID.String())
-	return nil
-}
-
-// Delete method removes a document from the Database that matches key
-// TODO: delete all referenced docs if tag is empty string
-func (m *MongoStore) Delete(coll string, key Key, tag string) error {
-	if !m.validateParams(coll, key, tag) {
-		return pkgerrors.New("Mandatory fields are missing")
-	}
-
-	c := getCollection(coll, m)
-	ctx := context.Background()
-
-	//Get the masterkey document based on given key
-	filter := bson.D{{"key", key}}
-	//Remove the tag ID entry from masterkey table
-	update := bson.D{
-		{
-			"$unset", bson.D{
-				{tag, ""},
-			},
-		},
-	}
-	keydata, err := decodeBytes(c.FindOneAndUpdate(ctx, filter, update,
-		options.FindOneAndUpdate().SetReturnDocument(options.Before)))
-	if err != nil {
-		//No document was found. Return nil.
-		if err == mongo.ErrNoDocuments {
-			return nil
-		}
-		//Return any other error that was found.
-		return pkgerrors.Errorf("Error decoding master table after update: %s",
-			err.Error())
-	}
-
-	//Read the tag objectID from document
-	elems, err := keydata.Elements()
-	if err != nil {
-		return pkgerrors.Errorf("Error reading elements from database: %s", err.Error())
-	}
-
-	tagoid, ok := keydata.Lookup(tag).ObjectIDOK()
-	if !ok {
-		return pkgerrors.Errorf("Error finding objectID for tag %s", tag)
-	}
-
-	//Use tag objectID to read the data from store
-	err = m.deleteObjectByID(coll, tagoid)
-	if err != nil {
-		return pkgerrors.Errorf("Error deleting from database: %s", err.Error())
-	}
-
-	//Delete master table if no more tags left
-	//_id, key and tag should be elements in before doc
-	//if master table needs to be removed too
-	if len(elems) == 3 {
-		keyid, ok := keydata.Lookup("_id").ObjectIDOK()
-		if !ok {
-			return pkgerrors.Errorf("Error finding objectID for key %s", key)
-		}
-		err = m.deleteObjectByID(coll, keyid)
-		if err != nil {
-			return pkgerrors.Errorf("Error deleting master table from database: %s", err.Error())
-		}
-	}
-
-	return nil
-}
-
 func (m *MongoStore) findFilter(key Key) (primitive.M, error) {
 
 	var bsonMap bson.M
diff --git a/src/orchestrator/pkg/infra/db/mongo_test.go b/src/orchestrator/pkg/infra/db/mongo_test.go
index d57c19dd..3e14e755 100644
--- a/src/orchestrator/pkg/infra/db/mongo_test.go
+++ b/src/orchestrator/pkg/infra/db/mongo_test.go
@@ -17,13 +17,8 @@
 package db
 
 import (
-	"bytes"
 	"context"
-	"strings"
-	"testing"
 
-	pkgerrors "github.com/pkg/errors"
-	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/mongo"
 	"go.mongodb.org/mongo-driver/mongo/options"
 )
@@ -83,388 +78,3 @@ func (c *mockCollection) CountDocuments(ctx context.Context, filter interface{},
 	opts ...*options.CountOptions) (int64, error) {
 	return 1, c.Err
 }
-
-func TestCreate(t *testing.T) {
-	testCases := []struct {
-		label         string
-		input         map[string]interface{}
-		mockColl      *mockCollection
-		bson          bson.Raw
-		expectedError string
-	}{
-		{
-			label: "Successfull creation of entry",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "tagName",
-				"data": "Data In String Format",
-			},
-			bson:     bson.Raw{'\x08', '\x00', '\x00', '\x00', '\x0A', 'x', '\x00', '\x00'},
-			mockColl: &mockCollection{},
-		},
-		{
-			label: "UnSuccessfull creation of entry",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "tagName",
-				"data": "Data In String Format",
-			},
-			mockColl: &mockCollection{
-				Err: pkgerrors.New("DB Error"),
-			},
-			expectedError: "DB Error",
-		},
-		{
-			label: "Missing input fields",
-			input: map[string]interface{}{
-				"coll": "",
-				"key":  MockKey{Key: ""},
-				"tag":  "",
-				"data": "",
-			},
-			expectedError: "No Data to store",
-			mockColl:      &mockCollection{},
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.label, func(t *testing.T) {
-			m, _ := NewMongoStore("name", &mongo.Database{})
-			// Override the getCollection function with our mocked version
-			getCollection = func(coll string, m *MongoStore) MongoCollection {
-				return testCase.mockColl
-			}
-
-			decodeBytes = func(sr *mongo.SingleResult) (bson.Raw, error) {
-				return testCase.bson, testCase.mockColl.Err
-			}
-
-			err := m.Create(testCase.input["coll"].(string), testCase.input["key"].(Key),
-				testCase.input["tag"].(string), testCase.input["data"])
-			if err != nil {
-				if testCase.expectedError == "" {
-					t.Fatalf("Create method returned an un-expected (%s)", err)
-				}
-				if !strings.Contains(string(err.Error()), testCase.expectedError) {
-					t.Fatalf("Create method returned an error (%s)", err)
-				}
-			}
-		})
-	}
-}
-
-func TestUpdate(t *testing.T) {
-	testCases := []struct {
-		label         string
-		input         map[string]interface{}
-		mockColl      *mockCollection
-		bson          bson.Raw
-		expectedError string
-	}{
-		{
-			label: "Successfull update of entry",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "metadata",
-				"data": "Data In String Format",
-			},
-			// Binary form of
-			// {
-			//	"_id" : ObjectId("5c115156777ff85654248ae1"),
-			//  "key" : bson.D{{"name","testdef"},{"version","v1"}},
-			//  "metadata" : ObjectId("5c115156c9755047e318bbfd")
-			// }
-			bson: bson.Raw{
-				'\x58', '\x00', '\x00', '\x00', '\x03', '\x6b', '\x65', '\x79',
-				'\x00', '\x27', '\x00', '\x00', '\x00', '\x02', '\x6e', '\x61',
-				'\x6d', '\x65', '\x00', '\x08', '\x00', '\x00', '\x00', '\x74',
-				'\x65', '\x73', '\x74', '\x64', '\x65', '\x66', '\x00', '\x02',
-				'\x76', '\x65', '\x72', '\x73', '\x69', '\x6f', '\x6e', '\x00',
-				'\x03', '\x00', '\x00', '\x00', '\x76', '\x31', '\x00', '\x00',
-				'\x07', '\x6d', '\x65', '\x74', '\x61', '\x64', '\x61', '\x74',
-				'\x61', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77', '\x7f',
-				'\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x07', '\x5f',
-				'\x69', '\x64', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77',
-				'\x7f', '\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x00',
-			},
-			mockColl: &mockCollection{},
-		},
-		{
-			label: "Entry does not exist",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "tagName",
-				"data": "Data In String Format",
-			},
-			mockColl: &mockCollection{
-				Err: pkgerrors.New("DB Error"),
-			},
-			expectedError: "DB Error",
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.label, func(t *testing.T) {
-			m, _ := NewMongoStore("name", &mongo.Database{})
-			// Override the getCollection function with our mocked version
-			getCollection = func(coll string, m *MongoStore) MongoCollection {
-				return testCase.mockColl
-			}
-
-			decodeBytes = func(sr *mongo.SingleResult) (bson.Raw, error) {
-				return testCase.bson, testCase.mockColl.Err
-			}
-
-			err := m.Update(testCase.input["coll"].(string), testCase.input["key"].(Key),
-				testCase.input["tag"].(string), testCase.input["data"])
-			if err != nil {
-				if testCase.expectedError == "" {
-					t.Fatalf("Create method returned an un-expected (%s)", err)
-				}
-				if !strings.Contains(string(err.Error()), testCase.expectedError) {
-					t.Fatalf("Create method returned an error (%s)", err)
-				}
-			}
-		})
-	}
-}
-
-func TestRead(t *testing.T) {
-	testCases := []struct {
-		label         string
-		input         map[string]interface{}
-		mockColl      *mockCollection
-		bson          bson.Raw
-		expectedError string
-		expected      []byte
-	}{
-		{
-			label: "Successfull Read of entry",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "metadata",
-			},
-			// Binary form of
-			// {
-			//	"_id" : ObjectId("5c115156777ff85654248ae1"),
-			//  "key" : bson.D{{"name","testdef"},{"version","v1"}},
-			//  "metadata" : ObjectId("5c115156c9755047e318bbfd")
-			// }
-			bson: bson.Raw{
-				'\x58', '\x00', '\x00', '\x00', '\x03', '\x6b', '\x65', '\x79',
-				'\x00', '\x27', '\x00', '\x00', '\x00', '\x02', '\x6e', '\x61',
-				'\x6d', '\x65', '\x00', '\x08', '\x00', '\x00', '\x00', '\x74',
-				'\x65', '\x73', '\x74', '\x64', '\x65', '\x66', '\x00', '\x02',
-				'\x76', '\x65', '\x72', '\x73', '\x69', '\x6f', '\x6e', '\x00',
-				'\x03', '\x00', '\x00', '\x00', '\x76', '\x31', '\x00', '\x00',
-				'\x07', '\x6d', '\x65', '\x74', '\x61', '\x64', '\x61', '\x74',
-				'\x61', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77', '\x7f',
-				'\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x07', '\x5f',
-				'\x69', '\x64', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77',
-				'\x7f', '\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x00',
-			},
-			mockColl: &mockCollection{},
-			// This is not the document because we are mocking decodeBytes
-			expected: []byte{92, 17, 81, 86, 119, 127, 248, 86, 84, 36, 138, 225},
-		},
-		{
-			label: "UnSuccessfull Read of entry: object not found",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "badtag",
-			},
-			// Binary form of
-			// {
-			//	"_id" : ObjectId("5c115156777ff85654248ae1"),
-			//  "key" : bson.D{{"name","testdef"},{"version","v1"}},
-			//  "metadata" : ObjectId("5c115156c9755047e318bbfd")
-			// }
-			bson: bson.Raw{
-				'\x58', '\x00', '\x00', '\x00', '\x03', '\x6b', '\x65', '\x79',
-				'\x00', '\x27', '\x00', '\x00', '\x00', '\x02', '\x6e', '\x61',
-				'\x6d', '\x65', '\x00', '\x08', '\x00', '\x00', '\x00', '\x74',
-				'\x65', '\x73', '\x74', '\x64', '\x65', '\x66', '\x00', '\x02',
-				'\x76', '\x65', '\x72', '\x73', '\x69', '\x6f', '\x6e', '\x00',
-				'\x03', '\x00', '\x00', '\x00', '\x76', '\x31', '\x00', '\x00',
-				'\x07', '\x6d', '\x65', '\x74', '\x61', '\x64', '\x61', '\x74',
-				'\x61', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77', '\x7f',
-				'\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x07', '\x5f',
-				'\x69', '\x64', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77',
-				'\x7f', '\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x00',
-			},
-			mockColl:      &mockCollection{},
-			expectedError: "Error finding objectID",
-		},
-		{
-			label: "UnSuccessfull Read of entry",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "tagName",
-			},
-			mockColl: &mockCollection{
-				Err: pkgerrors.New("DB Error"),
-			},
-			expectedError: "DB Error",
-		},
-		{
-			label: "Missing input fields",
-			input: map[string]interface{}{
-				"coll": "",
-				"key":  MockKey{Key: ""},
-				"tag":  "",
-			},
-			expectedError: "Mandatory fields are missing",
-			mockColl:      &mockCollection{},
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.label, func(t *testing.T) {
-			m, _ := NewMongoStore("name", &mongo.Database{})
-			// Override the getCollection function with our mocked version
-			getCollection = func(coll string, m *MongoStore) MongoCollection {
-				return testCase.mockColl
-			}
-
-			decodeBytes = func(sr *mongo.SingleResult) (bson.Raw, error) {
-				return testCase.bson, testCase.mockColl.Err
-			}
-			got, err := m.Read(testCase.input["coll"].(string), testCase.input["key"].(Key),
-				testCase.input["tag"].(string))
-			if err != nil {
-				if testCase.expectedError == "" {
-					t.Fatalf("Read method returned an un-expected (%s)", err)
-				}
-				if !strings.Contains(string(err.Error()), testCase.expectedError) {
-					t.Fatalf("Read method returned an error (%s)", err)
-				}
-			} else {
-				if bytes.Compare(got, testCase.expected) != 0 {
-					t.Fatalf("Read returned unexpected data: %v, expected: %v",
-						string(got), testCase.expected)
-				}
-			}
-		})
-	}
-}
-
-func TestDelete(t *testing.T) {
-	testCases := []struct {
-		label         string
-		input         map[string]interface{}
-		mockColl      *mockCollection
-		bson          bson.Raw
-		expectedError string
-	}{
-		{
-			label: "Successfull Delete of entry",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "metadata",
-			},
-			// Binary form of
-			// {
-			//	"_id" : ObjectId("5c115156777ff85654248ae1"),
-			//  "key" : bson.D{{"name","testdef"},{"version","v1"}},
-			//  "metadata" : ObjectId("5c115156c9755047e318bbfd")
-			// }
-			bson: bson.Raw{
-				'\x58', '\x00', '\x00', '\x00', '\x03', '\x6b', '\x65', '\x79',
-				'\x00', '\x27', '\x00', '\x00', '\x00', '\x02', '\x6e', '\x61',
-				'\x6d', '\x65', '\x00', '\x08', '\x00', '\x00', '\x00', '\x74',
-				'\x65', '\x73', '\x74', '\x64', '\x65', '\x66', '\x00', '\x02',
-				'\x76', '\x65', '\x72', '\x73', '\x69', '\x6f', '\x6e', '\x00',
-				'\x03', '\x00', '\x00', '\x00', '\x76', '\x31', '\x00', '\x00',
-				'\x07', '\x6d', '\x65', '\x74', '\x61', '\x64', '\x61', '\x74',
-				'\x61', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77', '\x7f',
-				'\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x07', '\x5f',
-				'\x69', '\x64', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77',
-				'\x7f', '\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x00',
-			},
-			mockColl: &mockCollection{},
-		},
-		{
-			label: "UnSuccessfull Delete of entry",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "tagName",
-			},
-			mockColl: &mockCollection{
-				Err: pkgerrors.New("DB Error"),
-			},
-			expectedError: "DB Error",
-		},
-		{
-			label: "UnSuccessfull Delete, key not found",
-			input: map[string]interface{}{
-				"coll": "collname",
-				"key":  MockKey{Key: "keyvalue"},
-				"tag":  "tagName",
-			},
-			// Binary form of
-			// {
-			//	"_id" : ObjectId("5c115156777ff85654248ae1"),
-			//  "key" : bson.D{{"name","testdef"},{"version","v1"}},
-			//  "metadata" : ObjectId("5c115156c9755047e318bbfd")
-			// }
-			bson: bson.Raw{
-				'\x58', '\x00', '\x00', '\x00', '\x03', '\x6b', '\x65', '\x79',
-				'\x00', '\x27', '\x00', '\x00', '\x00', '\x02', '\x6e', '\x61',
-				'\x6d', '\x65', '\x00', '\x08', '\x00', '\x00', '\x00', '\x74',
-				'\x65', '\x73', '\x74', '\x64', '\x65', '\x66', '\x00', '\x02',
-				'\x76', '\x65', '\x72', '\x73', '\x69', '\x6f', '\x6e', '\x00',
-				'\x03', '\x00', '\x00', '\x00', '\x76', '\x31', '\x00', '\x00',
-				'\x07', '\x6d', '\x65', '\x74', '\x61', '\x64', '\x61', '\x74',
-				'\x61', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77', '\x7f',
-				'\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x07', '\x5f',
-				'\x69', '\x64', '\x00', '\x5c', '\x11', '\x51', '\x56', '\x77',
-				'\x7f', '\xf8', '\x56', '\x54', '\x24', '\x8a', '\xe1', '\x00',
-			},
-			mockColl:      &mockCollection{},
-			expectedError: "Error finding objectID",
-		},
-		{
-			label: "Missing input fields",
-			input: map[string]interface{}{
-				"coll": "",
-				"key":  MockKey{Key: ""},
-				"tag":  "",
-			},
-			expectedError: "Mandatory fields are missing",
-			mockColl:      &mockCollection{},
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.label, func(t *testing.T) {
-			m, _ := NewMongoStore("name", &mongo.Database{})
-			// Override the getCollection function with our mocked version
-			getCollection = func(coll string, m *MongoStore) MongoCollection {
-				return testCase.mockColl
-			}
-
-			decodeBytes = func(sr *mongo.SingleResult) (bson.Raw, error) {
-				return testCase.bson, testCase.mockColl.Err
-			}
-			err := m.Delete(testCase.input["coll"].(string), testCase.input["key"].(Key),
-				testCase.input["tag"].(string))
-			if err != nil {
-				if testCase.expectedError == "" {
-					t.Fatalf("Delete method returned an un-expected (%s)", err)
-				}
-				if !strings.Contains(string(err.Error()), testCase.expectedError) {
-					t.Fatalf("Delete method returned an error (%s)", err)
-				}
-			}
-		})
-	}
-}
diff --git a/src/orchestrator/pkg/infra/db/store.go b/src/orchestrator/pkg/infra/db/store.go
index a332fcda..d6ed6022 100644
--- a/src/orchestrator/pkg/infra/db/store.go
+++ b/src/orchestrator/pkg/infra/db/store.go
@@ -39,20 +39,6 @@ type Store interface {
 	// Unmarshal implements any unmarshaling needed for the database
 	Unmarshal(inp []byte, out interface{}) error
 
-	// Creates a new master document with key and links data with tag and
-	// creates a pointer(row) to the newly added data in the master table
-	Create(table string, key Key, tag string, data interface{}) error
-
-	// Reads data for a particular key with specific tag.
-	Read(table string, key Key, tag string) ([]byte, error)
-
-	// Update data for particular key with specific tag
-	Update(table string, key Key, tag string, data interface{}) error
-
-	// Deletes a specific tag data for key.
-	// TODO: If tag is empty, it will delete all tags under key.
-	Delete(table string, key Key, tag string) error
-
 	// Inserts and Updates a tag with key and also adds query fields if provided
 	Insert(coll string, key Key, query interface{}, tag string, data interface{}) error