Issue with Matcher I do not understand (AssignableTo returns unexpected false)

[berupp]

I am building a REST endpoint using gorilla/mux. I am passing an object into my http.Handlerfunc
which will get enriched with the request's context when the endpoint is called.

Now the code sample at the bottom reproduces the issue. I also added a Println to matcher.go:

func (matcher *AnyMatcher) Matches(param Param) bool {
        matcher.actual = reflect.TypeOf(param)
        if matcher.actual == nil {
                switch matcher.Type.Kind() {
                case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map,
                        reflect.Ptr, reflect.Slice, reflect.UnsafePointer:
                        return true
                default:
                        return false
                }
        }
        fmt.Printf("Matcher Type: %v - Param Type: %v -> matches %v\n", matcher.Type, matcher.actual, matcher.actual.AssignableTo(matcher.Type) )
        return matcher.actual.AssignableTo(matcher.Type)
}

The output, when I run the sample code below, is as follows:

Matcher Type: *context.valueCtx - Param Type: *context.valueCtx -> matches false
Shouldn't be nil <nil>

What I do not understand is: The types are the same, but AssignableTo returns false. I guess I am making a wrong assumption about reflect.TypeOf because my understanding is: If I reflect.TypeOf and object, the type should be completely independent from the content of the object. So why would the code fail? I am clueless.

The sample code:

package main
import(
	"github.com/petergtz/pegomock"
	"golang.org/x/net/context"
	"net/http"
	"fmt"
	"reflect"
	"net/http/httptest"
	"github.com/gorilla/mux"
)

func main() {
        //Create mock
	mockClient := NewMockSomeClient()
        //Return mock when Withontext is called with any context (`mux` creates a *context.valueCtx so does the Matcher)
	pegomock.When(mockClient.WithContext(AnyContext())).ThenReturn(mockClient)
	responseRecorder := httptest.NewRecorder()
	request, _ := http.NewRequest("GET", "/path/to/success", nil)

	r := mux.NewRouter()
	r.HandleFunc("/path/to/success", NewEndpoint(mockClient))
	r.ServeHTTP(responseRecorder, request)

}
func AnyContext() context.Context {
	ctx := context.WithValue(context.Background(), "", "")
	pegomock.RegisterMatcher(pegomock.NewAnyMatcher(reflect.TypeOf(ctx)))
	return ctx
}

func NewEndpoint(client SomeClient) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request){
		clientWithContext := client.WithContext(r.Context())
		fmt.Printf("Shouldn't be nil %v", clientWithContext)
	}
}
//Interface to mock
type SomeClient interface {
	WithContext(context.Context) SomeClient
}

//MOCK - Generated but package adjusted, so it can be in the same file
type MockSomeClient struct {
	fail func(message string, callerSkip ...int)
}

func NewMockSomeClient() *MockSomeClient {
	return &MockSomeClient{fail: pegomock.GlobalFailHandler}
}

func (mock *MockSomeClient) WithContext(_param0 context.Context) SomeClient {
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("WithContext", params, []reflect.Type{reflect.TypeOf((*SomeClient)(nil)).Elem()})
	var ret0 SomeClient
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(SomeClient)
		}
	}
	return ret0
}

func (mock *MockSomeClient) VerifyWasCalledOnce() *VerifierSomeClient {
	return &VerifierSomeClient{mock, pegomock.Times(1), nil}
}

func (mock *MockSomeClient) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierSomeClient {
	return &VerifierSomeClient{mock, invocationCountMatcher, nil}
}

func (mock *MockSomeClient) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierSomeClient {
	return &VerifierSomeClient{mock, invocationCountMatcher, inOrderContext}
}

type VerifierSomeClient struct {
	mock                   *MockSomeClient
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
}

func (verifier *VerifierSomeClient) WithContext(_param0 context.Context) *SomeClient_WithContext_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "WithContext", params)
	return &SomeClient_WithContext_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type SomeClient_WithContext_OngoingVerification struct {
	mock              *MockSomeClient
	methodInvocations []pegomock.MethodInvocation
}

func (c *SomeClient_WithContext_OngoingVerification) GetCapturedArguments() context.Context {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *SomeClient_WithContext_OngoingVerification) GetAllCapturedArguments() (_param0 []context.Context) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]context.Context, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(context.Context)
		}
	}
	return
}

[petergtz]

Interesting. I just tried to reproduce this and couldn't. I copied your code verbatim (btw thanks, this made it trivial to reproduce!) and got this:

$ go run main.go 
Matcher Type: *context.valueCtx - Param Type: *context.valueCtx -> matches true
Shouldn't be nil &{<nil>}

To make that last line more readable, I changed it to use https://github.com/davecgh/go-spew:

func NewEndpoint(client SomeClient) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		clientWithContext := client.WithContext(r.Context())
		spew.Dump(clientWithContext)
	}
}

That gives me:

$ go run main.go 
Matcher Type: *context.valueCtx - Param Type: *context.valueCtx -> matches true
(*main.MockSomeClient)(0xc42009c040)({
 fail: (func(string, ...int)) <nil>
})

I'm using

$ go version
go version go1.7.3 linux/amd64

Is it possible that you're using a different go version?

[berupp]

Hi Peter
Thanks for answering so quickly.
I am puzzled. I ran the original tests on OS/X so, now I tried it on a linux VM but I am getting the same failure result.

-bash-4.2$ go run main.go
O: *context.valueCtx, P: *context.valueCtx - match false
(interface {}) <nil>
-bash-4.2$ go version
go version go1.7.3 linux/amd64
-bash-4.2$

I'm asking my coworkers to run it on their machines.

[berupp]

Okay so my coworkers ran it and get the same result as you. I set up go on my Windows machine and I also get the expected, correct result.

So something really odd seems to be going on with my Mac...anyway, closing.

Thanks for your help