Deepak
86a4a28aee
All checks were successful
gitea-deepak/gogmagog/pipeline/pr-master This commit looks good
237 lines
6.7 KiB
Go
237 lines
6.7 KiB
Go
package routes_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"gitea.deepak.science/deepak/gogmagog/models"
|
|
"gitea.deepak.science/deepak/gogmagog/routes"
|
|
"github.com/stretchr/testify/assert"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestPureJSONPutAction(t *testing.T) {
|
|
// set up
|
|
assert := assert.New(t)
|
|
compOn, _ := time.Parse("2006-01-02", "2021-01-01")
|
|
a := &models.Action{
|
|
PlanID: 5,
|
|
CompletedOn: &compOn,
|
|
EstimatedChunks: 3,
|
|
CompletedChunks: 2,
|
|
ActionDescription: "here's an action",
|
|
}
|
|
m := getModel([]*models.Plan{}, []*models.Action{a})
|
|
router := routes.NewRouter(m)
|
|
data := []byte(`{
|
|
"action_description": "here's an action",
|
|
"estimated_chunks": 3,
|
|
"completed_chunks": 2,
|
|
"completed_on": "2021-01-01T00:00:00Z",
|
|
"plan_id": 5
|
|
}`)
|
|
req, _ := http.NewRequest("PUT", "/actions/0", bytes.NewBuffer(data))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
rr := httptest.NewRecorder()
|
|
// function under test
|
|
router.ServeHTTP(rr, req)
|
|
|
|
// check results
|
|
status := rr.Code
|
|
assert.Equal(http.StatusOK, status)
|
|
// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
|
|
expected := `{
|
|
"updated_action": {
|
|
"action_description": "here's an action",
|
|
"estimated_chunks": 3,
|
|
"completed_chunks": 2,
|
|
"completed_on": "2021-01-01T00:00:00Z",
|
|
"plan_id": 5,
|
|
"action_id": 0
|
|
},
|
|
"id": 0
|
|
}`
|
|
assert.JSONEq(expected, rr.Body.String())
|
|
contentType := rr.Header().Get("Content-Type")
|
|
assert.Equal("application/json", contentType)
|
|
}
|
|
|
|
func TestExtraFieldActionPutJSON(t *testing.T) {
|
|
// set up
|
|
assert := assert.New(t)
|
|
planDate, _ := time.Parse("2006-01-02", "2021-01-01")
|
|
p := &models.Plan{PlanID: 6, PlanDate: &planDate}
|
|
m := getModel([]*models.Plan{p}, []*models.Action{})
|
|
router := routes.NewRouter(m)
|
|
data := []byte(`{
|
|
"completed_on": "2021-01-01T00:00:00Z",
|
|
"plan_id": 5,
|
|
"sabotage": "omg"
|
|
}`)
|
|
req, _ := http.NewRequest("PUT", "/actions/1", bytes.NewBuffer(data))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
rr := httptest.NewRecorder()
|
|
// function under test
|
|
router.ServeHTTP(rr, req)
|
|
|
|
// check results
|
|
status := rr.Code
|
|
assert.Equal(http.StatusBadRequest, status)
|
|
// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
|
|
expected := `Bad Request`
|
|
assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
|
|
}
|
|
func TestEmptyBodyActionPut(t *testing.T) {
|
|
// set up
|
|
assert := assert.New(t)
|
|
planDate, _ := time.Parse("2006-01-02", "2021-01-01")
|
|
p := &models.Plan{PlanID: 6, PlanDate: &planDate}
|
|
m := getModel([]*models.Plan{p}, []*models.Action{})
|
|
router := routes.NewRouter(m)
|
|
data := []byte(``)
|
|
req, _ := http.NewRequest("PUT", "/actions/1", bytes.NewBuffer(data))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
rr := httptest.NewRecorder()
|
|
// function under test
|
|
router.ServeHTTP(rr, req)
|
|
|
|
// check results
|
|
status := rr.Code
|
|
assert.Equal(http.StatusBadRequest, status)
|
|
// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
|
|
expected := `Bad Request`
|
|
assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
|
|
}
|
|
|
|
func TestTwoBodyActionPut(t *testing.T) {
|
|
// set up
|
|
assert := assert.New(t)
|
|
planDate, _ := time.Parse("2006-01-02", "2021-01-01")
|
|
p := &models.Plan{PlanID: 6, PlanDate: &planDate}
|
|
m := getModel([]*models.Plan{p}, []*models.Action{})
|
|
router := routes.NewRouter(m)
|
|
data := []byte(`{
|
|
"plan_id": 5
|
|
}, {
|
|
"plan_id": 6
|
|
}`)
|
|
req, _ := http.NewRequest("PUT", "/actions/1", bytes.NewBuffer(data))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
rr := httptest.NewRecorder()
|
|
// function under test
|
|
router.ServeHTTP(rr, req)
|
|
|
|
// check results
|
|
status := rr.Code
|
|
assert.Equal(http.StatusBadRequest, status)
|
|
// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
|
|
expected := `Bad Request`
|
|
assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
|
|
}
|
|
|
|
func TestBadActionIDPut(t *testing.T) {
|
|
// set up
|
|
assert := assert.New(t)
|
|
planDate, _ := time.Parse("2006-01-02", "2021-01-01")
|
|
p := &models.Plan{PlanID: 6, PlanDate: &planDate}
|
|
m := getModel([]*models.Plan{p}, []*models.Action{})
|
|
router := routes.NewRouter(m)
|
|
data := []byte(`{
|
|
"plan_id": 5
|
|
}, {
|
|
"plan_id": 6
|
|
}`)
|
|
req, _ := http.NewRequest("PUT", "/actions/text", bytes.NewBuffer(data))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
rr := httptest.NewRecorder()
|
|
// function under test
|
|
router.ServeHTTP(rr, req)
|
|
|
|
// check results
|
|
status := rr.Code
|
|
assert.Equal(http.StatusNotFound, status)
|
|
// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
|
|
expected := `Not Found`
|
|
assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
|
|
}
|
|
|
|
func TestErrorUpdateAction(t *testing.T) {
|
|
// set up
|
|
assert := assert.New(t)
|
|
|
|
m := getErrorModel("Model always errors")
|
|
|
|
router := routes.NewRouter(m)
|
|
a := &models.Action{PlanID: 6}
|
|
data, _ := json.Marshal(a)
|
|
req, _ := http.NewRequest("PUT", "/actions/1", bytes.NewBuffer(data))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
rr := httptest.NewRecorder()
|
|
|
|
// function under test
|
|
router.ServeHTTP(rr, req)
|
|
|
|
// check results
|
|
status := rr.Code
|
|
assert.Equal(http.StatusInternalServerError, status)
|
|
// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
|
|
expected := `Internal Server Error`
|
|
assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
|
|
}
|
|
|
|
func TestErrorOnRetrieveUpdateAction(t *testing.T) {
|
|
// set up
|
|
assert := assert.New(t)
|
|
|
|
m := getErrorOnGetModel("Model always errors")
|
|
|
|
router := routes.NewRouter(m)
|
|
a := &models.Action{PlanID: 6}
|
|
data, _ := json.Marshal(a)
|
|
req, _ := http.NewRequest("PUT", "/actions/1", bytes.NewBuffer(data))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
rr := httptest.NewRecorder()
|
|
|
|
// function under test
|
|
router.ServeHTTP(rr, req)
|
|
|
|
// check results
|
|
status := rr.Code
|
|
assert.Equal(http.StatusInternalServerError, status)
|
|
// We pass in the date as a time.time so it makes sense that it comes back with a midnight timestamp.
|
|
expected := `Internal Server Error`
|
|
assert.Equal(expected, strings.TrimSpace(rr.Body.String()))
|
|
}
|
|
|
|
func TestErrorWriterUpdateAction(t *testing.T) {
|
|
// set up
|
|
assert := assert.New(t)
|
|
|
|
a := &models.Action{PlanID: 6}
|
|
m := getModel([]*models.Plan{}, []*models.Action{a})
|
|
|
|
router := routes.NewRouter(m)
|
|
data, _ := json.Marshal(a)
|
|
req, _ := http.NewRequest("PUT", "/actions/1", bytes.NewBuffer(data))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
rr := NewBadWriter()
|
|
|
|
// function under test
|
|
router.ServeHTTP(rr, req)
|
|
|
|
// check results
|
|
status := rr.Code
|
|
assert.Equal(http.StatusInternalServerError, status)
|
|
|
|
}
|