github
/
statping
mirror of https://github.com/statping/statping
1
0
Fork 0
Code Issues Releases Wiki Activity

testing

pull/44/merge
Hunter Long 2018-07-27 18:50:13 -07:00
parent e79ce2d145
commit 9a08214ad4
21 changed files with 333 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/cli.go
View File

@ -27,9 +27,9 @@ func CatchCLI(args []string) {
fmt.Printf("Statup v%v\n", VERSION)
case "assets":
core.RenderBoxes()
core.CreateAllAssets()
core.CreateAllAssets(".")
case "sass":
core.CompileSASS()
core.CompileSASS(".")
case "update":
gitCurrent, err := CheckGithubUpdates()
if err != nil {
@ -93,7 +93,7 @@ func RunOnce() {
if err != nil {
utils.Log(4, "config.yml file not found")
}
err = core.DbConnection(core.Configs.Connection, false, "")
err = core.DbConnection(core.Configs.Connection, false, ".")
if err != nil {
utils.Log(4, err)
}

9
cmd/main.go
View File

@ -15,8 +15,9 @@ import (
)
var (
VERSION string
usingEnv bool
VERSION string
usingEnv bool
directory string
)
func init() {
@ -33,7 +34,7 @@ func main() {
}
utils.Log(1, fmt.Sprintf("Starting Statup v%v", VERSION))
core.RenderBoxes()
core.HasAssets()
core.HasAssets(directory)
core.Configs, err = core.LoadConfig()
if err != nil {
@ -55,7 +56,7 @@ func LoadDotEnvs() error {
func mainProcess() {
var err error
err = core.DbConnection(core.Configs.Connection, false, "")
err = core.DbConnection(core.Configs.Connection, false, ".")
if err != nil {
utils.Log(4, fmt.Sprintf("could not connect to database: %v", err))
}

30
cmd/main_test.go
View File

@ -7,6 +7,7 @@ import (
"github.com/hunterlong/statup/handlers"
"github.com/hunterlong/statup/notifiers"
"github.com/hunterlong/statup/types"
"github.com/hunterlong/statup/utils"
"github.com/rendon/testcli"
"github.com/stretchr/testify/assert"
"net/http"
@ -25,14 +26,14 @@ var (
func init() {
gopath := os.Getenv("GOPATH")
gopath += "/src/github.com/hunterlong/statup/"
gopath += "/src/github.com/hunterlong/statup"
}
func RunInit(t *testing.T) {
core.RenderBoxes()
os.Remove(gopath + "statup.db")
os.Remove(gopath + "cmd/config.yml")
os.Remove(gopath + "cmd/index.html")
os.Remove(gopath + "/statup.db")
os.Remove(gopath + "/cmd/config.yml")
os.Remove(gopath + "/cmd/index.html")
route = handlers.Router()
LoadDotEnvs()
core.CoreApp = core.NewCore()
@ -157,9 +158,9 @@ func TestRunAll(t *testing.T) {
t.Run(dbt+" HTTP /settings", func(t *testing.T) {
RunSettingsHandler(t)
})
t.Run(dbt+" Cleanup", func(t *testing.T) {
Cleanup(t)
})
//t.Run(dbt+" Cleanup", func(t *testing.T) {
// Cleanup(t)
//})
}
@ -185,7 +186,7 @@ func TestExportCommand(t *testing.T) {
c.Run()
t.Log(c.Stdout())
assert.True(t, c.StdoutContains("Exporting Static 'index.html' page"))
assert.True(t, fileExists(gopath+"cmd/index.html"))
assert.True(t, fileExists(gopath+"/cmd/index.html"))
}
func TestAssetsCommand(t *testing.T) {
@ -199,6 +200,7 @@ func TestAssetsCommand(t *testing.T) {
}
func RunMakeDatabaseConfig(t *testing.T, db string) {
dir := utils.Dir()
port := 5432
if db == "mysql" {
port = 3306
@ -217,7 +219,7 @@ func RunMakeDatabaseConfig(t *testing.T, db string) {
"admin",
"",
nil,
gopath,
dir,
}
err := config.Save()
assert.Nil(t, err)
@ -226,7 +228,7 @@ func RunMakeDatabaseConfig(t *testing.T, db string) {
assert.Nil(t, err)
assert.Equal(t, db, core.Configs.Connection)
err = core.DbConnection(core.Configs.Connection, false, "")
err = core.DbConnection(core.Configs.Connection, false, dir)
assert.Nil(t, err)
}
@ -559,10 +561,10 @@ func RunSettingsHandler(t *testing.T) {
}
func Cleanup(t *testing.T) {
os.Remove(gopath + "cmd/statup.db")
//os.Remove(gopath+"cmd/config.yml")
os.RemoveAll(gopath + "cmd/assets")
os.RemoveAll(gopath + "cmd/logs")
os.Remove(gopath + "/cmd/statup.db")
//os.Remove(gopath+"/cmd/config.yml")
os.RemoveAll(gopath + "/cmd/assets")
os.RemoveAll(gopath + "/cmd/logs")
}
func fileExists(file string) bool {

87
core/assets.go
View File

@ -18,10 +18,7 @@ func RenderBoxes() {
}
func CopyToPublic(box *rice.Box, folder, file string) {
assetFolder := fmt.Sprintf("assets/%v/%v", folder, file)
if folder == "" {
assetFolder = fmt.Sprintf("assets/%v", file)
}
assetFolder := fmt.Sprintf("%v/%v", folder, file)
utils.Log(1, fmt.Sprintf("Copying %v to %v", file, assetFolder))
base, err := box.String(file)
if err != nil {
@ -43,24 +40,28 @@ func MakePublicFolder(folder string) {
}
}
func CompileSASS() error {
func CompileSASS(folder string) error {
sassBin := os.Getenv("SASS")
shell := os.Getenv("CMD_FILE")
utils.Log(1, fmt.Sprintf("Compiling SASS into /css/base.css..."))
command := fmt.Sprintf("%v %v %v", sassBin, "assets/scss/base.scss", "assets/css/base.css")
scssFile := fmt.Sprintf("%v/%v", folder, "assets/scss/base.scss")
baseFile := fmt.Sprintf("%v/%v", folder, "assets/css/base.css")
utils.Log(1, fmt.Sprintf("Compiling SASS %v into %v", scssFile, baseFile))
command := fmt.Sprintf("%v %v %v", sassBin, scssFile, baseFile)
testCmd := exec.Command(shell, command)
_, err := testCmd.Output()
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to compile assets with SASS %v", err))
utils.Log(3, fmt.Sprintf("SASS: %v | CMD_FILE:%v", sassBin, shell))
utils.Log(3, fmt.Sprintf("%v %v %v", sassBin, scssFile, baseFile))
return err
}
utils.Log(1, "SASS Compiling is complete!")
return err
}
func HasAssets() bool {
if _, err := os.Stat("assets"); err == nil {
func HasAssets(folder string) bool {
if _, err := os.Stat(folder + "/assets"); err == nil {
utils.Log(1, "Assets folder was found!")
UsingAssets = true
return true
@ -68,7 +69,13 @@ func HasAssets() bool {
assetEnv := os.Getenv("USE_ASSETS")
if assetEnv == "true" {
utils.Log(1, "Environment variable USE_ASSETS was found.")
CreateAllAssets()
CreateAllAssets(folder)
err := CompileSASS(folder)
if err != nil {
CopyToPublic(CssBox, folder+"/css", "base.css")
utils.Log(2, "Default 'base.css' was insert because SASS did not work.")
return true
}
UsingAssets = true
return true
}
@ -76,16 +83,16 @@ func HasAssets() bool {
return false
}
func SaveAsset(data, file string) {
utils.Log(1, fmt.Sprintf("Saving %v into assets folder", file))
err := ioutil.WriteFile("assets/"+file, []byte(data), 0644)
func SaveAsset(data, folder, file string) {
utils.Log(1, fmt.Sprintf("Saving %v/%v into assets folder", folder, file))
err := ioutil.WriteFile(folder+"/assets/"+file, []byte(data), 0644)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to save %v, %v", file, err))
utils.Log(3, fmt.Sprintf("Failed to save %v/%v, %v", folder, file, err))
}
}
func OpenAsset(file string) string {
dat, err := ioutil.ReadFile("assets/" + file)
func OpenAsset(folder, file string) string {
dat, err := ioutil.ReadFile(folder + "/assets/" + file)
if err != nil {
utils.Log(3, fmt.Sprintf("Failed to open %v, %v", file, err))
return ""
@ -93,37 +100,31 @@ func OpenAsset(file string) string {
return string(dat)
}
func CreateAllAssets() error {
utils.Log(1, "Dump Statup assets into current directory...")
MakePublicFolder("assets")
MakePublicFolder("assets/js")
MakePublicFolder("assets/css")
MakePublicFolder("assets/scss")
MakePublicFolder("assets/emails")
func CreateAllAssets(folder string) error {
utils.Log(1, fmt.Sprintf("Dump Statup assets into %v/assets", folder))
MakePublicFolder(folder + "/assets")
MakePublicFolder(folder + "/assets/js")
MakePublicFolder(folder + "/assets/css")
MakePublicFolder(folder + "/assets/scss")
MakePublicFolder(folder + "/assets/emails")
utils.Log(1, "Inserting scss, css, emails, and javascript files into assets..")
CopyToPublic(ScssBox, "scss", "base.scss")
CopyToPublic(ScssBox, "scss", "variables.scss")
CopyToPublic(CssBox, "css", "bootstrap.min.css")
CopyToPublic(JsBox, "js", "bootstrap.min.js")
CopyToPublic(JsBox, "js", "Chart.bundle.min.js")
CopyToPublic(JsBox, "js", "jquery-3.3.1.slim.min.js")
CopyToPublic(JsBox, "js", "main.js")
CopyToPublic(JsBox, "js", "setup.js")
CopyToPublic(TmplBox, "", "robots.txt")
CopyToPublic(TmplBox, "", "favicon.ico")
CopyToPublic(ScssBox, folder+"/assets/scss", "base.scss")
CopyToPublic(ScssBox, folder+"/assets/scss", "variables.scss")
CopyToPublic(CssBox, folder+"/assets/css", "bootstrap.min.css")
CopyToPublic(JsBox, folder+"/assets/js", "bootstrap.min.js")
CopyToPublic(JsBox, folder+"/assets/js", "Chart.bundle.min.js")
CopyToPublic(JsBox, folder+"/assets/js", "jquery-3.3.1.slim.min.js")
CopyToPublic(JsBox, folder+"/assets/js", "main.js")
CopyToPublic(JsBox, folder+"/assets/js", "setup.js")
CopyToPublic(TmplBox, folder+"/assets/", "robots.txt")
CopyToPublic(TmplBox, folder+"/assets/", "favicon.ico")
utils.Log(1, "Compiling CSS from SCSS style...")
err := CompileSASS()
if err != nil {
CopyToPublic(CssBox, "css", "base.css")
utils.Log(2, "Default 'base.css' was insert because SASS did not work.")
return err
}
utils.Log(1, "Statup assets have been inserted")
err := utils.Log(1, "Statup assets have been inserted")
return err
}
func DeleteAllAssets() error {
err := os.RemoveAll("assets")
func DeleteAllAssets(folder string) error {
err := os.RemoveAll(folder + "/assets")
if err != nil {
utils.Log(1, fmt.Sprintf("There was an issue deleting Statup Assets, %v", err))
return err

5
core/configs.go
View File

@ -22,6 +22,9 @@ func LoadConfig() (*types.Config, error) {
return nil, errors.New("config.yml file not found - starting in setup mode")
}
err = yaml.Unmarshal(file, &Configs)
if err != nil {
return nil, err
}
CoreApp.DbConnection = Configs.Connection
return Configs, err
}
@ -71,7 +74,7 @@ func LoadUsingEnv() (*types.Config, error) {
Email: "info@localhost.com",
}
err := DbConnection(dbConfig.DbConn, true, "")
err := DbConnection(dbConfig.DbConn, true, ".")
if err != nil {
utils.Log(4, err)
return nil, err

8
core/core.go
View File

@ -62,7 +62,7 @@ func InitApp() {
func InsertNotifierDB() error {
if DbSession == nil {
err := DbConnection(CoreApp.DbConnection, false, "")
err := DbConnection(CoreApp.DbConnection, false, ".")
if err != nil {
return errors.New("database connection has not been created")
}
@ -85,21 +85,21 @@ func (c Core) SassVars() string {
if !UsingAssets {
return ""
}
return OpenAsset("scss/variables.scss")
return OpenAsset(".", "scss/variables.scss")
}
func (c Core) BaseSASS() string {
if !UsingAssets {
return ""
}
return OpenAsset("scss/base.scss")
return OpenAsset(".", "scss/base.scss")
}
func (c Core) MobileSASS() string {
if !UsingAssets {
return ""
}
return OpenAsset("scss/mobile.scss")
return OpenAsset(".", "scss/mobile.scss")
}
func (c Core) AllOnline() bool {

34
core/core_test.go
View File

@ -8,14 +8,14 @@ import (
)
var (
testCore *Core
testConfig *DbConfig
testDatabase string
testCore *Core
testConfig *DbConfig
gopath string
)
func init() {
testDatabase = os.Getenv("GOPATH")
testDatabase += "/src/github.com/hunterlong/statup/"
gopath = os.Getenv("GOPATH")
gopath += "/src/github.com/hunterlong/statup"
utils.InitLogs()
RenderBoxes()
@ -31,14 +31,14 @@ func TestDbConfig_Save(t *testing.T) {
testConfig = &DbConfig{
DbConn: "sqlite",
Project: "Tester",
Location: testDatabase,
Location: gopath,
}
err := testConfig.Save()
assert.Nil(t, err)
}
func TestDbConnection(t *testing.T) {
err := DbConnection(testConfig.DbConn, false, testDatabase)
err := DbConnection(testConfig.DbConn, false, gopath)
assert.Nil(t, err)
}
@ -74,7 +74,25 @@ func TestCore_UsingAssets(t *testing.T) {
}
func TestHasAssets(t *testing.T) {
assert.False(t, HasAssets())
assert.False(t, HasAssets(gopath))
}
func TestCreateAssets(t *testing.T) {
assert.Nil(t, CreateAllAssets(gopath))
assert.True(t, HasAssets(gopath))
}
func TestCompileSASS(t *testing.T) {
t.SkipNow()
os.Setenv("SASS", "sass")
os.Setenv("CMD_FILE", gopath+"/cmd.sh")
assert.Nil(t, CompileSASS(gopath))
assert.True(t, HasAssets(gopath))
}
func TestDeleteAssets(t *testing.T) {
assert.Nil(t, DeleteAllAssets(gopath))
assert.False(t, HasAssets(gopath))
}
func TestInsertNotifierDB(t *testing.T) {

4
core/database.go
View File

@ -29,7 +29,7 @@ func DbConnection(dbType string, retry bool, location string) error {
var err error
if dbType == "sqlite" {
sqliteSettings = sqlite.ConnectionURL{
Database: location + "statup.db",
Database: location + "/statup.db",
}
DbSession, err = sqlite.Open(sqliteSettings)
if err != nil {
@ -86,7 +86,7 @@ func DbConnection(dbType string, retry bool, location string) error {
func waitForDb(dbType string) error {
time.Sleep(5 * time.Second)
return DbConnection(dbType, true, "")
return DbConnection(dbType, true, ".")
}
func DatabaseMaintence() {

92
core/services_test.go
View File

@ -16,9 +16,16 @@ func TestSelectAllServices(t *testing.T) {
assert.Equal(t, 5, len(services))
}
func TestSelectService(t *testing.T) {
func TestSelectHTTPService(t *testing.T) {
service := SelectService(1)
assert.Equal(t, "Google", service.ToService().Name)
assert.Equal(t, "http", service.ToService().Type)
}
func TestSelectTCPService(t *testing.T) {
service := SelectService(5)
assert.Equal(t, "Postgres TCP Check", service.ToService().Name)
assert.Equal(t, "tcp", service.ToService().Type)
}
func TestUpdateService(t *testing.T) {
@ -32,12 +39,12 @@ func TestUpdateService(t *testing.T) {
func TestServiceHTTPCheck(t *testing.T) {
service := SelectService(1)
checked := ServiceHTTPCheck(service.ToService())
checked := ServiceCheck(service.ToService())
assert.Equal(t, "Updated Google", checked.Name)
assert.True(t, checked.Online)
}
func TestCheckService(t *testing.T) {
func TestCheckHTTPService(t *testing.T) {
service := SelectService(1).ToService()
assert.Equal(t, "Updated Google", service.Name)
assert.True(t, service.Online)
@ -45,6 +52,20 @@ func TestCheckService(t *testing.T) {
assert.NotZero(t, service.Latency)
}
func TestServiceTCPCheck(t *testing.T) {
service := SelectService(5)
checked := ServiceCheck(service.ToService())
assert.Equal(t, "Postgres TCP Check", checked.Name)
assert.True(t, checked.Online)
}
func TestCheckTCPService(t *testing.T) {
service := SelectService(5).ToService()
assert.Equal(t, "Postgres TCP Check", service.Name)
assert.True(t, service.Online)
assert.NotZero(t, service.Latency)
}
func TestCreateService(t *testing.T) {
s := &types.Service{
Name: "Interpol - All The Rage Back Home",
@ -63,17 +84,78 @@ func TestCreateService(t *testing.T) {
assert.Equal(t, "Interpol - All The Rage Back Home", newService.Name)
}
func TestCreateFailingHTTPService(t *testing.T) {
s := &types.Service{
Name: "Bad URL",
Domain: "http://localhost/iamnothere",
ExpectedStatus: 200,
Interval: 30,
Type: "http",
Method: "GET",
Timeout: 5,
}
var err error
newServiceId, err = CreateService(s)
assert.Nil(t, err)
assert.NotZero(t, newServiceId)
newService := SelectService(newServiceId).ToService()
assert.Equal(t, "Bad URL", newService.Name)
}
func TestServiceFailedCheck(t *testing.T) {
service := SelectService(7)
checked := ServiceCheck(service.ToService())
assert.Equal(t, "Bad URL", checked.Name)
assert.False(t, checked.Online)
}
func TestCreateFailingTCPService(t *testing.T) {
s := &types.Service{
Name: "Bad TCP",
Domain: "localhost",
Port: 5050,
Interval: 30,
Type: "tcp",
Timeout: 5,
}
var err error
newServiceId, err = CreateService(s)
assert.Nil(t, err)
assert.NotZero(t, newServiceId)
newService := SelectService(newServiceId).ToService()
assert.Equal(t, "Bad TCP", newService.Name)
}
func TestServiceFailedTCPCheck(t *testing.T) {
service := SelectService(8)
checked := ServiceCheck(service.ToService())
assert.Equal(t, "Bad TCP", checked.Name)
assert.False(t, checked.Online)
}
func TestCreateServiceFailure(t *testing.T) {
fail := FailureData{
Issue: "This is not an issue, but it would container HTTP response errors.",
}
service := SelectService(8)
id, err := CreateServiceFailure(service.ToService(), fail)
assert.Nil(t, err)
assert.NotZero(t, id)
}
func TestDeleteService(t *testing.T) {
service := SelectService(newServiceId).ToService()
count, err := SelectAllServices()
assert.Nil(t, err)
assert.Equal(t, 6, len(count))
assert.Equal(t, 8, len(count))
err = DeleteService(service)
assert.Nil(t, err)
count, err = SelectAllServices()
assert.Nil(t, err)
assert.Equal(t, 5, len(count))
assert.Equal(t, 7, len(count))
}

27
handlers/dashboard.go
View File

@ -1,10 +1,7 @@
package handlers
import (
"encoding/json"
"fmt"
"github.com/hunterlong/statup/core"
"github.com/hunterlong/statup/types"
"github.com/hunterlong/statup/utils"
"net/http"
)
@ -82,27 +79,3 @@ func LogsLineHandler(w http.ResponseWriter, r *http.Request) {
w.Write(v)
}
}
type backups struct {
Core types.Core `json:"core"`
}
func BackupCreateHandler(w http.ResponseWriter, r *http.Request) {
//if !IsAuthenticated(r) {
// http.Redirect(w, r, "/", http.StatusSeeOther)
// return
//}
backup := backups{
Core: *core.CoreApp.ToCore(),
}
out, err := json.Marshal(backup)
if err != nil {
panic(err)
}
fmt.Println(out)
json.NewEncoder(w).Encode(backup)
}

88
handlers/handlers_test.go
View File

@ -57,6 +57,14 @@ func TestProcessSetupHandler(t *testing.T) {
assert.Equal(t, 303, rr.Code)
}
func TestCheckSetupHandler(t *testing.T) {
req, err := http.NewRequest("GET", "/setup", nil)
assert.Nil(t, err)
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
assert.Equal(t, 303, rr.Code)
}
func TestCheckIndexHandler(t *testing.T) {
req, err := http.NewRequest("GET", "/", nil)
assert.Nil(t, err)
@ -76,6 +84,19 @@ func TestServicesViewHandler(t *testing.T) {
assert.Contains(t, body, "Statup made with ❤️")
}
func TestServiceChartHandler(t *testing.T) {
req, err := http.NewRequest("GET", "/charts.js", nil)
assert.Nil(t, err)
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
body := rr.Body.String()
assert.Equal(t, 200, rr.Code)
assert.Contains(t, body, "var ctx_1")
assert.Contains(t, body, "var ctx_2")
assert.Contains(t, body, "var ctx_3")
assert.Contains(t, body, "var ctx_4")
}
func TestDashboardHandler(t *testing.T) {
req, err := http.NewRequest("GET", "/dashboard", nil)
assert.Nil(t, err)
@ -99,6 +120,20 @@ func TestLoginHandler(t *testing.T) {
assert.Equal(t, 303, rr.Code)
}
func TestBadLoginHandler(t *testing.T) {
form := url.Values{}
form.Add("username", "admin")
form.Add("password", "wrongpassword")
req, err := http.NewRequest("POST", "/dashboard", strings.NewReader(form.Encode()))
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
assert.Nil(t, err)
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
body := rr.Body.String()
assert.Contains(t, body, "Incorrect login information submitted, try again.")
assert.Equal(t, 200, rr.Code)
}
func TestServicesHandler(t *testing.T) {
req, err := http.NewRequest("GET", "/services", nil)
assert.Nil(t, err)
@ -124,6 +159,31 @@ func TestCreateUserHandler(t *testing.T) {
assert.Equal(t, 303, rr.Code)
}
func TestEditUserHandler(t *testing.T) {
form := url.Values{}
form.Add("username", "changedusername")
form.Add("password", "##########")
form.Add("email", "info@okokk.com")
form.Add("admin", "on")
req, err := http.NewRequest("POST", "/user/2", strings.NewReader(form.Encode()))
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
assert.Nil(t, err)
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
body := rr.Body.String()
assert.Contains(t, body, "<td>admin</td>")
assert.Contains(t, body, "<td>changedusername</td>")
assert.Equal(t, 200, rr.Code)
}
func TestDeleteUserHandler(t *testing.T) {
req, err := http.NewRequest("GET", "/user/2/delete", nil)
assert.Nil(t, err)
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
assert.Equal(t, 303, rr.Code)
}
func TestUsersHandler(t *testing.T) {
req, err := http.NewRequest("GET", "/users", nil)
assert.Nil(t, err)
@ -133,7 +193,21 @@ func TestUsersHandler(t *testing.T) {
assert.Equal(t, 200, rr.Code)
assert.Contains(t, body, "<title>Statup | Users</title>")
assert.Contains(t, body, "<td>admin</td>")
assert.Contains(t, body, "<td>newuser</td>")
assert.NotContains(t, body, "<td>changedusername</td>")
assert.Contains(t, body, "Statup made with ❤️")
}
func TestUsersEditHandler(t *testing.T) {
req, err := http.NewRequest("GET", "/user/1", nil)
assert.Nil(t, err)
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
body := rr.Body.String()
assert.Equal(t, 200, rr.Code)
assert.Contains(t, body, "<title>Statup | Users</title>")
assert.Contains(t, body, "<h3>User admin</h3>")
assert.Contains(t, body, "value=\"info@statup.io\"")
assert.Contains(t, body, "value=\"##########\"")
assert.Contains(t, body, "Statup made with ❤️")
}
@ -256,6 +330,14 @@ func TestServicesUpdateHandler(t *testing.T) {
assert.Contains(t, body, "Statup made with ❤️")
}
func TestDeleteServiceHandler(t *testing.T) {
req, err := http.NewRequest("POST", "/service/7/delete", nil)
assert.Nil(t, err)
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
assert.Equal(t, 303, rr.Code)
}
func TestLogsHandler(t *testing.T) {
t.SkipNow()
req, err := http.NewRequest("GET", "/logs", nil)
@ -312,7 +394,7 @@ func TestPrometheusHandler(t *testing.T) {
Router().ServeHTTP(rr, req)
body := rr.Body.String()
assert.Equal(t, 200, rr.Code)
assert.Contains(t, body, "statup_total_services 7")
assert.Contains(t, body, "statup_total_services 6")
}
func TestLogoutHandler(t *testing.T) {
@ -321,4 +403,4 @@ func TestLogoutHandler(t *testing.T) {
rr := httptest.NewRecorder()
Router().ServeHTTP(rr, req)
assert.Equal(t, 303, rr.Code)
}
}

1
handlers/routes.go
View File

@ -30,7 +30,6 @@ func Router() *mux.Router {
r.Handle("/service/{id}", http.HandlerFunc(ServicesUpdateHandler)).Methods("POST")
r.Handle("/service/{id}/edit", http.HandlerFunc(ServicesViewHandler))
r.Handle("/service/{id}/delete", http.HandlerFunc(ServicesDeleteHandler))
r.Handle("/service/{id}/badge.svg", http.HandlerFunc(ServicesBadgeHandler))
r.Handle("/service/{id}/delete_failures", http.HandlerFunc(ServicesDeleteFailuresHandler)).Methods("GET")
r.Handle("/service/{id}/checkin", http.HandlerFunc(CheckinCreateUpdateHandler)).Methods("POST")
r.Handle("/users", http.HandlerFunc(UsersHandler)).Methods("GET")

16
handlers/services.go
View File

@ -83,22 +83,6 @@ func ServicesViewHandler(w http.ResponseWriter, r *http.Request) {
ExecuteResponse(w, r, "service.html", serv)
}
func ServicesBadgeHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
serv := core.SelectService(utils.StringInt(vars["id"]))
service := serv.ToService()
var badge []byte
if service.Online {
badge = []byte(`<svg xmlns="http://www.w3.org/2000/svg" width="104" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><mask id="a"><rect width="104" height="20" rx="3" fill="#fff"/></mask><g mask="url(#a)"><path fill="#555" d="M0 0h54v20H0z"/><path fill="#4c1" d="M54 0h50v20H54z"/><path fill="url(#b)" d="M0 0h104v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11"><text x="28" y="15" fill="#010101" fill-opacity=".3">` + service.Name + `</text><text x="28" y="14">` + service.Name + `</text><text x="78" y="15" fill="#010101" fill-opacity=".3">online</text><text x="78" y="14">online</text></g></svg>`)
} else {
badge = []byte(`<svg xmlns="http://www.w3.org/2000/svg" width="99" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><mask id="a"><rect width="99" height="20" rx="3" fill="#fff"/></mask><g mask="url(#a)"><path fill="#555" d="M0 0h54v20H0z"/><path fill="#e05d44" d="M54 0h45v20H54z"/><path fill="url(#b)" d="M0 0h99v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11"><text x="28" y="15" fill="#010101" fill-opacity=".3">` + service.Name + `</text><text x="28" y="14">` + service.Name + `</text><text x="75.5" y="15" fill="#010101" fill-opacity=".3">offline</text><text x="75.5" y="14">offline</text></g></svg>`)
}
w.Header().Set("Content-Type", "image/svg+xml")
w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
w.Write(badge)
}
func ServicesUpdateHandler(w http.ResponseWriter, r *http.Request) {
if !IsAuthenticated(r) {
http.Redirect(w, r, "/", http.StatusSeeOther)

15
handlers/settings.go
View File

@ -57,9 +57,9 @@ func SaveSASSHandler(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
theme := r.PostForm.Get("theme")
variables := r.PostForm.Get("variables")
core.SaveAsset(theme, "scss/base.scss")
core.SaveAsset(variables, "scss/variables.scss")
core.CompileSASS()
core.SaveAsset(theme, ".", "scss/base.scss")
core.SaveAsset(variables, ".", "scss/variables.scss")
core.CompileSASS(".")
http.Redirect(w, r, "/settings", http.StatusSeeOther)
}
@ -68,7 +68,12 @@ func SaveAssetsHandler(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, "/", http.StatusSeeOther)
return
}
core.CreateAllAssets()
core.CreateAllAssets(".")
err := core.CompileSASS(".")
if err != nil {
core.CopyToPublic(core.CssBox, "css", "base.css")
utils.Log(2, "Default 'base.css' was insert because SASS did not work.")
}
core.UsingAssets = true
http.Redirect(w, r, "/settings", http.StatusSeeOther)
}
@ -78,7 +83,7 @@ func DeleteAssetsHandler(w http.ResponseWriter, req *http.Request) {
http.Redirect(w, req, "/", http.StatusSeeOther)
return
}
core.DeleteAllAssets()
core.DeleteAllAssets(".")
core.UsingAssets = false
LocalizedAssets(r)
http.Redirect(w, req, "/settings", http.StatusSeeOther)

4
handlers/setup.go
View File

@ -74,7 +74,7 @@ func ProcessSetupHandler(w http.ResponseWriter, r *http.Request) {
password,
email,
nil,
"",
".",
}
err := config.Save()
if err != nil {
@ -96,7 +96,7 @@ func ProcessSetupHandler(w http.ResponseWriter, r *http.Request) {
return
}
err = core.DbConnection(core.Configs.Connection, false, "")
err = core.DbConnection(core.Configs.Connection, false, ".")
if err != nil {
utils.Log(3, err)
core.DeleteConfig()

1
handlers/users.go
View File

@ -105,6 +105,7 @@ func UsersDeleteHandler(w http.ResponseWriter, r *http.Request) {
users, _ := core.SelectAllUsers()
if len(users) == 1 {
utils.Log(2, "cannot delete the only user in the system")
http.Redirect(w, r, "/users", http.StatusSeeOther)
return
}

4
notifiers/notifiers_test.go
View File

@ -49,14 +49,14 @@ func (n *Tester) Test() error {
func init() {
testDatabase = os.Getenv("GOPATH")
testDatabase += "/src/github.com/hunterlong/statup/"
testDatabase += "/src/github.com/hunterlong/statup"
utils.InitLogs()
}
func injectDatabase() {
sqliteDb := sqlite.ConnectionURL{
Database: testDatabase + "statup.db",
Database: testDatabase + "/statup.db",
}
dbSession, _ := sqlite.Open(sqliteDb)
Collections = dbSession.Collection("communication")

1
source/tmpl/user.html
View File

@ -56,7 +56,6 @@
</div>
<div class="form-group row">
<div class="col-sm-12">
<input type="hidden" name="user_id" value="{{.Id}}">
<button type="submit" class="btn btn-primary btn-block">Update User</button>
</div>
</div>

40
utils/log.go
View File

@ -2,7 +2,6 @@ package utils
import (
"fmt"
"github.com/fatih/color"
"gopkg.in/natefinch/lumberjack.v2"
"log"
"net/http"
@ -13,7 +12,6 @@ import (
var (
logFile *os.File
logLevel int
fmtLogs *log.Logger
ljLogger *lumberjack.Logger
LastLine interface{}
@ -44,23 +42,8 @@ func InitLogs() error {
MaxAge: 28,
}
fmtLogs = log.New(logFile, "", log.Ldate|log.Ltime)
log.SetOutput(ljLogger)
logEnv := os.Getenv("LOG")
if logEnv == "fatal" {
logLevel = 3
} else if logEnv == "debug" {
logLevel = 2
} else if logEnv == "info" {
logLevel = 1
} else {
logLevel = 0
}
rotate()
return err
}
@ -75,39 +58,42 @@ func rotate() {
}()
}
func Log(level int, err interface{}) {
func Log(level int, err interface{}) error {
LastLine = err
var outErr error
switch level {
case 5:
fmt.Printf("PANIC: %v\n", err)
fmtLogs.Fatalf("PANIC: %v\n", err)
_, outErr = fmt.Printf("PANIC: %v\n", err)
fmtLogs.Printf("PANIC: %v\n", err)
case 4:
fmt.Printf("FATAL: %v\n", err)
_, outErr = fmt.Printf("FATAL: %v\n", err)
fmtLogs.Printf("FATAL: %v\n", err)
//color.Red("ERROR: %v\n", err)
//os.Exit(2)
case 3:
fmt.Printf("ERROR: %v\n", err)
_, outErr = fmt.Printf("ERROR: %v\n", err)
fmtLogs.Printf("ERROR: %v\n", err)
//color.Red("ERROR: %v\n", err)
case 2:
fmt.Printf("WARNING: %v\n", err)
_, outErr = fmt.Printf("WARNING: %v\n", err)
fmtLogs.Printf("WARNING: %v\n", err)
//color.Yellow("WARNING: %v\n", err)
case 1:
fmt.Printf("INFO: %v\n", err)
_, outErr = fmt.Printf("INFO: %v\n", err)
fmtLogs.Printf("INFO: %v\n", err)
//color.Blue("INFO: %v\n", err)
case 0:
fmt.Printf("%v\n", err)
_, outErr = fmt.Printf("%v\n", err)
fmtLogs.Printf("%v\n", err)
color.White("%v\n", err)
//color.White("%v\n", err)
}
return outErr
}
func Http(r *http.Request) {
func Http(r *http.Request) string {
msg := fmt.Sprintf("%v (%v) | IP: %v", r.RequestURI, r.Method, r.Host)
fmtLogs.Printf("WEB: %v\n", msg)
fmt.Printf("WEB: %v\n", msg)
LastLine = msg
return msg
}

8
utils/utils.go
View File

@ -18,6 +18,14 @@ func IntString(s int) string {
return strconv.Itoa(s)
}
func Dir() string {
dir, err := os.Getwd()
if err != nil {
return "."
}
return dir
}
type Timestamp time.Time
type Timestamper interface {

21
utils/utils_test.go
View File

@ -1,7 +1,9 @@
package utils
import (
"github.com/pkg/errors"
"github.com/stretchr/testify/assert"
"net/http"
"testing"
"time"
)
@ -10,6 +12,25 @@ func TestInitLogs(t *testing.T) {
assert.Nil(t, InitLogs())
}
func TestDir(t *testing.T) {
assert.Contains(t, Dir(), "github.com/hunterlong/statup")
}
func TestLog(t *testing.T) {
assert.Nil(t, Log(0, errors.New("this is a 0 level error")))
assert.Nil(t, Log(1, errors.New("this is a 1 level error")))
assert.Nil(t, Log(2, errors.New("this is a 2 level error")))
assert.Nil(t, Log(3, errors.New("this is a 3 level error")))
assert.Nil(t, Log(4, errors.New("this is a 4 level error")))
assert.Nil(t, Log(5, errors.New("this is a 5 level error")))
}
func TestLogHTTP(t *testing.T) {
req, err := http.NewRequest("GET", "/", nil)
assert.Nil(t, err)
assert.NotEmpty(t, Http(req))
}
func TestIntString(t *testing.T) {
assert.Equal(t, "1", IntString(1))
}