Merge pull request 'set-vote' (#17) from set-vote into main

Reviewed-on: #17

go.mod

@@ -0,0 +1,17 @@
+module go-sjles-pta-vote
+
+go 1.24.4
+
+require github.com/glebarez/go-sqlite v1.22.0
+
+require (
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/google/uuid v1.5.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	golang.org/x/sys v0.15.0 // indirect
+	modernc.org/libc v1.37.6 // indirect
+	modernc.org/mathutil v1.6.0 // indirect
+	modernc.org/memory v1.7.2 // indirect
+	modernc.org/sqlite v1.28.0 // indirect
+)

go.sum

@@ -0,0 +1,23 @@
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/glebarez/go-sqlite v1.22.0 h1:uAcMJhaA6r3LHMTFgP0SifzgXg46yJkgxqyuyec+ruQ=
+github.com/glebarez/go-sqlite v1.22.0/go.mod h1:PlBIdHe0+aUEFn+r2/uthrWq4FxbzugL0L8Li6yQJbc=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26 h1:Xim43kblpZXfIBQsbuBVKCudVG457BR2GZFIz3uw3hQ=
+github.com/google/pprof v0.0.0-20221118152302-e6195bd50e26/go.mod h1:dDKJzRmX4S37WGHujM7tX//fmj1uioxKzKxz3lo4HJo=
+github.com/google/uuid v1.5.0 h1:1p67kYwdtXjb0gL0BPiP1Av9wiZPo5A8z2cWkTZ+eyU=
+github.com/google/uuid v1.5.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
+github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc=
+golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+modernc.org/libc v1.37.6 h1:orZH3c5wmhIQFTXF+Nt+eeauyd+ZIt2BX6ARe+kD+aw=
+modernc.org/libc v1.37.6/go.mod h1:YAXkAZ8ktnkCKaN9sw/UDeUVkGYJ/YquGO4FTi5nmHE=
+modernc.org/mathutil v1.6.0 h1:fRe9+AmYlaej+64JsEEhoWuAYBkOtQiMEU7n/XgfYi4=
+modernc.org/mathutil v1.6.0/go.mod h1:Ui5Q9q1TR2gFm0AQRqQUaBWFLAhQpCwNcuhBOSedWPo=
+modernc.org/memory v1.7.2 h1:Klh90S215mmH8c9gO98QxQFsY+W451E8AnzjoE2ee1E=
+modernc.org/memory v1.7.2/go.mod h1:NO4NVCQy0N7ln+T9ngWqOQfi7ley4vpwvARR+Hjw95E=
+modernc.org/sqlite v1.28.0 h1:Zx+LyDDmXczNnEQdvPuEfcFVA2ZPyaD7UCZDjef3BHQ=
+modernc.org/sqlite v1.28.0/go.mod h1:Qxpazz0zH8Z1xCFyi5GSL3FzbtZ3fvbjmywNogldEW0=

server/config/config.go

@@ -8,16 +8,13 @@ import (
 )
 
 type Config struct {
-	Host string `json:"host"`
+	DBPath string `json:"db_path"`
-	Port string `json:"port"`
-	User string `json:"user"`
-	Password string `json:"password"`
-	Database string `json:"database"`
 	RedisHost string `json:"redis_host"`
 	RedisPassword string `json:"redis_password"`
 }
 
 var conf *Config
+var conf_path string = ".env"
 
 func GetConfig() *Config {
 	if conf != nil {
@@ -27,7 +24,7 @@ func GetConfig() *Config {
 	conf = &Config{}
 
 	// TODO: Make this into a ini or toml file
-	confgContent, err := os.ReadFile(".env")
+	configContent, err := os.ReadFile(conf_path)
 
 	if err != nil {
 		fmt.Println("Error reading .env file: ", err)
@@ -41,24 +38,21 @@ func GetConfig() *Config {
 	for _, variable := range envVariables {
 		if strings.Contains(variable, "=") {
 			splitVariable := strings.Split(variable, "=")
-			envMap[splitVariable[0]] = splitVAriable[1]
+			envMap[splitVariable[0]] = splitVariable[1]
 		}
 	}
 
+	if err := json.Unmarshal([]byte(configContent), conf); err != nil {
+        fmt.Println("Error unmarshalling config file: ", err)
+        os.Exit(1)
+    }
+
 	// TODO: Better mapping of key to json values
 	// TODO: Better error checking if values are missing
 	// TODO: Default values
 	for key, value := range envMap {
-		if strings.Contains(key, "host") {
+		if strings.Contains(key, "db_path") {
-			conf.Host = value
+			conf.DBPath = value
-		} else if strings.Contains(key, "port") {
-			conf.Port = value
-		} else if strings.Contains(key, "user") {
-			conf.User = value
-		} else if strings.Contains(key, "password") {
-			conf.Password = value
-		} else if strings.Contains(key, "database") {
-			conf.Database = value
 		} else if strings.Contains(key, "redis_host") {
 			conf.RedisHost = value
 		} else if strings.Contains(key, "redis_password") {
@@ -71,6 +65,6 @@ func GetConfig() *Config {
 	return conf
 }
 
-func init() {
+func SetConfig(init_conf *Config) {
-	conf = GetConfig()
+	conf = init_conf
 }

server/db/db.go

@@ -2,46 +2,57 @@ package db
 
 import (
 	"database/sql"
-	"fmt"
-	
-	"go-sjles-pta-vote/config"
 
-	_ "github.com/lib/pq"
+	"go-sjles-pta-vote/server/config"
+
+	_ "github.com/glebarez/go-sqlite"
 )
 
+var build_db_query string = `
+CREATE TABLE IF NOT EXISTS polls (
+    id INTEGER PRIMARY KEY,
+    question TEXT NOT NULL,
+    member_yes_votes UNSIGNED INT NOT NULL DEFAULT 0,
+    member_no_votes UNSIGNED INT NOT NULL DEFAULT 0,
+    non_member_yes_votes UNSIGNED INT NOT NULL DEFAULT 0,
+    non_member_no_votes UNSIGNED INT NOT NULL DEFAULT 0,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    expires_at DATETIME
+);
+
+CREATE TABLE IF NOT EXISTS voters (
+    poll_id UNSIGNED INT NOT NULL,
+    voter_email TEXT NOT NULL,
+    FOREIGN KEY (poll_id) REFERENCES polls(id),
+    PRIMARY KEY (poll_id, voter_email)
+);
+
+CREATE TABLE IF NOT EXISTS members (
+    email TEXT NOT NULL,
+    member_name TEXT,
+    PRIMARY KEY (email)
+);
+`
+
 var db *sql.DB
 
-func Connect() error {
+func Connect() (*sql.DB, error) {
-	var err error
+	db_config := config.GetConfig()
-	dbConfig := config.GetConfig()
 
-	db, err = sql.Open(
+	db, err := sql.Open("sqlite", db_config.DBPath)
-		"postgres", 
-		fmt.Sprintf("host=%s port=%s user=%s password=%s dbname=%s sslmode=disable",
-			dbConfig.Host,
-			dbConfig.Port,
-			dbConfig.User,
-			dbCofnig.Password,
-			dbConfig.Database
-		)
-	)
 
 	if err != nil {
-		return err
+		return nil, err
 	}
 
-	if err = db.Ping(); err != nil {
+	_, err = db.Exec(build_db_query)
-		return err
+	
-	}
+	return db, err
-
-	fmt.Println("Connected to PostgreSQL")
-
-	return nil
 }
 
-// TODO: Is there a way to close automatically on app closure
 func Close() {
 	if db != nil {
 		_ = db.Close()
 	}
-}
+}

server/db/db_test.go

@@ -0,0 +1,29 @@
+package db
+
+import (
+	"os"
+	"testing"
+
+	"go-sjles-pta-vote/server/config"
+)
+
+func TestConnect(t *testing.T) {
+	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+	if err != nil {
+		t.Errorf(`Failed to create temporary db file: %v`, err)
+	}
+
+	init_conf := &config.Config{
+		DBPath: string(tmp_db.Name()),
+	}
+	config.SetConfig(init_conf)
+
+	defer os.Remove(tmp_db.Name())
+	tmp_db.Close()
+
+	if _, err := Connect(); err != nil {
+		t.Errorf(`Failed to create the database: %v`, err)
+	}
+
+	defer Close()
+}

server/models/poll.go

@@ -1,11 +1,15 @@
 package models
 
 type Poll struct {
-	ID int `json:"id"`
+	ID int64 `json:"id"`
-	Question string `json:"Question"`
+	Question string `json:"question"`
-	Options []string `json:"options"`
+	MemberYes int64 `json:"member_yes"`
+	MemberNo int64 `json:"member_no"`
+	NonMemberYes int64 `json:"non_member_yes`
+	NonMemberNo int64 `json:"non_member_no`
 	TotalVotes int `json:"total_votes"`
 	WhoVoted []string `json:"who_voted"`
 	CreatedAt string `json:"created_at"`
 	UpdatedAt string `json:"updated_at"`
+	ExpiresAt string `json:"expires_at"`
 }

server/models/vote.go

@@ -1,7 +1,7 @@
 package models
 
 type Vote struct {
-	PollID int `json:"poll_id"`
+	PollId int64 `json:"poll_id"`
-	OptionIndex int `json:"option_index"`
+	Vote bool `json:"vote"`
-	IsMember bool `json:"is_member"`
+	Email string `json:"email"`
 }

server/models/voters.go

@@ -0,0 +1,57 @@
+package models
+
+import (
+    "go-sjles-pta-vote/server/db"
+)
+
+type Voter struct {
+    Email   string `json:"email"`
+    IsMember bool   `json:"is_member"`
+    YesVote  bool   `json:"yes_vote"`
+}
+
+func GetVoters(pollId int64) ([]Voter, error) {
+    db_conn, err := db.Connect()
+    if err != nil {
+        return nil, err
+    }
+    defer db.Close()
+
+    rows, err := db_conn.Query(`
+        SELECT v.voter_email,
+               CASE
+                   WHEN m.email IS NOT NULL THEN 1
+                   ELSE 0
+               END AS is_member,
+               CASE
+                   WHEN p.member_yes_votes + p.non_member_yes_votes > p.member_no_votes + p.non_member_no_votes THEN 1
+                   ELSE 0
+               END AS yes_vote
+        FROM voters v
+        LEFT JOIN members m ON v.voter_email = m.email
+        LEFT JOIN polls p ON v.poll_id = p.id
+        WHERE v.poll_id = $1
+    `, pollId)
+    if err != nil {
+        return nil, err
+    }
+    defer rows.Close()
+
+    var voters []Voter
+    for rows.Next() {
+        var voter Voter
+        var isMember int
+        var yesVote int
+        if err := rows.Scan(&voter.Email, &isMember, &yesVote); err != nil {
+            return nil, err
+        }
+        voter.IsMember = isMember == 1
+        voter.YesVote = yesVote == 1
+        voters = append(voters, voter)
+    }
+    if err := rows.Err(); err != nil {
+        return nil, err
+    }
+
+    return voters, nil
+}

server/services/poll.go

@@ -0,0 +1,287 @@
+package services
+
+import (
+	"database/sql"
+	"errors"
+	"time"
+
+	"go-sjles-pta-vote/server/db"
+	"go-sjles-pta-vote/server/models"
+)
+
+var ErrQuestionAlreadyExists = errors.New("Question already exists")
+var ErrQuestionDoesntExist = errors.New("Question does not exist yet")
+var ErrVoterAlreadyVoted = errors.New("Voter already voted")
+var ErrPollNotFound = errors.New("Poll not found")
+
+func CreatePoll(poll *models.Poll) (*models.Poll, error) {
+	new_poll := models.Poll{}
+
+	db_conn, err := db.Connect()
+	if err != nil {
+		return nil, err
+	}
+	defer db.Close()
+
+	get_stmt, err := db_conn.Prepare(`
+		SELECT id 
+			FROM polls 
+			WHERE question == $1
+	`)
+	if err != nil {
+		return nil, err
+	}
+	defer get_stmt.Close()
+
+	var id int
+	err = get_stmt.QueryRow(poll.Question).Scan(&id)
+	if err != sql.ErrNoRows {
+		if err != nil {
+			return nil, err
+		}
+		return nil, ErrQuestionAlreadyExists
+	}
+	
+	stmt, err := db_conn.Prepare(`
+		INSERT INTO polls (
+			question,
+			expires_at
+		) VALUES (
+		 	$1,
+			$2
+		) RETURNING ID;
+	`)
+
+	if err != nil {
+		return nil, err
+	}
+
+	defer stmt.Close()
+
+	res, err := stmt.Exec(poll.Question, poll.ExpiresAt)
+	if err != nil {
+		return nil, err
+	}
+
+	new_poll.ID, err = res.LastInsertId()
+	
+	return &new_poll, err
+}
+
+func GetPollByQuestion(question string) (*models.Poll, error) {
+	new_poll := models.Poll{}
+
+	db_conn, err := db.Connect()
+	if err != nil {
+		return nil, err
+	}
+	defer db.Close()
+
+	get_poll_stmt, err := db_conn.Prepare(`
+		SELECT 
+			id, question, 
+			member_yes_votes, member_no_votes,
+			non_member_yes_votes, non_member_no_votes,
+			created_at, updated_at,
+			expires_at
+		FROM polls 
+		WHERE question == $1
+	`)
+	if err != nil {
+		return nil, err
+	}
+	defer get_poll_stmt.Close()
+
+	err = get_poll_stmt.QueryRow(question).Scan(
+		&new_poll.ID, &new_poll.Question,
+		&new_poll.MemberYes, &new_poll.MemberNo,
+		&new_poll.NonMemberYes, &new_poll.NonMemberNo,
+		&new_poll.CreatedAt, &new_poll.UpdatedAt,
+		&new_poll.ExpiresAt,
+	)
+
+	if err == sql.ErrNoRows {
+		return nil, ErrPollNotFound
+	} else if err != nil {
+		return nil, err
+	}
+
+	get_voters_stmt, err := db_conn.Prepare (`
+		SELECT voter_email 
+		FROM voters
+		WHERE poll_id == $1
+	`)
+	if err != nil {
+		return nil, err
+	}
+	defer get_voters_stmt.Close()
+
+	rows, err := get_voters_stmt.Query(new_poll.ID)
+
+	for rows.Next() {
+		var voter_email string
+		err = rows.Scan(&voter_email)
+		if err != nil {
+			return nil, err
+		}
+		new_poll.WhoVoted = append(new_poll.WhoVoted, voter_email)
+	}
+
+	return &new_poll, nil
+}
+
+func GetAndCreatePollByQuestion(question string) (*models.Poll, error) {
+	new_poll, err := GetPollByQuestion(question)
+
+	if err == ErrPollNotFound {
+		create_poll := &models.Poll{
+			Question: question,
+			ExpiresAt: time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"),
+		}
+
+		if _, err = CreatePoll(create_poll); err != nil {
+			return nil, err
+		}
+
+		return GetPollByQuestion(question)
+	} else if err != nil {
+		return nil, err
+	} else {
+		return new_poll, err
+	}
+}
+
+// Use models.Vote to set votes
+func SetVote(vote *models.Vote) error {
+	db_conn, err := db.Connect()
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	set_voter_stmt, err := db_conn.Prepare(`
+		INSERT OR IGNORE INTO voters
+			(poll_id, voter_email)
+		VALUES ($1, $2)
+	`)
+	if err != nil {
+		return err
+	}
+	defer set_voter_stmt.Close()
+
+	res, err := set_voter_stmt.Exec(vote.PollId, vote.Email)
+	if err != nil {
+		return err
+	} else {
+		rows_changed, err := res.RowsAffected()
+		if rows_changed != 1 {
+			return ErrVoterAlreadyVoted
+		} else if err != nil {
+			return err
+		}
+	}
+
+	is_voter_member_stmt, err := db_conn.Prepare(`
+		SELECT 1
+		FROM members
+		WHERE email == $1
+	`)
+	if err != nil {
+		return err
+	}
+	defer is_voter_member_stmt.Close()
+
+	var member_check int64
+	is_member := true
+	err = is_voter_member_stmt.QueryRow(vote.Email).Scan(&member_check)
+	if err == sql.ErrNoRows {
+		is_member = false
+	} else if err != nil {
+		return err
+	}
+
+	// Member column name is not dependant on user input
+	//	So it's ok to put it directly in the query
+	member_column_name := "member_"
+	if !is_member {
+		member_column_name = "non_" + member_column_name
+	}
+
+	if vote.Vote {
+		member_column_name += "yes_votes"
+	} else {
+		member_column_name += "no_votes"
+	}
+
+	add_vote_stmt, err := db_conn.Prepare(`
+		UPDATE polls
+		SET ` + member_column_name + ` = ` + member_column_name + ` + 1
+		WHERE id == $1
+	`)
+	if err != nil {
+		return err
+	}
+	defer add_vote_stmt.Close()
+
+	res, err = add_vote_stmt.Exec(vote.PollId)
+	if err != nil {
+		return err
+	}
+
+	if num, err := res.RowsAffected(); num != 1 {
+		return errors.New("Failed to update votes")
+	} else if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Delete a poll by name
+func DeletePollByQuestion(question string) error {
+	db_conn, err := db.Connect()
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	delete_votes_stmt, err := db_conn.Prepare(`
+		DELETE FROM voters
+		WHERE poll_id IN (
+			SELECT id 
+			FROM polls 
+			WHERE question == $1
+		)
+	`)
+	if err != nil {
+		return err
+	}
+	defer delete_votes_stmt.Close()
+
+	_, err = delete_votes_stmt.Exec(question)
+	if err != nil {
+		return err
+	}
+
+	delete_poll_stmt, err := db_conn.Prepare(`
+		DELETE FROM polls
+		WHERE question == $1
+	`)
+	if err != nil {
+		return err
+	}
+	defer delete_poll_stmt.Close()
+
+	res, err := delete_poll_stmt.Exec(question)
+	if err != nil {
+		return err
+	}
+
+	if num, err := res.RowsAffected(); num != 1 {
+		return errors.New("Failed to delete poll")
+	} else if err != nil {
+		return err
+	}
+
+	return nil
+}

server/services/services_test.go

@@ -0,0 +1,497 @@
+package services
+
+import (
+	"math/rand"
+	"os"
+	"testing"
+	"time"
+
+	"go-sjles-pta-vote/server/config"
+	"go-sjles-pta-vote/server/db"
+	"go-sjles-pta-vote/server/models"
+)
+
+const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-=`~!@#$%^&*()_+[]\\;',./{}|:\"<>?"
+
+var new_members = []struct{
+	email string
+	member_name string
+}{
+	{"test1@mail.me", "test1"},
+	{"test2@mail.me", "test2"},
+	{"test3@mail.me", "test3"},
+	{"test4@mail.me", "test4"},
+	{"test5@mail.me", "test5"},
+	{"test6@mail.me", "test6"},
+	{"test7@mail.me", "test7"},
+	{"test100@mail.me", "test100"},
+	{"test101@mail.me", "test101"},
+	{"test102@mail.me", "test102"},
+	{"test103@mail.me", "test103"},
+	{"test104@mail.me", "test104"},
+	{"test105@mail.me", "test105"},
+}
+
+var new_polls = []struct{
+	question string
+	member_yes_votes int64
+	member_no_votes int64
+	non_member_yes_votes int64
+	non_member_no_votes int64
+}{
+	{"ques1", 1, 2, 3, 4},
+	{"ques2", 3, 2, 4, 5},
+	{"ques3", 4, 3, 6, 5},
+}
+
+var new_voters = []struct{
+	poll_id int64
+	voter_email string
+}{
+	{1, "test1@mail.me"},
+	{1, "test2@mail.me"},
+	{1, "test3@mail.me"},
+	{1, "test10@mail.me"},
+	{1, "test11@mail.me"},
+	{1, "test12@mail.me"},
+	{1, "test13@mail.me"},
+	{1, "test14@mail.me"},
+	{1, "test15@mail.me"},
+	{1, "test16@mail.me"},
+	{2, "test1@mail.me"},
+	{2, "test2@mail.me"},
+	{2, "test3@mail.me"},
+	{2, "test4@mail.me"},
+	{2, "test5@mail.me"},
+	{2, "test10@mail.me"},
+	{2, "test11@mail.me"},
+	{2, "test12@mail.me"},
+	{2, "test13@mail.me"},
+	{2, "test14@mail.me"},
+	{2, "test15@mail.me"},
+	{2, "test16@mail.me"},
+	{2, "test17@mail.me"},
+	{2, "test18@mail.me"},
+	{3, "test1@mail.me"},
+	{3, "test2@mail.me"},
+	{3, "test3@mail.me"},
+	{3, "test4@mail.me"},
+	{3, "test5@mail.me"},
+	{3, "test6@mail.me"},
+	{3, "test7@mail.me"},
+	{3, "test10@mail.me"},
+	{3, "test11@mail.me"},
+	{3, "test12@mail.me"},
+	{3, "test13@mail.me"},
+	{3, "test14@mail.me"},
+	{3, "test15@mail.me"},
+	{3, "test16@mail.me"},
+	{3, "test17@mail.me"},
+	{3, "test18@mail.me"},
+	{3, "test19@mail.me"},
+	{3, "test20@mail.me"},
+}
+
+func RandString(length int) string {
+	rand_bytes := make([]byte, length)
+	for rand_index := range length {
+		rand_bytes[rand_index] = charset[rand.Intn(len(charset))]
+	}
+	return string(rand_bytes)
+}
+
+func PreLoadDB() error {
+	db_conn, err := db.Connect()
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	// Insert members
+	for i := range new_members {
+		_, err := db_conn.Exec(`INSERT INTO members (email, member_name) VALUES (?, ?)`, new_members[i].email, new_members[i].member_name)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Insert polls
+	for i := range new_polls {
+		result, err := db_conn.Exec(`INSERT INTO polls (question, member_yes_votes, member_no_votes, non_member_yes_votes, non_member_no_votes, expires_at) VALUES (?, ?, ?, ?, ?, ?)`, new_polls[i].question, new_polls[i].member_yes_votes, new_polls[i].member_no_votes, new_polls[i].non_member_yes_votes, new_polls[i].non_member_no_votes, time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"))
+		if err != nil {
+			return err
+		}
+		_, err = result.LastInsertId()
+		if err != nil {
+			return err
+		}
+	}
+
+	// Insert voters
+	for i := range new_voters {
+		_, err := db_conn.Exec(`INSERT INTO voters (poll_id, voter_email) VALUES (?, ?)`, new_voters[i].poll_id, new_voters[i].voter_email)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func TestCreatePoll(t *testing.T) {
+	parameters := []struct{
+		question string
+		table_index int64
+	}{
+		{RandString(10) + "1", 1},
+		{RandString(10) + "2", 2},
+		{RandString(10) + "3", 3},
+		{"\"" + RandString(10) + "4", 4},
+		{"\\\"" + RandString(10) + "5", 5},
+		{"'" + RandString(10) + "6", 6},
+		{";" + RandString(10) + "7", 7},
+		{"\\" + RandString(10) + "8", 8},
+	}
+
+	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+	if err != nil {
+		t.Errorf(`Failed to create temporary db file: %v`, err)
+	}
+
+	init_conf := &config.Config{
+		DBPath: string(tmp_db.Name()),
+	}
+	config.SetConfig(init_conf)
+
+	defer os.Remove(tmp_db.Name())
+	tmp_db.Close()
+	
+	if _, err := db.Connect(); err != nil {
+		t.Errorf(`Failed to create the database: %v`, err)
+	}
+
+	for i := range parameters {
+		create_poll := &models.Poll{
+			Question: parameters[i].question,
+			ExpiresAt: time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"),
+		}
+
+		new_poll, err := CreatePoll(create_poll)
+
+		if err != nil {
+			t.Fatalf(`Failed to create new poll %s: %v`, parameters[i].question, err)
+		}
+
+		if new_poll == nil {
+			t.Fatalf(`Failed to insert %s into table`, parameters[i].question)
+		}
+
+		if new_poll.ID != parameters[i].table_index {
+			t.Fatalf(`Incorrect increment in index for %s: expected %d != %d`, parameters[i].question, parameters[i].table_index, new_poll.ID)
+		}
+	}
+}
+
+func TestAlreadyExists(t *testing.T) {
+	question := "TestQuestion"
+
+	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+	if err != nil {
+		t.Errorf(`Failed to create temporary db file: %v`, err)
+	}
+
+	init_conf := &config.Config{
+		DBPath: string(tmp_db.Name()),
+	}
+	config.SetConfig(init_conf)
+
+	defer os.Remove(tmp_db.Name())
+	tmp_db.Close()
+	
+	if _, err := db.Connect(); err != nil {
+		t.Errorf(`Failed to create the database: %v`, err)
+	}
+
+	create_poll := &models.Poll{
+		Question: question,
+		ExpiresAt: time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"),
+	}
+
+	new_poll, err := CreatePoll(create_poll)
+
+	if err != nil {
+		t.Fatalf(`Failed to create new poll %s: %v`, question, err)
+	}
+
+	if new_poll == nil {
+		t.Fatalf(`Failed to insert %s into table`, question)
+	}
+
+	new_poll, err = CreatePoll(create_poll)
+
+	if err != ErrQuestionAlreadyExists {
+		t.Fatalf(`Should have failed adding %s as it already exists`, question)
+	}
+}
+
+func TestGetPollByQuestion(t *testing.T) {
+	question := "TestQuestion"
+
+	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+	if err != nil {
+		t.Errorf(`Failed to create temporary db file: %v`, err)
+	}
+
+	init_conf := &config.Config{
+		DBPath: string(tmp_db.Name()),
+	}
+	config.SetConfig(init_conf)
+
+	defer os.Remove(tmp_db.Name())
+	tmp_db.Close()
+	
+	if _, err := db.Connect(); err != nil {
+		t.Errorf(`Failed to create the database: %v`, err)
+	}
+
+	create_poll := &models.Poll{
+		Question: question,
+		ExpiresAt: time.Now().Add(time.Hour * 10).Format("2006-01-02 15:04:05"),
+	}
+
+	new_poll, err := CreatePoll(create_poll)
+
+	if err != nil {
+		t.Fatalf(`Failed to create new poll %s: %v`, question, err)
+	}
+
+	if new_poll == nil {
+		t.Fatalf(`Failed to insert %s into table`, question)
+	}
+
+	get_poll, err := GetPollByQuestion(question)
+
+	if err != nil {
+		t.Fatalf(`Failed to get the poll %s: %v`, question, err)
+	}
+
+	if get_poll.Question != question {
+		t.Fatalf(`Questions don't match: expected %s: recieved %s`, question, get_poll.Question)
+	}
+}
+
+func TestGetCreatePollByQuestion(t *testing.T) {
+	parameters := []struct{
+		question string
+		table_index int64
+	}{
+		{RandString(10) + "1", 1},
+		{RandString(10) + "2", 2},
+		{RandString(10) + "3", 3},
+		{"\"" + RandString(10) + "4", 4},
+		{"'" + RandString(10) + "5", 5},
+		{";" + RandString(10) + "6", 6},
+	}
+
+	tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+	if err != nil {
+		t.Errorf(`Failed to create temporary db file: %v`, err)
+	}
+
+	init_conf := &config.Config{
+		DBPath: string(tmp_db.Name()),
+	}
+	config.SetConfig(init_conf)
+
+	defer os.Remove(tmp_db.Name())
+	tmp_db.Close()
+	
+	if _, err := db.Connect(); err != nil {
+		t.Errorf(`Failed to create the database: %v`, err)
+	}
+
+	for i := range parameters {
+		new_poll, err := GetAndCreatePollByQuestion(parameters[i].question)
+
+		if err != nil {
+			t.Fatalf(`Failed to create new poll %s: %v`, parameters[i].question, err)
+		}
+
+		if new_poll == nil {
+			t.Fatalf(`Failed to insert %s into table`, parameters[i].question)
+		}
+
+		if new_poll.ID != parameters[i].table_index {
+			t.Fatalf(`Incorrect increment in index for %s: expected %d != %d`, parameters[i].question, parameters[i].table_index, new_poll.ID)
+		}
+
+		if new_poll.Question != parameters[i].question {
+			t.Fatalf(`Incorrect question returned: Expected %s != %s`, parameters[i].question, new_poll.Question)
+		}
+	}
+}
+
+func TestSetVote(t *testing.T) {
+    // Preload the database with members, polls, and voters
+    tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+    if err != nil {
+        t.Fatalf("Failed to create temporary database: %v", err)
+    }
+    defer os.Remove(tmp_db.Name())
+
+    init_conf := &config.Config{
+        DBPath: string(tmp_db.Name()),
+    }
+    config.SetConfig(init_conf)
+
+    err = PreLoadDB()
+    if err != nil {
+        t.Fatalf("Failed to preload database: %v", err)
+    }
+
+    // Add a non-member vote
+    random_email := RandString(10) + "@mail.me"
+    vote := &models.Vote{
+        PollId: 1,
+        Email: random_email,
+        Vote: true,
+    }
+    err = SetVote(vote)
+    if err != nil {
+        t.Fatalf("Failed to set non-member vote: %v", err)
+    }
+
+    // Add a member vote
+    member_email := "test100@mail.me"
+    vote = &models.Vote{
+        PollId: 1,
+        Email: member_email,
+        Vote: true,
+    }
+    err = SetVote(vote)
+    if err != nil {
+        t.Fatalf("Failed to set member vote: %v", err)
+    }
+
+    // Verify the votes were added correctly
+    voters, err := models.GetVoters(1) // Use GetVoters from models
+    if err != nil {
+        t.Fatalf("Failed to get voters: %v", err)
+    }
+
+    expected_non_member_votes := 4 + 1 // Original non-member votes + new non-member vote
+    expected_member_votes := 3 + 1    // Original member votes + new member vote
+
+    for _, voter := range voters {
+        if voter.Email == random_email && voter.YesVote {
+            expected_non_member_votes--
+        } else if voter.Email == member_email && voter.YesVote {
+            expected_member_votes--
+        }
+    }
+
+    if expected_non_member_votes != 5 || expected_member_votes != 4 {
+        t.Errorf("Expected %d non-member votes and %d member votes, but got %d non-member votes and %d member votes", 4+1, 3+1, expected_non_member_votes, expected_member_votes)
+    }
+}
+
+func TestVoterAlreadyVoted(t *testing.T) {
+    // Preload the database with members, polls, and voters
+    tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+    if err != nil {
+        t.Fatalf("Failed to create temporary database: %v", err)
+    }
+    defer os.Remove(tmp_db.Name())
+
+    init_conf := &config.Config{
+        DBPath: string(tmp_db.Name()),
+    }
+    config.SetConfig(init_conf)
+
+    err = PreLoadDB()
+    if err != nil {
+        t.Fatalf("Failed to preload database: %v", err)
+    }
+
+    // Add a non-member vote
+    random_email := RandString(10) + "@mail.me"
+    vote := &models.Vote{
+        PollId: 1,
+        Email: random_email,
+        Vote: true,
+    }
+    err = SetVote(vote)
+    if err != nil {
+        t.Fatalf("Failed to set non-member vote: %v", err)
+    }
+
+    // Add a member vote
+    member_email := "test100@mail.me"
+    vote = &models.Vote{
+        PollId: 1,
+        Email: member_email,
+        Vote: true,
+    }
+    err = SetVote(vote)
+    if err != nil {
+        t.Fatalf("Failed to set member vote: %v", err)
+    }
+
+    // Attempt to add another non-member vote
+    vote = &models.Vote{
+        PollId: 1,
+        Email: random_email,
+        Vote: true,
+    }
+    err = SetVote(vote)
+    if err != ErrVoterAlreadyVoted {
+        t.Fatalf("Expected ErrVoterAlreadyVoted, but got %v", err)
+    }
+
+    // Attempt to add another member vote
+    vote = &models.Vote{
+        PollId: 1,
+        Email: member_email,
+        Vote: true,
+    }
+    err = SetVote(vote)
+    if err != ErrVoterAlreadyVoted {
+        t.Fatalf("Expected ErrVoterAlreadyVoted, but got %v", err)
+    }
+}
+
+func TestDeletePollByQuestion(t *testing.T) {
+    // Preload the database with members, polls, and voters
+    tmp_db, err := os.CreateTemp("", "vote_test.*.db")
+    if err != nil {
+        t.Fatalf("Failed to create temporary database: %v", err)
+    }
+    defer os.Remove(tmp_db.Name())
+
+    init_conf := &config.Config{
+        DBPath: string(tmp_db.Name()),
+    }
+    config.SetConfig(init_conf)
+
+    err = PreLoadDB()
+    if err != nil {
+        t.Fatalf("Failed to preload database: %v", err)
+    }
+
+    // Get a question from the new_polls array
+    testQuestion := new_polls[0].question
+
+    // Delete the poll by question
+    err = DeletePollByQuestion(testQuestion)
+    if err != nil {
+        t.Fatalf("Failed to delete poll by question: %v", err)
+    }
+
+    // Verify that the poll was deleted
+    _, err = GetPollByQuestion(testQuestion)
+    if err == nil {
+        t.Fatalf("Expected error when getting deleted poll, but got none")
+    } else if err != ErrPollNotFound {
+        t.Fatalf("Expected ErrPollNotFound, but got %v", err)
+    }
+}