Merge branch 'master' into lash/purify-more

Reviewed-on: urdt/ussd#254

cmd/africastalking/main.go

@@ -42,6 +42,7 @@ func main() {
 	var connStr string
 	var resourceDir string
 	var size uint
+	var database string
 	var engineDebug bool
 	var host string
 	var port uint
@@ -71,6 +72,7 @@ func main() {
 	logg.Infof("start command", "build", build, "conn", connData, "resourcedir", resourceDir, "outputsize", size)
 
 	ctx := context.Background()
+	ctx = context.WithValue(ctx, "Database", database)
 	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "default language set error: %v", err)

cmd/async/main.go

@@ -52,6 +52,7 @@ func main() {
 	var sessionId string
 	var resourceDir string
 	var size uint
+	var database string
 	var engineDebug bool
 	var host string
 	var port uint
@@ -82,6 +83,7 @@ func main() {
 	logg.Infof("start command", "conn", connData, "resourcedir", resourceDir, "outputsize", size, "sessionId", sessionId)
 
 	ctx := context.Background()
+	ctx = context.WithValue(ctx, "Database", database)
 
 	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
 	if err != nil {

cmd/http/main.go

@@ -26,8 +26,8 @@ import (
 )
 
 var (
-	logg          = logging.NewVanilla()
+	logg      = logging.NewVanilla()
-	scriptDir     = path.Join("services", "registration")
+	scriptDir = path.Join("services", "registration")
 	menuSeparator = ": "
 )
 
@@ -41,6 +41,7 @@ func main() {
 	var connStr string
 	var resourceDir string
 	var size uint
+	var database string
 	var engineDebug bool
 	var host string
 	var port uint
@@ -70,6 +71,7 @@ func main() {
 	logg.Infof("start command", "conn", connData, "resourcedir", resourceDir, "outputsize", size)
 
 	ctx := context.Background()
+	ctx = context.WithValue(ctx, "Database", database)
 
 	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
 	if err != nil {

cmd/main.go

@@ -36,6 +36,7 @@ func main() {
 	var connStr string
 	var size uint
 	var sessionId string
+	var database string
 	var engineDebug bool
 	var resourceDir string
 	var err error
@@ -68,6 +69,7 @@ func main() {
 
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
+	ctx = context.WithValue(ctx, "Database", database)
 
 	ln, err := lang.LanguageFromCode(config.DefaultLanguage)
 	if err != nil {

devtools/store/generate/main.go

@@ -9,16 +9,14 @@ import (
 	"path"
 
 	"git.defalsify.org/vise.git/logging"
-	"git.grassecon.net/urdt/ussd/common"
 	"git.grassecon.net/urdt/ussd/config"
-	"git.grassecon.net/urdt/ussd/initializers"
 	"git.grassecon.net/urdt/ussd/internal/storage"
-	testdataloader "github.com/peteole/testdata-loader"
+	"git.grassecon.net/urdt/ussd/initializers"
+	"git.grassecon.net/urdt/ussd/common"
 )
 
 var (
 	logg      = logging.NewVanilla()
-	baseDir   = testdataloader.GetBasePath()
 	scriptDir = path.Join("services", "registration")
 )
 
@@ -26,6 +24,7 @@ func init() {
 	initializers.LoadEnvVariables()
 }
 
+
 func main() {
 	config.LoadConfig()
 
@@ -87,4 +86,5 @@ func main() {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)
 	}
+	
 }

initializers/load.go

@@ -3,30 +3,24 @@ package initializers
 import (
 	"log"
 	"os"
-	"path"
 	"strconv"
 
 	"github.com/joho/godotenv"
 )
 
 func LoadEnvVariables() {
-	LoadEnvVariablesPath(".")
+	err := godotenv.Load()
-}
-
-func LoadEnvVariablesPath(dir string) {
-	fp := path.Join(dir, ".env")
-	err := godotenv.Load(fp)
 	if err != nil {
-		log.Fatal("Error loading .env file", err)
+		log.Fatal("Error loading .env file")
 	}
 }
 
 // Helper to get environment variables with a default fallback
 func GetEnv(key, defaultVal string) string {
-	if value, exists := os.LookupEnv(key); exists {
+  if value, exists := os.LookupEnv(key); exists {
-		return value
+   	return value
 	}
-	return defaultVal
+  return defaultVal
 }
 
 // Helper to safely convert environment variables to uint

internal/handlers/application/menuhandler.go

@@ -1,4 +1,4 @@
-package ussd
+package application
 
 import (
 	"bytes"

internal/handlers/application/menuhandler_test.go

@@ -1,4 +1,4 @@
-package ussd
+package application
 
 import (
 	"context"

internal/handlers/base.go

@@ -6,46 +6,46 @@ import (
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
 
-	"git.grassecon.net/urdt/ussd/internal/handlers/ussd"
+	"git.grassecon.net/urdt/ussd/internal/handlers/application"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 )
 
 type BaseSessionHandler struct {
 	cfgTemplate engine.Config
-	rp RequestParser
+	rp          RequestParser
-	rs resource.Resource
+	rs          resource.Resource
-	hn *ussd.Handlers
+	hn          *application.Handlers
-	provider storage.StorageProvider
+	provider    storage.StorageProvider
 }
 
-func NewBaseSessionHandler(cfg engine.Config, rs resource.Resource, stateDb db.Db, userdataDb db.Db, rp RequestParser, hn *ussd.Handlers) *BaseSessionHandler {
+func NewBaseSessionHandler(cfg engine.Config, rs resource.Resource, stateDb db.Db, userdataDb db.Db, rp RequestParser, hn *application.Handlers) *BaseSessionHandler {
 	return &BaseSessionHandler{
 		cfgTemplate: cfg,
-		rs: rs,
+		rs:          rs,
-		hn: hn,
+		hn:          hn,
-		rp: rp,
+		rp:          rp,
-		provider: storage.NewSimpleStorageProvider(stateDb, userdataDb),
+		provider:    storage.NewSimpleStorageProvider(stateDb, userdataDb),
 	}
 }
 
-func(f* BaseSessionHandler) Shutdown() {
+func (f *BaseSessionHandler) Shutdown() {
 	err := f.provider.Close()
 	if err != nil {
 		logg.Errorf("handler shutdown error", "err", err)
 	}
 }
 
-func(f *BaseSessionHandler) GetEngine(cfg engine.Config, rs resource.Resource, pr *persist.Persister) engine.Engine {
+func (f *BaseSessionHandler) GetEngine(cfg engine.Config, rs resource.Resource, pr *persist.Persister) engine.Engine {
 	en := engine.NewEngine(cfg, rs)
 	en = en.WithPersister(pr)
 	return en
 }
 
-func(f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error) {
+func (f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error) {
 	var r bool
 	var err error
 	var ok bool
-	
+
 	logg.InfoCtxf(rqs.Ctx, "new request", "data", rqs)
 
 	rqs.Storage, err = f.provider.Get(rqs.Config.SessionId)
@@ -84,25 +84,25 @@ func(f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error)
 		return rqs, err
 	}
 
-	rqs.Continue = r 
+	rqs.Continue = r
 	return rqs, nil
 }
 
-func(f *BaseSessionHandler) Output(rqs RequestSession) (RequestSession,  error) {
+func (f *BaseSessionHandler) Output(rqs RequestSession) (RequestSession, error) {
 	var err error
 	_, err = rqs.Engine.Flush(rqs.Ctx, rqs.Writer)
 	return rqs, err
 }
 
-func(f *BaseSessionHandler) Reset(rqs RequestSession) (RequestSession, error) {
+func (f *BaseSessionHandler) Reset(rqs RequestSession) (RequestSession, error) {
 	defer f.provider.Put(rqs.Config.SessionId, rqs.Storage)
 	return rqs, rqs.Engine.Finish()
 }
 
-func(f *BaseSessionHandler) GetConfig() engine.Config {
+func (f *BaseSessionHandler) GetConfig() engine.Config {
 	return f.cfgTemplate
 }
 
-func(f *BaseSessionHandler) GetRequestParser() RequestParser {
+func (f *BaseSessionHandler) GetRequestParser() RequestParser {
 	return f.rp
 }

internal/handlers/handlerservice.go

@@ -10,13 +10,13 @@ import (
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
 
-	"git.grassecon.net/urdt/ussd/internal/handlers/ussd"
+	"git.grassecon.net/urdt/ussd/internal/handlers/application"
 	"git.grassecon.net/urdt/ussd/internal/utils"
 	"git.grassecon.net/urdt/ussd/remote"
 )
 
 type HandlerService interface {
-	GetHandler() (*ussd.Handlers, error)
+	GetHandler() (*application.Handlers, error)
 }
 
 func getParser(fp string, debug bool) (*asm.FlagParser, error) {
@@ -64,73 +64,73 @@ func (ls *LocalHandlerService) SetDataStore(db *db.Db) {
 	ls.UserdataStore = db
 }
 
-func (ls *LocalHandlerService) GetHandler(accountService remote.AccountServiceInterface) (*ussd.Handlers, error) {
+func (ls *LocalHandlerService) GetHandler(accountService remote.AccountServiceInterface) (*application.Handlers, error) {
 	replaceSeparatorFunc := func(input string) string {
 		return strings.ReplaceAll(input, ":", ls.Cfg.MenuSeparator)
 	}
 
-	ussdHandlers, err := ussd.NewHandlers(ls.Parser, *ls.UserdataStore, ls.AdminStore, accountService, replaceSeparatorFunc)
+	appHandlers, err := application.NewHandlers(ls.Parser, *ls.UserdataStore, ls.AdminStore, accountService, replaceSeparatorFunc)
 	if err != nil {
 		return nil, err
 	}
-	ussdHandlers = ussdHandlers.WithPersister(ls.Pe)
+	appHandlers = appHandlers.WithPersister(ls.Pe)
-	ls.DbRs.AddLocalFunc("set_language", ussdHandlers.SetLanguage)
+	ls.DbRs.AddLocalFunc("set_language", appHandlers.SetLanguage)
-	ls.DbRs.AddLocalFunc("create_account", ussdHandlers.CreateAccount)
+	ls.DbRs.AddLocalFunc("create_account", appHandlers.CreateAccount)
-	ls.DbRs.AddLocalFunc("save_temporary_pin", ussdHandlers.SaveTemporaryPin)
+	ls.DbRs.AddLocalFunc("save_temporary_pin", appHandlers.SaveTemporaryPin)
-	ls.DbRs.AddLocalFunc("verify_create_pin", ussdHandlers.VerifyCreatePin)
+	ls.DbRs.AddLocalFunc("verify_create_pin", appHandlers.VerifyCreatePin)
-	ls.DbRs.AddLocalFunc("check_identifier", ussdHandlers.CheckIdentifier)
+	ls.DbRs.AddLocalFunc("check_identifier", appHandlers.CheckIdentifier)
-	ls.DbRs.AddLocalFunc("check_account_status", ussdHandlers.CheckAccountStatus)
+	ls.DbRs.AddLocalFunc("check_account_status", appHandlers.CheckAccountStatus)
-	ls.DbRs.AddLocalFunc("authorize_account", ussdHandlers.Authorize)
+	ls.DbRs.AddLocalFunc("authorize_account", appHandlers.Authorize)
-	ls.DbRs.AddLocalFunc("quit", ussdHandlers.Quit)
+	ls.DbRs.AddLocalFunc("quit", appHandlers.Quit)
-	ls.DbRs.AddLocalFunc("check_balance", ussdHandlers.CheckBalance)
+	ls.DbRs.AddLocalFunc("check_balance", appHandlers.CheckBalance)
-	ls.DbRs.AddLocalFunc("validate_recipient", ussdHandlers.ValidateRecipient)
+	ls.DbRs.AddLocalFunc("validate_recipient", appHandlers.ValidateRecipient)
-	ls.DbRs.AddLocalFunc("transaction_reset", ussdHandlers.TransactionReset)
+	ls.DbRs.AddLocalFunc("transaction_reset", appHandlers.TransactionReset)
-	ls.DbRs.AddLocalFunc("invite_valid_recipient", ussdHandlers.InviteValidRecipient)
+	ls.DbRs.AddLocalFunc("invite_valid_recipient", appHandlers.InviteValidRecipient)
-	ls.DbRs.AddLocalFunc("max_amount", ussdHandlers.MaxAmount)
+	ls.DbRs.AddLocalFunc("max_amount", appHandlers.MaxAmount)
-	ls.DbRs.AddLocalFunc("validate_amount", ussdHandlers.ValidateAmount)
+	ls.DbRs.AddLocalFunc("validate_amount", appHandlers.ValidateAmount)
-	ls.DbRs.AddLocalFunc("reset_transaction_amount", ussdHandlers.ResetTransactionAmount)
+	ls.DbRs.AddLocalFunc("reset_transaction_amount", appHandlers.ResetTransactionAmount)
-	ls.DbRs.AddLocalFunc("get_recipient", ussdHandlers.GetRecipient)
+	ls.DbRs.AddLocalFunc("get_recipient", appHandlers.GetRecipient)
-	ls.DbRs.AddLocalFunc("get_sender", ussdHandlers.GetSender)
+	ls.DbRs.AddLocalFunc("get_sender", appHandlers.GetSender)
-	ls.DbRs.AddLocalFunc("get_amount", ussdHandlers.GetAmount)
+	ls.DbRs.AddLocalFunc("get_amount", appHandlers.GetAmount)
-	ls.DbRs.AddLocalFunc("reset_incorrect", ussdHandlers.ResetIncorrectPin)
+	ls.DbRs.AddLocalFunc("reset_incorrect", appHandlers.ResetIncorrectPin)
-	ls.DbRs.AddLocalFunc("save_firstname", ussdHandlers.SaveFirstname)
+	ls.DbRs.AddLocalFunc("save_firstname", appHandlers.SaveFirstname)
-	ls.DbRs.AddLocalFunc("save_familyname", ussdHandlers.SaveFamilyname)
+	ls.DbRs.AddLocalFunc("save_familyname", appHandlers.SaveFamilyname)
-	ls.DbRs.AddLocalFunc("save_gender", ussdHandlers.SaveGender)
+	ls.DbRs.AddLocalFunc("save_gender", appHandlers.SaveGender)
-	ls.DbRs.AddLocalFunc("save_location", ussdHandlers.SaveLocation)
+	ls.DbRs.AddLocalFunc("save_location", appHandlers.SaveLocation)
-	ls.DbRs.AddLocalFunc("save_yob", ussdHandlers.SaveYob)
+	ls.DbRs.AddLocalFunc("save_yob", appHandlers.SaveYob)
-	ls.DbRs.AddLocalFunc("save_offerings", ussdHandlers.SaveOfferings)
+	ls.DbRs.AddLocalFunc("save_offerings", appHandlers.SaveOfferings)
-	ls.DbRs.AddLocalFunc("reset_account_authorized", ussdHandlers.ResetAccountAuthorized)
+	ls.DbRs.AddLocalFunc("reset_account_authorized", appHandlers.ResetAccountAuthorized)
-	ls.DbRs.AddLocalFunc("reset_allow_update", ussdHandlers.ResetAllowUpdate)
+	ls.DbRs.AddLocalFunc("reset_allow_update", appHandlers.ResetAllowUpdate)
-	ls.DbRs.AddLocalFunc("get_profile_info", ussdHandlers.GetProfileInfo)
+	ls.DbRs.AddLocalFunc("get_profile_info", appHandlers.GetProfileInfo)
-	ls.DbRs.AddLocalFunc("verify_yob", ussdHandlers.VerifyYob)
+	ls.DbRs.AddLocalFunc("verify_yob", appHandlers.VerifyYob)
-	ls.DbRs.AddLocalFunc("reset_incorrect_date_format", ussdHandlers.ResetIncorrectYob)
+	ls.DbRs.AddLocalFunc("reset_incorrect_date_format", appHandlers.ResetIncorrectYob)
-	ls.DbRs.AddLocalFunc("initiate_transaction", ussdHandlers.InitiateTransaction)
+	ls.DbRs.AddLocalFunc("initiate_transaction", appHandlers.InitiateTransaction)
-	ls.DbRs.AddLocalFunc("verify_new_pin", ussdHandlers.VerifyNewPin)
+	ls.DbRs.AddLocalFunc("verify_new_pin", appHandlers.VerifyNewPin)
-	ls.DbRs.AddLocalFunc("confirm_pin_change", ussdHandlers.ConfirmPinChange)
+	ls.DbRs.AddLocalFunc("confirm_pin_change", appHandlers.ConfirmPinChange)
-	ls.DbRs.AddLocalFunc("quit_with_help", ussdHandlers.QuitWithHelp)
+	ls.DbRs.AddLocalFunc("quit_with_help", appHandlers.QuitWithHelp)
-	ls.DbRs.AddLocalFunc("fetch_community_balance", ussdHandlers.FetchCommunityBalance)
+	ls.DbRs.AddLocalFunc("fetch_community_balance", appHandlers.FetchCommunityBalance)
-	ls.DbRs.AddLocalFunc("set_default_voucher", ussdHandlers.SetDefaultVoucher)
+	ls.DbRs.AddLocalFunc("set_default_voucher", appHandlers.SetDefaultVoucher)
-	ls.DbRs.AddLocalFunc("check_vouchers", ussdHandlers.CheckVouchers)
+	ls.DbRs.AddLocalFunc("check_vouchers", appHandlers.CheckVouchers)
-	ls.DbRs.AddLocalFunc("get_vouchers", ussdHandlers.GetVoucherList)
+	ls.DbRs.AddLocalFunc("get_vouchers", appHandlers.GetVoucherList)
-	ls.DbRs.AddLocalFunc("view_voucher", ussdHandlers.ViewVoucher)
+	ls.DbRs.AddLocalFunc("view_voucher", appHandlers.ViewVoucher)
-	ls.DbRs.AddLocalFunc("set_voucher", ussdHandlers.SetVoucher)
+	ls.DbRs.AddLocalFunc("set_voucher", appHandlers.SetVoucher)
-	ls.DbRs.AddLocalFunc("get_voucher_details", ussdHandlers.GetVoucherDetails)
+	ls.DbRs.AddLocalFunc("get_voucher_details", appHandlers.GetVoucherDetails)
-	ls.DbRs.AddLocalFunc("reset_valid_pin", ussdHandlers.ResetValidPin)
+	ls.DbRs.AddLocalFunc("reset_valid_pin", appHandlers.ResetValidPin)
-	ls.DbRs.AddLocalFunc("check_pin_mismatch", ussdHandlers.CheckBlockedNumPinMisMatch)
+	ls.DbRs.AddLocalFunc("check_pin_mismatch", appHandlers.CheckBlockedNumPinMisMatch)
-	ls.DbRs.AddLocalFunc("validate_blocked_number", ussdHandlers.ValidateBlockedNumber)
+	ls.DbRs.AddLocalFunc("validate_blocked_number", appHandlers.ValidateBlockedNumber)
-	ls.DbRs.AddLocalFunc("retrieve_blocked_number", ussdHandlers.RetrieveBlockedNumber)
+	ls.DbRs.AddLocalFunc("retrieve_blocked_number", appHandlers.RetrieveBlockedNumber)
-	ls.DbRs.AddLocalFunc("reset_unregistered_number", ussdHandlers.ResetUnregisteredNumber)
+	ls.DbRs.AddLocalFunc("reset_unregistered_number", appHandlers.ResetUnregisteredNumber)
-	ls.DbRs.AddLocalFunc("reset_others_pin", ussdHandlers.ResetOthersPin)
+	ls.DbRs.AddLocalFunc("reset_others_pin", appHandlers.ResetOthersPin)
-	ls.DbRs.AddLocalFunc("save_others_temporary_pin", ussdHandlers.SaveOthersTemporaryPin)
+	ls.DbRs.AddLocalFunc("save_others_temporary_pin", appHandlers.SaveOthersTemporaryPin)
-	ls.DbRs.AddLocalFunc("get_current_profile_info", ussdHandlers.GetCurrentProfileInfo)
+	ls.DbRs.AddLocalFunc("get_current_profile_info", appHandlers.GetCurrentProfileInfo)
-	ls.DbRs.AddLocalFunc("check_transactions", ussdHandlers.CheckTransactions)
+	ls.DbRs.AddLocalFunc("check_transactions", appHandlers.CheckTransactions)
-	ls.DbRs.AddLocalFunc("get_transactions", ussdHandlers.GetTransactionsList)
+	ls.DbRs.AddLocalFunc("get_transactions", appHandlers.GetTransactionsList)
-	ls.DbRs.AddLocalFunc("view_statement", ussdHandlers.ViewTransactionStatement)
+	ls.DbRs.AddLocalFunc("view_statement", appHandlers.ViewTransactionStatement)
-	ls.DbRs.AddLocalFunc("update_all_profile_items", ussdHandlers.UpdateAllProfileItems)
+	ls.DbRs.AddLocalFunc("update_all_profile_items", appHandlers.UpdateAllProfileItems)
-	ls.DbRs.AddLocalFunc("set_back", ussdHandlers.SetBack)
+	ls.DbRs.AddLocalFunc("set_back", appHandlers.SetBack)
-	ls.DbRs.AddLocalFunc("show_blocked_account", ussdHandlers.ShowBlockedAccount)
+	ls.DbRs.AddLocalFunc("show_blocked_account", appHandlers.ShowBlockedAccount)
 
-	return ussdHandlers, nil
+	return appHandlers, nil
 }
 
 // TODO: enable setting of sessionId on engine init time

internal/storage/parse.go

@@ -15,7 +15,6 @@ const (
 type ConnData struct {
 	typ int
 	str string
-	domain string
 }
 
 func (cd *ConnData) DbType() int {
@@ -26,38 +25,23 @@ func (cd *ConnData) String() string {
 	return cd.str
 }
 
-func (cd *ConnData) Domain() string {
+func probePostgres(s string) (string, bool) {
-	return cd.domain
-}
-
-func (cd *ConnData) Path() string {
-	v, _ := url.Parse(cd.str)
-	v.RawQuery = ""
-	return v.String()
-}
-
-func probePostgres(s string) (string, string, bool) {
-	domain := "public"
 	v, err := url.Parse(s)
 	if err != nil {
-		return "", "", false
+		return "", false
 	}
 	if v.Scheme != "postgres" {
-		return "", "", false
+		return "", false
 	}
-	vv := v.Query()
+	return s, true
-	if vv.Has("search_path") {
-		domain = vv.Get("search_path")
-	}
-	return s, domain, true
 }
 
-func probeGdbm(s string) (string, string, bool) {
+func probeGdbm(s string) (string, bool) {
 	if !path.IsAbs(s) {
-		return "", "", false
+		return "", false
 	}
 	s = path.Clean(s)
-	return s, "", true
+	return s, true
 }
 
 func ToConnData(connStr string) (ConnData, error) {
@@ -67,15 +51,14 @@ func ToConnData(connStr string) (ConnData, error) {
 		return o, nil
 	}
 
-	v, domain, ok := probePostgres(connStr)
+	v, ok := probePostgres(connStr)
 	if ok {
 		o.typ = DBTYPE_POSTGRES
 		o.str = v
-		o.domain = domain
 		return o, nil
 	}
 
-	v, _, ok = probeGdbm(connStr)
+	v, ok = probeGdbm(connStr)
 	if ok {
 		o.typ = DBTYPE_GDBM
 		o.str = v

internal/storage/storageservice.go

@@ -14,7 +14,6 @@ import (
 	"git.defalsify.org/vise.git/persist"
 	"git.defalsify.org/vise.git/resource"
 	gdbmstorage "git.grassecon.net/urdt/ussd/internal/storage/db/gdbm"
-	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 var (
@@ -55,12 +54,7 @@ func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.D
 	connStr := ms.conn.String()
 	dbTyp := ms.conn.DbType()
 	if dbTyp == DBTYPE_POSTGRES {
-		// TODO: move to vise
+		newDb = postgres.NewPgDb()
-		err = ensureSchemaExists(ctx, ms.conn)
-		if err != nil {
-			return nil, err
-		}
-		newDb = postgres.NewPgDb().WithSchema(ms.conn.Domain())
 	} else if dbTyp == DBTYPE_GDBM {
 		err = ms.ensureDbDir()
 		if err != nil {
@@ -71,7 +65,7 @@ func (ms *MenuStorageService) getOrCreateDb(ctx context.Context, existingDb db.D
 	} else {
 		return nil, fmt.Errorf("unsupported connection string: '%s'\n", ms.conn.String())
 	}
-	logg.DebugCtxf(ctx, "connecting to db", "conn", connStr, "conndata", ms.conn)
+	logg.DebugCtxf(ctx, "connecting to db", "conn", connStr)
 	err = newDb.Connect(ctx, connStr)
 	if err != nil {
 		return nil, err
@@ -102,23 +96,6 @@ func (ms *MenuStorageService) WithGettext(path string, lns []lang.Language) *Men
 	return ms
 }
 
-// ensureSchemaExists creates a new schema if it does not exist
-func ensureSchemaExists(ctx context.Context, conn ConnData) error {
-	h, err := pgxpool.New(ctx, conn.Path())
-	if err != nil {
-		return fmt.Errorf("failed to connect to the database: %w", err)
-	}
-	defer h.Close()
-
-	query := fmt.Sprintf("CREATE SCHEMA IF NOT EXISTS %s", conn.Domain())
-	_, err = h.Exec(ctx, query)
-	if err != nil {
-		return fmt.Errorf("failed to create schema: %w", err)
-	}
-
-	return nil
-}
-
 func (ms *MenuStorageService) GetPersister(ctx context.Context) (*persist.Persister, error) {
 	stateStore, err := ms.GetStateStore(ctx)
 	if err != nil {

internal/testutil/engine.go

@@ -11,33 +11,20 @@ import (
 	"git.defalsify.org/vise.git/engine"
 	"git.defalsify.org/vise.git/logging"
 	"git.defalsify.org/vise.git/resource"
-	"git.grassecon.net/urdt/ussd/initializers"
 	"git.grassecon.net/urdt/ussd/internal/handlers"
 	"git.grassecon.net/urdt/ussd/internal/storage"
 	"git.grassecon.net/urdt/ussd/internal/testutil/testservice"
 	"git.grassecon.net/urdt/ussd/internal/testutil/testtag"
-	"git.grassecon.net/urdt/ussd/remote"
 	testdataloader "github.com/peteole/testdata-loader"
+	"git.grassecon.net/urdt/ussd/remote"
 )
 
 var (
-	logg             = logging.NewVanilla()
 	baseDir   = testdataloader.GetBasePath()
-	scriptDir        = path.Join(baseDir, "services", "registration")
+	logg      = logging.NewVanilla()
-	selectedDatabase = ""
+	scriptDir = path.Join(baseDir, "services", "registration")
-	selectedDbSchema = ""
 )
 
-func init() {
-	initializers.LoadEnvVariablesPath(baseDir)
-}
-
-// SetDatabase updates the database used by TestEngine
-func SetDatabase(dbType string, dbSchema string) {
-	selectedDatabase = dbType
-	selectedDbSchema = dbSchema
-}
-
 func TestEngine(sessionId string) (engine.Engine, func(), chan bool) {
 	ctx := context.Background()
 	ctx = context.WithValue(ctx, "SessionId", sessionId)

menutraversal_test/menu_traversal_test.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"flag"
-	"fmt"
 	"log"
 	"math/rand"
 	"os"
@@ -15,7 +14,6 @@ import (
 	"git.grassecon.net/urdt/ussd/internal/testutil"
 	"git.grassecon.net/urdt/ussd/internal/testutil/driver"
 	"github.com/gofrs/uuid"
-	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 var (
@@ -26,8 +24,6 @@ var (
 )
 
 var groupTestFile = flag.String("test-file", "group_test.json", "The test file to use for running the group tests")
-var database = flag.String("db", "gdbm", "Specify the database (gdbm or postgres)")
-var dbSchema = flag.String("schema", "test", "Specify the database schema (default test)")
 
 func testStore() string {
 	v, _ :=  filepath.Abs(".test_state/state.gdbm")
@@ -88,40 +84,12 @@ func extractSendAmount(response []byte) string {
 }
 
 func TestMain(m *testing.M) {
-	// Parse the flags
-	flag.Parse()
-
 	sessionID = GenerateSessionId()
 	defer func() {
 		if err := os.RemoveAll(testStore()); err != nil {
 			log.Fatalf("Failed to delete state store %s: %v", testStore(), err)
 		}
 	}()
-
-	// Set the selected database
-	testutil.SetDatabase(*database, *dbSchema)
-
-	// Cleanup the schema table after tests
-	defer func() {
-		if *database == "postgres" {
-			ctx := context.Background()
-			connStr := "postgres://" //storage.BuildConnStr()
-			dbConn, err := pgxpool.New(ctx, connStr)
-			if err != nil {
-				log.Fatalf("Failed to connect to database for cleanup: %v", err)
-			}
-			defer dbConn.Close()
-
-			query := fmt.Sprintf("DELETE FROM %s.kv_vise;", *dbSchema)
-			_, execErr := dbConn.Exec(ctx, query)
-			if execErr != nil {
-				log.Printf("Failed to cleanup table %s.kv_vise: %v", *dbSchema, execErr)
-			} else {
-				log.Printf("Successfully cleaned up table %s.kv_vise", *dbSchema)
-			}
-		}
-	}()
-
 	m.Run()
 }
 
@@ -158,6 +126,7 @@ func TestAccountCreationSuccessful(t *testing.T) {
 		}
 	}
 	<-eventChannel
+
 }
 
 func TestAccountRegistrationRejectTerms(t *testing.T) {