Ajedrez_Purgatorio/Assets/Tests/EditMode/Meta/SaveSystemTests.cs

using NUnit.Framework;
using UnityEngine;
using UnityEngine.TestTools;
using System.IO;
using AjedrezPurgatorio.Meta;

namespace AjedrezPurgatorio.Tests.Unit.Meta
{
    [TestFixture]
    [Category("Unit")]
    [Category("Meta")]
    [Category("SaveSystem")]
    [Category("FastTests")]
    public class SaveSystemTests
    {
        private GameObject _root;
        private SaveSystem _saveSystem;
        private CampaignState _campaignState;
        private string _testSaveDir;

        [SetUp]
        public void Setup()
        {
            _root = new GameObject("SaveSystemTestRoot");
            _saveSystem = _root.AddComponent<SaveSystem>();
            _campaignState = ScriptableObject.CreateInstance<CampaignState>();
            _testSaveDir = Path.Combine(Application.temporaryCachePath, "save_tests");
            Directory.CreateDirectory(_testSaveDir);
        }

        [TearDown]
        public void Teardown()
        {
            Object.DestroyImmediate(_campaignState);
            Object.DestroyImmediate(_root);

            if (Directory.Exists(_testSaveDir))
            {
                Directory.Delete(_testSaveDir, true);
            }
        }

        private static void ExpectInvalidSlotLog(int slot)
        {
            LogAssert.Expect(LogType.Error, $"[SaveSystem] Invalid save slot: {slot}. Must be between 0 and 2.");
        }

        #region SaveGame Tests

        [Test]
        public void SaveGame_NullCampaignState_ReturnsFalse()
        {
            LogAssert.Expect(LogType.Error, "[SaveSystem] Cannot save with null campaign state.");
            Assert.IsFalse(_saveSystem.SaveGame(0, null, 0));
        }

        [Test]
        public void SaveGame_InvalidSlot_ReturnsFalse()
        {
            ExpectInvalidSlotLog(-1);
            Assert.IsFalse(_saveSystem.SaveGame(-1, _campaignState, 0));
            ExpectInvalidSlotLog(10);
            Assert.IsFalse(_saveSystem.SaveGame(10, _campaignState, 0));
        }

        #endregion

        #region LoadGame Tests

        [Test]
        public void LoadGame_InvalidSlot_ReturnsNull()
        {
            ExpectInvalidSlotLog(-1);
            Assert.IsNull(_saveSystem.LoadGame(-1));
            ExpectInvalidSlotLog(100);
            Assert.IsNull(_saveSystem.LoadGame(100));
        }

        #endregion

        #region DoesSaveExist Tests

        [Test]
        public void DoesSaveExist_InvalidSlot_ReturnsFalse()
        {
            ExpectInvalidSlotLog(-1);
            Assert.IsFalse(_saveSystem.DoesSaveExist(-1));
            ExpectInvalidSlotLog(5);
            Assert.IsFalse(_saveSystem.DoesSaveExist(5));
        }

        #endregion

        #region DeleteSave Tests

        [Test]
        public void DeleteSave_InvalidSlot_ReturnsFalse()
        {
            ExpectInvalidSlotLog(-1);
            Assert.IsFalse(_saveSystem.DeleteSave(-1));
            ExpectInvalidSlotLog(5);
            Assert.IsFalse(_saveSystem.DeleteSave(5));
        }

        [Test]
        public void DeleteSave_NonexistentSave_ReturnsFalse()
        {
            Assert.IsFalse(_saveSystem.DeleteSave(0));
        }

        #endregion

        #region GetSaveInfo Tests

        [Test]
        public void GetSaveInfo_InvalidSlot_ReturnsDefaultInfo()
        {
            ExpectInvalidSlotLog(-1);
            var info = _saveSystem.GetSaveInfo(-1);

            Assert.IsNotNull(info);
            Assert.IsFalse(info.exists);
            Assert.AreEqual(-1, info.slot);
        }

        [Test]
        public void GetSaveInfo_NonexistentSave_ReturnsNonExistentInfo()
        {
            var info = _saveSystem.GetSaveInfo(0);

            Assert.IsNotNull(info);
            Assert.IsFalse(info.exists);
            Assert.AreEqual(0, info.slot);
        }

        #endregion

        #region GetAllSaveInfos Tests

        [Test]
        public void GetAllSaveInfos_ReturnsArray()
        {
            var infos = _saveSystem.GetAllSaveInfos();

            Assert.IsNotNull(infos);
            Assert.AreEqual(3, infos.Length);
        }

        #endregion

        #region GetMostRecentSaveSlot Tests

        [Test]
        public void GetMostRecentSaveSlot_NoSaves_ReturnsNegativeOne()
        {
            Assert.AreEqual(-1, _saveSystem.GetMostRecentSaveSlot());
        }

        #endregion

        #region SaveData Structure Tests

        [Test]
        public void SaveData_DefaultValues_AreCorrect()
        {
            var data = new SaveSystem.SaveData();

            Assert.AreEqual(0, data.saveSlot);
            Assert.AreEqual(0, data.currentChapterIndex);
            Assert.IsNotNull(data.completedChapters);
            Assert.AreEqual(0, data.completedChapters.Count);
            Assert.IsNotNull(data.alivePieces);
            Assert.AreEqual(0, data.alivePieces.Count);
            Assert.AreEqual(0, data.totalPiecesLost);
            Assert.IsFalse(data.lastChapterWasVictory);
            Assert.AreEqual(1, data.saveVersion);
        }

        [Test]
        public void SaveData_CustomValues_ArePreserved()
        {
            var data = new SaveSystem.SaveData
            {
                saveSlot = 2,
                currentChapterIndex = 3,
                totalPiecesLost = 5,
                lastChapterWasVictory = true
            };

            Assert.AreEqual(2, data.saveSlot);
            Assert.AreEqual(3, data.currentChapterIndex);
            Assert.AreEqual(5, data.totalPiecesLost);
            Assert.IsTrue(data.lastChapterWasVictory);
        }

        #endregion

        #region SaveInfo Structure Tests

        [Test]
        public void SaveInfo_DefaultValues_AreCorrect()
        {
            var info = new SaveSystem.SaveInfo(1);

            Assert.AreEqual(1, info.slot);
            Assert.AreEqual("", info.saveDate);
            Assert.AreEqual(0, info.currentChapter);
            Assert.IsFalse(info.exists);
        }

        #endregion
    }
}