479 lines
12 KiB
Go
479 lines
12 KiB
Go
package controller
|
|
|
|
import (
|
|
"acc-server-manager/local/model"
|
|
"acc-server-manager/tests"
|
|
"bytes"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
func TestController_JSONParsing_Success(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test basic JSON parsing functionality
|
|
app := fiber.New()
|
|
|
|
app.Post("/test", func(c *fiber.Ctx) error {
|
|
var data map[string]interface{}
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return c.Status(400).JSON(fiber.Map{"error": "Invalid JSON"})
|
|
}
|
|
return c.JSON(data)
|
|
})
|
|
|
|
// Prepare test data
|
|
testData := map[string]interface{}{
|
|
"name": "test",
|
|
"value": 123,
|
|
}
|
|
bodyBytes, err := json.Marshal(testData)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Create request
|
|
req := httptest.NewRequest("POST", "/test", bytes.NewReader(bodyBytes))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
// Execute request
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
|
|
// Parse response
|
|
var response map[string]interface{}
|
|
body, err := io.ReadAll(resp.Body)
|
|
tests.AssertNoError(t, err)
|
|
err = json.Unmarshal(body, &response)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Verify response
|
|
tests.AssertEqual(t, "test", response["name"])
|
|
tests.AssertEqual(t, float64(123), response["value"]) // JSON numbers are float64
|
|
}
|
|
|
|
func TestController_JSONParsing_InvalidJSON(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test handling of invalid JSON
|
|
app := fiber.New()
|
|
|
|
app.Post("/test", func(c *fiber.Ctx) error {
|
|
var data map[string]interface{}
|
|
if err := c.BodyParser(&data); err != nil {
|
|
return c.Status(400).JSON(fiber.Map{"error": "Invalid JSON"})
|
|
}
|
|
return c.JSON(data)
|
|
})
|
|
|
|
// Create request with invalid JSON
|
|
req := httptest.NewRequest("POST", "/test", bytes.NewReader([]byte("invalid json")))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
// Execute request
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 400, resp.StatusCode)
|
|
|
|
// Parse error response
|
|
var response map[string]interface{}
|
|
body, err := io.ReadAll(resp.Body)
|
|
tests.AssertNoError(t, err)
|
|
err = json.Unmarshal(body, &response)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Verify error response
|
|
tests.AssertEqual(t, "Invalid JSON", response["error"])
|
|
}
|
|
|
|
func TestController_UUIDValidation_Success(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test UUID parameter validation
|
|
app := fiber.New()
|
|
|
|
app.Get("/test/:id", func(c *fiber.Ctx) error {
|
|
id := c.Params("id")
|
|
|
|
// Validate UUID
|
|
if _, err := uuid.Parse(id); err != nil {
|
|
return c.Status(400).JSON(fiber.Map{"error": "Invalid UUID"})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{"id": id, "valid": true})
|
|
})
|
|
|
|
// Create request with valid UUID
|
|
validUUID := uuid.New().String()
|
|
req := httptest.NewRequest("GET", "/test/"+validUUID, nil)
|
|
|
|
// Execute request
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
|
|
// Parse response
|
|
var response map[string]interface{}
|
|
body, err := io.ReadAll(resp.Body)
|
|
tests.AssertNoError(t, err)
|
|
err = json.Unmarshal(body, &response)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Verify response
|
|
tests.AssertEqual(t, validUUID, response["id"])
|
|
tests.AssertEqual(t, true, response["valid"])
|
|
}
|
|
|
|
func TestController_UUIDValidation_InvalidUUID(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test handling of invalid UUID
|
|
app := fiber.New()
|
|
|
|
app.Get("/test/:id", func(c *fiber.Ctx) error {
|
|
id := c.Params("id")
|
|
|
|
// Validate UUID
|
|
if _, err := uuid.Parse(id); err != nil {
|
|
return c.Status(400).JSON(fiber.Map{"error": "Invalid UUID"})
|
|
}
|
|
|
|
return c.JSON(fiber.Map{"id": id, "valid": true})
|
|
})
|
|
|
|
// Create request with invalid UUID
|
|
req := httptest.NewRequest("GET", "/test/invalid-uuid", nil)
|
|
|
|
// Execute request
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 400, resp.StatusCode)
|
|
|
|
// Parse error response
|
|
var response map[string]interface{}
|
|
body, err := io.ReadAll(resp.Body)
|
|
tests.AssertNoError(t, err)
|
|
err = json.Unmarshal(body, &response)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Verify error response
|
|
tests.AssertEqual(t, "Invalid UUID", response["error"])
|
|
}
|
|
|
|
func TestController_QueryParameters_Success(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test query parameter handling
|
|
app := fiber.New()
|
|
|
|
app.Get("/test", func(c *fiber.Ctx) error {
|
|
restart := c.QueryBool("restart", false)
|
|
override := c.QueryBool("override", false)
|
|
format := c.Query("format", "json")
|
|
|
|
return c.JSON(fiber.Map{
|
|
"restart": restart,
|
|
"override": override,
|
|
"format": format,
|
|
})
|
|
})
|
|
|
|
// Create request with query parameters
|
|
req := httptest.NewRequest("GET", "/test?restart=true&override=false&format=xml", nil)
|
|
|
|
// Execute request
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
|
|
// Parse response
|
|
var response map[string]interface{}
|
|
body, err := io.ReadAll(resp.Body)
|
|
tests.AssertNoError(t, err)
|
|
err = json.Unmarshal(body, &response)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Verify response
|
|
tests.AssertEqual(t, true, response["restart"])
|
|
tests.AssertEqual(t, false, response["override"])
|
|
tests.AssertEqual(t, "xml", response["format"])
|
|
}
|
|
|
|
func TestController_HTTPMethods_Success(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test different HTTP methods
|
|
app := fiber.New()
|
|
|
|
var getCalled, postCalled, putCalled, deleteCalled bool
|
|
|
|
app.Get("/test", func(c *fiber.Ctx) error {
|
|
getCalled = true
|
|
return c.JSON(fiber.Map{"method": "GET"})
|
|
})
|
|
|
|
app.Post("/test", func(c *fiber.Ctx) error {
|
|
postCalled = true
|
|
return c.JSON(fiber.Map{"method": "POST"})
|
|
})
|
|
|
|
app.Put("/test", func(c *fiber.Ctx) error {
|
|
putCalled = true
|
|
return c.JSON(fiber.Map{"method": "PUT"})
|
|
})
|
|
|
|
app.Delete("/test", func(c *fiber.Ctx) error {
|
|
deleteCalled = true
|
|
return c.JSON(fiber.Map{"method": "DELETE"})
|
|
})
|
|
|
|
// Test GET
|
|
req := httptest.NewRequest("GET", "/test", nil)
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
tests.AssertEqual(t, true, getCalled)
|
|
|
|
// Test POST
|
|
req = httptest.NewRequest("POST", "/test", nil)
|
|
resp, err = app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
tests.AssertEqual(t, true, postCalled)
|
|
|
|
// Test PUT
|
|
req = httptest.NewRequest("PUT", "/test", nil)
|
|
resp, err = app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
tests.AssertEqual(t, true, putCalled)
|
|
|
|
// Test DELETE
|
|
req = httptest.NewRequest("DELETE", "/test", nil)
|
|
resp, err = app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
tests.AssertEqual(t, true, deleteCalled)
|
|
}
|
|
|
|
func TestController_ErrorHandling_StatusCodes(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test different error status codes
|
|
app := fiber.New()
|
|
|
|
app.Get("/400", func(c *fiber.Ctx) error {
|
|
return c.Status(400).JSON(fiber.Map{"error": "Bad Request"})
|
|
})
|
|
|
|
app.Get("/401", func(c *fiber.Ctx) error {
|
|
return c.Status(401).JSON(fiber.Map{"error": "Unauthorized"})
|
|
})
|
|
|
|
app.Get("/403", func(c *fiber.Ctx) error {
|
|
return c.Status(403).JSON(fiber.Map{"error": "Forbidden"})
|
|
})
|
|
|
|
app.Get("/404", func(c *fiber.Ctx) error {
|
|
return c.Status(404).JSON(fiber.Map{"error": "Not Found"})
|
|
})
|
|
|
|
app.Get("/500", func(c *fiber.Ctx) error {
|
|
return c.Status(500).JSON(fiber.Map{"error": "Internal Server Error"})
|
|
})
|
|
|
|
// Test different status codes
|
|
testCases := []struct {
|
|
path string
|
|
code int
|
|
}{
|
|
{"/400", 400},
|
|
{"/401", 401},
|
|
{"/403", 403},
|
|
{"/404", 404},
|
|
{"/500", 500},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
req := httptest.NewRequest("GET", tc.path, nil)
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, tc.code, resp.StatusCode)
|
|
}
|
|
}
|
|
|
|
func TestController_ConfigurationModel_JSONSerialization(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test Configuration model JSON serialization
|
|
app := fiber.New()
|
|
|
|
app.Get("/config", func(c *fiber.Ctx) error {
|
|
config := &model.Configuration{
|
|
UdpPort: model.IntString(9231),
|
|
TcpPort: model.IntString(9232),
|
|
MaxConnections: model.IntString(30),
|
|
LanDiscovery: model.IntString(1),
|
|
RegisterToLobby: model.IntString(1),
|
|
ConfigVersion: model.IntString(1),
|
|
}
|
|
return c.JSON(config)
|
|
})
|
|
|
|
// Create request
|
|
req := httptest.NewRequest("GET", "/config", nil)
|
|
|
|
// Execute request
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
|
|
// Parse response
|
|
var response model.Configuration
|
|
body, err := io.ReadAll(resp.Body)
|
|
tests.AssertNoError(t, err)
|
|
err = json.Unmarshal(body, &response)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Verify response
|
|
tests.AssertEqual(t, model.IntString(9231), response.UdpPort)
|
|
tests.AssertEqual(t, model.IntString(9232), response.TcpPort)
|
|
tests.AssertEqual(t, model.IntString(30), response.MaxConnections)
|
|
tests.AssertEqual(t, model.IntString(1), response.LanDiscovery)
|
|
tests.AssertEqual(t, model.IntString(1), response.RegisterToLobby)
|
|
tests.AssertEqual(t, model.IntString(1), response.ConfigVersion)
|
|
}
|
|
|
|
func TestController_UserModel_JSONSerialization(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test User model JSON serialization (password should be hidden)
|
|
app := fiber.New()
|
|
|
|
app.Get("/user", func(c *fiber.Ctx) error {
|
|
user := &model.User{
|
|
ID: uuid.New(),
|
|
Username: "testuser",
|
|
Password: "secret-password", // Should not appear in JSON
|
|
RoleID: uuid.New(),
|
|
}
|
|
return c.JSON(user)
|
|
})
|
|
|
|
// Create request
|
|
req := httptest.NewRequest("GET", "/user", nil)
|
|
|
|
// Execute request
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
|
|
// Parse response as raw JSON to check password is excluded
|
|
body, err := io.ReadAll(resp.Body)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Verify password field is not in JSON
|
|
if bytes.Contains(body, []byte("password")) || bytes.Contains(body, []byte("secret-password")) {
|
|
t.Fatal("Password should not be included in JSON response")
|
|
}
|
|
|
|
// Verify other fields are present
|
|
if !bytes.Contains(body, []byte("username")) || !bytes.Contains(body, []byte("testuser")) {
|
|
t.Fatal("Username should be included in JSON response")
|
|
}
|
|
}
|
|
|
|
func TestController_MiddlewareChaining_Success(t *testing.T) {
|
|
// Setup environment and test helper
|
|
tests.SetTestEnv()
|
|
helper := tests.NewTestHelper(t)
|
|
defer helper.Cleanup()
|
|
|
|
// Test middleware chaining
|
|
app := fiber.New()
|
|
|
|
var middleware1Called, middleware2Called, handlerCalled bool
|
|
|
|
// Middleware 1
|
|
middleware1 := func(c *fiber.Ctx) error {
|
|
middleware1Called = true
|
|
c.Locals("middleware1", "executed")
|
|
return c.Next()
|
|
}
|
|
|
|
// Middleware 2
|
|
middleware2 := func(c *fiber.Ctx) error {
|
|
middleware2Called = true
|
|
c.Locals("middleware2", "executed")
|
|
return c.Next()
|
|
}
|
|
|
|
// Handler
|
|
handler := func(c *fiber.Ctx) error {
|
|
handlerCalled = true
|
|
return c.JSON(fiber.Map{
|
|
"middleware1": c.Locals("middleware1"),
|
|
"middleware2": c.Locals("middleware2"),
|
|
"handler": "executed",
|
|
})
|
|
}
|
|
|
|
app.Get("/test", middleware1, middleware2, handler)
|
|
|
|
// Create request
|
|
req := httptest.NewRequest("GET", "/test", nil)
|
|
|
|
// Execute request
|
|
resp, err := app.Test(req)
|
|
tests.AssertNoError(t, err)
|
|
tests.AssertEqual(t, 200, resp.StatusCode)
|
|
|
|
// Verify all were called
|
|
tests.AssertEqual(t, true, middleware1Called)
|
|
tests.AssertEqual(t, true, middleware2Called)
|
|
tests.AssertEqual(t, true, handlerCalled)
|
|
|
|
// Parse response
|
|
var response map[string]interface{}
|
|
body, err := io.ReadAll(resp.Body)
|
|
tests.AssertNoError(t, err)
|
|
err = json.Unmarshal(body, &response)
|
|
tests.AssertNoError(t, err)
|
|
|
|
// Verify middleware values were passed
|
|
tests.AssertEqual(t, "executed", response["middleware1"])
|
|
tests.AssertEqual(t, "executed", response["middleware2"])
|
|
tests.AssertEqual(t, "executed", response["handler"])
|
|
}
|