zkill-susser/analytics_test.go

package main

import (
	"context"
	"testing"
)

func TestQueryTimeByHour(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryTimeByHour(ctx, filters)
	if err != nil {
		t.Fatalf("QueryTimeByHour failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryTimeByHour returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryTimeByHour returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  Hour %d: %d kills, %d unique victims, %d systems", r.KillHour, r.KillCount, r.UniqueVictims, r.SystemsHit)
	}
}

func TestQueryTimeByDay(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryTimeByDay(ctx, filters)
	if err != nil {
		t.Fatalf("QueryTimeByDay failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryTimeByDay returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryTimeByDay returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s: %d kills, %d unique victims", r.DayName, r.KillCount, r.UniqueVictims)
	}
}

func TestQueryTimeByDate(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryTimeByDate(ctx, filters)
	if err != nil {
		t.Fatalf("QueryTimeByDate failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryTimeByDate returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryTimeByDate returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  Date %s: %d kills, %d unique victims, %d systems", r.KillDate, r.KillCount, r.UniqueVictims, r.SystemsHit)
	}
}

func TestQueryTimeByMonth(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryTimeByMonth(ctx, filters)
	if err != nil {
		t.Fatalf("QueryTimeByMonth failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryTimeByMonth returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryTimeByMonth returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  Month %s: %d kills, %d unique victims", r.Month, r.KillCount, r.UniqueVictims)
	}
}

func TestQueryLocationBySystem(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryLocationBySystem(ctx, filters)
	if err != nil {
		t.Fatalf("QueryLocationBySystem failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryLocationBySystem returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryLocationBySystem returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  System %s (%s): %d kills, %d unique victims, %.2f sec", r.SolarSystemName, r.RegionName, r.KillCount, r.UniqueVictims, r.Security)
	}
}

func TestQueryLocationByRegion(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryLocationByRegion(ctx, filters)
	if err != nil {
		t.Fatalf("QueryLocationByRegion failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryLocationByRegion returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryLocationByRegion returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  Region %s: %d kills, %d systems, %d unique victims", r.RegionName, r.KillCount, r.SystemsWithKills, r.UniqueVictims)
	}
}

func TestQueryLocationByConstellation(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryLocationByConstellation(ctx, filters)
	if err != nil {
		t.Fatalf("QueryLocationByConstellation failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryLocationByConstellation returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryLocationByConstellation returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  Constellation %s (%s): %d kills, %d systems", r.ConstellationName, r.RegionName, r.KillCount, r.SystemsInConstellation)
	}
}

func TestQueryLocationBySecurity(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryLocationBySecurity(ctx, filters)
	if err != nil {
		t.Fatalf("QueryLocationBySecurity failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryLocationBySecurity returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryLocationBySecurity returned %d results", len(results))
	for _, r := range results {
		t.Logf("  %s: %d kills, %d systems", r.SecStatus, r.KillCount, r.Systems)
	}
}

func TestQueryShipByVictim(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryShipByVictim(ctx, filters)
	if err != nil {
		t.Fatalf("QueryShipByVictim failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryShipByVictim returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryShipByVictim returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s (%s/%s): %d kills, %d unique pilots", r.ShipTypeName, r.ShipGroupName, r.ShipCategoryName, r.KillCount, r.UniquePilots)
	}
}

func TestQueryShipByAttacker(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryShipByAttacker(ctx, filters)
	if err != nil {
		t.Fatalf("QueryShipByAttacker failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryShipByAttacker returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryShipByAttacker returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s (%s): %d times used, %d kills, %d final blows, %d total damage", r.ShipTypeName, r.ShipGroupName, r.TimesUsed, r.KillsParticipated, r.FinalBlows, r.TotalDamage)
	}
}

func TestQueryPlayerByVictimCharacter(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryPlayerByVictimCharacter(ctx, filters)
	if err != nil {
		t.Fatalf("QueryPlayerByVictimCharacter failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryPlayerByVictimCharacter returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryPlayerByVictimCharacter returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s (%s/%s): %d deaths, %d ships lost", r.CharacterName, r.Corporation, r.Alliance, r.Deaths, r.ShipsLost)
	}
}

func TestQueryPlayerByVictimCorporation(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryPlayerByVictimCorporation(ctx, filters)
	if err != nil {
		t.Fatalf("QueryPlayerByVictimCorporation failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryPlayerByVictimCorporation returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryPlayerByVictimCorporation returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s (%s): %d losses, %d members killed", r.Corporation, r.Alliance, r.Losses, r.MembersKilled)
	}
}

func TestQueryPlayerByVictimAlliance(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryPlayerByVictimAlliance(ctx, filters)
	if err != nil {
		t.Fatalf("QueryPlayerByVictimAlliance failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryPlayerByVictimAlliance returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryPlayerByVictimAlliance returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s: %d losses, %d corps hit, %d members killed", r.Alliance, r.Losses, r.CorpsHit, r.MembersKilled)
	}
}

func TestQueryPlayerByAttackerCharacter(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryPlayerByAttackerCharacter(ctx, filters)
	if err != nil {
		t.Fatalf("QueryPlayerByAttackerCharacter failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryPlayerByAttackerCharacter returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryPlayerByAttackerCharacter returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s (%s/%s): %d kills, %d final blows, %d total damage", r.CharacterName, r.Corporation, r.Alliance, r.KillsParticipated, r.FinalBlows, r.TotalDamage)
	}
}

func TestQueryPlayerByAttackerCorporation(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryPlayerByAttackerCorporation(ctx, filters)
	if err != nil {
		t.Fatalf("QueryPlayerByAttackerCorporation failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryPlayerByAttackerCorporation returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryPlayerByAttackerCorporation returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s (%s): %d kills, %d members involved", r.Corporation, r.Alliance, r.KillsParticipated, r.MembersInvolved)
	}
}

func TestQueryPlayerByAttackerAlliance(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryPlayerByAttackerAlliance(ctx, filters)
	if err != nil {
		t.Fatalf("QueryPlayerByAttackerAlliance failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryPlayerByAttackerAlliance returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryPlayerByAttackerAlliance returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s: %d kills, %d corps, %d members", r.Alliance, r.KillsParticipated, r.CorpsInvolved, r.MembersInvolved)
	}
}

func TestQueryModuleBySlotType(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryModuleBySlotType(ctx, filters)
	if err != nil {
		t.Fatalf("QueryModuleBySlotType failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryModuleBySlotType returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryModuleBySlotType returned %d results", len(results))
	for _, r := range results {
		t.Logf("  %s: %d items fitted, %d ships, %d module variety", r.SlotType, r.ItemsFitted, r.ShipsWithSlot, r.ModuleVariety)
	}
}

func TestQueryModuleByModule(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryModuleByModule(ctx, filters)
	if err != nil {
		t.Fatalf("QueryModuleByModule failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryModuleByModule returned no results (this is OK if database is empty)")
		return
	}

	t.Logf("QueryModuleByModule returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s (%s/%s): %d times fitted, %d ships", r.ItemTypeName, r.ItemGroupName, r.ItemCategoryName, r.TimesFitted, r.ShipsWithModule)
	}
}

func TestQueryModuleCoOccurrence(t *testing.T) {
	db, err := GetDB()
	if err != nil {
		t.Fatalf("Failed to get DB: %v", err)
	}

	ctx := context.Background()
	filters := AnalyticsFilters{}

	results, err := db.QueryModuleCoOccurrence(ctx, filters, 26914, "mid")
	if err != nil {
		t.Fatalf("QueryModuleCoOccurrence failed: %v", err)
	}

	if len(results) == 0 {
		t.Log("QueryModuleCoOccurrence returned no results (this is OK if database is empty or module doesn't exist)")
		return
	}

	t.Logf("QueryModuleCoOccurrence returned %d results", len(results))
	for i, r := range results {
		if i >= 3 {
			break
		}
		t.Logf("  %s (%s): %d times together, %.2f%%", r.ItemTypeName, r.SlotType, r.TimesTogether, r.Percentage)
	}
}