Controller用のテストutilを作成

backend/controllers/friends_controller.go

@@ -0,0 +1,29 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+// FriendsController is a struct to define the friends controller
+type FriendsController struct {
+}
+
+// NewFriendsController is a function to create a new friends controller
+func NewFriendsController() *FriendsController {
+	return &FriendsController{}
+}
+
+// GetFriendsResponse is a struct to define the get friends response
+type GetFriendsResponse struct {
+	Message string `json:"message"`
+}
+
+// GetFriends is a function to handle the get friends request
+func (controller *FriendsController) GetFriends(c *gin.Context) {
+
+	var response GetFriendsResponse
+	response.Message = "Get friends successful"
+	c.JSON(http.StatusOK, response)
+}

backend/controllers/login_controller.go

@@ -0,0 +1,39 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+// LoginController is a struct to define the login controller
+type LoginController struct {
+}
+
+// NewLoginController is a function to create a new login controller
+func NewLoginController() *LoginController {
+	return &LoginController{}
+}
+
+// LoginRequest is a struct to define the login request
+type LoginRequest struct {
+	Message string `json:"message" binding:"required"`
+}
+
+// LoginResponse is a struct to define the login response
+type LoginResponse struct {
+	Message string `json:"message"`
+}
+
+// Login is a function to handle the login request
+func (controller *LoginController) Login(c *gin.Context) {
+	var request LoginRequest
+	if err := c.ShouldBindJSON(&request); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
+	var response LoginResponse
+	response.Message = "Login successful"
+	c.JSON(http.StatusOK, response)
+}

backend/controllers/login_controller_test.go

@@ -0,0 +1,61 @@
+package controllers_test
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+
+	"gomoku/controllers"
+	"gomoku/utils/testutils"
+)
+
+func TestLoginController_Login(t *testing.T) {
+
+	tests := []testutils.ControllerTestCase{
+		{
+			Name: "Test case 1: Success",
+			Request: testutils.HTTPRequest{
+				Body: map[string]interface{}{
+					"message": "Hello",
+				},
+			},
+			Response: testutils.HTTPResponse{
+				Code: http.StatusOK,
+				Body: map[string]interface{}{
+					"message": "Login successful",
+				},
+			},
+		},
+		{
+			Name: "Test case 2: Failed with empty",
+			Request: testutils.HTTPRequest{
+				Body: map[string]interface{}{},
+			},
+			Response: testutils.HTTPResponse{
+				Code: http.StatusBadRequest,
+				Body: map[string]interface{}{
+					"error": "Key: 'LoginRequest.Message' Error:Field validation for 'Message' failed on the 'required' tag",
+				},
+			},
+		},
+		{
+			Name: "Test case 3: Failed with number",
+			Request: testutils.HTTPRequest{
+				Body: map[string]interface{}{
+					"message": 123,
+				},
+			},
+			Response: testutils.HTTPResponse{
+				Code: http.StatusBadRequest,
+				Body: map[string]interface{}{
+					"error": "json: cannot unmarshal number into Go struct field LoginRequest.message of type string",
+				},
+			},
+		},
+	}
+
+	testutils.RunControllerTest(t, tests, func() gin.HandlerFunc {
+		return controllers.NewLoginController().Login
+	})
+}

backend/go.mod

@@ -1,4 +1,4 @@
-module sample
+module gomoku
 
 go 1.22.6
 

backend/main.go

@@ -1,18 +1,10 @@
 package main
 
 import (
-	"net/http"
-	"github.com/gin-gonic/gin"
-	_ "github.com/lib/pq"	
+	"gomoku/routes"
 )
 
 func main() {
-	r := gin.Default()
-
-	r.GET("/", func(c *gin.Context) {
-		c.JSON(http.StatusOK, gin.H{
-			"message": "Hello World",
-		})
-	})
-	r.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
+	router := routes.GetRouter()
+	router.Run(":8080")
 }

backend/models/database/database.go

@@ -0,0 +1,10 @@
+package database
+
+import (
+	"gorm.io/gorm"
+)
+
+// Database struct
+type Database struct {
+	*gorm.DB
+}

backend/models/friend.go

@@ -0,0 +1,10 @@
+package models
+
+import (
+	"gorm.io/gorm"
+)
+
+// Friend struct
+type Friend struct {
+	gorm.Model
+}

backend/models/user.go

@@ -0,0 +1,10 @@
+package models
+
+import (
+	"gorm.io/gorm"
+)
+
+// User struct
+type User struct {
+	gorm.Model
+}

backend/routes/router.go

@@ -0,0 +1,28 @@
+package routes
+
+import (
+	"github.com/gin-gonic/gin"
+
+	"gomoku/controllers"
+)
+
+func GetRouter() *gin.Engine {
+	router := gin.Default()
+
+	api := router.Group("/api/v1")
+	{
+		users := api.Group("/users")
+		{
+			loginController := controllers.NewLoginController()
+			users.POST("/login", loginController.Login)
+		}
+
+		friends := api.Group("/friends")
+		{
+			friendsController := controllers.NewFriendsController()
+			friends.GET("/", friendsController.GetFriends)
+		}
+	}
+
+	return router
+}

backend/utils/testutils/controller_testutil.go

@@ -0,0 +1,136 @@
+package testutils
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+)
+
+// ControllerTestCase represents a test case for a controller.
+type ControllerTestCase struct {
+	Name     string       // Name is the name of the test case.
+	Request  HTTPRequest  // Request is the HTTP request to be tested.
+	Response HTTPResponse // Response is the expected HTTP response.
+}
+
+// RunControllerTest is a helper function for testing controller functions in a Gin framework.
+// It runs a series of test cases and compares the expected response with the actual response.
+// The function takes the following parameters:
+// - t: The testing.T object for reporting test failures.
+// - tests: A slice of ControllerTestCase structs representing the test cases to run.
+// - targetControllerHandler: A function that returns the controller handler function to be tested.
+//
+// Each test case in the tests slice should have the following fields:
+// - Name: The name of the test case.
+// - Request: A struct representing the HTTP request to be made.
+//   - Method: The HTTP method of the request (e.g., "GET", "POST", etc.).
+//   - Url: The URL of the request.
+//   - Body: The request body as a JSON object.
+//   - Query: A map of query parameters to be added to the URL.
+//
+// - Response: A struct representing the expected HTTP response.
+//   - Code: The expected HTTP status code.
+//   - Body: The expected response body as a JSON object.
+//
+// Example usage:
+//
+//	tests := []ControllerTestCase{
+//		{
+//			Name: "Test case 1",
+//			Request: HTTPRequest{
+//				Method: http.MethodGet,
+//				Url:    "/api/v1/test",
+//				Body:   nil,
+//			},
+//			Response: HTTPResponse{
+//				Code: http.StatusOK,
+//				Body: map[string]interface{}{
+//					"message": "success",
+//				},
+//			},
+//		},
+//		// Add more test cases here...
+//	}
+//	RunControllerTest(t, tests, func() gin.HandlerFunc {
+//		return NewTestController().TestFunction
+//	})
+func RunControllerTest(t *testing.T, tests []ControllerTestCase, targetController func() gin.HandlerFunc) {
+
+	// Helper function to marshal the body as a JSON string.
+	marshalBody := func(body interface{}) string {
+		if body == nil {
+			return ""
+		}
+		jsonBody, err := json.Marshal(body)
+		if err != nil {
+			t.Errorf("failed to marshal body: %v", err)
+			return ""
+		}
+		return string(jsonBody)
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.Name, func(t *testing.T) {
+			// Create a new Gin context for each test case.
+			response := httptest.NewRecorder()
+			c, _ := gin.CreateTestContext(response)
+
+			// Set the request method, URL, and body.
+			requestBody, err := json.Marshal(tt.Request.Body)
+			if err != nil {
+				t.Errorf("failed to marshal request body: %v", err)
+			}
+
+			// Parse the request URL and add query parameters.
+			requestUrl, err := url.Parse(tt.Request.Url)
+			if err != nil {
+				t.Errorf("failed to parse url: %v", err)
+			}
+
+			parsedRequestQuery := requestUrl.Query()
+			for key, value := range tt.Request.Query {
+				parsedRequestQuery.Set(key, value)
+			}
+			requestUrl.RawQuery = parsedRequestQuery.Encode()
+
+			// Create the request object.
+			c.Request, err = http.NewRequest(
+				tt.Request.Method,
+				requestUrl.String(),
+				strings.NewReader(string(requestBody)),
+			)
+			if err != nil {
+				t.Errorf("failed to create request: %v", err)
+			}
+			c.Request.Header.Set("Content-Type", "application/json")
+
+			// Call the target controller function.
+			targetController()(c)
+
+			// Check the response status code and body.
+			if response.Code != tt.Response.Code {
+				t.Errorf("got = %v, want %v", response.Code, tt.Response.Code)
+			} else {
+				// Unmarshal the response body.
+				var body interface{}
+				if err := json.Unmarshal(response.Body.Bytes(), &body); err != nil {
+					t.Errorf("failed to unmarshal response body: %v", err)
+				}
+
+				// Marshal actual and expected body
+				actualBody := marshalBody(body)
+				expectedBody := marshalBody(tt.Response.Body)
+
+				// compare body as string
+				if actualBody != expectedBody {
+					t.Errorf("got = %v, want %v", actualBody, expectedBody)
+				}
+			}
+		})
+	}
+}

backend/utils/testutils/http_struct.go

@@ -0,0 +1,15 @@
+package testutils
+
+// HTTPRequest represents an HTTP request.
+type HTTPRequest struct {
+	Method string
+	Url    string
+	Body   interface{}
+	Query  map[string]string
+}
+
+// HTTPResponse represents an HTTP response.
+type HTTPResponse struct {
+	Code int
+	Body interface{}
+}