diff --git a/README.md b/README.md
index 4640bec6..54bd3533 100644
--- a/README.md
+++ b/README.md
@@ -11,12 +11,10 @@ An easy to use Status Page for your websites and applications. Statping will aut
 
 [![GoDoc](https://godoc.org/github.com/golang/gddo?status.svg)](https://godoc.org/github.com/statping/statping) [![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg)](https://gitter.im/statping/general) [![](https://images.microbadger.com/badges/image/hunterlong/statping.svg)](https://microbadger.com/images/hunterlong/statping) [![Docker Pulls](https://img.shields.io/docker/pulls/hunterlong/statping.svg)](https://hub.docker.com/r/hunterlong/statping/builds/)
 
-## A Future-Proof Status Page
-Statping strives to remain future-proof and remain intact if a failure is created. Your Statping service should not be running on the same instance you're trying to monitor. If your server crashes your Status Page should still remaining online to notify your users of downtime.
+<img align="left" width="320" height="235" src="https://img.cjx.io/statupsiterun.gif">
 
-<p align="center">
-<img width="80%" src="https://img.cjx.io/statupsiterun.gif">
-</p>
+<h2>A Future-Proof Status Page</h2>
+Statping strives to remain future-proof and remain intact if a failure is created. Your Statping service should not be running on the same instance you're trying to monitor. If your server crashes your Status Page should still remaining online to notify your users of downtime.
 
 ## Lightweight and Fast
 Statping is a very lightweight application and is available for Linux, Mac, and Windows. The Docker image is only ~16Mb so you know that this application won't be filling up your hard drive space.
diff --git a/cmd/main.go b/cmd/main.go
index 7e5231bc..58077b33 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -28,7 +28,6 @@ import (
 	"github.com/statping/statping/source"
 
 	"github.com/pkg/errors"
-	"github.com/statping/statping/database"
 	"github.com/statping/statping/handlers"
 	"github.com/statping/statping/types/configs"
 	"github.com/statping/statping/types/core"
@@ -47,6 +46,8 @@ var (
 	port        int
 	log         = utils.Log.WithField("type", "cmd")
 	httpServer  = make(chan bool)
+
+	confgs *configs.DbConfig
 )
 
 func init() {
@@ -119,29 +120,29 @@ func main() {
 		log.Errorln(err)
 	}
 
-	c, err := configs.LoadConfigs()
+	confgs, err = configs.LoadConfigs()
 	if err != nil {
 		if err := SetupMode(); err != nil {
 			exit(err)
 		}
 	}
 
-	if err = configs.ConnectConfigs(c); err != nil {
+	if err = configs.ConnectConfigs(confgs); err != nil {
 		exit(err)
 	}
 
-	exists := database.DB().HasTable("core")
+	exists := confgs.Db.HasTable("core")
 	if !exists {
 
-		if err := c.DropDatabase(); err != nil {
+		if err := confgs.DropDatabase(); err != nil {
 			exit(errors.Wrap(err, "error dropping database"))
 		}
 
-		if err := configs.CreateDatabase(); err != nil {
+		if err := confgs.CreateDatabase(); err != nil {
 			exit(errors.Wrap(err, "error creating database"))
 		}
 
-		if err := configs.CreateAdminUser(c); err != nil {
+		if err := configs.CreateAdminUser(confgs); err != nil {
 			exit(errors.Wrap(err, "error creating default admin user"))
 		}
 
@@ -151,7 +152,7 @@ func main() {
 
 	}
 
-	if err := c.MigrateDatabase(); err != nil {
+	if err := confgs.MigrateDatabase(); err != nil {
 		exit(err)
 	}
 
@@ -170,7 +171,7 @@ func main() {
 func Close() {
 	sentry.Flush(3 * time.Second)
 	utils.CloseLogs()
-	database.Close()
+	confgs.Close()
 }
 
 func SetupMode() error {
diff --git a/database/database.go b/database/database.go
index a0ceadd0..36a10819 100644
--- a/database/database.go
+++ b/database/database.go
@@ -18,9 +18,7 @@ const (
 	TIME_DAY   = "2006-01-02"
 )
 
-var (
-	database Database
-)
+var database Database
 
 // Database is an interface which DB implements
 type Database interface {
@@ -112,39 +110,35 @@ type Database interface {
 	DbType() string
 }
 
-func DB() Database {
-	return database
-}
-
 func (it *Db) DbType() string {
 	return it.Database.Dialect().GetName()
 }
 
-func Close() error {
-	if database == nil {
+func Close(db Database) error {
+	if db == nil {
 		return nil
 	}
-	return database.Close()
+	return db.Close()
 }
 
-func LogMode(b bool) Database {
-	return database.LogMode(b)
+func LogMode(db Database, b bool) Database {
+	return db.LogMode(b)
 }
 
-func Begin(model interface{}) Database {
+func Begin(db Database, model interface{}) Database {
 	if all, ok := model.(string); ok {
 		if all == "migration" {
-			return database.Begin()
+			return db.Begin()
 		}
 	}
-	return database.Model(model).Begin()
+	return db.Model(model).Begin()
 }
 
-func Available() bool {
-	if database == nil {
+func Available(db Database) bool {
+	if db == nil {
 		return false
 	}
-	if err := database.DB().Ping(); err != nil {
+	if err := db.DB().Ping(); err != nil {
 		return false
 	}
 	return true
@@ -179,11 +173,15 @@ func Openw(dialect string, args ...interface{}) (db Database, err error) {
 	if err != nil {
 		return nil, err
 	}
-	db = Wrap(gormdb)
-	database = db
+	database = Wrap(gormdb)
 	return database, err
 }
 
+func OpenTester() (Database, error) {
+	newDb, err := Openw("sqlite3", ":memory:?cache=shared")
+	return newDb, err
+}
+
 // Wrap wraps gorm.DB in an interface
 func Wrap(db *gorm.DB) Database {
 	return &Db{
diff --git a/database/grouping.go b/database/grouping.go
index 905a5569..86dbdc00 100644
--- a/database/grouping.go
+++ b/database/grouping.go
@@ -50,11 +50,11 @@ var (
 	ByAverage = func(column string, multiplier int) By {
 		switch database.DbType() {
 		case "mysql":
-			return By(fmt.Sprintf("CAST(AVG(%s)*%d as UNSIGNED) as amount", column, multiplier))
+			return By(fmt.Sprintf("CAST(AVG(%s) as UNSIGNED) as amount", column))
 		case "postgres":
-			return By(fmt.Sprintf("cast(AVG(%s)*%d as int) as amount", column, multiplier))
+			return By(fmt.Sprintf("cast(AVG(%s) as int) as amount", column))
 		default:
-			return By(fmt.Sprintf("cast(AVG(%s)*%d as int) as amount", column, multiplier))
+			return By(fmt.Sprintf("cast(AVG(%s) as int) as amount", column))
 		}
 	}
 )
@@ -157,7 +157,7 @@ func ParseQueries(r *http.Request, o isObject) *GroupQuery {
 		limit = 10000
 	}
 
-	db := o.Db()
+	q := o.Db()
 
 	if grouping == "" {
 		grouping = "1h"
@@ -176,7 +176,7 @@ func ParseQueries(r *http.Request, o isObject) *GroupQuery {
 		Limit:     int(limit),
 		Offset:    int(offset),
 		FillEmpty: fill,
-		db:        db,
+		db:        q,
 	}
 
 	if startField == 0 {
@@ -190,18 +190,18 @@ func ParseQueries(r *http.Request, o isObject) *GroupQuery {
 	}
 
 	if query.Limit != 0 {
-		db = db.Limit(query.Limit)
+		q = q.Limit(query.Limit)
 	}
 	if query.Offset > 0 {
-		db = db.Offset(query.Offset)
+		q = q.Offset(query.Offset)
 	}
 
-	db = db.Where("created_at BETWEEN ? AND ?", db.FormatTime(query.Start), db.FormatTime(query.End))
+	q = q.Where("created_at BETWEEN ? AND ?", q.FormatTime(query.Start), q.FormatTime(query.End))
 
 	if query.Order != "" {
-		db = db.Order(query.Order)
+		q = q.Order(query.Order)
 	}
-	query.db = db
+	query.db = q
 
 	return query
 }
diff --git a/database/routines.go b/database/routines.go
index 00c62faa..872c41cb 100644
--- a/database/routines.go
+++ b/database/routines.go
@@ -59,8 +59,8 @@ func databaseMaintence(dur time.Duration) {
 // DeleteAllSince will delete a specific table's records based on a time.
 func DeleteAllSince(table string, date time.Time) {
 	sql := fmt.Sprintf("DELETE FROM %v WHERE created_at < '%v';", table, database.FormatTime(date))
-	db := database.Exec(sql)
-	if db.Error() != nil {
-		log.Warnln(db.Error())
+	q := database.Exec(sql)
+	if q.Error() != nil {
+		log.Warnln(q.Error())
 	}
 }
diff --git a/frontend/src/assets/scss/base.scss b/frontend/src/assets/scss/base.scss
index 97c4883b..8ad831fc 100644
--- a/frontend/src/assets/scss/base.scss
+++ b/frontend/src/assets/scss/base.scss
@@ -5,6 +5,22 @@ HTML,BODY {
     background-color: $background-color;
 }
 
+
+.chartmarker {
+  background-color: white;
+  padding: 5px;
+}
+
+.chartmarker SPAN {
+  font-size: 11pt;
+  display: block;
+  color: #8b8b8b;
+}
+
+.apexcharts-tooltip {
+  box-shadow: none;
+}
+
 .contain-card {
 
   .card-header {
diff --git a/frontend/src/chart_design.js b/frontend/src/chart_design.js
new file mode 100644
index 00000000..e69de29b
diff --git a/frontend/src/components/Service/ServiceChart.vue b/frontend/src/components/Service/ServiceChart.vue
index e7d204ed..5d84dcce 100644
--- a/frontend/src/components/Service/ServiceChart.vue
+++ b/frontend/src/components/Service/ServiceChart.vue
@@ -4,19 +4,20 @@
 
 <script>
   import Api from "../../API"
+  const timeoptions = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric' };
 
   const axisOptions = {
     labels: {
       show: false
     },
     crosshairs: {
-      show: false
+      show: true
     },
     lines: {
       show: false
     },
     tooltip: {
-      enabled: false
+      enabled: true
     },
     axisTicks: {
       show: false
@@ -25,7 +26,7 @@
       show: false
     },
     marker: {
-      show: false
+      show: true
     }
   };
 
@@ -47,6 +48,9 @@
               showing: false,
               data: [],
               chartOptions: {
+                  noData: {
+                      text: 'Loading...'
+                  },
                   chart: {
                       height: 210,
                       width: "100%",
@@ -76,21 +80,47 @@
                           left: -10,
                       }
                   },
+                  dropShadow: {
+                      enabled: false,
+                  },
                   xaxis: {
                       type: "datetime",
-                      ...axisOptions
+                      labels: {
+                          show: false
+                      },
                   },
                   yaxis: {
-                      ...axisOptions
+                      labels: {
+                          show: false
+                      },
                   },
                   tooltip: {
-                      enabled: false,
-                      marker: {
-                          show: false,
+                      theme: false,
+                      enabled: true,
+                      markers: {
+                          size: 0
+                      },
+                      custom: function({series, seriesIndex, dataPointIndex, w}) {
+                          let service = w.globals.seriesNames[0];
+                          let ts = w.globals;
+                          window.console.log(ts);
+                          let val = series[seriesIndex][dataPointIndex];
+                          if (val > 1000) {
+                              val = (val * 0.1).toFixed(0) + " milliseconds"
+                          } else {
+                              val = (val * 0.01).toFixed(0) + " microseconds"
+                          }
+                          return `<div class="chartmarker"><span>${service} Average Response</span> <span class="font-3">${val}</span></div>`
+                      },
+                      fixed: {
+                          enabled: true,
+                          position: 'topRight',
+                          offsetX: -30,
+                          offsetY: 0,
                       },
                       x: {
                           show: false,
-                      }
+                      },
                   },
                   legend: {
                       show: false,
@@ -132,6 +162,7 @@
       },
       methods: {
           async chartHits(group) {
+              window.console.log(this.service.created_at)
               this.data = await Api.service_hits(this.service.id, this.toUnix(this.service.created_at), this.toUnix(new Date()), group, false)
 
               if (this.data.length === 0 && group !== "1h") {
@@ -139,7 +170,7 @@
               }
               this.series = [{
                   name: this.service.name,
-                  ...this.convertToChartData(this.data)
+                  ...this.convertToChartData(this.data, 0.01)
               }]
               this.ready = true
           }
diff --git a/handlers/api.go b/handlers/api.go
index 940183a3..6bb9b11e 100644
--- a/handlers/api.go
+++ b/handlers/api.go
@@ -127,13 +127,13 @@ func apiClearCacheHandler(w http.ResponseWriter, r *http.Request) {
 	returnJson(output, w, r)
 }
 
-func sendErrorJson(err error, w http.ResponseWriter, r *http.Request) {
+func sendErrorJson(err error, w http.ResponseWriter, r *http.Request, statusCode ...int) {
 	log.Warnln(fmt.Errorf("sending error response for %v: %v", r.URL.String(), err.Error()))
 	output := apiResponse{
 		Status: "error",
 		Error:  err.Error(),
 	}
-	returnJson(output, w, r)
+	returnJson(output, w, r, statusCode...)
 }
 
 func sendJsonAction(obj interface{}, method string, w http.ResponseWriter, r *http.Request) {
diff --git a/handlers/api_test.go b/handlers/api_test.go
index 2976eb37..8ab459ac 100644
--- a/handlers/api_test.go
+++ b/handlers/api_test.go
@@ -1,5 +1,3 @@
-// +build int
-
 package handlers
 
 import (
diff --git a/handlers/checkins_test.go b/handlers/checkins_test.go
index 975b7ce8..e2e09925 100644
--- a/handlers/checkins_test.go
+++ b/handlers/checkins_test.go
@@ -1,5 +1,3 @@
-// +build int
-
 package handlers
 
 import (
diff --git a/handlers/groups.go b/handlers/groups.go
index ed13f524..f5189f90 100644
--- a/handlers/groups.go
+++ b/handlers/groups.go
@@ -43,7 +43,7 @@ func apiAllGroupHandler(r *http.Request) interface{} {
 func apiGroupHandler(w http.ResponseWriter, r *http.Request) {
 	group, err := selectGroup(r)
 	if err != nil {
-		sendErrorJson(errors.Wrap(err, "group not found"), w, r)
+		sendErrorJson(errors.Wrap(err, "group not found"), w, r, http.StatusNotFound)
 		return
 	}
 	returnJson(group, w, r)
diff --git a/handlers/groups_test.go b/handlers/groups_test.go
index 00b79def..bc49afec 100644
--- a/handlers/groups_test.go
+++ b/handlers/groups_test.go
@@ -1,5 +1,3 @@
-// +build int
-
 package handlers
 
 import (
diff --git a/handlers/handlers.go b/handlers/handlers.go
index 6638f73d..0c419fc6 100644
--- a/handlers/handlers.go
+++ b/handlers/handlers.go
@@ -286,8 +286,12 @@ func executeJSResponse(w http.ResponseWriter, r *http.Request, file string, data
 	//}
 }
 
-func returnJson(d interface{}, w http.ResponseWriter, r *http.Request) {
+func returnJson(d interface{}, w http.ResponseWriter, r *http.Request, statusCode ...int) {
 	w.Header().Set("Content-Type", "application/json")
+	if len(statusCode) != 0 {
+		code := statusCode[0]
+		w.WriteHeader(code)
+	}
 	json.NewEncoder(w).Encode(d)
 }
 
diff --git a/handlers/messages_test.go b/handlers/messages_test.go
index babc62d2..a51e2260 100644
--- a/handlers/messages_test.go
+++ b/handlers/messages_test.go
@@ -1,5 +1,3 @@
-// +build int
-
 package handlers
 
 import (
diff --git a/handlers/notifiers_test.go b/handlers/notifiers_test.go
index 331c8027..31cd60de 100644
--- a/handlers/notifiers_test.go
+++ b/handlers/notifiers_test.go
@@ -1,5 +1,3 @@
-// +build int
-
 package handlers
 
 import (
@@ -10,7 +8,7 @@ import (
 )
 
 func TestAttachment(t *testing.T) {
-	err := notifiers.AttachNotifiers()
+	err := notifiers.Migrate()
 	require.Nil(t, err)
 }
 
diff --git a/handlers/prometheus.go b/handlers/prometheus.go
index dcd264df..e4cfb845 100644
--- a/handlers/prometheus.go
+++ b/handlers/prometheus.go
@@ -91,14 +91,14 @@ func prometheusHandler(w http.ResponseWriter, r *http.Request) {
 
 		PrometheusComment(fmt.Sprintf("Service #%d '%s':", ser.Id, ser.Name))
 		PrometheusExportKey("service_failures", id, name, ser.AllFailures().Count())
-		PrometheusExportKey("service_latency", id, name, ser.Latency*100)
+		PrometheusExportKey("service_latency", id, name, ser.Latency)
 		PrometheusExportKey("service_online", id, name, online)
 		PrometheusExportKey("service_status_code", id, name, ser.LastStatusCode)
 		PrometheusExportKey("service_response_length", id, name, len([]byte(ser.LastResponse)))
 		PrometheusExportKey("service_ping_time", id, name, ser.PingTime)
 		PrometheusExportKey("service_last_latency", id, name, ser.LastLatency)
 		PrometheusExportKey("service_last_lookup", id, name, ser.LastLookupTime)
-		PrometheusExportKey("service_last_check", id, name, time.Now().Sub(ser.LastCheck).Milliseconds())
+		PrometheusExportKey("service_last_check", id, name, utils.Now().Sub(ser.LastCheck).Milliseconds())
 		//PrometheusExportKey("service_online_seconds", id, name, ser.SecondsOnline)
 		//PrometheusExportKey("service_offline_seconds", id, name, ser.SecondsOffline)
 
diff --git a/handlers/services.go b/handlers/services.go
index 05e01bc2..eea4b37b 100644
--- a/handlers/services.go
+++ b/handlers/services.go
@@ -89,11 +89,11 @@ func apiCreateServiceHandler(w http.ResponseWriter, r *http.Request) {
 func apiServiceUpdateHandler(w http.ResponseWriter, r *http.Request) {
 	service, err := serviceByID(r)
 	if err != nil {
-		sendErrorJson(err, w, r)
+		sendErrorJson(err, w, r, http.StatusNotFound)
 		return
 	}
 	if err := DecodeJSON(r, &service); err != nil {
-		sendErrorJson(err, w, r)
+		sendErrorJson(err, w, r, http.StatusBadRequest)
 		return
 	}
 
diff --git a/handlers/services_test.go b/handlers/services_test.go
index 0879b646..f02e7ee7 100644
--- a/handlers/services_test.go
+++ b/handlers/services_test.go
@@ -1,5 +1,3 @@
-// +build int
-
 package handlers
 
 import (
diff --git a/handlers/setup.go b/handlers/setup.go
index 9d4a554e..d995d06b 100644
--- a/handlers/setup.go
+++ b/handlers/setup.go
@@ -17,7 +17,6 @@ package handlers
 
 import (
 	"errors"
-	"github.com/statping/statping/database"
 	"github.com/statping/statping/notifiers"
 	"github.com/statping/statping/types/configs"
 	"github.com/statping/statping/types/core"
@@ -62,14 +61,14 @@ func processSetupHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	exists := database.DB().HasTable("core")
+	exists := confgs.Db.HasTable("core")
 	if !exists {
 		if err := confgs.DropDatabase(); err != nil {
 			sendErrorJson(err, w, r)
 			return
 		}
 
-		if err := configs.CreateDatabase(); err != nil {
+		if err := confgs.CreateDatabase(); err != nil {
 			sendErrorJson(err, w, r)
 			return
 		}
diff --git a/handlers/users_test.go b/handlers/users_test.go
index fe7d299e..7b31ee7e 100644
--- a/handlers/users_test.go
+++ b/handlers/users_test.go
@@ -1,5 +1,3 @@
-// +build int
-
 package handlers
 
 import (
diff --git a/source/source.go b/source/source.go
index 2513a4aa..3acc2a94 100644
--- a/source/source.go
+++ b/source/source.go
@@ -20,9 +20,9 @@ package source
 import (
 	"fmt"
 	"github.com/GeertJohan/go.rice"
-	"github.com/statping/statping/utils"
 	"github.com/pkg/errors"
 	"github.com/russross/blackfriday/v2"
+	"github.com/statping/statping/utils"
 	"os"
 	"path/filepath"
 	"strings"
diff --git a/types/checkins/checkins_test.go b/types/checkins/checkins_test.go
new file mode 100644
index 00000000..043a2e7b
--- /dev/null
+++ b/types/checkins/checkins_test.go
@@ -0,0 +1,117 @@
+package checkins
+
+import (
+	"github.com/statping/statping/database"
+	"github.com/statping/statping/types/failures"
+	"github.com/statping/statping/utils"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
+)
+
+var testCheckin = &Checkin{
+	ServiceId:   1,
+	Name:        "Test Checkin",
+	Interval:    60,
+	GracePeriod: 10,
+	ApiKey:      "tHiSiSaTeStXXX",
+	CreatedAt:   utils.Now(),
+	UpdatedAt:   utils.Now(),
+	LastHitTime: utils.Now().Add(-15 * time.Second),
+}
+
+var testCheckinHits = []*CheckinHit{{
+	Checkin:   1,
+	From:      "0.0.0.0.0",
+	CreatedAt: utils.Now().Add(-30 * time.Second),
+}, {
+	Checkin:   2,
+	From:      "0.0.0.0",
+	CreatedAt: utils.Now().Add(-180 * time.Second),
+}}
+
+var testApiKey string
+
+func TestInit(t *testing.T) {
+	db, err := database.OpenTester()
+	require.Nil(t, err)
+	db.AutoMigrate(&Checkin{}, &CheckinHit{}, &failures.Failure{})
+	db.Create(&testCheckin)
+	for _, v := range testCheckinHits {
+		db.Create(&v)
+	}
+	assert.True(t, db.HasTable(&Checkin{}))
+	assert.True(t, db.HasTable(&CheckinHit{}))
+	assert.True(t, db.HasTable(&failures.Failure{}))
+	SetDB(db)
+}
+
+func TestFind(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Equal(t, "Test Checkin", item.Name)
+	assert.NotEmpty(t, item.ApiKey)
+	testApiKey = item.ApiKey
+}
+
+func TestFindByAPI(t *testing.T) {
+	item, err := FindByAPI(testApiKey)
+	require.Nil(t, err)
+	assert.Equal(t, "Test Checkin", item.Name)
+}
+
+func TestAll(t *testing.T) {
+	items := All()
+	assert.Len(t, items, 1)
+}
+
+func TestCreate(t *testing.T) {
+	example := &Checkin{
+		Name: "Example 2",
+	}
+	err := example.Create()
+	example.Close()
+	require.Nil(t, err)
+	assert.NotZero(t, example.Id)
+	assert.Equal(t, "Example 2", example.Name)
+	assert.NotZero(t, example.CreatedAt)
+	assert.NotEmpty(t, example.ApiKey)
+}
+
+func TestUpdate(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	item.Name = "Updated"
+
+	err = item.Update()
+	require.Nil(t, err)
+	assert.Equal(t, "Updated", item.Name)
+	item.Close()
+}
+
+func TestCheckin_Expected(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	expected := item.Expected()
+	assert.GreaterOrEqual(t, expected.Seconds(), float64(29))
+}
+
+func TestDelete(t *testing.T) {
+	all := All()
+	assert.Len(t, all, 2)
+
+	item, err := Find(2)
+	require.Nil(t, err)
+
+	err = item.Delete()
+	require.Nil(t, err)
+
+	all = All()
+	assert.Len(t, all, 1)
+}
+
+func TestClose(t *testing.T) {
+	assert.Nil(t, db.Close())
+}
diff --git a/types/checkins/database.go b/types/checkins/database.go
index d52b4e29..18d3ea54 100644
--- a/types/checkins/database.go
+++ b/types/checkins/database.go
@@ -5,48 +5,57 @@ import (
 	"github.com/statping/statping/utils"
 )
 
-func DB() database.Database {
-	return database.DB().Model(&Checkin{})
-}
+var db database.Database
+var dbHits database.Database
 
-func DBhits() database.Database {
-	return database.DB().Model(&CheckinHit{})
+func SetDB(database database.Database) {
+	db = database.Model(&Checkin{})
+	dbHits = database.Model(&CheckinHit{})
 }
 
 func Find(id int64) (*Checkin, error) {
 	var checkin Checkin
-	db := DB().Where("id = ?", id).Find(&checkin)
-	return &checkin, db.Error()
+	q := db.Where("id = ?", id).Find(&checkin)
+	return &checkin, q.Error()
 }
 
 func FindByAPI(key string) (*Checkin, error) {
 	var checkin Checkin
-	db := DB().Where("api = ?", key).Find(&checkin)
-	return &checkin, db.Error()
+	q := db.Where("api_key = ?", key).Find(&checkin)
+	return &checkin, q.Error()
 }
 
 func All() []*Checkin {
 	var checkins []*Checkin
-	DB().Find(&checkins)
+	db.Find(&checkins)
 	return checkins
 }
 
 func (c *Checkin) Create() error {
 	c.ApiKey = utils.RandomString(7)
-	db := DB().Create(c)
+	q := db.Create(c)
 
 	c.Start()
 	go c.CheckinRoutine()
-	return db.Error()
+	return q.Error()
 }
 
 func (c *Checkin) Update() error {
-	db := DB().Update(c)
-	return db.Error()
+	q := db.Update(c)
+	return q.Error()
 }
 
 func (c *Checkin) Delete() error {
 	c.Close()
-	db := DB().Delete(c)
-	return db.Error()
+	q := dbHits.Where("checkin = ?", c.Id).Delete(&CheckinHit{})
+	if err := q.Error(); err != nil {
+		return err
+	}
+	q = db.Model(&Checkin{}).Delete(c)
+	return q.Error()
 }
+
+//func (c *Checkin) AfterDelete() error {
+//	//q := dbHits.Where("checkin = ?", c.Id).Delete(&CheckinHit{})
+//	return q.Error()
+//}
diff --git a/types/checkins/database_hits.go b/types/checkins/database_hits.go
index 657337a8..dbbb5713 100644
--- a/types/checkins/database_hits.go
+++ b/types/checkins/database_hits.go
@@ -2,28 +2,28 @@ package checkins
 
 func (c *Checkin) LastHit() *CheckinHit {
 	var hit CheckinHit
-	DBhits().Where("checkin = ?", c.Id).Limit(1).Find(&hit)
+	dbHits.Where("checkin = ?", c.Id).Limit(1).Find(&hit)
 	return &hit
 }
 
 func (c *Checkin) Hits() []*CheckinHit {
 	var hits []*CheckinHit
-	DBhits().Where("checkin = ?", c.Id).Find(&hits)
+	dbHits.Where("checkin = ?", c.Id).Find(&hits)
 	c.AllHits = hits
 	return hits
 }
 
 func (c *CheckinHit) Create() error {
-	db := DBhits().Create(c)
-	return db.Error()
+	q := dbHits.Create(c)
+	return q.Error()
 }
 
 func (c *CheckinHit) Update() error {
-	db := DBhits().Update(c)
-	return db.Error()
+	q := dbHits.Update(c)
+	return q.Error()
 }
 
 func (c *CheckinHit) Delete() error {
-	db := DBhits().Delete(c)
-	return db.Error()
+	q := dbHits.Delete(c)
+	return q.Error()
 }
diff --git a/types/checkins/failures.go b/types/checkins/failures.go
index 52c0dfbc..c2745abe 100644
--- a/types/checkins/failures.go
+++ b/types/checkins/failures.go
@@ -7,7 +7,7 @@ import (
 
 func (c *Checkin) CreateFailure(f *failures.Failure) error {
 	f.Checkin = c.Id
-	return failures.DB().Create(&f).Error()
+	return failures.DB().Create(f).Error()
 }
 
 func (c *Checkin) FailuresColumnID() (string, int64) {
@@ -19,5 +19,5 @@ func (c *Checkin) Failures() failures.Failurer {
 }
 
 func (c *Checkin) FailuresSince(t time.Time) failures.Failurer {
-	return failures.FailuresSince(t, c)
+	return failures.Since(t, c)
 }
diff --git a/types/checkins/generate.go b/types/checkins/generate.go
new file mode 100644
index 00000000..5e3ffbb0
--- /dev/null
+++ b/types/checkins/generate.go
@@ -0,0 +1,3 @@
+package checkins
+
+//go:generate counterfeiter . Checkin
diff --git a/types/checkins/routine.go b/types/checkins/routine.go
index ba580181..40eb0667 100644
--- a/types/checkins/routine.go
+++ b/types/checkins/routine.go
@@ -47,7 +47,7 @@ CheckinLoop:
 					Method:    "checkin",
 					Service:   c.ServiceId,
 					Checkin:   c.Id,
-					PingTime:  c.Expected().Seconds(),
+					PingTime:  c.Expected().Milliseconds(),
 					CreatedAt: time.Time{},
 				}
 
diff --git a/types/checkins/struct.go b/types/checkins/struct.go
index 1e4308ba..d274e1f0 100644
--- a/types/checkins/struct.go
+++ b/types/checkins/struct.go
@@ -1,7 +1,6 @@
 package checkins
 
 import (
-	"github.com/statping/statping/database"
 	"github.com/statping/statping/types/failures"
 	"github.com/statping/statping/utils"
 	"time"
@@ -32,24 +31,7 @@ type CheckinHit struct {
 	CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
 }
 
-// BeforeCreate for checkinHit will set CreatedAt to UTC
-func (c *CheckinHit) BeforeCreate() (err error) {
-	if c.CreatedAt.IsZero() {
-		c.CreatedAt = time.Now().UTC()
-	}
-	return
-}
-
 func (c *Checkin) BeforeCreate() (err error) {
 	c.ApiKey = utils.RandomString(7)
-	if c.CreatedAt.IsZero() {
-		c.CreatedAt = time.Now().UTC()
-		c.UpdatedAt = time.Now().UTC()
-	}
-	return
-}
-
-func (c *Checkin) BeforeDelete(tx database.Database) (err error) {
-	return tx.Where("id = ?", c.ServiceId).
-		Update("group_id", 0).Error()
+	return nil
 }
diff --git a/types/configs/connection.go b/types/configs/connection.go
index b2141ed7..123abfca 100644
--- a/types/configs/connection.go
+++ b/types/configs/connection.go
@@ -5,7 +5,16 @@ import (
 	"github.com/jinzhu/gorm"
 	"github.com/pkg/errors"
 	"github.com/statping/statping/database"
+	"github.com/statping/statping/types/checkins"
+	"github.com/statping/statping/types/core"
+	"github.com/statping/statping/types/failures"
+	"github.com/statping/statping/types/groups"
+	"github.com/statping/statping/types/hits"
+	"github.com/statping/statping/types/incidents"
+	"github.com/statping/statping/types/messages"
+	"github.com/statping/statping/types/notifications"
 	"github.com/statping/statping/types/null"
+	"github.com/statping/statping/types/services"
 	"github.com/statping/statping/types/users"
 	"github.com/statping/statping/utils"
 	"os"
@@ -15,9 +24,6 @@ import (
 // Connect will attempt to connect to the sqlite, postgres, or mysql database
 func Connect(configs *DbConfig, retry bool) error {
 	postgresSSL := os.Getenv("POSTGRES_SSLMODE")
-	if database.Available() {
-		return nil
-	}
 	var conn string
 	var err error
 
@@ -25,7 +31,7 @@ func Connect(configs *DbConfig, retry bool) error {
 	case "sqlite", "sqlite3", "memory":
 		if configs.DbConn == "memory" {
 			conn = "sqlite3"
-			configs.DbConn = ":memory"
+			configs.DbConn = ":memory:"
 		} else {
 			conn = findDbFile(configs)
 			configs.SqlFile = conn
@@ -76,14 +82,31 @@ func Connect(configs *DbConfig, retry bool) error {
 
 	if dbSession.DB().Ping() == nil {
 		if utils.VerboseMode >= 4 {
-			database.LogMode(true).Debug().SetLogger(gorm.Logger{log})
+			dbSession.LogMode(true).Debug().SetLogger(gorm.Logger{log})
 		}
 		log.Infoln(fmt.Sprintf("Database %v connection was successful.", configs.DbConn))
 	}
 
+	configs.Db = dbSession
+
+	initModels(configs.Db)
+
 	return err
 }
 
+func initModels(db database.Database) {
+	core.SetDB(db)
+	services.SetDB(db)
+	hits.SetDB(db)
+	failures.SetDB(db)
+	checkins.SetDB(db)
+	notifications.SetDB(db)
+	incidents.SetDB(db)
+	users.SetDB(db)
+	messages.SetDB(db)
+	groups.SetDB(db)
+}
+
 func CreateAdminUser(configs *DbConfig) error {
 	log.Infoln(fmt.Sprintf("Core database does not exist, creating now!"))
 
diff --git a/types/configs/database.go b/types/configs/database.go
index c8e3a908..82b44331 100644
--- a/types/configs/database.go
+++ b/types/configs/database.go
@@ -76,7 +76,7 @@ func (d *DbConfig) DropDatabase() error {
 	var DbModels = []interface{}{&services.Service{}, &users.User{}, &hits.Hit{}, &failures.Failure{}, &messages.Message{}, &groups.Group{}, &checkins.Checkin{}, &checkins.CheckinHit{}, &notifications.Notification{}, &incidents.Incident{}, &incidents.IncidentUpdate{}}
 	log.Infoln("Dropping Database Tables...")
 	for _, t := range DbModels {
-		if err := database.DB().DropTableIfExists(t); err != nil {
+		if err := d.Db.DropTableIfExists(t); err != nil {
 			return err.Error()
 		}
 		log.Infof("Dropped table: %T\n", t)
@@ -84,19 +84,23 @@ func (d *DbConfig) DropDatabase() error {
 	return nil
 }
 
+func (d *DbConfig) Close() {
+	d.Db.Close()
+}
+
 // CreateDatabase will CREATE TABLES for each of the Statping elements
-func CreateDatabase() error {
+func (d *DbConfig) CreateDatabase() error {
 	var err error
 
 	var DbModels = []interface{}{&services.Service{}, &users.User{}, &hits.Hit{}, &failures.Failure{}, &messages.Message{}, &groups.Group{}, &checkins.Checkin{}, &checkins.CheckinHit{}, &notifications.Notification{}, &incidents.Incident{}, &incidents.IncidentUpdate{}}
 
 	log.Infoln("Creating Database Tables...")
 	for _, table := range DbModels {
-		if err := database.DB().CreateTable(table); err.Error() != nil {
+		if err := d.Db.CreateTable(table); err.Error() != nil {
 			return err.Error()
 		}
 	}
-	if err := database.DB().Table("core").CreateTable(&core.Core{}); err.Error() != nil {
+	if err := d.Db.Table("core").CreateTable(&core.Core{}); err.Error() != nil {
 		return err.Error()
 	}
 	log.Infoln("Statping Database Created")
diff --git a/types/configs/migration.go b/types/configs/migration.go
index ab9afe3a..e441ee55 100644
--- a/types/configs/migration.go
+++ b/types/configs/migration.go
@@ -2,7 +2,6 @@ package configs
 
 import (
 	"fmt"
-	"github.com/statping/statping/database"
 	"github.com/statping/statping/types/checkins"
 	"github.com/statping/statping/types/core"
 	"github.com/statping/statping/types/failures"
@@ -51,7 +50,7 @@ func (c *DbConfig) MigrateDatabase() error {
 	var DbModels = []interface{}{&services.Service{}, &users.User{}, &hits.Hit{}, &failures.Failure{}, &messages.Message{}, &groups.Group{}, &checkins.Checkin{}, &checkins.CheckinHit{}, &notifications.Notification{}, &incidents.Incident{}, &incidents.IncidentUpdate{}}
 
 	log.Infoln("Migrating Database Tables...")
-	tx := database.Begin("migration")
+	tx := c.Db.Begin()
 	defer func() {
 		if r := recover(); r != nil {
 			tx.Rollback()
@@ -75,19 +74,19 @@ func (c *DbConfig) MigrateDatabase() error {
 	}
 	log.Infoln("Statping Database Tables Migrated")
 
-	if err := database.DB().Model(&hits.Hit{}).AddIndex("idx_service_hit", "service").Error(); err != nil {
+	if err := c.Db.Model(&hits.Hit{}).AddIndex("idx_service_hit", "service").Error(); err != nil {
 		log.Errorln(err)
 	}
 
-	if err := database.DB().Model(&hits.Hit{}).AddIndex("hit_created_at", "created_at").Error(); err != nil {
+	if err := c.Db.Model(&hits.Hit{}).AddIndex("hit_created_at", "created_at").Error(); err != nil {
 		log.Errorln(err)
 	}
 
-	if err := database.DB().Model(&failures.Failure{}).AddIndex("idx_service_fail", "service").Error(); err != nil {
+	if err := c.Db.Model(&failures.Failure{}).AddIndex("idx_service_fail", "service").Error(); err != nil {
 		log.Errorln(err)
 	}
 
-	if err := database.DB().Model(&failures.Failure{}).AddIndex("idx_checkin_fail", "checkin").Error(); err != nil {
+	if err := c.Db.Model(&failures.Failure{}).AddIndex("idx_checkin_fail", "checkin").Error(); err != nil {
 		log.Errorln(err)
 	}
 	log.Infoln("Database Indexes Created")
diff --git a/types/configs/seed_test.go b/types/configs/seed_test.go
index 2b136325..b6c16e58 100644
--- a/types/configs/seed_test.go
+++ b/types/configs/seed_test.go
@@ -1,13 +1,5 @@
 package configs
 
-import (
-	"github.com/romanyx/polluter"
-	"github.com/statping/statping/database"
-	"github.com/statping/statping/utils"
-	"os"
-	"testing"
-)
-
 //func preparePostgresDB(t *testing.T) (database.Database, error) {
 //	dbName := fmt.Sprintf("db_%d", time.Now().UnixNano())
 //	db, err := database.Openw("sqlite3", dbName)
@@ -17,20 +9,3 @@ import (
 //
 //	return db, db.Error()
 //}
-
-func TestSeedDatabase(t *testing.T) {
-	t.SkipNow()
-	dir := utils.Directory
-	f, err := os.Open(dir + "/testdata.yml")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer f.Close()
-
-	p := polluter.New(polluter.PostgresEngine(database.DB().DB()))
-
-	if err := p.Pollute(f); err != nil {
-		t.Fatalf("failed to pollute: %s", err)
-	}
-
-}
diff --git a/types/configs/struct.go b/types/configs/struct.go
index 585f6351..f85c72e8 100644
--- a/types/configs/struct.go
+++ b/types/configs/struct.go
@@ -1,5 +1,7 @@
 package configs
 
+import "github.com/statping/statping/database"
+
 const SqliteFilename = "statping.db"
 
 // DbConfig struct is used for the Db connection and creates the 'config.yml' file
@@ -23,4 +25,6 @@ type DbConfig struct {
 	SqlFile     string `yaml:"sqlfile,omitempty" json:"-"`
 	LocalIP     string `yaml:"-" json:"-"`
 	filename    string `yaml:"-" json:"-"`
+
+	Db database.Database `yaml:"-" json:"-"`
 }
diff --git a/types/core/database.go b/types/core/database.go
index fdfcd28f..cb966050 100644
--- a/types/core/database.go
+++ b/types/core/database.go
@@ -9,27 +9,29 @@ import (
 	"time"
 )
 
-func DB() database.Database {
-	return database.DB().Table("core")
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&Core{})
 }
 
 func Select() (*Core, error) {
 	var c Core
 	// SelectCore will return the CoreApp global variable and the settings/configs for Statping
-	if !database.Available() {
+	if err := db.DB().Ping(); err != nil {
 		return nil, errors.New("database has not been initiated yet.")
 	}
-	exists := DB().HasTable("core")
+	exists := db.HasTable("core")
 	if !exists {
 		return nil, errors.New("core database has not been setup yet.")
 	}
-	db := DB().Find(&c)
-	if db.Error() != nil {
+	q := db.Find(&c)
+	if q.Error() != nil {
 		return nil, db.Error()
 	}
 	App = &c
 	App.UseCdn = null.NewNullBool(os.Getenv("USE_CDN") == "true")
-	return App, db.Error()
+	return App, q.Error()
 }
 
 func (c *Core) Create() error {
@@ -44,13 +46,13 @@ func (c *Core) Create() error {
 		Domain:      c.Domain,
 		MigrationId: time.Now().Unix(),
 	}
-	db := DB().Create(&newCore)
-	return db.Error()
+	q := db.Create(&newCore)
+	return q.Error()
 }
 
 func (c *Core) Update() error {
-	db := DB().Update(c)
-	return db.Error()
+	q := db.Update(c)
+	return q.Error()
 }
 
 func (c *Core) Delete() error {
@@ -73,6 +75,6 @@ func Sample() error {
 		Footer:      null.NewNullString(""),
 	}
 
-	db := DB().Create(core)
-	return db.Error()
+	q := db.Create(core)
+	return q.Error()
 }
diff --git a/types/failures/database.go b/types/failures/database.go
index 1913cf49..d03549dd 100644
--- a/types/failures/database.go
+++ b/types/failures/database.go
@@ -2,33 +2,39 @@ package failures
 
 import "github.com/statping/statping/database"
 
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&Failure{})
+}
+
 func DB() database.Database {
-	return database.DB().Model(&Failure{})
+	return db
 }
 
 func Find(id int64) (*Failure, error) {
 	var failure Failure
-	db := DB().Where("id = ?", id).Find(&failure)
-	return &failure, db.Error()
+	q := db.Where("id = ?", id).Find(&failure)
+	return &failure, q.Error()
 }
 
 func All() []*Failure {
 	var failures []*Failure
-	DB().Find(&failures)
+	db.Find(&failures)
 	return failures
 }
 
 func (f *Failure) Create() error {
-	db := DB().Create(f)
-	return db.Error()
+	q := db.Create(f)
+	return q.Error()
 }
 
 func (f *Failure) Update() error {
-	db := DB().Update(f)
-	return db.Error()
+	q := db.Update(f)
+	return q.Error()
 }
 
 func (f *Failure) Delete() error {
-	db := DB().Delete(f)
-	return db.Error()
+	q := db.Delete(f)
+	return q.Error()
 }
diff --git a/types/failures/interface.go b/types/failures/interface.go
index 5babce05..2954d118 100644
--- a/types/failures/interface.go
+++ b/types/failures/interface.go
@@ -18,37 +18,54 @@ func (f Failurer) Db() database.Database {
 	return f.db
 }
 
+func (f Failurer) First() *Failure {
+	var fail Failure
+	f.db.Order("id ASC").Limit(1).Find(&fail)
+	return &fail
+}
+
+func (f Failurer) Last() *Failure {
+	var fail Failure
+	f.db.Order("id DESC").Limit(1).Find(&fail)
+	return &fail
+}
+
 func (f Failurer) List() []*Failure {
 	var fails []*Failure
 	f.db.Find(&fails)
 	return fails
 }
 
+func (f Failurer) LastAmount(amount int) []*Failure {
+	var fail []*Failure
+	f.db.Order("id asc").Limit(amount).Find(&fail)
+	return fail
+}
+
+func (f Failurer) Since(t time.Time) []*Failure {
+	var fails []*Failure
+	f.db.Since(t).Find(&fails)
+	return fails
+}
+
 func (f Failurer) Count() int {
 	var amount int
 	f.db.Count(&amount)
 	return amount
 }
 
-func (f Failurer) Last(amount int) []*Failure {
-	var fails []*Failure
-	f.db.Limit(amount).Find(&fails)
-	return fails
-}
-
-func (f Failurer) Since(t time.Time) []*Failure {
-	var fails []*Failure
-	f.db.Since(t).Find(&fails)
-	return fails
+func (f Failurer) DeleteAll() error {
+	q := f.db.Delete(&Failure{})
+	return q.Error()
 }
 
 func AllFailures(obj ColumnIDInterfacer) Failurer {
 	column, id := obj.FailuresColumnID()
-	return Failurer{DB().Where(fmt.Sprintf("%s = ?", column), id)}
+	return Failurer{db.Where(fmt.Sprintf("%s = ?", column), id)}
 }
 
-func FailuresSince(t time.Time, obj ColumnIDInterfacer) Failurer {
+func Since(t time.Time, obj ColumnIDInterfacer) Failurer {
 	column, id := obj.FailuresColumnID()
-	timestamp := DB().FormatTime(t)
-	return Failurer{DB().Where(fmt.Sprintf("%s = ? AND created_at > ?", column), id, timestamp)}
+	timestamp := db.FormatTime(t)
+	return Failurer{db.Where(fmt.Sprintf("%s = ? AND created_at > ?", column), id, timestamp)}
 }
diff --git a/types/failures/samples.go b/types/failures/samples.go
index 9df0d7c8..a600d224 100644
--- a/types/failures/samples.go
+++ b/types/failures/samples.go
@@ -14,7 +14,7 @@ import (
 )
 
 func Samples() error {
-	tx := DB().Begin()
+	tx := db.Begin()
 	sg := new(sync.WaitGroup)
 
 	createdAt := utils.Now().Add(-3 * types.Day)
diff --git a/types/failures/struct.go b/types/failures/struct.go
index 004aafd6..14bf75a0 100644
--- a/types/failures/struct.go
+++ b/types/failures/struct.go
@@ -17,18 +17,10 @@ type Failure struct {
 	ErrorCode int       `gorm:"column:error_code" json:"error_code"`
 	Service   int64     `gorm:"index;column:service" json:"-"`
 	Checkin   int64     `gorm:"index;column:checkin" json:"-"`
-	PingTime  float64   `gorm:"column:ping_time"  json:"ping"`
+	PingTime  int64     `gorm:"column:ping_time"  json:"ping"`
 	CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
 }
 
-// BeforeCreate for Failure will set CreatedAt to UTC
-func (f *Failure) BeforeCreate() (err error) {
-	if f.CreatedAt.IsZero() {
-		f.CreatedAt = time.Now().UTC()
-	}
-	return
-}
-
 type FailSort []Failure
 
 func (s FailSort) Len() int {
diff --git a/types/groups/database.go b/types/groups/database.go
index c1f323c5..6edbd79d 100644
--- a/types/groups/database.go
+++ b/types/groups/database.go
@@ -5,35 +5,37 @@ import (
 	"sort"
 )
 
-func DB() database.Database {
-	return database.DB().Model(&Group{})
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&Group{})
 }
 
 func Find(id int64) (*Group, error) {
 	var group Group
-	db := DB().Where("id = ?", id).Find(&group)
-	return &group, db.Error()
+	q := db.Where("id = ?", id).Find(&group)
+	return &group, q.Error()
 }
 
 func All() []*Group {
 	var groups []*Group
-	DB().Find(&groups)
+	db.Find(&groups)
 	return groups
 }
 
 func (g *Group) Create() error {
-	db := DB().Create(g)
-	return db.Error()
+	q := db.Create(g)
+	return q.Error()
 }
 
 func (g *Group) Update() error {
-	db := DB().Update(g)
-	return db.Error()
+	q := db.Update(g)
+	return q.Error()
 }
 
 func (g *Group) Delete() error {
-	db := DB().Delete(g)
-	return db.Error()
+	q := db.Delete(g)
+	return q.Error()
 }
 
 // SelectGroups returns all groups
diff --git a/types/groups/groups_test.go b/types/groups/groups_test.go
new file mode 100644
index 00000000..e881259c
--- /dev/null
+++ b/types/groups/groups_test.go
@@ -0,0 +1,89 @@
+package groups
+
+import (
+	"github.com/statping/statping/database"
+	"github.com/statping/statping/types/null"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+var example = &Group{
+	Name:   "Example Group",
+	Public: null.NewNullBool(true),
+	Order:  1,
+}
+
+func TestInit(t *testing.T) {
+	db, err := database.OpenTester()
+	require.Nil(t, err)
+	db.CreateTable(&Group{})
+	db.Create(&example)
+	SetDB(db)
+}
+
+func TestFind(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Equal(t, "Example Group", item.Name)
+}
+
+func TestAll(t *testing.T) {
+	items := All()
+	assert.Len(t, items, 1)
+}
+
+func TestCreate(t *testing.T) {
+	example := &Group{
+		Name:   "Example 2",
+		Public: null.NewNullBool(false),
+		Order:  3,
+	}
+	err := example.Create()
+	require.Nil(t, err)
+	assert.NotZero(t, example.Id)
+	assert.Equal(t, "Example 2", example.Name)
+	assert.NotZero(t, example.CreatedAt)
+}
+
+func TestUpdate(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	item.Name = "Updated"
+	item.Order = 1
+	err = item.Update()
+	require.Nil(t, err)
+	assert.Equal(t, "Updated", item.Name)
+}
+
+func TestSelectGroups(t *testing.T) {
+	groups := SelectGroups(true, true)
+	assert.Len(t, groups, 2)
+
+	groups = SelectGroups(false, false)
+	assert.Len(t, groups, 1)
+
+	groups = SelectGroups(false, true)
+	assert.Len(t, groups, 2)
+
+	assert.Equal(t, "Updated", groups[0].Name)
+	assert.Equal(t, "Example 2", groups[1].Name)
+}
+
+func TestDelete(t *testing.T) {
+	all := All()
+	assert.Len(t, all, 2)
+
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	err = item.Delete()
+	require.Nil(t, err)
+
+	all = All()
+	assert.Len(t, all, 1)
+}
+
+func TestClose(t *testing.T) {
+	assert.Nil(t, db.Close())
+}
diff --git a/types/groups/methods.go b/types/groups/methods.go
index 6c786528..1052c339 100644
--- a/types/groups/methods.go
+++ b/types/groups/methods.go
@@ -1,13 +1,12 @@
 package groups
 
 import (
-	"github.com/statping/statping/database"
 	"github.com/statping/statping/types/services"
 )
 
 func (g *Group) Services() []*services.Service {
 	var services []*services.Service
-	database.DB().Where("group = ?", g.Id).Find(&services)
+	db.Where("group = ?", g.Id).Find(&services)
 	return services
 }
 
diff --git a/types/hits/database.go b/types/hits/database.go
index 44660ac7..158f3418 100644
--- a/types/hits/database.go
+++ b/types/hits/database.go
@@ -7,33 +7,35 @@ import (
 
 var log = utils.Log
 
-func DB() database.Database {
-	return database.DB().Model(&Hit{})
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&Hit{})
 }
 
 func Find(id int64) (*Hit, error) {
 	var group Hit
-	db := DB().Where("id = ?", id).Find(&group)
-	return &group, db.Error()
+	q := db.Where("id = ?", id).Find(&group)
+	return &group, q.Error()
 }
 
 func All() []*Hit {
 	var hits []*Hit
-	DB().Find(&hits)
+	db.Find(&hits)
 	return hits
 }
 
 func (h *Hit) Create() error {
-	db := DB().Create(h)
-	return db.Error()
+	q := db.Create(h)
+	return q.Error()
 }
 
 func (h *Hit) Update() error {
-	db := DB().Update(h)
-	return db.Error()
+	q := db.Update(h)
+	return q.Error()
 }
 
 func (h *Hit) Delete() error {
-	db := DB().Delete(h)
-	return db.Error()
+	q := db.Delete(h)
+	return q.Error()
 }
diff --git a/types/hits/interface.go b/types/hits/interface.go
index 58e5fbf8..7ec566fa 100644
--- a/types/hits/interface.go
+++ b/types/hits/interface.go
@@ -42,9 +42,9 @@ func (h Hitters) List() []*Hit {
 	return hits
 }
 
-func (h Hitters) LastCount(amounts int) []*Hit {
+func (h Hitters) LastAmount(amount int) []*Hit {
 	var hits []*Hit
-	h.db.Order("id asc").Limit(amounts).Find(&hits)
+	h.db.Order("id asc").Limit(amount).Find(&hits)
 	return hits
 }
 
@@ -54,18 +54,23 @@ func (h Hitters) Count() int {
 	return count
 }
 
+func (h Hitters) DeleteAll() error {
+	q := h.db.Delete(&Hit{})
+	return q.Error()
+}
+
 func (h Hitters) Sum() float64 {
 	result := struct {
 		amount float64
 	}{0}
 
-	h.db.Select("AVG(latency) as amount").Scan(&result).Debug()
+	h.db.Select("AVG(latency) as amount").Scan(&result)
 	return result.amount
 }
 
-func (h Hitters) Avg() int64 {
+func (h Hitters) Avg() float64 {
 	result := struct {
-		amount int64
+		amount float64
 	}{0}
 
 	h.db.Select("AVG(latency) as amount").Scan(&result)
@@ -74,11 +79,11 @@ func (h Hitters) Avg() int64 {
 
 func AllHits(obj ColumnIDInterfacer) Hitters {
 	column, id := obj.HitsColumnID()
-	return Hitters{DB().Where(fmt.Sprintf("%s = ?", column), id)}
+	return Hitters{db.Where(fmt.Sprintf("%s = ?", column), id)}
 }
 
-func HitsSince(t time.Time, obj ColumnIDInterfacer) Hitters {
+func Since(t time.Time, obj ColumnIDInterfacer) Hitters {
 	column, id := obj.HitsColumnID()
-	timestamp := DB().FormatTime(t)
-	return Hitters{DB().Where(fmt.Sprintf("%s = ? AND created_at > ?", column), id, timestamp)}
+	timestamp := db.FormatTime(t)
+	return Hitters{db.Where(fmt.Sprintf("%s = ? AND created_at > ?", column), id, timestamp)}
 }
diff --git a/types/hits/samples.go b/types/hits/samples.go
index 29601947..4ed14776 100644
--- a/types/hits/samples.go
+++ b/types/hits/samples.go
@@ -16,7 +16,7 @@ import (
 var SampleHits = 99900.
 
 func Samples() error {
-	tx := DB().Begin()
+	tx := db.Begin()
 	sg := new(sync.WaitGroup)
 
 	for i := int64(1); i <= 5; i++ {
@@ -24,7 +24,7 @@ func Samples() error {
 		if err != nil {
 			log.Error(err)
 		}
-		tx = DB().Begin()
+		tx = db.Begin()
 	}
 
 	return tx.Error()
@@ -44,8 +44,8 @@ func createHitsAt(db database.Database, serviceID int64, sg *sync.WaitGroup) err
 
 		hit := &Hit{
 			Service:   serviceID,
-			Latency:   latency,
-			PingTime:  latency * 0.15,
+			Latency:   int64(latency * 10000000),
+			PingTime:  int64(latency * 5000000),
 			CreatedAt: createdAt,
 		}
 
diff --git a/types/hits/struct.go b/types/hits/struct.go
index 951f1d40..ecd29984 100644
--- a/types/hits/struct.go
+++ b/types/hits/struct.go
@@ -6,8 +6,8 @@ import "time"
 type Hit struct {
 	Id        int64     `gorm:"primary_key;column:id" json:"id"`
 	Service   int64     `gorm:"column:service" json:"-"`
-	Latency   float64   `gorm:"column:latency" json:"latency"`
-	PingTime  float64   `gorm:"column:ping_time" json:"ping_time"`
+	Latency   int64     `gorm:"column:latency" json:"latency"`
+	PingTime  int64     `gorm:"column:ping_time" json:"ping_time"`
 	CreatedAt time.Time `gorm:"column:created_at" json:"created_at"`
 }
 
diff --git a/types/incidents/database.go b/types/incidents/database.go
index 1368ee04..a9294946 100644
--- a/types/incidents/database.go
+++ b/types/incidents/database.go
@@ -2,29 +2,35 @@ package incidents
 
 import "github.com/statping/statping/database"
 
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&Incident{})
+}
+
 func Find(id int64) (*Incident, error) {
 	var incident Incident
-	db := database.DB().Model(&Incident{}).Where("id = ?", id).Find(&incident)
-	return &incident, db.Error()
+	q := db.Where("id = ?", id).Find(&incident)
+	return &incident, q.Error()
 }
 
 func All() []*Incident {
 	var incidents []*Incident
-	database.DB().Model(&Incident{}).Find(&incidents)
+	db.Find(&incidents)
 	return incidents
 }
 
 func (i *Incident) Create() error {
-	db := database.DB().Create(i)
-	return db.Error()
+	q := db.Create(i)
+	return q.Error()
 }
 
 func (i *Incident) Update() error {
-	db := database.DB().Update(i)
-	return db.Error()
+	q := db.Update(i)
+	return q.Error()
 }
 
 func (i *Incident) Delete() error {
-	db := database.DB().Delete(i)
-	return db.Error()
+	q := db.Delete(i)
+	return q.Error()
 }
diff --git a/types/incidents/database_updates.go b/types/incidents/database_updates.go
index 896f0061..e5e0aab8 100644
--- a/types/incidents/database_updates.go
+++ b/types/incidents/database_updates.go
@@ -1,25 +1,23 @@
 package incidents
 
-import "github.com/statping/statping/database"
-
 func (i *Incident) Updates() []*IncidentUpdate {
 	var updates []*IncidentUpdate
-	database.DB().Model(&IncidentUpdate{}).Where("incident = ?", i.Id).Find(&updates)
+	db.Model(&IncidentUpdate{}).Where("incident = ?", i.Id).Find(&updates)
 	i.AllUpdates = updates
 	return updates
 }
 
 func (i *IncidentUpdate) Create() error {
-	db := database.DB().Create(i)
-	return db.Error()
+	q := db.Create(i)
+	return q.Error()
 }
 
 func (i *IncidentUpdate) Update() error {
-	db := database.DB().Update(i)
-	return db.Error()
+	q := db.Update(i)
+	return q.Error()
 }
 
 func (i *IncidentUpdate) Delete() error {
-	db := database.DB().Delete(i)
-	return db.Error()
+	q := db.Delete(i)
+	return q.Error()
 }
diff --git a/types/incidents/incidents_test.go b/types/incidents/incidents_test.go
new file mode 100644
index 00000000..115427ce
--- /dev/null
+++ b/types/incidents/incidents_test.go
@@ -0,0 +1,83 @@
+package incidents
+
+import (
+	"github.com/statping/statping/database"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+var example = &Incident{
+	Title:       "Example",
+	Description: "No description",
+	ServiceId:   1,
+}
+
+var update1 = &IncidentUpdate{
+	IncidentId: 1,
+	Message:    "First one here",
+	Type:       "update",
+}
+
+var update2 = &IncidentUpdate{
+	IncidentId: 1,
+	Message:    "Second one here",
+	Type:       "update",
+}
+
+func TestInit(t *testing.T) {
+	db, err := database.OpenTester()
+	require.Nil(t, err)
+	db.AutoMigrate(&Incident{}, &IncidentUpdate{})
+	db.Create(&example)
+	SetDB(db)
+}
+
+func TestFind(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Equal(t, "Example", item.Title)
+}
+
+func TestAll(t *testing.T) {
+	items := All()
+	assert.Len(t, items, 1)
+}
+
+func TestCreate(t *testing.T) {
+	example := &Incident{
+		Title: "Example 2",
+	}
+	err := example.Create()
+	require.Nil(t, err)
+	assert.NotZero(t, example.Id)
+	assert.Equal(t, "Example 2", example.Title)
+	assert.NotZero(t, example.CreatedAt)
+}
+
+func TestUpdate(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	item.Title = "Updated"
+	err = item.Update()
+	require.Nil(t, err)
+	assert.Equal(t, "Updated", item.Title)
+}
+
+func TestDelete(t *testing.T) {
+	all := All()
+	assert.Len(t, all, 2)
+
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	err = item.Delete()
+	require.Nil(t, err)
+
+	all = All()
+	assert.Len(t, all, 1)
+}
+
+func TestClose(t *testing.T) {
+	assert.Nil(t, db.Close())
+}
diff --git a/types/messages/database.go b/types/messages/database.go
index 1ee4f0d9..b4246c48 100644
--- a/types/messages/database.go
+++ b/types/messages/database.go
@@ -2,33 +2,35 @@ package messages
 
 import "github.com/statping/statping/database"
 
-func DB() database.Database {
-	return database.DB().Model(&Message{})
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&Message{})
 }
 
 func Find(id int64) (*Message, error) {
 	var message Message
-	db := DB().Where("id = ?", id).Find(&message)
-	return &message, db.Error()
+	q := db.Where("id = ?", id).Find(&message)
+	return &message, q.Error()
 }
 
 func All() []*Message {
 	var messages []*Message
-	DB().Find(&messages)
+	db.Find(&messages)
 	return messages
 }
 
 func (m *Message) Create() error {
-	db := DB().Create(m)
-	return db.Error()
+	q := db.Create(m)
+	return q.Error()
 }
 
 func (m *Message) Update() error {
-	db := DB().Update(m)
-	return db.Error()
+	q := db.Update(m)
+	return q.Error()
 }
 
 func (m *Message) Delete() error {
-	db := DB().Delete(m)
-	return db.Error()
+	q := db.Delete(m)
+	return q.Error()
 }
diff --git a/types/messages/messages_test.go b/types/messages/messages_test.go
new file mode 100644
index 00000000..fda3e71f
--- /dev/null
+++ b/types/messages/messages_test.go
@@ -0,0 +1,76 @@
+package messages
+
+import (
+	"github.com/statping/statping/database"
+	"github.com/statping/statping/utils"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
+)
+
+var example = &Message{
+	Title:       "Example Message",
+	Description: "Description here",
+	StartOn:     utils.Now().Add(10 * time.Minute),
+	EndOn:       utils.Now().Add(15 * time.Minute),
+	ServiceId:   1,
+}
+
+func TestInit(t *testing.T) {
+	db, err := database.OpenTester()
+	require.Nil(t, err)
+	db.CreateTable(&Message{})
+	db.Create(&example)
+	SetDB(db)
+}
+
+func TestFind(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Equal(t, "Example Message", item.Title)
+}
+
+func TestAll(t *testing.T) {
+	items := All()
+	assert.Len(t, items, 1)
+}
+
+func TestCreate(t *testing.T) {
+	example := &Message{
+		Title:       "Example 2",
+		Description: "New Message here",
+	}
+	err := example.Create()
+	require.Nil(t, err)
+	assert.NotZero(t, example.Id)
+	assert.Equal(t, "Example 2", example.Title)
+	assert.NotZero(t, example.CreatedAt)
+}
+
+func TestUpdate(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	item.Title = "Updated"
+	err = item.Update()
+	require.Nil(t, err)
+	assert.Equal(t, "Updated", item.Title)
+}
+
+func TestDelete(t *testing.T) {
+	all := All()
+	assert.Len(t, all, 2)
+
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	err = item.Delete()
+	require.Nil(t, err)
+
+	all = All()
+	assert.Len(t, all, 1)
+}
+
+func TestClose(t *testing.T) {
+	assert.Nil(t, db.Close())
+}
diff --git a/types/notifications/database.go b/types/notifications/database.go
index 28ffd4b9..2b8ebd07 100644
--- a/types/notifications/database.go
+++ b/types/notifications/database.go
@@ -5,19 +5,21 @@ import (
 	"github.com/statping/statping/database"
 )
 
-func DB() database.Database {
-	return database.DB().Model(&Notification{})
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&Notification{})
 }
 
 func Append(n Notifier) {
 	allNotifiers = append(allNotifiers, n)
 }
 
-func Find(name string) (Notifier, error) {
+func Find(name string) (*Notification, error) {
 	for _, n := range allNotifiers {
 		notif := n.Select()
 		if notif.Name() == name || notif.Method == name {
-			return n, nil
+			return notif, nil
 		}
 	}
 	return nil, errors.New("notifier not found")
@@ -29,9 +31,11 @@ func All() []Notifier {
 
 func (n *Notification) Create() error {
 	var notif Notification
-	if DB().Where("method = ?", n.Method).Find(&notif).RecordNotFound() {
-		return DB().Create(n).Error()
+	if db.Where("method = ?", n.Method).Find(&notif).RecordNotFound() {
+		Append(n)
+		return db.Create(n).Error()
 	}
+	Append(n)
 	return nil
 }
 
@@ -44,7 +48,7 @@ func (n *Notification) Update() error {
 	} else {
 		n.Close()
 	}
-	err := DB().Update(n)
+	err := db.Update(n)
 	return err.Error()
 }
 
diff --git a/types/notifications/notifications_test.go b/types/notifications/notifications_test.go
new file mode 100644
index 00000000..4478b5b7
--- /dev/null
+++ b/types/notifications/notifications_test.go
@@ -0,0 +1,135 @@
+package notifications
+
+import (
+	"github.com/statping/statping/database"
+	"github.com/statping/statping/types/null"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+var form1 = NotificationForm{
+	Type:     "text",
+	Title:    "Example Input",
+	DbField:  "Host",
+	Required: true,
+	IsHidden: false,
+	IsList:   false,
+	IsSwitch: false,
+}
+
+var form2 = NotificationForm{
+	Type:     "text",
+	Title:    "Example Input 2",
+	DbField:  "ApiKey",
+	Required: true,
+	IsHidden: false,
+	IsList:   false,
+	IsSwitch: false,
+}
+
+var example = &exampleNotif{&Notification{
+	Method:    "example",
+	Enabled:   null.NewNullBool(true),
+	Limits:    3,
+	Removable: false,
+	Form:      []NotificationForm{form1, form2},
+	Delay:     30,
+}}
+
+type exampleNotif struct {
+	*Notification
+}
+
+func (e *exampleNotif) OnSave() error {
+	return nil
+}
+
+func (e *exampleNotif) Select() *Notification {
+	return e.Notification
+}
+
+func (e *exampleNotif) Send(data interface{}) error {
+	return nil
+}
+
+func TestInit(t *testing.T) {
+	db, err := database.OpenTester()
+	require.Nil(t, err)
+	db.CreateTable(&Notification{})
+	db.Create(example.Select())
+	SetDB(db)
+}
+
+func TestFind(t *testing.T) {
+	Append(example)
+	itemer, err := Find(example.Method)
+	require.Nil(t, err)
+
+	item := itemer.Select()
+	require.NotNil(t, item)
+
+	assert.Equal(t, "example", item.Method)
+	assert.Len(t, allNotifiers, 1)
+}
+
+func TestAll(t *testing.T) {
+	items := All()
+	assert.Len(t, items, 1)
+	assert.Len(t, allNotifiers, 1)
+}
+
+func TestCreate(t *testing.T) {
+	assert.Len(t, allNotifiers, 1)
+
+	example := &Notification{
+		Method:      "anotherexample",
+		Title:       "Example 2",
+		Description: "New Message here",
+	}
+	err := example.Create()
+	require.Nil(t, err)
+	assert.NotZero(t, example.Id)
+	assert.Equal(t, "anotherexample", example.Method)
+	assert.Equal(t, "Example 2", example.Title)
+	assert.NotZero(t, example.CreatedAt)
+
+	items := All()
+	assert.Len(t, items, 2)
+	assert.Len(t, allNotifiers, 2)
+}
+
+func TestUpdate(t *testing.T) {
+	itemer, err := Find("anotherexample")
+	require.Nil(t, err)
+	require.NotNil(t, itemer)
+
+	item := itemer.Select()
+	require.NotNil(t, item)
+
+	item.Host = "Updated Host Var"
+	err = item.Update()
+	require.Nil(t, err)
+	assert.Equal(t, "Updated Host Var", item.Host)
+}
+
+func TestDelete(t *testing.T) {
+	all := All()
+	assert.Len(t, all, 2)
+
+	itemer, err := Find("example2")
+	require.Nil(t, err)
+
+	item := itemer.Select()
+	require.NotNil(t, item)
+
+	err = item.Delete()
+	require.Nil(t, err)
+
+	all = All()
+	assert.Len(t, all, 2)
+}
+
+func TestClose(t *testing.T) {
+	assert.Nil(t, db.Close())
+}
diff --git a/types/notifications/struct.go b/types/notifications/struct.go
index fdf2ca8d..61c624cd 100644
--- a/types/notifications/struct.go
+++ b/types/notifications/struct.go
@@ -152,7 +152,7 @@ func reverseLogs(input []*NotificationLog) []*NotificationLog {
 // SelectNotification returns the Notification struct from the database
 func SelectNotification(n Notifier) (*Notification, error) {
 	notifier := n.Select()
-	err := DB().Where("method = ?", notifier.Method).Find(&notifier)
+	err := db.Where("method = ?", notifier.Method).Find(&notifier)
 	return notifier, err.Error()
 }
 
diff --git a/types/null/null_test.go b/types/null/null_test.go
new file mode 100644
index 00000000..395c093e
--- /dev/null
+++ b/types/null/null_test.go
@@ -0,0 +1,29 @@
+package null
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestNewNullBool(t *testing.T) {
+	val := NewNullBool(true)
+	assert.True(t, val.Bool)
+
+	val = NewNullBool(false)
+	assert.False(t, val.Bool)
+}
+
+func TestNewNullInt64(t *testing.T) {
+	val := NewNullInt64(29)
+	assert.Equal(t, int64(29), val.Int64)
+}
+
+func TestNewNullString(t *testing.T) {
+	val := NewNullString("statping.com")
+	assert.Equal(t, "statping.com", val.String)
+}
+
+func TestNewNullFloat64(t *testing.T) {
+	val := NewNullFloat64(42.222)
+	assert.Equal(t, float64(42.222), val.Float64)
+}
diff --git a/types/services/checkins.go b/types/services/checkins.go
index 79a47ae9..4b8abbd4 100644
--- a/types/services/checkins.go
+++ b/types/services/checkins.go
@@ -1,7 +1,6 @@
 package services
 
 import (
-	"github.com/statping/statping/database"
 	"github.com/statping/statping/types/checkins"
 )
 
@@ -15,6 +14,6 @@ func CheckinProcess(s *Service) {
 
 func (s *Service) Checkins() []*checkins.Checkin {
 	var chks []*checkins.Checkin
-	database.DB().Where("service = ?", s.Id).Find(&chks)
+	db.Where("service = ?", s.Id).Find(&chks)
 	return chks
 }
diff --git a/types/services/database.go b/types/services/database.go
index 1d276086..2a3c8862 100644
--- a/types/services/database.go
+++ b/types/services/database.go
@@ -10,8 +10,10 @@ import (
 
 var log = utils.Log
 
-func DB() database.Database {
-	return database.DB().Model(&Service{})
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&Service{})
 }
 
 func Find(id int64) (*Service, error) {
@@ -24,7 +26,7 @@ func Find(id int64) (*Service, error) {
 
 func all() []*Service {
 	var services []*Service
-	DB().Find(&services)
+	db.Find(&services)
 	return services
 }
 
@@ -42,17 +44,21 @@ func AllInOrder() []Service {
 }
 
 func (s *Service) Create() error {
-	err := DB().Create(s)
+	err := db.Create(s)
 	if err.Error() != nil {
 		log.Errorln(fmt.Sprintf("Failed to create service %v #%v: %v", s.Name, s.Id, err))
 		return err.Error()
 	}
+	return nil
+}
+
+func (s *Service) AfterCreate() error {
 	allServices[s.Id] = s
 	return nil
 }
 
 func (s *Service) Update() error {
-	db := DB().Update(s)
+	q := db.Update(s)
 
 	allServices[s.Id] = s
 
@@ -68,20 +74,49 @@ func (s *Service) Update() error {
 
 	//notifier.OnUpdatedService(s.Service)
 
-	return db.Error()
+	return q.Error()
 }
 
 func (s *Service) Delete() error {
-	db := database.DB().Delete(s)
-
 	s.Close()
-	delete(allServices, s.Id)
-	//notifier.OnDeletedService(s.Service)
 
-	return db.Error()
+	if err := s.DeleteFailures(); err != nil {
+		return err
+	}
+	if err := s.DeleteHits(); err != nil {
+		return err
+	}
+
+	delete(allServices, s.Id)
+
+	q := db.Model(&Service{}).Delete(s)
+	//notifier.OnDeletedService(s.Service)
+	return q.Error()
 }
 
 func (s *Service) DeleteFailures() error {
-	query := database.DB().Exec(`DELETE FROM failures WHERE service = ?`, s.Id)
-	return query.Error()
+	return s.AllFailures().DeleteAll()
+}
+
+func (s *Service) DeleteHits() error {
+	return s.AllHits().DeleteAll()
+}
+
+func (s *Service) DeleteCheckins() error {
+	for _, c := range s.Checkins() {
+		if err := c.Delete(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+//func (s *Service) AfterDelete() error {
+//
+//	return nil
+//}
+
+func (s *Service) AfterFind() error {
+	s.UpdateStats()
+	return nil
 }
diff --git a/types/services/failures.go b/types/services/failures.go
index d35d683a..fe5badcf 100644
--- a/types/services/failures.go
+++ b/types/services/failures.go
@@ -15,26 +15,13 @@ func (s *Service) AllFailures() failures.Failurer {
 	return failures.AllFailures(s)
 }
 
-func (s *Service) LastFailure() *failures.Failure {
-	var fail failures.Failure
-	failures.DB().Where("service = ?", s.Id).Order("id desc").Limit(1).Find(&fail)
-	return &fail
-}
-
-func (s *Service) FailuresCount() int {
-	var amount int
-	failures.DB().Where("service = ?", s.Id).Count(&amount)
-	return amount
-}
-
-func (s *Service) FailuresSince(t time.Time) []*failures.Failure {
-	var fails []*failures.Failure
-	failures.DB().Where("service = ?", s.Id).Find(&fails)
+func (s *Service) FailuresSince(t time.Time) failures.Failurer {
+	fails := failures.Since(t, s)
 	return fails
 }
 
 func (s *Service) DowntimeText() string {
-	last := s.LastFailure()
+	last := s.AllFailures().Last()
 	if last == nil {
 		return ""
 	}
diff --git a/types/services/hits.go b/types/services/hits.go
index c1f57a9c..789027d7 100644
--- a/types/services/hits.go
+++ b/types/services/hits.go
@@ -22,5 +22,5 @@ func (s *Service) AllHits() hits.Hitters {
 }
 
 func (s *Service) HitsSince(t time.Time) hits.Hitters {
-	return hits.HitsSince(t, s)
+	return hits.Since(t, s)
 }
diff --git a/types/services/methods.go b/types/services/methods.go
index 7c7bb333..eda51229 100644
--- a/types/services/methods.go
+++ b/types/services/methods.go
@@ -4,6 +4,7 @@ import (
 	"crypto/sha1"
 	"encoding/hex"
 	"fmt"
+	"github.com/statping/statping/types"
 	"github.com/statping/statping/types/null"
 	"github.com/statping/statping/utils"
 	"net/url"
@@ -33,6 +34,13 @@ func (s *Service) Close() {
 	}
 }
 
+func humanMicro(val int64) string {
+	if val < 10000 {
+		return fmt.Sprintf("%d μs", val)
+	}
+	return fmt.Sprintf("%0.0f ms", float64(val)*0.001)
+}
+
 // IsRunning returns true if the service go routine is running
 func (s *Service) IsRunning() bool {
 	if s.Running == nil {
@@ -68,7 +76,7 @@ func SelectAllServices(start bool) (map[int64]*Service, error) {
 			CheckinProcess(s)
 		}
 
-		fails := s.AllFailures().Last(limitedFailures)
+		fails := s.AllFailures().LastAmount(limitedFailures)
 		s.Failures = fails
 
 		for _, c := range s.Checkins() {
@@ -137,12 +145,12 @@ func (s *Service) UpdateStats() *Service {
 	s.Online24Hours = s.OnlineDaysPercent(1)
 	s.Online7Days = s.OnlineDaysPercent(7)
 	s.AvgResponse = s.AvgTime()
-	s.FailuresLast24Hours = len(s.AllFailures().Since(utils.Now().Add(-time.Hour * 24)))
+	s.FailuresLast24Hours = s.FailuresSince(utils.Now().Add(-time.Hour * 24)).Count()
 
 	if s.LastOffline.IsZero() {
-		lastFail := s.LastFailure()
+		lastFail := s.AllFailures().Last()
 		if lastFail != nil {
-			s.LastOffline = s.LastFailure().CreatedAt
+			s.LastOffline = lastFail.CreatedAt
 		}
 	}
 
@@ -155,29 +163,31 @@ func (s *Service) UpdateStats() *Service {
 }
 
 // AvgTime will return the average amount of time for a service to response back successfully
-func (s *Service) AvgTime() int64 {
+func (s *Service) AvgTime() float64 {
 	return s.AllHits().Avg()
 }
 
 // OnlineDaysPercent returns the service's uptime percent within last 24 hours
 func (s *Service) OnlineDaysPercent(days int) float32 {
-	ago := utils.Now().Add((-24 * time.Duration(days)) * time.Hour)
+	ago := utils.Now().Add(-time.Duration(days) * types.Day)
 	return s.OnlineSince(ago)
 }
 
 // OnlineSince accepts a time since parameter to return the percent of a service's uptime.
 func (s *Service) OnlineSince(ago time.Time) float32 {
-	failed := s.AllFailures().Since(ago)
-	if len(failed) == 0 {
+	failed := s.FailuresSince(ago)
+	failsList := failed.List()
+	if len(failsList) == 0 {
 		s.Online24Hours = 100.00
 		return s.Online24Hours
 	}
-	total := s.AllHits().Since(ago)
-	if len(total) == 0 {
+	total := s.HitsSince(ago)
+	hitsList := total.List()
+	if len(hitsList) == 0 {
 		s.Online24Hours = 0
 		return s.Online24Hours
 	}
-	avg := float64(len(failed)) / float64(len(total)) * 100
+	avg := float64(len(hitsList)) / float64(len(failsList)) * 100
 	avg = 100 - avg
 	if avg < 0 {
 		avg = 0
@@ -190,12 +200,12 @@ func (s *Service) OnlineSince(ago time.Time) float32 {
 // Downtime returns the amount of time of a offline service
 func (s *Service) Downtime() time.Duration {
 	hit := s.LastHit()
-	fail := s.LastFailure()
+	fail := s.AllFailures().Last()
 	if hit == nil {
 		return time.Duration(0)
 	}
 	if fail == nil {
-		return utils.Now().Sub(fail.CreatedAt)
+		return utils.Now().Sub(hit.CreatedAt)
 	}
 
 	return fail.CreatedAt.Sub(hit.CreatedAt)
diff --git a/types/services/routine.go b/types/services/routine.go
index d1627b0b..0eb86ac7 100644
--- a/types/services/routine.go
+++ b/types/services/routine.go
@@ -64,9 +64,9 @@ func parseHost(s *Service) string {
 }
 
 // dnsCheck will check the domain name and return a float64 for the amount of time the DNS check took
-func dnsCheck(s *Service) (float64, error) {
+func dnsCheck(s *Service) (int64, error) {
 	var err error
-	t1 := time.Now()
+	t1 := utils.Now()
 	host := parseHost(s)
 	if s.Type == "tcp" {
 		_, err = net.LookupHost(host)
@@ -77,7 +77,7 @@ func dnsCheck(s *Service) (float64, error) {
 		return 0, err
 	}
 	t2 := time.Now()
-	subTime := t2.Sub(t1).Seconds()
+	subTime := t2.Sub(t1).Microseconds()
 	return subTime, err
 }
 
@@ -101,7 +101,7 @@ func CheckIcmp(s *Service, record bool) *Service {
 	}
 	p.AddIPAddr(ra)
 	p.OnRecv = func(addr *net.IPAddr, rtt time.Duration) {
-		s.Latency = rtt.Seconds()
+		s.Latency = rtt.Microseconds()
 		recordSuccess(s)
 	}
 	err = p.Run()
@@ -125,7 +125,7 @@ func CheckTcp(s *Service, record bool) *Service {
 		return s
 	}
 	s.PingTime = dnsLookup
-	t1 := time.Now()
+	t1 := utils.Now()
 	domain := fmt.Sprintf("%v", s.Domain)
 	if s.Port != 0 {
 		domain = fmt.Sprintf("%v:%v", s.Domain, s.Port)
@@ -146,8 +146,8 @@ func CheckTcp(s *Service, record bool) *Service {
 		}
 		return s
 	}
-	t2 := time.Now()
-	s.Latency = t2.Sub(t1).Seconds()
+	t2 := utils.Now()
+	s.Latency = t2.Sub(t1).Microseconds()
 	s.LastResponse = ""
 	if record {
 		recordSuccess(s)
@@ -171,7 +171,7 @@ func CheckHttp(s *Service, record bool) *Service {
 		return s
 	}
 	s.PingTime = dnsLookup
-	t1 := time.Now()
+	t1 := utils.Now()
 
 	timeout := time.Duration(s.Timeout) * time.Second
 	var content []byte
@@ -195,8 +195,8 @@ func CheckHttp(s *Service, record bool) *Service {
 		}
 		return s
 	}
-	t2 := time.Now()
-	s.Latency = t2.Sub(t1).Seconds()
+	t2 := utils.Now()
+	s.Latency = t2.Sub(t1).Microseconds()
 	s.LastResponse = string(content)
 	s.LastStatusCode = res.StatusCode
 
@@ -226,21 +226,21 @@ func CheckHttp(s *Service, record bool) *Service {
 
 // recordSuccess will create a new 'hit' record in the database for a successful/online service
 func recordSuccess(s *Service) {
-	s.LastOnline = time.Now().UTC()
+	s.LastOnline = utils.Now()
 	s.Online = true
 	hit := &hits.Hit{
 		Service:   s.Id,
 		Latency:   s.Latency,
 		PingTime:  s.PingTime,
-		CreatedAt: time.Now().UTC(),
+		CreatedAt: utils.Now(),
 	}
 	if err := hit.Create(); err != nil {
 		log.Error(err)
 	}
 	log.WithFields(utils.ToFields(hit, s)).Infoln(
-		fmt.Sprintf("Service #%d '%v' Successful Response: %0.2f ms | Lookup in: %0.2f ms | Online: %v | Interval: %d seconds", s.Id, s.Name, hit.Latency*1000, hit.PingTime*1000, s.Online, s.Interval))
-	s.LastLookupTime = int64(hit.PingTime * 1000)
-	s.LastLatency = int64(hit.Latency * 1000)
+		fmt.Sprintf("Service #%d '%v' Successful Response: %s | Lookup in: %s | Online: %v | Interval: %d seconds", s.Id, s.Name, humanMicro(hit.Latency), humanMicro(hit.PingTime), s.Online, s.Interval))
+	s.LastLookupTime = hit.PingTime
+	s.LastLatency = hit.Latency
 	//notifier.OnSuccess(s)
 	s.SuccessNotified = true
 }
diff --git a/types/services/services_test.go b/types/services/services_test.go
new file mode 100644
index 00000000..25982b1b
--- /dev/null
+++ b/types/services/services_test.go
@@ -0,0 +1,285 @@
+package services
+
+import (
+	"fmt"
+	"github.com/statping/statping/database"
+	"github.com/statping/statping/types/checkins"
+	"github.com/statping/statping/types/failures"
+	"github.com/statping/statping/types/hits"
+	"github.com/statping/statping/types/null"
+	"github.com/statping/statping/utils"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
+)
+
+var example = &Service{
+	Name:           "Example Service",
+	Domain:         "https://statping.com",
+	ExpectedStatus: 200,
+	Interval:       30,
+	Type:           "http",
+	Method:         "GET",
+	Timeout:        5,
+	Order:          1,
+	VerifySSL:      null.NewNullBool(true),
+	Public:         null.NewNullBool(true),
+	GroupId:        1,
+	Permalink:      null.NewNullString("statping"),
+	LastCheck:      utils.Now().Add(-5 * time.Second),
+	LastOffline:    utils.Now().Add(-5 * time.Second),
+	LastOnline:     utils.Now().Add(-60 * time.Second),
+}
+
+var hit1 = &hits.Hit{
+	Service:   1,
+	Latency:   0.1234,
+	PingTime:  0.01234,
+	CreatedAt: utils.Now().Add(-120 * time.Second),
+}
+
+var hit2 = &hits.Hit{
+	Service:   1,
+	Latency:   0.2345,
+	PingTime:  0.02345,
+	CreatedAt: utils.Now().Add(-60 * time.Second),
+}
+
+var hit3 = &hits.Hit{
+	Service:   1,
+	Latency:   0.3456,
+	PingTime:  0.03456,
+	CreatedAt: utils.Now().Add(-30 * time.Second),
+}
+
+var exmapleCheckin = &checkins.Checkin{
+	ServiceId:   1,
+	Name:        "Example Checkin",
+	Interval:    60,
+	GracePeriod: 30,
+	ApiKey:      "wdededede",
+}
+
+var fail1 = &failures.Failure{
+	Issue:     "example not found",
+	ErrorCode: 404,
+	Service:   1,
+	PingTime:  0.0123,
+	CreatedAt: utils.Now().Add(-160 * time.Second),
+}
+
+var fail2 = &failures.Failure{
+	Issue:     "example 2 not found",
+	ErrorCode: 500,
+	Service:   1,
+	PingTime:  0.0123,
+	CreatedAt: utils.Now().Add(-5 * time.Second),
+}
+
+func TestInit(t *testing.T) {
+	db, err := database.OpenTester()
+	require.Nil(t, err)
+	db.AutoMigrate(&Service{}, &hits.Hit{}, &checkins.Checkin{}, &checkins.CheckinHit{}, &failures.Failure{})
+	db.Create(&example)
+	db.Create(&hit1)
+	db.Create(&hit2)
+	db.Create(&hit3)
+	db.Create(&exmapleCheckin)
+	db.Create(&fail1)
+	db.Create(&fail2)
+	checkins.SetDB(db)
+	failures.SetDB(db)
+	hits.SetDB(db)
+	SetDB(db)
+}
+
+func TestFind(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Equal(t, "Example Service", item.Name)
+	assert.NotZero(t, item.LastOnline)
+	assert.NotZero(t, item.LastOffline)
+	assert.NotZero(t, item.LastCheck)
+}
+
+func TestAll(t *testing.T) {
+	items := All()
+	assert.Len(t, items, 1)
+}
+
+func TestService_Checkins(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Len(t, item.Checkins(), 1)
+}
+
+func TestService_AllHits(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Len(t, item.AllHits().List(), 3)
+	assert.Equal(t, 3, item.AllHits().Count())
+}
+
+func TestService_AllFailures(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Len(t, item.AllFailures().List(), 2)
+	assert.Equal(t, 2, item.AllFailures().Count())
+}
+
+func TestService_FirstHit(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	hit := item.FirstHit()
+	assert.Equal(t, int64(1), hit.Id)
+}
+
+func TestService_LastHit(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	hit := item.AllHits().Last()
+	assert.Equal(t, int64(3), hit.Id)
+}
+
+func TestService_LastFailure(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	fail := item.AllFailures().Last()
+	assert.Equal(t, int64(2), fail.Id)
+}
+
+func TestService_Duration(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Equal(t, float64(30), item.Duration().Seconds())
+}
+
+func TestService_AvgTime(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	assert.Equal(t, "", item.AvgTime())
+}
+
+func TestService_HitsSince(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	count := item.HitsSince(utils.Now().Add(-30 * time.Second))
+	assert.Equal(t, 1, count.Count())
+
+	count = item.HitsSince(utils.Now().Add(-180 * time.Second))
+	assert.Equal(t, 3, count.Count())
+}
+
+func TestService_IsRunning(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.False(t, item.IsRunning())
+}
+
+func TestService_OnlineDaysPercent(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	amount := item.OnlineDaysPercent(1)
+
+	assert.Equal(t, "", amount)
+}
+
+func TestService_Downtime(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	amount := item.Downtime().Seconds()
+	assert.Equal(t, "25", fmt.Sprintf("%0.f", amount))
+}
+
+func TestService_FailuresSince(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	count := item.FailuresSince(utils.Now().Add(-6 * time.Second))
+	assert.Equal(t, 1, count.Count())
+
+	count = item.FailuresSince(utils.Now().Add(-180 * time.Second))
+	assert.Equal(t, 2, count.Count())
+}
+
+func TestCreate(t *testing.T) {
+	example := &Service{
+		Name:           "Example Service 2",
+		Domain:         "https://slack.statping.com",
+		ExpectedStatus: 200,
+		Interval:       10,
+		Type:           "http",
+		Method:         "GET",
+		Timeout:        5,
+		Order:          3,
+		VerifySSL:      null.NewNullBool(true),
+		Public:         null.NewNullBool(false),
+		GroupId:        1,
+		Permalink:      null.NewNullString("statping2"),
+	}
+	err := example.Create()
+	require.Nil(t, err)
+	assert.NotZero(t, example.Id)
+	assert.Equal(t, "Example Service 2", example.Name)
+	assert.False(t, example.Public.Bool)
+	assert.NotZero(t, example.CreatedAt)
+	assert.Equal(t, int64(2), example.Id)
+	assert.Len(t, allServices, 2)
+}
+
+func TestUpdate(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	item.Name = "Updated Service"
+	item.Order = 1
+	err = item.Update()
+	require.Nil(t, err)
+	assert.Equal(t, int64(1), item.Id)
+	assert.Equal(t, "Updated Service", item.Name)
+}
+
+func TestAllInOrder(t *testing.T) {
+	inOrder := AllInOrder()
+	assert.Len(t, inOrder, 2)
+	assert.Equal(t, "Updated Service", inOrder[0].Name)
+	assert.Equal(t, "Example Service 2", inOrder[1].Name)
+}
+
+func TestDelete(t *testing.T) {
+	all := All()
+	assert.Len(t, all, 2)
+
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Equal(t, int64(1), item.Id)
+
+	err = item.Delete()
+	require.Nil(t, err)
+
+	all = All()
+	assert.Len(t, all, 1)
+}
+
+func TestService_CheckService(t *testing.T) {
+	item, err := Find(2)
+	require.Nil(t, err)
+
+	hitsCount := item.AllHits().Count()
+	failsCount := item.AllFailures().Count()
+
+	assert.Equal(t, 3, hitsCount)
+	assert.Equal(t, 2, failsCount)
+
+	item.CheckService(true)
+
+	assert.Equal(t, 4, hitsCount)
+	assert.Equal(t, 2, failsCount)
+}
+
+func TestClose(t *testing.T) {
+	assert.Nil(t, db.Close())
+}
diff --git a/types/services/struct.go b/types/services/struct.go
index 650f3e69..4b523dbb 100644
--- a/types/services/struct.go
+++ b/types/services/struct.go
@@ -41,11 +41,11 @@ type Service struct {
 	CreatedAt           time.Time           `gorm:"column:created_at" json:"created_at"`
 	UpdatedAt           time.Time           `gorm:"column:updated_at" json:"updated_at"`
 	Online              bool                `gorm:"-" json:"online"`
-	Latency             float64             `gorm:"-" json:"latency"`
-	PingTime            float64             `gorm:"-" json:"ping_time"`
+	Latency             int64               `gorm:"-" json:"latency"`
+	PingTime            int64               `gorm:"-" json:"ping_time"`
 	Online24Hours       float32             `gorm:"-" json:"online_24_hours"`
 	Online7Days         float32             `gorm:"-" json:"online_7_days"`
-	AvgResponse         int64               `gorm:"-" json:"avg_response"`
+	AvgResponse         float64             `gorm:"-" json:"avg_response"`
 	FailuresLast24Hours int                 `gorm:"-" json:"failures_24_hours"`
 	Running             chan bool           `gorm:"-" json:"-"`
 	Checkpoint          time.Time           `gorm:"-" json:"-"`
diff --git a/types/users/database.go b/types/users/database.go
index c288a082..ffe351c2 100644
--- a/types/users/database.go
+++ b/types/users/database.go
@@ -4,56 +4,56 @@ import (
 	"github.com/prometheus/common/log"
 	"github.com/statping/statping/database"
 	"github.com/statping/statping/utils"
-	"time"
 )
 
-func DB() database.Database {
-	return database.DB().Model(&User{})
+var db database.Database
+
+func SetDB(database database.Database) {
+	db = database.Model(&User{})
 }
 
 func Find(id int64) (*User, error) {
 	var user User
-	db := DB().Where("id = ?", id).Find(&user)
-	return &user, db.Error()
+	q := db.Where("id = ?", id).Find(&user)
+	return &user, q.Error()
 }
 
 func FindByUsername(username string) (*User, error) {
 	var user User
-	db := DB().Where("username = ?", username).Find(&user)
-	return &user, db.Error()
+	q := db.Where("username = ?", username).Find(&user)
+	return &user, q.Error()
 }
 
 func All() []*User {
 	var users []*User
-	DB().Find(&users)
+	db.Find(&users)
 	return users
 }
 
 func (u *User) Create() error {
-	u.CreatedAt = time.Now().UTC()
-	u.Password = utils.HashPassword(u.Password)
-	if u.ApiKey == "" || u.ApiSecret == "" {
-		u.ApiKey = utils.NewSHA1Hash(16)
-		u.ApiSecret = utils.NewSHA1Hash(16)
-	}
-	db := DB().Create(u)
+	q := db.Create(u)
 	if db.Error() == nil {
 		log.Warnf("User #%d (%s) has been created", u.Id, u.Username)
 	}
-	return db.Error()
+	return q.Error()
 }
 
 func (u *User) Update() error {
-	//u.ApiKey = utils.NewSHA1Hash(5)
-	//u.ApiSecret = utils.NewSHA1Hash(10)
-	db := DB().Update(u)
-	return db.Error()
+	q := db.Update(u)
+	return q.Error()
 }
 
 func (u *User) Delete() error {
-	db := DB().Delete(u)
+	q := db.Delete(u)
 	if db.Error() == nil {
 		log.Warnf("User #%d (%s) has been deleted", u.Id, u.Username)
 	}
-	return db.Error()
+	return q.Error()
+}
+
+func (u *User) BeforeCreate() error {
+	u.Password = utils.HashPassword(u.Password)
+	u.ApiKey = utils.NewSHA1Hash(16)
+	u.ApiSecret = utils.NewSHA1Hash(16)
+	return nil
 }
diff --git a/types/users/struct.go b/types/users/struct.go
index e32e9715..8d1b790f 100644
--- a/types/users/struct.go
+++ b/types/users/struct.go
@@ -2,7 +2,6 @@ package users
 
 import (
 	"github.com/statping/statping/types/null"
-	"github.com/statping/statping/utils"
 	"time"
 )
 
@@ -18,14 +17,3 @@ type User struct {
 	CreatedAt time.Time     `gorm:"column:created_at" json:"created_at"`
 	UpdatedAt time.Time     `gorm:"column:updated_at" json:"updated_at"`
 }
-
-// BeforeCreate for User will set CreatedAt to UTC
-func (u *User) BeforeCreate() (err error) {
-	u.ApiKey = utils.RandomString(16)
-	u.ApiSecret = utils.RandomString(16)
-	if u.CreatedAt.IsZero() {
-		u.CreatedAt = time.Now().UTC()
-		u.UpdatedAt = time.Now().UTC()
-	}
-	return
-}
diff --git a/types/users/users_test.go b/types/users/users_test.go
new file mode 100644
index 00000000..ca1e4f57
--- /dev/null
+++ b/types/users/users_test.go
@@ -0,0 +1,92 @@
+package users
+
+import (
+	"github.com/statping/statping/database"
+	"github.com/statping/statping/types/null"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+var example = &User{
+	Username: "example_user",
+	Email:    "Description here",
+	Password: "password123",
+	Admin:    null.NewNullBool(true),
+}
+
+func TestInit(t *testing.T) {
+	db, err := database.OpenTester()
+	require.Nil(t, err)
+	db.CreateTable(&User{})
+	db.Create(&example)
+	SetDB(db)
+}
+
+func TestFind(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	assert.Equal(t, "example_user", item.Username)
+	assert.NotEmpty(t, item.ApiKey)
+	assert.NotEmpty(t, item.ApiSecret)
+	assert.NotEqual(t, "password123", item.Password)
+	assert.True(t, item.Admin.Bool)
+}
+
+func TestFindByUsername(t *testing.T) {
+	item, err := FindByUsername("example_user")
+	require.Nil(t, err)
+	assert.Equal(t, "example_user", item.Username)
+	assert.NotEmpty(t, item.ApiKey)
+	assert.NotEmpty(t, item.ApiSecret)
+	assert.NotEqual(t, "password123", item.Password)
+	assert.True(t, item.Admin.Bool)
+}
+
+func TestAll(t *testing.T) {
+	items := All()
+	assert.Len(t, items, 1)
+}
+
+func TestCreate(t *testing.T) {
+	example := &User{
+		Username: "exampleuser2",
+		Password: "password12345",
+		Email:    "info@yahoo.com",
+	}
+	err := example.Create()
+	require.Nil(t, err)
+	assert.NotZero(t, example.Id)
+	assert.Equal(t, "exampleuser2", example.Username)
+	assert.NotEqual(t, "password12345", example.Password)
+	assert.NotZero(t, example.CreatedAt)
+	assert.NotEmpty(t, example.ApiKey)
+	assert.NotEmpty(t, example.ApiSecret)
+}
+
+func TestUpdate(t *testing.T) {
+	item, err := Find(1)
+	require.Nil(t, err)
+	item.Username = "updated_user"
+	err = item.Update()
+	require.Nil(t, err)
+	assert.Equal(t, "updated_user", item.Username)
+}
+
+func TestDelete(t *testing.T) {
+	all := All()
+	assert.Len(t, all, 2)
+
+	item, err := Find(1)
+	require.Nil(t, err)
+
+	err = item.Delete()
+	require.Nil(t, err)
+
+	all = All()
+	assert.Len(t, all, 1)
+}
+
+func TestClose(t *testing.T) {
+	assert.Nil(t, db.Close())
+}