Define method of struct inside function

I have this code

func baz() {
    type mockDatabase struct{}
    
    //
    //  More code
    //
}

I want to define a method of mockDatabase, so the full code would look like this:

func baz() {
    type mockDatabase struct{}
    
    func (m *mockDatabase) Foo() {
        // Implement function here
    }
    
    //
    //  More code
    //
}

The reason I want to do this is I'm injecting a dependency into a function, and I want to create a "mock object" to inject into the function (the function takes an interface as an argument and the mock object will implement the interface).

I could create the struct outside, but it seems more logical to declare the struct locally to decrease namespace clutter, especially when these mock objects will only be used once. Am I missing something here? Is it better practice to define it outside the test function so it's not long? What should I do here?

The idiomatic Go would be to use package for namespacing.

package mock 
type MockDatabase struct {}
func (m *mockDatabase) Foo() {}

In the main code, you can call from the package

package main
import (
        "path/to/mock"
)
var m = New(mock.MockDatabase)
func baz() {
        m.Foo()
}

Directly - no. And honestly, I think that pie-o-pah answered your question. But. If you still want to do it your way for some reason, you can do it with a little bit of boilerplate wrapping and clever use of closures:

type I interface {
	Foo()
}
type ExtendableI struct {
	foo func()
}
func (i ExtendableI) Foo() {
	i.foo()
}
func main() {
	type MyI int
	myI := MyI(42)
	foo := func() {
		fmt.Println(myI) // Close over myI making it work like a method.
	}
	ei := ExtendableI{foo: foo}
	useI(ei) // useI needs an I.
}

Playground: http://play.golang.org/p/G2HKhjb5fk.