matchmaking-system/internal/data/mongo/mongo_test.go

package mongo

import (
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"matchmaking-system/internal/conf"
	"reflect"
	"testing"
)

func TestMgoAggregate(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     mongo.Pipeline
	}
	tests := []struct {
		name    string
		args    args
		want    interface{}
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoAggregate(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoAggregate() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoAggregate() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoBulkWrite(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		models     []mongo.WriteModel
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoBulkWrite(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.models); (err != nil) != tt.wantErr {
				t.Errorf("MgoBulkWrite() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoConnect(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
	}
	tests := []struct {
		name string
		args args
		want *mongo.Collection
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MgoConnect(tt.args.mgoDb, tt.args.DataBase, tt.args.collection); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoConnect() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoDeleteMany(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoDeleteMany(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter); (err != nil) != tt.wantErr {
				t.Errorf("MgoDeleteMany() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoDeleteOne(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoDeleteOne(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter); (err != nil) != tt.wantErr {
				t.Errorf("MgoDeleteOne() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoFind(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		want    interface{}
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoFind(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoFind() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoFind() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoFindAll(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		want    interface{}
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoFindAll(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoFindAll() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoFindAll() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoFindOne(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		want    bson.D
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoFindOne(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoFindOne() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoFindOne() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoFindTotal(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		want    int64
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoFindTotal(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoFindTotal() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("MgoFindTotal() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoInsertMany(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		docs       []interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoInsertMany(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.docs); (err != nil) != tt.wantErr {
				t.Errorf("MgoInsertMany() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoInsertOne(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		docs       interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoInsertOne(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.docs); (err != nil) != tt.wantErr {
				t.Errorf("MgoInsertOne() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoIsExist(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MgoIsExist(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter); got != tt.want {
				t.Errorf("MgoIsExist() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoPagingFind(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
		limit      int64
		page       int64
		sort       int
	}
	tests := []struct {
		name    string
		args    args
		want    []bson.M
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoPagingFind(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter, tt.args.limit, tt.args.page, tt.args.sort)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoPagingFind() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoPagingFind() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoUpdateID(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		id         interface{}
		update     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoUpdateID(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.id, tt.args.update); (err != nil) != tt.wantErr {
				t.Errorf("MgoUpdateID() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoUpdateMany(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
		update     []interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoUpdateMany(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter, tt.args.update); (err != nil) != tt.wantErr {
				t.Errorf("MgoUpdateMany() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoUpdateOne(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
		update     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoUpdateOne(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter, tt.args.update); (err != nil) != tt.wantErr {
				t.Errorf("MgoUpdateOne() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestNewMongodb(t *testing.T) {
	type args struct {
		c *conf.Data
	}
	tests := []struct {
		name string
		args args
		want *mongo.Client
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := NewMongodb(tt.args.c); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("NewMongodb() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_mgoConnect(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
	}
	tests := []struct {
		name string
		args args
		want *mongo.Collection
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := mgoConnect(tt.args.mgoDb, tt.args.DataBase, tt.args.collection); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("mgoConnect() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoAggregate1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     mongo.Pipeline
	}
	tests := []struct {
		name    string
		args    args
		want    interface{}
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoAggregate(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoAggregate() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoAggregate() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoBulkWrite1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		models     []mongo.WriteModel
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoBulkWrite(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.models); (err != nil) != tt.wantErr {
				t.Errorf("MgoBulkWrite() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoConnect1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
	}
	tests := []struct {
		name string
		args args
		want *mongo.Collection
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MgoConnect(tt.args.mgoDb, tt.args.DataBase, tt.args.collection); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoConnect() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoDeleteMany1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoDeleteMany(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter); (err != nil) != tt.wantErr {
				t.Errorf("MgoDeleteMany() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoDeleteOne1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoDeleteOne(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter); (err != nil) != tt.wantErr {
				t.Errorf("MgoDeleteOne() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoFind1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		want    interface{}
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoFind(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoFind() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoFind() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoFindAll1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		want    interface{}
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoFindAll(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoFindAll() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoFindAll() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoFindOne1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		want    bson.D
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoFindOne(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoFindOne() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoFindOne() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoFindTotal1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name    string
		args    args
		want    int64
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoFindTotal(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoFindTotal() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if got != tt.want {
				t.Errorf("MgoFindTotal() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoInsertMany1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		docs       []interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoInsertMany(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.docs); (err != nil) != tt.wantErr {
				t.Errorf("MgoInsertMany() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoInsertOne1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		docs       interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoInsertOne(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.docs); (err != nil) != tt.wantErr {
				t.Errorf("MgoInsertOne() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoIsExist1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
	}
	tests := []struct {
		name string
		args args
		want bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := MgoIsExist(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter); got != tt.want {
				t.Errorf("MgoIsExist() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoPagingFind1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
		limit      int64
		page       int64
		sort       int
	}
	tests := []struct {
		name    string
		args    args
		want    []bson.M
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got, err := MgoPagingFind(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter, tt.args.limit, tt.args.page, tt.args.sort)
			if (err != nil) != tt.wantErr {
				t.Errorf("MgoPagingFind() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(got, tt.want) {
				t.Errorf("MgoPagingFind() got = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestMgoUpdateID1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		id         interface{}
		update     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoUpdateID(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.id, tt.args.update); (err != nil) != tt.wantErr {
				t.Errorf("MgoUpdateID() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoUpdateMany1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
		update     []interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoUpdateMany(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter, tt.args.update); (err != nil) != tt.wantErr {
				t.Errorf("MgoUpdateMany() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestMgoUpdateOne1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
		filter     interface{}
		update     interface{}
	}
	tests := []struct {
		name    string
		args    args
		wantErr bool
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := MgoUpdateOne(tt.args.mgoDb, tt.args.DataBase, tt.args.collection, tt.args.filter, tt.args.update); (err != nil) != tt.wantErr {
				t.Errorf("MgoUpdateOne() error = %v, wantErr %v", err, tt.wantErr)
			}
		})
	}
}

func TestNewMongodb1(t *testing.T) {
	type args struct {
		c *conf.Data
	}
	tests := []struct {
		name string
		args args
		want *mongo.Client
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := NewMongodb(tt.args.c); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("NewMongodb() = %v, want %v", got, tt.want)
			}
		})
	}
}

func Test_mgoConnect1(t *testing.T) {
	type args struct {
		mgoDb      *mongo.Client
		DataBase   string
		collection string
	}
	tests := []struct {
		name string
		args args
		want *mongo.Collection
	}{
		// TODO: Add test cases.
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := mgoConnect(tt.args.mgoDb, tt.args.DataBase, tt.args.collection); !reflect.DeepEqual(got, tt.want) {
				t.Errorf("mgoConnect() = %v, want %v", got, tt.want)
			}
		})
	}
}