zkill-susser/db_test.go

package main

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestQueryFitsOnlyShipReturnsOneShip(t *testing.T) {
	dbi, err := GetDB()
	require.NoError(t, err)
	db := dbi.(*DBWrapper)

	allStats, err := db.QueryFits(QueryParams{Ship: 32872})
	require.NoError(t, err)
	require.Greater(t, allStats.TotalKillmails, int64(0))

	assert.Equal(t, 1, len(allStats.ShipBreakdown))
}

func TestQueryFitsNoShipsReturnsEmptyBreakdown(t *testing.T) {
	dbi, err := GetDB()
	require.NoError(t, err)
	db := dbi.(*DBWrapper)

	stats, err := db.QueryFits(QueryParams{Ship: -1})
	require.NoError(t, err)
	assert.Equal(t, int64(0), stats.TotalKillmails)
	assert.Empty(t, stats.ShipBreakdown)
	assert.Empty(t, stats.SystemBreakdown)
}

func TestQueryFitsSystemFilterIs100PercentForThatSystem(t *testing.T) {
	dbi, err := GetDB()
	require.NoError(t, err)
	db := dbi.(*DBWrapper)

	shipID := int64(32872)
	allStats, err := db.QueryFits(QueryParams{Ship: shipID})
	require.NoError(t, err)
	require.Greater(t, allStats.TotalKillmails, int64(0))

	systemID := pickTopSystemID(allStats)

	stats, err := db.QueryFits(QueryParams{Ship: shipID, Systems: []int64{systemID}})
	require.NoError(t, err)
	require.Greater(t, stats.TotalKillmails, int64(0))

	assert.Equal(t, 1, len(stats.SystemBreakdown))
	sys := stats.SystemBreakdown[systemID]
	assert.Equal(t, stats.TotalKillmails, sys.Count)
	assert.InDelta(t, 100.0, sys.Percentage, 0.01)
}

func TestQueryFitsModuleFilterHasCooccurringModules(t *testing.T) {
	dbi, err := GetDB()
	require.NoError(t, err)
	db := dbi.(*DBWrapper)

	resetModuleSlotCache(t)

	shipID := int64(32872)
	shipStats, err := db.QueryFits(QueryParams{Ship: shipID})
	require.NoError(t, err)
	require.Greater(t, shipStats.TotalKillmails, int64(0))
	require.Greater(t, totalModuleKinds(shipStats), 1)

	moduleID := pickAnyModule(shipStats, false)

	stats, err := db.QueryFits(QueryParams{Ship: shipID, Modules: []int64{moduleID}})
	require.NoError(t, err)
	require.Greater(t, stats.TotalKillmails, int64(0))

	mod := moduleStatsFor(stats, moduleID)
	require.NotNil(t, mod)
	assert.Equal(t, stats.TotalKillmails, mod.Count)
	assert.InDelta(t, 100.0, mod.Percentage, 0.01)
}

func TestQueryFitsDroneFilterHasCooccurringModules(t *testing.T) {
	dbi, err := GetDB()
	require.NoError(t, err)
	db := dbi.(*DBWrapper)

	resetModuleSlotCache(t)

	shipID := int64(32872)
	shipStats, err := db.QueryFits(QueryParams{Ship: shipID})
	require.NoError(t, err)
	require.Greater(t, shipStats.TotalKillmails, int64(0))
	require.Greater(t, len(shipStats.Drones), 0)
	require.Greater(t, totalModuleKinds(shipStats), 1)

	droneID := pickAnyModule(shipStats, true)

	stats, err := db.QueryFits(QueryParams{Ship: shipID, Modules: []int64{droneID}})
	require.NoError(t, err)
	require.Greater(t, stats.TotalKillmails, int64(0))

	mod := moduleStatsFor(stats, droneID)
	require.NotNil(t, mod)
	assert.Equal(t, stats.TotalKillmails, mod.Count)
	assert.InDelta(t, 100.0, mod.Percentage, 0.01)
}

func TestQueryFitsModuleFilterKeepsOtherModulesAndSlots(t *testing.T) {
	dbi, err := GetDB()
	require.NoError(t, err)
	db := dbi.(*DBWrapper)

	resetModuleSlotCache(t)

	shipID := int64(32872)
	moduleID := int64(16433)

	stats, err := db.QueryFits(QueryParams{Ship: shipID, Modules: []int64{moduleID}})
	require.NoError(t, err)
	require.Greater(t, stats.TotalKillmails, int64(0))

	mod := moduleStatsFor(stats, moduleID)
	require.NotNil(t, mod)
	assert.Equal(t, stats.TotalKillmails, mod.Count)
	assert.InDelta(t, 100.0, mod.Percentage, 0.01)

	assert.Greater(t, len(stats.HighSlotModules), 1, "other high-slot modules should remain")
	otherSlots := len(stats.MidSlotModules) + len(stats.LowSlotModules) + len(stats.Rigs) + len(stats.Drones)
	assert.Greater(t, otherSlots, 0, "other slot categories should remain populated")
}

func pickTopSystemID(stats *FitStatistics) int64 {
	var bestID int64
	var bestCount int64
	for id, s := range stats.SystemBreakdown {
		if s.Count > bestCount {
			bestCount = s.Count
			bestID = id
		}
	}
	if bestID == 0 {
		panic("no systems found in statistics")
	}
	return bestID
}

func totalModuleKinds(stats *FitStatistics) int {
	return len(stats.HighSlotModules) +
		len(stats.MidSlotModules) +
		len(stats.LowSlotModules) +
		len(stats.Rigs) +
		len(stats.Drones)
}

func moduleStatsFor(stats *FitStatistics, moduleID int64) *ModuleStats {
	if m, ok := stats.HighSlotModules[int32(moduleID)]; ok {
		return &m
	}
	if m, ok := stats.MidSlotModules[int32(moduleID)]; ok {
		return &m
	}
	if m, ok := stats.LowSlotModules[int32(moduleID)]; ok {
		return &m
	}
	if m, ok := stats.Rigs[int32(moduleID)]; ok {
		return &m
	}
	if m, ok := stats.Drones[int32(moduleID)]; ok {
		return &m
	}
	return nil
}

func resetModuleSlotCache(t *testing.T) {
	t.Helper()
	for k := range moduleSlotCache {
		delete(moduleSlotCache, k)
	}
}

func pickAnyModule(stats *FitStatistics, onlyDrones bool) int64 {
	if onlyDrones {
		for id := range stats.Drones {
			return int64(id)
		}
		return 0
	}
	for id := range stats.HighSlotModules {
		return int64(id)
	}
	for id := range stats.MidSlotModules {
		return int64(id)
	}
	for id := range stats.LowSlotModules {
		return int64(id)
	}
	for id := range stats.Rigs {
		return int64(id)
	}
	for id := range stats.Drones {
		return int64(id)
	}
	return 0
}