add step list for server creation

tests/unit/controller/controller_simple_test.go

@@ -14,12 +14,10 @@ import (
 )
 
 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 {
@@ -30,7 +28,6 @@ func TestController_JSONParsing_Success(t *testing.T) {
 		return c.JSON(data)
 	})
 
-	// Prepare test data
 	testData := map[string]interface{}{
 		"name":  "test",
 		"value": 123,
@@ -38,34 +35,28 @@ func TestController_JSONParsing_Success(t *testing.T) {
 	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
+	tests.AssertEqual(t, float64(123), response["value"])
 }
 
 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 {
@@ -76,39 +67,31 @@ func TestController_JSONParsing_InvalidJSON(t *testing.T) {
 		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"})
 		}
@@ -116,40 +99,33 @@ func TestController_UUIDValidation_Success(t *testing.T) {
 		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"})
 		}
@@ -157,32 +133,26 @@ func TestController_UUIDValidation_InvalidUUID(t *testing.T) {
 		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 {
@@ -197,34 +167,28 @@ func TestController_QueryParameters_Success(t *testing.T) {
 		})
 	})
 
-	// 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
@@ -249,28 +213,24 @@ func TestController_HTTPMethods_Success(t *testing.T) {
 		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)
@@ -279,12 +239,10 @@ func TestController_HTTPMethods_Success(t *testing.T) {
 }
 
 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 {
@@ -307,7 +265,6 @@ func TestController_ErrorHandling_StatusCodes(t *testing.T) {
 		return c.Status(500).JSON(fiber.Map{"error": "Internal Server Error"})
 	})
 
-	// Test different status codes
 	testCases := []struct {
 		path string
 		code int
@@ -328,12 +285,10 @@ func TestController_ErrorHandling_StatusCodes(t *testing.T) {
 }
 
 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 {
@@ -348,22 +303,18 @@ func TestController_ConfigurationModel_JSONSerialization(t *testing.T) {
 		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)
@@ -373,73 +324,61 @@ func TestController_ConfigurationModel_JSONSerialization(t *testing.T) {
 }
 
 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
+			Password: "secret-password",
 			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{
@@ -451,27 +390,22 @@ func TestController_MiddlewareChaining_Success(t *testing.T) {
 
 	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"])