How to mock a middleware that makes external call in Golang test?

TLDR: There is a go-chi middleware that is making an external call to authorise the request. I need to mock what it does.

Details:

I have this test:

func Test_HTTP_UserSet_Create_InvalidAction(t *testing.T) {
	requestBody :=
		`{
			"name": "test",
			"action": "TEST"
		}`

	req, _ := http.NewRequest("POST", "/1234/users", bytes.NewBuffer([]byte(requestBody)))

	recorder := setupInvalidActionRecorder(t, req)

	if status := recorder.Code; status != http.StatusBadRequest {
		t.Errorf("Status code expected to be %d but got %d", http.StatusBadRequest, status)
		return
	}
}

The above setupUnknownErrorRecorder is:

func setupUnknownErrorRecorder(t *testing.T, request *http.Request) *httptest.ResponseRecorder {
	recorder := httptest.NewRecorder()

	c := resty.New()

	resource := users.NewResource(
		httpClient.NewHttpClient(log, &config.Server{}, &logger.LogRecord{}, c),
	)

	resource.Routes().ServeHTTP(recorder, request)

	return recorder
}

The result I'm getting is:

=== RUN   Test_HTTP_UserSet_Create_InvalidAction
    invalidAction_test.go:71: Status code expected to be 400 but got 401
--- FAIL: Test_HTTP_UserSet_Create_InvalidAction (0.00s)

This result is expected since the server is making an external call using the client c that I'm passing to NewResource.

There is a go-chi middleware that is using this client to make the external call.

My question is: how can I make this http call always return 200 without to really make the call. Aka how to mock this call?

Edit:
The interface of the httpClient above is:

type HttpClient struct {
	logger          *logger.Logger
	config          *config.Server
	instrumentation *instrumentation
	record          *logger.LogRecord
	restyClient     *resty.Client
}

func NewHttpClient(
	logger *logger.Logger,
	config *config.Server,
	record *logger.LogRecord,
	restyClient *resty.Client,
) HttpClient {
	return HttpClient{
		instrumentation: newInstrumentation(logger, record),
		config:          config,
		logger:          logger,
		record:          record,
		restyClient:     restyClient,
	}
}

A very basic rule of a testable code says that you cannot just create new services inside your other services. You need to inject it, and prepare an interface if there is none already for the whatever is resty.New returning. That way you can inject your mock in the tests.

Then you can use for example https://pkg.go.dev/github.com/stretchr/testify/mock for generating mocks and saying what should be the returned value by your mocked service.

Update after comment:

type HttpClient struct {
    logger          *logger.Logger
    config          *config.Server
    instrumentation *instrumentation
    record          *logger.LogRecord
    restyClient     *resty.Client // <- this is the thing you want to change from a pointer to resty.Client to an interface
}

Check which methods of the restyClient are you using in the code and create your new interface containing them like:

type MyRestyClient interface {
   FirstUsedMethod(..)
   
   ...
}

and exchange the restyClient declaration to

type HttpClient struct {
    ...
    restyClient     MyRestyClient

after that you can use mockery from the link I pasted before with a command to generate a mock for you.

Later, you just setup the mock in the tests:

restyMock := new(RestyMock)
restyMock.On("MethodYouExpect").Return(returnValueOfYourChoice)

and you inject so prepared mock into your service under tests.