I'm mocking out a DataStore and it's Get/Set functionality. The trouble I'm having is: cannot use s (type *MockStore) as type *datastore.Storage in argument to EventHandler
This is caused by my EventHandler function needing to be passed a *datastore.Storage as an argument type. I want to Test (http test) EvenHandler() using the MockStore I've created instead of the real datastore. I'm using the golang testify mock package.
Some Code Examples
type MockStore struct{
mock.Mock
}
func (s *MockStore) Get() ...
func EventHandler(w http.ResponseWriter, r *http.Request, bucket *datastore.Storage){
//Does HTTP stuff and stores things in a data store
// Need to mock out the data store get/sets
}
// Later in my Tests
ms := MockStore
EventHandler(w,r,ms)
A few things:
Create an interface that will be implemented both by datastore.Storage and your mock store.
Use the above interface as the argument type in EventHandler (not a pointer to the interface).
Pass a pointer to your MockStore to EventHandler, as the Get method is defined for a pointer to the struct.
Your updated code should be something like the following:
type Store interface {
Get() (interface{}, bool) // change as needed
Set(interface{}) bool
}
type MockStore struct {
mock.Mock
}
func (s *MockStore) Get() ...
func EventHandler(w http.ResponseWriter, r *http.Request,bucket datastore.Storage){
//Does HTTP stuff and stores things in a data store
// Need to mock out the data store get/sets
}
// Later in my Tests
ms := &MockStore{}
EventHandler(w,r,ms)
Related
I have to mock test a service.to create new service i need to pass gorm.DB{} but every time i pass it and run the test i get nil pointer error(panic).
please help on how to mock gorm.DB{} instance correctly for unit testing.
func NewService(db *gorm.DB) Service {
return &service{
repo: newReactionRepo(db),
}
}
making the mock call in the test like this :-
mockDB = &gorm.DB{}
package.NewService(mockDB)
getting this error
testing.tRunner.func1.2({0x1648e40, 0x21cdd60})
C:/Program Files/Go/src/testing/testing.go:1396 +0x24e
testing.tRunner.func1()
C:/Program Files/Go/src/testing/testing.go:1399 +0x39f
panic({0x1648e40, 0x21cdd60})
C:/Program Files/Go/src/runtime/panic.go:884 +0x212
gorm.io/gorm.(*DB).Session(0x21ef260, 0xc000861a50)
C:/Users/acb/sdk/go1.17/pkg/mod/gorm.io/gorm#v1.24.2/gorm.go:215 +0x3b
gorm.io/gorm.(*DB).WithContext(...)
You could initialize db, ie:
//...
mockDB := initDb()
package.NewService(mockDB)
//...
func initDb() *gorm.DB {
dsn := "host=localhost user=myuser password=mypassword dbname=mydb port=5432 sslmode=disable"
db, err := gorm.Open(postgres.Open(dsn))
if err != nil {
log.Fatal("couldn't connect to db")
}
return db
}
Since the gorm.DB type is a struct, it makes unit testing with it directly a bit difficult. With the nil pointer error you are getting, you may need to modify your code to check for a nil value passed in so that it doesn't try and call methods on a nil pointer.
If you want to have unit tests, you could wrap your database operations in an interface, and then provide a mock implementation that does not use a real database. This can be done by creating an interface that defines the methods needed for interacting with the database, and then creating a struct that implements this interface for the actual database operations.
For example:
// Database is an interface that defines methods for interacting with a database.
type Database interface {
Create(data interface{}) error
GetByID(id int, result interface{}) error
}
// RealDatabase is a struct that implements the Database interface
// using a real GORM connection.
type RealDatabase struct {
// db is a connection to the database
db *gorm.DB
}
// Create saves the data in the database
func (rdb *RealDatabase) Create(data interface{}) error {
return rdb.db.Create(data).Error
}
// GetByID retrieves the data by ID from the database
func (rdb *RealDatabase) GetByID(id int, result interface{}) error {
return rdb.db.First(result, id).Error
}
// MockDatabase is a struct that implements the Database interface
// using a mock GORM connection.
type MockDatabase struct {
// data is a map of ID to data used for mocking.
data map[int]interface{}
}
// Create does not do anything but returns no errors
func (mdb *MockDatabase) Create(data interface{}) error {
return nil
}
// GetByID returns the data for a given ID
func (mdb *MockDatabase) GetByID(id int, result interface{}) error {
data, ok := mdb.data[id]
if !ok {
return fmt.Errorf("data not found for ID: %d", id)
}
result = data
return nil
}
In this example, the RealDatabase struct uses GORM to interact with the database, while the MockDatabase struct uses a map to mimic the behavior of the real database. The Create method in the MockDatabase struct does nothing and returns no errors, and the GetByID method returns the data for a given ID. You can also add more functionality to the mock struct and the interface to mimic the behavior of the real database as needed.
Finally, you could also use the Gomock library, which provides tools to automatically generate mock versions of interfaces you provide to it.
You might try something using composition.
type DBInstance struct {
*gorm.DB
}
Pass an instance of DBInstance to NewService(db DBInstance) instead of *gorm.DB. You can mock the methods of *gorm.DB that are used when unit testing your code. Example:
func (DBInstance) Find(dest interface{}, conds ...interface{}) (tx *DB) {
// mock implementation of gorm.DB.Find()
}
When calling from actual code use initialize DB instance using the db instance:
dsn := "host=localhost user=myuser password=mypassword dbname=mydb port=5432 sslmode=disable"
db, err := gorm.Open(postgres.Open(dsn))
dbInstance := DBInstance{
&db,
}
When calling from unit test, pass an empty uninitialized *gorm.DB object and mock all the required methods.
dbInstance := DBInstance{
&gorm.DB{},
}
I am trying to create a database mock in my code, then i am introducing interfaces to my code, to create the mock:
This is my code (I don't know if it's the correct approach)
package interfaces
type ObjectAPI interface {
FindSomethingInDatabase(ctx context.Context, name string) (e.Response, error)
}
And my implementation of the interface is:
package repositories
func FindSomethingInDatabase(ctx context.Context, name string) (e.Response, error) {
statement, err := db.SqlStatementWithCtx(ctx,
`SELECT *
FROM table
WHERE name = ? LIMIT 1`)
row := statement.QueryRowContext(ctx, name)
if err != nil {
return e.Response{}, err
}
statement.Close()
return toResponse(row), nil //this method convert row database to e.Response struct
}
Now I need call from one method the implementation of my FindSomethingInDatabase, then i am receiving an object type interface:
func CallImplementation(request *dto.XRequest, repo i.ObjectAPI) dto.XResponse{
result := repo.FindSomethingInDatabase(request.Ctx, request.Name)
// more code
}
But now I don't know how can I call CallImplementation` to pass an object with the implementation.
Call the method passing the implementation of the interface
An interface describes a type. Since your FindSomethingInDatabase implementation is just a func without a receiver, there is no type that implements interface ObjectAPI.
You can pass a value of type func(ctx context.Context, name string) (e.Response, error) into CallImplementation as a callback and get rid of the interface altogether. Alternatively, keep the interface, define a type, and make that type the receiver for your current FindSomethingInDatabase implementation. You can then pass the type to CallImplementation, since it will now implement the ObjectAPI interface. An example of the latter (which would be my preferred option for extensibility):
type database struct {}
func (d *database) FindSomethingInDatabase(ctx context.Context, name string) (e.Response, error) {
// ...
}
func CallImplementation(request *dto.XRequest, repo i.ObjectAPI) dto.XResponse{
result := repo.FindSomethingInDatabase(request.Ctx, request.Name)
// more code
}
func main() {
db := &database{}
_ = Callimplementation(getRequest(), db)
}
In this case, you will probably want to store db as a member of database, rather than having it as a global variable (which appears to be the case now).
refer mockery. it provides auto generation of mocks for interfaces and can be good reference about best practices for mocking.
typically you would do this:
api.go:
type API interface {
Something(ctx context.Context, name string) (e.Response, error)
}
type ApiImpl struct {
}
func (t *ApiImpl) Something(ctx context.Context, name string) (e.Response, error) {
// impl
}
api_test.go
// mocks can be hand coded or autogenerated using mockery
type MockImpl struct {
}
func (m *MockImpl) Something(ctx context.Context, name string) (e.Response, error) {
// mock implementation
}
func TestSomething(t * testing.T) {
// test code with mocks
}
I am new to golang and came from a java background.
Here is my problem today: How to unit test a component that uses a third-party library that doesn't provide an interface in Golang? Here is my concrete example:
I have a class that uses golang mongodb driver to implement some DB operations like below:
package mypackage
type myClientBeingTested struct {
client *mongo.Client
}
func (mc *myClientBeingTested) FindOne(filter interface{}) (*mongo.SingleResult, error) {
result := mc.client.FindOne(context.Background(), filter)
if result.Err() == mongo.ErrNoDocuments {
return nil, nil
} else {
return nil, Errors.New("My own error message")
}
return result, nil
}
Now I'd like to write some unit tests for this method and realized that it's impossible to mock a third party dependency that doesn't have an interface implementation. In the example above, mongo.Client is a struct type. After some researching and thinking, the only possible way seems to be like below:
package mypackage
type myClientBeingTested struct {
client *mongo.Client
}
var findOneFunc = func(client *mongo.Client, ctx context.Context, filter interface{}) (*mongo.SingleResult, error) {
return client.findOne(ctx, filter)
}
func (mc *myClientBeingTested) FindOne(filter interface{}) (*mongo.SingleResult, error) {
result := findOneFunc(mc.client, filter)
if result.Err() == mongo.ErrNoDocuments {
return nil, nil
} else {
return nil, Errors.New("My own error message")
}
return result, nil
}
Then in my unit test I can stub findOneFunc with my own stub like below
findOneFunc = func(client *mongo.Client, ctx context.Context, filter interface{}) (*mongo.SingleResult, error) {
// my own implementation
}
But this seems to be a hack. Is there any authentic/recommended way to handling situations like that? Appreciate your responses!
It should be possible to write your own interface for the methods that you need to use from a struct imported from a 3rd party library.
type MongoClient interface {
FindOne(context.Context, mongo.D) (*mongo.SingleResult, error)
}
type myClientBeingTested struct {
client MongoClient
}
// in tests
type mockMongoClient struct {
// implement MongoClient, pass in to myClientBeingTested
}
However for most apps it provides a better guarantee to run tests against a local or in memory database to verify that everything works end to end. If that becomes too slow it can make sense to mock at the business logic level instead of the database query level.
For example:
type User struct {}
type UserMgmt interface {
Login(email, pass string) (*User, error)
}
// for testing api or workflows
type MockUserMgmt struct {}
// for production app
type LiveUserMgmt struct {
client *mongo.Client
}
In the unit test it would look like:
// user_mgmt_test.go test code
userMgmt := &LiveUserMgmt{client: mongo.Connect("localhost")}
// test public library methods
In api or workflow tests it would look like:
userMgmt := &MockUserMgmt{}
// example pass to api routes
api := &RequestHandler{
UserMgmt: userMgmt,
}
EDIT:
I'm too new to comment on my post, but re your question about mocking the struct, you apply the same principle. If the mongo type is a struct, you can create an interface (even with the same name) and depend on the interface instead of directly depending on the struct. Then via the interface you can mock out the methods you need to.
// The mongo struct you depend on and need to mock
type mongo struct {
someState string
}
// The real world function you need to mock out
func (m *mongo) Foo() error {
// do stuff
return nil
}
// Construct an interface with a method that matches the signature you need to mock
type mockableMongoInterface interface {
Foo() error
}
Now depend on mockableMongoInterface instead of directly on mongo. You can still pass your third party mongo struct to sites where you need it, because go will understand the type via the interface.
This aligns with Adrian's comment on your question.
I have a piece of code which accepts an io.Writer implementation as an argument.
func printSummary(writer io.Writer) {
// Implementation of the 'printSummary' method goes here.
}
Now, I can easily create a mock to create a unit test.
This would look like the following:
type ioWriterMock struct {
writtenBytes []byte
}
func (writer *ioWriterMock) Write(p []byte) (int, error) {
writer.writtenBytes = append(writer.writtenBytes, p...)
return 0, nil
}
However, this does mean that I need to declare my mock outside of my unit test, which makes it available in the whole package.
I would like to create my test, and that everything that my test depends on is inside the test.
This for the simple reason that everything is in one place and that I don't need to scan different files in my package to find the different parts that are required for my test.
In a unit test, you can create a struct and define functions.
This is done using the following approach:
func TestParse(t *testing.T) {
type utCase struct {
name string
summary string
expectedWrittenBytes []byte
}
createUtCase := func(name, summary string, expWrittenBytes []byte) utCase {
retVal := new(utCase)
retVal.name = name
retVal.summary = summary
retVal.expectedWrittenBytes = expWrittenBytes
return *retVal
}
}
So embedding the io.Writer mock in the unit test can be done in the following way:
func TestParse(t *testing.T) {
type ioWriterMock struct {
writtenBytes []byte
}
}
One thing which I don't find is how I'm able to implement the io.Writer interface on that type.
As suggested by #mkopriva, put the ioWriterMock definition next to the TestParse function in the _test.go file. In go, it is not allowed to put the definition of a function inside another function. You can only define the struct type in a function.
By defining the ioWriterMock type and Write method inside the test file, it will only be visible during test execution. It won't be present and thus visible when using the package outside of a test.
Also, considering the given example, a bytes.Buffer would be a good free substitute to your ioWriterMock as suggested by #Flimzy.
I am looking to test the PostUser function that looks something like this (error handling omitted for simplicity):
func PostUser(env *Env, w http.ResponseWriter, req *http.Request) error {
decoder := json.NewDecoder(req.Body)
decoder.Decode(&user)
if len(user.Username) < 2 || len(user.Username) > 30 {
return StatusError{400, errors.New("usernames need to be more than 2 characters and less than 30 characters")}
}
emailRe := regexp.MustCompile(`^[a-z0-9._%+\-]+#[a-z0-9.\-]+\.[a-z]{2,4}$`)
if !emailRe.MatchString(user.Email) {
return StatusError{400, errors.New("invalid email address")}
}
if len(user.Password) < 8 {
return StatusError{400, errors.New("passwords need to be more at least 8 characters")}
}
hashedPassword,_ := bcrypt.GenerateFromPassword([]byte(user.Password), 12)
env.DB.InsertUser(user.Username, hashedPassword, user.Email) // need to mock this out
userData,_ := json.Marshal(user)
defer req.Body.Close()
w.Write(userData)
return nil
}
My env.go file looks like this:
type Env struct {
DB *db.DB
}
My db.go file looks like this:
type DB struct {
Session *mgo.Session
}
How do I mock the InsertUser call by my DB struct, so that I can unit test the PostUser?
To use mocks for testing you need to create an interface that your mock can implement. Naturally, the struct you're replacing the mock with also needs to implement all the methods of the interface so that they are freely interchangeable.
For example, you could have an interface:
type DBInterface interface {
InsertUser(string, string, string)
//all other methods on the DB struct here
}
Then your DB struct already implements all the methods of the interface. From there you can create a mock struct that also implements the interface.
type DBMock struct {}
func (dbm *DBMock) InsertUser(username, password, email string) {
//whatever mock functionality you want here
return
}
//all other methods also implemented.
Then you can alter env to have a pointer to a DBInterface instead of a DB. When you setup the env to be passed into the handler, in the production version use the DB struct and in testing use the DBMock struct.