Golang test mock functions best practices

I am developing some tests for my code (using the testing package), and I am wondering what's the best way to mock functions inside the tested function:

Should I pass the function as parameter?
In that case, what if that function calls another function? Should I pass both the first and second function as parameters in the tested one?

Note: some of the functions are called on objects (i.e. someObj.Create()) and use HTTP API calls.

UPDATE for clarification:

Example: functions

func f1() error {
  ... //some API call
}

func (s *SomeStruct) f2() error {
  return f1
}

func f3() error {
  return nil
}

func f4() error {
  ...
  err = obj.f2()
  ...
  err = f3()
  ...
}

For the above: if I want to test f4, what's the best way to mock f2 and f3?

If I pass f2 and f3 to f4 as parameters it would work, but then what for the f2 test? Should I pass f1 to f2 as parameter?

And if that's it, should then f4 have f1 as well in the parameters?

As a general guideline, functions aren't very mockable so its in our best interests to mock structs that implement a certain interface that may be passed into functions to test the different branches of code. See below for a basic example.

package a

type DoSomethingInterface interface {
	DoSomething() error
}


func DoSomething(a DoSomethingInterface) {
	if err := a.DoSomething(); err != nil {
		fmt.Println("error occurred")
		return
	}
	fmt.Println("no error occurred")
    return
}

package a_test

import (
	"testing"
	"<path to a>/a"
)

type simpleMock struct {
	err error
}

func (m *simpleMock) DoSomething() error {
	return m.err
}

func TestDoSomething(t *testing.T) {
	errorMock := &simpleMock{errors.New("some error")}
	a.DoSomething(errorMock)
	// test that "an error occurred" is logged

	regularMock := &simpleMock{}
	a.DoSomething(regularMock)
	// test "no error occurred" is logged
}

In the above example, you would test the DoSomething function and the branches that happens eg. you would create an instance of the mock with an error for one test case and create another instance of the mock without the error to test the other case. The respective cases are to test a certain string has been logged to standard out; in this case it would be "error occurred" when simpleMock is instantiated with an error and "no error occurred" when there simpleMock is not instantiated with an error.

This can of course be expanded to other cases eg. the DoSomething function actually returns some kind of value and you want to make an assertion on the value.

Edit:

I updated the code with the concern that the interface lives in another package. Note that the new updated code has a package a that contains the interface and the function under test and a package a_test that is merely a template of how to approach testing a.DoSomething.

I'm not sure what you're trying to do here but I'll explain how testing should be done in Go.

Lets say we have an application with the following directory hierarchy:

root/
  pack1/
    pack1.go
    pack1_test.go
  pack2/
    pack2.go
    pack2_test.go
  main.go
  main_test.go

We'll assume that pack2.go has the functions you want to test:

package pack2 

func f1() error {
  ... //some API call
}

func (s *SomeStruct) f2() error {
  return f1
}

func f3() error {
  return nil
}

func f4() error {
  ...
  err = obj.f2()
  ...
  err = f3()
  ...
}

Looks good so far. Now if you want to test the functions in pack2, you would create a file called pack2_test.go. All test files in go are named similarly (packagename_test.go). Now lets see the inside of a typical test for a package (pack2_test.go in this example):

package pack2

import (
  "testing"
  "fmt"
)

TestF1(*testing.T) {
  x := "something for testing"
  f1() // This tests f1 from the package "pact2.go"
}


TestF2(*testing.T) {
    y := new(somestruct) 
    y.f2() // tests f2 from package "pact2.go"
}


TestF3(*testing.T) {
   /// some code
   f3() // tests f3
}


TestF4(*testing.T) {
    /// code
    f3() // you get the gist
}

Let me explain. Notice how in pack2_test.go, the first line says that the package is pack2. In a nutshell, this means that we're in the "scope" of the package pack2 and thus all the functions found in pack2 can be called as if you're within pack2. Thats why, within the Testf* functions, we could've called the functions from pack2. Another thing to note is the imported package "testing". This helps with two things:

First, it provides some functionality for running tests. I won't go into that.
Second, it helps identify the functions that go test should run.

Now to the functions. Any function within a test package that has the prefix "Test" and the parameters "t *testing.T" (you can use "*testing.T" when you don't need to use the testing functionality) will be executed when you run go test. You use the variable t to reference the testing functionality I mentioned. You can also declare functions without the prefix and call them within the prefixed functions.

So, if I go to my terminal and run go test, it will execute the functions you want to test, specified in pack2_test.go

You can learn more about testing here and here