816 lines
20 KiB
Go
816 lines
20 KiB
Go
package housing
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"zombiezen.com/go/sqlite/sqlitex"
|
|
)
|
|
|
|
// createTestPool creates an in-memory SQLite database pool for testing
|
|
func createTestPool(t *testing.T) *sqlitex.Pool {
|
|
dbName := fmt.Sprintf("file:test_%s.db?mode=memory&cache=shared", t.Name())
|
|
pool, err := sqlitex.NewPool(dbName, sqlitex.PoolOptions{})
|
|
if err != nil {
|
|
t.Fatalf("Failed to create test database pool: %v", err)
|
|
}
|
|
return pool
|
|
}
|
|
|
|
// setupTestDB creates test tables and returns a DatabaseHousingManager
|
|
func setupTestDB(t *testing.T) *DatabaseHousingManager {
|
|
pool := createTestPool(t)
|
|
dhm := NewDatabaseHousingManager(pool)
|
|
|
|
ctx := context.Background()
|
|
if err := dhm.EnsureHousingTables(ctx); err != nil {
|
|
t.Fatalf("Failed to create test tables: %v", err)
|
|
}
|
|
|
|
return dhm
|
|
}
|
|
|
|
// insertTestData inserts sample data for testing
|
|
func insertTestData(t *testing.T, dhm *DatabaseHousingManager) {
|
|
ctx := context.Background()
|
|
|
|
// Insert test house zones
|
|
testZones := []*HouseZone{
|
|
{
|
|
ID: 1,
|
|
Name: "Small Studio",
|
|
ZoneID: 100,
|
|
CostCoin: 50000,
|
|
CostStatus: 1000,
|
|
UpkeepCoin: 5000,
|
|
UpkeepStatus: 100,
|
|
Alignment: 0, // Neutral
|
|
GuildLevel: 0,
|
|
VaultSlots: 4,
|
|
MaxItems: 100,
|
|
MaxVisitors: 10,
|
|
UpkeepPeriod: 604800, // 1 week
|
|
Description: "A cozy small studio apartment",
|
|
},
|
|
{
|
|
ID: 2,
|
|
Name: "Large House",
|
|
ZoneID: 101,
|
|
CostCoin: 500000,
|
|
CostStatus: 10000,
|
|
UpkeepCoin: 50000,
|
|
UpkeepStatus: 1000,
|
|
Alignment: 1, // Good
|
|
GuildLevel: 20,
|
|
VaultSlots: 8,
|
|
MaxItems: 500,
|
|
MaxVisitors: 50,
|
|
UpkeepPeriod: 604800,
|
|
Description: "A spacious large house",
|
|
},
|
|
}
|
|
|
|
for _, zone := range testZones {
|
|
if err := dhm.SaveHouseZone(ctx, zone); err != nil {
|
|
t.Fatalf("Failed to insert test house zone: %v", err)
|
|
}
|
|
}
|
|
|
|
// Insert test player houses
|
|
testPlayerHouses := []PlayerHouseData{
|
|
{
|
|
CharacterID: 1001,
|
|
HouseID: 1,
|
|
InstanceID: 5001,
|
|
UpkeepDue: time.Now().Add(24 * time.Hour),
|
|
EscrowCoins: 25000,
|
|
EscrowStatus: 500,
|
|
Status: HouseStatusActive,
|
|
HouseName: "Alice's Studio",
|
|
VisitPermission: 1,
|
|
PublicNote: "Welcome to my home!",
|
|
PrivateNote: "Remember to water plants",
|
|
AllowFriends: true,
|
|
AllowGuild: false,
|
|
RequireApproval: false,
|
|
ShowOnDirectory: true,
|
|
AllowDecoration: true,
|
|
TaxExempt: false,
|
|
},
|
|
{
|
|
CharacterID: 1002,
|
|
HouseID: 2,
|
|
InstanceID: 5002,
|
|
UpkeepDue: time.Now().Add(48 * time.Hour),
|
|
EscrowCoins: 100000,
|
|
EscrowStatus: 2000,
|
|
Status: HouseStatusActive,
|
|
HouseName: "Bob's Manor",
|
|
VisitPermission: 2,
|
|
PublicNote: "Guild meetings welcome",
|
|
PrivateNote: "Check security settings",
|
|
AllowFriends: true,
|
|
AllowGuild: true,
|
|
RequireApproval: true,
|
|
ShowOnDirectory: true,
|
|
AllowDecoration: false,
|
|
TaxExempt: true,
|
|
},
|
|
}
|
|
|
|
for _, house := range testPlayerHouses {
|
|
_, err := dhm.AddPlayerHouse(ctx, house)
|
|
if err != nil {
|
|
t.Fatalf("Failed to insert test player house: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNewDatabaseHousingManager(t *testing.T) {
|
|
pool := createTestPool(t)
|
|
dhm := NewDatabaseHousingManager(pool)
|
|
|
|
if dhm == nil {
|
|
t.Fatal("NewDatabaseHousingManager returned nil")
|
|
}
|
|
|
|
if dhm.pool != pool {
|
|
t.Error("Database pool not set correctly")
|
|
}
|
|
}
|
|
|
|
func TestEnsureHousingTables(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
ctx := context.Background()
|
|
|
|
// Test that tables were created (this should not error on second call)
|
|
if err := dhm.EnsureHousingTables(ctx); err != nil {
|
|
t.Errorf("EnsureHousingTables failed on second call: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestHouseZoneOperations(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
ctx := context.Background()
|
|
|
|
// Test SaveHouseZone and LoadHouseZone
|
|
testZone := &HouseZone{
|
|
ID: 100,
|
|
Name: "Test House",
|
|
ZoneID: 200,
|
|
CostCoin: 100000,
|
|
CostStatus: 2000,
|
|
UpkeepCoin: 10000,
|
|
UpkeepStatus: 200,
|
|
Alignment: -1, // Evil
|
|
GuildLevel: 10,
|
|
VaultSlots: 6,
|
|
MaxItems: 250,
|
|
MaxVisitors: 25,
|
|
UpkeepPeriod: 1209600, // 2 weeks
|
|
Description: "A test house for unit testing",
|
|
}
|
|
|
|
// Save house zone
|
|
if err := dhm.SaveHouseZone(ctx, testZone); err != nil {
|
|
t.Fatalf("SaveHouseZone failed: %v", err)
|
|
}
|
|
|
|
// Load house zone
|
|
loadedZone, err := dhm.LoadHouseZone(ctx, testZone.ID)
|
|
if err != nil {
|
|
t.Fatalf("LoadHouseZone failed: %v", err)
|
|
}
|
|
|
|
// Verify loaded data
|
|
if loadedZone.ID != testZone.ID {
|
|
t.Errorf("Expected ID %d, got %d", testZone.ID, loadedZone.ID)
|
|
}
|
|
if loadedZone.Name != testZone.Name {
|
|
t.Errorf("Expected Name %s, got %s", testZone.Name, loadedZone.Name)
|
|
}
|
|
if loadedZone.Description != testZone.Description {
|
|
t.Errorf("Expected Description %s, got %s", testZone.Description, loadedZone.Description)
|
|
}
|
|
|
|
// Test LoadHouseZones
|
|
zones, err := dhm.LoadHouseZones(ctx)
|
|
if err != nil {
|
|
t.Fatalf("LoadHouseZones failed: %v", err)
|
|
}
|
|
|
|
if len(zones) != 1 {
|
|
t.Errorf("Expected 1 zone, got %d", len(zones))
|
|
}
|
|
|
|
// Test DeleteHouseZone
|
|
if err := dhm.DeleteHouseZone(ctx, testZone.ID); err != nil {
|
|
t.Fatalf("DeleteHouseZone failed: %v", err)
|
|
}
|
|
|
|
// Verify deletion
|
|
_, err = dhm.LoadHouseZone(ctx, testZone.ID)
|
|
if err == nil {
|
|
t.Error("Expected error when loading deleted house zone, got nil")
|
|
}
|
|
}
|
|
|
|
func TestPlayerHouseOperations(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Test LoadPlayerHouses
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil {
|
|
t.Fatalf("LoadPlayerHouses failed: %v", err)
|
|
}
|
|
|
|
if len(houses) != 1 {
|
|
t.Errorf("Expected 1 house for character 1001, got %d", len(houses))
|
|
}
|
|
|
|
if houses[0].HouseName != "Alice's Studio" {
|
|
t.Errorf("Expected house name 'Alice's Studio', got %s", houses[0].HouseName)
|
|
}
|
|
|
|
// Test LoadPlayerHouse by unique ID
|
|
house, err := dhm.LoadPlayerHouse(ctx, houses[0].UniqueID)
|
|
if err != nil {
|
|
t.Fatalf("LoadPlayerHouse failed: %v", err)
|
|
}
|
|
|
|
if house.CharacterID != 1001 {
|
|
t.Errorf("Expected character ID 1001, got %d", house.CharacterID)
|
|
}
|
|
|
|
// Test GetHouseByInstance
|
|
houseByInstance, err := dhm.GetHouseByInstance(ctx, 5001)
|
|
if err != nil {
|
|
t.Fatalf("GetHouseByInstance failed: %v", err)
|
|
}
|
|
|
|
if houseByInstance.CharacterID != 1001 {
|
|
t.Errorf("Expected character ID 1001, got %d", houseByInstance.CharacterID)
|
|
}
|
|
|
|
// Test GetNextHouseID
|
|
nextID, err := dhm.GetNextHouseID(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetNextHouseID failed: %v", err)
|
|
}
|
|
|
|
if nextID <= houses[0].UniqueID {
|
|
t.Errorf("Expected next ID > %d, got %d", houses[0].UniqueID, nextID)
|
|
}
|
|
}
|
|
|
|
func TestPlayerHouseUpdates(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Get a test house
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil || len(houses) == 0 {
|
|
t.Fatalf("Failed to load test house: %v", err)
|
|
}
|
|
|
|
houseID := houses[0].UniqueID
|
|
|
|
// Test UpdateHouseUpkeepDue
|
|
newUpkeepDue := time.Now().Add(72 * time.Hour)
|
|
if err := dhm.UpdateHouseUpkeepDue(ctx, houseID, newUpkeepDue); err != nil {
|
|
t.Fatalf("UpdateHouseUpkeepDue failed: %v", err)
|
|
}
|
|
|
|
// Verify update
|
|
updatedHouse, err := dhm.LoadPlayerHouse(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("Failed to load updated house: %v", err)
|
|
}
|
|
|
|
if updatedHouse.UpkeepDue.Unix() != newUpkeepDue.Unix() {
|
|
t.Errorf("Expected upkeep due %v, got %v", newUpkeepDue, updatedHouse.UpkeepDue)
|
|
}
|
|
|
|
// Test UpdateHouseEscrow
|
|
if err := dhm.UpdateHouseEscrow(ctx, houseID, 50000, 1000); err != nil {
|
|
t.Fatalf("UpdateHouseEscrow failed: %v", err)
|
|
}
|
|
|
|
// Verify escrow update
|
|
updatedHouse, err = dhm.LoadPlayerHouse(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("Failed to load updated house: %v", err)
|
|
}
|
|
|
|
if updatedHouse.EscrowCoins != 50000 {
|
|
t.Errorf("Expected escrow coins 50000, got %d", updatedHouse.EscrowCoins)
|
|
}
|
|
if updatedHouse.EscrowStatus != 1000 {
|
|
t.Errorf("Expected escrow status 1000, got %d", updatedHouse.EscrowStatus)
|
|
}
|
|
}
|
|
|
|
func TestHouseDeposits(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Get a test house
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil || len(houses) == 0 {
|
|
t.Fatalf("Failed to load test house: %v", err)
|
|
}
|
|
|
|
houseID := houses[0].UniqueID
|
|
|
|
// Test SaveDeposit
|
|
testDeposit := HouseDeposit{
|
|
Timestamp: time.Now(),
|
|
Amount: 10000,
|
|
LastAmount: 15000,
|
|
Status: 200,
|
|
LastStatus: 300,
|
|
Name: "Alice",
|
|
CharacterID: 1001,
|
|
}
|
|
|
|
if err := dhm.SaveDeposit(ctx, houseID, testDeposit); err != nil {
|
|
t.Fatalf("SaveDeposit failed: %v", err)
|
|
}
|
|
|
|
// Test LoadDeposits
|
|
deposits, err := dhm.LoadDeposits(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadDeposits failed: %v", err)
|
|
}
|
|
|
|
if len(deposits) != 1 {
|
|
t.Errorf("Expected 1 deposit, got %d", len(deposits))
|
|
}
|
|
|
|
if deposits[0].Amount != testDeposit.Amount {
|
|
t.Errorf("Expected deposit amount %d, got %d", testDeposit.Amount, deposits[0].Amount)
|
|
}
|
|
if deposits[0].Name != testDeposit.Name {
|
|
t.Errorf("Expected deposit name %s, got %s", testDeposit.Name, deposits[0].Name)
|
|
}
|
|
}
|
|
|
|
func TestHouseHistory(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Get a test house
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil || len(houses) == 0 {
|
|
t.Fatalf("Failed to load test house: %v", err)
|
|
}
|
|
|
|
houseID := houses[0].UniqueID
|
|
|
|
// Test AddHistory
|
|
testHistory := HouseHistory{
|
|
Timestamp: time.Now(),
|
|
Amount: 5000,
|
|
Status: 100,
|
|
Reason: "Weekly upkeep",
|
|
Name: "System",
|
|
CharacterID: 0, // System transaction
|
|
PosFlag: 0, // Withdrawal
|
|
Type: 1, // Upkeep
|
|
}
|
|
|
|
if err := dhm.AddHistory(ctx, houseID, testHistory); err != nil {
|
|
t.Fatalf("AddHistory failed: %v", err)
|
|
}
|
|
|
|
// Test LoadHistory
|
|
history, err := dhm.LoadHistory(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadHistory failed: %v", err)
|
|
}
|
|
|
|
if len(history) != 1 {
|
|
t.Errorf("Expected 1 history entry, got %d", len(history))
|
|
}
|
|
|
|
if history[0].Reason != testHistory.Reason {
|
|
t.Errorf("Expected history reason %s, got %s", testHistory.Reason, history[0].Reason)
|
|
}
|
|
if history[0].Amount != testHistory.Amount {
|
|
t.Errorf("Expected history amount %d, got %d", testHistory.Amount, history[0].Amount)
|
|
}
|
|
}
|
|
|
|
func TestHouseAccess(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Get a test house
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil || len(houses) == 0 {
|
|
t.Fatalf("Failed to load test house: %v", err)
|
|
}
|
|
|
|
houseID := houses[0].UniqueID
|
|
|
|
// Test SaveHouseAccess
|
|
testAccess := []HouseAccess{
|
|
{
|
|
CharacterID: 2001,
|
|
PlayerName: "Bob",
|
|
AccessLevel: 1,
|
|
Permissions: 15, // Full permissions
|
|
GrantedBy: 1001,
|
|
GrantedDate: time.Now(),
|
|
ExpiresDate: time.Now().Add(30 * 24 * time.Hour),
|
|
Notes: "Trusted friend",
|
|
},
|
|
{
|
|
CharacterID: 2002,
|
|
PlayerName: "Charlie",
|
|
AccessLevel: 2,
|
|
Permissions: 7, // Limited permissions
|
|
GrantedBy: 1001,
|
|
GrantedDate: time.Now(),
|
|
ExpiresDate: time.Now().Add(7 * 24 * time.Hour),
|
|
Notes: "Temporary access",
|
|
},
|
|
}
|
|
|
|
if err := dhm.SaveHouseAccess(ctx, houseID, testAccess); err != nil {
|
|
t.Fatalf("SaveHouseAccess failed: %v", err)
|
|
}
|
|
|
|
// Test LoadHouseAccess
|
|
accessList, err := dhm.LoadHouseAccess(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadHouseAccess failed: %v", err)
|
|
}
|
|
|
|
if len(accessList) != 2 {
|
|
t.Errorf("Expected 2 access entries, got %d", len(accessList))
|
|
}
|
|
|
|
// Test DeleteHouseAccess
|
|
if err := dhm.DeleteHouseAccess(ctx, houseID, 2002); err != nil {
|
|
t.Fatalf("DeleteHouseAccess failed: %v", err)
|
|
}
|
|
|
|
// Verify deletion
|
|
accessList, err = dhm.LoadHouseAccess(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadHouseAccess after deletion failed: %v", err)
|
|
}
|
|
|
|
if len(accessList) != 1 {
|
|
t.Errorf("Expected 1 access entry after deletion, got %d", len(accessList))
|
|
}
|
|
|
|
if accessList[0].CharacterID != 2001 {
|
|
t.Errorf("Expected remaining access for character 2001, got %d", accessList[0].CharacterID)
|
|
}
|
|
}
|
|
|
|
func TestHouseAmenities(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Get a test house
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil || len(houses) == 0 {
|
|
t.Fatalf("Failed to load test house: %v", err)
|
|
}
|
|
|
|
houseID := houses[0].UniqueID
|
|
|
|
// Test SaveHouseAmenity
|
|
testAmenity := HouseAmenity{
|
|
ID: 1,
|
|
Type: 1, // Furniture
|
|
Name: "Comfortable Chair",
|
|
Cost: 1000,
|
|
StatusCost: 20,
|
|
PurchaseDate: time.Now(),
|
|
X: 100.5,
|
|
Y: 200.0,
|
|
Z: 50.25,
|
|
Heading: 180.0,
|
|
IsActive: true,
|
|
}
|
|
|
|
if err := dhm.SaveHouseAmenity(ctx, houseID, testAmenity); err != nil {
|
|
t.Fatalf("SaveHouseAmenity failed: %v", err)
|
|
}
|
|
|
|
// Test LoadHouseAmenities
|
|
amenities, err := dhm.LoadHouseAmenities(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadHouseAmenities failed: %v", err)
|
|
}
|
|
|
|
if len(amenities) != 1 {
|
|
t.Errorf("Expected 1 amenity, got %d", len(amenities))
|
|
}
|
|
|
|
if amenities[0].Name != testAmenity.Name {
|
|
t.Errorf("Expected amenity name %s, got %s", testAmenity.Name, amenities[0].Name)
|
|
}
|
|
if amenities[0].X != testAmenity.X {
|
|
t.Errorf("Expected X position %f, got %f", testAmenity.X, amenities[0].X)
|
|
}
|
|
|
|
// Test DeleteHouseAmenity
|
|
if err := dhm.DeleteHouseAmenity(ctx, houseID, testAmenity.ID); err != nil {
|
|
t.Fatalf("DeleteHouseAmenity failed: %v", err)
|
|
}
|
|
|
|
// Verify deletion
|
|
amenities, err = dhm.LoadHouseAmenities(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadHouseAmenities after deletion failed: %v", err)
|
|
}
|
|
|
|
if len(amenities) != 0 {
|
|
t.Errorf("Expected 0 amenities after deletion, got %d", len(amenities))
|
|
}
|
|
}
|
|
|
|
func TestHouseItems(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Get a test house
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil || len(houses) == 0 {
|
|
t.Fatalf("Failed to load test house: %v", err)
|
|
}
|
|
|
|
houseID := houses[0].UniqueID
|
|
|
|
// Test SaveHouseItem
|
|
testItem := HouseItem{
|
|
ID: 1,
|
|
ItemID: 12345,
|
|
CharacterID: 1001,
|
|
X: 150.0,
|
|
Y: 250.0,
|
|
Z: 75.5,
|
|
Heading: 90.0,
|
|
PitchX: 5.0,
|
|
PitchY: 0.0,
|
|
RollX: 0.0,
|
|
RollY: 2.5,
|
|
PlacedDate: time.Now(),
|
|
Quantity: 1,
|
|
Condition: 100,
|
|
House: "main",
|
|
}
|
|
|
|
if err := dhm.SaveHouseItem(ctx, houseID, testItem); err != nil {
|
|
t.Fatalf("SaveHouseItem failed: %v", err)
|
|
}
|
|
|
|
// Test LoadHouseItems
|
|
items, err := dhm.LoadHouseItems(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadHouseItems failed: %v", err)
|
|
}
|
|
|
|
if len(items) != 1 {
|
|
t.Errorf("Expected 1 item, got %d", len(items))
|
|
}
|
|
|
|
if items[0].ItemID != testItem.ItemID {
|
|
t.Errorf("Expected item ID %d, got %d", testItem.ItemID, items[0].ItemID)
|
|
}
|
|
if items[0].House != testItem.House {
|
|
t.Errorf("Expected house %s, got %s", testItem.House, items[0].House)
|
|
}
|
|
|
|
// Test DeleteHouseItem
|
|
if err := dhm.DeleteHouseItem(ctx, houseID, testItem.ID); err != nil {
|
|
t.Fatalf("DeleteHouseItem failed: %v", err)
|
|
}
|
|
|
|
// Verify deletion
|
|
items, err = dhm.LoadHouseItems(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadHouseItems after deletion failed: %v", err)
|
|
}
|
|
|
|
if len(items) != 0 {
|
|
t.Errorf("Expected 0 items after deletion, got %d", len(items))
|
|
}
|
|
}
|
|
|
|
func TestGetHousesForUpkeep(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Test with cutoff time in the future (should find houses)
|
|
cutoffTime := time.Now().Add(72 * time.Hour)
|
|
houses, err := dhm.GetHousesForUpkeep(ctx, cutoffTime)
|
|
if err != nil {
|
|
t.Fatalf("GetHousesForUpkeep failed: %v", err)
|
|
}
|
|
|
|
if len(houses) != 2 {
|
|
t.Errorf("Expected 2 houses for upkeep, got %d", len(houses))
|
|
}
|
|
|
|
// Test with cutoff time in the past (should find no houses)
|
|
cutoffTime = time.Now().Add(-24 * time.Hour)
|
|
houses, err = dhm.GetHousesForUpkeep(ctx, cutoffTime)
|
|
if err != nil {
|
|
t.Fatalf("GetHousesForUpkeep with past cutoff failed: %v", err)
|
|
}
|
|
|
|
if len(houses) != 0 {
|
|
t.Errorf("Expected 0 houses for past upkeep, got %d", len(houses))
|
|
}
|
|
}
|
|
|
|
func TestGetHouseStatistics(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Add some test data for statistics
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil || len(houses) == 0 {
|
|
t.Fatalf("Failed to load test house: %v", err)
|
|
}
|
|
|
|
houseID := houses[0].UniqueID
|
|
|
|
// Add some deposits and history for stats
|
|
testDeposit := HouseDeposit{
|
|
Timestamp: time.Now(),
|
|
Amount: 5000,
|
|
LastAmount: 10000,
|
|
Status: 100,
|
|
LastStatus: 200,
|
|
Name: "Alice",
|
|
CharacterID: 1001,
|
|
}
|
|
|
|
if err := dhm.SaveDeposit(ctx, houseID, testDeposit); err != nil {
|
|
t.Fatalf("Failed to save test deposit: %v", err)
|
|
}
|
|
|
|
testHistory := HouseHistory{
|
|
Timestamp: time.Now(),
|
|
Amount: 2000,
|
|
Status: 50,
|
|
Reason: "Withdrawal",
|
|
Name: "Alice",
|
|
CharacterID: 1001,
|
|
PosFlag: 0, // Withdrawal
|
|
Type: 2,
|
|
}
|
|
|
|
if err := dhm.AddHistory(ctx, houseID, testHistory); err != nil {
|
|
t.Fatalf("Failed to add test history: %v", err)
|
|
}
|
|
|
|
// Test GetHouseStatistics
|
|
stats, err := dhm.GetHouseStatistics(ctx)
|
|
if err != nil {
|
|
t.Fatalf("GetHouseStatistics failed: %v", err)
|
|
}
|
|
|
|
if stats.TotalHouses != 2 {
|
|
t.Errorf("Expected 2 total houses, got %d", stats.TotalHouses)
|
|
}
|
|
if stats.ActiveHouses != 2 {
|
|
t.Errorf("Expected 2 active houses, got %d", stats.ActiveHouses)
|
|
}
|
|
if stats.TotalDeposits != 1 {
|
|
t.Errorf("Expected 1 total deposits, got %d", stats.TotalDeposits)
|
|
}
|
|
if stats.TotalWithdrawals != 1 {
|
|
t.Errorf("Expected 1 total withdrawals, got %d", stats.TotalWithdrawals)
|
|
}
|
|
}
|
|
|
|
func TestDeletePlayerHouse(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
insertTestData(t, dhm)
|
|
ctx := context.Background()
|
|
|
|
// Get a test house
|
|
houses, err := dhm.LoadPlayerHouses(ctx, 1001)
|
|
if err != nil || len(houses) == 0 {
|
|
t.Fatalf("Failed to load test house: %v", err)
|
|
}
|
|
|
|
houseID := houses[0].UniqueID
|
|
|
|
// Add some related data that should be cascade deleted
|
|
testDeposit := HouseDeposit{
|
|
Timestamp: time.Now(),
|
|
Amount: 5000,
|
|
LastAmount: 10000,
|
|
Status: 100,
|
|
LastStatus: 200,
|
|
Name: "Alice",
|
|
CharacterID: 1001,
|
|
}
|
|
|
|
if err := dhm.SaveDeposit(ctx, houseID, testDeposit); err != nil {
|
|
t.Fatalf("Failed to save test deposit: %v", err)
|
|
}
|
|
|
|
// Test DeletePlayerHouse
|
|
if err := dhm.DeletePlayerHouse(ctx, houseID); err != nil {
|
|
t.Fatalf("DeletePlayerHouse failed: %v", err)
|
|
}
|
|
|
|
// Verify deletion
|
|
_, err = dhm.LoadPlayerHouse(ctx, houseID)
|
|
if err == nil {
|
|
t.Error("Expected error when loading deleted player house, got nil")
|
|
}
|
|
|
|
// Verify related data was also deleted
|
|
deposits, err := dhm.LoadDeposits(ctx, houseID)
|
|
if err != nil {
|
|
t.Fatalf("LoadDeposits after house deletion failed: %v", err)
|
|
}
|
|
|
|
if len(deposits) != 0 {
|
|
t.Errorf("Expected 0 deposits after house deletion, got %d", len(deposits))
|
|
}
|
|
|
|
// Verify other houses are still there
|
|
remainingHouses, err := dhm.LoadPlayerHouses(ctx, 1002)
|
|
if err != nil {
|
|
t.Fatalf("Failed to load remaining houses: %v", err)
|
|
}
|
|
|
|
if len(remainingHouses) != 1 {
|
|
t.Errorf("Expected 1 remaining house, got %d", len(remainingHouses))
|
|
}
|
|
}
|
|
|
|
func TestErrorCases(t *testing.T) {
|
|
dhm := setupTestDB(t)
|
|
ctx := context.Background()
|
|
|
|
// Test loading non-existent house zone
|
|
_, err := dhm.LoadHouseZone(ctx, 999)
|
|
if err == nil {
|
|
t.Error("Expected error when loading non-existent house zone, got nil")
|
|
}
|
|
|
|
// Test loading non-existent player house
|
|
_, err = dhm.LoadPlayerHouse(ctx, 999)
|
|
if err == nil {
|
|
t.Error("Expected error when loading non-existent player house, got nil")
|
|
}
|
|
|
|
// Test loading house by non-existent instance
|
|
_, err = dhm.GetHouseByInstance(ctx, 999)
|
|
if err == nil {
|
|
t.Error("Expected error when loading house by non-existent instance, got nil")
|
|
}
|
|
|
|
// Test operations on non-existent house
|
|
nonExistentHouseID := int64(999)
|
|
|
|
deposits, err := dhm.LoadDeposits(ctx, nonExistentHouseID)
|
|
if err != nil {
|
|
t.Errorf("LoadDeposits should not error on non-existent house: %v", err)
|
|
}
|
|
if len(deposits) != 0 {
|
|
t.Errorf("Expected 0 deposits for non-existent house, got %d", len(deposits))
|
|
}
|
|
|
|
history, err := dhm.LoadHistory(ctx, nonExistentHouseID)
|
|
if err != nil {
|
|
t.Errorf("LoadHistory should not error on non-existent house: %v", err)
|
|
}
|
|
if len(history) != 0 {
|
|
t.Errorf("Expected 0 history entries for non-existent house, got %d", len(history))
|
|
}
|
|
}
|
|
|
|
// Helper function to compare times with tolerance for database precision
|
|
func timesEqual(t1, t2 time.Time, tolerance time.Duration) bool {
|
|
diff := t1.Sub(t2)
|
|
if diff < 0 {
|
|
diff = -diff
|
|
}
|
|
return diff <= tolerance
|
|
} |