update tests

Database/server.go

@@ -38,14 +38,14 @@ func GetServersList(db *sql.DB) ([]Server, error) {
 	return servers, err
 }
 
-func GetServersbyID(db *sql.DB, id int64) Server {
+func GetServersbyID(db *sql.DB, id int64) (Server, error) {
 	var s Server
 	rows := db.QueryRow("SELECT * FROM dashboard_server WHERE id = ?", id)
 	err := rows.Scan(&s.ID, &s.Hostname, &s.OsId)
 	if err != nil {
-		return Server{}
+		return Server{}, nil
 	}
-	return s
+	return s, err
 }
 
 func GetServersbyOS(db *sql.DB, id int64) ([]Server, error) {

Http/server.go

@@ -52,14 +52,23 @@ func GetServersbyID(w http.ResponseWriter, r *http.Request) {
 	}
 	dbConn := db.GetDatabaseConnection()
 	defer dbConn.Close()
-	server = db.GetServersbyID(dbConn, int64(id))
+	server, err = db.GetServersbyID(dbConn, int64(id))
-	logRequest(t, r, status)
+	if err != nil {
+		log.Println("Error getting Server by ID", err)
+		status = 500
+	}
+	if status != 500 {
 		w.Header().Set("Content-Type", "application/json")
 		err = json.NewEncoder(w).Encode(server)
 		if err != nil {
 			log.Println("Error getting OS list")
+			w.WriteHeader(http.StatusInternalServerError)
+			logRequest(t, r, status)
 			return
 		}
+	}
+	w.WriteHeader(status)
+	logRequest(t, r, status)
 }
 
 func GetServersbyOS(w http.ResponseWriter, r *http.Request) {
@@ -74,9 +83,6 @@ func GetServersbyOS(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Println("Error converting ID", err)
 		status = 500
-		logRequest(t, r, status)
-		w.WriteHeader(status)
-		return
 	}
 	dbConn := db.GetDatabaseConnection()
 	defer dbConn.Close()
@@ -84,20 +90,21 @@ func GetServersbyOS(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Println("Error getting servers by OS", err)
 		status = 500
-		logRequest(t, r, status)
-		w.WriteHeader(status)
-		return
 	}
-	logRequest(t, r, status)
+	if status != 500 {
 		w.Header().Set("Content-Type", "application/json")
 		err = json.NewEncoder(w).Encode(servers)
 		if err != nil {
-		log.Println("Error getting OS list")
+			log.Println("Error encoding OS list")
-		status = 500
+			w.Header().Del("Content-Type")
+			logRequest(t, r, status)
+			w.WriteHeader(http.StatusInternalServerError)
+			return
+		}
+	}
 	logRequest(t, r, status)
 	w.WriteHeader(status)
 	return
-	}
 }
 
 func CreateServer(w http.ResponseWriter, r *http.Request) {
@@ -110,14 +117,16 @@ func CreateServer(w http.ResponseWriter, r *http.Request) {
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		log.Println(err.Error(), "Error reading request body")
+		status = 500
 	}
 
 	params := make(map[string]null.String)
 	err = json.Unmarshal(body, &params)
 	if err != nil {
 		log.Println(err.Error(), "Error parsing request body")
-		return
+		status = 500
 	}
+	if status != 500 {
 		server.Hostname = params["hostname"]
 		server.OsId = params["os_id"]
 		dbConn := db.GetDatabaseConnection()
@@ -127,6 +136,7 @@ func CreateServer(w http.ResponseWriter, r *http.Request) {
 			log.Println(err.Error(), "Error creating server")
 			status = 500
 		}
+	}
 	logRequest(t, r, status)
 	w.WriteHeader(status)
 }

Http/server_test.go

@@ -88,61 +88,71 @@ func TestGetServerList(t *testing.T) {
 }
 
 func TestGetServerbyID(t *testing.T) {
-	// Créer une connexion à la base de données simulée
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
-	dbConn, mock, err := sqlmock.New()
 	if err != nil {
 		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
 	}
-	defer dbConn.Close()
+	defer mockDB.Close()
-
-	// Simuler la réponse de la base de données
-	mockServer := db.Server{
-		ID: 1, Hostname: null.StringFrom("testsla"), OsId: null.StringFrom("8"),
-	}
-
-	rows := sqlmock.NewRows([]string{"id", "hostname", "os_id"}).
-		AddRow(1, "testsla", "8")
-
-	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM dashboard_server WHERE id = ?")).WithArgs(sqlmock.AnyArg()).WillReturnRows(rows)
-
-	// Remplacer la fonction GetDatabaseConnection par une version mockée
-	originalGetDatabaseConnection := db.GetDatabaseConnection
 	db.GetDatabaseConnection = func() *sql.DB {
-		return dbConn
+		return mockDB
 	}
-	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()
 
-	// Créer une requête HTTP
+	mockServer := []db.Server{
-	req, err := http.NewRequest("GET", "/server/1", nil)
+		{ID: 1, Hostname: null.StringFrom("testsla"), OsId: null.StringFrom("8")},
+	}
+
+	tests := []struct {
+		name                string
+		requestParam        string
+		mockBehavior        func()
+		expectedStatus      int
+		expectedContentType string
+	}{
+		{
+			name:         "Successfully get Server by OS ID",
+			requestParam: "1",
+			mockBehavior: func() {
+				rows := sqlmock.NewRows([]string{"id", "hostname", "os_id"}).AddRow(1, "testsla", "8")
+				mock.ExpectQuery("SELECT * FROM dashboard_server WHERE id = ?").WithArgs(sqlmock.AnyArg()).WillReturnRows(rows)
+			},
+			expectedStatus:      http.StatusOK,
+			expectedContentType: "application/json",
+		},
+		{
+			name:                "Error getting Server by ID",
+			requestParam:        "test",
+			mockBehavior:        func() {},
+			expectedStatus:      http.StatusInternalServerError,
+			expectedContentType: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.mockBehavior()
+
+			req, err := http.NewRequest("GET", "/server/", nil)
 			if err != nil {
 				t.Fatal(err)
 			}
+			req = mux.SetURLVars(req, map[string]string{"id": tt.requestParam})
 
-	// Ajouter les paramètres de la route
-	req = mux.SetURLVars(req, map[string]string{"id": "1"})
-
-	// Créer un ResponseRecorder pour enregistrer la réponse
 			rr := httptest.NewRecorder()
 			handler := http.HandlerFunc(GetServersbyID)
-
-	// Appeler la fonction GetServer
 			handler.ServeHTTP(rr, req)
 
-	// Vérifier le statut de la réponse
+			if status := rr.Code; status != tt.expectedStatus {
-	if status := rr.Code; status != http.StatusOK {
 				t.Errorf("handler returned wrong status code: got %v want %v",
-			status, http.StatusOK)
+					status, tt.expectedStatus)
 			}
 
-	// Vérifier le type de contenu de la réponse
+			if ct := rr.Header().Get("Content-Type"); ct != tt.expectedContentType {
-	expectedContentType := "application/json"
-	if ct := rr.Header().Get("Content-Type"); ct != expectedContentType {
 				t.Errorf("handler returned wrong content type: got %v want %v",
-			ct, expectedContentType)
+					ct, tt.expectedContentType)
 			}
 
-	// Vérifier le corps de la réponse
+			var responseServer []db.Server
-	var responseServer db.Server
+			if len(responseServer) > 0 {
 				err = json.NewDecoder(rr.Body).Decode(&responseServer)
 				if err != nil {
 					t.Fatal("Error decoding json request", err)
@@ -153,10 +163,12 @@ func TestGetServerbyID(t *testing.T) {
 						responseServer, mockServer)
 				}
 
-	// Vérifier que toutes les attentes ont été satisfaites
+			}
 			if err := mock.ExpectationsWereMet(); err != nil {
 				t.Errorf("there were unfulfilled expectations: %s", err)
 			}
+		})
+	}
 }
 
 func TestGetServerbyOS(t *testing.T) {