How to go about testing queries

[miniscruff]

Hey again, I was able to get everything working for a smoke test model with the usual CRUD operations and got to work writing a test for them.

The general pattern I have gone with, which could be wrong, is to pass a bob.Executor to my structs and use that whenever I need to make a query. I am wondering if there is some method or process to build a mock or stub executor to run tests against instead of connecting to the database directly. I did create a factory and add mods to generate a struct with random values but I don't see any way to take that factory and pass it to my struct as an executor. Especially since the factory needs an executor to create objects.

Note: I would like to be able to override any results to return an error as well, but have not gotten that far.

Sample go code to, hopefully, illustrate my concern.

// this would be the generated model
type CarModel struct {
    ID   string
    Make string
    Year int
}

// this is my http handler struct, but could be anything
type CarHandler struct {
    exec bob.Executor // this type may or may not be right either
}

// Get would be similar to an HTTP Get
func (c *CarHandler) Get(ctx context.Context, id int) (*CarModel, error) {
    car, err := models.FindCar(ctx, c.exec, id)
    if err != nil {
        // log stuff
        return nil, err
    }

    return car, nil
}

func TestCar_GetReturnsCar(t *testing.T) {
    ctx := context.Background()

    // create a factory, we will use this later
    factory := factory.New()

    // not sure if it is possible to create some mock database executor here?
    // I was kinda thinking factory had some method to return an executor
    // like `factory.Executor()` in order to fake queries with a factory.
    exec := bob.TestExec() // does not exist

    // just build a random car model by default
    factory.AddBaseCarMod(factory.CarMod.RandomizeAllColumns())
    existingCar, _ := factory.NewCar().Create(ctx, exec)

    // get a car from the db
    c := CarHandler{exec: exec}
    getCar, err := c.Get(ctx, existingCar.ID)

    // require the values to match
    require.Nil(t, err)
    require.Equal(t, existingCar.Make, getCar.Make)
    require.Equal(t, existingCar.Year, getCar.Year)
}

Let me know if I missed something, I looked around the code as much as I could but couldn't find anything to solve the issue.

[stephenafamo]

bob.Executor is just an interface which is easy to mock. Any existing package to mock a database/sql connection can also be used with Bob. For example, if using DATA-DOG/go-sqlmock:

func TestCar_GetReturnsCar(t *testing.T) {
    ctx := context.Background()

    db, mock, err := sqlmock.New()
    if err != nil {
        t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
    }
    defer db.Close()

    exec := bob.NewDB(db) // This is a valid bob executor

    // Do the tests
}

However, with factories, it becomes easier to test your code directly against a DB. You're already quite close, my preferred method is to use DATA-DOG/go-txdb to insert these entries in the DB and test against it, but run them all in a transaction and rollback after the tests finish.

func init() {
    // we register an sql driver named "txdb"
    txdb.Register("txdb", "mysql", "root@/txdb_test")
}

func TestCar_GetReturnsCar(t *testing.T) {
    db, err := sql.Open("txdb", "identifier")
    if err != nil {
        t.Fatalf(err)
    }
    defer db.Close()

    exec := bob.NewDB(db) // This is a valid bob executor

    // The rest of your code should work as expected and rollback after the tests finish.


    // create a factory, we will use this later
    factory := factory.New()

    // just build a random car model by default
    factory.AddBaseCarMod(factory.CarMod.RandomizeAllColumns())
    existingCar, _ := factory.NewCar().Create(ctx, exec)

    // get a car from the db
    c := CarHandler{exec: exec}
    getCar, err := c.Get(ctx, existingCar.ID)

    // require the values to match
    require.Nil(t, err)
    require.Equal(t, existingCar.Make, getCar.Make)
    require.Equal(t, existingCar.Year, getCar.Year)
}

To trigger specific errors, I will say to simulate the real DB condition. For example, if the user email must be unique, use the factory to add a user with an email, and then test that your CreateUser method fails with the unique constraint violation error.

Since bob.Executor is also an interface (with just 2 methods), you could create an implementation that returns an error on command for your test. Maybe call it an ErrorExecutor.

[miniscruff]

Working out great so far, thanks for the help. Here is my error executor if anyone else needs it.

type ErrorExecutor struct {
	Err error
}

func NewErrorExecutor() *ErrorExecutor {
	return &ErrorExecutor{
		Err: errors.New("expected error"),
	}
}

func (e *ErrorExecutor) ExecContext(context.Context, string, ...any) (sql.Result, error) {
	return nil, e.Err
}

func (e *ErrorExecutor) QueryContext(ctx context.Context, query string, args ...any) (scan.Rows, error) {
	return nil, e.Err
}