gogmagog/routes/actions_test.go

package routes_test

import (
	"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 TestEmptyActions(t *testing.T) {
	// set up
	assert := assert.New(t)
	m := getEmptyModel()
	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions", nil)

	rr := httptest.NewRecorder()

	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusOK, status)
	expected := `[]`

	assert.JSONEq(expected, rr.Body.String())
	contentType := rr.Header().Get("Content-Type")
	assert.Equal("application/json", contentType)
}

func TestOneAction(t *testing.T) {
	// set up
	assert := assert.New(t)
	createdDate, _ := time.Parse("2006-01-02", "2021-01-01")
	updatedDate, _ := time.Parse("2006-01-02", "2021-01-02")
	completedDate, _ := time.Parse("2006-01-02", "2021-01-03")
	a1 := &models.Action{ActionID: 3, ActionDescription: "testing", CompletedChunks: 1, CompletedOn: &completedDate, CreatedAt: &createdDate, UpdatedAt: &updatedDate, EstimatedChunks: 3, PlanID: 0}
	m := getModel([]*models.Plan{}, []*models.Action{a1})
	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions", nil)

	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 := `[
		{
			"action_id": 3,
			"action_description": "testing",
			"estimated_chunks": 3,
			"completed_chunks": 1,
			"completed_on": "2021-01-03T00:00:00Z",
			"updated_at": "2021-01-02T00:00:00Z",
			"created_at": "2021-01-01T00:00:00Z",
			"plan_id": 0
		}
	]`
	assert.JSONEq(expected, rr.Body.String())
	contentType := rr.Header().Get("Content-Type")
	assert.Equal("application/json", contentType)
}

func TestErrorAction(t *testing.T) {
	// set up
	assert := assert.New(t)

	m := getErrorModel("Model always errors")

	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions", nil)

	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 TestEmptyActionErrorWriter(t *testing.T) {
	// set up
	assert := assert.New(t)

	m := getEmptyModel()

	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions", nil)

	rr := NewBadWriter()

	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusInternalServerError, status)

}

func TestOneActionByID(t *testing.T) {
	// set up
	assert := assert.New(t)
	createdDate, _ := time.Parse("2006-01-02", "2021-01-01")
	updatedDate, _ := time.Parse("2006-01-02", "2021-01-02")
	a := &models.Action{ActionID: 6, ActionDescription: "howdy", CompletedOn: nil, CreatedAt: &createdDate, UpdatedAt: &updatedDate, CompletedChunks: 0, EstimatedChunks: 54, PlanID: 3}
	m := getModel([]*models.Plan{}, []*models.Action{a})
	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions/6", nil)

	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 := `{
			"action_id": 6,
			"action_description": "howdy",
			"estimated_chunks": 54,
			"completed_chunks": 0,
			"updated_at": "2021-01-02T00:00:00Z",
			"created_at": "2021-01-01T00:00:00Z",
			"plan_id": 3
		}`
	assert.JSONEq(expected, rr.Body.String())
	contentType := rr.Header().Get("Content-Type")
	assert.Equal("application/json", contentType)
}

func TestErrorActionByID(t *testing.T) {
	// set up
	assert := assert.New(t)

	m := getErrorModel("Model always errors")

	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions/5", nil)

	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 TestEmptyActionErrorWriterByID(t *testing.T) {
	// set up
	assert := assert.New(t)

	a := &models.Action{ActionID: 6}
	m := getModel([]*models.Plan{}, []*models.Action{a})

	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions/6", nil)

	rr := NewBadWriter()

	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusInternalServerError, status)

}

func TestNotFoundActionByIDText(t *testing.T) {
	// set up
	assert := assert.New(t)

	m := getEmptyModel()

	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions/wo", nil)

	rr := httptest.NewRecorder()

	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusNotFound, status)

}
func TestNotFoundActionByIDEmpty(t *testing.T) {
	// set up
	assert := assert.New(t)

	m := getEmptyModel()

	router := routes.NewRouter(m)
	req, _ := http.NewRequest("GET", "/actions/1", nil)

	rr := httptest.NewRecorder()

	// function under test
	router.ServeHTTP(rr, req)

	// check results
	status := rr.Code
	assert.Equal(http.StatusNotFound, status)

}