update tests

Http/os.go

@@ -0,0 +1,174 @@
+package http
+
+import (
+	"encoding/json"
+	db "infra-dashboard/Database"
+	"io"
+	"log"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gorilla/mux"
+	"gopkg.in/guregu/null.v4"
+)
+
+func GetOS(w http.ResponseWriter, r *http.Request) {
+	var list []db.OS
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	list, err = db.GetOS(dbConn)
+	if err != nil {
+		log.Println("Error getting OS list")
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(list)
+	if err != nil {
+		log.Println("Error encoding OS list")
+		return
+	}
+}
+
+func GetOSbyID(w http.ResponseWriter, r *http.Request) {
+	var os db.OS
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	params := mux.Vars(r)
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	id, err := strconv.ParseInt(params["id"], 10, 64)
+	if err != nil {
+		log.Println("Error converting ID", err)
+		status = 500
+	}
+	os, err = db.GetOSbyID(dbConn, int64(id))
+	if err != nil {
+		log.Println("Error getting OS")
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(os)
+	if err != nil {
+		log.Println("Error getting OS by ID")
+		return
+	}
+}
+
+func GetDistributionList(w http.ResponseWriter, r *http.Request) {
+	var list []null.String
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	list, err = db.GetDistributionList(dbConn)
+	if err != nil {
+		log.Println("Error getting distribution list")
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(list)
+	if err != nil {
+		log.Println("Error getting distribution list")
+		return
+	}
+}
+
+func GetVersionsByDistributionList(w http.ResponseWriter, r *http.Request) {
+	var list []null.String
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	params := mux.Vars(r)
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	list, err = db.GetVersionsByDistributionList(dbConn, params["distribution"])
+	if err != nil {
+		log.Println("Error getting distribution list")
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(list)
+	if err != nil {
+		log.Println("Error getting distribution list")
+		return
+	}
+}
+
+func CreateOS(w http.ResponseWriter, r *http.Request) {
+	var os db.OS
+	var err error
+
+	t := time.Now()
+	status := 204
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Println("Error reading request body", err)
+	}
+
+	params := make(map[string]null.String)
+	err = json.Unmarshal(body, &params)
+	if err != nil {
+		log.Println("Error unmarshalling request body", err)
+		return
+	}
+	os.Distribution = params["distribution"]
+	os.Version = params["version"]
+	os.EndOfSupport = params["end_of_support"]
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	err = db.CreateOS(os, dbConn)
+	if err != nil {
+		log.Println("Error creating new OS", err)
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.WriteHeader(status)
+}
+
+func DeleteOS(w http.ResponseWriter, r *http.Request) {
+	var os db.OS
+	var err error
+	var status int
+	t := time.Now()
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+	}
+
+	params := make(map[string]null.String)
+	err = json.Unmarshal(body, &params)
+	if err != nil {
+		log.Println("Error unmarshalling request body", err)
+		return
+	}
+	os.Distribution = params["distribution"]
+	os.Version = params["version"]
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	status, err = db.DeleteOS(os, dbConn)
+	if err != nil {
+		log.Println(err.Error(), "Error deleting OS")
+	}
+	logRequest(t, r, status)
+	w.WriteHeader(status)
+}

Http/os_test.go

@@ -0,0 +1,230 @@
+package http
+
+import (
+	"database/sql"
+	"encoding/json"
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/gorilla/mux"
+	"gopkg.in/guregu/null.v4"
+	db "infra-dashboard/Database"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"regexp"
+	"testing"
+)
+
+func TestGetOS(t *testing.T) {
+	// Créer une connexion à la base de données simulée
+	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()
+
+	// Simuler la réponse de la base de données
+	mockOSList := []db.OS{
+		{ID: 1, Distribution: null.StringFrom("Ubuntu"), Version: null.StringFrom("22.04"), EndOfSupport: null.StringFrom("2026-04-01")},
+		{ID: 2, Distribution: null.StringFrom("Debian"), Version: null.StringFrom("12"), EndOfSupport: null.StringFrom("2028-04-01")},
+	}
+
+	rows := sqlmock.NewRows([]string{"id", "distribution", "version", "end_of_support"}).
+		AddRow(1, "Ubuntu", "22.04", "2026-04-01").
+		AddRow(2, "Debian", "12", "2028-04-01")
+
+	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM dashboard_os")).WillReturnRows(rows)
+
+	// Remplacer la fonction GetDatabaseConnection par une version mockée
+	originalGetDatabaseConnection := db.GetDatabaseConnection
+	db.GetDatabaseConnection = func() *sql.DB {
+		return dbConn
+	}
+	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()
+
+	// Créer une requête HTTP
+	req, err := http.NewRequest("GET", "/os", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Créer un ResponseRecorder pour enregistrer la réponse
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(GetOS)
+
+	// Appeler la fonction GetOS
+	handler.ServeHTTP(rr, req)
+
+	// Vérifier le statut de la réponse
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Vérifier le type de contenu de la réponse
+	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)
+	}
+
+	// Vérifier le corps de la réponse
+	var responseOSList []db.OS
+	err = json.NewDecoder(rr.Body).Decode(&responseOSList)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(responseOSList, mockOSList) {
+		t.Errorf("handler returned unexpected body: got %v want %v",
+			responseOSList, mockOSList)
+	}
+
+	// Vérifier que toutes les attentes ont été satisfaites
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("there were unfulfilled expectations: %s", err)
+	}
+}
+
+func TestGetOSbyID(t *testing.T) {
+	// Créer une connexion à la base de données simulée
+	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()
+
+	// Simuler la réponse de la base de données
+	mockOS := db.OS{
+		ID: 1, Distribution: null.StringFrom("Ubuntu"), Version: null.StringFrom("22.04"), EndOfSupport: null.StringFrom("2026-04-01"),
+	}
+
+	rows := sqlmock.NewRows([]string{"id", "distribution", "version", "end_of_support"}).
+		AddRow(1, "Ubuntu", "22.04", "2026-04-01")
+
+	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM dashboard_os 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
+	}
+	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()
+
+	// Créer une requête HTTP
+	req, err := http.NewRequest("GET", "/os/1", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// 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(GetOSbyID)
+
+	// Appeler la fonction GetOS
+	handler.ServeHTTP(rr, req)
+
+	// Vérifier le statut de la réponse
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Vérifier le type de contenu de la réponse
+	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)
+	}
+
+	// Vérifier le corps de la réponse
+	var responseOS db.OS
+	err = json.NewDecoder(rr.Body).Decode(&responseOS)
+	if err != nil {
+		t.Fatal("Error decoding json request", err)
+	}
+
+	if !reflect.DeepEqual(responseOS, mockOS) {
+		t.Errorf("handler returned unexpected body: got %v want %v",
+			responseOS, mockOS)
+	}
+
+	// Vérifier que toutes les attentes ont été satisfaites
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("there were unfulfilled expectations: %s", err)
+	}
+}
+
+func TestGetDistributionList(t *testing.T) {
+	// Créer une connexion à la base de données simulée
+	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()
+
+	// Simuler la réponse de la base de données
+	mockDistributionList := []null.String{}
+	mockDistributionList = append(mockDistributionList, null.StringFrom("Ubuntu"))
+	mockDistributionList = append(mockDistributionList, null.StringFrom("Debian"))
+
+	rows := sqlmock.NewRows([]string{"distribution"}).
+		AddRow("Ubuntu").
+		AddRow("Debian")
+
+	mock.ExpectQuery(regexp.QuoteMeta("SELECT DISTINCT distribution FROM dashboard_os")).WillReturnRows(rows)
+
+	// Remplacer la fonction GetDatabaseConnection par une version mockée
+	originalGetDatabaseConnection := db.GetDatabaseConnection
+	db.GetDatabaseConnection = func() *sql.DB {
+		return dbConn
+	}
+	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()
+
+	// Créer une requête HTTP
+	req, err := http.NewRequest("GET", "/os/distribution", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Créer un ResponseRecorder pour enregistrer la réponse
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(GetDistributionList)
+
+	// Appeler la fonction GetOS
+	handler.ServeHTTP(rr, req)
+
+	// Vérifier le statut de la réponse
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Vérifier le type de contenu de la réponse
+	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)
+	}
+
+	// Vérifier le corps de la réponse
+	var responseOSList []null.String
+	err = json.NewDecoder(rr.Body).Decode(&responseOSList)
+	log.Println(responseOSList)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(responseOSList, mockDistributionList) {
+		t.Errorf("handler returned unexpected body: got %v want %v",
+			responseOSList, mockDistributionList)
+	}
+
+	// Vérifier que toutes les attentes ont été satisfaites
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("there were unfulfilled expectations: %s", err)
+	}
+}

Http/package.go

@@ -0,0 +1,179 @@
+package http
+
+import (
+	"encoding/json"
+	"gopkg.in/guregu/null.v4"
+	db "infra-dashboard/Database"
+	"io"
+	"log"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/gorilla/mux"
+)
+
+func GetAllPackages(w http.ResponseWriter, r *http.Request) {
+	var list []db.Package
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	db_conn := db.GetDatabaseConnection()
+	defer db_conn.Close()
+	list, err = db.GetPackage(db_conn)
+	if err != nil {
+		log.Println("Error getting Package list")
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(list)
+	if err != nil {
+		log.Println("Error encoding response")
+		return
+	}
+}
+
+func GetPackagebyID(w http.ResponseWriter, r *http.Request) {
+	var pkg db.Package
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	params := mux.Vars(r)
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	id, err := strconv.ParseInt(params["id"], 10, 64)
+	if err != nil {
+		log.Println("Error converting ID", err)
+		status = 500
+	}
+	pkg, err = db.GetPackagebyID(dbConn, int64(id))
+	if err != nil {
+		log.Println("Error getting Package")
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(pkg)
+	if err != nil {
+		log.Println("Error encoding response")
+		return
+	}
+}
+
+func CreatePackage(w http.ResponseWriter, r *http.Request) {
+	var pkg db.Package
+	var err error
+	t := time.Now()
+	status := 200
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+	}
+
+	params := make(map[string]null.String)
+	err = json.Unmarshal(body, &params)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+		return
+	}
+	pkg.Name = params["name"]
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	err = db.CreatePackage(pkg, dbConn)
+	if err != nil {
+		log.Println("Error creating package", pkg.Name)
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.WriteHeader(status)
+}
+
+func DisablePackage(w http.ResponseWriter, r *http.Request) {
+	var pkg db.Package
+	var err error
+	var status int
+	t := time.Now()
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+	}
+
+	params := make(map[string]null.String)
+	err = json.Unmarshal(body, &params)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+		return
+	}
+	pkg.Name = params["name"]
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	status, err = db.DisablePackage(pkg, dbConn)
+	if err != nil {
+		log.Println(err.Error(), "Error disabling package", pkg.Name)
+	}
+	logRequest(t, r, status)
+	w.WriteHeader(status)
+}
+
+func EnablePackage(w http.ResponseWriter, r *http.Request) {
+	var pkg db.Package
+	var err error
+	var status int
+	t := time.Now()
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+	}
+
+	params := make(map[string]null.String)
+	err = json.Unmarshal(body, &params)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+		return
+	}
+	pkg.Name = params["name"]
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	status, err = db.EnablePackage(pkg, dbConn)
+	if err != nil {
+		log.Println(err.Error(), "Error enabling package", pkg.Name)
+	}
+	logRequest(t, r, status)
+	w.WriteHeader(status)
+}
+
+func DeletePackage(w http.ResponseWriter, r *http.Request) {
+	var pkg db.Package
+	var err error
+	var status int
+	t := time.Now()
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+	}
+
+	params := make(map[string]null.String)
+	err = json.Unmarshal(body, &params)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+		return
+	}
+	pkg.Name = params["name"]
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	status, err = db.DeletePackage(pkg, dbConn)
+	if err != nil {
+		log.Println(err.Error(), "Error deleting package", pkg.Name)
+	}
+	logRequest(t, r, status)
+	w.WriteHeader(status)
+}

Http/package_test.go

@@ -0,0 +1,159 @@
+package http
+
+import (
+	"database/sql"
+	"encoding/json"
+	db "infra-dashboard/Database"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"regexp"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/gorilla/mux"
+	"gopkg.in/guregu/null.v4"
+)
+
+func TestGetPackage(t *testing.T) {
+	// Créer une connexion à la base de données simulée
+	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()
+
+	// Simuler la réponse de la base de données
+	mockPackageList := []db.Package{
+		{ID: 1, Name: null.StringFrom("Redis"), Active: 1},
+		{ID: 2, Name: null.StringFrom("Rabbit"), Active: 0},
+	}
+
+	rows := sqlmock.NewRows([]string{"id", "name", "active"}).
+		AddRow(1, "Redis", "1").
+		AddRow(2, "Rabbit", "0")
+
+	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM dashboard_package")).WillReturnRows(rows)
+
+	// Remplacer la fonction GetDatabaseConnection par une version mockée
+	originalGetDatabaseConnection := db.GetDatabaseConnection
+	db.GetDatabaseConnection = func() *sql.DB {
+		return dbConn
+	}
+	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()
+
+	// Créer une requête HTTP
+	req, err := http.NewRequest("GET", "/package", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Créer un ResponseRecorder pour enregistrer la réponse
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(GetAllPackages)
+
+	// Appeler la fonction GetPackage
+	handler.ServeHTTP(rr, req)
+
+	// Vérifier le statut de la réponse
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Vérifier le type de contenu de la réponse
+	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)
+	}
+
+	// Vérifier le corps de la réponse
+	var responsePackageList []db.Package
+	err = json.NewDecoder(rr.Body).Decode(&responsePackageList)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(responsePackageList, mockPackageList) {
+		t.Errorf("handler returned unexpected body: got %v want %v",
+			responsePackageList, mockPackageList)
+	}
+
+	// Vérifier que toutes les attentes ont été satisfaites
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("there were unfulfilled expectations: %s", err)
+	}
+}
+
+func TestGetPackagebyID(t *testing.T) {
+	// Créer une connexion à la base de données simulée
+	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()
+
+	// Simuler la réponse de la base de données
+	mockPackage := db.Package{
+		ID: 1, Name: null.StringFrom("Redis"), Active: 1,
+	}
+
+	rows := sqlmock.NewRows([]string{"id", "name", "active"}).
+		AddRow(1, "Redis", "1")
+
+	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM dashboard_package 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
+	}
+	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()
+
+	// Créer une requête HTTP
+	req, err := http.NewRequest("GET", "/package/1", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// 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(GetPackagebyID)
+
+	// Appeler la fonction GetPackage
+	handler.ServeHTTP(rr, req)
+
+	// Vérifier le statut de la réponse
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Vérifier le type de contenu de la réponse
+	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)
+	}
+
+	// Vérifier le corps de la réponse
+	var responsePackage db.Package
+	err = json.NewDecoder(rr.Body).Decode(&responsePackage)
+	if err != nil {
+		t.Fatal("Error decoding json request", err)
+	}
+
+	if !reflect.DeepEqual(responsePackage, mockPackage) {
+		t.Errorf("handler returned unexpected body: got %v want %v",
+			responsePackage, mockPackage)
+	}
+
+	// Vérifier que toutes les attentes ont été satisfaites
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("there were unfulfilled expectations: %s", err)
+	}
+}

Http/server.go

@@ -0,0 +1,161 @@
+package http
+
+import (
+	"encoding/json"
+	db "infra-dashboard/Database"
+	"io"
+	"log"
+	"net/http"
+	"strconv"
+	"time"
+
+	"gopkg.in/guregu/null.v4"
+
+	"github.com/gorilla/mux"
+)
+
+func GetServersList(w http.ResponseWriter, r *http.Request) {
+	var list []db.Server
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	list, err = db.GetServersList(dbConn)
+	if err != nil {
+		log.Println("Error getting OS list")
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(list)
+	if err != nil {
+		log.Println("Error getting OS list")
+		return
+	}
+}
+
+func GetServersbyID(w http.ResponseWriter, r *http.Request) {
+	var server db.Server
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	params := mux.Vars(r)
+	id, err := strconv.ParseInt(params["id"], 10, 32)
+	if err != nil {
+		log.Println("Error converting ID", err)
+		status = 500
+	}
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	server = db.GetServersbyID(dbConn, int64(id))
+	logRequest(t, r, status)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(server)
+	if err != nil {
+		log.Println("Error getting OS list")
+		return
+	}
+}
+
+func GetServersbyOS(w http.ResponseWriter, r *http.Request) {
+	var servers []db.Server
+	var err error
+
+	t := time.Now()
+	status := 200
+
+	params := mux.Vars(r)
+	osId, err := strconv.ParseInt(params["os_id"], 10, 32)
+	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()
+	servers, err = db.GetServersbyOS(dbConn, int64(osId))
+	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)
+	w.Header().Set("Content-Type", "application/json")
+	err = json.NewEncoder(w).Encode(servers)
+	if err != nil {
+		log.Println("Error getting OS list")
+		status = 500
+		logRequest(t, r, status)
+		w.WriteHeader(status)
+		return
+	}
+}
+
+func CreateServer(w http.ResponseWriter, r *http.Request) {
+	var server db.Server
+	var err error
+
+	t := time.Now()
+	status := 204
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+	}
+
+	params := make(map[string]null.String)
+	err = json.Unmarshal(body, &params)
+	if err != nil {
+		log.Println(err.Error(), "Error parsing request body")
+		return
+	}
+	server.Hostname = params["hostname"]
+	server.OsId = params["os_id"]
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	err = db.CreateServer(server, dbConn)
+	if err != nil {
+		log.Println(err.Error(), "Error creating server")
+		status = 500
+	}
+	logRequest(t, r, status)
+	w.WriteHeader(status)
+}
+
+func DeleteServer(w http.ResponseWriter, r *http.Request) {
+	var server db.Server
+	var err error
+	var status int
+	t := time.Now()
+
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		log.Println(err.Error(), "Error reading request body")
+	}
+
+	params := make(map[string]null.String)
+	err = json.Unmarshal(body, &params)
+	if err != nil {
+		log.Println(err.Error(), "Error parsing request body")
+		return
+	}
+	server.Hostname = params["hostname"]
+	server.OsId = params["os_id"]
+	dbConn := db.GetDatabaseConnection()
+	defer dbConn.Close()
+	status, err = db.DeleteServer(server, dbConn)
+	if err != nil {
+		log.Println(err.Error(), "Error deleting server")
+	}
+	logRequest(t, r, status)
+	w.WriteHeader(status)
+}

Http/server_test.go

@@ -0,0 +1,380 @@
+package http
+
+import (
+	"bytes"
+	"database/sql"
+	"encoding/json"
+	db "infra-dashboard/Database"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"regexp"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/gorilla/mux"
+	"gopkg.in/guregu/null.v4"
+)
+
+func TestGetServerList(t *testing.T) {
+	// Créer une connexion à la base de données simulée
+	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()
+
+	// Simuler la réponse de la base de données
+	mockServerList := []db.Server{
+		{ID: 1, Hostname: null.StringFrom("testsla"), OsId: null.StringFrom("8")},
+		{ID: 2, Hostname: null.StringFrom("Rabbit"), OsId: null.StringFrom("7")},
+	}
+
+	rows := sqlmock.NewRows([]string{"id", "name", "active"}).
+		AddRow(1, "testsla", "8").
+		AddRow(2, "Rabbit", "7")
+
+	mock.ExpectQuery(regexp.QuoteMeta("SELECT * FROM dashboard_server")).WillReturnRows(rows)
+
+	// Remplacer la fonction GetDatabaseConnection par une version mockée
+	originalGetDatabaseConnection := db.GetDatabaseConnection
+	db.GetDatabaseConnection = func() *sql.DB {
+		return dbConn
+	}
+	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()
+
+	// Créer une requête HTTP
+	req, err := http.NewRequest("GET", "/servers", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Créer un ResponseRecorder pour enregistrer la réponse
+	rr := httptest.NewRecorder()
+	handler := http.HandlerFunc(GetServersList)
+
+	// Appeler la fonction GetServer
+	handler.ServeHTTP(rr, req)
+
+	// Vérifier le statut de la réponse
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Vérifier le type de contenu de la réponse
+	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)
+	}
+
+	// Vérifier le corps de la réponse
+	var responseServerList []db.Server
+	err = json.NewDecoder(rr.Body).Decode(&responseServerList)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(responseServerList, mockServerList) {
+		t.Errorf("handler returned unexpected body: got %v want %v",
+			responseServerList, mockServerList)
+	}
+
+	// Vérifier que toutes les attentes ont été satisfaites
+	if err := mock.ExpectationsWereMet(); err != nil {
+		t.Errorf("there were unfulfilled expectations: %s", err)
+	}
+}
+
+func TestGetServerbyID(t *testing.T) {
+	// Créer une connexion à la base de données simulée
+	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()
+
+	// 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
+	}
+	defer func() { db.GetDatabaseConnection = originalGetDatabaseConnection }()
+
+	// Créer une requête HTTP
+	req, err := http.NewRequest("GET", "/server/1", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// 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 != http.StatusOK {
+		t.Errorf("handler returned wrong status code: got %v want %v",
+			status, http.StatusOK)
+	}
+
+	// Vérifier le type de contenu de la réponse
+	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)
+	}
+
+	// Vérifier le corps de la réponse
+	var responseServer db.Server
+	err = json.NewDecoder(rr.Body).Decode(&responseServer)
+	if err != nil {
+		t.Fatal("Error decoding json request", err)
+	}
+
+	if !reflect.DeepEqual(responseServer, mockServer) {
+		t.Errorf("handler returned unexpected body: got %v want %v",
+			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) {
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
+	if err != nil {
+		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
+	}
+	defer mockDB.Close()
+	db.GetDatabaseConnection = func() *sql.DB {
+		return mockDB
+	}
+
+	mockServer := []db.Server{
+		{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: "8",
+			mockBehavior: func() {
+				rows := sqlmock.NewRows([]string{"id", "hostname", "os_id"}).AddRow(1, "testsla", "8")
+				mock.ExpectQuery("SELECT * FROM dashboard_server WHERE os_id = ?").WithArgs(sqlmock.AnyArg()).WillReturnRows(rows)
+			},
+			expectedStatus:      http.StatusOK,
+			expectedContentType: "application/json",
+		},
+		{
+			name:                "Error getting Server by OS 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/os/", nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			req = mux.SetURLVars(req, map[string]string{"os_id": tt.requestParam})
+
+			rr := httptest.NewRecorder()
+			handler := http.HandlerFunc(GetServersbyOS)
+			handler.ServeHTTP(rr, req)
+
+			if status := rr.Code; status != tt.expectedStatus {
+				t.Errorf("handler returned wrong status code: got %v want %v",
+					status, tt.expectedStatus)
+			}
+
+			if ct := rr.Header().Get("Content-Type"); ct != tt.expectedContentType {
+				t.Errorf("handler returned wrong content type: got %v want %v",
+					ct, tt.expectedContentType)
+			}
+
+			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)
+				}
+
+				if !reflect.DeepEqual(responseServer, mockServer) {
+					t.Errorf("handler returned unexpected body: got %v want %v",
+						responseServer, mockServer)
+				}
+
+			}
+			if err := mock.ExpectationsWereMet(); err != nil {
+				t.Errorf("there were unfulfilled expectations: %s", err)
+			}
+		})
+	}
+}
+
+func TestCreateServer(t *testing.T) {
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
+	if err != nil {
+		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
+	}
+	defer mockDB.Close()
+	db.GetDatabaseConnection = func() *sql.DB {
+		return mockDB
+	}
+
+	// Define the test cases
+	tests := []struct {
+		name           string
+		requestBody    string
+		mockBehavior   func()
+		expectedStatus int
+	}{
+		{
+			name:        "Successful server creation",
+			requestBody: `{"hostname": "test-host", "os_id": "1"}`,
+			mockBehavior: func() {
+				mock.ExpectPrepare("INSERT INTO dashboard_server (hostname, os_id) VALUES ( ?, ?)").ExpectExec().WithArgs("test-host", "1").WillReturnResult(sqlmock.NewResult(1, 1))
+			},
+			expectedStatus: http.StatusNoContent,
+		},
+		{
+			name:           "Error creating server",
+			requestBody:    `{"hostname": "test-host", "os_id": "1"}`,
+			mockBehavior:   func() {},
+			expectedStatus: http.StatusInternalServerError,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Set up the mock behavior
+			tt.mockBehavior()
+
+			// Create a request with the test body
+			req, err := http.NewRequest("POST", "/server/create", bytes.NewBuffer([]byte(tt.requestBody)))
+			if err != nil {
+				t.Fatalf("could not create request: %v", err)
+			}
+			req.Header.Set("Content-Type", "application/json")
+
+			// Create a ResponseRecorder to record the response
+			rr := httptest.NewRecorder()
+			handler := http.HandlerFunc(CreateServer)
+
+			// Call the handler
+			handler.ServeHTTP(rr, req)
+
+			// Check the status code
+			if status := rr.Code; status != tt.expectedStatus {
+				t.Errorf("handler returned wrong status code: got %v want %v",
+					status, tt.expectedStatus)
+			}
+
+			// Verify that all expectations were met
+			if err := mock.ExpectationsWereMet(); err != nil {
+				t.Errorf("there were unmet expectations: %s", err)
+			}
+		})
+	}
+}
+
+func TestDeleteServer(t *testing.T) {
+	// Create a mock database connection
+	mockDB, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
+	if err != nil {
+		t.Fatalf("an error '%s' was not expected when opening a stub database connection", err)
+	}
+	defer mockDB.Close()
+
+	// Mock the GetDatabaseConnection function
+	db.GetDatabaseConnection = func() *sql.DB {
+		return mockDB
+	}
+
+	// Define the test cases
+	tests := []struct {
+		name           string
+		requestBody    string
+		mockBehavior   func()
+		expectedStatus int
+	}{
+		{
+			name:        "Successful server deletion",
+			requestBody: `{"hostname": "test-host", "os_id": "1"}`,
+			mockBehavior: func() {
+				mock.ExpectPrepare("DELETE FROM dashboard_server WHERE hostname = ? AND os_id = ?").ExpectExec().WithArgs("test-host", "1").WillReturnResult(sqlmock.NewResult(1, 1))
+			},
+			expectedStatus: http.StatusOK,
+		},
+		{
+			name:        "Error deleting server",
+			requestBody: `{"hostname": "test-host", "os_id": "1"}`,
+			mockBehavior: func() {
+			},
+			expectedStatus: http.StatusInternalServerError,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Set up the mock behavior
+			tt.mockBehavior()
+
+			// Create a request with the test body
+			req, err := http.NewRequest("POST", "/server/delete", bytes.NewBuffer([]byte(tt.requestBody)))
+			if err != nil {
+				t.Fatalf("could not create request: %v", err)
+			}
+			req.Header.Set("Content-Type", "application/json")
+
+			// Create a ResponseRecorder to record the response
+			rr := httptest.NewRecorder()
+			handler := http.HandlerFunc(DeleteServer)
+
+			// Call the handler
+			handler.ServeHTTP(rr, req)
+
+			// Check the status code
+			if status := rr.Code; status != tt.expectedStatus {
+				t.Errorf("handler returned wrong status code: got %v want %v",
+					status, tt.expectedStatus)
+			}
+
+			// Verify that all expectations were met
+			if err := mock.ExpectationsWereMet(); err != nil {
+				t.Errorf("there were unmet expectations: %s", err)
+			}
+		})
+	}
+}

Http/utils.go

@@ -0,0 +1,43 @@
+package http
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"time"
+)
+
+func RequestHandler(w http.ResponseWriter, r *http.Request) {
+	t := time.Now()
+	logRequest(t, r, 418)
+	w.WriteHeader(http.StatusTeapot)
+	_, err := fmt.Fprint(w, "Bip Boop I'm a teapot")
+	if err != nil {
+		log.Println("Something went wrong with the teapot")
+	}
+}
+
+func HealthHandler(w http.ResponseWriter, _ *http.Request) {
+	_, _ = io.WriteString(w, "OK")
+}
+
+func NotFound(w http.ResponseWriter, r *http.Request) {
+	t := time.Now()
+	logRequest(t, r, 404)
+	w.WriteHeader(http.StatusNotFound)
+}
+
+func logRequest(t time.Time, r *http.Request, s int) {
+	log.Printf("%s - - %s \"%s %s %s\" %d %d \"-\" \"%s\" %d\n",
+		r.Host,
+		t.Format("[02/Jan/2006:15:04:05 -0700]"),
+		r.Method,
+		r.URL.Path,
+		r.Proto,
+		s,
+		r.ContentLength,
+		r.UserAgent(),
+		time.Since(t).Milliseconds(),
+	)
+}

Http/utils_test.go

@@ -0,0 +1,59 @@
+package http
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestHealthHandler(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/healthcheck", nil)
+	w := httptest.NewRecorder()
+	HealthHandler(w, req)
+	res := w.Result()
+	defer res.Body.Close()
+
+	data, err := io.ReadAll(res.Body)
+	if err != nil {
+		t.Errorf("Expected error to be nil, got %v", err)
+	}
+	if res.StatusCode != http.StatusOK {
+		t.Errorf("Expected status code 200, got %v", res.StatusCode)
+	}
+	if string(data) != "OK" {
+		t.Errorf("Expected 'OK', got %v", string(data))
+	}
+}
+
+func TestRequestHandler(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/", nil)
+	w := httptest.NewRecorder()
+	RequestHandler(w, req)
+	res := w.Result()
+	defer res.Body.Close()
+
+	_, err := io.ReadAll(res.Body)
+	if err != nil {
+		t.Errorf("Expected error to be nil, got %v", err)
+	}
+	if res.StatusCode != http.StatusTeapot {
+		t.Errorf("Expected status code 418, got %v", res.StatusCode)
+	}
+}
+
+func TestNotFound(t *testing.T) {
+	req := httptest.NewRequest(http.MethodGet, "/metrics", nil)
+	w := httptest.NewRecorder()
+	NotFound(w, req)
+	res := w.Result()
+	defer res.Body.Close()
+
+	_, err := io.ReadAll(res.Body)
+	if err != nil {
+		t.Errorf("Expected error to be nil, got %v", err)
+	}
+	if res.StatusCode != http.StatusNotFound {
+		t.Errorf("Expected status code 404, got %v", res.StatusCode)
+	}
+}