Add support for persistent mocks with Maybe() or Times()

[Jrmy2402]

Currently, there's no way to set up a mock that can be used for multiple identical queries, similar to the Maybe() or Times() functionality in github.com/stretchr/testify/mock.

The objective is to allow the definition of a mock that can respond to the same query multiple times without needing to be redefined. This would be particularly useful for testing code that executes the same query in rapid succession.

[pashagolub]

Would you, please, provide a short snippet showing this functionality? I'd like to see how convenient it can be before considering implementation details.

[Jrmy2402]

Quick example:

package main

import (
	"context"
	"fmt"
	"github.com/jackc/pgx/v5/pgxpool"
	"sync/atomic"
	"time"

	pgx "github.com/jackc/pgx/v5"
)

// PoolPG is an interface to abstract the Pool
type PoolPG interface {
	Close()
	Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
}

type Sync struct {
	db     PoolPG
	synced atomic.Bool
}

func NewSync(db PoolPG) *Sync {
	return &Sync{
		db: db,
	}
}

func (s *Sync) Sync(ctx context.Context) {
	go func() {
		s.synced.Store(true)
		defer func() {
			s.synced.Store(false)
		}()
		ticker := time.NewTicker(1 * time.Second)
		defer ticker.Stop()
		for {
			select {
			case <-ctx.Done():
				fmt.Println("stopped sync due to context done")
				return
			case <-ticker.C:

				sql := "Select * from products"
				rows, err := s.db.Query(context.Background(), sql)
				if err != nil {
					fmt.Println(err)
					return
				}
				for rows.Next() {
					// do something
				}

				if err = rows.Err(); err != nil {
					return
				}
			}
		}
	}()
	return
}

func main() {
	// @NOTE: the real connection is not required for tests
	db, err := pgxpool.New(context.Background(), "postgres://rolname@hostname/dbname")
	if err != nil {
		panic(err)
	}
	defer db.Close()

	syncer := NewSync(db)
	syncer.Sync(context.Background())

	time.Sleep(10 * time.Second)

}

Tests:

package main

import (
	"context"
	"github.com/pashagolub/pgxmock/v2"
	"github.com/stretchr/testify/assert"
	"testing"
	"time"
)

func TestShouldUpdateStats(t *testing.T) {
	mock, err := pgxmock.NewPool(pgxmock.QueryMatcherOption(pgxmock.QueryMatcherEqual))
	if err != nil {
		t.Fatal(err)
	}
	defer mock.Close()

	mock.ExpectQuery("Select * from products").
		WillReturnRows(
			mock.NewRows([]string{"id"}).AddRow("1"))
	//.Maybe()
	//.Times(2)

	syncer := NewSync(mock)
	syncer.Sync(context.Background())

	time.Sleep(10 * time.Second)
	assert.True(t, syncer.synced.Load())

}

I could test this code more efficiently with the Maybe() or Times(2).

[pashagolub]

Looks cool. One question: are we expecting the query maybe execution or maybe returning rows? Times(2) means at least 2 times or no more than 2 times? Or exactly 2 times?

[Jrmy2402]

For the Maybe(): that the query may be executed one or multiple times.
For the Times(X): that the query should be executed X times.
It would be great to have the possibility to cancel a Maybe() or overload the rows returned by the mock to change the return after some time.

[pashagolub]

Would you, please, try v3 beta? Try this command to check it out:

go get -u github.com/pashagolub/pgxmock/v3@v3.0.0-beta1

[Jrmy2402]

I'm sorry, but I will not have the possibility to test it before 18 September :(
Thanks a lot for this new version, I will try it around the 18 September.

[Jrmy2402]

I tested the new version and it works fine, thanks a lot :)
Sorry for the delay in the response