305 lines
8.5 KiB
Go
305 lines
8.5 KiB
Go
package tests
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"gocarlog/internal/db"
|
|
"gocarlog/internal/model"
|
|
)
|
|
|
|
// setupTestDB erstellt eine Test-Datenbank mit allen Tabellen und Seed-Daten
|
|
func setupTestDB(t *testing.T) *db.Database {
|
|
t.Helper()
|
|
database, err := db.NewDatabase(":memory:")
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Erstellen der Datenbank: %v", err)
|
|
}
|
|
return database
|
|
}
|
|
|
|
// ==================== Fuel Tests ====================
|
|
|
|
func TestGetFuels(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
fuels, err := model.GetFuels(database.DB)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Abrufen der Kraftstoffe: %v", err)
|
|
}
|
|
if len(fuels) != 5 {
|
|
t.Errorf("Erwartet 5 Kraftstoffe, gefunden: %d", len(fuels))
|
|
}
|
|
}
|
|
|
|
func TestGetFuelByID(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
fuel, err := model.GetFuelByID(database.DB, 0)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Abrufen des Kraftstoffs: %v", err)
|
|
}
|
|
if fuel.Name != "Diesel" {
|
|
t.Errorf("Erwartet 'Diesel', gefunden: %s", fuel.Name)
|
|
}
|
|
if fuel.Unit != "L" {
|
|
t.Errorf("Erwartet 'L', gefunden: %s", fuel.Unit)
|
|
}
|
|
}
|
|
|
|
func TestGetFuelByIDNotFound(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
_, err := model.GetFuelByID(database.DB, 999)
|
|
if err == nil {
|
|
t.Error("Erwartet Fehler für nicht-existenten Kraftstoff")
|
|
}
|
|
}
|
|
|
|
// ==================== Vehicle Tests ====================
|
|
|
|
func TestGetVehicles(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
// Erstelle 3 Fahrzeuge
|
|
names := []string{"BMW 320d", "Audi A4", "Tesla Model 3"}
|
|
fuelIDs := []int{0, 1, 4}
|
|
|
|
for i := range names {
|
|
fuelID := fuelIDs[i]
|
|
v := &model.Vehicle{
|
|
Name: names[i],
|
|
FuelID: &fuelID,
|
|
Year: intPtr(2020 + i),
|
|
Manufacturer: strPtr("Autohersteller"),
|
|
}
|
|
if err := model.CreateVehicle(database.DB, v); err != nil {
|
|
t.Fatalf("Fehler beim Anlegen: %v", err)
|
|
}
|
|
}
|
|
|
|
vehicles, total, err := model.GetVehicles(database.DB, map[string]string{}, 100, 0)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Abrufen: %v", err)
|
|
}
|
|
if total != 3 {
|
|
t.Errorf("Erwartet 3 Fahrzeuge, gefunden: %d", total)
|
|
}
|
|
if len(vehicles) != 3 {
|
|
t.Errorf("Erwartet 3 Einträge, gefunden: %d", len(vehicles))
|
|
}
|
|
}
|
|
|
|
func TestGetVehiclesFilter(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
// Erstelle Fahrzeuge
|
|
v1 := &model.Vehicle{Name: "BMW 320d", FuelID: intPtr(0)}
|
|
v2 := &model.Vehicle{Name: "BMW X5", FuelID: intPtr(0)}
|
|
v3 := &model.Vehicle{Name: "Audi A4", FuelID: intPtr(1)}
|
|
model.CreateVehicle(database.DB, v1)
|
|
model.CreateVehicle(database.DB, v2)
|
|
model.CreateVehicle(database.DB, v3)
|
|
|
|
// Filter nach name "BMW"
|
|
filters := map[string]string{"name": "BMW"}
|
|
_, total, err := model.GetVehicles(database.DB, filters, 100, 0)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Filtern: %v", err)
|
|
}
|
|
if total != 2 {
|
|
t.Errorf("Erwartet 2 BMW-Fahrzeuge, gefunden: %d", total)
|
|
}
|
|
|
|
// Filter nach fuel_id 1
|
|
filters2 := map[string]string{"fuel_id": "1"}
|
|
_, total2, err := model.GetVehicles(database.DB, filters2, 100, 0)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Filtern: %v", err)
|
|
}
|
|
if total2 != 1 {
|
|
t.Errorf("Erwartet 1 Benzin-Fahrzeug, gefunden: %d", total2)
|
|
}
|
|
}
|
|
|
|
func TestGetVehicleByID(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
v := &model.Vehicle{Name: "Test Auto", FuelID: intPtr(0)}
|
|
model.CreateVehicle(database.DB, v)
|
|
|
|
detail, err := model.GetVehicleByID(database.DB, v.ID)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Abrufen: %v", err)
|
|
}
|
|
if detail.Name != "Test Auto" {
|
|
t.Errorf("Erwartet 'Test Auto', gefunden: %s", detail.Name)
|
|
}
|
|
if detail.Fuel == nil || detail.Fuel.Name != "Diesel" {
|
|
t.Error("Fuel sollte Diesel sein")
|
|
}
|
|
}
|
|
|
|
func TestUpdateOdometer(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
v := &model.Vehicle{Name: "Test", FuelID: intPtr(0)}
|
|
model.CreateVehicle(database.DB, v)
|
|
|
|
err := model.UpdateOdometer(database.DB, v.ID, 50000.0)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Update: %v", err)
|
|
}
|
|
|
|
detail, err := model.GetVehicleByID(database.DB, v.ID)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Abrufen: %v", err)
|
|
}
|
|
if detail.CurrentOdometer != 50000.0 {
|
|
t.Errorf("Erwartet 50000, gefunden: %f", detail.CurrentOdometer)
|
|
}
|
|
}
|
|
|
|
// ==================== Log Tests ====================
|
|
|
|
func TestCreateLogOdometerUpdate(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
v := &model.Vehicle{Name: "Test", FuelID: intPtr(0)}
|
|
model.CreateVehicle(database.DB, v)
|
|
|
|
// Erster Eintrag mit 10000 km
|
|
l1 := &model.Log{VehicleID: v.ID, LogType: "tankung", Odometer: 10000, FuelID: intPtr(0), Quantity: 5.0}
|
|
model.CreateLog(database.DB, l1)
|
|
|
|
// Zweiter Eintrag mit höherem km-Stand
|
|
l2 := &model.Log{VehicleID: v.ID, LogType: "tankung", Odometer: 15000, FuelID: intPtr(0), Quantity: 6.0}
|
|
model.CreateLog(database.DB, l2)
|
|
|
|
detail, _ := model.GetVehicleByID(database.DB, v.ID)
|
|
if detail.CurrentOdometer != 15000 {
|
|
t.Errorf("Erwartet 15000, gefunden: %f", detail.CurrentOdometer)
|
|
}
|
|
}
|
|
|
|
func TestGetLogs(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
v := &model.Vehicle{Name: "Test Auto", FuelID: intPtr(0)}
|
|
model.CreateVehicle(database.DB, v)
|
|
|
|
// Erstelle einige Logs
|
|
model.CreateLog(database.DB, &model.Log{
|
|
VehicleID: v.ID, LogType: "tankung", Odometer: 10000, FuelID: intPtr(0),
|
|
Cost: 65.50, Quantity: 5.2, Note: strPtr("Tankung 1"),
|
|
})
|
|
model.CreateLog(database.DB, &model.Log{
|
|
VehicleID: v.ID, LogType: "wartung", Odometer: 12000, FuelID: nil,
|
|
Cost: 200.0, Quantity: 0, Note: strPtr("Inspektion"),
|
|
})
|
|
model.CreateLog(database.DB, &model.Log{
|
|
VehicleID: v.ID, LogType: "tankung", Odometer: 15000, FuelID: intPtr(0),
|
|
Cost: 70.0, Quantity: 5.5, Note: strPtr("Tankung 2"),
|
|
})
|
|
|
|
logs, total, summary, err := model.GetLogs(database.DB, map[string]string{}, 100, 0)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Abrufen: %v", err)
|
|
}
|
|
if total != 3 {
|
|
t.Errorf("Erwartet 3 Logs, gefunden: %d", total)
|
|
}
|
|
if len(logs) != 3 {
|
|
t.Errorf("Erwartet 3 Einträge, gefunden: %d", len(logs))
|
|
}
|
|
// Kosten-Zusammenfassung
|
|
if summary.Tankung != 135.50 {
|
|
t.Errorf("Erwartet Tankung-Kosten 135.50, gefunden: %f", summary.Tankung)
|
|
}
|
|
if summary.Wartung != 200.0 {
|
|
t.Errorf("Erwartet Wartung-Kosten 200.0, gefunden: %f", summary.Wartung)
|
|
}
|
|
}
|
|
|
|
func TestGetLogsFilter(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
v := &model.Vehicle{Name: "Test", FuelID: intPtr(0)}
|
|
model.CreateVehicle(database.DB, v)
|
|
|
|
model.CreateLog(database.DB, &model.Log{VehicleID: v.ID, LogType: "tankung", Odometer: 10000, FuelID: intPtr(0)})
|
|
model.CreateLog(database.DB, &model.Log{VehicleID: v.ID, LogType: "wartung", Odometer: 12000})
|
|
|
|
filters := map[string]string{"log_type": "wartung"}
|
|
_, total, _, err := model.GetLogs(database.DB, filters, 100, 0)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Filtern: %v", err)
|
|
}
|
|
if total != 1 {
|
|
t.Errorf("Erwartet 1 Wartungseintrag, gefunden: %d", total)
|
|
}
|
|
}
|
|
|
|
func TestGetConsumption(t *testing.T) {
|
|
database := setupTestDB(t)
|
|
defer database.Close()
|
|
|
|
v := &model.Vehicle{Name: "Test Auto", FuelID: intPtr(0)}
|
|
model.CreateVehicle(database.DB, v)
|
|
|
|
// Tankung bei 10000 km — 5.2L
|
|
model.CreateLog(database.DB, &model.Log{
|
|
VehicleID: v.ID, LogType: "tankung", Odometer: 10000, FuelID: intPtr(0),
|
|
Quantity: 5.2, Cost: 65.50,
|
|
})
|
|
// Tankung bei 12000 km — 5.0L (Distanz: 2000km, Verbrauch: 5.0L)
|
|
model.CreateLog(database.DB, &model.Log{
|
|
VehicleID: v.ID, LogType: "tankung", Odometer: 12000, FuelID: intPtr(0),
|
|
Quantity: 5.0, Cost: 63.00,
|
|
})
|
|
// Tankung bei 15000 km — 5.5L (Distanz: 3000km, Verbrauch: 5.5L)
|
|
model.CreateLog(database.DB, &model.Log{
|
|
VehicleID: v.ID, LogType: "tankung", Odometer: 15000, FuelID: intPtr(0),
|
|
Quantity: 5.5, Cost: 70.00,
|
|
})
|
|
|
|
result, err := model.GetConsumption(database.DB, v.ID, nil, nil)
|
|
if err != nil {
|
|
t.Fatalf("Fehler beim Abrufen des Verbrauchs: %v", err)
|
|
}
|
|
if result == nil {
|
|
t.Fatal("Verbrauchsergebnis sollte nicht nil sein")
|
|
}
|
|
// Gesamt-Distanz: 15000 - 10000 = 5000km
|
|
if result.TotalDistance != 5000.0 {
|
|
t.Errorf("Erwartet 5000km Distanz, gefunden: %f", result.TotalDistance)
|
|
}
|
|
// Gesamt-Kraftstoff: 5.0 + 5.5 = 10.5L (zwei vollständige Tankungen)
|
|
if result.TotalFuel != 10.5 {
|
|
t.Errorf("Erwartet 10.5L Kraftstoff, gefunden: %f", result.TotalFuel)
|
|
}
|
|
// Durchschnittsverbrauch: 10.5 / 4000 * 100 = 0.2625 L/100km
|
|
if result.AverageConsumption == nil {
|
|
t.Error("AverageConsumption sollte nicht nil sein")
|
|
}
|
|
}
|
|
|
|
// ==================== Helper Funktionen ====================
|
|
|
|
func intPtr(i int) *int {
|
|
return &i
|
|
}
|
|
|
|
func strPtr(s string) *string {
|
|
return &s
|
|
}
|