res_levis_backend/tests/controller/controller_test.go

package controller

import (
	"bytes"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/AFASystems/presence/internal/pkg/controller"
	"github.com/AFASystems/presence/internal/pkg/model"
	"github.com/gorilla/mux"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

func setupTestDB(t *testing.T) *gorm.DB {
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	if err != nil {
		t.Fatalf("Failed to open test DB: %v", err)
	}
	if err := db.AutoMigrate(&model.Gateway{}, &model.Zone{}, &model.Tracker{}, &model.TrackerZones{}, &model.Config{}, &model.Settings{}, &model.Tracks{}); err != nil {
		t.Fatalf("Failed to migrate: %v", err)
	}
	return db
}

func TestGatewayListController_Empty(t *testing.T) {
	db := setupTestDB(t)
	handler := controller.GatewayListController(db)

	req := httptest.NewRequest(http.MethodGet, "/gateways", nil)
	rec := httptest.NewRecorder()
	handler.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("Expected 200, got %d", rec.Code)
	}
	var gateways []model.Gateway
	if err := json.NewDecoder(rec.Body).Decode(&gateways); err != nil {
		t.Fatalf("Failed to decode: %v", err)
	}
	if len(gateways) != 0 {
		t.Errorf("Expected 0 gateways, got %d", len(gateways))
	}
}

func TestGatewayAddController(t *testing.T) {
	db := setupTestDB(t)
	handler := controller.GatewayAddController(db)

	gateway := model.Gateway{
		ID:   "gw-1",
		Name: "Gateway 1",
		MAC:  "AA:BB:CC:DD:EE:FF",
	}
	body, _ := json.Marshal(gateway)
	req := httptest.NewRequest(http.MethodPost, "/gateways", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	rec := httptest.NewRecorder()
	handler.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("Expected 200, got %d: %s", rec.Code, rec.Body.String())
	}
	if rec.Body.String() != "ok" {
		t.Errorf("Expected 'ok', got %s", rec.Body.String())
	}

	var list []model.Gateway
	db.Find(&list)
	if len(list) != 1 || list[0].Name != "Gateway 1" {
		t.Errorf("Expected 1 gateway in DB, got %+v", list)
	}
}

func TestGatewayDeleteController(t *testing.T) {
	db := setupTestDB(t)
	db.Create(&model.Gateway{ID: "gw-1", Name: "G1", MAC: "AA:BB:CC:DD:EE:FF"})

	req := httptest.NewRequest(http.MethodDelete, "/gateways/gw-1", nil)
	req = mux.SetURLVars(req, map[string]string{"id": "gw-1"})
	rec := httptest.NewRecorder()
	controller.GatewayDeleteController(db).ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("Expected 200, got %d", rec.Code)
	}

	var count int64
	db.Model(&model.Gateway{}).Where("id = ?", "gw-1").Count(&count)
	if count != 0 {
		t.Error("Expected gateway to be deleted")
	}
}

func TestTrackerListController_Empty(t *testing.T) {
	db := setupTestDB(t)
	handler := controller.TrackerList(db)

	req := httptest.NewRequest(http.MethodGet, "/trackers", nil)
	rec := httptest.NewRecorder()
	handler.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("Expected 200, got %d", rec.Code)
	}
	var list []model.Tracker
	if err := json.NewDecoder(rec.Body).Decode(&list); err != nil {
		t.Fatalf("Failed to decode: %v", err)
	}
	if len(list) != 0 {
		t.Errorf("Expected 0 trackers, got %d", len(list))
	}
}

func TestZoneListController_Empty(t *testing.T) {
	db := setupTestDB(t)
	handler := controller.ZoneListController(db)

	req := httptest.NewRequest(http.MethodGet, "/zones", nil)
	rec := httptest.NewRecorder()
	handler.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("Expected 200, got %d", rec.Code)
	}
}

func TestSettingsListController(t *testing.T) {
	db := setupTestDB(t)
	handler := controller.SettingsListController(db)

	req := httptest.NewRequest(http.MethodGet, "/settings", nil)
	rec := httptest.NewRecorder()
	handler.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("Expected 200, got %d", rec.Code)
	}
}