Can I make a type assertion work with a typedef?

I have a custom type that allows me to work with an API more conveniently:

type Object map[string]interface{}

And this thing doesn't work:

var mockResponse = map[string]interface{}{"success": true}
resp, ok := mockResponse.(Object)
// ok = false

Can I do anything so mockResponse.(Object)'s ok is true? It's basically the same type...

First of all, your "pseudo code" is a compile time error. You can't use type assertion on a value with concrete type (there's no point, a concrete type is a concrete type and nothing else), you may only use it on an interface value.

The example should be:

var mockResponse interface{} = map[string]interface{}{"success": true}
resp, ok := mockResponse.(Object)

Note that if mockResponse would be of type map[string]interface{}, then no type assertion would be needed, you could simply convert it to Object like this:

var mockResponse = map[string]interface{}{"success": true}
obj := Object(mockResponse)

The type definition creates a new, distinct type. And the type assertion to a concrete type only holds if you use the same concrete type.

What you may do is write a helper function which extracts Object from an interface value, which may handle both map[string]interface{} and also if the concrete type is Object:

func getObj(x interface{}) (o Object, ok bool) {
	switch v := x.(type) {
	case Object:
		return v, true
	case map[string]interface{}:
		return Object(v), true
	}
	return nil, false
}

Testing it:

resp, ok := getObj(map[string]interface{}{"success": true})
fmt.Println(resp, ok)

resp, ok = getObj(Object{"success": true})
fmt.Println(resp, ok)

resp, ok = getObj("invalid")
fmt.Println(resp, ok)

Output (try it on the Go Playground):

map[success:true] true
map[success:true] true
map[] false

Note: the above getObj() does not handle all possible cases where an Object could be "acquired" from the interface value.

For example if we'd have a type definition like this:

type Object2 Object

Passing a value of Object2 to getObj(), an Object would not be extracted from it, even though a value of type Object2 could be converted to Object:

resp, ok = getObj(Object2{"success": true})
fmt.Println(resp, ok) // map[] false

If you want to handle all possible cases where the concrete value is convertible to Object, you may use reflection:

var objType = reflect.TypeOf(Object{})

func getObj(x interface{}) (o Object, ok bool) {
	if v := reflect.ValueOf(x); v.Type().ConvertibleTo(objType) {
		o, ok = v.Convert(objType).Interface().(Object)
		return
	}
	return nil, false
}

Testing it (try this one on the Go Playground):

resp, ok = getObj(Object2{"success": true})
fmt.Println(resp, ok) // map[success:true] true

Using reflection is slower than a simple type assertion or type switch, so you can mix the 2 solutions:

func getObj(x interface{}) (o Object, ok bool) {
	// First try the trivial cases:
	switch v := x.(type) {
	case Object:
		return v, true
	case map[string]interface{}:
		return Object(v), true
	}

	// Then revert to reflection:
	if v := reflect.ValueOf(x); v.Type().ConvertibleTo(objType) {
		o, ok = v.Convert(objType).Interface().(Object)
		return
	}
	return nil, false
}