CODEWITHSUNDEEP
mongodbgomongo-go
user10400458
user10400458

Reputation:

Mocking MongoDB response in Go

I'm fetching a document from MongoDB and passing it into function transform, e.g. 

var doc map[string]interface{}
err := collection.FindOne(context.TODO(), filter).Decode(&doc) 
result := transform(doc)

I want to write unit tests for transform, but I'm not sure how to mock a response from MongoDB. Ideally I want to set something like this up:

func TestTransform(t *testing.T) {
    byt := []byte(`
    {"hello": "world",
     "message": "apple"}
 `)

    var doc map[string]interface{}

    >>> Some method here to Decode byt into doc like the code above <<<

    out := transform(doc)
    expected := ...
    if diff := deep.Equal(expected, out); diff != nil {
        t.Error(diff)
    }
}

One way would be to json.Unmarshal into doc, but this sometimes gives different results. For example, if the document in MongoDB has an array in it, then that array is decoded into doc as a bson.A type not []interface{} type.

Upvotes: 7

Views: 7882

Answers (3)

AnhellO
AnhellO

Reputation: 1069

A member from my team recently found out there is a hidden gem inside the official MongoDB driver for GO: https://pkg.go.dev/go.mongodb.org/[email protected]/mongo/integration/mtest. Although the package is in experimental mode and there is no backward compatibility guaranteed for it, it can help you to perform unit testing, at least with this version of the driver.

You can check this cool article with plenty of examples of how to use it: https://medium.com/@victor.neuret/mocking-the-official-mongo-golang-driver-5aad5b226a78. Additionally, here is the repository with the code samples for this article: https://github.com/victorneuret/mongo-go-driver-mock.

So, based in your example and the samples from the article I think you could try something like the following (of course, you might need to tweak and experiment with this):

func TestTransform(t *testing.T) {
    mt := mtest.New(t, mtest.NewOptions().ClientType(mtest.Mock))
    defer mt.Close()

    mt.Run("find & transform", func(mt *mtest.T) {
        myollection = mt.Coll
        expected := myStructure{...}

        mt.AddMockResponses(mtest.CreateCursorResponse(1, "foo.bar", mtest.FirstBatch, bson.D{
            {"_id", expected.ID},
            {"field-1", expected.Field1},
            {"field-2", expected.Field2},
        }))

        response, err := myFindFunction(expected.ID)
        if err != nil {
            t.Error(err)
        }

        out := transform(response)
        if diff := deep.Equal(expected, out); diff != nil {
            t.Error(diff)
        }
    })
}

Alternatively, you can perform a more real testing and in an automated way via integration testing with Docker containers. There are a few good packages that could help you with this:

I have followed this approach with dockertest library to automate a full integration testing environment that could be setUp and tearDown via the go test -v -run Integration command. See a full example here: https://github.com/AnhellO/learn-dockertest/tree/master/mongo.

Hope this helps.

Upvotes: 5

mentalmap
mentalmap

Reputation: 35

Using monkey library to hook any function from mongo driver.

For example:

func insert(collection *mongo.Collection) (int, error) {
    ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)

    u := User{
        Name: "kevin",
        Age:  20,
    }

    res, err := collection.InsertOne(ctx, u)
    if err != nil {
        log.Printf("error: %v", err)
        return 0, err
    }

    id := res.InsertedID.(int)
    return id, nil
}

func TestInsert(t *testing.T) {
    var c *mongo.Collection

    var guard *monkey.PatchGuard
    guard = monkey.PatchInstanceMethod(reflect.TypeOf(c), "InsertOne",
        func(c *mongo.Collection, ctx context.Context, document interface{}, opts ...*options.InsertOneOptions) (*mongo.InsertOneResult, error) {
            guard.Unpatch()
            defer guard.Restore()

            log.Printf("record: %+v, collection: %s, database: %s", document, c.Name(), c.Database().Name())
            res := &mongo.InsertOneResult{
                InsertedID: 100,
            }

            return res, nil
        })

    collection := client.Database("db").Collection("person")
    id, err := insert(collection)

    require.NoError(t, err)
    assert.Equal(t, id, 100)
}

Upvotes: 0

alexzimmer96
alexzimmer96

Reputation: 1036

The best solution to write testable could would be to extract your code to a DAO or Data-Repository. You would define an interface which would return what you need. This way, you can just used a Mocked Version for testing.

// repository.go
type ISomeRepository interface {
    Get(string) (*SomeModel, error)
}

type SomeRepository struct { ... }

func (r *SomeRepository) Get(id string) (*SomeModel, error) {
    // Handling a real repository access and returning your Object
}

When you need to mock it, just create a Mock-Struct and implement the interface:

// repository_test.go

type SomeMockRepository struct { ... }

func (r *SomeRepository) Get(id string) (*SomeModel, error) {
    return &SomeModel{...}, nil
}

func TestSomething() {
    // You can use your mock as ISomeRepository
    var repo *ISomeRepository
    repo = &SomeMockRepository{}
    someModel, err := repo.Get("123")
}

This is best used with some kind of dependency-injection, so passing this repository as ISomeRepository into the function.

Upvotes: 1

Related Questions