Should I always define structure properties as interface for testability?

As far as I understand the only way to mock structure dependencies in Go is to use interfaces. So my question is: In cases when my struct has methods which perform some actions (when structure is not just a model storing data), should I always define the properties as interfaces in order to properly mock & test it?

Simple example:

type UserService struct {
    userRepository UserRepository
}

func (us *UserService) MaleUsers() []User {
	all := us.userRepository.FindAll()
	maleUsers := []User{}
	for _, u := range all {
		if u.gender == "male" {
			maleUsers = append(maleUsers, u)
		}
	}
	return maleUsers
}

Imagine we have user service which has a dependency: repository.
Service has method which gets all users and then filters them by some criteria.
By the way filtering logic could go in a separate dependency to avoid filtering in service method (SRP).

Btw. I came from Java world. If this approach of structuring applications is not ideomatic in Go please let me know.

In order to mock the userRepository dependency of your UserService, you are correct in thinking the best approach would be to use an interface.

Firstly, create your interface:

type UserRepository interface {
	FindAll() []Users
}

Then build a mock:

type MockUserRepository struct{}

func (mock MockUserRepository) FindAll() []Users {
	// here you would manually build a slice of users and return it
	return []Users
}

Finally, use this mock as as a dependency in your test case:

func TestMaleUsers(t *testing.T) {
	// compose service using mock
	service := UserService {
		userRepository: MockUserRepository,
	}
	
	// get output of method call
	users := service.MaleUsers()
	
	// perform assertions on output
}

This way you have created a mock of your interface which can be used in your tests without having to perform any database calls on your repository.

I guess, it is reasonable to use interfaces if you want to properly perform a unit testing, as you stated in your question. More than that, in some other languages like Java or C#, it is a natural way of doing so. However, you can also easily test the code of your package without any changes if it doesn't have external dependencies.

Besides, I would highly recommend you to use interfaces as much as possible, in that way you would achieve higher cohesion and less coupling, which would make your code more maintainable and testable.

In Go, an entity could satisfy an interface implicitly, so all you need to have an ability to mock your structure in future is to add an interface declaration. Check out some examples:

type MaleIterable interface {
    MaleUsers() []User
}

type UserIterable interface {
    FindAll() []User
}

Here is a code snippet, which could also be useful for you.

package main

import "fmt"

type User struct {
    Name string
    Gender string
    Age int
}

type UserIterable interface {
    FindAll() []User
}

type FakeUserRepository struct {}

func (ur FakeUserRepository) FindAll() []User {
    return []User{
        User{Name:"Alex", Gender:"male", Age:19},
        User{Name:"Max", Gender:"male", Age:34},
        User{Name:"Maria", Gender:"female", Age:12},
    }
}

type UserService struct {
    userRepository UserIterable
}

func (us *UserService) MaleUsers() []User {
    all := us.userRepository.FindAll()
    maleUsers := []User{}
    for _, u := range all {
        if u.Gender == "male" {
            maleUsers = append(maleUsers, u)
        }
    }
    return maleUsers
}

func main() {
    us := UserService{
        userRepository: FakeUserRepository{},
    }
    males := us.MaleUsers()
    fmt.Println(males)
}