Return 500 server error on database failures (#191)

2026-05-06 21:42:07 +08:00 · 2019-05-25 14:37:24 +08:00
parent 11165faa06
commit 67493c643e
30 changed files with 1129 additions and 491 deletions
--- a/database/application.go
+++ b/database/application.go
@@ -2,26 +2,33 @@ package database

 import (
 	"github.com/gotify/server/model"
+	"github.com/jinzhu/gorm"
 )

 // GetApplicationByToken returns the application for the given token or nil.
-func (d *GormDatabase) GetApplicationByToken(token string) *model.Application {
+func (d *GormDatabase) GetApplicationByToken(token string) (*model.Application, error) {
 	app := new(model.Application)
-	d.DB.Where("token = ?", token).Find(app)
-	if app.Token == token {
-		return app
+	err := d.DB.Where("token = ?", token).Find(app).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if app.Token == token {
+		return app, err
+	}
+	return nil, err
 }

 // GetApplicationByID returns the application for the given id or nil.
-func (d *GormDatabase) GetApplicationByID(id uint) *model.Application {
+func (d *GormDatabase) GetApplicationByID(id uint) (*model.Application, error) {
 	app := new(model.Application)
-	d.DB.Where("id = ?", id).Find(app)
-	if app.ID == id {
-		return app
+	err := d.DB.Where("id = ?", id).Find(app).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if app.ID == id {
+		return app, err
+	}
+	return nil, err
 }

 // CreateApplication creates an application.
@@ -36,10 +43,13 @@ func (d *GormDatabase) DeleteApplicationByID(id uint) error {
 }

 // GetApplicationsByUser returns all applications from a user.
-func (d *GormDatabase) GetApplicationsByUser(userID uint) []*model.Application {
+func (d *GormDatabase) GetApplicationsByUser(userID uint) ([]*model.Application, error) {
 	var apps []*model.Application
-	d.DB.Where("user_id = ?", userID).Find(&apps)
-	return apps
+	err := d.DB.Where("user_id = ?", userID).Find(&apps).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+	}
+	return apps, err
 }

 // UpdateApplication updates an application.
--- a/database/application_test.go
+++ b/database/application_test.go
@@ -6,57 +6,87 @@ import (
 )

 func (s *DatabaseSuite) TestApplication() {
-	assert.Nil(s.T(), s.db.GetApplicationByToken("asdasdf"), "not existing app")
-	assert.Nil(s.T(), s.db.GetApplicationByID(uint(1)), "not existing app")
+
+	if app, err := s.db.GetApplicationByToken("asdasdf"); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), app, "not existing app")
+	}
+
+	if app, err := s.db.GetApplicationByID(uint(1)); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), app, "not existing app")
+	}

 	user := &model.User{Name: "test", Pass: []byte{1}}
 	s.db.CreateUser(user)
 	assert.NotEqual(s.T(), 0, user.ID)

-	apps := s.db.GetApplicationsByUser(user.ID)
-	assert.Empty(s.T(), apps)
+	if apps, err := s.db.GetApplicationsByUser(user.ID); assert.NoError(s.T(), err) {
+		assert.Empty(s.T(), apps)
+	}

 	app := &model.Application{UserID: user.ID, Token: "C0000000000", Name: "backupserver"}
 	s.db.CreateApplication(app)

-	apps = s.db.GetApplicationsByUser(user.ID)
-	assert.Len(s.T(), apps, 1)
-	assert.Contains(s.T(), apps, app)
+	if apps, err := s.db.GetApplicationsByUser(user.ID); assert.NoError(s.T(), err) {
+		assert.Len(s.T(), apps, 1)
+		assert.Contains(s.T(), apps, app)
+	}

-	newApp := s.db.GetApplicationByToken(app.Token)
-	assert.Equal(s.T(), app, newApp)
+	newApp, err := s.db.GetApplicationByToken(app.Token)
+	if assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), app, newApp)
+	}

-	newApp = s.db.GetApplicationByID(app.ID)
-	assert.Equal(s.T(), app, newApp)
+	newApp, err = s.db.GetApplicationByID(app.ID)
+	if assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), app, newApp)
+	}

 	newApp.Image = "asdasd"
-	s.db.UpdateApplication(newApp)
+	assert.NoError(s.T(), s.db.UpdateApplication(newApp))

-	newApp = s.db.GetApplicationByID(app.ID)
-	assert.Equal(s.T(), "asdasd", newApp.Image)
+	newApp, err = s.db.GetApplicationByID(app.ID)
+	if assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), "asdasd", newApp.Image)
+	}

-	s.db.DeleteApplicationByID(app.ID)
+	assert.NoError(s.T(), s.db.DeleteApplicationByID(app.ID))

-	apps = s.db.GetApplicationsByUser(user.ID)
-	assert.Empty(s.T(), apps)
+	if apps, err := s.db.GetApplicationsByUser(user.ID); assert.NoError(s.T(), err) {
+		assert.Empty(s.T(), apps)
+	}

-	assert.Nil(s.T(), s.db.GetApplicationByID(app.ID))
+	if app, err := s.db.GetApplicationByID(app.ID); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), app)
+	}
 }

 func (s *DatabaseSuite) TestDeleteAppDeletesMessages() {
-	s.db.CreateApplication(&model.Application{ID: 55, Token: "token"})
-	s.db.CreateApplication(&model.Application{ID: 66, Token: "token2"})
-	s.db.CreateMessage(&model.Message{ID: 12, ApplicationID: 55})
-	s.db.CreateMessage(&model.Message{ID: 13, ApplicationID: 66})
-	s.db.CreateMessage(&model.Message{ID: 14, ApplicationID: 55})
-	s.db.CreateMessage(&model.Message{ID: 15, ApplicationID: 55})
+	assert.NoError(s.T(), s.db.CreateApplication(&model.Application{ID: 55, Token: "token"}))
+	assert.NoError(s.T(), s.db.CreateApplication(&model.Application{ID: 66, Token: "token2"}))
+	assert.NoError(s.T(), s.db.CreateMessage(&model.Message{ID: 12, ApplicationID: 55}))
+	assert.NoError(s.T(), s.db.CreateMessage(&model.Message{ID: 13, ApplicationID: 66}))
+	assert.NoError(s.T(), s.db.CreateMessage(&model.Message{ID: 14, ApplicationID: 55}))
+	assert.NoError(s.T(), s.db.CreateMessage(&model.Message{ID: 15, ApplicationID: 55}))

-	s.db.DeleteApplicationByID(55)
+	assert.NoError(s.T(), s.db.DeleteApplicationByID(55))

-	assert.Nil(s.T(), s.db.GetMessageByID(12))
-	assert.NotNil(s.T(), s.db.GetMessageByID(13))
-	assert.Nil(s.T(), s.db.GetMessageByID(14))
-	assert.Nil(s.T(), s.db.GetMessageByID(15))
-	assert.Empty(s.T(), s.db.GetMessagesByApplication(55))
-	assert.NotEmpty(s.T(), s.db.GetMessagesByApplication(66))
+	if msg, err := s.db.GetMessageByID(12); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), msg)
+	}
+	if msg, err := s.db.GetMessageByID(13); assert.NoError(s.T(), err) {
+		assert.NotNil(s.T(), msg)
+	}
+	if msg, err := s.db.GetMessageByID(14); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), msg)
+	}
+	if msg, err := s.db.GetMessageByID(15); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), msg)
+	}
+
+	if msgs, err := s.db.GetMessagesByApplication(55); assert.NoError(s.T(), err) {
+		assert.Empty(s.T(), msgs)
+	}
+	if msgs, err := s.db.GetMessagesByApplication(66); assert.NoError(s.T(), err) {
+		assert.NotEmpty(s.T(), msgs)
+	}
 }
--- a/database/client.go
+++ b/database/client.go
@@ -1,25 +1,34 @@
 package database

-import "github.com/gotify/server/model"
+import (
+	"github.com/gotify/server/model"
+	"github.com/jinzhu/gorm"
+)

 // GetClientByID returns the client for the given id or nil.
-func (d *GormDatabase) GetClientByID(id uint) *model.Client {
+func (d *GormDatabase) GetClientByID(id uint) (*model.Client, error) {
 	client := new(model.Client)
-	d.DB.Where("id = ?", id).Find(client)
-	if client.ID == id {
-		return client
+	err := d.DB.Where("id = ?", id).Find(client).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if client.ID == id {
+		return client, err
+	}
+	return nil, err
 }

 // GetClientByToken returns the client for the given token or nil.
-func (d *GormDatabase) GetClientByToken(token string) *model.Client {
+func (d *GormDatabase) GetClientByToken(token string) (*model.Client, error) {
 	client := new(model.Client)
-	d.DB.Where("token = ?", token).Find(client)
-	if client.Token == token {
-		return client
+	err := d.DB.Where("token = ?", token).Find(client).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if client.Token == token {
+		return client, err
+	}
+	return nil, err
 }

 // CreateClient creates a client.
@@ -28,10 +37,13 @@ func (d *GormDatabase) CreateClient(client *model.Client) error {
 }

 // GetClientsByUser returns all clients from a user.
-func (d *GormDatabase) GetClientsByUser(userID uint) []*model.Client {
+func (d *GormDatabase) GetClientsByUser(userID uint) ([]*model.Client, error) {
 	var clients []*model.Client
-	d.DB.Where("user_id = ?", userID).Find(&clients)
-	return clients
+	err := d.DB.Where("user_id = ?", userID).Find(&clients).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+	}
+	return clients, err
 }

 // DeleteClientByID deletes a client by its id.
--- a/database/client_test.go
+++ b/database/client_test.go
@@ -6,38 +6,51 @@ import (
 )

 func (s *DatabaseSuite) TestClient() {
-	assert.Nil(s.T(), s.db.GetClientByID(1), "not existing client")
-	assert.Nil(s.T(), s.db.GetClientByToken("asdasd"), "not existing client")
+	if client, err := s.db.GetClientByID(1); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), client, "not existing client")
+	}
+	if client, err := s.db.GetClientByToken("asdasd"); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), client, "not existing client")
+	}

 	user := &model.User{Name: "test", Pass: []byte{1}}
 	s.db.CreateUser(user)
 	assert.NotEqual(s.T(), 0, user.ID)

-	clients := s.db.GetClientsByUser(user.ID)
-	assert.Empty(s.T(), clients)
+	if clients, err := s.db.GetClientsByUser(user.ID); assert.NoError(s.T(), err) {
+		assert.Empty(s.T(), clients)
+	}

 	client := &model.Client{UserID: user.ID, Token: "C0000000000", Name: "android"}
-	s.db.CreateClient(client)
+	assert.NoError(s.T(), s.db.CreateClient(client))

-	clients = s.db.GetClientsByUser(user.ID)
-	assert.Len(s.T(), clients, 1)
-	assert.Contains(s.T(), clients, client)
+	if clients, err := s.db.GetClientsByUser(user.ID); assert.NoError(s.T(), err) {
+		assert.Len(s.T(), clients, 1)
+		assert.Contains(s.T(), clients, client)
+	}

-	newClient := s.db.GetClientByID(client.ID)
-	assert.Equal(s.T(), client, newClient)
+	newClient, err := s.db.GetClientByID(client.ID)
+	if assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), client, newClient)
+	}

-	newClient = s.db.GetClientByToken(client.Token)
-	assert.Equal(s.T(), client, newClient)
+	if newClient, err := s.db.GetClientByToken(client.Token); assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), client, newClient)
+	}

 	updateClient := &model.Client{ID: client.ID, UserID: user.ID, Token: "C0000000000", Name: "new_name"}
 	s.db.UpdateClient(updateClient)
-	updatedClient := s.db.GetClientByID(client.ID)
-	assert.Equal(s.T(), updateClient, updatedClient)
+	if updatedClient, err := s.db.GetClientByID(client.ID); assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), updateClient, updatedClient)
+	}

 	s.db.DeleteClientByID(client.ID)

-	clients = s.db.GetClientsByUser(user.ID)
-	assert.Empty(s.T(), clients)
+	if clients, err := s.db.GetClientsByUser(user.ID); assert.NoError(s.T(), err) {
+		assert.Empty(s.T(), clients)
+	}

-	assert.Nil(s.T(), s.db.GetClientByID(client.ID))
+	if client, err := s.db.GetClientByID(client.ID); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), client)
+	}
 }
--- a/database/message.go
+++ b/database/message.go
@@ -2,16 +2,20 @@ package database

 import (
 	"github.com/gotify/server/model"
+	"github.com/jinzhu/gorm"
 )

 // GetMessageByID returns the messages for the given id or nil.
-func (d *GormDatabase) GetMessageByID(id uint) *model.Message {
+func (d *GormDatabase) GetMessageByID(id uint) (*model.Message, error) {
 	msg := new(model.Message)
-	d.DB.Find(msg, id)
-	if msg.ID == id {
-		return msg
+	err := d.DB.Find(msg, id).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if msg.ID == id {
+		return msg, err
+	}
+	return nil, err
 }

 // CreateMessage creates a message.
@@ -20,43 +24,55 @@ func (d *GormDatabase) CreateMessage(message *model.Message) error {
 }

 // GetMessagesByUser returns all messages from a user.
-func (d *GormDatabase) GetMessagesByUser(userID uint) []*model.Message {
+func (d *GormDatabase) GetMessagesByUser(userID uint) ([]*model.Message, error) {
 	var messages []*model.Message
-	d.DB.Joins("JOIN applications ON applications.user_id = ?", userID).
-		Where("messages.application_id = applications.id").Order("id desc").Find(&messages)
-	return messages
+	err := d.DB.Joins("JOIN applications ON applications.user_id = ?", userID).
+		Where("messages.application_id = applications.id").Order("id desc").Find(&messages).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+	}
+	return messages, err
 }

 // GetMessagesByUserSince returns limited messages from a user.
 // If since is 0 it will be ignored.
-func (d *GormDatabase) GetMessagesByUserSince(userID uint, limit int, since uint) []*model.Message {
+func (d *GormDatabase) GetMessagesByUserSince(userID uint, limit int, since uint) ([]*model.Message, error) {
 	var messages []*model.Message
 	db := d.DB.Joins("JOIN applications ON applications.user_id = ?", userID).
 		Where("messages.application_id = applications.id").Order("id desc").Limit(limit)
 	if since != 0 {
 		db = db.Where("messages.id < ?", since)
 	}
-	db.Find(&messages)
-	return messages
+	err := db.Find(&messages).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+	}
+	return messages, err
 }

 // GetMessagesByApplication returns all messages from an application.
-func (d *GormDatabase) GetMessagesByApplication(tokenID uint) []*model.Message {
+func (d *GormDatabase) GetMessagesByApplication(tokenID uint) ([]*model.Message, error) {
 	var messages []*model.Message
-	d.DB.Where("application_id = ?", tokenID).Order("id desc").Find(&messages)
-	return messages
+	err := d.DB.Where("application_id = ?", tokenID).Order("id desc").Find(&messages).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+	}
+	return messages, err
 }

 // GetMessagesByApplicationSince returns limited messages from an application.
 // If since is 0 it will be ignored.
-func (d *GormDatabase) GetMessagesByApplicationSince(appID uint, limit int, since uint) []*model.Message {
+func (d *GormDatabase) GetMessagesByApplicationSince(appID uint, limit int, since uint) ([]*model.Message, error) {
 	var messages []*model.Message
 	db := d.DB.Where("application_id = ?", appID).Order("id desc").Limit(limit)
 	if since != 0 {
 		db = db.Where("messages.id < ?", since)
 	}
-	db.Find(&messages)
-	return messages
+	err := db.Find(&messages).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+	}
+	return messages, err
 }

 // DeleteMessageByID deletes a message by its id.
@@ -71,7 +87,8 @@ func (d *GormDatabase) DeleteMessagesByApplication(applicationID uint) error {

 // DeleteMessagesByUser deletes all messages from a user.
 func (d *GormDatabase) DeleteMessagesByUser(userID uint) error {
-	for _, app := range d.GetApplicationsByUser(userID) {
+	app, _ := d.GetApplicationsByUser(userID)
+	for _, app := range app {
 		d.DeleteMessagesByApplication(app.ID)
 	}
 	return nil
--- a/database/message_test.go
+++ b/database/message_test.go
@@ -6,10 +6,13 @@ import (

 	"github.com/gotify/server/model"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func (s *DatabaseSuite) TestMessage() {
-	assert.Nil(s.T(), s.db.GetMessageByID(5), "not existing message")
+	messages, err := s.db.GetMessageByID(5)
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), messages, "not existing message")

 	user := &model.User{Name: "test", Pass: []byte{1}}
 	s.db.CreateUser(user)
@@ -19,116 +22,140 @@ func (s *DatabaseSuite) TestMessage() {
 	s.db.CreateApplication(backupServer)
 	assert.NotEqual(s.T(), 0, backupServer.ID)

-	msgs := s.db.GetMessagesByUser(user.ID)
+	msgs, err := s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
 	assert.Empty(s.T(), msgs)
-	msgs = s.db.GetMessagesByApplication(backupServer.ID)
+
+	msgs, err = s.db.GetMessagesByApplication(backupServer.ID)
+	require.NoError(s.T(), err)
 	assert.Empty(s.T(), msgs)

 	backupdone := &model.Message{ApplicationID: backupServer.ID, Message: "backup done", Title: "backup", Priority: 1, Date: time.Now()}
-	s.db.CreateMessage(backupdone)
+	require.NoError(s.T(), s.db.CreateMessage(backupdone))
 	assert.NotEqual(s.T(), 0, backupdone.ID)

-	assertEquals(s.T(), s.db.GetMessageByID(backupdone.ID), backupdone)
+	messages, err = s.db.GetMessageByID(backupdone.ID)
+	require.NoError(s.T(), err)
+	assertEquals(s.T(), messages, backupdone)

-	msgs = s.db.GetMessagesByUser(user.ID)
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 1)
 	assertEquals(s.T(), msgs[0], backupdone)

-	msgs = s.db.GetMessagesByApplication(backupServer.ID)
+	msgs, err = s.db.GetMessagesByApplication(backupServer.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 1)
 	assertEquals(s.T(), msgs[0], backupdone)

 	loginServer := &model.Application{UserID: user.ID, Token: "A0000000001", Name: "loginserver"}
-	s.db.CreateApplication(loginServer)
+	require.NoError(s.T(), s.db.CreateApplication(loginServer))
 	assert.NotEqual(s.T(), 0, loginServer.ID)

 	logindone := &model.Message{ApplicationID: loginServer.ID, Message: "login done", Title: "login", Priority: 1, Date: time.Now()}
-	s.db.CreateMessage(logindone)
+	require.NoError(s.T(), s.db.CreateMessage(logindone))
 	assert.NotEqual(s.T(), 0, logindone.ID)

-	msgs = s.db.GetMessagesByUser(user.ID)
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 2)
 	assertEquals(s.T(), msgs[0], logindone)
 	assertEquals(s.T(), msgs[1], backupdone)

-	msgs = s.db.GetMessagesByApplication(backupServer.ID)
+	msgs, err = s.db.GetMessagesByApplication(backupServer.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 1)
 	assertEquals(s.T(), msgs[0], backupdone)

 	loginfailed := &model.Message{ApplicationID: loginServer.ID, Message: "login failed", Title: "login", Priority: 1, Date: time.Now()}
-	s.db.CreateMessage(loginfailed)
+	require.NoError(s.T(), s.db.CreateMessage(loginfailed))
 	assert.NotEqual(s.T(), 0, loginfailed.ID)

-	msgs = s.db.GetMessagesByApplication(backupServer.ID)
+	msgs, err = s.db.GetMessagesByApplication(backupServer.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 1)
 	assertEquals(s.T(), msgs[0], backupdone)

-	msgs = s.db.GetMessagesByApplication(loginServer.ID)
+	msgs, err = s.db.GetMessagesByApplication(loginServer.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 2)
 	assertEquals(s.T(), msgs[0], loginfailed)
 	assertEquals(s.T(), msgs[1], logindone)

-	msgs = s.db.GetMessagesByUser(user.ID)
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 3)
 	assertEquals(s.T(), msgs[0], loginfailed)
 	assertEquals(s.T(), msgs[1], logindone)
 	assertEquals(s.T(), msgs[2], backupdone)

 	backupfailed := &model.Message{ApplicationID: backupServer.ID, Message: "backup failed", Title: "backup", Priority: 1, Date: time.Now()}
-	s.db.CreateMessage(backupfailed)
+	require.NoError(s.T(), s.db.CreateMessage(backupfailed))
 	assert.NotEqual(s.T(), 0, backupfailed.ID)

-	msgs = s.db.GetMessagesByUser(user.ID)
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 4)
 	assertEquals(s.T(), msgs[0], backupfailed)
 	assertEquals(s.T(), msgs[1], loginfailed)
 	assertEquals(s.T(), msgs[2], logindone)
 	assertEquals(s.T(), msgs[3], backupdone)

-	msgs = s.db.GetMessagesByApplication(loginServer.ID)
+	msgs, err = s.db.GetMessagesByApplication(loginServer.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 2)
 	assertEquals(s.T(), msgs[0], loginfailed)
 	assertEquals(s.T(), msgs[1], logindone)

-	s.db.DeleteMessagesByApplication(loginServer.ID)
-	assert.Empty(s.T(), s.db.GetMessagesByApplication(loginServer.ID))
+	require.NoError(s.T(), s.db.DeleteMessagesByApplication(loginServer.ID))
+	msgs, err = s.db.GetMessagesByApplication(loginServer.ID)
+	require.NoError(s.T(), err)
+	assert.Empty(s.T(), msgs)

-	msgs = s.db.GetMessagesByUser(user.ID)
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 2)
 	assertEquals(s.T(), msgs[0], backupfailed)
 	assertEquals(s.T(), msgs[1], backupdone)

 	logindone = &model.Message{ApplicationID: loginServer.ID, Message: "login done", Title: "login", Priority: 1, Date: time.Now()}
-	s.db.CreateMessage(logindone)
+	require.NoError(s.T(), s.db.CreateMessage(logindone))
 	assert.NotEqual(s.T(), 0, logindone.ID)

-	msgs = s.db.GetMessagesByUser(user.ID)
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 3)
 	assertEquals(s.T(), msgs[0], logindone)
 	assertEquals(s.T(), msgs[1], backupfailed)
 	assertEquals(s.T(), msgs[2], backupdone)

 	s.db.DeleteMessagesByUser(user.ID)
-	assert.Empty(s.T(), s.db.GetMessagesByUser(user.ID))
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
+	assert.Empty(s.T(), msgs)

 	logout := &model.Message{ApplicationID: loginServer.ID, Message: "logout success", Title: "logout", Priority: 1, Date: time.Now()}
 	s.db.CreateMessage(logout)
-	msgs = s.db.GetMessagesByUser(user.ID)
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), msgs, 1)
 	assertEquals(s.T(), msgs[0], logout)

-	s.db.DeleteMessageByID(logout.ID)
-	assert.Empty(s.T(), s.db.GetMessagesByUser(user.ID))
+	require.NoError(s.T(), s.db.DeleteMessageByID(logout.ID))
+	msgs, err = s.db.GetMessagesByUser(user.ID)
+	require.NoError(s.T(), err)
+	assert.Empty(s.T(), msgs)
+
 }

 func (s *DatabaseSuite) TestGetMessagesSince() {
 	user := &model.User{Name: "test", Pass: []byte{1}}
-	s.db.CreateUser(user)
+	require.NoError(s.T(), s.db.CreateUser(user))

 	app := &model.Application{UserID: user.ID, Token: "A0000000000"}
 	app2 := &model.Application{UserID: user.ID, Token: "A0000000001"}
-	s.db.CreateApplication(app)
-	s.db.CreateApplication(app2)
+	require.NoError(s.T(), s.db.CreateApplication(app))
+	require.NoError(s.T(), s.db.CreateApplication(app2))

 	curDate := time.Now()
 	for i := 1; i <= 500; i++ {
@@ -136,53 +163,66 @@ func (s *DatabaseSuite) TestGetMessagesSince() {
 		s.db.CreateMessage(&model.Message{ApplicationID: app2.ID, Message: "abc", Date: curDate.Add(time.Duration(i) * time.Second)})
 	}

-	actual := s.db.GetMessagesByUserSince(user.ID, 50, 0)
+	actual, err := s.db.GetMessagesByUserSince(user.ID, 50, 0)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 1000, 951, 1)

-	actual = s.db.GetMessagesByUserSince(user.ID, 50, 951)
+	actual, err = s.db.GetMessagesByUserSince(user.ID, 50, 951)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 950, 901, 1)

-	actual = s.db.GetMessagesByUserSince(user.ID, 100, 951)
+	actual, err = s.db.GetMessagesByUserSince(user.ID, 100, 951)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 100)
 	hasIDInclusiveBetween(s.T(), actual, 950, 851, 1)

-	actual = s.db.GetMessagesByUserSince(user.ID, 100, 51)
+	actual, err = s.db.GetMessagesByUserSince(user.ID, 100, 51)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 50, 1, 1)

-	actual = s.db.GetMessagesByApplicationSince(app.ID, 50, 0)
+	actual, err = s.db.GetMessagesByApplicationSince(app.ID, 50, 0)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 999, 901, 2)

-	actual = s.db.GetMessagesByApplicationSince(app.ID, 50, 901)
+	actual, err = s.db.GetMessagesByApplicationSince(app.ID, 50, 901)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 899, 801, 2)

-	actual = s.db.GetMessagesByApplicationSince(app.ID, 100, 666)
+	actual, err = s.db.GetMessagesByApplicationSince(app.ID, 100, 666)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 100)
 	hasIDInclusiveBetween(s.T(), actual, 665, 467, 2)

-	actual = s.db.GetMessagesByApplicationSince(app.ID, 100, 101)
+	actual, err = s.db.GetMessagesByApplicationSince(app.ID, 100, 101)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 99, 1, 2)

-	actual = s.db.GetMessagesByApplicationSince(app2.ID, 50, 0)
+	actual, err = s.db.GetMessagesByApplicationSince(app2.ID, 50, 0)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 1000, 902, 2)

-	actual = s.db.GetMessagesByApplicationSince(app2.ID, 50, 902)
+	actual, err = s.db.GetMessagesByApplicationSince(app2.ID, 50, 902)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 900, 802, 2)

-	actual = s.db.GetMessagesByApplicationSince(app2.ID, 100, 667)
+	actual, err = s.db.GetMessagesByApplicationSince(app2.ID, 100, 667)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 100)
 	hasIDInclusiveBetween(s.T(), actual, 666, 468, 2)

-	actual = s.db.GetMessagesByApplicationSince(app2.ID, 100, 102)
+	actual, err = s.db.GetMessagesByApplicationSince(app2.ID, 100, 102)
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), actual, 50)
 	hasIDInclusiveBetween(s.T(), actual, 100, 2, 2)
+
 }

 func hasIDInclusiveBetween(t *testing.T, msgs []*model.Message, from, to, decrement int) {
--- a/database/migration_test.go
+++ b/database/migration_test.go
@@ -47,17 +47,25 @@ func (s *MigrationSuite) TestMigration() {
 	assert.True(s.T(), db.DB.HasTable(new(model.Application)))

 	// a user already exist, not adding a new user
-	assert.Nil(s.T(), db.GetUserByName("admin"))
+	if user, err := db.GetUserByName("admin"); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), user)
+	}

 	// the old user should persist
-	assert.Equal(s.T(), true, db.GetUserByName("test_user").Admin)
+	if user, err := db.GetUserByName("test_user"); assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), true, user.Admin)
+	}

 	// we should be able to create applications
-	assert.Nil(s.T(), db.CreateApplication(&model.Application{
-		Token:       "A1234",
-		UserID:      db.GetUserByName("test_user").ID,
-		Description: "this is a test application",
-		Name:        "test application",
-	}))
-	assert.Equal(s.T(), "test application", db.GetApplicationByToken("A1234").Name)
+	if user, err := db.GetUserByName("test_user"); assert.NoError(s.T(), err) {
+		assert.Nil(s.T(), db.CreateApplication(&model.Application{
+			Token:       "A1234",
+			UserID:      user.ID,
+			Description: "this is a test application",
+			Name:        "test application",
+		}))
+	}
+	if app, err := db.GetApplicationByToken("A1234"); assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), "test application", app.Name)
+	}
 }
--- a/database/plugin.go
+++ b/database/plugin.go
@@ -2,33 +2,43 @@ package database

 import (
 	"github.com/gotify/server/model"
+	"github.com/jinzhu/gorm"
 )

 // GetPluginConfByUser gets plugin configurations from a user
-func (d *GormDatabase) GetPluginConfByUser(userid uint) []*model.PluginConf {
+func (d *GormDatabase) GetPluginConfByUser(userid uint) ([]*model.PluginConf, error) {
 	var plugins []*model.PluginConf
-	d.DB.Where("user_id = ?", userid).Find(&plugins)
-	return plugins
+	err := d.DB.Where("user_id = ?", userid).Find(&plugins).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
+	}
+	return plugins, err
 }

 // GetPluginConfByUserAndPath gets plugin configuration by user and file name
-func (d *GormDatabase) GetPluginConfByUserAndPath(userid uint, path string) *model.PluginConf {
+func (d *GormDatabase) GetPluginConfByUserAndPath(userid uint, path string) (*model.PluginConf, error) {
 	plugin := new(model.PluginConf)
-	d.DB.Where("user_id = ? AND module_path = ?", userid, path).First(plugin)
-	if plugin.ModulePath == path {
-		return plugin
+	err := d.DB.Where("user_id = ? AND module_path = ?", userid, path).First(plugin).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if plugin.ModulePath == path {
+		return plugin, err
+	}
+	return nil, err
 }

 // GetPluginConfByApplicationID gets plugin configuration by its internal appid.
-func (d *GormDatabase) GetPluginConfByApplicationID(appid uint) *model.PluginConf {
+func (d *GormDatabase) GetPluginConfByApplicationID(appid uint) (*model.PluginConf, error) {
 	plugin := new(model.PluginConf)
-	d.DB.Where("application_id = ?", appid).First(plugin)
-	if plugin.ApplicationID == appid {
-		return plugin
+	err := d.DB.Where("application_id = ?", appid).First(plugin).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if plugin.ApplicationID == appid {
+		return plugin, err
+	}
+	return nil, err
 }

 // CreatePluginConf creates a new plugin configuration
@@ -37,23 +47,29 @@ func (d *GormDatabase) CreatePluginConf(p *model.PluginConf) error {
 }

 // GetPluginConfByToken gets plugin configuration by plugin token
-func (d *GormDatabase) GetPluginConfByToken(token string) *model.PluginConf {
+func (d *GormDatabase) GetPluginConfByToken(token string) (*model.PluginConf, error) {
 	plugin := new(model.PluginConf)
-	d.DB.Where("token = ?", token).First(plugin)
-	if plugin.Token == token {
-		return plugin
+	err := d.DB.Where("token = ?", token).First(plugin).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if plugin.Token == token {
+		return plugin, err
+	}
+	return nil, err
 }

 // GetPluginConfByID gets plugin configuration by plugin ID
-func (d *GormDatabase) GetPluginConfByID(id uint) *model.PluginConf {
+func (d *GormDatabase) GetPluginConfByID(id uint) (*model.PluginConf, error) {
 	plugin := new(model.PluginConf)
-	d.DB.Where("id = ?", id).First(plugin)
-	if plugin.ID == id {
-		return plugin
+	err := d.DB.Where("id = ?", id).First(plugin).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if plugin.ID == id {
+		return plugin, err
+	}
+	return nil, err
 }

 // UpdatePluginConf updates plugin configuration
--- a/database/plugin_test.go
+++ b/database/plugin_test.go
@@ -3,6 +3,7 @@ package database
 import (
 	"github.com/gotify/server/model"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func (s *DatabaseSuite) TestPluginConf() {
@@ -18,23 +19,53 @@ func (s *DatabaseSuite) TestPluginConf() {
 	assert.Nil(s.T(), s.db.CreatePluginConf(&plugin))

 	assert.Equal(s.T(), uint(1), plugin.ID)
-	assert.Equal(s.T(), "Pabc", s.db.GetPluginConfByUserAndPath(1, "github.com/gotify/example-plugin").Token)
-	assert.Equal(s.T(), true, s.db.GetPluginConfByToken("Pabc").Enabled)
-	assert.Equal(s.T(), "Pabc", s.db.GetPluginConfByApplicationID(2).Token)
-	assert.Equal(s.T(), "github.com/gotify/example-plugin", s.db.GetPluginConfByID(1).ModulePath)
+	pluginConf, err := s.db.GetPluginConfByUserAndPath(1, "github.com/gotify/example-plugin")
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), "Pabc", pluginConf.Token)

-	assert.Nil(s.T(), s.db.GetPluginConfByToken("Pnotexist"))
-	assert.Nil(s.T(), s.db.GetPluginConfByID(12))
-	assert.Nil(s.T(), s.db.GetPluginConfByUserAndPath(1, "not/exist"))
-	assert.Nil(s.T(), s.db.GetPluginConfByApplicationID(99))
+	pluginConf, err = s.db.GetPluginConfByToken("Pabc")
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), true, pluginConf.Enabled)

-	assert.Len(s.T(), s.db.GetPluginConfByUser(1), 1)
-	assert.Len(s.T(), s.db.GetPluginConfByUser(0), 0)
+	pluginConf, err = s.db.GetPluginConfByApplicationID(2)
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), "Pabc", pluginConf.Token)
+
+	pluginConf, err = s.db.GetPluginConfByID(1)
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), "github.com/gotify/example-plugin", pluginConf.ModulePath)
+
+	pluginConf, err = s.db.GetPluginConfByToken("Pnotexist")
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), pluginConf)
+
+	pluginConf, err = s.db.GetPluginConfByID(12)
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), pluginConf)
+
+	pluginConf, err = s.db.GetPluginConfByUserAndPath(1, "not/exist")
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), pluginConf)
+
+	pluginConf, err = s.db.GetPluginConfByApplicationID(99)
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), pluginConf)
+
+	pluginConfs, err := s.db.GetPluginConfByUser(1)
+	require.NoError(s.T(), err)
+	assert.Len(s.T(), pluginConfs, 1)
+
+	pluginConfs, err = s.db.GetPluginConfByUser(0)
+	require.NoError(s.T(), err)
+	assert.Len(s.T(), pluginConfs, 0)

 	testConf := `{"test_config_key":"hello"}`
 	plugin.Enabled = false
 	plugin.Config = []byte(testConf)
 	assert.Nil(s.T(), s.db.UpdatePluginConf(&plugin))
-	assert.Equal(s.T(), false, s.db.GetPluginConfByToken("Pabc").Enabled)
-	assert.Equal(s.T(), testConf, string(s.db.GetPluginConfByToken("Pabc").Config))
+	pluginConf, err = s.db.GetPluginConfByToken("Pabc")
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), false, pluginConf.Enabled)
+	assert.Equal(s.T(), testConf, string(pluginConf.Config))
+
 }
--- a/database/user.go
+++ b/database/user.go
@@ -2,30 +2,37 @@ package database

 import (
 	"github.com/gotify/server/model"
+	"github.com/jinzhu/gorm"
 )

 // GetUserByName returns the user by the given name or nil.
-func (d *GormDatabase) GetUserByName(name string) *model.User {
+func (d *GormDatabase) GetUserByName(name string) (*model.User, error) {
 	user := new(model.User)
-	d.DB.Where("name = ?", name).Find(user)
-	if user.Name == name {
-		return user
+	err := d.DB.Where("name = ?", name).Find(user).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if user.Name == name {
+		return user, err
+	}
+	return nil, err
 }

 // GetUserByID returns the user by the given id or nil.
-func (d *GormDatabase) GetUserByID(id uint) *model.User {
+func (d *GormDatabase) GetUserByID(id uint) (*model.User, error) {
 	user := new(model.User)
-	d.DB.Find(user, id)
-	if user.ID == id {
-		return user
+	err := d.DB.Find(user, id).Error
+	if err == gorm.ErrRecordNotFound {
+		err = nil
 	}
-	return nil
+	if user.ID == id {
+		return user, err
+	}
+	return nil, err
 }

 // CountUser returns the user count which satisfies the given condition.
-func (d *GormDatabase) CountUser(condition ...interface{}) int {
+func (d *GormDatabase) CountUser(condition ...interface{}) (int, error) {
 	c := -1
 	handle := d.DB.Model(new(model.User))
 	if len(condition) == 1 {
@@ -33,34 +40,37 @@ func (d *GormDatabase) CountUser(condition ...interface{}) int {
 	} else if len(condition) > 1 {
 		handle = handle.Where(condition[0], condition[1:]...)
 	}
-	handle.Count(&c)
-	return c
+	err := handle.Count(&c).Error
+	return c, err
 }

 // GetUsers returns all users.
-func (d *GormDatabase) GetUsers() []*model.User {
+func (d *GormDatabase) GetUsers() ([]*model.User, error) {
 	var users []*model.User
-	d.DB.Find(&users)
-	return users
+	err := d.DB.Find(&users).Error
+	return users, err
 }

 // DeleteUserByID deletes a user by its id.
 func (d *GormDatabase) DeleteUserByID(id uint) error {
-	for _, app := range d.GetApplicationsByUser(id) {
+	apps, _ := d.GetApplicationsByUser(id)
+	for _, app := range apps {
 		d.DeleteApplicationByID(app.ID)
 	}
-	for _, client := range d.GetClientsByUser(id) {
+	clients, _ := d.GetClientsByUser(id)
+	for _, client := range clients {
 		d.DeleteClientByID(client.ID)
 	}
-	for _, conf := range d.GetPluginConfByUser(id) {
+	pluginConfs, _ := d.GetPluginConfByUser(id)
+	for _, conf := range pluginConfs {
 		d.DeletePluginConfByID(conf.ID)
 	}
 	return d.DB.Where("id = ?", id).Delete(&model.User{}).Error
 }

 // UpdateUser updates a user.
-func (d *GormDatabase) UpdateUser(user *model.User) {
-	d.DB.Save(user)
+func (d *GormDatabase) UpdateUser(user *model.User) error {
+	return d.DB.Save(user).Error
 }

 // CreateUser creates a user.
--- a/database/user_test.go
+++ b/database/user_test.go
@@ -3,28 +3,44 @@ package database
 import (
 	"github.com/gotify/server/model"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 func (s *DatabaseSuite) TestUser() {
-	assert.Nil(s.T(), s.db.GetUserByID(55), "not existing user")
-	assert.Nil(s.T(), s.db.GetUserByName("nicories"), "not existing user")
+	user, err := s.db.GetUserByID(55)
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), user, "not existing user")

-	jmattheis := s.db.GetUserByID(1)
+	user, err = s.db.GetUserByName("nicories")
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), user, "not existing user")
+
+	jmattheis, err := s.db.GetUserByID(1)
+	require.NoError(s.T(), err)
 	assert.NotNil(s.T(), jmattheis, "on bootup the first user should be automatically created")
-	assert.Equal(s.T(), 1, s.db.CountUser("admin = ?", true), 1, "there is initially one admin")

-	users := s.db.GetUsers()
+	adminCount, err := s.db.CountUser("admin = ?", true)
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), 1, adminCount, 1, "there is initially one admin")
+
+	users, err := s.db.GetUsers()
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), users, 1)
 	assert.Contains(s.T(), users, jmattheis)

 	nicories := &model.User{Name: "nicories", Pass: []byte{1, 2, 3, 4}, Admin: false}
 	s.db.CreateUser(nicories)
 	assert.NotEqual(s.T(), 0, nicories.ID, "on create user a new id should be assigned")
-	assert.Equal(s.T(), 2, s.db.CountUser(), "two users should exist")
+	userCount, err := s.db.CountUser()
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), 2, userCount, "two users should exist")

-	assert.Equal(s.T(), nicories, s.db.GetUserByName("nicories"))
+	user, err = s.db.GetUserByName("nicories")
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), nicories, user)

-	users = s.db.GetUsers()
+	users, err = s.db.GetUsers()
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), users, 2)
 	assert.Contains(s.T(), users, jmattheis)
 	assert.Contains(s.T(), users, nicories)
@@ -32,73 +48,138 @@ func (s *DatabaseSuite) TestUser() {
 	nicories.Name = "tom"
 	nicories.Pass = []byte{12}
 	nicories.Admin = true
-	s.db.UpdateUser(nicories)
-	tom := s.db.GetUserByID(nicories.ID)
-	assert.Equal(s.T(), &model.User{ID: nicories.ID, Name: "tom", Pass: []byte{12}, Admin: true}, tom)
-	users = s.db.GetUsers()
-	assert.Len(s.T(), users, 2)
-	assert.Equal(s.T(), 2, s.db.CountUser(&model.User{Admin: true}), "two admins exist")
+	require.NoError(s.T(), s.db.UpdateUser(nicories))

-	s.db.DeleteUserByID(tom.ID)
-	users = s.db.GetUsers()
+	tom, err := s.db.GetUserByID(nicories.ID)
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), &model.User{ID: nicories.ID, Name: "tom", Pass: []byte{12}, Admin: true}, tom)
+
+	users, err = s.db.GetUsers()
+	require.NoError(s.T(), err)
+	assert.Len(s.T(), users, 2)
+
+	adminCount, err = s.db.CountUser(&model.User{Admin: true})
+	require.NoError(s.T(), err)
+	assert.Equal(s.T(), 2, adminCount, "two admins exist")
+
+	require.NoError(s.T(), s.db.DeleteUserByID(tom.ID))
+	users, err = s.db.GetUsers()
+	require.NoError(s.T(), err)
 	assert.Len(s.T(), users, 1)
 	assert.Contains(s.T(), users, jmattheis)

 	s.db.DeleteUserByID(jmattheis.ID)
-	users = s.db.GetUsers()
+	users, err = s.db.GetUsers()
+	require.NoError(s.T(), err)
 	assert.Empty(s.T(), users)
+
 }

 func (s *DatabaseSuite) TestUserPlugins() {
-	s.db.CreateUser(&model.User{Name: "geek", ID: 16})
-	s.db.CreatePluginConf(&model.PluginConf{
-		UserID:     s.db.GetUserByName("geek").ID,
-		ModulePath: "github.com/gotify/example-plugin",
-		Token:      "P1234",
-		Enabled:    true,
-	})
-	s.db.CreatePluginConf(&model.PluginConf{
-		UserID:     s.db.GetUserByName("geek").ID,
-		ModulePath: "github.com/gotify/example-plugin/v2",
-		Token:      "P5678",
-		Enabled:    true,
-	})
+	assert.NoError(s.T(), s.db.CreateUser(&model.User{Name: "geek", ID: 16}))
+	if geekUser, err := s.db.GetUserByName("geek"); assert.NoError(s.T(), err) {
+		s.db.CreatePluginConf(&model.PluginConf{
+			UserID:     geekUser.ID,
+			ModulePath: "github.com/gotify/example-plugin",
+			Token:      "P1234",
+			Enabled:    true,
+		})
+		s.db.CreatePluginConf(&model.PluginConf{
+			UserID:     geekUser.ID,
+			ModulePath: "github.com/gotify/example-plugin/v2",
+			Token:      "P5678",
+			Enabled:    true,
+		})
+	}

-	assert.Len(s.T(), s.db.GetPluginConfByUser(s.db.GetUserByName("geek").ID), 2)
-	assert.Equal(s.T(), "github.com/gotify/example-plugin", s.db.GetPluginConfByToken("P1234").ModulePath)
+	if geekUser, err := s.db.GetUserByName("geek"); assert.NoError(s.T(), err) {
+		if pluginConfs, err := s.db.GetPluginConfByUser(geekUser.ID); assert.NoError(s.T(), err) {
+			assert.Len(s.T(), pluginConfs, 2)
+		}
+	}
+	if pluginConf, err := s.db.GetPluginConfByToken("P1234"); assert.NoError(s.T(), err) {
+		assert.Equal(s.T(), "github.com/gotify/example-plugin", pluginConf.ModulePath)
+	}

 }

 func (s *DatabaseSuite) TestDeleteUserDeletesApplicationsAndClientsAndPluginConfs() {
-	s.db.CreateUser(&model.User{Name: "nicories", ID: 10})
-	s.db.CreateApplication(&model.Application{ID: 100, Token: "apptoken", UserID: 10})
-	s.db.CreateMessage(&model.Message{ID: 1000, ApplicationID: 100})
-	s.db.CreateClient(&model.Client{ID: 10000, Token: "clienttoken", UserID: 10})
-	s.db.CreatePluginConf(&model.PluginConf{ID: 1000, Token: "plugintoken", UserID: 10})
+	require.NoError(s.T(), s.db.CreateUser(&model.User{Name: "nicories", ID: 10}))
+	require.NoError(s.T(), s.db.CreateApplication(&model.Application{ID: 100, Token: "apptoken", UserID: 10}))
+	require.NoError(s.T(), s.db.CreateMessage(&model.Message{ID: 1000, ApplicationID: 100}))
+	require.NoError(s.T(), s.db.CreateClient(&model.Client{ID: 10000, Token: "clienttoken", UserID: 10}))
+	require.NoError(s.T(), s.db.CreatePluginConf(&model.PluginConf{ID: 1000, Token: "plugintoken", UserID: 10}))

-	s.db.CreateUser(&model.User{Name: "nicories2", ID: 20})
-	s.db.CreateApplication(&model.Application{ID: 200, Token: "apptoken2", UserID: 20})
-	s.db.CreateMessage(&model.Message{ID: 2000, ApplicationID: 200})
-	s.db.CreateClient(&model.Client{ID: 20000, Token: "clienttoken2", UserID: 20})
-	s.db.CreatePluginConf(&model.PluginConf{ID: 2000, Token: "plugintoken2", UserID: 20})
+	require.NoError(s.T(), s.db.CreateUser(&model.User{Name: "nicories2", ID: 20}))
+	require.NoError(s.T(), s.db.CreateApplication(&model.Application{ID: 200, Token: "apptoken2", UserID: 20}))
+	require.NoError(s.T(), s.db.CreateMessage(&model.Message{ID: 2000, ApplicationID: 200}))
+	require.NoError(s.T(), s.db.CreateClient(&model.Client{ID: 20000, Token: "clienttoken2", UserID: 20}))
+	require.NoError(s.T(), s.db.CreatePluginConf(&model.PluginConf{ID: 2000, Token: "plugintoken2", UserID: 20}))

-	s.db.DeleteUserByID(10)
+	require.NoError(s.T(), s.db.DeleteUserByID(10))

-	assert.Nil(s.T(), s.db.GetApplicationByToken("apptoken"))
-	assert.Nil(s.T(), s.db.GetClientByToken("clienttoken"))
-	assert.Empty(s.T(), s.db.GetClientsByUser(10))
-	assert.Empty(s.T(), s.db.GetApplicationsByUser(10))
-	assert.Empty(s.T(), s.db.GetMessagesByApplication(100))
-	assert.Empty(s.T(), s.db.GetMessagesByUser(10))
-	assert.Empty(s.T(), s.db.GetPluginConfByUser(10))
-	assert.Nil(s.T(), s.db.GetMessageByID(1000))
+	app, err := s.db.GetApplicationByToken("apptoken")
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), app)
+
+	client, err := s.db.GetClientByToken("clienttoken")
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), client)
+
+	clients, err := s.db.GetClientsByUser(10)
+	require.NoError(s.T(), err)
+	assert.Empty(s.T(), clients)
+
+	apps, err := s.db.GetApplicationsByUser(10)
+	require.NoError(s.T(), err)
+	assert.Empty(s.T(), apps)
+
+	msgs, err := s.db.GetMessagesByApplication(100)
+	require.NoError(s.T(), err)
+	assert.Empty(s.T(), msgs)
+
+	msgs, err = s.db.GetMessagesByUser(10)
+	require.NoError(s.T(), err)
+	assert.Empty(s.T(), msgs)
+
+	pluginConfs, err := s.db.GetPluginConfByUser(10)
+	require.NoError(s.T(), err)
+	assert.Empty(s.T(), pluginConfs)
+
+	msg, err := s.db.GetMessageByID(1000)
+	require.NoError(s.T(), err)
+	assert.Nil(s.T(), msg)
+
+	app, err = s.db.GetApplicationByToken("apptoken2")
+	require.NoError(s.T(), err)
+	assert.NotNil(s.T(), app)
+
+	client, err = s.db.GetClientByToken("clienttoken2")
+	require.NoError(s.T(), err)
+	assert.NotNil(s.T(), client)
+
+	clients, err = s.db.GetClientsByUser(20)
+	require.NoError(s.T(), err)
+	assert.NotEmpty(s.T(), clients)
+
+	apps, err = s.db.GetApplicationsByUser(20)
+	require.NoError(s.T(), err)
+	assert.NotEmpty(s.T(), apps)
+
+	pluginConf, err := s.db.GetPluginConfByUser(20)
+	require.NoError(s.T(), err)
+	assert.NotEmpty(s.T(), pluginConf)
+
+	msgs, err = s.db.GetMessagesByApplication(200)
+	require.NoError(s.T(), err)
+	assert.NotEmpty(s.T(), msgs)
+
+	msgs, err = s.db.GetMessagesByUser(20)
+	require.NoError(s.T(), err)
+	assert.NotEmpty(s.T(), msgs)
+
+	msg, err = s.db.GetMessageByID(2000)
+	require.NoError(s.T(), err)
+	assert.NotNil(s.T(), msg)

-	assert.NotNil(s.T(), s.db.GetApplicationByToken("apptoken2"))
-	assert.NotNil(s.T(), s.db.GetClientByToken("clienttoken2"))
-	assert.NotEmpty(s.T(), s.db.GetClientsByUser(20))
-	assert.NotEmpty(s.T(), s.db.GetApplicationsByUser(20))
-	assert.NotEmpty(s.T(), s.db.GetPluginConfByUser(20))
-	assert.NotEmpty(s.T(), s.db.GetMessagesByApplication(200))
-	assert.NotEmpty(s.T(), s.db.GetMessagesByUser(20))
-	assert.NotNil(s.T(), s.db.GetMessageByID(2000))
 }