Go Lang How to Mock Package Method? [duplicate] - unit-testing

Question

Part of our code is time-sensitive, and we need to able to reserve something and then release it in 30-60 seconds, etc., which we can just do a time.Sleep(60 * time.Second).
I have just implemented the time interface, and during the test I used a stubbed implementation of the time interface, similar to this golang-nuts discussion.
However, time.Now() is called in multiple sites which means we need to pass a variable around to keep track of how much time we have actually slept.
Is there an alternative way to stub out time.Now() globally? Maybe making a system call to change the system clock?
Can we maybe write our own time package which basically wraps around the time package but allows us to change it?
Our current implementation works well. I am a Go beginner, and I am curious to see if anyone has other ideas.

Answer 1

With implementing a custom interface you are already on the right way. I take it you use the following advise from the golang-nuts thread you've posted:
type Clock interface {
Now() time.Time
After(d time.Duration) <-chan time.Time
}
and provide a concrete implementation
type realClock struct{}
func (realClock) Now() time.Time { return time.Now() }
func (realClock) After(d time.Duration) <-chan time.Time { return time.After(d) }
and a testing implementation.
Original
Changing the system time while making tests (or in general) is a bad idea.
You don't know what depends on the system time while executing tests and you don't want to find out the hard way by spending days of debugging into that. Just don't do it.
There is also no way to shadow the time package globally and doing that would not do
anything more you couldn't do with the interface solution. You can write your own time package
which uses the standard library and provides a function to switch to a mock time library for
testing if it is the time object you need to pass around with the interface solution that is bothering you.
The best way to design and test your code would probably be to make as much code stateless as possible.
Split your functionality in testable, stateless parts. Testing these components separately is much easier then. Also, fewer side effects means that it is much easier to make the code run concurrently.

Answer 2

If the methods you need to mock are few, such as Now(), you can make a package variable which can be overwritten by tests:
package foo
import "time"
var now = time.Now
// The rest of your code...which calls now() instead of time.Now()
then in your test file:
package foo
import (
"testing"
"time"
)
var now = func() time.Time { return ... }
// Your tests

Answer 3

I use the bouk/monkey package to replace the time.Now() calls in my code with a fake:
package main
import (
"fmt"
"time"
"github.com/bouk/monkey"
)
func main() {
wayback := time.Date(1974, time.May, 19, 1, 2, 3, 4, time.UTC)
patch := monkey.Patch(time.Now, func() time.Time { return wayback })
defer patch.Unpatch()
fmt.Printf("It is now %s\n", time.Now())
}
This works well in tests to fake out system dependencies and avoids the abused dependency injection (DI) pattern. Production code stays separate from test code and you gain useful control of system dependencies.

Answer 4

Also if you need to just stub time.Now you can inject the dependency as a function, e.g.,
func moonPhase(now func() time.Time) {
if now == nil {
now = time.Now
}
// Use now()...
}
// Then dependent code uses just
moonPhase(nil)
// And tests inject own version
stubNow := func() time.Time { return time.Unix(1515151515, 0) }
moonPhase(stubNow)
Granted, all that is a bit ugly if you come from a dynamic languages background (e.g., Ruby) :(

Answer 5

There are multiple way to mock or stub time.Now() in test code:
Passing an instance of time to the function
func CheckEndOfMonth(now time.Time) {
...
}
Passing a generator to the function
CheckEndOfMonth(now func() time.Time) {
// ...
x := now()
}
Abstract with an interface
type Clock interface {
Now() time.Time
}
type realClock struct {}
func (realClock) Now() time.Time { return time.Now() }
func main() {
CheckEndOfMonth(realClock{})
}
Package level time generator function
type nowFuncT func() time.Time
var nowFunc nowFuncT
func TestCheckEndOfMonth(t *Testing.T) {
nowFunc = func() time.Time {
return time.Now()
}
defer function() {
nowFunc = time.Now
}
// Test your code here
}
Embed time generator in struct
type TimeValidator struct {
// .. your fields
clock func() time.Time
}
func (t TimeValidator) CheckEndOfMonth() {
x := t.now()
// ...
}
func (t TimeValidator) now() time.Time {
if t.clock == nil {
return time.Now() // default implementation which fall back to standard library
}
return t.clock()
}
Each has its own pluses and minuses. The best way is to separate the function that generates the time and the processing part that uses the time.
The post Stubbing Time in golang goes into details about it and there is an example for making function with time dependency to be easily tested.

Answer 6

We can stub time.Now simply by using the Go package undefinedlabs/go-mpatch.
Import the go-mpatch package and put the below code snippet in the code wherever you need to stub time.Now():
mpatch.PatchMethod(time.Now, func() time.Time {
return time.Date(2020, 11, 01, 00, 00, 00, 0, time.UTC)
})
Replace the values of time.Date as per your need.
check out the sample code to check the working of go-mpatch.
go-playground sample

Answer 7

I found a relatively simple solution here. The basic idea is using another function called "nowFunc" to get the time.Now().
In your main, initialize this function to return time.Now(). In your test, initialize this function to return a fixed fake time.

Answer 8

This is the same as Jonathan Hall's answer, but I am adding a concrete example.
Concept:
You can create a global function called CurrentTime to wrap the time.now()
Reassign the CurrentTime function in tests, and make it return the desired value.
File main.go
package main
import (
"fmt"
"time"
)
func main() {
fmt.Printf("This is the current year : %d ", GetCurrentYear())
}
// 'GetCurrentYear' function uses 'CurrentTime' function internally
func GetCurrentYear() int {
return CurrentTime().Year()
}
var CurrentTime = func() time.Time {
return time.Now()
}
File main_test.go
package main
import (
"testing"
"time"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) { TestingT(t) }
type S struct{}
var _ = Suite(&S{})
func (s *S) TestCurrentYearShouldBeReturnedCorrectly(c *C) {
expectedYear := 2022
curentInstant := time.Date(expectedYear, 12, 01, 00, 00, 00, 0, time.UTC)
// Make 'CurrentTime' return hard-coded time in tests
CurrentTime = func() time.Time {
return curentInstant
}
c.Assert(GetCurrentYear(), Equals, expectedYear)
}
Here is the Go Playground link.

Answer 9

The simple alternative is you can use sqlmock.AnyArg() to pass time.Now() as an argument.
Example
If the query is
[sqlBuilder.Update][2](tableName).Set("last_updated", time.Now()).Where(sq.Eq{"id": id}).ToSql()
and you want to mock this, do
sqlMock.ExpectExec("UPDATE tableName SET last_updated = ? WHERE id = ?").WithArgs(sqlmock.AnyArg())
instead of
sqlMock.ExpectExec("UPDATE tableName SET last_updated = ? WHERE id = ?").WithArgs(time.Now())

Answer 10

You can also use the faketime method used for Go Playground.
It will keep an internal "clock" value which replaces time.Now(), and will instantly return from any call to time.Sleep(), merely increasing the internal counter.
All calls to runtime.write (for example, fmt.Println) will be prefixed with the following header:
\0 \0 P B <8-byte time> <4-byte data length> (big endian)
It was implemented here: https://github.com/golang/go/commit/5ff38e476177ce9e67375bd010bea2e030f2fe19
Using it is as simple as go run -tags=faketime test.go
Example test.go:
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("Test!")
time.Sleep(time.Second * 5)
fmt.Println("Done.")
}
Output:
go run -v -tags=faketime scratch_22.go | hexdump -C
00000000 00 00 50 42 11 74 ef ed ab 18 60 00 00 00 00 06 |..PB.t....`.....|
00000010 54 65 73 74 21 0a 00 00 50 42 11 74 ef ee d5 1e |Test!...PB.t....|
00000020 52 00 00 00 00 06 44 6f 6e 65 2e 0a |R.....Done..|
0000002c
However, I wouldn't recommend using this for actual unit tests, as the change to runtime.write will probably have unintended consequences, breaking a lot of other things.

Answer 11

What works for me is a small struct
package clock
import "time"
type Clock struct {
MockTime time.Time
}
func (c Clock) Now() time.Time {
if c.MockTime.IsZero() {
return time.Now() // use default golang
} else {
return c.MockTime
}
}
Embed the Clock struct in your struct as a dependency, or pass it along as function parameter.