geometry-tower-defense/Assets/Tests/EditMode/EventDefinitionFactoryTests.cs

using GeometryTD.Definition;
using GeometryTD.Factory;
using GeometryTD.DataTable;
using Newtonsoft.Json.Linq;
using NUnit.Framework;

namespace GeometryTD.Tests.EditMode
{
    public sealed class EventDefinitionFactoryTests
    {
        [Test]
        public void RequirementFactory_Creates_GoldAtLeast_From_Count_Or_Gold_Field()
        {
            EventRequirementBase countRequirement = EventRequirementFactory.Create(
                "GoldAtLeast",
                JObject.Parse(@"{ ""Count"": 35 }"));
            EventRequirementBase goldRequirement = EventRequirementFactory.Create(
                "GoldAtLeast",
                JObject.Parse(@"{ ""Gold"": 21 }"));

            Assert.That(countRequirement, Is.TypeOf<GoldAtLeastRequirement>());
            Assert.That(((GoldAtLeastParam)countRequirement.Param).Gold, Is.EqualTo(35));
            Assert.That(goldRequirement, Is.TypeOf<GoldAtLeastRequirement>());
            Assert.That(((GoldAtLeastParam)goldRequirement.Param).Gold, Is.EqualTo(21));
        }

        [Test]
        public void RequirementFactory_Creates_Component_And_Relic_Requirements_With_Expected_Params()
        {
            EventRequirementBase compRequirement = EventRequirementFactory.Create(
                "CompCountAtLeast",
                JObject.Parse(@"{ ""Count"": 2, ""Rarity"": ""Blue"" }"));
            EventRequirementBase relicRequirement = EventRequirementFactory.Create(
                "HasRelic",
                JObject.Parse(@"{ ""Id"": 9001 }"));

            Assert.That(compRequirement, Is.TypeOf<CompCountAtLeastRequirement>());
            CompCountAtLeastParam compParam = (CompCountAtLeastParam)compRequirement.Param;
            Assert.That(compParam.Count, Is.EqualTo(2));
            Assert.That(compParam.Rarity, Is.EqualTo(RarityType.Blue));

            Assert.That(relicRequirement, Is.TypeOf<HasRelicRequirement>());
            Assert.That(((HasRelicParam)relicRequirement.Param).RelicId, Is.EqualTo(9001));
        }

        [Test]
        public void EffectFactory_Creates_AddGold_And_Component_Effects_With_Probability()
        {
            EventEffectBase addGoldEffect = EventEffectFactory.Create(
                "AddGold",
                JObject.Parse(@"{ ""Count"": 80 }"),
                0.75f);
            EventEffectBase addRandomCompEffect = EventEffectFactory.Create(
                "AddRandomComps",
                JObject.Parse(@"{ ""Count"": 1, ""Rarity"": ""Purple"" }"),
                0.5f);
            EventEffectBase removeRandomCompEffect = EventEffectFactory.Create(
                "RemoveRandomComps",
                JObject.Parse(@"{ ""Count"": 2, ""Rarity"": ""Blue"" }"),
                0.25f);

            Assert.That(addGoldEffect, Is.TypeOf<AddGoldEffect>());
            Assert.That(((AddGoldParam)addGoldEffect.Param).Count, Is.EqualTo(80));
            Assert.That(addGoldEffect.Probability, Is.EqualTo(0.75f));

            Assert.That(addRandomCompEffect, Is.TypeOf<AddRandomCompsEffect>());
            AddRandomCompsParam addParam = (AddRandomCompsParam)addRandomCompEffect.Param;
            Assert.That(addParam.Count, Is.EqualTo(1));
            Assert.That(addParam.Rarity, Is.EqualTo(RarityType.Purple));
            Assert.That(addRandomCompEffect.Probability, Is.EqualTo(0.5f));

            Assert.That(removeRandomCompEffect, Is.TypeOf<RemoveRandomCompsEffect>());
            RemoveRandomCompsParam removeParam = (RemoveRandomCompsParam)removeRandomCompEffect.Param;
            Assert.That(removeParam.Count, Is.EqualTo(2));
            Assert.That(removeParam.Rarity, Is.EqualTo(RarityType.Blue));
            Assert.That(removeRandomCompEffect.Probability, Is.EqualTo(0.25f));
        }

        [Test]
        public void EffectFactory_Creates_AddRandomComponents_With_Ranged_Rarity()
        {
            EventEffectBase effect = EventEffectFactory.Create(
                "AddRandomComps",
                JObject.Parse(@"{ ""Count"": 1, ""MinRarity"": ""Green"", ""MaxRarity"": ""Blue"" }"),
                0.6f);

            Assert.That(effect, Is.TypeOf<AddRandomCompsEffect>());
            AddRandomCompsParam param = (AddRandomCompsParam)effect.Param;
            Assert.That(param.Count, Is.EqualTo(1));
            Assert.That(param.MinRarity, Is.EqualTo(RarityType.Green));
            Assert.That(param.MaxRarity, Is.EqualTo(RarityType.Blue));
            Assert.That(param.Rarity, Is.EqualTo(RarityType.None));
            Assert.That(effect.Probability, Is.EqualTo(0.6f));
        }

        [Test]
        public void EffectFactory_Throws_When_Ranged_Rarity_Config_Is_Incomplete()
        {
            Assert.That(
                () => EventEffectFactory.Create(
                    "AddRandomComps",
                    JObject.Parse(@"{ ""Count"": 1, ""MinRarity"": ""Green"" }")),
                Throws.TypeOf<System.InvalidOperationException>());
        }

        [Test]
        public void EffectFactory_Creates_DamageRandomTowerEnduranceEffect_With_Expected_Params()
        {
            EventEffectBase effect = EventEffectFactory.Create(
                "DamageRandomTowersEndurance",
                JObject.Parse(@"{ ""Count"": 3, ""Amount"": 15 }"),
                0.4f);

            Assert.That(effect, Is.TypeOf<DamageRandomTowerEnduranceEffect>());
            DamageRandomTowerEnduranceParam param = (DamageRandomTowerEnduranceParam)effect.Param;
            Assert.That(param.Count, Is.EqualTo(3));
            Assert.That(param.Amount, Is.EqualTo(15));
            Assert.That(effect.Probability, Is.EqualTo(0.4f));
        }

        [Test]
        public void Factories_Return_Null_For_Unsupported_Or_Empty_Type()
        {
            Assert.That(EventRequirementFactory.Create(string.Empty, JObject.Parse("{}")), Is.Null);
            Assert.That(EventRequirementFactory.Create("UnknownRequirement", JObject.Parse("{}")), Is.Null);
            Assert.That(EventEffectFactory.Create(string.Empty, JObject.Parse("{}")), Is.Null);
            Assert.That(EventEffectFactory.Create("UnknownEffect", JObject.Parse("{}")), Is.Null);
        }

        [Test]
        public void DREvent_ParseDataRow_Builds_OptionsRaw_From_Four_Columns()
        {
            DREvent row = new DREvent();
            bool parsed = row.ParseDataRow(
                "\t1\t\t测试事件\t测试描述\t{\"optionText\":\"选项一\",\"rewardEffects\":[]}\t{\"optionText\":\"选项二\",\"rewardEffects\":[]}\t\t",
                null);

            Assert.That(parsed, Is.True);
            JArray options = JArray.Parse(row.OptionsRaw);
            Assert.That(options.Count, Is.EqualTo(2));
            Assert.That(options[0].Value<string>("optionText"), Is.EqualTo("选项一"));
            Assert.That(options[1].Value<string>("optionText"), Is.EqualTo("选项二"));
        }
    }
}