webapp

internal/server/http.go

@@ -0,0 +1,64 @@
+package server
+
+import (
+	"encoding/json"
+	"net/http"
+
+	apimiddleware "clintonambulance.com/calculate_negative_points/internal/api/middleware"
+	views_api "clintonambulance.com/calculate_negative_points/internal/api/requests"
+	"clintonambulance.com/calculate_negative_points/internal/config"
+	internal_web "clintonambulance.com/calculate_negative_points/internal/web"
+	"github.com/go-chi/chi/v5/middleware"
+	"github.com/swaggest/openapi-go/openapi31"
+	"github.com/swaggest/rest/response"
+	"github.com/swaggest/rest/web"
+	"go.uber.org/zap"
+)
+
+type ErrorResponse struct {
+	Message string `json:"message"`
+}
+
+func errorResponder(w http.ResponseWriter, error string, code int) {
+	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+	w.WriteHeader(code)
+	_ = json.NewEncoder(w).Encode(ErrorResponse{Message: error})
+}
+
+func notFoundResponder(w http.ResponseWriter, _r *http.Request) {
+	errorResponder(w, "Not Found", http.StatusNotFound)
+}
+
+func NewHttpServer(logger *zap.Logger, version config.Version) (*web.Service, *openapi31.Reflector) {
+	reflector := openapi31.NewReflector()
+	service := web.NewService(reflector)
+
+	service.OpenAPISchema().SetTitle("Calculate Negative Points")
+	service.OpenAPISchema().SetDescription("Easily maintain Calculate Negative Points")
+	service.OpenAPISchema().SetVersion("v1.0.0")
+
+	service.Use(
+		middleware.RealIP,
+		middleware.RequestID,
+		apimiddleware.AddRequestIDHeaderMiddleware,
+		apimiddleware.LoggingMiddleware(logger),
+		apimiddleware.ErrorHandler,
+	)
+	service.NotFound(notFoundResponder)
+
+	return service, reflector
+}
+
+func MountAllEndpoints(srv *web.Service, version config.Version, config *config.ApplicationConfig, logger *zap.Logger) {
+	views_api.MountInternalApiEndpoints(srv, config, logger)
+
+	// This should be last because it does wildcard matching
+	internal_web.MountWebEndpoints(srv, config, logger)
+}
+
+func init() {
+	// Override some global defaults:
+	// This is just "application/json" by default, let's include the charset as well.
+	response.DefaultSuccessResponseContentType = "application/json; charset=UTF-8"
+}

internal/server/http_test.go

@@ -0,0 +1,51 @@
+package server_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+
+	"testing"
+
+	"clintonambulance.com/calculate_negative_points/internal/config"
+	"clintonambulance.com/calculate_negative_points/internal/server"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestServer(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Http Suite")
+}
+
+var _ = Describe("NewHttpServer", func() {
+	It("Creates a new HttpServer", func() {
+		var logOutput bytes.Buffer
+		version := config.Version{Release: "test-version"}
+		logger, _ := config.NewLogger(version, &logOutput, []string{"cmd", "-e", "testEnvironment"})
+		srv, _ := server.NewHttpServer(logger, version)
+		srv.Method(http.MethodHead, "/dummy-route", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusNoContent)
+		}))
+
+		req := httptest.NewRequest(http.MethodGet, "/foobar", nil)
+		rec := httptest.NewRecorder()
+
+		// Validate that the server responds with the web frontend for unknown routes
+		srv.ServeHTTP(rec, req)
+
+		Expect(rec.Code).To(Equal(http.StatusNotFound))
+		Expect(rec.Header().Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
+		Expect(rec.Body.String()).To(ContainSubstring(`{"message":"Not Found"}`))
+
+		// Validate that it writes to the log for all requests
+		var logMessage map[string]interface{}
+		err := json.Unmarshal(logOutput.Bytes(), &logMessage)
+		Expect(err).ToNot(HaveOccurred())
+		Expect(logMessage["msg"]).To(Equal("HTTP request processed"))
+		Expect(logMessage["method"]).To(Equal("GET"))
+		Expect(logMessage["uri"]).To(Equal("/foobar"))
+		Expect(logMessage["status"]).To(Equal(404.0))
+	})
+})