Write further backend tests

backend/controller/check_controller.go

@@ -10,9 +10,9 @@ import (
 )
 
 type GetChecksQueryParameter struct {
-	From           *time.Time `form:"from" binding:"required"`
-	To             *time.Time `form:"to" binding:"required"`
-	ReduceByFactor *int       `form:"reduceByFactor" binding:"required"`
+	From           *time.Time `form:"from"`
+	To             *time.Time `form:"to"`
+	ReduceByFactor *int       `form:"reduceByFactor"`
 }
 
 func getChecks(ctx *gin.Context) {
@@ -25,6 +25,21 @@ func getChecks(ctx *gin.Context) {
 		return
 	}
 
+	if queryParameter.From == nil {
+		from := time.Now().Add(-24 * time.Hour)
+		queryParameter.From = &from
+	}
+
+	if queryParameter.To == nil {
+		to := time.Now()
+		queryParameter.To = &to
+	}
+
+	if queryParameter.ReduceByFactor == nil {
+		reduceByFactor := 1
+		queryParameter.ReduceByFactor = &reduceByFactor
+	}
+
 	checks, err := service.GetChecks(ctx.Request.Context(), serviceId, *queryParameter.From, *queryParameter.To, *queryParameter.ReduceByFactor)
 	if err != nil {
 		log.Errorf("Unable to get checks from database: '%s'", err)

backend/controller/failure_controller.go

@@ -11,10 +11,10 @@ import (
 )
 
 type GetFailuresQueryParameter struct {
-	PageSize *int       `form:"pageSize" binding:"required"`
-	Page     *int       `form:"page" binding:"required"`
-	From     *time.Time `form:"from" binding:"required"`
-	To       *time.Time `form:"to" binding:"required"`
+	PageSize *int       `form:"pageSize"`
+	Page     *int       `form:"page"`
+	From     *time.Time `form:"from"`
+	To       *time.Time `form:"to"`
 }
 
 type GetFailuresGroupedByDayQueryParameter struct {
@@ -32,6 +32,26 @@ func getFailures(ctx *gin.Context) {
 		return
 	}
 
+	if queryParameter.From == nil {
+		from := time.Now().Add(-24 * time.Hour)
+		queryParameter.From = &from
+	}
+
+	if queryParameter.To == nil {
+		to := time.Now()
+		queryParameter.To = &to
+	}
+
+	if queryParameter.Page == nil {
+		page := 0
+		queryParameter.Page = &page
+	}
+
+	if queryParameter.PageSize == nil {
+		pageSize := 50
+		queryParameter.PageSize = &pageSize
+	}
+
 	failures, err := service.GetFailures(ctx.Request.Context(), serviceId, *queryParameter.From, *queryParameter.To, *queryParameter.PageSize, *queryParameter.Page)
 	if err != nil {
 		log.Errorf("Unable to get is failures from database: '%s'", err)

backend/integration_test/base_test.go

@@ -59,6 +59,7 @@ func (suite *MonHttpTestSuite) SetupSuite() {
 func (suite *MonHttpTestSuite) SetupTest() {
 	log.Println("Setup test")
 	suite.setupSettings()
+	suite.cleanupDatabase()
 }
 
 func (suite *MonHttpTestSuite) TearDownTest() {
@@ -136,3 +137,10 @@ func (suite *MonHttpTestSuite) resetSettings() {
 func (suite *MonHttpTestSuite) loadTestConfig() {
 	assert.Nil(suite.T(), service.LoadConfig())
 }
+
+func (suite *MonHttpTestSuite) cleanupDatabase() {
+	_, err := service.GetDatabase().Exec("DELETE FROM service;")
+	if err != nil {
+		suite.T().Fail()
+	}
+}

backend/integration_test/scheduler_service_test.go

@@ -0,0 +1,96 @@
+package integration_test
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/koloo91/monhttp/repository"
+	"github.com/koloo91/monhttp/service"
+	"github.com/stretchr/testify/assert"
+	"net/http"
+	"net/http/httptest"
+)
+
+func (suite *MonHttpTestSuite) createNewService() (string, error) {
+	requestBody, err := json.Marshal(map[string]interface{}{
+		"name":                          "MyService",
+		"type":                          "HTTP",
+		"intervalInSeconds":             30,
+		"endpoint":                      "http://localhost",
+		"httpMethod":                    "GET",
+		"requestTimeoutInSeconds":       60,
+		"httpHeaders":                   "httpHeaders",
+		"httpBody":                      "httpBody",
+		"expectedHttpResponseBody":      "expectedHttpResponseBody",
+		"expectedHttpStatusCode":        200,
+		"followRedirects":               true,
+		"verifySsl":                     true,
+		"enableNotifications":           true,
+		"notifyAfterNumberOfFailures":   2,
+		"continuouslySendNotifications": true,
+		"notifiers":                     []string{"global"},
+	})
+	if err != nil {
+		return "", err
+	}
+
+	recorder := httptest.NewRecorder()
+	request, _ := http.NewRequest(http.MethodPost, "/api/services", bytes.NewBuffer(requestBody))
+	request.SetBasicAuth(user, password)
+
+	suite.router.ServeHTTP(recorder, request)
+
+	var responseBody map[string]interface{}
+	if err := json.Unmarshal(recorder.Body.Bytes(), &responseBody); err != nil {
+		return "", nil
+	}
+
+	assert.Equal(suite.T(), http.StatusCreated, recorder.Code)
+
+	return responseBody["id"].(string), nil
+}
+
+func (suite *MonHttpTestSuite) TestServiceCheckShouldBeFailureIfHostNotReachable() {
+	serviceId, err := suite.createNewService()
+	assert.Nil(suite.T(), err)
+
+	job, err := repository.GetJobByServiceId(context.Background(), serviceId)
+	assert.Nil(suite.T(), err)
+
+	service.ProcessService(0, job.Id)
+
+	// get checks
+	checksRecorder := httptest.NewRecorder()
+	checksRequest, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("/api/services/%s/checks", serviceId), nil)
+	checksRequest.SetBasicAuth(user, password)
+
+	suite.router.ServeHTTP(checksRecorder, checksRequest)
+
+	var checksResponseBody map[string]interface{}
+	assert.Nil(suite.T(), json.Unmarshal(checksRecorder.Body.Bytes(), &checksResponseBody))
+
+	assert.Equal(suite.T(), http.StatusOK, checksRecorder.Code)
+
+	checksData := checksResponseBody["data"].([]interface{})
+
+	firstChecksEntry := checksData[0].(map[string]interface{})
+	assert.NotEmpty(suite.T(), firstChecksEntry["id"])
+	assert.Equal(suite.T(), serviceId, firstChecksEntry["serviceId"])
+	assert.Equal(suite.T(), 0.0, firstChecksEntry["latencyInMs"])
+	assert.Equal(suite.T(), true, firstChecksEntry["isFailure"])
+	assert.NotEmpty(suite.T(), firstChecksEntry["createdAt"])
+
+	// get failures
+	failuresRecorder := httptest.NewRecorder()
+	failuresRequest, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("/api/services/%s/failures", serviceId), nil)
+	failuresRequest.SetBasicAuth(user, password)
+
+	suite.router.ServeHTTP(failuresRecorder, failuresRequest)
+
+	var failuresResponseBody map[string]interface{}
+	assert.Nil(suite.T(), json.Unmarshal(failuresRecorder.Body.Bytes(), &failuresResponseBody))
+
+	assert.Equal(suite.T(), http.StatusOK, failuresRecorder.Code)
+	// TODO: assert
+}

backend/repository/job_repository.go

@@ -18,6 +18,7 @@ const (
 								WHERE id = $1 
 								FOR UPDATE;`
 	updateJobByIdExecuteAtQuery = `UPDATE job SET execute_at = $2 WHERE id = $1;`
+	getJobByServiceId           = `SELECT id, execute_at, created_at, updated_at FROM job WHERE service_id = $1;`
 )
 
 func InsertJobTx(ctx context.Context, tx *sql.Tx, job model.Job) error {
@@ -73,3 +74,22 @@ func UpdateJobByIdExecuteAtTx(ctx context.Context, tx *sql.Tx, id string, execut
 	}
 	return nil
 }
+
+func GetJobByServiceId(ctx context.Context, serviceId string) (model.Job, error) {
+	row := db.QueryRowContext(ctx, getJobByServiceId, serviceId)
+
+	var id string
+	var executeAt, createdAt, updatedAt time.Time
+
+	if err := row.Scan(&id, &executeAt, &createdAt, &updatedAt); err != nil {
+		return model.Job{}, err
+	}
+
+	return model.Job{
+		Id:        id,
+		ServiceId: serviceId,
+		ExecuteAt: executeAt,
+		CreatedAt: createdAt,
+		UpdatedAt: updatedAt,
+	}, nil
+}