Merge pull request #2 from mmadariaga/get-f1-race-summary-by-year-api-endpoint

f1 race summary

Author: mmadariaga

README.md

@@ -21,8 +21,9 @@ go run cmd/api/main.go
 
 ## Features
 
-Currently, the API only has one route:
+Currently, the API only has two routes:
 - `GET /ping`: Returns a simple "pong" response.
+- `GET /races`: Returns application_races.Response json object with a summary of all the races of the year 2024 in f1. This endpoint requires Basic Auth
 
 Example:
 ```bash
@@ -32,7 +33,7 @@ pong
 
 ## TODO
 
- - [ ] Add more routes and functionalities.
+ - [ ] Use goroutines to fetch data from third party APIs faster
  - [ ] Enhance test coverage.
 
 ## Licence

bin/run

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+set -e 
+SCRIPT_DIR=$(dirname $(realpath $0))
+
+pushd ${SCRIPT_DIR}/../
+    go run cmd/api/main.go
+popd

cmd/api/main.go

@@ -8,14 +8,14 @@ import (
 
 	"fmt"
 
-	"github.com/mmadariaga/go-api/internal/router"
+	infrastructure_router "github.com/mmadariaga/go-api/internal/infrastructure/router"
 )
 
 func main() {
 	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
 	log.Print("Starting GO API service")
 
-	router := router.RouterFactory()
+	router := infrastructure_router.RouterFactory()
 
 	port := ":8080"
 	log.Print("listening on localhost" + port)

internal/application/pong/Pong.go

@@ -0,0 +1,5 @@
+package application_pong
+
+func Pong() string {
+	return "pong"
+}

internal/application/pong/Pong_test.go

@@ -0,0 +1,16 @@
+package application_pong
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPong(t *testing.T) {
+
+	assert := assert.New(t)
+
+	resp := Pong()
+
+	assert.Equal(resp, "pong")
+}

internal/application/races/GetRacesByYear.go

@@ -0,0 +1,57 @@
+package application_races
+
+import (
+	domain_model "github.com/mmadariaga/go-api/internal/domain/model"
+	domain_service "github.com/mmadariaga/go-api/internal/domain/service"
+)
+
+type Response struct {
+	domain_model.Race
+	Podium [3]domain_model.Podium `json:"podium"`
+}
+
+type GetRacesByYearDependencies interface {
+	domain_service.GetPodiumByRaceDependencies
+	FetchRacesByYear(year int) ([]domain_model.Race, error)
+}
+
+func GetRacesByYear(
+	year int,
+	dependencies GetRacesByYearDependencies,
+) ([]Response, error) {
+
+	races, error := dependencies.FetchRacesByYear(year)
+	if error != nil {
+		return nil, error
+	}
+
+	podiumsByRace, error := domain_service.GetPodiumByRace(
+		races,
+		dependencies,
+	)
+	if error != nil {
+		return nil, error
+	}
+
+	response := make([]Response, 0, len(races))
+	for _, race := range races {
+
+		podium := podiumsByRace[race.Id]
+
+		response = append(
+			response,
+			Response{
+				Race: domain_model.Race{
+					Id:          race.Id,
+					Year:        race.Year,
+					StartDate:   race.StartDate,
+					CountryName: race.CountryName,
+					CircuitName: race.CircuitName,
+				},
+				Podium: podium,
+			},
+		)
+	}
+
+	return response, nil
+}

internal/application/races/GetRacesByYear_test.go

@@ -0,0 +1,78 @@
+package application_races
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+
+	domain_model "github.com/mmadariaga/go-api/internal/domain/model"
+	test_domain_model "github.com/mmadariaga/go-api/internal/test/domain/model"
+)
+
+func TestGetRacesByYear(t *testing.T) {
+
+	assert := assert.New(t)
+
+	suzuka := test_domain_model.Suzuka()
+	drivers := test_domain_model.GetAllDriverExamplesAsArray()
+	podiums := test_domain_model.GetPodiumWithDrivers(
+		"Max VERSTAPPEN",
+		"Fernando ALONSO",
+		"Lewis HAMILTON",
+	)
+
+	mockInfraDependencies := new(MockInfraDependencies)
+	mockInfraDependencies.On(
+		"FetchRacesByYear",
+		2024,
+	).Return(
+		suzuka,
+		nil,
+	)
+	mockInfraDependencies.On(
+		"FetchPodiumByRace",
+		suzuka[0].Id,
+		drivers,
+	).Return(
+		podiums,
+		nil,
+	)
+	mockInfraDependencies.On(
+		"FetchDriversByRace",
+		suzuka[0].Id,
+	).Return(
+		drivers,
+		nil,
+	)
+
+	result, error := GetRacesByYear(
+		2024,
+		mockInfraDependencies,
+	)
+
+	assert.Equal(error, nil)
+	assert.Equal(result[0].Race.CircuitName, "Suzuka")
+	assert.Equal(result[0].Podium[0].Position, 1)
+	assert.Equal(result[0].Podium[0].FullName, "Max VERSTAPPEN")
+	assert.Equal(result[0].Podium[1].FullName, "Fernando ALONSO")
+
+	mockInfraDependencies.AssertExpectations(t)
+}
+
+type MockInfraDependencies struct {
+	mock.Mock
+}
+
+func (m *MockInfraDependencies) FetchRacesByYear(year int) ([]domain_model.Race, error) {
+	args := m.Called(year)
+	return args.Get(0).([]domain_model.Race), args.Error(1)
+}
+func (m *MockInfraDependencies) FetchPodiumByRace(raceId int, drivers []domain_model.Driver) ([3]domain_model.Podium, error) {
+	args := m.Called(raceId, drivers)
+	return args.Get(0).([3]domain_model.Podium), args.Error(1)
+}
+func (m *MockInfraDependencies) FetchDriversByRace(raceId int) ([]domain_model.Driver, error) {
+	args := m.Called(raceId)
+	return args.Get(0).([]domain_model.Driver), args.Error(1)
+}

internal/controller/Ping.go

@@ -0,0 +1,9 @@
+package domain_model
+
+type Driver struct {
+	Number   int    `json:"driver_number"`
+	FullName string `json:"full_name"`
+	Country  string `json:"country_code"`
+	Avatar   string `json:"avatar"`
+	TeamName string `json:"team_name"`
+}

internal/domain/model/Driver.go

@@ -0,0 +1,6 @@
+package domain_model
+
+type Podium struct {
+	Driver
+	Position int `json:"position"`
+}

internal/domain/model/Podium.go

@@ -0,0 +1,11 @@
+package domain_model
+
+import "time"
+
+type Race struct {
+	Id          int       `json:"id"`
+	Year        int       `json:"year"`
+	StartDate   time.Time `json:"date_start"`
+	CountryName string    `json:"country_name"`
+	CircuitName string    `json:"circuit_name"`
+}

internal/domain/model/Race.go

@@ -0,0 +1,25 @@
+package domain_service
+
+import (
+	domain_model "github.com/mmadariaga/go-api/internal/domain/model"
+)
+
+type GetDriversByRaceDependencies interface {
+	FetchDriversByRace(raceId int) ([]domain_model.Driver, error)
+}
+
+func GetDriversByRace(races []domain_model.Race, dependencies GetDriversByRaceDependencies) (map[int][]domain_model.Driver, error) {
+
+	driversByRace := make(map[int][]domain_model.Driver)
+
+	for _, race := range races {
+		result, error := dependencies.FetchDriversByRace(race.Id)
+		if error != nil {
+			return nil, error
+		}
+
+		driversByRace[race.Id] = result
+	}
+
+	return driversByRace, nil
+}

internal/domain/service/GetDriversByRace.go

@@ -0,0 +1,34 @@
+package domain_service
+
+import (
+	domain_model "github.com/mmadariaga/go-api/internal/domain/model"
+)
+
+type GetPodiumByRaceDependencies interface {
+	GetDriversByRaceDependencies
+	FetchPodiumByRace(raceId int, drivers []domain_model.Driver) ([3]domain_model.Podium, error)
+}
+
+func GetPodiumByRace(
+	races []domain_model.Race,
+	dependencies GetPodiumByRaceDependencies,
+) (map[int][3]domain_model.Podium, error) {
+
+	podiumsByRace := make(map[int][3]domain_model.Podium)
+
+	drivers, error := GetDriversByRace(races, dependencies)
+	if error != nil {
+		return nil, error
+	}
+
+	for _, race := range races {
+		result, error := dependencies.FetchPodiumByRace(race.Id, drivers[race.Id])
+		if error != nil {
+			return nil, error
+		}
+
+		podiumsByRace[race.Id] = result
+	}
+
+	return podiumsByRace, nil
+}

internal/domain/service/GetPodiumByRace.go

@@ -0,0 +1,12 @@
+package infrastructure_controller
+
+import (
+	"net/http"
+
+	application_pong "github.com/mmadariaga/go-api/internal/application/pong"
+)
+
+func Ping(w http.ResponseWriter, r *http.Request) {
+	resp := application_pong.Pong()
+	w.Write([]byte(resp))
+}

internal/infrastructure/controller/Ping.go

@@ -0,0 +1,24 @@
+package infrastructure_controller
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/mmadariaga/go-api/internal/test"
+)
+
+func TestPing(t *testing.T) {
+
+	mockWriter := new(test.MockResponseWriter)
+	mockWriter.On(
+		"Write",
+		[]byte("pong"),
+	).Return(
+		len("pong"),
+		nil,
+	)
+
+	Ping(mockWriter, new(http.Request))
+
+	mockWriter.AssertExpectations(t)
+}

internal/infrastructure/controller/Ping_test.go

@@ -0,0 +1,43 @@
+package infrastructure_controller
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/rs/zerolog/log"
+
+	application_races "github.com/mmadariaga/go-api/internal/application/races"
+	domain_model "github.com/mmadariaga/go-api/internal/domain/model"
+	infrastructure_service "github.com/mmadariaga/go-api/internal/infrastructure/service"
+)
+
+func Races(w http.ResponseWriter, r *http.Request) {
+
+	races, error := application_races.GetRacesByYear(
+		2024,
+		&infraDependencies{},
+	)
+	if error != nil {
+		log.Panic().Msg(error.Error())
+	}
+
+	racesJson, error := json.Marshal(races)
+	if error != nil {
+		log.Panic().Msg(error.Error())
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(racesJson)
+}
+
+type infraDependencies struct{}
+
+func (d *infraDependencies) FetchRacesByYear(year int) ([]domain_model.Race, error) {
+	return infrastructure_service.FetchRacesByYear(year)
+}
+func (d *infraDependencies) FetchPodiumByRace(raceId int, drivers []domain_model.Driver) ([3]domain_model.Podium, error) {
+	return infrastructure_service.FetchPodiumByRace(raceId, drivers)
+}
+func (d *infraDependencies) FetchDriversByRace(raceId int) ([]domain_model.Driver, error) {
+	return infrastructure_service.FetchDriversByRace(raceId)
+}