Merge pull request #9 from eiladin/unit-tests

Add unit-tests

go.mod

@@ -6,10 +6,13 @@ require (
 	github.com/fsnotify/fsnotify v1.4.9 // indirect
 	github.com/gofiber/cors v0.2.2
 	github.com/gofiber/fiber v1.13.3
+	github.com/jarcoal/httpmock v1.0.5
 	github.com/klauspost/compress v1.10.10 // indirect
 	github.com/pelletier/go-toml v1.8.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/spf13/viper v1.4.0
+	github.com/stretchr/testify v1.5.1
+	github.com/valyala/fasthttp v1.15.1
 	golang.org/x/sys v0.0.0-20200728102440-3e129f6d46b1 // indirect
 	gorm.io/driver/mysql v0.3.1
 	gorm.io/driver/postgres v0.2.6

go.sum

@@ -116,6 +116,8 @@ github.com/jackc/puddle v0.0.0-20190413234325-e4ced69a3a2b/go.mod h1:m4B5Dj62Y0f
 github.com/jackc/puddle v0.0.0-20190608224051-11cab39313c9/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v1.1.0/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jackc/puddle v1.1.1/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
+github.com/jarcoal/httpmock v1.0.5 h1:cHtVEcTxRSX4J0je7mWPfc9BpDpqzXSJ5HbymZmyHck=
+github.com/jarcoal/httpmock v1.0.5/go.mod h1:ATjnClrvW/3tijVmpL/va5Z3aAyGvqU3gCT8nX0Txik=
 github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
 github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
 github.com/jinzhu/now v1.1.1 h1:g39TucaRWyV3dwDO++eEc6qf8TVIQ/Da48WmqjZ3i7E=

internal/database/database.go

@@ -7,18 +7,21 @@ import (
 	"strings"
 
 	"github.com/eiladin/go-simple-startpage/internal/config"
+	"github.com/eiladin/go-simple-startpage/pkg/interfaces"
 	"gorm.io/driver/mysql"
 	"gorm.io/driver/postgres"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
 	"gorm.io/gorm/logger"
 )
 
-// DBConn holds the database connection
-var DBConn *gorm.DB
+// DB structure
+type DB struct {
+	DB *gorm.DB
+}
 
 // InitDB initialized the selected database
-func InitDB() {
+func InitDB() *gorm.DB {
 	var err error
 	c := config.GetConfig()
 
@@ -42,26 +45,43 @@ func InitDB() {
 	}
 
 	if driver == "sqlite" {
-		DBConn, err = gorm.Open(sqlite.Open(database), cfg)
+		conn, err := gorm.Open(sqlite.Open(database), cfg)
 		if err != nil {
 			fmt.Println("db err: ", err)
 		}
+		return conn
 	} else if driver == "postgres" {
 		dsn := fmt.Sprintf("host=%s port=%s user=%s dbname=%s sslmode=disable password=%s", host, port, username, database, password)
-		DBConn, err = gorm.Open(postgres.Open(dsn), cfg)
+		conn, err := gorm.Open(postgres.Open(dsn), cfg)
 		if err != nil {
 			fmt.Println("db err: ", err)
 		}
+		return conn
 	} else if driver == "mysql" {
 		dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, database)
-		DBConn, err = gorm.Open(mysql.Open(dsn), cfg)
-		if err != nil {
-			fmt.Println("db err: ", err)
-		}
-	} else {
-		DBConn, err = gorm.Open(sqlite.Open("simple-startpage.db"), &gorm.Config{})
+		conn, err := gorm.Open(mysql.Open(dsn), cfg)
 		if err != nil {
 			fmt.Println("db err: ", err)
 		}
+		return conn
+	}
+	conn, err := gorm.Open(sqlite.Open("simple-startpage.db"), &gorm.Config{})
+	if err != nil {
+		fmt.Println("db err: ", err)
 	}
+	return conn
+}
+
+// CreateNetwork creates a network in the database
+func (d *DB) CreateNetwork(net *interfaces.Network) {
+	d.DB.Unscoped().Where("1 = 1").Delete(&interfaces.Tag{})
+	d.DB.Unscoped().Where("1 = 1").Delete(&interfaces.Site{})
+	d.DB.Unscoped().Where("1 = 1").Delete(&interfaces.Link{})
+	d.DB.Unscoped().Where("1 = 1").Delete(&interfaces.Network{})
+	d.DB.Create(&net)
+}
+
+// FindNetwork reads a network from the database
+func (d *DB) FindNetwork(net *interfaces.Network) {
+	d.DB.Preload("Sites.Tags").Preload("Sites").Preload("Links").Find(&net)
 }

internal/network/network.go

@@ -1,33 +1,32 @@
 package network
 
 import (
-	"github.com/eiladin/go-simple-startpage/internal/database"
+	"github.com/eiladin/go-simple-startpage/pkg/interfaces"
 	"github.com/gofiber/fiber"
 )
 
+// Handler handles Network commands
+type Handler struct {
+	NetworkService interfaces.NetworkService
+}
+
 // GetNetwork handles /api/network
-func GetNetwork(c *fiber.Ctx) {
-	db := database.DBConn
-	var net Network
-	db.Preload("Sites.Tags").Preload("Sites").Preload("Links").Find(&net)
+func (h Handler) GetNetwork(c *fiber.Ctx) {
+	var net interfaces.Network
+	h.NetworkService.FindNetwork(&net)
 	c.Status(fiber.StatusOK).JSON(net)
 }
 
 // NewNetwork handles /api/network
-func NewNetwork(c *fiber.Ctx) {
-	var net Network
+func (h Handler) NewNetwork(c *fiber.Ctx) {
+	var net interfaces.Network
 	err := c.BodyParser(&net)
 	if err != nil {
 		c.Status(fiber.StatusBadRequest)
 		return
 	}
 
-	db := database.DBConn
-	db.Unscoped().Where("1 = 1").Delete(&Tag{})
-	db.Unscoped().Where("1 = 1").Delete(&Site{})
-	db.Unscoped().Where("1 = 1").Delete(&Link{})
-	db.Unscoped().Where("1 = 1").Delete(&Network{})
-	db.Create(&net)
+	h.NetworkService.CreateNetwork(&net)
 
 	c.Status(fiber.StatusOK).JSON(fiber.Map{
 		"id": net.ID,

internal/network/network_test.go

@@ -0,0 +1,79 @@
+package network
+
+import (
+	"testing"
+
+	"github.com/eiladin/go-simple-startpage/pkg/interfaces"
+	"github.com/gofiber/fiber"
+	"github.com/stretchr/testify/assert"
+	"github.com/valyala/fasthttp"
+)
+
+type mockNetworkService struct {
+	CreateNetworkFunc func(*interfaces.Network)
+	FindNetworkFunc   func(*interfaces.Network)
+}
+
+func (m *mockNetworkService) CreateNetwork(net *interfaces.Network) {
+	m.CreateNetworkFunc(net)
+}
+
+func (m *mockNetworkService) FindNetwork(net *interfaces.Network) {
+	m.FindNetworkFunc(net)
+}
+
+func TestNewNetwork(t *testing.T) {
+	app := fiber.New()
+	ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+
+	body := `{ "network": "test-network" }`
+
+	ctx.Fasthttp.Request.Header.SetContentType(fiber.MIMEApplicationJSON)
+	ctx.Fasthttp.Request.SetBody([]byte(body))
+	ctx.Fasthttp.Request.Header.SetContentLength(len(body))
+
+	defer app.ReleaseCtx(ctx)
+	var store mockNetworkService
+	store.CreateNetworkFunc = func(net *interfaces.Network) {
+		net.ID = 12345
+	}
+	handler := Handler{NetworkService: &store}
+	handler.NewNetwork(ctx)
+
+	assert.Equal(t, `{"id":12345}`, string(ctx.Fasthttp.Response.Body()))
+}
+
+func TestNewNetworkError(t *testing.T) {
+	app := fiber.New()
+	ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+
+	body := `{ "network": "test-network" }`
+
+	ctx.Fasthttp.Request.SetBody([]byte(body))
+	ctx.Fasthttp.Request.Header.SetContentLength(len(body))
+
+	defer app.ReleaseCtx(ctx)
+	var store mockNetworkService
+	store.CreateNetworkFunc = func(net *interfaces.Network) {
+		net.ID = 12345
+	}
+	handler := Handler{NetworkService: &store}
+	handler.NewNetwork(ctx)
+
+	assert.Equal(t, fasthttp.StatusBadRequest, ctx.Fasthttp.Response.StatusCode())
+}
+
+func TestFindNetwork(t *testing.T) {
+	app := fiber.New()
+	ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
+	defer app.ReleaseCtx(ctx)
+	var store mockNetworkService
+	store.FindNetworkFunc = func(net *interfaces.Network) {
+		net.ID = 12345
+		net.Network = "test-network"
+	}
+	handler := Handler{NetworkService: &store}
+	handler.GetNetwork(ctx)
+
+	assert.Equal(t, `{"network":"test-network","links":null,"sites":null}`, string(ctx.Fasthttp.Response.Body()))
+}

internal/network/status.go

@@ -1,7 +1,6 @@
 package network
 
 import (
-	"context"
 	"crypto/tls"
 	"fmt"
 	"net"
@@ -10,19 +9,20 @@ import (
 	"time"
 
 	"github.com/eiladin/go-simple-startpage/internal/config"
+	"github.com/eiladin/go-simple-startpage/pkg/interfaces"
 	"github.com/gofiber/fiber"
 )
 
-func (s *Site) updateStatus() error {
+func updateStatus(s *interfaces.Site) error {
 	url, err := url.Parse(s.URI)
 	if err != nil {
 		return fmt.Errorf("Unable to parse URI: %s", s.URI)
 	}
 	s.IP = getIP(url)
 	if url.Scheme == "ssh" {
-		return s.testSSH(url)
+		return testSSH(s, url)
 	}
-	return s.testHTTP(url)
+	return testHTTP(s, url)
 }
 
 func getIP(u *url.URL) string {
@@ -34,7 +34,7 @@ func getIP(u *url.URL) string {
 	return ips[0].String()
 }
 
-func (s *Site) testSSH(u *url.URL) error {
+func testSSH(s *interfaces.Site, u *url.URL) error {
 	conn, err := net.Dial("tcp", u.Host)
 	if err != nil {
 		return err
@@ -44,18 +44,17 @@ func (s *Site) testSSH(u *url.URL) error {
 	return nil
 }
 
-func (s *Site) testHTTP(u *url.URL) error {
+var httpClient = http.Client{
+	Transport: &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	},
+}
+
+func testHTTP(s *interfaces.Site, u *url.URL) error {
 	c := config.GetConfig()
-	dialer := &net.Dialer{
-		Timeout: time.Duration(c.HealthCheck.Timeout) * time.Millisecond,
-	}
-	http.DefaultTransport.(*http.Transport).DialContext =
-		func(ctx context.Context, network, addr string) (net.Conn, error) {
-			return dialer.DialContext(ctx, network, addr)
-		}
-	http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
+	httpClient.Timeout = time.Millisecond * time.Duration(c.HealthCheck.Timeout)
 
-	r, err := http.Get(s.URI)
+	r, err := httpClient.Get(u.String())
 	if err != nil {
 		return err
 	}
@@ -68,14 +67,14 @@ func (s *Site) testHTTP(u *url.URL) error {
 }
 
 // UpdateStatus handles /api/status
-func UpdateStatus(c *fiber.Ctx) {
-	var s Site
+func (h Handler) UpdateStatus(c *fiber.Ctx) {
+	var s interfaces.Site
 	err := c.BodyParser(&s)
 	if err != nil {
 		c.Status(fiber.StatusBadRequest)
 		return
 	}
-	err = s.updateStatus()
+	err = updateStatus(&s)
 	if err != nil {
 		c.Status(fiber.StatusInternalServerError).JSON(fiber.Map{
 			"error": err.Error(),