feat: abstract out transport layer

Author: kendallm

example

@@ -0,0 +1,8 @@
+package errors
+
+import "errors"
+
+var (
+	ErrNotFound   = errors.New("not found")
+	ErrBadRequest = errors.New("bad request")
+)

internal/errors/errors.go

@@ -0,0 +1,86 @@
+package transport
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+
+	appErr "example/internal/errors"
+	"example/internal/users"
+
+	"github.com/labstack/echo/v4"
+)
+
+type HTTPConfig struct {
+	Port         int
+	UsersService users.Service
+}
+
+type HTTPServer struct {
+	e    *echo.Echo
+	port int
+}
+
+func NewHTTPServer(config *HTTPConfig) *HTTPServer {
+	e := echo.New()
+	registerHTTPRoutes(e, config.UsersService)
+	return &HTTPServer{
+		e:    e,
+		port: config.Port,
+	}
+}
+
+func (server *HTTPServer) Start() {
+	server.e.Logger.Fatal(server.e.Start(fmt.Sprintf(":%d", server.port)))
+}
+
+func registerHTTPRoutes(e *echo.Echo, usersService users.Service) {
+	e.PUT("/users/:id", updateUser(usersService))
+}
+
+type updateUserRequest struct {
+	ID        string `param:"id"`
+	FirstName string `json:"first_name"`
+	LastName  string `json:"last_name"`
+}
+
+type updateUserResponse struct {
+	ID        string `json:"id"`
+	FirstName string `json:"first_name"`
+	LastName  string `json:"last_name"`
+}
+
+func updateUser(usersService users.Service) echo.HandlerFunc {
+	return func(c echo.Context) error {
+		var request updateUserRequest
+		err := c.Bind(&request)
+		if err != nil {
+			return c.NoContent(http.StatusBadRequest)
+		}
+
+		resp, err := usersService.UpdateUser(users.UpdateUserRequest{
+			ID:        request.ID,
+			FirstName: request.FirstName,
+			LastName:  request.LastName,
+		})
+
+		if err != nil {
+			return c.NoContent(MapErrorToHTTPStatus(err))
+		}
+		return c.JSON(http.StatusOK, updateUserResponse{
+			ID:        resp.ID,
+			FirstName: resp.FirstName,
+			LastName:  resp.LastName,
+		})
+	}
+}
+
+func MapErrorToHTTPStatus(err error) int {
+	switch {
+	case errors.Is(err, appErr.ErrNotFound):
+		return http.StatusNotFound
+	case errors.Is(err, appErr.ErrBadRequest):
+		return http.StatusNotFound
+	}
+	return http.StatusInternalServerError
+}

internal/transport/http.go

@@ -0,0 +1,49 @@
+package users
+
+import (
+	appErr "example/internal/errors"
+	"fmt"
+)
+
+type UpdateUserRequest struct {
+	ID        string
+	FirstName string
+	LastName  string
+}
+
+type UpdateUserResponse struct {
+	ID        string
+	FirstName string
+	LastName  string
+}
+
+type User struct {
+	ID        string
+	FirstName string
+	LastName  string
+}
+
+type Service struct {
+	DB map[string]*User
+}
+
+func (s *Service) UpdateUser(request UpdateUserRequest) (UpdateUserResponse, error) {
+	user, ok := s.DB[request.ID]
+	if !ok {
+		return UpdateUserResponse{}, fmt.Errorf("unable to find user in db: %w", appErr.ErrNotFound)
+	}
+
+	if request.FirstName != "" {
+		user.FirstName = request.FirstName
+	}
+
+	if request.LastName != "" {
+		user.LastName = request.LastName
+	}
+
+	return UpdateUserResponse{
+		ID:        user.ID,
+		FirstName: user.FirstName,
+		LastName:  user.LastName,
+	}, nil
+}

internal/users/service.go

@@ -0,0 +1,65 @@
+package users_test
+
+import (
+	"testing"
+
+	appErr "example/internal/errors"
+	"example/internal/users"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUpdateUser(t *testing.T) {
+
+	t.Run("should update user when user exists", func(t *testing.T) {
+
+		mockDB := map[string]*users.User{
+			"test_user_id": &users.User{
+				ID:        "test_user_id",
+				FirstName: "Test",
+				LastName:  "User",
+			},
+		}
+
+		request := users.UpdateUserRequest{
+			ID:        "test_user_id",
+			FirstName: "UpdatedTest",
+			LastName:  "UpdatedUser",
+		}
+		expectedResponse := users.UpdateUserResponse{
+			ID:        "test_user_id",
+			FirstName: "UpdatedTest",
+			LastName:  "UpdatedUser",
+		}
+		s := users.Service{DB: mockDB}
+
+		if response, err := s.UpdateUser(request); assert.NoError(t, err) {
+			user := mockDB["test_user_id"]
+			assert.Equal(t, expectedResponse, response)
+			assert.Equal(t, "UpdatedTest", user.FirstName)
+			assert.Equal(t, "UpdatedUser", user.LastName)
+		}
+	})
+
+	t.Run("should return ErrNotFound when user not found", func(t *testing.T) {
+		mockDB := map[string]*users.User{
+			"test_user_id": &users.User{
+				ID:        "test_user_id",
+				FirstName: "Test",
+				LastName:  "User",
+			},
+		}
+
+		request := users.UpdateUserRequest{
+			ID:        "bad_user_id",
+			FirstName: "UpdatedTest",
+			LastName:  "UpdatedUser",
+		}
+
+		s := users.Service{DB: mockDB}
+
+		if response, err := s.UpdateUser(request); assert.ErrorIs(t, err, appErr.ErrNotFound) {
+			assert.Equal(t, users.UpdateUserResponse{}, response)
+		}
+	})
+}

internal/users/service_test.go

@@ -1,9 +1,8 @@
 package main
 
 import (
-	"net/http"
-
-	"github.com/labstack/echo/v4"
+	"example/internal/transport"
+	"example/internal/users"
 )
 
 type User struct {
@@ -13,27 +12,15 @@ type User struct {
 }
 
 func main() {
-	userDB := make(map[string]*User)
-	e := echo.New()
-	e.PUT("/users/:id", updateUser(userDB))
-	e.Logger.Fatal(e.Start(":8080"))
-}
-
-func updateUser(userDB map[string]*User) echo.HandlerFunc {
-	return func(c echo.Context) error {
-		var user User
-		err := c.Bind(&user)
-		if err != nil {
-			return c.NoContent(http.StatusBadRequest)
-		}
-		dbUser, ok := userDB[user.ID]
-		if !ok {
-			return c.NoContent(http.StatusNotFound)
-		}
+	userDB := make(map[string]*users.User)
+	usersService := users.Service{
+		DB: userDB,
+	}
 
-		dbUser.FirstName = user.FirstName
-		dbUser.LastName = user.LastName
+	httpService := transport.NewHTTPServer(&transport.HTTPConfig{
+		Port:         8080,
+		UsersService: usersService,
+	})
 
-		return c.JSON(http.StatusOK, dbUser)
-	}
+	httpService.Start()
 }