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

additional testing

pull/508/head
hunterlong 2020-04-19 01:03:50 -07:00
parent 3210dfa226
commit 7355105c68
20 changed files with 582 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/cli.go
View File

@ -50,7 +50,7 @@ func exportCli(args []string) error {
if err != nil {
return err
}
if err = configs.ConnectConfigs(config); err != nil {
if err = configs.ConnectConfigs(config, false); err != nil {
return err
}
if _, err := services.SelectAllServices(false); err != nil {
@ -172,7 +172,7 @@ func importCli(args []string) error {
if err != nil {
return err
}
if err = configs.ConnectConfigs(config); err != nil {
if err = configs.ConnectConfigs(config, false); err != nil {
return err
}
if data, err = ExportSettings(); err != nil {
@ -262,7 +262,7 @@ func runOnce() error {
if err != nil {
return errors.Wrap(err, "config.yml file not found")
}
err = configs.ConnectConfigs(config)
err = configs.ConnectConfigs(config, false)
if err != nil {
return errors.Wrap(err, "issue connecting to database")
}

2
cmd/main.go
View File

@ -91,7 +91,7 @@ func start() {
}
}
if err = configs.ConnectConfigs(confgs); err != nil {
if err = configs.ConnectConfigs(confgs, true); err != nil {
exit(err)
}

81
handlers/api_test.go
View File

@ -1,6 +1,7 @@
package handlers
import (
"encoding/base64"
"encoding/json"
"fmt"
"github.com/getsentry/sentry-go"
@ -18,7 +19,6 @@ import (
"net/http"
"net/http/httptest"
"net/url"
"os"
"strings"
"testing"
)
@ -55,6 +55,21 @@ func TestSetupRoutes(t *testing.T) {
form.Add("domain", "http://localhost:8080")
form.Add("email", "info@statping.com")
badForm := url.Values{}
badForm.Add("db_host", "badconnection")
badForm.Add("db_user", utils.Params.GetString("DB_USER"))
badForm.Add("db_password", utils.Params.GetString("DB_PASS"))
badForm.Add("db_database", utils.Params.GetString("DB_DATABASE"))
badForm.Add("db_connection", "mysql")
badForm.Add("db_port", utils.Params.GetString("DB_PORT"))
badForm.Add("project", "Tester")
badForm.Add("username", "admin")
badForm.Add("password", "password123")
badForm.Add("sample_data", "on")
badForm.Add("description", "This is an awesome test")
badForm.Add("domain", "http://localhost:8080")
badForm.Add("email", "info@statping.com")
tests := []HTTPTest{
{
Name: "Statping Check",
@ -69,13 +84,22 @@ func TestSetupRoutes(t *testing.T) {
},
},
{
Name: "Statping Run Setup",
URL: "/api/setup",
Method: "POST",
Body: form.Encode(),
ExpectedStatus: 200,
HttpHeaders: []string{"Content-Type=application/x-www-form-urlencoded"},
ExpectedFiles: []string{utils.Directory + "/config.yml"},
Name: "Statping Error Setup",
URL: "/api/setup",
Method: "POST",
Body: badForm.Encode(),
ExpectedStatus: 500,
ExpectedContains: []string{BadJSONDatabase},
HttpHeaders: []string{"Content-Type=application/x-www-form-urlencoded"},
},
{
Name: "Statping Run Setup",
URL: "/api/setup",
Method: "POST",
Body: form.Encode(),
//ExpectedStatus: 200,
HttpHeaders: []string{"Content-Type=application/x-www-form-urlencoded"},
ExpectedFiles: []string{utils.Directory + "/config.yml"},
FuncTest: func(t *testing.T) error {
if !core.App.Setup {
return errors.New("core has not been setup")
@ -92,7 +116,8 @@ func TestSetupRoutes(t *testing.T) {
return nil
},
AfterTest: StopServices,
}}
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
@ -190,6 +215,14 @@ func TestMainApiRoutes(t *testing.T) {
GreaterThan: 20,
ExpectedContains: []string{date},
},
{
Name: "Logs endpoint",
URL: "/api/logs",
Method: "GET",
ExpectedStatus: 200,
GreaterThan: 20,
ExpectedContains: []string{date},
},
{
Name: "Logs Last Line endpoint",
URL: "/api/logs/last",
@ -273,6 +306,13 @@ func RunHTTPTest(test HTTPTest, t *testing.T) (string, *testing.T, error) {
}
defer rr.Result().Body.Close()
if test.ExpectedStatus != 0 {
if test.ExpectedStatus != rr.Result().StatusCode {
assert.Equal(t, test.ExpectedStatus, rr.Result().StatusCode)
return "", t, fmt.Errorf("status code %v does not match %v", rr.Result().StatusCode, test.ExpectedStatus)
}
}
body, err := ioutil.ReadAll(rr.Result().Body)
if err != nil {
assert.Nil(t, err)
@ -281,10 +321,6 @@ func RunHTTPTest(test HTTPTest, t *testing.T) (string, *testing.T, error) {
stringBody := string(body)
if test.ExpectedStatus != rr.Result().StatusCode {
assert.Equal(t, test.ExpectedStatus, rr.Result().StatusCode)
return stringBody, t, fmt.Errorf("status code %v does not match %v", rr.Result().StatusCode, test.ExpectedStatus)
}
if len(test.ExpectedContains) != 0 {
for _, v := range test.ExpectedContains {
assert.Contains(t, stringBody, v)
@ -348,11 +384,13 @@ func Request(test HTTPTest) (*httptest.ResponseRecorder, error) {
}
func SetTestENV(t *testing.T) error {
return os.Setenv("GO_ENV", "test")
utils.Params.Set("GO_ENV", "test")
return nil
}
func UnsetTestENV(t *testing.T) error {
return os.Setenv("GO_ENV", "production")
utils.Params.Set("GO_ENV", "production")
return nil
}
func StopServices(t *testing.T) error {
@ -362,6 +400,19 @@ func StopServices(t *testing.T) error {
return nil
}
func basicAuth(username, password string) string {
auth := username + ":" + password
return base64.StdEncoding.EncodeToString([]byte(auth))
}
var (
Success = `"status":"success"`
MethodCreate = `"method":"create"`
MethodUpdate = `"method":"update"`
MethodDelete = `"method":"delete"`
BadJSON = `{incorrect: JSON %%% formatting, [&]}`
BadJSONResponse = `{"error":"could not decode incoming JSON"}`
BadJSONDatabase = `{"error":"error connecting to database`
)

13
handlers/checkin.go
View File

@ -1,7 +1,6 @@
package handlers
import (
"fmt"
"github.com/gorilla/mux"
"github.com/statping/statping/types/checkins"
"github.com/statping/statping/types/errors"
@ -47,7 +46,7 @@ func checkinCreateHandler(w http.ResponseWriter, r *http.Request) {
}
service, err := services.Find(checkin.ServiceId)
if err != nil {
sendErrorJson(fmt.Errorf("missing service_id field"), w, r)
sendErrorJson(err, w, r)
return
}
checkin.ServiceId = service.Id
@ -59,9 +58,9 @@ func checkinCreateHandler(w http.ResponseWriter, r *http.Request) {
}
func checkinHitHandler(w http.ResponseWriter, r *http.Request) {
checkin, id, err := findCheckin(r)
checkin, _, err := findCheckin(r)
if err != nil {
sendErrorJson(fmt.Errorf("checkin %s was not found", id), w, r)
sendErrorJson(err, w, r)
return
}
ip, _, _ := net.SplitHostPort(r.RemoteAddr)
@ -75,7 +74,7 @@ func checkinHitHandler(w http.ResponseWriter, r *http.Request) {
err = hit.Create()
if err != nil {
sendErrorJson(fmt.Errorf("checkin %v was not found", id), w, r)
sendErrorJson(err, w, r)
return
}
checkin.Failing = false
@ -84,9 +83,9 @@ func checkinHitHandler(w http.ResponseWriter, r *http.Request) {
}
func checkinDeleteHandler(w http.ResponseWriter, r *http.Request) {
checkin, id, err := findCheckin(r)
checkin, _, err := findCheckin(r)
if err != nil {
sendErrorJson(fmt.Errorf("checkin %v was not found", id), w, r)
sendErrorJson(err, w, r)
return
}

99
handlers/checkins_test.go
View File

@ -1,15 +1,38 @@
package handlers
import (
"encoding/json"
"github.com/statping/statping/types/checkins"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"testing"
)
func TestUnAuthenticatedCheckinRoutes(t *testing.T) {
tests := []HTTPTest{
{
Name: "No Authentication - New Checkin",
URL: "/api/checkins",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Delete Checkin",
URL: "/api/checkins/1",
Method: "DELETE",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
str, t, err := RunHTTPTest(v, t)
t.Logf("Test %s: \n %v\n", v.Name, str)
assert.Nil(t, err)
})
}
}
func TestApiCheckinRoutes(t *testing.T) {
var apiToken string
tests := []HTTPTest{
{
Name: "Statping Create Checkins",
@ -23,7 +46,8 @@ func TestApiCheckinRoutes(t *testing.T) {
"name": "Example Checkin",
"service_id": 1,
"checkin_interval": 300,
"grace_period": 60
"grace_period": 60,
"api_key": "example"
}`,
},
{
@ -33,49 +57,26 @@ func TestApiCheckinRoutes(t *testing.T) {
ExpectedStatus: 200,
ResponseLen: 3,
BeforeTest: SetTestENV,
ResponseFunc: func(t *testing.T, resp []byte) error {
var checkin []*checkins.Checkin
if err := json.Unmarshal(resp, &checkin); err != nil {
return err
}
require.Len(t, checkin, 3)
last := checkin[len(checkin)-1]
apiToken = last.ApiKey
require.NotEmpty(t, apiToken)
return nil
},
},
{
Name: "Statping View Checkin",
URL: "/api/checkins/" + apiToken,
Method: "GET",
ExpectedStatus: 200,
ExpectedContains: []string{Success, `"type":"checkin","method":"create"`},
BeforeTest: SetTestENV,
SecureRoute: true,
Skip: true,
Name: "Statping View Checkin",
URL: "/api/checkins/example",
Method: "GET",
ExpectedStatus: 200,
BeforeTest: SetTestENV,
SecureRoute: true,
},
{
Name: "Statping Trigger Checkin",
URL: "/checkin/" + apiToken,
Method: "GET",
ExpectedStatus: 200,
ExpectedContains: []string{Success, `"type":"checkin","method":"create"`},
SecureRoute: true,
BeforeTest: SetTestENV,
Skip: true,
},
{
Name: "Statping Delete Checkin",
URL: "/api/checkins/" + apiToken,
Method: "DELETE",
ExpectedContains: []string{Success, `"type":"checkin","method":"create"`},
BeforeTest: SetTestENV,
Skip: true,
Name: "Statping Trigger Checkin",
URL: "/checkin/example",
Method: "GET",
ExpectedStatus: 200,
SecureRoute: true,
BeforeTest: SetTestENV,
},
{
Name: "Statping Missing Trigger Checkin",
URL: "/checkin/" + apiToken,
URL: "/checkin/missing123",
Method: "GET",
BeforeTest: SetTestENV,
ExpectedStatus: 404,
@ -87,6 +88,22 @@ func TestApiCheckinRoutes(t *testing.T) {
BeforeTest: SetTestENV,
ExpectedStatus: 404,
},
{
Name: "Statping Delete Checkin",
URL: "/api/checkins/example",
Method: "DELETE",
BeforeTest: SetTestENV,
ExpectedContains: []string{Success},
ExpectedStatus: 200,
},
{
Name: "Incorrect JSON POST",
URL: "/api/checkins",
Body: BadJSON,
ExpectedContains: []string{BadJSONResponse},
Method: "POST",
ExpectedStatus: 422,
},
}
for _, v := range tests {

79
handlers/groups_test.go
View File

@ -1,10 +1,46 @@
package handlers
import (
"github.com/statping/statping/types/groups"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"testing"
)
func TestUnAuthenticatedGroupRoutes(t *testing.T) {
tests := []HTTPTest{
{
Name: "No Authentication - New Group",
URL: "/api/groups",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Update Group",
URL: "/api/groups/1",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Delete Group",
URL: "/api/groups/1",
Method: "DELETE",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
str, t, err := RunHTTPTest(v, t)
t.Logf("Test %s: \n %v\n", v.Name, str)
assert.Nil(t, err)
})
}
}
func TestGroupAPIRoutes(t *testing.T) {
tests := []HTTPTest{
{
@ -47,6 +83,14 @@ func TestGroupAPIRoutes(t *testing.T) {
Method: "POST",
ExpectedStatus: 200,
},
{
Name: "Incorrect JSON POST",
URL: "/api/groups",
Body: BadJSON,
ExpectedContains: []string{BadJSONResponse},
Method: "POST",
ExpectedStatus: 422,
},
{
Name: "Statping Public and Private Groups",
URL: "/api/groups",
@ -87,13 +131,34 @@ func TestGroupAPIRoutes(t *testing.T) {
ExpectedStatus: 404,
},
{
Name: "Statping Delete Group",
URL: "/api/groups/1",
Method: "DELETE",
ExpectedStatus: 200,
AfterTest: UnsetTestENV,
SecureRoute: true,
}}
Name: "Statping Update Group",
URL: "/api/groups/1",
Method: "POST",
Body: `{
"name": "Updated Group",
"public": false
}`,
ExpectedStatus: 200,
ExpectedContains: []string{Success, MethodUpdate},
BeforeTest: SetTestENV,
SecureRoute: true,
AfterTest: func(t *testing.T) error {
g, err := groups.Find(1)
require.Nil(t, err)
assert.Equal(t, "Updated Group", g.Name)
return nil
},
},
{
Name: "Statping Delete Group",
URL: "/api/groups/1",
Method: "DELETE",
ExpectedStatus: 200,
ExpectedContains: []string{Success, MethodDelete},
AfterTest: UnsetTestENV,
SecureRoute: true,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {

10
handlers/handlers.go
View File

@ -10,7 +10,6 @@ import (
"github.com/statping/statping/types/errors"
"html/template"
"net/http"
"os"
"path"
"strings"
"time"
@ -110,7 +109,7 @@ func IsReadAuthenticated(r *http.Request) bool {
// IsFullAuthenticated returns true if the HTTP request is authenticated. You can set the environment variable GO_ENV=test
// to bypass the admin authenticate to the dashboard features.
func IsFullAuthenticated(r *http.Request) bool {
if os.Getenv("GO_ENV") == "test" {
if utils.Params.Get("GO_ENV") == "test" {
return true
}
if core.App == nil {
@ -187,7 +186,7 @@ func IsUser(r *http.Request) bool {
if !core.App.Setup {
return false
}
if os.Getenv("GO_ENV") == "test" {
if utils.Params.Get("GO_ENV") == "test" {
return true
}
tk, err := getJwtToken(r)
@ -255,6 +254,11 @@ func returnJson(d interface{}, w http.ResponseWriter, r *http.Request) {
json.NewEncoder(w).Encode(e)
return
}
if e, ok := d.(error); ok {
w.WriteHeader(500)
json.NewEncoder(w).Encode(errors.New(e.Error()))
return
}
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(d)
}

65
handlers/incidents_test.go
View File

@ -5,6 +5,54 @@ import (
"testing"
)
func TestUnAuthenticatedIncidentRoutes(t *testing.T) {
tests := []HTTPTest{
{
Name: "No Authentication - New Incident",
URL: "/api/services/1/incidents",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - New Incident Update",
URL: "/api/incidents/updates",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Update Incident",
URL: "/api/incidents/1",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Delete Incident",
URL: "/api/incidents/1",
Method: "DELETE",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Delete Incident Update",
URL: "/api/incidents/1/updates/1",
Method: "DELETE",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
str, t, err := RunHTTPTest(v, t)
t.Logf("Test %s: \n %v\n", v.Name, str)
assert.Nil(t, err)
})
}
}
func TestIncidentsAPIRoutes(t *testing.T) {
tests := []HTTPTest{
{
@ -63,6 +111,15 @@ func TestIncidentsAPIRoutes(t *testing.T) {
BeforeTest: SetTestENV,
ExpectedContains: []string{Success},
},
{
Name: "Incorrect Checkin JSON POST",
URL: "/api/incidents/1/updates",
Body: BadJSON,
ExpectedContains: []string{BadJSONResponse},
BeforeTest: SetTestENV,
Method: "POST",
ExpectedStatus: 422,
},
{
Name: "Statping Delete Incident Update",
URL: "/api/incidents/1/updates/1",
@ -79,6 +136,14 @@ func TestIncidentsAPIRoutes(t *testing.T) {
BeforeTest: SetTestENV,
ExpectedContains: []string{Success},
},
{
Name: "Incorrect JSON POST",
URL: "/api/services/1/incidents",
Body: BadJSON,
ExpectedContains: []string{BadJSONResponse},
Method: "POST",
ExpectedStatus: 422,
},
}
for _, v := range tests {

47
handlers/messages_test.go
View File

@ -5,6 +5,40 @@ import (
"testing"
)
func TestUnAuthenticatedMessageRoutes(t *testing.T) {
tests := []HTTPTest{
{
Name: "No Authentication - New Message",
URL: "/api/messages",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Update Message",
URL: "/api/messages/1",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Delete Message",
URL: "/api/messages/1",
Method: "DELETE",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
str, t, err := RunHTTPTest(v, t)
t.Logf("Test %s: \n %v\n", v.Name, str)
assert.Nil(t, err)
})
}
}
func TestMessagesApiRoutes(t *testing.T) {
tests := []HTTPTest{
{
@ -57,7 +91,7 @@ func TestMessagesApiRoutes(t *testing.T) {
"notify_before_scale": "hour"
}`,
ExpectedStatus: 200,
ExpectedContains: []string{`"status":"success"`, `"type":"message"`, `"method":"update"`},
ExpectedContains: []string{Success, `"type":"message"`, MethodUpdate},
BeforeTest: SetTestENV,
SecureRoute: true,
},
@ -66,7 +100,7 @@ func TestMessagesApiRoutes(t *testing.T) {
URL: "/api/messages/1",
Method: "DELETE",
ExpectedStatus: 200,
ExpectedContains: []string{`"status":"success"`, `"method":"delete"`},
ExpectedContains: []string{Success, MethodDelete},
BeforeTest: SetTestENV,
SecureRoute: true,
},
@ -76,6 +110,15 @@ func TestMessagesApiRoutes(t *testing.T) {
Method: "GET",
ExpectedStatus: 404,
},
{
Name: "Incorrect JSON POST",
URL: "/api/messages",
Body: BadJSON,
ExpectedContains: []string{BadJSONResponse},
BeforeTest: SetTestENV,
Method: "POST",
ExpectedStatus: 422,
},
}
for _, v := range tests {

46
handlers/notifiers_test.go
View File

@ -11,6 +11,40 @@ func TestAttachment(t *testing.T) {
notifiers.InitNotifiers()
}
func TestUnAuthenticatedNotifierRoutes(t *testing.T) {
tests := []HTTPTest{
{
Name: "No Authentication - View All Notifiers",
URL: "/api/notifiers",
Method: "GET",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - View Notifier",
URL: "/api/notifier/slack",
Method: "GET",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Update Notifier",
URL: "/api/notifier/slack",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
str, t, err := RunHTTPTest(v, t)
t.Logf("Test %s: \n %v\n", v.Name, str)
assert.Nil(t, err)
})
}
}
func TestApiNotifiersRoutes(t *testing.T) {
tests := []HTTPTest{
{
@ -49,7 +83,17 @@ func TestApiNotifiersRoutes(t *testing.T) {
ExpectedContains: []string{`"method":"slack"`},
BeforeTest: SetTestENV,
SecureRoute: true,
}}
},
{
Name: "Incorrect JSON POST",
URL: "/api/notifier/slack",
Body: BadJSON,
ExpectedContains: []string{BadJSONResponse},
BeforeTest: SetTestENV,
Method: "POST",
ExpectedStatus: 422,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {

1
handlers/routes.go
View File

@ -100,7 +100,6 @@ func Router() *mux.Router {
api.Handle("/api/services", authenticated(apiCreateServiceHandler, false)).Methods("POST")
api.Handle("/api/services/{id}", scoped(apiServiceHandler)).Methods("GET")
api.Handle("/api/reorder/services", authenticated(reorderServiceHandler, false)).Methods("POST")
api.Handle("/api/services/{id}/running", authenticated(apiServiceRunningHandler, false)).Methods("POST")
api.Handle("/api/services/{id}", authenticated(apiServiceUpdateHandler, false)).Methods("POST")
api.Handle("/api/services/{id}", authenticated(apiServiceDeleteHandler, false)).Methods("DELETE")
api.Handle("/api/services/{id}/failures", scoped(apiServiceFailuresHandler)).Methods("GET")

14
handlers/services.go
View File

@ -95,20 +95,6 @@ func apiServiceUpdateHandler(w http.ResponseWriter, r *http.Request) {
sendJsonAction(service, "update", w, r)
}
func apiServiceRunningHandler(w http.ResponseWriter, r *http.Request) {
service, err := findService(r)
if err != nil {
sendErrorJson(err, w, r)
return
}
if service.IsRunning() {
service.Close()
} else {
service.Start()
}
sendJsonAction(service, "running", w, r)
}
func apiServiceDataHandler(w http.ResponseWriter, r *http.Request) {
service, err := findService(r)
if err != nil {

50
handlers/services_test.go
View File

@ -13,6 +13,40 @@ import (
"time"
)
func TestUnAuthenticatedServicesRoutes(t *testing.T) {
tests := []HTTPTest{
{
Name: "No Authentication - New Service",
URL: "/api/services",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Update Service",
URL: "/api/services/1",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Delete Service",
URL: "/api/services/1",
Method: "DELETE",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
str, t, err := RunHTTPTest(v, t)
t.Logf("Test %s: \n %v\n", v.Name, str)
assert.Nil(t, err)
})
}
}
func TestApiServiceRoutes(t *testing.T) {
since := utils.Now().Add(-30 * types.Day)
end := utils.Now().Add(-30 * time.Minute)
@ -239,7 +273,7 @@ func TestApiServiceRoutes(t *testing.T) {
"order_id": 0
}`,
ExpectedStatus: 200,
ExpectedContains: []string{Success, `"name":"Updated New Service"`, `"method":"update"`},
ExpectedContains: []string{Success, `"name":"Updated New Service"`, MethodUpdate},
FuncTest: func(t *testing.T) error {
item, err := services.Find(1)
require.Nil(t, err)
@ -272,7 +306,7 @@ func TestApiServiceRoutes(t *testing.T) {
URL: "/api/services/1",
Method: "DELETE",
ExpectedStatus: 200,
ExpectedContains: []string{Success, `"method":"delete"`},
ExpectedContains: []string{Success, MethodDelete},
FuncTest: func(t *testing.T) error {
count := len(services.Services())
if count != 6 {
@ -281,7 +315,17 @@ func TestApiServiceRoutes(t *testing.T) {
return nil
},
SecureRoute: true,
}}
},
{
Name: "Incorrect JSON POST",
URL: "/api/services",
Body: BadJSON,
ExpectedContains: []string{BadJSONResponse},
BeforeTest: SetTestENV,
Method: "POST",
ExpectedStatus: 422,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {

7
handlers/setup.go
View File

@ -32,13 +32,8 @@ func processSetupHandler(w http.ResponseWriter, r *http.Request) {
log.WithFields(utils.ToFields(core.App, confgs)).Debugln("new configs posted")
if err = configs.ConnectConfigs(confgs); err != nil {
if err = configs.ConnectConfigs(confgs, false); err != nil {
log.Errorln(err)
if err := confgs.Delete(); err != nil {
log.Errorln(err)
sendErrorJson(err, w, r)
return
}
sendErrorJson(err, w, r)
return
}

41
handlers/theme_test.go
View File

@ -7,6 +7,47 @@ import (
"testing"
)
func TestUnAuthenticatedThemeRoutes(t *testing.T) {
tests := []HTTPTest{
{
Name: "No Authentication - Create Themes",
URL: "/api/theme/create",
Method: "GET",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - View Themes",
URL: "/api/theme",
Method: "GET",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Update Themes",
URL: "/api/theme",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Delete Themes",
URL: "/api/theme",
Method: "DELETE",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
str, t, err := RunHTTPTest(v, t)
t.Logf("Test %s: \n %v\n", v.Name, str)
assert.Nil(t, err)
})
}
}
func TestThemeRoutes(t *testing.T) {
tests := []HTTPTest{
{

92
handlers/users_test.go
View File

@ -1,11 +1,54 @@
package handlers
import (
"github.com/statping/statping/utils"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"net/url"
"testing"
)
func TestUnAuthenticatedUserRoutes(t *testing.T) {
tests := []HTTPTest{
{
Name: "No Authentication - New User",
URL: "/api/users",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Update User",
URL: "/api/users/1",
Method: "POST",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - View User",
URL: "/api/users/1",
Method: "GET",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
{
Name: "No Authentication - Delete User",
URL: "/api/users/1",
Method: "DELETE",
ExpectedStatus: 401,
BeforeTest: UnsetTestENV,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {
str, t, err := RunHTTPTest(v, t)
t.Logf("Test %s: \n %v\n", v.Name, str)
assert.Nil(t, err)
})
}
}
func TestApiUsersRoutes(t *testing.T) {
form := url.Values{}
form.Add("username", "adminupdated")
@ -16,12 +59,29 @@ func TestApiUsersRoutes(t *testing.T) {
badForm.Add("password", "wrongpassword")
tests := []HTTPTest{
{
Name: "Check Basic Authentication",
URL: "/api",
Method: "GET",
ExpectedStatus: 401,
BeforeTest: func(t *testing.T) error {
utils.Params.Set("AUTH_USERNAME", "admin")
utils.Params.Set("AUTH_PASSWORD", "admin")
return nil
},
AfterTest: func(t *testing.T) error {
utils.Params.Set("AUTH_USERNAME", "")
utils.Params.Set("AUTH_PASSWORD", "")
return nil
},
},
{
Name: "Statping All Users",
URL: "/api/users",
Method: "GET",
ExpectedStatus: 200,
ResponseLen: 1,
BeforeTest: SetTestENV,
}, {
Name: "Statping Create User",
URL: "/api/users",
@ -33,12 +93,18 @@ func TestApiUsersRoutes(t *testing.T) {
"password": "passsword123",
"admin": true
}`,
ExpectedStatus: 200,
ExpectedStatus: 200,
ExpectedContains: []string{Success, MethodCreate},
}, {
Name: "Statping View User",
URL: "/api/users/1",
Method: "GET",
ExpectedStatus: 200,
}, {
Name: "Statping Incorrect User ID",
URL: "/api/users/NOinteger",
Method: "GET",
ExpectedStatus: 422,
}, {
Name: "Statping Missing User",
URL: "/api/users/9393939393",
@ -54,12 +120,14 @@ func TestApiUsersRoutes(t *testing.T) {
"password": "password12345",
"admin": true
}`,
ExpectedStatus: 200,
ExpectedStatus: 200,
ExpectedContains: []string{Success, MethodUpdate},
}, {
Name: "Statping Delete User",
URL: "/api/users/2",
Method: "DELETE",
ExpectedStatus: 200,
Name: "Statping Delete User",
URL: "/api/users/2",
Method: "DELETE",
ExpectedStatus: 200,
ExpectedContains: []string{Success, MethodDelete},
}, {
Name: "Statping Login User",
URL: "/api/login",
@ -81,7 +149,17 @@ func TestApiUsersRoutes(t *testing.T) {
URL: "/api/logout",
Method: "GET",
ExpectedStatus: 303,
}}
},
{
Name: "Incorrect JSON POST",
URL: "/api/users",
Body: BadJSON,
ExpectedContains: []string{BadJSONResponse},
BeforeTest: SetTestENV,
Method: "POST",
ExpectedStatus: 422,
},
}
for _, v := range tests {
t.Run(v.Name, func(t *testing.T) {

9
source/source_test.go
View File

@ -23,6 +23,15 @@ func TestCore_UsingAssets(t *testing.T) {
assert.False(t, UsingAssets(dir))
}
func TestCore_UsingAssetsTrue(t *testing.T) {
utils.Params.Set("USE_ASSETS", true)
assert.False(t, UsingAssets(dir))
assert.DirExists(t, dir+"/assets")
utils.Params.Set("USE_ASSETS", false)
err := utils.DeleteDirectory(dir + "/assets")
assert.Nil(t, err)
}
func TestCreateAssets(t *testing.T) {
assert.Nil(t, CreateAllAssets(dir))
assert.True(t, UsingAssets(dir))

4
types/checkins/struct.go
View File

@ -32,6 +32,8 @@ type CheckinHit struct {
}
func (c *Checkin) BeforeCreate() (err error) {
c.ApiKey = utils.RandomString(7)
if c.ApiKey == "" {
c.ApiKey = utils.RandomString(7)
}
return nil
}

4
types/configs/file.go
View File

@ -10,8 +10,8 @@ import (
var log = utils.Log
func ConnectConfigs(configs *DbConfig) error {
err := Connect(configs, true)
func ConnectConfigs(configs *DbConfig, retry bool) error {
err := Connect(configs, retry)
if err != nil {
return errors.Wrap(err, "error connecting to database")
}

26
utils/utils_test.go
View File

@ -16,6 +16,32 @@ func TestCreateLog(t *testing.T) {
assert.Nil(t, err)
}
func TestToFields(t *testing.T) {
example := struct {
Id int64
Str string
}{
Id: 1,
Str: "example input",
}
fields := ToFields(example)
assert.Equal(t, "", fields)
}
func TestGetLastLine(t *testing.T) {
last := GetLastLine()
require.NotNil(t, last)
assert.Equal(t, "", last.lineAsString())
}
func TestReplaceValue(t *testing.T) {
assert.Equal(t, true, replaceVal(true))
assert.Equal(t, 42, replaceVal(42))
assert.Equal(t, "hello world", replaceVal("hello world"))
assert.Equal(t, "5s", replaceVal(time.Duration(5*time.Second)))
}
func TestInitLogs(t *testing.T) {
assert.Nil(t, InitLogs())
Log.Infoln("this is a test")