Dragon-Knight/internal/drops/drops_test.go

package drops

import (
	"os"
	"testing"

	"dk/internal/database"
)

func setupTestDB(t *testing.T) *database.DB {
	testDB := "test_drops.db"
	t.Cleanup(func() {
		os.Remove(testDB)
	})

	db, err := database.Open(testDB)
	if err != nil {
		t.Fatalf("Failed to open test database: %v", err)
	}

	// Create drops table
	createTable := `CREATE TABLE drops (
		id    INTEGER PRIMARY KEY AUTOINCREMENT,
		name  TEXT NOT NULL DEFAULT '',
		level INTEGER NOT NULL DEFAULT 0,
		type  INTEGER NOT NULL DEFAULT 0,
		att   TEXT NOT NULL DEFAULT ''
	)`

	if err := db.Exec(createTable); err != nil {
		t.Fatalf("Failed to create drops table: %v", err)
	}

	// Insert test data
	testDrops := `INSERT INTO drops (name, level, type, att) VALUES
		('Life Pebble', 1, 1, 'maxhp,10'),
		('Magic Stone', 10, 1, 'maxmp,25'),
		('Dragon''s Scale', 10, 1, 'defensepower,25'),
		('Angel''s Joy', 25, 1, 'maxhp,25,strength,25')`

	if err := db.Exec(testDrops); err != nil {
		t.Fatalf("Failed to insert test drops: %v", err)
	}

	return db
}

func TestFind(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	// Test finding existing drop
	drop, err := Find(db, 1)
	if err != nil {
		t.Fatalf("Failed to find drop: %v", err)
	}

	if drop.ID != 1 {
		t.Errorf("Expected ID 1, got %d", drop.ID)
	}
	if drop.Name != "Life Pebble" {
		t.Errorf("Expected name 'Life Pebble', got '%s'", drop.Name)
	}
	if drop.Level != 1 {
		t.Errorf("Expected level 1, got %d", drop.Level)
	}
	if drop.Type != TypeConsumable {
		t.Errorf("Expected type %d, got %d", TypeConsumable, drop.Type)
	}
	if drop.Att != "maxhp,10" {
		t.Errorf("Expected att1 'maxhp,10', got '%s'", drop.Att)
	}

	// Test finding non-existent drop
	_, err = Find(db, 999)
	if err == nil {
		t.Error("Expected error when finding non-existent drop")
	}
}

func TestAll(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	drops, err := All(db)
	if err != nil {
		t.Fatalf("Failed to get all drops: %v", err)
	}

	if len(drops) != 4 {
		t.Errorf("Expected 4 drops, got %d", len(drops))
	}

	// Check first drop
	if drops[0].Name != "Life Pebble" {
		t.Errorf("Expected first drop to be 'Life Pebble', got '%s'", drops[0].Name)
	}
}

func TestByLevel(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	// Test drops available at level 10
	drops, err := ByLevel(db, 10)
	if err != nil {
		t.Fatalf("Failed to get drops by level: %v", err)
	}

	if len(drops) != 3 {
		t.Errorf("Expected 3 drops at level 10, got %d", len(drops))
	}

	// Verify they are ordered by level
	if drops[0].Level != 1 {
		t.Errorf("Expected first drop level 1, got %d", drops[0].Level)
	}
	if drops[1].Level != 10 {
		t.Errorf("Expected second drop level 10, got %d", drops[1].Level)
	}

	// Test drops available at level 1
	lowLevelDrops, err := ByLevel(db, 1)
	if err != nil {
		t.Fatalf("Failed to get drops by level 1: %v", err)
	}

	if len(lowLevelDrops) != 1 {
		t.Errorf("Expected 1 drop at level 1, got %d", len(lowLevelDrops))
	}
}

func TestByType(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	consumables, err := ByType(db, TypeConsumable)
	if err != nil {
		t.Fatalf("Failed to get consumable drops: %v", err)
	}

	if len(consumables) != 4 {
		t.Errorf("Expected 4 consumable drops, got %d", len(consumables))
	}

	// Verify they are ordered by level, then ID
	if consumables[0].Level > consumables[1].Level {
		t.Error("Expected drops to be ordered by level")
	}
}

func TestBuilder(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	// Create new drop using builder
	drop, err := NewBuilder(db).
		WithName("Test Drop").
		WithLevel(15).
		WithType(TypeConsumable).
		WithAtt("strength,20,dexterity,15").
		Create()

	if err != nil {
		t.Fatalf("Failed to create drop with builder: %v", err)
	}

	if drop.ID == 0 {
		t.Error("Expected non-zero ID after creation")
	}
	if drop.Name != "Test Drop" {
		t.Errorf("Expected name 'Test Drop', got '%s'", drop.Name)
	}
	if drop.Level != 15 {
		t.Errorf("Expected level 15, got %d", drop.Level)
	}
	if drop.Type != TypeConsumable {
		t.Errorf("Expected type %d, got %d", TypeConsumable, drop.Type)
	}
	if drop.Att != "strength,20,dexterity,15" {
		t.Errorf("Expected att 'strength,20,dexterity,15', got '%s'", drop.Att)
	}

	// Verify it was saved to database
	foundDrop, err := Find(db, drop.ID)
	if err != nil {
		t.Fatalf("Failed to find created drop: %v", err)
	}

	if foundDrop.Name != "Test Drop" {
		t.Errorf("Created drop not found in database")
	}
}

func TestSave(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	drop, err := Find(db, 1)
	if err != nil {
		t.Fatalf("Failed to find drop: %v", err)
	}

	// Modify drop
	drop.Name = "Updated Life Pebble"
	drop.Level = 5
	drop.Att = "maxhp,15"

	// Save changes
	err = drop.Save()
	if err != nil {
		t.Fatalf("Failed to save drop: %v", err)
	}

	// Verify changes were saved
	updatedDrop, err := Find(db, 1)
	if err != nil {
		t.Fatalf("Failed to find updated drop: %v", err)
	}

	if updatedDrop.Name != "Updated Life Pebble" {
		t.Errorf("Expected updated name 'Updated Life Pebble', got '%s'", updatedDrop.Name)
	}
	if updatedDrop.Level != 5 {
		t.Errorf("Expected updated level 5, got %d", updatedDrop.Level)
	}
	if updatedDrop.Att != "maxhp,15" {
		t.Errorf("Expected updated att 'maxhp,15', got '%s'", updatedDrop.Att)
	}
}

func TestDelete(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	drop, err := Find(db, 1)
	if err != nil {
		t.Fatalf("Failed to find drop: %v", err)
	}

	// Delete drop
	err = drop.Delete()
	if err != nil {
		t.Fatalf("Failed to delete drop: %v", err)
	}

	// Verify drop was deleted
	_, err = Find(db, 1)
	if err == nil {
		t.Error("Expected error when finding deleted drop")
	}
}

func TestDropMethods(t *testing.T) {
	db := setupTestDB(t)
	defer db.Close()

	pebble, _ := Find(db, 1)

	// Test IsConsumable
	if !pebble.IsConsumable() {
		t.Error("Expected pebble to be consumable")
	}

	// Test TypeName
	if pebble.TypeName() != "Consumable" {
		t.Errorf("Expected pebble type name 'Consumable', got '%s'", pebble.TypeName())
	}

}