schedtxt_api/cmd/api/main_test.go

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net/http"
	"os"
	"path"
	"testing"

	"github.com/go-chi/chi/v5"
	"github.com/joho/godotenv"

	"git.kundeng.us/phoenix/textsender-api/internal/app"
	"git.kundeng.us/phoenix/textsender-api/internal/config"
	"git.kundeng.us/phoenix/textsender-api/internal/db"
	"git.kundeng.us/phoenix/textsender-api/internal/handler"
	"git.kundeng.us/phoenix/textsender-api/internal/handler/endpoint"
	mdlware "git.kundeng.us/phoenix/textsender-api/internal/middleware"
	"git.kundeng.us/phoenix/textsender-api/internal/services"
	"git.kundeng.us/phoenix/textsender-api/internal/store"
)

var testRouter *chi.Mux

func TestMain(m *testing.M) {
	cfg, apiApp := load()

	database, err := db.NewDatabase(cfg.GetDBConnString())
	if err != nil {
		fmt.Println(err.Error())
		panic("Failed to initialize database")
	}
	defer database.Close()

	ctx := context.Background()

	if cfg.ResetDB {
		if err = database.ResetDatabase(ctx); err != nil {
			fmt.Println(err.Error())
			panic("Failed to initialize database")
		}
	} else {
		if exists, err := db.TableExists(ctx, database.Pool, "contacts "); err == nil && !exists {
			fmt.Println("Resetting database")
			err = database.ResetDatabase(ctx)
			if err != nil {
				fmt.Printf("Error:%v", err)
			}
		} else {
			fmt.Printf("Error:%v", err)
		}
	}

	jwtService := services.NewJWTService(cfg.JWTSecret)

	contactStore := store.NewContactStore(database.Pool)
	messageStore := store.NewMessageStore(db.Pool)
	schStore := store.NewScheduledMessageStore(db.Pool)
	schMsgEventStore := store.NewScheduledMessageEventStore(db.Pool)
	merStore := store.NewMessageEventResponseStore(db.Pool)

	contactHandler := handler.NewContactHandler(apiApp, contactStore)
	messageHandler := handler.NewMessageHandler(apiApp, messageStore)
	scheduledMessageHandler := handler.NewScheduledMessageHandler(apiApp, schStore)
	scheduledMessageEventHandler := handler.NewScheduledMessageEventHandler(apiApp, schMsgEventStore, schStore)
	scheduledMessageStatusHandler := handler.NewScheduledMessageStatusHandler(apiApp, schMsgEventStore, schStore)
	eventHandler := handler.NewEventResponseHandler(apiApp, merStore)

	testRouter = chi.NewRouter()
	testRouter.Handle(endpoint.ADD_CONTACT_ENDPOINT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.AddContact)))
	testRouter.Handle(endpoint.GET_CONTACT, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(contactHandler.GetContact)))
	testRouter.Handle(endpoint.ADD_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.AddMessage)))
	testRouter.Handle(endpoint.GET_MESSAGE, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(messageHandler.GetMessage)))
	testRouter.Handle(endpoint.ScheduleMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.AddScheduledMessage)))
	testRouter.Method("GET", endpoint.GetScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.GetScheduledMessageEvent)))
	testRouter.Method("DELETE", endpoint.DeleteScheduledMessageEventEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageEventHandler.DeleteScheduledMessageEvent)))
	testRouter.Method("PATCH", endpoint.UpdateScheduledMessageStatusEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageStatusHandler.UpdateStatus)))
	testRouter.Method("GET", endpoint.GetScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.GetScheduledMessage)))
	testRouter.Method("GET", endpoint.FetchNextScheduledMessageEndpoint, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(scheduledMessageHandler.FetchNextMessage)))
	testRouter.Method("POST", endpoint.RecordEventResponse, mdlware.AuthMiddleware(jwtService)(http.HandlerFunc(eventHandler.RecordResponse)))

	code := m.Run()
	os.Exit(code)
}

func load() (*config.Config, *app.App) {
	resetDb := flag.Bool("reset-db", false, "Reset the database schema and exit")
	port := flag.String("port", config.PORT, "Server port")
	flag.Parse()

	cwd, _ := os.Getwd()
	envPath := path.Join(cwd, ".env")

	err := godotenv.Load(envPath)
	if err != nil {
		envPath = path.Join(cwd, "../..", ".env")
		if err := godotenv.Load(envPath); err != nil {
			panic("Error loading .env file: " + err.Error())
		}
	}

	unpackedConnString := config.UnpackDBConnString()
	dbConnString := unpackedConnString.Parse()

	if tCfg, err := config.TwilioConfig(); err != nil {
		log.Fatal("Error: ", err)
		return nil, nil
	} else {
		return &config.Config{
			DBConnString: dbConnString,
			ServerPort:   *port,
			ResetDB:      *resetDb,
		}, &app.App{TwilioConfig: tCfg}
	}
}

func resetTestDB(t *testing.T) {
	t.Helper()
	_, err := db.Pool.Exec(context.Background(), "DELETE FROM contacts")
	if err != nil {
		t.Fatalf("Failed to reset test database: %v", err)
	}
}