cmd/web/main.go

@@ -23,25 +23,8 @@ var (
 
 // main is the main application function
 func main() {
-	err := run()
+    // what am I going to put in the session
-	if err != nil {
+    gob.Register(models.Reservation{})
-		log.Fatal(err)
-	}
-
-	fmt.Printf("Starting application on port %s\n", portNumber)
-
-	srv := &http.Server{
-		Addr:    portNumber,
-		Handler: routes(&app),
-	}
-
-	err = srv.ListenAndServe()
-	log.Fatal(err)
-}
-
-func run() error {
-	// what am I going to put in the session
-	gob.Register(models.Reservation{})
 
 	// change this to true when in production
 	app.InProduction = false
@@ -65,5 +48,14 @@ func run() error {
 	handlers.NewHandlers(repo)
 
 	render.NewTemplates(&app)
-	return nil
+
+	fmt.Printf("Starting application on port %s\n", portNumber)
+
+	srv := &http.Server{
+		Addr:    portNumber,
+		Handler: routes(&app),
+	}
+
+	err = srv.ListenAndServe()
+	log.Fatal(err)
 }

cmd/web/main_test.go

@@ -1,10 +0,0 @@
-package main
-
-import "testing"
-
-func TestRun(t *testing.T) {
-	err := run()
-	if err != nil {
-		t.Error("failed run()")
-	}
-}

cmd/web/middleware_test.go

@@ -1,45 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"testing"
-)
-
-func TestNoSurf(t *testing.T) {
-	var myH myHandler
-
-	h := NoSurf(&myH)
-
-	switch v := h.(type) {
-	case http.Handler:
-	// do nothing
-	default:
-		t.Errorf("type is not http.Handler, but is %T", v)
-	}
-}
-
-func TestSessionLoad(t *testing.T) {
-	var myH myHandler
-
-	s := SessionLoad(&myH)
-
-	switch v := s.(type) {
-	case http.Handler:
-	// do nothing
-	default:
-		t.Errorf("type is not http.Handler, but is %T", v)
-	}
-}
-
-func TestWriteToConsole(t *testing.T) {
-	var myH myHandler
-
-	w := WriteToConsole(&myH)
-
-	switch v := w.(type) {
-	case http.Handler:
-	// do nothing
-	default:
-		t.Errorf("type is not http.Handler, but is %T", v)
-	}
-}

cmd/web/routes_test.go

@@ -1,21 +0,0 @@
-package main
-
-import (
-	"go-udemy-web-1/internal/config"
-	"testing"
-
-	"github.com/go-chi/chi/v5"
-)
-
-func TestRoutes(t *testing.T) {
-	var app config.AppConfig
-
-	mux := routes(&app)
-
-	switch v := mux.(type) {
-	case *chi.Mux:
-	// do nothing
-	default:
-		t.Errorf("type is not *chi.Mux, is %T", v)
-	}
-}

cmd/web/setup_test.go

@@ -1,16 +0,0 @@
-package main
-
-import (
-	"net/http"
-	"os"
-	"testing"
-)
-
-func TestMain(m *testing.M) {
-	os.Exit(m.Run())
-}
-
-type myHandler struct{}
-
-func (mh *myHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-}

internal/handlers/handlers_test.go

@@ -1,75 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"testing"
-)
-
-type postData struct {
-	key   string
-	value string
-}
-
-var theTests = []struct {
-	name               string
-	url                string
-	method             string
-	params             []postData
-	expectedStatusCode int
-}{
-	{"home", "/", "GET", []postData{}, http.StatusOK},
-	{"about", "/about", "GET", []postData{}, http.StatusOK},
-	{"gq", "/generals-quarters", "GET", []postData{}, http.StatusOK},
-	{"ms", "/majors-suite", "GET", []postData{}, http.StatusOK},
-	{"sa", "/availability", "GET", []postData{}, http.StatusOK},
-	{"contact", "/contact", "GET", []postData{}, http.StatusOK},
-	{"ma", "/make-reservation", "GET", []postData{}, http.StatusOK},
-	{"post-search-avail", "/availability", "POST", []postData{
-		{key: "start", value: "2020-01-01"},
-		{key: "end", value: "2020-01-02"},
-	}, http.StatusOK},
-	{"post-search-avail-json", "/availability-json", "POST", []postData{
-		{key: "start", value: "2020-01-01"},
-		{key: "end", value: "2020-01-02"},
-	}, http.StatusOK},
-	{"make-reservation", "/make-reservation", "POST", []postData{
-		{key: "first_name", value: "John"},
-		{key: "last_name", value: "Smith"},
-		{key: "email", value: "me@here.com"},
-		{key: "phone", value: "12345"},
-	}, http.StatusOK},
-}
-
-func TestHandlers(t *testing.T) {
-	routes := getRoutes()
-	ts := httptest.NewTLSServer(routes)
-	defer ts.Close()
-
-	for _, e := range theTests {
-		if e.method == "GET" {
-			resp, err := ts.Client().Get(ts.URL + e.url)
-			if err != nil {
-				t.Log(err)
-				t.Fatal(err)
-			}
-			if resp.StatusCode != e.expectedStatusCode {
-				t.Errorf("for %s, expected %d but got %d", e.name, e.expectedStatusCode, resp.StatusCode)
-			}
-		} else {
-			values := url.Values{}
-			for _, x := range e.params {
-				values.Add(x.key, x.value)
-			}
-			resp, err := ts.Client().PostForm(ts.URL+e.url, values)
-			if err != nil {
-				t.Log(err)
-				t.Fatal(err)
-			}
-			if resp.StatusCode != e.expectedStatusCode {
-				t.Errorf("for %s, expected %d but got %d", e.name, e.expectedStatusCode, resp.StatusCode)
-			}
-		}
-	}
-}

internal/handlers/setup_test.go

@@ -1,140 +0,0 @@
-package handlers
-
-import (
-	"encoding/gob"
-	"fmt"
-	"go-udemy-web-1/internal/config"
-	"go-udemy-web-1/internal/models"
-	"go-udemy-web-1/internal/render"
-	"html/template"
-	"log"
-	"net/http"
-	"path/filepath"
-	"time"
-
-	"github.com/alexedwards/scs/v2"
-	"github.com/go-chi/chi/v5"
-	"github.com/go-chi/chi/v5/middleware"
-	"github.com/justinas/nosurf"
-)
-
-var functions = template.FuncMap{}
-
-var (
-	app     config.AppConfig
-	session *scs.SessionManager
-)
-
-func getRoutes() http.Handler {
-	gob.Register(models.Reservation{})
-	// change this to true when in production
-	app.InProduction = false
-
-	session = scs.New()
-	session.Lifetime = 24 * time.Hour
-	session.Cookie.Persist = true
-	session.Cookie.SameSite = http.SameSiteLaxMode
-	session.Cookie.Secure = app.InProduction
-
-	app.Session = session
-
-	tc, err := CreateTestTemplateCache()
-	if err != nil {
-		log.Fatalf("cannot create template cache: %s", err)
-	}
-	app.TemplateCahce = tc
-	app.UseCache = true // Not to use ./templates
-
-	repo := NewRepo(&app)
-	NewHandlers(repo)
-
-	render.NewTemplates(&app)
-
-	mux := chi.NewMux()
-
-	mux.Use(middleware.Recoverer)
-	// mux.Use(NoSurf)  // No need to test
-	mux.Use(SessionLoad)
-
-	mux.Get("/", Repo.Home)
-	mux.Get("/about", Repo.About)
-	mux.Get("/contact", Repo.Contact)
-	mux.Get("/generals-quarters", Repo.Generals)
-	mux.Get("/majors-suite", Repo.Majors)
-	mux.Get("/availability", Repo.Availability)
-	mux.Post("/availability", Repo.PostAvailability)
-	mux.Post("/availability-json", Repo.AvailabilityJSON)
-	mux.Get("/make-reservation", Repo.MakeReservation)
-	mux.Post("/make-reservation", Repo.PostMakeReservation)
-	mux.Get("/reservation-summary", Repo.ReservationSummary)
-
-	fileServer := http.FileServer(http.Dir("./static/"))
-	mux.Handle("/static/*", http.StripPrefix("/static", fileServer))
-
-	return mux
-}
-
-// WriteToConsole writes a log when user hits a page
-func WriteToConsole(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		fmt.Printf("Hit the page %s\n", r.URL.String())
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// NoSurf adds CSRF protection to all POST requests
-func NoSurf(next http.Handler) http.Handler {
-	csrfHandler := nosurf.New(next)
-
-	csrfHandler.SetBaseCookie(http.Cookie{
-		HttpOnly: true,
-		Path:     "/",
-		Secure:   app.InProduction,
-		SameSite: http.SameSiteLaxMode,
-	})
-
-	return csrfHandler
-}
-
-// SessionLoad loads and saves the session on every request
-func SessionLoad(next http.Handler) http.Handler {
-	return session.LoadAndSave(next)
-}
-
-var pathToTemplates = "../../templates"
-
-func CreateTestTemplateCache() (map[string]*template.Template, error) {
-	myCache := map[string]*template.Template{}
-
-	// get all of the files named *.page.tmpl from templates
-	pages, err := filepath.Glob(fmt.Sprintf("%s/*.page.tmpl", pathToTemplates))
-	if err != nil {
-		return myCache, err
-	}
-
-	// range through all files ending with *page.tmpl
-	for _, page := range pages {
-		name := filepath.Base(page)
-		ts, err := template.New(name).Funcs(functions).ParseFiles(page)
-		if err != nil {
-			return myCache, err
-		}
-
-		matches, err := filepath.Glob(fmt.Sprintf("%s/*.layout.tmpl", pathToTemplates))
-		if err != nil {
-			return myCache, err
-		}
-
-		if len(matches) > 0 {
-			ts, err = ts.ParseGlob(fmt.Sprintf("%s/*.layout.tmpl", pathToTemplates))
-			if err != nil {
-				return myCache, err
-			}
-		}
-
-		myCache[name] = ts
-	}
-
-	return myCache, nil
-}

internal/render/render.go

@@ -2,7 +2,6 @@ package render
 
 import (
 	"bytes"
-	"fmt"
 	"go-udemy-web-1/internal/config"
 	"go-udemy-web-1/internal/models"
 	"html/template"
@@ -13,12 +12,7 @@ import (
 	"github.com/justinas/nosurf"
 )
 
-var functions = template.FuncMap{}
+var app *config.AppConfig
-
-var (
-	app             *config.AppConfig
-	pathToTemplates = "./templates"
-)
 
 // NewTemplates sets the config for the template package
 func NewTemplates(a *config.AppConfig) {
@@ -71,8 +65,8 @@ func RenderTemplate(w http.ResponseWriter, r *http.Request, tmpl string, td *mod
 func CreateTemplateCache() (map[string]*template.Template, error) {
 	myCache := map[string]*template.Template{}
 
-	// get all of the files named *.page.tmpl from templates
+	// get all of the files named *.page.tmpl from ./templates
-	pages, err := filepath.Glob(fmt.Sprintf("%s/*.page.tmpl", pathToTemplates))
+	pages, err := filepath.Glob("./templates/*.page.tmpl")
 	if err != nil {
 		return myCache, err
 	}
@@ -80,18 +74,18 @@ func CreateTemplateCache() (map[string]*template.Template, error) {
 	// range through all files ending with *page.tmpl
 	for _, page := range pages {
 		name := filepath.Base(page)
-		ts, err := template.New(name).Funcs(functions).ParseFiles(page)
+		ts, err := template.New(name).ParseFiles(page)
 		if err != nil {
 			return myCache, err
 		}
 
-		matches, err := filepath.Glob(fmt.Sprintf("%s/*.layout.tmpl", pathToTemplates))
+		matches, err := filepath.Glob("./templates/*.layout.tmpl")
 		if err != nil {
 			return myCache, err
 		}
 
 		if len(matches) > 0 {
-			ts, err = ts.ParseGlob(fmt.Sprintf("%s/*.layout.tmpl", pathToTemplates))
+			ts, err = ts.ParseGlob("./templates/*.layout.tmpl")
 			if err != nil {
 				return myCache, err
 			}