Remove unused mongo db methods from emco code

Remove the set of unused (legacy from v1) mongo
db methods so that they are not used in the emco
code base.

Issue-ID: MULTICLOUD-1227
Signed-off-by: Eric Multanen <eric.w.multanen@intel.com>
Change-Id: Ibe94892e5b1d0f33192be7ea3db5c55b3f8cbf60

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