testing middleware

Author: pethron

cmd/config/templates.go

@@ -3,9 +3,11 @@ package config
 import (
 	"github.com/justinas/nosurf"
 	"html/template"
+	"io/fs"
 	"net/http"
 	"path/filepath"
 	"snippetbox.pethron.me/internal/models"
+	"snippetbox.pethron.me/ui"
 	"time"
 )
 
@@ -20,7 +22,10 @@ type TemplateData struct {
 }
 
 func humanDate(t time.Time) string {
-	return t.Format("02 Jan 2006 at 15:04")
+	if t.IsZero() {
+		return ""
+	}
+	return t.UTC().Format("02 Jan 2006 at 15:04")
 }
 
 var functions = template.FuncMap{
@@ -35,30 +40,27 @@ func NewTemplateCache() (map[string]*template.Template, error) {
 	// match the pattern "./ui/html/pages/*.tmpl". This will essentially gives
 	// us a slice of all the filepaths for our application 'page' templates
 	// like: [ui/html/pages/home.tmpl ui/html/pages/view.tmpl]
-	pages, err := filepath.Glob("./ui/html/pages/*.tmpl")
+	pages, err := fs.Glob(ui.Files, "html/pages/*.tmpl")
 	if err != nil {
+
 		return nil, err
 	}
 
 	// Loop through the page filepaths one-by-one.
 	for _, page := range pages {
 		name := filepath.Base(page)
 
-		ts, err := template.New(name).Funcs(functions).ParseFiles("./ui/html/base.tmpl")
-		if err != nil {
-			return nil, err
+		patterns := []string{
+			"html/base.tmpl",
+			"html/partials/*.tmpl",
+			page,
 		}
 
-		ts, err = ts.ParseGlob("./ui/html/partials/*.tmpl")
+		ts, err := template.New(name).Funcs(functions).ParseFS(ui.Files,
+			patterns...)
 		if err != nil {
 			return nil, err
 		}
-
-		ts, err = ts.ParseFiles(page)
-		if err != nil {
-			return nil, err
-		}
-
 		cache[name] = ts
 	}
 

cmd/config/templates_test.go

@@ -0,0 +1,37 @@
+package config
+
+import (
+	"snippetbox.pethron.me/internal/assert"
+	"testing"
+	"time"
+)
+
+func TestHumanDate(t *testing.T) {
+	tests := []struct {
+		name string
+		tm   time.Time
+		want string
+	}{
+		{
+			name: "UTC",
+			tm:   time.Date(2022, 3, 17, 10, 15, 0, 0, time.UTC),
+			want: "17 Mar 2022 at 10:15",
+		}, {
+			name: "Empty",
+			tm:   time.Time{},
+			want: "",
+		}, {
+			name: "CET",
+			tm:   time.Date(2022, 3, 17, 10, 15, 0, 0, time.FixedZone("CET", 1*60*60)),
+			want: "17 Mar 2022 at 09:15",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			hd := humanDate(tt.tm)
+			// Use the new assert.Equal() helper to compare the expected and
+			// actual values.
+			assert.Equal(t, hd, tt.want)
+		})
+	}
+}

cmd/web/handlers.go

@@ -84,7 +84,7 @@ func snippetCreatePost(app *config.Application) http.HandlerFunc {
 		form.CheckField(validator.NotBlank(form.Title), "title", "This field cannot be blank")
 		form.CheckField(validator.MaxChars(form.Title, 100), "title", "This field cannot be more than 100 characters long")
 		form.CheckField(validator.NotBlank(form.Content), "content", "This field cannot be blank")
-		form.CheckField(validator.PermittedInt(form.Expires, 1, 7, 365), "expires", "This field must equal 1, 7 or 365")
+		form.CheckField(validator.PermittedValue(form.Expires, 1, 7, 365), "expires", "This field must equal 1, 7 or 365")
 
 		if !form.Valid() {
 			data := app.NewTemplateData(r)
@@ -235,3 +235,7 @@ func userLogoutPost(app *config.Application) http.HandlerFunc {
 		http.Redirect(w, r, "/", http.StatusSeeOther)
 	}
 }
+
+func ping(w http.ResponseWriter, r *http.Request) {
+	w.Write([]byte("OK"))
+}

cmd/web/handlers_test.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"snippetbox.pethron.me/internal/assert"
+	"testing"
+)
+
+func TestPing(t *testing.T) {
+	// Initialize a new httptest.ResponseRecorder.
+	rr := httptest.NewRecorder()
+	// Initialize a new dummy http.Request.
+	r, err := http.NewRequest(http.MethodGet, "/", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Call the ping handler function, passing in the
+	// httptest.ResponseRecorder and http.Request.
+	ping(rr, r)
+	// Call the Result() method on the http.ResponseRecorder to get the
+	// http.Response generated by the ping handler.
+	rs := rr.Result()
+	// Check that the status code written by the ping handler was 200.
+	assert.Equal(t, rs.StatusCode, http.StatusOK)
+	// And we can check that the response body written by the ping handler
+	// equals "OK".
+	defer rs.Body.Close()
+	body, err := io.ReadAll(rs.Body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	bytes.TrimSpace(body)
+	assert.Equal(t, string(body), "OK")
+}

cmd/web/routes.go

@@ -5,6 +5,7 @@ import (
 	"github.com/justinas/alice"
 	"net/http"
 	"snippetbox.pethron.me/cmd/config"
+	"snippetbox.pethron.me/ui"
 )
 
 func routes(app *config.Application) func() http.Handler {
@@ -15,9 +16,9 @@ func routes(app *config.Application) func() http.Handler {
 			app.NotFoundError(w)
 		})
 
-		fileServer := http.FileServer(http.Dir("./ui/static/"))
+		fileServer := http.FileServer(http.FS(ui.Files))
 
-		router.Handler(http.MethodGet, "/static/*filepath", http.StripPrefix("/static", fileServer))
+		router.Handler(http.MethodGet, "/static/*filepath", fileServer)
 
 		// unprotected
 		dynamic := alice.New(app.SessionManager.LoadAndSave, noSurf, Authenticate(app))

internal/assert/assert.go

@@ -0,0 +1,10 @@
+package assert
+
+import "testing"
+
+func Equal[T comparable](t *testing.T, actual, expected T) {
+	t.Helper()
+	if actual != expected {
+		t.Errorf("got: %v; want: %v", actual, expected)
+	}
+}

internal/validator/validator.go

@@ -70,6 +70,15 @@ func PermittedInt(value int, permittedValues ...int) bool {
 	return false
 }
 
+func PermittedValue[T comparable](value T, permittedValues ...T) bool {
+	for i := range permittedValues {
+		if value == permittedValues[i] {
+			return true
+		}
+	}
+	return false
+}
+
 // Matches returns true if a value matches a provided compiled regular
 // expression pattern.
 func Matches(value string, rx *regexp.Regexp) bool {

tmp/web

@@ -0,0 +1,8 @@
+package ui
+
+import (
+	"embed"
+)
+
+//go:embed "html" "static"
+var Files embed.FS