Code

const XGO_VERSION = ""

func TestListStdlib(t *testing.T) {
	if XGO_VERSION != "" {
		t.Fatalf("fail")
	}
}

Compile err:

cannot convert string(__xgo_XGO_VERSION_13_5) == "" (untyped bool value) to type string

Reason: during constant propagation, operations are wrapped also. But if the operator yields bool, we can stop.

type MyStruct struct {
    name string
}
func (c *MyStruct) Name() name{
    return c.name
}

*MyStruct.Name return type is invalid, should be:

type MyStruct struct {
    name string
}
func (c *MyStruct) Name() string {
    return c.name
}

Current implementation does not support nested mocking:

func Foo() string {
     return "foo " + Bar()
}

func Bar() string {
    return "bar"
}

If setup mock on Foo, then Bar cannot be mocked.

The main consideration is xgo cannot figure out if calling interceptor inside pre or post stage will cause infinite recursion or not. Actually, there are cases where calling or not calling can make sense. So xgo cannot determine if a function intercepting should be nested.

Thus, to avoid surprising users, xgo defaults to avoid nested trap.

The bug #9 (comment) was introduced by adding test on windows.

But when committing the tests only pass go1.22.1, from go1.17 to go1.21 were not tested against.

I believe if there were some CI job to do the tests this bug can be easily noticed and fixed.

When compiling:

const SET_EMPTY_STRING = "<empty>"
const SET_ZERO = math.MaxInt64 - 1
const SET_ZERO_UINT = math.MaxUint64 - 1
const SET_ZERO_INT32 = math.MaxInt32 - 1
const SET_ZERO_UINT32 = math.MaxUint32 - 1

Workaround:

const SET_EMPTY_STRING = "<empty>"
const SET_ZERO int64 = math.MaxInt64 - 1
const SET_ZERO_UINT uint64 = math.MaxUint64 - 1
const SET_ZERO_INT32 int32 = math.MaxInt32 - 1
const SET_ZERO_UINT32 uint32 = math.MaxUint32 - 1

This may be caused by protobuf. But cyclic reference should also be handled normally.

When writing asserts, could we just naturally do the actual check without repeating any name?

Current situation:

if result!="1234"{
    t.Fatalf("expect result to be %s, actual: %s", "123", result)
}

If we can just write:

assert.Assert(result=="1234")

And xgo prints the variable name and actual value in a breaking down style upon failure:

xxx_test.go:12    result=="1234"
                    ^
                    "123"

Besides, I think maybe we need to let user write AST plugins.

go.mod

module trace

go 1.21.7

require github.com/xhd2015/xgo/runtime v1.0.25

trace_test.go

package trace

import (
	"testing"

	_ "github.com/xhd2015/xgo/runtime/trace"
)

func TestTrace(t *testing.T) {
	A()
}

func A() string {
	return "A"
}

overlay.json

{
    "Replace": {
        "ROOT/trace/trace_test.go": "ROOT/tmp/trace_repalce_test.go"
    }
}

The replaced files content is identical to the original one.

run:

# trace normal
xgo test -v --strace ./

# trace empty
xgo test -v --strace --overlay overlay.json ./

A general solution to #48

Provides the user a chance to inspect specific package's content, and modify them on the fly.

A possible implementation:

• When xgo compiles a package, it finds possible matching plugins,
• These plugins are go code which accepts a compile context as input, and return a Result describing what effects will be applied to the following compiling process, for instance, inserting a code snippet into beginning of a specific file

Plugin signature:

package plugin_demo

import (
     "github.com/xhd2015/xgo/plugin"
)

func Handle(ctx *plugin.CompileContext) *plugin.Result {
    return nil
}

Primary considerations:

• Performance
  • the plugin should be an opt in feature, if there isn't any, then performance should be as same as before
  • if there is some, ensure only invoke them when targets match
• Security
  • We should if user do not deliberately use it, then the compiler should bypass it
• Reusability
  • Plugin can be written in another separate module, then imported by different projects.

When run xgo test --strace, auto start a server to list all generated traces.

Fail message:

fatal error: runtime: C malloc failed
_cgo_gotypes.go:202 ...
github.com/mattn/go-sqlite3._Cfunc_CString({0xc00004f130, 0x4a})
        _cgo_gotypes.go:202 +0x1d2 fp=0xc000e663d8 sp=0xc000e662c8 pc=0x101ac2a72
github.com/mattn/go-sqlite3.(*SQLiteDriver).Open(0xc0008eaf60, {0xc00004f130, 0x4a})
        /Users/xhd2015/Projects/gopath/pkg/mod/github.com/mattn/[email protected]/sqlite3.go:1456 +0x2a5e fp=0xc000e66920 sp=0xc000e663d8 pc=0x101af06be
database/sql.dsnConnector.Connect(...)
        /Users/xhd2015/.xgo/go-instrument/go1.21.7_Us_xh_in_go_096be049/go1.21.7/src/database/sql/sql.go:758

The line of code: name := C.CString(dsn).

After comparing xgo v1.0.26 with xgo v1.0.25, and do some bisect, found this is related to the new introduced --filepath:

fileValue := funcDecl.File   --> v1.0.26
fileValue := funcDecl.FileSyntax.Pos().RelFilename() --> v1.0.25

The actual fileValue for this package.

The stack trace shows that the file holding cgo types is _cgo_gotypes.go.

And by inserting a debug snippet into the go compiler:

relFile := f.Pos().RelFilename()
trimFile := TrimFilename(f.Pos().Base())
pkgPath := xgo_ctxt.GetPkgPath()
exec.Command("bash", "-c", fmt.Sprintf("echo 'pkg=%s relFile=%s trimFile=%s' >> /tmp/debug.log", pkgPath, relFile, trimFile)).Run()

The log shows:

pkg=github.com/mattn/go-sqlite3 relFile=/var/folders/y8/kmfy7f8s5bb5qfsp0z8h7j5m0000gq/T/go-build1192418818/b174/_cgo_gotypes.go trimFile=_cgo_gotypes.go

pkg=github.com/mattn/go-sqlite3 relFile=/var/folders/y8/kmfy7f8s5bb5qfsp0z8h7j5m0000gq/T/go-build1192418818/b174/_cgo_import.go trimFile=_cgo_import.go

Could be possibly introduced the difference between relFile and trimFile.
xgo v1.0.26: use trimFile
xgo v1.0.25: use relFile

It is critical to get the actual time, both time.Now and time.Since should call to the original function if possible.

Build a community

The github action supports these matrix smartly, we can utilize this.

func TestMethodMock(t *testing.T) {
	myStruct := &MyStruct{
		name: "my struct",
	}
	otherStruct := &MyStruct{
		name: "other struct",
	}
	mock.Mock(myStruct.name, func(ctx context.Context, fn *core.FuncInfo, args core.Object, results core.Object) error {
		results.GetFieldIndex(0).Set("mock struct")
		return nil
	})

	// myStruct is affected
	name := myStruct.Name()
	if name != "mock struct" {
		t.Fatalf("expect myStruct.Name() to be 'mock struct', actual: %s", name)
	}

	// otherStruct is not affected
	otherName := otherStruct.Name()
	if otherName != "other struct" {
		t.Fatalf("expect otherStruct.Name() to be 'other struct', actual: %s", otherName)
	}
}

command: xgo test -run TestMethodMock .\mock_tcp_conn\
error: create ~/.xgo/log: mkdir C:\Users\admin\.xgo\go-instrument\go1.20.5_C:_Us_ad_sc_ap_go_cu_90061880: The directory name is invalid.

maybe create windows dir/file could not include ":"

Is it possible to mock only method of a struct instance?

Currently init functions are skipped, that makes it impossible to inject mock and collect trace during the init stage.

However since init functions just run once and run serially, it has no performance impact at all. It might be useful.

This has positive impact on performance since only a small portion of the program will be intercepted

This specifically removes the blank import.

import _ "github.com/xhd2015/xgo/runtime/trace"

This can be achieved by packing the runtime with xgo itself.

Currently, if we want to visualize trace of each test ,we need to manually add a line:

func TestHelloWorld(t *testing.T){
    defer trace.Begin()()
    ...
}

But if we don't want trace, we need to manually remove that line, this causes some inconvenience.

So, propose adding a flag --trace flag, that will look like:

xgo test --trace -run TestHelloWorld

If --trace=off or not present, no trace will output.

Generic functions and methods are currently skipped because their generic definition is just a template, there is no function instrumentation emitted until concrete types have been decided.

But since we use source code rewritting instead of IR rewritting for stdlib functions(see #6), it should be easy to also use source code rewritting for intercepting generic method and functions.

Generic function example:

package mock_generic_func

import (
	"context"
	"net/http"
	"testing"

	"github.com/xhd2015/xgo/runtime/core"
	"github.com/xhd2015/xgo/runtime/mock"
)

func ToString[T any](v T) string {
    return fmt.Sprint(v)
}

func TestMockGenericFunc(t *testing.T) {
	mock.Mock(ToString[int], func(ctx context.Context, fn *core.FuncInfo, args, results core.Object) error {
		results.GetFieldIndex(0).Set("hello world")
		return nil
	})
        expect := "hello world"
        output := ToString(0)
	if expect != output {
		t.Fatalf("expect ToString[int](0) to be %s, actual: %s", expect, output)
	}
}

Generic method example:

package mock_generic_method

import (
	"context"
	"net/http"
	"testing"

	"github.com/xhd2015/xgo/runtime/core"
	"github.com/xhd2015/xgo/runtime/mock"
)

type Formatter[T any] struct {
    prefix T
}

func (c *Formatter[T]) Format(v T) string {
    return fmt.Sprintf("%v: %v", c.prefix, v)
}

func TestMockGenericMethod(t *testing.T) {
       formatter := &Formatter[int]{ prefix: 1 }
	mock.Mock(formatter.Format, func(ctx context.Context, fn *core.FuncInfo, args, results core.Object) error {
		results.GetFieldIndex(0).Set("hello world")
		return nil
	})
        expect := "hello world"
        output := formatter.Format(0)
	if expect != output {
		t.Fatalf("expect ToString[int](0) to be %s, actual: %s", expect, output)
	}
}

What about MockByName and MockMethodByName ? Still works, the name can still be referenced without any type parameter.

Are we going to support per-type parameter mock? Seems no, but we can provide type parameter infos to the user to decide the concrete type. Or, user can just type assert the receiver or arguments or results to check what actual type parameter is.

Some use case involve mocking time.Now,time.Sleep, etc.

For example: https://www.reddit.com/r/golang/s/VKGwG7SjlG

Currently IR rewritting is turned off for stdlib.
Should add support for these functions and may even allow user to specify what other functions they want to mock.

Never depend on the implementation directly. Abstract a layer between the implementation and the intent.

For example, when testing a service with external dependencies, we want to mock all of them.

But we should not directly mock their request or response, instead, we abstract a data structure called TestingContext.

This TestingContext is declared as a universal data fake storage:

type TestingContext struct {
    Users []*User
    Checkouts []*Checkout
    Config *Config
}

Then each dependency read data from this central data storage, and construct corresponding response based on the data.

And to reduce duplication of repeating declaring TestingContext, different tests can share a basic TestingContext, adding their custom overlay to the context.

Since gomonkey and mockery both aim to provide mock for go, each in different ways. And their method should be considered outdated as xgo has evovled.

Thus, I propose we find active projects(has commits in last 2 months) that are still using these two library, finding how their tests are written with the help of the 2 library, and try to create a PR to replace them with xgo, demonstrating that xgo is a better choice, even the choice of the state of art.

xgo version: v1.0.10
go version: go 1.21

code

package demo

import (
	"testing"
)

const condition = false

func TestClosuerWithIf(t *testing.T) {
	t.Logf("begin \n")
	if condition {
		defer func() {
				t.Logf("defer\n")
		}()
	}

	t.Logf("end\n")
}

error:

$ xgo test ./demo
sub.TestClosuerWithIf.func1·f: relocation target sub.TestClosuerWithIf.func1 not defined
FAIL   demo [build failed]

However, without the if condition, everything works fine.
With go1.22, the above code works fine.

Since we are helping open projects migrating from gomonkey to xgo, see #18.
We need to draft a migration document.

Do not require user to manually modify the code, the tool can automatically parse the code and rewrite gomonkey API calls to xgo

There are cases where some function are just not exported by a function, by we really want to bypass them.

The ability to mock should be not bound to visibility.

Example:

package provider

func DoSomething(...){
    ...
   doSomethingNetwork(...)
    ...
}

func doSomethingNetwork(...){
}

If we must rely on DoSomething but cannot change its code, then unless doSomethingNetwork can be mocked, otherwise we cannot write a test case that bypasses it.

The API would look like:

// package level function
func MockByName(pkg string, funcName string,interceptor func() error)) func()

// instance level emthod
// NOTE: instance must have method
func MockMethodByName(instance interface{}, method string, interceptor func() error) func()

Usage:

mock.MockByName("github.com/xhd2015/xgo/test", "doSomethingNetwork", func(ctx context.Context) error{
     // bypass the private function
     return nil
})

Specifically, the json.newTypeEncoder. When it returns unsupported function, we can just silently ignore that field.

Here is an example when trying to marshal a stack trace with cancelFunc unmarshalable:

error:json: error calling MarshalJSON for type *sorted_map.SortedMap: json: error calling MarshalJSON for type *sorted_map.SortedMap: json: error calling MarshalJSON for type *sorted_map.SortedMap: json: error calling MarshalJSON for type *sorted_map.SortedMap: json: error calling MarshalJSON for type trap.object: field _r1: json: unsupported type: context.CancelFunc

I download xgo by install.sh

curl -fsSL https://github.com/xhd2015/xgo/raw/master/install.sh | bash

And when I run:

xgo test -run TestMethodMock ./mock_tcp_conn

I got error:

fork/exec /Users/xhd2015/installed/go1.21.7/bin/go: no such file or directory

Maybe something wrong with build-release

Based on our practical experience, an out-of-box tool, even opinioned, will provide a newer thought on simplifying testing.

In this case, xgo, should be reinterpreted as eXtension to go.

The so-called IR rewriting sounds unfamiliar to people.What's it? How does it solve the problem that go-monkey suffers?How does it compare to other mock strategies?Can we dig further to employ this technique not only in mock, but also system tracing?

TLS is useful when context is not passing everywhere. And I don't want people to change their code to just add context just for passing goroutine local data

Currently the mock.Mock(fn,interceptor) API provides a general way to setup mock.

When testing a logic with many external dependencies, the mock setup ends with a lot of results.GetFieldIndex(0).Set(...) call, as below:

func TestMyLargeFunc(t *testing.T){
    mock.Mock(pkg1.F, func(ctx context.Context, fn *core.FuncInfo, args, results core.Object) error {
		return nil
    })
    mock.Mock(pkg2.F, func(ctx context.Context, fn *core.FuncInfo, args, results core.Object) error {
                results.GetFieldIndex(0).Set(&Model{...})
		return nil
    })
    mock.Mock(pkg3.F, func(ctx context.Context, fn *core.FuncInfo, args, results core.Object) error {
                results.GetFieldIndex(0).Set(&Model{...})
		return nil
    })
    ...
    MyLargeFunc()
    ...
}

Thus, we propose a new API based on generic:

// T should be a function
func Patch[T](fn T, replacer T) func()

The above test can be write as following with better type safety:

func TestMyLargeFunc(t *testing.T){
    mock.Patch(pkg1.F, func() error {
		return nil
    })
    mock.Patch(pkg2.F, func(ctx context.Context) (*Model,error){
                return &Model{...},nil
    })
    mock.Patch(pkg3.F, func(ctx context.Context) (*Model,error){
                return &Model{...},nil
    })
    ...
    MyLargeFunc()
    ...
}

As for go1.17 and below, the function can just be:

// fn should be a function
func Patch(fn interface{}, replacer interface{}) func()

It should be compatible with the generic version.

As for the mock by name version, also add corresponding PatchByName and PatchMethodByName, but no generic param can be specified. And it is the user's responsibility to ensure the function signature matches.

NOTE: this Patch is not always feasible if some type in the function signature are not exported. In these case, just use the Mock API as before.

fatal error: semacquire not on the G stack

runtime stack:
sync.runtime_SemacquireMutex(0x70000fd9ed90, 0x6b, 0x70000fd9edc8)
        /Users/xhd2015/.xgo/go-instrument/go1.17.5_Us_xh_in_go_8887a105/go1.17.5/src/runtime/sema.go:71 +0x25

The code that causes panic (https://github.com/xhd2015/xgo/blob/master/runtime/trap/trap.go):

func init() {
	__xgo_link_on_gonewproc(func(g uintptr) {
		if isByPassing() {
			return
		}
		local := getLocalInterceptorList()
		if local == nil || (len(local.head) == 0 && len(local.tail) == 0) {
			return
		}
		// inherit interceptors of last group
		localInterceptors.Store(g, &interceptorGroup{   <---- localInterceptors.mu.Lock() causes the panic
			groups: []*interceptorList{{
				list: local.copy(),
			}},
		})
	})
}

It is possible, and could be a major feature of xgo. Because package runtime/functab already have all registered func informations, so we can call them.

This could be a standalone usage apart from trap, mock and trace.

command: go run ./script/build-release --local

error: duplicate suffix

大佬，支持interface的mock吗

When running unit test, some packages are annoying.Though we are not going to use it while testing, it still stops testing.

Example: vendor/github.com/lucas-clemente/quic-go/internal/handshake/unsafe.go

func init() {
	if !structsEqual(&tls.ConnectionState{}, &qtls.ConnectionState{}) {
		panic("qtls.ConnectionState not compatible with tls.ConnectionState")
	}
	if !structsEqual(&tls.ClientSessionState{}, &qtls.ClientSessionState{}) {
		panic("qtls.ClientSessionState not compatible with tls.ClientSessionState")
	}
}

I want to rewrite it into

func init() {
        if true {
            return
        }
	if !structsEqual(&tls.ConnectionState{}, &qtls.ConnectionState{}) {
		panic("qtls.ConnectionState not compatible with tls.ConnectionState")
	}
	if !structsEqual(&tls.ClientSessionState{}, &qtls.ClientSessionState{}) {
		panic("qtls.ClientSessionState not compatible with tls.ClientSessionState")
	}
}

var lock sync.Mutex

func demo(){
     lock.Lock()
    defer lock.Unlock()
     ...
}

Will be transformed to:

var lock sync.Mutex

func demo(){
    __xgo_lock1 := lock
    __xgo_lock1.Lock()
    __xgo_lock2 := lock
     defer __xgo_lock2.Unlock()
     ...
}

Is obviously wrong.

Other types include: sync.Map.

Some function may modify it's input, and some may not. For these modifying the input, serializing the snapshot helps to improve the trace accuracy.
And it's better to support this smartly without the user needing to modify anything.

When the trace becomes large, it's hard to move around.

Given a test:

package debug

import (
	"testing"

	"github.com/xhd2015/xgo/runtime/mock"
)

func TestDebug(t *testing.T) {
	mock.Patch(greet, func(s string) string {
		return "mock " + s
	})
	greet("world")
}

func greet(s string) string {
	return "hello " + s
}

When debugging with delve, we set a breakpoint at the line the calls mock.Patch, then click step into, we will enter a file named __xgo_autogen_register_func_helper.go

The call stack looks like:

[debug.__xgo_link_generated_init_regs_body] debug_test.go    <--- stack top
[debug.init.0]  __xgo_autogen_register_func_helper.go
[runtime.doInit1] proc.go
[runtime.doInit] proc.go
[runtime.main] proc.go
[runtime.goexit] asm_amd64.s

After stepping into, the call stack looks like:

[debug.__xgo_local_register_func]   __xgo_autogen_register_func_helper.go  <--- stack top
[debug.__xgo_link_generated_init_regs_body] debug_test.go
[debug.init.0]  __xgo_autogen_register_func_helper.go
[runtime.doInit1] proc.go
[runtime.doInit] proc.go
[runtime.main] proc.go
[runtime.goexit] asm_amd64.s

And an error prompted by vscode saying:The editor could not be opened because the file was not found

The file path shows runtime/test/__xgo_autogen_register_func_helper.go.

Demo:

Continuing the work yet to be finished 0171046

It would add support for older go versions which may cover some old projects.

This is my command:

xgo test -v -run TestTodoController_Suite --strace ./interfaces/controllers

And this is my output:
Notice the warnings at the top....

go: -replace=../MHGoLib=/Users/marcelloh/data/Go/go-private/SBC/MHGoLib: invalid old path: malformed import path "../MHGoLib": invalid path element ".."
WARNING: --strace requires: import _ "github.com/xhd2015/xgo/runtime/trace"
   failed to auto import github.com/xhd2015/xgo/runtime/trace: exit status 1
=== RUN   TestTodoController_Suite
=== RUN   TestTodoController_Suite/Test_TodoController_EditRecord_Error_ID
=== RUN   TestTodoController_Suite/Test_TodoController_EditRecord_Good
=== RUN   TestTodoController_Suite/Test_TodoController_EditRecord_Wrong
=== RUN   TestTodoController_Suite/Test_TodoController_GetMoreRecords
=== RUN   TestTodoController_Suite/Test_TodoController_GetMoreRecordsJSON
=== RUN   TestTodoController_Suite/Test_TodoController_GetMoreRecordsJSON_Error
=== RUN   TestTodoController_Suite/Test_TodoController_GetOneRecord
=== RUN   TestTodoController_Suite/Test_TodoController_GetOneRecordJSON_Error_ID
=== RUN   TestTodoController_Suite/Test_TodoController_GetOneRecordJSON_Error_Wrong
=== RUN   TestTodoController_Suite/Test_TodoController_GetOneRecordJSON_Good
=== RUN   TestTodoController_Suite/Test_TodoController_GetOneRecord_Error_ID
=== RUN   TestTodoController_Suite/Test_TodoController_GetOneRecord_Error_Wrong
=== RUN   TestTodoController_Suite/Test_TodoController_SaveRecord_Error_ID
=== RUN   TestTodoController_Suite/Test_TodoController_SaveRecord_Good
=== RUN   TestTodoController_Suite/Test_TodoController_SaveRecord_Wrong
=== RUN   TestTodoController_Suite/Test_TodoController_SaveRecord_WrongValidation
--- PASS: TestTodoController_Suite (0.03s)
    --- PASS: TestTodoController_Suite/Test_TodoController_EditRecord_Error_ID (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_EditRecord_Good (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_EditRecord_Wrong (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetMoreRecords (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetMoreRecordsJSON (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetMoreRecordsJSON_Error (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetOneRecord (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetOneRecordJSON_Error_ID (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetOneRecordJSON_Error_Wrong (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetOneRecordJSON_Good (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetOneRecord_Error_ID (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_GetOneRecord_Error_Wrong (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_SaveRecord_Error_ID (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_SaveRecord_Good (0.01s)
    --- PASS: TestTodoController_Suite/Test_TodoController_SaveRecord_Wrong (0.00s)
    --- PASS: TestTodoController_Suite/Test_TodoController_SaveRecord_WrongValidation (0.00s)
PASS
ok      dev.local/marcelloh/SBC/interfaces/controllers    0.520s

Add a playground to run examples lively, and show traces by running some tests.

That may probably introduce a domain for xgo itself.

1. add windows install powershell like install.ps1
2. build from source with windows met two errors:
   1. without "--local" options, goterror: sum sha256: exec: "shasum": executable file not found in %PATH%
   2. with "--local" options, got error: GOOS=windows GOARCH=amd64:rename C:\Users\admin\AppData\Local\Temp\xgo-release3949503335\xgo C:\Users\admin\.xgo\bin\xgo: The system cannot find the path specified.

Additionally, build from source binary with windows without ".exe" suffix