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

1 files changed, 0 insertions, 390 deletions

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)
-				}
-			}
-		})
-	}
-}