What is Unit Testing?
Unit testing is a method we follow to test the smallest piece of code that can be logically isolated in a project often a function.
In Golang we have our standard library called testing. We use it to test a function and check various scenarios and our function is behaving the way we want.
Why do we need Unit Testing?
That’s an interesting question we use it for convenience and maintainability of our project in long term. Once the project has gone bigger & bigger it will be very hard for the developer to test that every corner of the project is running properly if some part of the code is changed. So we use testing for that suppose some developer has changed some part of the code & they can run the test and see everything is running properly.
What is Mocking?
Suppose you have written a web API or have written something related to a Database so when you will be testing you will require some kind of similar environment like a Server or Database to test your code. But, it’s very expensive and inconvenient to have some server or database to test the code. So we use something called mocking which consists of some kind of fake environment for testing and will provide similar features to the actual environment.
Testing MongoDB
Now you know what is testing and mocking and have written some awesome MongoDB and now you want to test the code. MongoDB provides something for us which is mtest. (P.S. – It states that “mtest is unstable and there is no backward compatibility guarantee. It is experimental and subject to change.”). So using it is a little tricky.
Creating Mock Environment
To create a mock deployment in mtest we do the following –
mt := mtest.New(t, mtest.NewOptions().DatabaseName("test-db").ClientType(mtest.Mock))
It will create and return a mock MongoDB deployment upon which we can run our tests.
Sample Go code to test
Suppose you have the following Go struct data –
type Data struct {
ID primitive.ObjectID `json:"id" bson:"_id"`
DataID string `json:"data_id" bson:"data_id"`
Name string `json:"name" bson:"name"`
PublishedAt time.Time `json:"publishedAt" bson:"publishedAt"`
}
You have the following method for this data struct dealing with MongoDB.
func Create(ctx context.Context, data Data, col *mongo.Collection) (string, error) {
_, err := col.InsertOne(ctx, data)
if err != nil {
return "", err
}
return "Data Created", nil
}
func Get(ctx context.Context, dataID string, col *mongo.Collection) (Data, error) {
res := col.FindOne(ctx, bson.M{
"data_id": dataID,
})
if res.Err() != nil {
return Data{}, res.Err()
}
var data Data
err := res.Decode(&data)
if err != nil {
return Data{}, err
}
return data, nil
}
Writing tests for the above code
Create
By default when you run the mtest for a mock deployment it will create a collection mt.Coll and delete it after the test has been done. So, below which we will write a typical success command –
func TestCreateData(t *testing.T) {
t.Parallel()
ctx := context.Background()
mt := mtest.New(t, mtest.NewOptions().DatabaseName("test-db").ClientType(mtest.Mock))
defer mt.Close()
testCases := []struct {
name string
data Data
prepareMock func(mt *mtest.T)
want string
wantErr bool
}{
{
name: "create data successfully",
data: Data{
ID: primitive.NewObjectID(),
DataID: uuid.New().String(),
Name: "John Doe",
PublishedAt: time.Now(),
},
prepareMock: func(mt *mtest.T) {
mt.AddMockResponses(mtest.CreateSuccessResponse())
},
want: "Data Created",
wantErr: false,
},
}
for _, tt := range testCases {
mt.Run(tt.name, func(mt *mtest.T) {
tt.prepareMock(mt)
got, err := Create(ctx, tt.data, mt.Coll)
if tt.wantErr {
assert.Errorf(t, err, "Want error but got: %v", err)
} else {
assert.NoErrorf(t, err, "Not expecting error but got: %v", err)
}
assert.Equalf(t, tt.want, got, "want: %v, but got: %v", tt.want, got)
})
}
}
What we are doing here –
- Creating the MongoDB mock deployment(Also closing it after it is done by defer).
- Defining a struct slice with the necessary data needed to test and operating over the slice so that in long term we can add more scenarios without writing the same code again and again.
- prepareMock – It’s where we are creating the mock response on the collection. This means when you will be calling the target method the mock response will be returned and you will check whether your function is behaving correctly with the response scenario or not.
- Lastly, you will call the
Createmethod and assert the return values with the desired values or not.
Thanks to mtest that it provides a function to create a mock response for some successful insertion of data in the DB that is mtest.CreateSuccessResponse()
Get
Here if you see the code you will see that there are three scenarios in the code –
- Get data successfully.
- If no filter matches then it returns an error.
- If data inside the Db is corrupted then it will throw some decode error.
func TestGetData(t *testing.T) {
t.Parallel()
ctx := context.Background()
mt := mtest.New(t, mtest.NewOptions().DatabaseName("test-db").ClientType(mtest.Mock))
defer mt.Close()
id := primitive.NewObjectID()
dataid := uuid.New().String()
publishedAt := time.Now().UTC().Truncate(time.Millisecond)
testCases := []struct {
name string
dataID string
prepareMock func(mt *mtest.T)
want Data
wantErr bool
}{
{
name: "get Data Successfully",
prepareMock: func(mt *mtest.T) {
first := mtest.CreateCursorResponse(1, "foo.bar", mtest.FirstBatch, bson.D{
{Key: "_id", Value: id},
{Key: "data_id", Value: dataid},
{Key: "name", Value: "John Doe"},
{Key: "publishedAt", Value: publishedAt},
})
killCursor := mtest.CreateCursorResponse(0, "foo.bar", mtest.NextBatch)
mt.AddMockResponses(first, killCursor)
},
dataID: dataid,
want: Data{
ID: id,
DataID: dataid,
Name: "John Doe",
PublishedAt: publishedAt,
},
wantErr: false,
},
{
name: "get decode error",
prepareMock: func(mt *mtest.T) {
// The name expect a `string` but in the DB there is `integer` stored
// So, while decoding it will throw an error.
first := mtest.CreateCursorResponse(1, "foo.bar", mtest.FirstBatch, bson.D{
{Key: "_id", Value: id},
{Key: "data_id", Value: dataid},
{Key: "name", Value: 1234},
{Key: "publishedAt", Value: publishedAt},
})
killCursor := mtest.CreateCursorResponse(0, "foo.bar", mtest.NextBatch)
mt.AddMockResponses(first, killCursor)
},
dataID: dataid,
want: Data{},
wantErr: true,
},
{
name: "wrong data ID",
prepareMock: func(mt *mtest.T) {
mt.AddMockResponses(bson.D{
{Key: "ok", Value: 1},
{Key: "acknowledged", Value: true},
{Key: "n", Value: 0},
})
},
dataID: uuid.NewString(),
want: Data{},
wantErr: true,
},
}
for _, tt := range testCases {
mt.Run(tt.name, func(mt *mtest.T) {
tt.prepareMock(mt)
got, err := Get(ctx, tt.dataID, mt.Coll)
if tt.wantErr {
assert.Errorf(t, err, "Want error but got: %v", err)
} else {
assert.NoErrorf(t, err, "Not expecting error but got: %v", err)
}
assert.Equalf(t, tt.want, got, "want: %v, but got: %v", tt.want, got)
})
}
}
What we are doing here –
- As usual, initiating mock MongoDB deployment.
- Defining a struct slice with necessary fields for testing. Also, define some Data struct fields so that it stays unique throughout the test case.
- Scenario 1 (Successful Get of Data) – Here we define a mock response for the collection –
first := mtest.CreateCursorResponse(1, "foo.bar", mtest.FirstBatch, bson.D{
{Key: "_id", Value: id},
{Key: "data_id", Value: dataid},
{Key: "name", Value: "John Doe"},
{Key: "publishedAt", Value: publishedAt},
})
killCursor := mtest.CreateCursorResponse(0, "foo.bar", mtest.NextBatch)
mt.AddMockResponses(first, killCursor)
Once we call the Get function the collections will return these mock responses and will not throw any error and return the data.
- Scenario 2 (Decode Error) – Here we will return a mock response that will consist of an integer field in a place where it should be a string.
first := mtest.CreateCursorResponse(1, "foo.bar", mtest.FirstBatch, bson.D{
{Key: "_id", Value: id},
{Key: "data_id", Value: dataid},
{Key: "name", Value: 1234},
{Key: "publishedAt", Value: publishedAt},
})
killCursor := mtest.CreateCursorResponse(0, "foo.bar", mtest.NextBatch)
mt.AddMockResponses(first, killCursor)
Here the Get function will get the response and will try to decode it wouldn’t be able to do it and will return a decode error.
- Scenario 3 (No Filter Match) – Here we will create a mock response that will consist of zero response.
mt.AddMockResponses(bson.D{
{Key: "ok", Value: 1},
{Key: "acknowledged", Value: true},
{Key: "n", Value: 0},
})
Here the Get method will get n = 0 means no filter match and throw an error and that’s the correct behavior.
Thanks 🙂
Aniruddha Basak 