Recount-Server/tests/testdb.go

package debug_mode

import (
	"encoding/json"
	"nickiel.net/recount_server/types"
	"os"

	"github.com/jmoiron/sqlx"
	_ "github.com/mattn/go-sqlite3"
	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
)

func SetLogLevel(level zerolog.Level) {
	zerolog.SetGlobalLevel(level)
}

func Init_testdb(DB_TYPE string, DB_CONNECTION_STRING string) {

	cwd, err := os.Getwd()
	if err != nil {
		log.Fatal().Err(err).Msg("Could not get current working directory")
	} else {
		cwd = cwd + "/"
		log.Trace().Msgf("Currect working directory is: %s", cwd)
	}

	_, err = os.Stat(cwd + DB_CONNECTION_STRING)
	if err != nil {
		log.Debug().Msg("No existing test.db file found")
	} else {
		log.Debug().Msg("Found existing test.db file. Attempting to delete")
		err = os.Remove(cwd + DB_CONNECTION_STRING)
		if err != nil {
			log.Warn().Err(err).Msg("Failed to delete testing db. Continueing anyways")
		} else {
			log.Debug().Msg("Deleted test.db file successfully")
		}
	}

	db, err := sqlx.Connect(DB_TYPE, DB_CONNECTION_STRING)
	if err != nil {
		log.Fatal().
			Err(err).
			Msg("Couldn't open test db")
	}

	defer db.Close()

	init_sql := `
CREATE TABLE accounts (
	acnt_id Integer PRIMARY KEY,
	acnt_display_name varchar(50) NOT NULL,
	acnt_description varchar(250) NULL
);

CREATE TABLE buckets (
	bkt_id Integer PRIMARY KEY,
	bkt_display_code varchar(5) NOT NULL,
	bkt_display_name varchar(50) NULL,
	bkt_description varchar(250) NULL
);

CREATE TABLE transactions (
	trns_id Integer PRIMARY KEY,
	trns_amount money NOT NULL,
	trns_description varchar(250) NULL,
	trns_account int4 NOT NULL,
	trns_bucket int4 NULL,
	trns_date Date not null,
    FOREIGN KEY (trns_account)
        REFERENCES accounts (acnt_id)
        ON UPDATE CASCADE ON DELETE SET NULL,
    FOREIGN KEY (trns_bucket)
        REFERENCES buckets (bkt_id)
        ON UPDATE CASCADE ON DELETE SET NULL
);

CREATE TABLE transaction_breakdown (
	trns_brkdwn_id Integer PRIMARY KEY,
	trns_brkdwn_amount money NOT NULL,
	trns_brkdwn_parent_transaction int4 NOT NULL,
	trns_brkdwn_catagory int4 NULL,
	trns_brkdwn_bucket int4 NULL,
    FOREIGN KEY (trns_brkdwn_parent_transaction)
        REFERENCES transactions (trns_id)
        ON UPDATE CASCADE ON DELETE SET NULL,
    FOREIGN KEY (trns_brkdwn_catagory)
        REFERENCES transaction_categories(trns_ctgry_id)
        ON UPDATE CASCADE ON DELETE SET NULL,
    FOREIGN KEY (trns_brkdwn_bucket)
        REFERENCES buckets (bkt_id)
        ON UPDATE CASCADE ON DELETE SET NULL
);

CREATE TABLE transaction_categories (
	trns_ctgry_id Integer PRIMARY KEY,
	trns_ctgry_display_code varchar(5) NOT NULL,
	trns_ctgry_display_name varchar(50) NOT NULL,
	trns_ctgry_description varchar(250) NULL
);

INSERT INTO accounts (acnt_display_name, acnt_description) VALUES ("BECU Saving", "Savings Account");
INSERT INTO buckets (bkt_display_code, bkt_display_name, bkt_description) VALUES 
    ("SVNGS", "Savings", "Savings Bucket");
INSERT INTO transactions (trns_amount, trns_description, trns_account, trns_bucket, trns_date) VALUES
    ("50.00", "Money", 1, 1, "2023-11-10");
`

	tx := db.MustBegin()
	tx.MustExec(init_sql)

	err = tx.Commit()

	if err != nil {
		log.Fatal().
			Err(err).
			Msg("Could not commit transaction")
	}

	jsonExample := `{
        "Id": 3,
        "Amount": "100",
        "Description": {
            "String": "Transaction 3",
            "Valid": true
        },
        "Account": 1,
        "Bucket": {
            "Int64": 1,
            "Valid": true
        },
        "TransactionDate": "2023-11-11T00:00:00Z"
    }`

	var trns types.Transaction = types.Transaction{}
	err = json.Unmarshal([]byte(jsonExample), &trns)

	if err != nil {
		log.Fatal().Err(err).Msg("could not unmarshal")
	}

	_, err = db.NamedExec("INSERT INTO transactions"+
		"(trns_amount, trns_description, trns_account, trns_bucket, trns_date)"+
		"VALUES (:trns_amount, :trns_description, :trns_account, :trns_bucket, :trns_date)",
		trns)

	log.Debug().Msg("Test database initialized")

}