04-03. Add fetching course command

Author: etrapani

04-03-command-bus/cmd/api/bootstrap/boostrap.go

@@ -3,6 +3,7 @@ package bootstrap
 import (
 	"database/sql"
 	"fmt"
+	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal/fetching"
 
 	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal/creating"
 	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal/platform/bus/inmemory"
@@ -36,9 +37,13 @@ func Run() error {
 	courseRepository := mysql.NewCourseRepository(db)
 
 	creatingCourseService := creating.NewCourseService(courseRepository)
+	fetchingCourseService := fetching.NewCourseFetchingService(courseRepository)
 
 	createCourseCommandHandler := creating.NewCourseCommandHandler(creatingCourseService)
+	fetchingCourseCommandHandler := fetching.NewCourseCommandHandler(fetchingCourseService)
+
 	commandBus.Register(creating.CourseCommandType, createCourseCommandHandler)
+	commandBus.Register(fetching.CourseCommandType, fetchingCourseCommandHandler)
 
 	srv := server.New(host, port, commandBus)
 	return srv.Run()

04-03-command-bus/internal/course.go

@@ -87,6 +87,7 @@ type Course struct {
 // CourseRepository defines the expected behaviour from a course storage.
 type CourseRepository interface {
 	Save(ctx context.Context, course Course) error
+	GetAll(ctx context.Context) ([]Course, error)
 }
 
 //go:generate mockery --case=snake --outpkg=storagemocks --output=platform/storage/storagemocks --name=CourseRepository

04-03-command-bus/internal/creating/service.go

@@ -27,3 +27,4 @@ func (s CourseService) CreateCourse(ctx context.Context, id, name, duration stri
 	}
 	return s.courseRepository.Save(ctx, course)
 }
+

04-03-command-bus/internal/fetching/command.go

@@ -0,0 +1,46 @@
+package fetching
+
+import (
+	"context"
+	"errors"
+	mooc "github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal"
+
+	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/kit/command"
+)
+
+const CourseCommandType command.Type = "command.fetching.courses"
+
+// CourseCommand is the command dispatched to create a new course.
+type CourseCommand struct {
+}
+// NewCourseCommand creates a new CourseCommand.
+func NewFetchCourseCommand() CourseCommand {
+	return CourseCommand{}
+}
+
+func (c CourseCommand) Type() command.Type {
+	return CourseCommandType
+}
+
+// CourseCommandHandler is the command handler
+// responsible for creating courses.
+type CourseCommandHandler struct {
+	service FetchingCourseService
+}
+
+// NewCourseCommandHandler initializes a new CourseCommandHandler.
+func NewCourseCommandHandler(service FetchingCourseService) CourseCommandHandler {
+	return CourseCommandHandler{
+		service: service,
+	}
+}
+
+// Handle implements the command.Handler interface.
+func (h CourseCommandHandler) Handle(ctx context.Context, cmd command.Command) ([]mooc.Course, error) {
+	_, ok := cmd.(CourseCommand)
+	if !ok {
+		return nil, errors.New("unexpected command")
+	}
+
+	return h.service.GetAll(ctx)
+}

04-03-command-bus/internal/fetching/service.go

@@ -0,0 +1,25 @@
+package fetching
+
+import (
+	"context"
+
+	mooc "github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/internal"
+)
+
+// CourseService is the default CourseService interface
+// implementation returned by fetching.NewCourseFetchingService.
+type FetchingCourseService struct {
+	courseRepository mooc.CourseRepository
+}
+
+// NewCourseService returns the default Service interface implementation.
+func NewCourseFetchingService(courseRepository mooc.CourseRepository) FetchingCourseService {
+	return FetchingCourseService{
+		courseRepository: courseRepository,
+	}
+}
+
+// CreateCourse implements the creating.CourseService interface.
+func (s FetchingCourseService) GetAll(ctx context.Context) ([]mooc.Course, error) {
+	return s.courseRepository.GetAll(ctx)
+}

04-03-command-bus/internal/platform/server/handler/courses/get.go

@@ -0,0 +1,34 @@
+package courses
+
+import (
+	"github.com/CodelyTV/go-hexagonal_http_api-course/04-03-command-bus/kit/command"
+	"github.com/gin-gonic/gin"
+)
+
+type getResponse struct {
+	Id       string `json:"id"`
+	Name     string `json:"name"`
+	Duration string `json:"duration"`
+}
+
+// GetHandler returns an HTTP handler for courses.
+func GetHandler(commandBus command.Bus) gin.HandlerFunc {
+	return func(ctx *gin.Context) {
+		/*var courses, err := commandBus.Dispatch(ctx, fetching.NewFetchCourseCommand())
+
+		if err != nil {
+			// Si quiero devolver error en ves de la lista se rompe me genera un error de unmarshal
+			ctx.JSON(http.StatusInternalServerError, []getResponse{})
+			return
+		}
+		response := make([]getResponse, 0, len(courses))
+		for _, course := range courses {
+			response = append(response, getResponse{
+				Id:       course.ID().String(),
+				Name:     course.Name().String(),
+				Duration: course.Duration().String(),
+			})
+		}
+		ctx.JSON(http.StatusOK, response)*/
+	}
+}

04-03-command-bus/internal/platform/server/handler/courses/get_test.go

@@ -0,0 +1,76 @@
+package courses
+
+import (
+	"encoding/json"
+	"errors"
+	mooc "github.com/CodelyTV/go-hexagonal_http_api-course/02-04-domain-validations/internal"
+	"github.com/CodelyTV/go-hexagonal_http_api-course/02-04-domain-validations/internal/platform/storage/storagemocks"
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestGetHandler(t *testing.T) {
+	tests := map[string]struct {
+		mockData []mooc.Course
+		mockError error
+		expectedResponse []getResponse
+		expectedStatus int
+	}{
+		"Empty repo return 200 with empty list": {
+			mockData: []mooc.Course{},
+			mockError: nil,
+			expectedStatus:http.StatusOK,
+			expectedResponse: []getResponse{}},
+		"Repo error return 500": {
+			mockData: []mooc.Course{},
+			mockError: errors.New("the field Duration can not be empty"),
+			expectedStatus:http.StatusInternalServerError,
+			expectedResponse: []getResponse{}},
+		"Fully repo return 200 with list of courses":{
+			mockData: []mooc.Course{ mockCourse("8a1c5cdc-ba57-445a-994d-aa412d23723f", "Courses Complete", "123")},
+			mockError: nil,
+			expectedStatus:http.StatusOK,
+			expectedResponse: []getResponse{{Id: "8a1c5cdc-ba57-445a-994d-aa412d23723f", Name: "Courses Complete", Duration: "123"}}},
+	}
+	for key, value := range tests {
+		t.Run(key, func(t *testing.T) {
+
+			courseRepository := new(storagemocks.CourseRepository)
+			courseRepository.On("GetAll", mock.Anything).Return(value.mockData, value.mockError)
+			gin.SetMode(gin.TestMode)
+			r := gin.New()
+			r.GET("/courses", GetHandler(courseRepository))
+
+			req, err := http.NewRequest(http.MethodGet, "/courses", nil)
+			require.NoError(t, err)
+
+			rec := httptest.NewRecorder()
+			r.ServeHTTP(rec, req)
+
+			res := rec.Result()
+			defer res.Body.Close()
+
+			assert.Equal(t, value.expectedStatus, res.StatusCode)
+			var response []getResponse
+			if err := json.NewDecoder(res.Body).Decode(&response); err != nil {
+				log.Fatalln(err)
+			}
+
+			assert.Equal(t, value.expectedResponse, response)
+		})
+	}
+}
+
+func mockCourse(id string, name string, duration string) mooc.Course {
+	course, err := mooc.NewCourse(id, name, duration)
+	if err != nil{
+		log.Fatalln(err)
+	}
+	return course
+}

04-03-command-bus/internal/platform/server/server.go

@@ -38,4 +38,5 @@ func (s *Server) Run() error {
 func (s *Server) registerRoutes() {
 	s.engine.GET("/health", health.CheckHandler())
 	s.engine.POST("/courses", courses.CreateHandler(s.commandBus))
+	s.engine.GET("/courses", courses.GetHandler(s.commandBus))
 }

04-03-command-bus/internal/platform/storage/mysql/course_repository.go

@@ -37,3 +37,34 @@ func (r *CourseRepository) Save(ctx context.Context, course mooc.Course) error {
 
 	return nil
 }
+
+
+// GetAll implements the mooc.CourseRepository interface.
+func (r *CourseRepository) GetAll(ctx context.Context) (courses []mooc.Course, err error) {
+	courseSQLStruct := sqlbuilder.NewSelectBuilder()
+	courseSQLStruct.Select("id", "name", "duration")
+	courseSQLStruct.From(sqlCourseTable)
+
+	sqlQuery, args := courseSQLStruct.Build()
+
+
+	rows, err := r.db.QueryContext(ctx, sqlQuery, args...)
+	if err != nil {
+		return nil, fmt.Errorf("error trying to get course on database: %v", err)
+	}
+	defer rows.Close()
+	courses = []mooc.Course{}
+	for rows.Next() {
+		var sqlCourse sqlCourse
+		err := rows.Scan(sqlCourse.ID, sqlCourse.Name, sqlCourse.Duration)
+		if err != nil {
+			return nil, err
+		}
+		course, err := mooc.NewCourse(sqlCourse.ID, sqlCourse.Name, sqlCourse.Duration)
+		if err != nil {
+			return nil, err
+		}
+		courses = append(courses, course)
+	}
+	return courses, nil
+}