Test Containers about neverl8 HOT 2 CLOSED

package test_util

import (
	"context"
	"fmt"
	"github.com/docker/go-connections/nat"
	"github.com/jinzhu/gorm"
	"github.com/testcontainers/testcontainers-go"
	"github.com/testcontainers/testcontainers-go/modules/postgres"
	"github.com/testcontainers/testcontainers-go/wait"
	"log"
	"time"
)

type TestDb struct {
	Db        *gorm.DB
	container testcontainers.Container
}

func SetupTestDb() *TestDb {
	ctx := context.Background()
	container, port, _ := createContainer(ctx)
	db, err := gorm.Open("postgres", fmt.Sprintf("host=localhost user=user password=password dbname=testdb sslmode=disable port=%s", port.Port()))
	if err != nil {
		log.Fatalf("####Failed to connect to the database: %s", err)
	}
	return &TestDb{Db: db, container: container}
}

func (tdb *TestDb) TearDown() {
	tdb.Db.Close()
	// remove test container
	_ = tdb.container.Terminate(context.Background())
}

func createContainer(ctx context.Context) (testcontainers.Container, nat.Port, error) {
	dbName := "testdb"
	dbUser := "user"
	dbPassword := "password"

	postgresContainer, err := postgres.RunContainer(ctx,
		testcontainers.WithImage("docker.io/postgres:15.2-alpine"),
		postgres.WithDatabase(dbName),
		postgres.WithUsername(dbUser),
		postgres.WithPassword(dbPassword),
		testcontainers.WithWaitStrategy(
			wait.ForLog("database system is ready to accept connections").
				WithOccurrence(2).
				WithStartupTimeout(5*time.Second)),
	)

	// Define the container request

	if err != nil {
		log.Fatalf("Failed to start container: %s", err)
	}

	// Get the container's mapped port
	mappedPort, err := postgresContainer.MappedPort(ctx, "5432")
	if err != nil {
		log.Fatalf("Failed to get mapped port: %s", err)
	}

	return postgresContainer, mappedPort, nil
}

package repository_test

import (
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/postgres"
	"github.com/rise8-us/activ8/model"
	"github.com/rise8-us/activ8/repository"
	"github.com/rise8-us/activ8/test_util"
	"github.com/stretchr/testify/assert"
	"os"
	"testing"
	"time"
)

var db *gorm.DB

func TestMain(m *testing.M) {
	testDB := test_util.SetupTestDb()
	db = testDB.Db
	//TODO: Look at moving to go-migrate an running migrations as part of SetupTestDb()
	//setup DB
	db.AutoMigrate(&model.Person{})
	defer testDB.TearDown()
	os.Exit(m.Run())
}

func TestCreatePerson(t *testing.T) {

	repo := repository.NewPersonRepository(db)

	// Mock test data
	person := &model.Person{
		Email:       "a.b@com",
		FirstName:   "Jeff",
		LastName:    "Wills",
		DisplayName: "Zoji",
	}

	// Call the CreatePerson function
	createdPerson, err := repo.CreatePerson(person)

	// Assert that no error occurred
	assert.NoError(t, err, "expected no error")
	// Assert that the created person matches the input person
	assert.NotNil(t, createdPerson, "expected person to be created")
	assert.Equal(t, createdPerson.Email, person.Email, "expected calendar to match")
	assert.Equal(t, uint(1), person.ID, "expected user id to be 1")
	assert.Equal(t, time.Now().Minute(), person.CreatedAt.Minute(), "expected created at to be set")
}