How to generate a mock an interface from an external package if it uses something from its internal directory?

[4k1k0]

I'm trying to generate a mock for an interface that uses something from an internal package but I get this error: use of internal package github.com/jackc/pgx/v4/internal/sanitize not allowed.

This error is present when I'm trying to use mockery using Golang 1.22.3 but using 1.19.3 works fine.

Go	Mockery	Package	Error
1.19.3	2.40.1	4.15.0	None
1.22.3	2.40.1	4.15.0	use of internal package github.com/jackc/pgx/v4/internal/sanitize not allowed

My specs:

OS: MacOS Sonoma 14.6.1
Arch: Go darwin/arm64

My mockery file contains:

quiet: False
keeptree: False
dir: "mocks"
disable-version-string: True
with-expecter: True
mockname: "{{.InterfaceName}}"
filename: "{{.MockName}}.go"
outpkg: mocks
packages:
  yako/vendor/github.com/jackc/pgx/v4:
    interfaces:
      Rows:

Mockery output:

27 Aug 24 18:27 CST INF Starting mockery dry-run=false version=v2.40.1
27 Aug 24 18:27 CST INF Using config: /Users/wako/Documents/code/go/src/yako/.mockery.yaml dry-run=false version=v2.40.1
27 Aug 24 18:27 CST ERR encountered error when loading package error="vendor/github.com/jackc/pgx/v4/conn.go:15:2: use of internal package github.com/jackc/pgx/v4/internal/sanitize not allowed" dry-run=false version=v2.40.1
27 Aug 24 18:27 CST ERR encountered error when loading package error="-: This application uses version go1.21 of the source-processing packages but runs version go1.22 of 'go list'. It may fail to process source files that rely on newer language features. If so, rebuild the application using a newer version of Go." dry-run=false version=v2.40.1
27 Aug 24 18:27 CST ERR unable to parse packages error="error occurred when loading packages" dry-run=false version=v2.40.1
error occurred when loading packages

The content from vendor/github.com/jackc/pgx/v4/conn.go:15:2 is:

package pgx

import (
	"context"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/jackc/pgconn"
	"github.com/jackc/pgconn/stmtcache"
	"github.com/jackc/pgproto3/v2"
	"github.com/jackc/pgtype"
	"github.com/jackc/pgx/v4/internal/sanitize"
)

func (c *Conn) sanitizeForSimpleQuery(sql string, args ...interface{}) (string, error) {
...
...
...
	return sanitize.SanitizeSQL(sql, valueArgs...)
}

Go 1.19.3 and Mockery 2.40.1 generate the following file:

// Code generated by mockery. DO NOT EDIT.

package mocks

import (
	pgconn "github.com/jackc/pgconn"
	mock "github.com/stretchr/testify/mock"

	pgproto3 "github.com/jackc/pgproto3/v2"
)

// Rows is an autogenerated mock type for the Rows type
type Rows struct {
	mock.Mock
}

type Rows_Expecter struct {
	mock *mock.Mock
}

func (_m *Rows) EXPECT() *Rows_Expecter {
	return &Rows_Expecter{mock: &_m.Mock}
}

// Close provides a mock function with given fields:
func (_m *Rows) Close() {
	_m.Called()
}

// Rows_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
type Rows_Close_Call struct {
	*mock.Call
}

// Close is a helper method to define mock.On call
func (_e *Rows_Expecter) Close() *Rows_Close_Call {
	return &Rows_Close_Call{Call: _e.mock.On("Close")}
}

func (_c *Rows_Close_Call) Run(run func()) *Rows_Close_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Rows_Close_Call) Return() *Rows_Close_Call {
	_c.Call.Return()
	return _c
}

func (_c *Rows_Close_Call) RunAndReturn(run func()) *Rows_Close_Call {
	_c.Call.Return(run)
	return _c
}

// CommandTag provides a mock function with given fields:
func (_m *Rows) CommandTag() pgconn.CommandTag {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for CommandTag")
	}

	var r0 pgconn.CommandTag
	if rf, ok := ret.Get(0).(func() pgconn.CommandTag); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(pgconn.CommandTag)
		}
	}

	return r0
}

// Rows_CommandTag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommandTag'
type Rows_CommandTag_Call struct {
	*mock.Call
}

// CommandTag is a helper method to define mock.On call
func (_e *Rows_Expecter) CommandTag() *Rows_CommandTag_Call {
	return &Rows_CommandTag_Call{Call: _e.mock.On("CommandTag")}
}

func (_c *Rows_CommandTag_Call) Run(run func()) *Rows_CommandTag_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Rows_CommandTag_Call) Return(_a0 pgconn.CommandTag) *Rows_CommandTag_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Rows_CommandTag_Call) RunAndReturn(run func() pgconn.CommandTag) *Rows_CommandTag_Call {
	_c.Call.Return(run)
	return _c
}

// Err provides a mock function with given fields:
func (_m *Rows) Err() error {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Err")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// Rows_Err_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Err'
type Rows_Err_Call struct {
	*mock.Call
}

// Err is a helper method to define mock.On call
func (_e *Rows_Expecter) Err() *Rows_Err_Call {
	return &Rows_Err_Call{Call: _e.mock.On("Err")}
}

func (_c *Rows_Err_Call) Run(run func()) *Rows_Err_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Rows_Err_Call) Return(_a0 error) *Rows_Err_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Rows_Err_Call) RunAndReturn(run func() error) *Rows_Err_Call {
	_c.Call.Return(run)
	return _c
}

// FieldDescriptions provides a mock function with given fields:
func (_m *Rows) FieldDescriptions() []pgproto3.FieldDescription {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for FieldDescriptions")
	}

	var r0 []pgproto3.FieldDescription
	if rf, ok := ret.Get(0).(func() []pgproto3.FieldDescription); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]pgproto3.FieldDescription)
		}
	}

	return r0
}

// Rows_FieldDescriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FieldDescriptions'
type Rows_FieldDescriptions_Call struct {
	*mock.Call
}

// FieldDescriptions is a helper method to define mock.On call
func (_e *Rows_Expecter) FieldDescriptions() *Rows_FieldDescriptions_Call {
	return &Rows_FieldDescriptions_Call{Call: _e.mock.On("FieldDescriptions")}
}

func (_c *Rows_FieldDescriptions_Call) Run(run func()) *Rows_FieldDescriptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Rows_FieldDescriptions_Call) Return(_a0 []pgproto3.FieldDescription) *Rows_FieldDescriptions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Rows_FieldDescriptions_Call) RunAndReturn(run func() []pgproto3.FieldDescription) *Rows_FieldDescriptions_Call {
	_c.Call.Return(run)
	return _c
}

// Next provides a mock function with given fields:
func (_m *Rows) Next() bool {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Next")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// Rows_Next_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Next'
type Rows_Next_Call struct {
	*mock.Call
}

// Next is a helper method to define mock.On call
func (_e *Rows_Expecter) Next() *Rows_Next_Call {
	return &Rows_Next_Call{Call: _e.mock.On("Next")}
}

func (_c *Rows_Next_Call) Run(run func()) *Rows_Next_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Rows_Next_Call) Return(_a0 bool) *Rows_Next_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Rows_Next_Call) RunAndReturn(run func() bool) *Rows_Next_Call {
	_c.Call.Return(run)
	return _c
}

// RawValues provides a mock function with given fields:
func (_m *Rows) RawValues() [][]byte {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for RawValues")
	}

	var r0 [][]byte
	if rf, ok := ret.Get(0).(func() [][]byte); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([][]byte)
		}
	}

	return r0
}

// Rows_RawValues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RawValues'
type Rows_RawValues_Call struct {
	*mock.Call
}

// RawValues is a helper method to define mock.On call
func (_e *Rows_Expecter) RawValues() *Rows_RawValues_Call {
	return &Rows_RawValues_Call{Call: _e.mock.On("RawValues")}
}

func (_c *Rows_RawValues_Call) Run(run func()) *Rows_RawValues_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Rows_RawValues_Call) Return(_a0 [][]byte) *Rows_RawValues_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Rows_RawValues_Call) RunAndReturn(run func() [][]byte) *Rows_RawValues_Call {
	_c.Call.Return(run)
	return _c
}

// Scan provides a mock function with given fields: dest
func (_m *Rows) Scan(dest ...interface{}) error {
	var _ca []interface{}
	_ca = append(_ca, dest...)
	ret := _m.Called(_ca...)

	if len(ret) == 0 {
		panic("no return value specified for Scan")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(...interface{}) error); ok {
		r0 = rf(dest...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// Rows_Scan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Scan'
type Rows_Scan_Call struct {
	*mock.Call
}

// Scan is a helper method to define mock.On call
//   - dest ...interface{}
func (_e *Rows_Expecter) Scan(dest ...interface{}) *Rows_Scan_Call {
	return &Rows_Scan_Call{Call: _e.mock.On("Scan",
		append([]interface{}{}, dest...)...)}
}

func (_c *Rows_Scan_Call) Run(run func(dest ...interface{})) *Rows_Scan_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]interface{}, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		run(variadicArgs...)
	})
	return _c
}

func (_c *Rows_Scan_Call) Return(_a0 error) *Rows_Scan_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Rows_Scan_Call) RunAndReturn(run func(...interface{}) error) *Rows_Scan_Call {
	_c.Call.Return(run)
	return _c
}

// Values provides a mock function with given fields:
func (_m *Rows) Values() ([]interface{}, error) {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Values")
	}

	var r0 []interface{}
	var r1 error
	if rf, ok := ret.Get(0).(func() ([]interface{}, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() []interface{}); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]interface{})
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Rows_Values_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Values'
type Rows_Values_Call struct {
	*mock.Call
}

// Values is a helper method to define mock.On call
func (_e *Rows_Expecter) Values() *Rows_Values_Call {
	return &Rows_Values_Call{Call: _e.mock.On("Values")}
}

func (_c *Rows_Values_Call) Run(run func()) *Rows_Values_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *Rows_Values_Call) Return(_a0 []interface{}, _a1 error) *Rows_Values_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Rows_Values_Call) RunAndReturn(run func() ([]interface{}, error)) *Rows_Values_Call {
	_c.Call.Return(run)
	return _c
}

// NewRows creates a new instance of Rows. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewRows(t interface {
	mock.TestingT
	Cleanup(func())
}) *Rows {
	mock := &Rows{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

[LandonTClipp]

There are three ways:

1. Don't use internal
2. Have your objects/structs/interfaces/whatever use a non-internal type alias to your internal type (not actually working yet for various reasons, Fix Go 1.23 types.Alias handling #808 should make this better, but you can also use the replace-types to get aliases to work).
3. Output your mocks in the same package as the mocked interfaces: https://vektra.github.io/mockery/latest/configuration/#__tabbed_1_2

[4k1k0]

What if the interface I am trying to use is from a dependency and I am referring to the file using the vendor directory?

Also I do not understand why I get this error if I am using the same Mockery version. The one thing that changes is my go version.