Convert AllianceTeam, Award, and LowerThird models to use Bolt DB.

model/alliance_team.go

@@ -5,53 +5,70 @@
 
 package model
 
+import "sort"
+
 type AllianceTeam struct {
-	Id           int
+	Id           int64 `db:"id"`
 	AllianceId   int
 	PickPosition int
 	TeamId       int
 }
 
 func (database *Database) CreateAllianceTeam(allianceTeam *AllianceTeam) error {
-	return database.allianceTeamMap.Insert(allianceTeam)
+	return database.tables[AllianceTeam{}].create(allianceTeam)
 }
 
 func (database *Database) GetTeamsByAlliance(allianceId int) ([]AllianceTeam, error) {
 	var allianceTeams []AllianceTeam
-	err := database.allianceTeamMap.Select(&allianceTeams,
-		"SELECT * FROM alliance_teams WHERE allianceid = ? ORDER BY pickposition", allianceId)
-	return allianceTeams, err
+	if err := database.tables[AllianceTeam{}].getAll(&allianceTeams); err != nil {
+		return nil, err
+	}
+	sort.Slice(allianceTeams, func(i, j int) bool {
+		return allianceTeams[i].PickPosition < allianceTeams[j].PickPosition
+	})
+
+	var matchingAllianceTeams []AllianceTeam
+	for _, allianceTeam := range allianceTeams {
+		if allianceTeam.AllianceId == allianceId {
+			matchingAllianceTeams = append(matchingAllianceTeams, allianceTeam)
+		}
+	}
+	return matchingAllianceTeams, nil
 }
 
-func (database *Database) SaveAllianceTeam(allianceTeam *AllianceTeam) error {
-	_, err := database.allianceTeamMap.Update(allianceTeam)
-	return err
+func (database *Database) UpdateAllianceTeam(allianceTeam *AllianceTeam) error {
+	return database.tables[AllianceTeam{}].update(allianceTeam)
 }
 
-func (database *Database) DeleteAllianceTeam(allianceTeam *AllianceTeam) error {
-	_, err := database.allianceTeamMap.Delete(allianceTeam)
-	return err
+func (database *Database) DeleteAllianceTeam(id int64) error {
+	return database.tables[AllianceTeam{}].delete(id)
 }
 
 func (database *Database) TruncateAllianceTeams() error {
-	return database.allianceTeamMap.TruncateTables()
+	return database.tables[AllianceTeam{}].truncate()
 }
 
 func (database *Database) GetAllAlliances() ([][]AllianceTeam, error) {
-	alliances := make([][]AllianceTeam, 0)
 	var allianceTeams []AllianceTeam
-	err := database.allianceTeamMap.Select(&allianceTeams,
-		"SELECT * FROM alliance_teams ORDER BY allianceid, pickposition")
-	if err == nil {
-		// Format the sorted list of teams into a two-dimensional slice.
-		currentAllianceId := -1
-		for _, allianceTeam := range allianceTeams {
-			if allianceTeam.AllianceId != currentAllianceId {
-				currentAllianceId = allianceTeam.AllianceId
-				alliances = append(alliances, make([]AllianceTeam, 0))
-			}
-			alliances[len(alliances)-1] = append(alliances[len(alliances)-1], allianceTeam)
-		}
+	if err := database.tables[AllianceTeam{}].getAll(&allianceTeams); err != nil {
+		return nil, err
 	}
-	return alliances, err
+	sort.Slice(allianceTeams, func(i, j int) bool {
+		if allianceTeams[i].AllianceId == allianceTeams[j].AllianceId {
+			return allianceTeams[i].PickPosition < allianceTeams[j].PickPosition
+		}
+		return allianceTeams[i].AllianceId < allianceTeams[j].AllianceId
+	})
+
+	alliances := make([][]AllianceTeam, 0)
+	// Format the sorted list of teams into a two-dimensional slice.
+	currentAllianceId := -1
+	for _, allianceTeam := range allianceTeams {
+		if allianceTeam.AllianceId != currentAllianceId {
+			currentAllianceId = allianceTeam.AllianceId
+			alliances = append(alliances, make([]AllianceTeam, 0))
+		}
+		alliances[len(alliances)-1] = append(alliances[len(alliances)-1], allianceTeam)
+	}
+	return alliances, nil
 }

model/alliance_team_test.go

@@ -10,6 +10,7 @@ import (
 
 func TestGetNonexistentAlliance(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	allianceTeams, err := db.GetTeamsByAlliance(1114)
 	assert.Nil(t, err)
@@ -18,6 +19,7 @@ func TestGetNonexistentAlliance(t *testing.T) {
 
 func TestAllianceTeamCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	allianceTeam := AllianceTeam{0, 1, 0, 254}
 	db.CreateAllianceTeam(&allianceTeam)
@@ -27,13 +29,13 @@ func TestAllianceTeamCrud(t *testing.T) {
 	assert.Equal(t, allianceTeam, allianceTeams[0])
 
 	allianceTeam.TeamId = 1114
-	db.SaveAllianceTeam(&allianceTeam)
+	db.UpdateAllianceTeam(&allianceTeam)
 	allianceTeams, err = db.GetTeamsByAlliance(1)
 	assert.Nil(t, err)
 	assert.Equal(t, 1, len(allianceTeams))
 	assert.Equal(t, allianceTeam.TeamId, allianceTeams[0].TeamId)
 
-	db.DeleteAllianceTeam(&allianceTeam)
+	db.DeleteAllianceTeam(allianceTeam.Id)
 	allianceTeams, err = db.GetTeamsByAlliance(1)
 	assert.Nil(t, err)
 	assert.Empty(t, allianceTeams)
@@ -41,6 +43,7 @@ func TestAllianceTeamCrud(t *testing.T) {
 
 func TestGetTeamsByAlliance(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	BuildTestAlliances(db)
 	allianceTeams, err := db.GetTeamsByAlliance(1)
@@ -61,6 +64,7 @@ func TestGetTeamsByAlliance(t *testing.T) {
 
 func TestTruncateAllianceTeams(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	allianceTeam := AllianceTeam{0, 1, 0, 254}
 	db.CreateAllianceTeam(&allianceTeam)
@@ -72,6 +76,7 @@ func TestTruncateAllianceTeams(t *testing.T) {
 
 func TestGetAllAlliances(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	alliances, err := db.GetAllAlliances()
 	assert.Nil(t, err)

model/award.go

@@ -5,8 +5,10 @@
 
 package model
 
+import "sort"
+
 type Award struct {
-	Id         int
+	Id         int64 `db:"id"`
 	Type       AwardType
 	AwardName  string
 	TeamId     int
@@ -22,41 +24,49 @@ const (
 )
 
 func (database *Database) CreateAward(award *Award) error {
-	return database.awardMap.Insert(award)
+	return database.tables[Award{}].create(award)
 }
 
-func (database *Database) GetAwardById(id int) (*Award, error) {
-	award := new(Award)
-	err := database.awardMap.Get(award, id)
-	if err != nil && err.Error() == "sql: no rows in result set" {
-		award = nil
-		err = nil
-	}
+func (database *Database) GetAwardById(id int64) (*Award, error) {
+	var award *Award
+	err := database.tables[Award{}].getById(id, &award)
 	return award, err
 }
 
-func (database *Database) SaveAward(award *Award) error {
-	_, err := database.awardMap.Update(award)
-	return err
+func (database *Database) UpdateAward(award *Award) error {
+	return database.tables[Award{}].update(award)
 }
 
-func (database *Database) DeleteAward(award *Award) error {
-	_, err := database.awardMap.Delete(award)
-	return err
+func (database *Database) DeleteAward(id int64) error {
+	return database.tables[Award{}].delete(id)
 }
 
 func (database *Database) TruncateAwards() error {
-	return database.awardMap.TruncateTables()
+	return database.tables[Award{}].truncate()
 }
 
 func (database *Database) GetAllAwards() ([]Award, error) {
 	var awards []Award
-	err := database.awardMap.Select(&awards, "SELECT * FROM awards ORDER BY id")
-	return awards, err
+	if err := database.tables[Award{}].getAll(&awards); err != nil {
+		return nil, err
+	}
+	sort.Slice(awards, func(i, j int) bool {
+		return awards[i].Id < awards[j].Id
+	})
+	return awards, nil
 }
 
 func (database *Database) GetAwardsByType(awardType AwardType) ([]Award, error) {
-	var awards []Award
-	err := database.awardMap.Select(&awards, "SELECT * FROM awards WHERE type = ? ORDER BY id", awardType)
-	return awards, err
+	awards, err := database.GetAllAwards()
+	if err != nil {
+		return nil, err
+	}
+
+	var matchingAwards []Award
+	for _, award := range awards {
+		if award.Type == awardType {
+			matchingAwards = append(matchingAwards, award)
+		}
+	}
+	return matchingAwards, nil
 }

model/award_test.go

@@ -10,6 +10,7 @@ import (
 
 func TestGetNonexistentAward(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	award, err := db.GetAwardById(1114)
 	assert.Nil(t, err)
@@ -18,15 +19,17 @@ func TestGetNonexistentAward(t *testing.T) {
 
 func TestAwardCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	award := Award{0, JudgedAward, "Saftey Award", 254, ""}
-	db.CreateAward(&award)
+	assert.Nil(t, db.CreateAward(&award))
 	award2, err := db.GetAwardById(1)
 	assert.Nil(t, err)
 	assert.Equal(t, award, *award2)
 
+	award2.Id = 0
 	award2.AwardName = "Spirit Award"
-	db.CreateAward(award2)
+	assert.Nil(t, db.CreateAward(award2))
 	awards, err := db.GetAllAwards()
 	assert.Nil(t, err)
 	if assert.Equal(t, 2, len(awards)) {
@@ -36,13 +39,13 @@ func TestAwardCrud(t *testing.T) {
 
 	award.TeamId = 0
 	award.PersonName = "Travus Cubington"
-	db.SaveAward(&award)
+	assert.Nil(t, db.UpdateAward(&award))
 	award2, err = db.GetAwardById(1)
 	assert.Nil(t, err)
 	assert.Equal(t, award.TeamId, award2.TeamId)
 	assert.Equal(t, award.PersonName, award2.PersonName)
 
-	db.DeleteAward(&award)
+	assert.Nil(t, db.DeleteAward(award.Id))
 	award2, err = db.GetAwardById(1)
 	assert.Nil(t, err)
 	assert.Nil(t, award2)
@@ -50,6 +53,7 @@ func TestAwardCrud(t *testing.T) {
 
 func TestTruncateAwards(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	award := Award{0, JudgedAward, "Saftey Award", 254, ""}
 	db.CreateAward(&award)
@@ -61,6 +65,7 @@ func TestTruncateAwards(t *testing.T) {
 
 func TestGetAwardsByType(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	award1 := Award{0, WinnerAward, "Event Winner", 1114, ""}
 	db.CreateAward(&award1)

model/database.go

@@ -14,7 +14,6 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 	"go.etcd.io/bbolt"
 	"io"
-	"log"
 	"os"
 	"path/filepath"
 	"strings"
@@ -25,7 +24,11 @@ const backupsDir = "db/backups"
 const migrationsDir = "db/migrations"
 
 var BaseDir = "." // Mutable for testing
-var recordTypes = []interface{}{}
+var recordTypes = []interface{}{
+	AllianceTeam{},
+	Award{},
+	LowerThird{},
+}
 
 type Database struct {
 	Path             string
@@ -35,11 +38,8 @@ type Database struct {
 	matchResultMap   *modl.DbMap
 	rankingMap       *modl.DbMap
 	teamMap          *modl.DbMap
-	allianceTeamMap  *modl.DbMap
-	lowerThirdMap    *modl.DbMap
 	sponsorSlideMap  *modl.DbMap
 	scheduleBlockMap *modl.DbMap
-	awardMap         *modl.DbMap
 	userSessionMap   *modl.DbMap
 	bolt             *bbolt.DB
 	tables           map[interface{}]*table
@@ -87,11 +87,9 @@ func OpenDatabase(filename string) (*Database, error) {
 	return &database, nil
 }
 
-func (database *Database) Close() {
+func (database *Database) Close() error {
 	database.db.Close()
-	if err := database.bolt.Close(); err != nil {
-		log.Println(err)
-	}
+	return database.bolt.Close()
 }
 
 // Creates a copy of the current database and saves it to the backups directory.
@@ -138,21 +136,12 @@ func (database *Database) mapTables() {
 	database.teamMap = modl.NewDbMap(database.db, dialect)
 	database.teamMap.AddTableWithName(Team{}, "teams").SetKeys(false, "Id")
 
-	database.allianceTeamMap = modl.NewDbMap(database.db, dialect)
-	database.allianceTeamMap.AddTableWithName(AllianceTeam{}, "alliance_teams").SetKeys(true, "Id")
-
-	database.lowerThirdMap = modl.NewDbMap(database.db, dialect)
-	database.lowerThirdMap.AddTableWithName(LowerThird{}, "lower_thirds").SetKeys(true, "Id")
-
 	database.sponsorSlideMap = modl.NewDbMap(database.db, dialect)
 	database.sponsorSlideMap.AddTableWithName(SponsorSlide{}, "sponsor_slides").SetKeys(true, "Id")
 
 	database.scheduleBlockMap = modl.NewDbMap(database.db, dialect)
 	database.scheduleBlockMap.AddTableWithName(ScheduleBlock{}, "schedule_blocks").SetKeys(true, "Id")
 
-	database.awardMap = modl.NewDbMap(database.db, dialect)
-	database.awardMap.AddTableWithName(Award{}, "awards").SetKeys(true, "Id")
-
 	database.userSessionMap = modl.NewDbMap(database.db, dialect)
 	database.userSessionMap.AddTableWithName(UserSession{}, "user_sessions").SetKeys(true, "Id")
 }

model/event_settings_test.go

@@ -10,6 +10,7 @@ import (
 
 func TestEventSettingsReadWrite(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	eventSettings, err := db.GetEventSettings()
 	assert.Nil(t, err)

model/lower_third.go

@@ -5,57 +5,73 @@
 
 package model
 
+import (
+	"sort"
+)
+
 type LowerThird struct {
-	Id           int
+	Id           int64 `db:"id"`
 	TopText      string
 	BottomText   string
 	DisplayOrder int
-	AwardId      int
+	AwardId      int64
 }
 
 func (database *Database) CreateLowerThird(lowerThird *LowerThird) error {
-	return database.lowerThirdMap.Insert(lowerThird)
+	return database.tables[LowerThird{}].create(lowerThird)
 }
 
-func (database *Database) GetLowerThirdById(id int) (*LowerThird, error) {
-	lowerThird := new(LowerThird)
-	err := database.lowerThirdMap.Get(lowerThird, id)
-	if err != nil && err.Error() == "sql: no rows in result set" {
-		lowerThird = nil
-		err = nil
-	}
+func (database *Database) GetLowerThirdById(id int64) (*LowerThird, error) {
+	var lowerThird *LowerThird
+	err := database.tables[LowerThird{}].getById(id, &lowerThird)
 	return lowerThird, err
 }
 
-func (database *Database) SaveLowerThird(lowerThird *LowerThird) error {
-	_, err := database.lowerThirdMap.Update(lowerThird)
-	return err
+func (database *Database) UpdateLowerThird(lowerThird *LowerThird) error {
+	return database.tables[LowerThird{}].update(lowerThird)
 }
 
-func (database *Database) DeleteLowerThird(lowerThird *LowerThird) error {
-	_, err := database.lowerThirdMap.Delete(lowerThird)
-	return err
+func (database *Database) DeleteLowerThird(id int64) error {
+	return database.tables[LowerThird{}].delete(id)
 }
 
 func (database *Database) TruncateLowerThirds() error {
-	return database.lowerThirdMap.TruncateTables()
+	return database.tables[LowerThird{}].truncate()
 }
 
 func (database *Database) GetAllLowerThirds() ([]LowerThird, error) {
 	var lowerThirds []LowerThird
-	err := database.lowerThirdMap.Select(&lowerThirds, "SELECT * FROM lower_thirds ORDER BY displayorder")
-	return lowerThirds, err
+	if err := database.tables[LowerThird{}].getAll(&lowerThirds); err != nil {
+		return nil, err
+	}
+	sort.Slice(lowerThirds, func(i, j int) bool {
+		return lowerThirds[i].DisplayOrder < lowerThirds[j].DisplayOrder
+	})
+	return lowerThirds, nil
 }
 
-func (database *Database) GetLowerThirdsByAwardId(awardId int) ([]LowerThird, error) {
-	var lowerThirds []LowerThird
-	err := database.lowerThirdMap.Select(&lowerThirds, "SELECT * FROM lower_thirds WHERE awardid = ? ORDER BY id",
-		awardId)
-	return lowerThirds, err
+func (database *Database) GetLowerThirdsByAwardId(awardId int64) ([]LowerThird, error) {
+	lowerThirds, err := database.GetAllLowerThirds()
+	if err != nil {
+		return nil, err
+	}
+
+	var matchingLowerThirds []LowerThird
+	for _, lowerThird := range lowerThirds {
+		if lowerThird.AwardId == awardId {
+			matchingLowerThirds = append(matchingLowerThirds, lowerThird)
+		}
+	}
+	return matchingLowerThirds, nil
 }
 
 func (database *Database) GetNextLowerThirdDisplayOrder() int {
-	var count int
-	_ = database.lowerThirdMap.SelectOne(&count, "SELECT MAX(displayorder) + 1 FROM lower_thirds")
-	return count
+	lowerThirds, err := database.GetAllLowerThirds()
+	if err != nil {
+		return 0
+	}
+	if len(lowerThirds) == 0 {
+		return 1
+	}
+	return lowerThirds[len(lowerThirds)-1].DisplayOrder + 1
 }

model/lower_third_test.go

@@ -10,6 +10,7 @@ import (
 
 func TestGetNonexistentLowerThird(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	lowerThird, err := db.GetLowerThirdById(1114)
 	assert.Nil(t, err)
@@ -18,20 +19,29 @@ func TestGetNonexistentLowerThird(t *testing.T) {
 
 func TestLowerThirdCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
-	lowerThird := LowerThird{0, "Top Text", "Bottom Text", 0, 0}
-	db.CreateLowerThird(&lowerThird)
+	lowerThirds, err := db.GetAllLowerThirds()
+	assert.Nil(t, err)
+	assert.Equal(t, 0, len(lowerThirds))
+
+	lowerThird := LowerThird{0, "Top Text", "Bottom Text", 1, 0}
+	assert.Nil(t, db.CreateLowerThird(&lowerThird))
 	lowerThird2, err := db.GetLowerThirdById(1)
 	assert.Nil(t, err)
 	assert.Equal(t, lowerThird, *lowerThird2)
 
 	lowerThird.BottomText = "Blorpy"
-	db.SaveLowerThird(&lowerThird)
+	assert.Nil(t, db.UpdateLowerThird(&lowerThird))
 	lowerThird2, err = db.GetLowerThirdById(1)
 	assert.Nil(t, err)
 	assert.Equal(t, lowerThird.BottomText, lowerThird2.BottomText)
 
-	db.DeleteLowerThird(&lowerThird)
+	lowerThirds, err = db.GetAllLowerThirds()
+	assert.Nil(t, err)
+	assert.Equal(t, 1, len(lowerThirds))
+
+	assert.Nil(t, db.DeleteLowerThird(lowerThird.Id))
 	lowerThird2, err = db.GetLowerThirdById(1)
 	assert.Nil(t, err)
 	assert.Nil(t, lowerThird2)
@@ -39,10 +49,11 @@ func TestLowerThirdCrud(t *testing.T) {
 
 func TestTruncateLowerThirds(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	lowerThird := LowerThird{0, "Top Text", "Bottom Text", 0, 0}
-	db.CreateLowerThird(&lowerThird)
-	db.TruncateLowerThirds()
+	assert.Nil(t, db.CreateLowerThird(&lowerThird))
+	assert.Nil(t, db.TruncateLowerThirds())
 	lowerThird2, err := db.GetLowerThirdById(1)
 	assert.Nil(t, err)
 	assert.Nil(t, lowerThird2)
@@ -50,18 +61,25 @@ func TestTruncateLowerThirds(t *testing.T) {
 
 func TestGetLowerThirdsByAwardId(t *testing.T) {
 	db := setupTestDb(t)
-	lowerThird1 := LowerThird{0, "Top Text", "Bottom Text", 0, 0}
-	db.CreateLowerThird(&lowerThird1)
-	lowerThird2 := LowerThird{0, "Award 1", "", 1, 5}
-	db.CreateLowerThird(&lowerThird2)
-	lowerThird3 := LowerThird{0, "Award 2", "", 2, 2}
-	db.CreateLowerThird(&lowerThird3)
-	lowerThird4 := LowerThird{0, "Award 1", "Award 1 Winner", 3, 5}
-	db.CreateLowerThird(&lowerThird4)
-	nextDisplayOrder := db.GetNextLowerThirdDisplayOrder()
-	assert.Equal(t, 4, nextDisplayOrder)
+	defer db.Close()
 
-	lowerThirds, err := db.GetLowerThirdsByAwardId(5)
+	nextDisplayOrder := db.GetNextLowerThirdDisplayOrder()
+	assert.Equal(t, 1, nextDisplayOrder)
+	lowerThird1 := LowerThird{0, "Top Text", "Bottom Text", 1, 0}
+	assert.Nil(t, db.CreateLowerThird(&lowerThird1))
+	lowerThird2 := LowerThird{0, "Award 1", "", 2, 5}
+	assert.Nil(t, db.CreateLowerThird(&lowerThird2))
+	lowerThird3 := LowerThird{0, "Award 2", "", 3, 2}
+	assert.Nil(t, db.CreateLowerThird(&lowerThird3))
+	lowerThird4 := LowerThird{0, "Award 1", "Award 1 Winner", 4, 5}
+	assert.Nil(t, db.CreateLowerThird(&lowerThird4))
+	lowerThirds, err := db.GetAllLowerThirds()
+	assert.Nil(t, err)
+	assert.Equal(t, 4, len(lowerThirds))
+	nextDisplayOrder = db.GetNextLowerThirdDisplayOrder()
+	assert.Equal(t, 5, nextDisplayOrder)
+
+	lowerThirds, err = db.GetLowerThirdsByAwardId(5)
 	assert.Nil(t, err)
 	if assert.Equal(t, 2, len(lowerThirds)) {
 		assert.Equal(t, lowerThird2, lowerThirds[0])
@@ -72,4 +90,7 @@ func TestGetLowerThirdsByAwardId(t *testing.T) {
 	if assert.Equal(t, 1, len(lowerThirds)) {
 		assert.Equal(t, lowerThird3, lowerThirds[0])
 	}
+	lowerThirds, err = db.GetLowerThirdsByAwardId(39)
+	assert.Nil(t, err)
+	assert.Equal(t, 0, len(lowerThirds))
 }

model/match_result_test.go

@@ -10,6 +10,7 @@ import (
 
 func TestGetNonexistentMatchResult(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	match, err := db.GetMatchResultForMatch(1114)
 	assert.Nil(t, err)
@@ -18,9 +19,10 @@ func TestGetNonexistentMatchResult(t *testing.T) {
 
 func TestMatchResultCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	matchResult := BuildTestMatchResult(254, 5)
-	db.CreateMatchResult(matchResult)
+	assert.Nil(t, db.CreateMatchResult(matchResult))
 	matchResult2, err := db.GetMatchResultForMatch(254)
 	assert.Nil(t, err)
 	assert.Equal(t, matchResult, matchResult2)
@@ -38,6 +40,7 @@ func TestMatchResultCrud(t *testing.T) {
 
 func TestTruncateMatchResults(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	matchResult := BuildTestMatchResult(254, 1)
 	db.CreateMatchResult(matchResult)
@@ -49,6 +52,7 @@ func TestTruncateMatchResults(t *testing.T) {
 
 func TestGetMatchResultForMatch(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	matchResult := BuildTestMatchResult(254, 2)
 	db.CreateMatchResult(matchResult)

model/match_test.go

@@ -11,6 +11,7 @@ import (
 
 func TestGetNonexistentMatch(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	match, err := db.GetMatchById(1114)
 	assert.Nil(t, err)
@@ -19,6 +20,7 @@ func TestGetNonexistentMatch(t *testing.T) {
 
 func TestMatchCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	match := Match{0, "qualification", "254", time.Now().UTC(), 0, 0, 0, 0, 0, 1, false, 2, false, 3, false, 4, false,
 		5, false, 6, false, time.Now().UTC(), time.Now().UTC(), MatchNotPlayed}
@@ -44,6 +46,7 @@ func TestMatchCrud(t *testing.T) {
 
 func TestTruncateMatches(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	match := Match{0, "qualification", "254", time.Now().UTC(), 0, 0, 0, 0, 0, 1, false, 2, false, 3, false, 4, false,
 		5, false, 6, false, time.Now().UTC(), time.Now().UTC(), MatchNotPlayed}
@@ -56,6 +59,7 @@ func TestTruncateMatches(t *testing.T) {
 
 func TestGetMatchesByElimRoundGroup(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	match := Match{Type: "elimination", DisplayName: "SF1-1", ElimRound: 2, ElimGroup: 1, ElimInstance: 1,
 		ElimRedAlliance: 8, ElimBlueAlliance: 4}
@@ -85,6 +89,7 @@ func TestGetMatchesByElimRoundGroup(t *testing.T) {
 
 func TestGetMatchesByType(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	match := Match{0, "qualification", "1", time.Now().UTC(), 0, 0, 0, 0, 0, 1, false, 2, false, 3, false, 4, false,
 		5, false, 6, false, time.Now().UTC(), time.Now().UTC(), MatchNotPlayed}

model/ranking_test.go

@@ -11,6 +11,7 @@ import (
 
 func TestGetNonexistentRanking(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	ranking, err := db.GetRankingForTeam(1114)
 	assert.Nil(t, err)
@@ -19,9 +20,10 @@ func TestGetNonexistentRanking(t *testing.T) {
 
 func TestRankingCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	ranking := game.TestRanking1()
-	db.CreateRanking(ranking)
+	assert.Nil(t, db.CreateRanking(ranking))
 	ranking2, err := db.GetRankingForTeam(254)
 	assert.Nil(t, err)
 	assert.Equal(t, ranking, ranking2)
@@ -31,15 +33,11 @@ func TestRankingCrud(t *testing.T) {
 	ranking2, err = db.GetRankingForTeam(254)
 	assert.Nil(t, err)
 	assert.Equal(t, ranking.Random, ranking2.Random)
-
-	db.DeleteRanking(ranking)
-	ranking2, err = db.GetRankingForTeam(254)
-	assert.Nil(t, err)
-	assert.Nil(t, ranking2)
 }
 
 func TestTruncateRankings(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	ranking := game.TestRanking1()
 	db.CreateRanking(ranking)
@@ -51,6 +49,7 @@ func TestTruncateRankings(t *testing.T) {
 
 func TestGetAllRankings(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	rankings, err := db.GetAllRankings()
 	assert.Nil(t, err)
@@ -58,7 +57,7 @@ func TestGetAllRankings(t *testing.T) {
 
 	numRankings := 20
 	for i := 1; i <= numRankings; i++ {
-		db.CreateRanking(&game.Ranking{TeamId: i})
+		assert.Nil(t, db.CreateRanking(&game.Ranking{TeamId: i, Rank: i}))
 	}
 	rankings, err = db.GetAllRankings()
 	assert.Nil(t, err)

model/schedule_block_test.go

@@ -11,6 +11,7 @@ import (
 
 func TestScheduleBlockCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	scheduleBlock1 := ScheduleBlock{0, "practice", time.Now().UTC(), 10, 600}
 	assert.Nil(t, db.CreateScheduleBlock(&scheduleBlock1))

model/sponsor_slide_test.go

@@ -10,6 +10,7 @@ import (
 
 func TestGetNonexistentSponsorSlide(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	sponsorSlide, err := db.GetSponsorSlideById(1114)
 	assert.Nil(t, err)
@@ -18,11 +19,12 @@ func TestGetNonexistentSponsorSlide(t *testing.T) {
 
 func TestSponsorSlideCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	assert.Equal(t, 0, db.GetNextSponsorSlideDisplayOrder())
 
 	sponsorSlide := SponsorSlide{0, "Subtitle", "Line 1", "Line 2", "", 10, 0}
-	db.CreateSponsorSlide(&sponsorSlide)
+	assert.Nil(t, db.CreateSponsorSlide(&sponsorSlide))
 	sponsorSlide2, err := db.GetSponsorSlideById(1)
 	assert.Nil(t, err)
 	assert.Equal(t, sponsorSlide, *sponsorSlide2)
@@ -42,6 +44,7 @@ func TestSponsorSlideCrud(t *testing.T) {
 
 func TestTruncateSponsorSlides(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	sponsorSlide := SponsorSlide{0, "Subtitle", "Line 1", "Line 2", "", 10, 0}
 	db.CreateSponsorSlide(&sponsorSlide)

model/team_test.go

@@ -10,6 +10,7 @@ import (
 
 func TestGetNonexistentTeam(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	team, err := db.GetTeamById(1114)
 	assert.Nil(t, err)
@@ -18,6 +19,7 @@ func TestGetNonexistentTeam(t *testing.T) {
 
 func TestTeamCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	team := Team{Id: 254, Name: "NASA", Nickname: "The Cheesy Poofs", City: "San Jose", StateProv: "CA",
 		Country: "USA", RookieYear: 1999, RobotName: "Barrage"}
@@ -40,6 +42,7 @@ func TestTeamCrud(t *testing.T) {
 
 func TestTruncateTeams(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	team := Team{Id: 254, Name: "NASA", Nickname: "The Cheesy Poofs", City: "San Jose", StateProv: "CA",
 		Country: "USA", RookieYear: 1999, RobotName: "Barrage"}
@@ -52,6 +55,7 @@ func TestTruncateTeams(t *testing.T) {
 
 func TestGetAllTeams(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	teams, err := db.GetAllTeams()
 	assert.Nil(t, err)

model/user_session_test.go

@@ -11,6 +11,7 @@ import (
 
 func TestGetNonexistentUserSession(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	session, err := db.GetUserSessionByToken("blorpy")
 	assert.Nil(t, err)
@@ -19,6 +20,7 @@ func TestGetNonexistentUserSession(t *testing.T) {
 
 func TestUserSessionCrud(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	session := UserSession{0, "token1", "Bertha", time.Now()}
 	err := db.CreateUserSession(&session)
@@ -37,6 +39,7 @@ func TestUserSessionCrud(t *testing.T) {
 
 func TestTruncateUserSessions(t *testing.T) {
 	db := setupTestDb(t)
+	defer db.Close()
 
 	session := UserSession{0, "token1", "Bertha", time.Now()}
 	db.CreateUserSession(&session)