com.wallstop-studios.unity-helpers 2.0.3 → 2.1.0

package/Tests/Runtime/Tags/AttributeTests.cs

@@ -0,0 +1,192 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags
+{
+    using System;
+    using NUnit.Framework;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Tags;
+    using Attribute = WallstopStudios.UnityHelpers.Tags.Attribute;
+
+    [TestFixture]
+    public sealed class AttributeTests : AttributeTagsTestBase
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            ResetEffectHandleId();
+        }
+
+        [Test]
+        public void CurrentValueReflectsBaseValueWhenUnmodified()
+        {
+            Attribute attribute = new(12f);
+            Assert.AreEqual(12f, attribute.CurrentValue);
+            Assert.AreEqual(12f, attribute.BaseValue);
+        }
+
+        [Test]
+        public void ApplyAttributeModificationWithoutHandleMutatesBase()
+        {
+            Attribute attribute = new(10f);
+            AttributeModification modification = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 5f,
+            };
+
+            attribute.ApplyAttributeModification(modification);
+            Assert.AreEqual(15f, attribute.BaseValue);
+            Assert.AreEqual(15f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void ApplyAndRemoveAttributeModificationWithHandleRecalculates()
+        {
+            Attribute attribute = new(100f);
+            AttributeModification addition = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 25f,
+            };
+
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.name = "Buff";
+            EffectHandle handle = EffectHandle.CreateInstance(effect);
+
+            attribute.ApplyAttributeModification(addition, handle);
+            Assert.AreEqual(125f, attribute.CurrentValue);
+            Assert.AreEqual(100f, attribute.BaseValue);
+
+            bool removed = attribute.RemoveAttributeModification(handle);
+            Assert.IsTrue(removed);
+            Assert.AreEqual(100f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void ApplyAttributeModificationWithMultiplicationExecutesInOrder()
+        {
+            Attribute attribute = new(10f);
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.name = "Stacking";
+            EffectHandle handle = EffectHandle.CreateInstance(effect);
+
+            attribute.ApplyAttributeModification(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Addition,
+                    value = 5f,
+                },
+                handle
+            );
+            attribute.ApplyAttributeModification(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Multiplication,
+                    value = 2f,
+                },
+                handle
+            );
+
+            Assert.AreEqual(30f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void AttributeEqualsSupportsFloatComparisons()
+        {
+            Attribute attribute = new(7.25f);
+            Assert.IsTrue(attribute.Equals(7.25f));
+            Assert.IsTrue(attribute.Equals((double)7.25f));
+            Assert.IsFalse(attribute.Equals(7.5f));
+            Assert.AreEqual("7.25", attribute.ToString());
+        }
+
+        [Test]
+        public void ClearCacheForcesRecalculation()
+        {
+            Attribute attribute = new(10f);
+            AttributeModification addition = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 5f,
+            };
+
+            attribute.ApplyAttributeModification(addition);
+            Assert.AreEqual(15f, attribute.CurrentValue);
+
+            attribute.ClearCache();
+            Assert.AreEqual(15f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void AddProducesHandleAndAppliesAddition()
+        {
+            Attribute attribute = new(10f);
+
+            EffectHandle handle = attribute.Add(5f);
+            Assert.AreEqual(15f, attribute.CurrentValue);
+            Assert.AreEqual(1L, handle.id);
+
+            bool removed = attribute.RemoveAttributeModification(handle);
+            Assert.IsTrue(removed);
+            Assert.AreEqual(10f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void SubtractStacksAsNegativeAddition()
+        {
+            Attribute attribute = new(20f);
+
+            EffectHandle addition = attribute.Add(5f);
+            EffectHandle subtraction = attribute.Subtract(8f);
+            EffectHandle multiplier = attribute.Multiply(2f);
+
+            Assert.AreEqual(34f, attribute.CurrentValue);
+
+            bool subtractionRemoved = attribute.RemoveAttributeModification(subtraction);
+            Assert.IsTrue(subtractionRemoved);
+            Assert.AreEqual(50f, attribute.CurrentValue);
+
+            attribute.RemoveAttributeModification(addition);
+            attribute.RemoveAttributeModification(multiplier);
+        }
+
+        [Test]
+        public void DivideAppliesReciprocalMultiplication()
+        {
+            Attribute attribute = new(12f);
+
+            EffectHandle addition = attribute.Add(6f);
+            EffectHandle division = attribute.Divide(3f);
+
+            Assert.AreEqual(6f, attribute.CurrentValue);
+
+            bool divisionRemoved = attribute.RemoveAttributeModification(division);
+            Assert.IsTrue(divisionRemoved);
+            Assert.AreEqual(18f, attribute.CurrentValue);
+
+            attribute.RemoveAttributeModification(addition);
+        }
+
+        [Test]
+        public void DivideThrowsWhenValueIsZero()
+        {
+            Attribute attribute = new(10f);
+            Assert.Throws<ArgumentException>(() => attribute.Divide(0f));
+        }
+
+        [Test]
+        public void ArithmeticHelpersThrowWhenValueIsNotFinite()
+        {
+            Attribute attribute = new(5f);
+
+            Assert.Throws<ArgumentException>(() => attribute.Add(float.NaN));
+            Assert.Throws<ArgumentException>(() => attribute.Subtract(float.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => attribute.Multiply(float.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => attribute.Divide(float.PositiveInfinity));
+        }
+    }
+}

package/Tests/Runtime/Tags/AttributeTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6cef49ba760748098e3c1fc18a7b1142
+timeCreated: 1761249381

package/Tests/Runtime/Tags/AttributeUtilitiesTests.cs

@@ -80,6 +80,112 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
             Assert.IsTrue(entity.HasAnyTag(list));
         }
 
+        [UnityTest]
+        public IEnumerator GetActiveTagsExtensionHandlesBuffers()
+        {
+            GameObject entity = CreateTrackedGameObject("Tagged", typeof(TagHandler));
+            yield return null;
+            TagHandler handler = entity.GetComponent<TagHandler>();
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Shield");
+
+            List<string> initial = entity.GetActiveTags();
+            CollectionAssert.AreEquivalent(new[] { "Buff", "Shield" }, initial);
+
+            List<string> reusable = new() { "Sentinel" };
+            List<string> reused = entity.GetActiveTags(reusable);
+            Assert.AreSame(reusable, reused);
+            CollectionAssert.AreEquivalent(new[] { "Buff", "Shield" }, reused);
+            Assert.IsFalse(reused.Contains("Sentinel"));
+        }
+
+        [UnityTest]
+        public IEnumerator GetHandlesWithTagExtensionCreatesBuffers()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            yield return null;
+            EffectHandler effectHandler = entity.GetComponent<EffectHandler>();
+
+            AttributeEffect effect = CreateEffect(
+                "Buff",
+                e =>
+                {
+                    e.effectTags.Add("Buff");
+                }
+            );
+            EffectHandle handle = effectHandler.ApplyEffect(effect).Value;
+
+            List<EffectHandle> handles = entity.GetHandlesWithTag("Buff");
+            Assert.AreEqual(1, handles.Count);
+            Assert.AreEqual(handle, handles[0]);
+
+            List<EffectHandle> reusable = new() { EffectHandle.CreateInstance(effect) };
+            List<EffectHandle> reused = entity.GetHandlesWithTag("Buff", reusable);
+            Assert.AreSame(reusable, reused);
+            Assert.AreEqual(1, reused.Count);
+            Assert.AreEqual(handle, reused[0]);
+        }
+
+        [Test]
+        public void AttributeEffectQueryHelpersReturnExpectedResults()
+        {
+            AttributeEffect effect = CreateEffect(
+                "Query",
+                e =>
+                {
+                    e.effectTags.Add("Buff");
+                    e.effectTags.Add("Shield");
+                    e.modifications.Add(
+                        new AttributeModification
+                        {
+                            attribute = nameof(TestAttributesComponent.health),
+                            action = ModificationAction.Addition,
+                            value = 5f,
+                        }
+                    );
+                    e.modifications.Add(
+                        new AttributeModification
+                        {
+                            attribute = nameof(TestAttributesComponent.armor),
+                            action = ModificationAction.Addition,
+                            value = 3f,
+                        }
+                    );
+                    e.modifications.Add(
+                        new AttributeModification
+                        {
+                            attribute = nameof(TestAttributesComponent.health),
+                            action = ModificationAction.Multiplication,
+                            value = 1.1f,
+                        }
+                    );
+                }
+            );
+
+            Assert.IsTrue(effect.HasTag("Buff"));
+            Assert.IsFalse(effect.HasTag("Missing"));
+
+            HashSet<string> query = new() { "Missing", "Shield" };
+            Assert.IsTrue(effect.HasAnyTag(query));
+            IReadOnlyList<string> list = new List<string> { "Other", "Buff" };
+            Assert.IsTrue(effect.HasAnyTag(list));
+            List<string> none = new() { "Missing" };
+            Assert.IsFalse(effect.HasAnyTag(none));
+
+            Assert.IsTrue(effect.ModifiesAttribute(nameof(TestAttributesComponent.health)));
+            Assert.IsTrue(effect.ModifiesAttribute(nameof(TestAttributesComponent.armor)));
+            Assert.IsFalse(effect.ModifiesAttribute("Speed"));
+
+            List<AttributeModification> buffer = new();
+            effect.GetModifications(nameof(TestAttributesComponent.health), buffer);
+            Assert.AreEqual(2, buffer.Count);
+            Assert.AreEqual(nameof(TestAttributesComponent.health), buffer[0].attribute);
+            Assert.AreEqual(nameof(TestAttributesComponent.health), buffer[1].attribute);
+
+            effect.GetModifications("Speed", buffer);
+            Assert.AreEqual(0, buffer.Count);
+        }
+
         [UnityTest]
         public IEnumerator ApplyEffectAddsAttributesCosmeticsAndTags()
         {
@@ -370,6 +476,145 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
             Assert.IsFalse(entity.HasTag("Buff"));
         }
 
+        [UnityTest]
+        public IEnumerator ExtensionHelpersBridgeTagAndEffectQueries()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            yield return null;
+
+            AttributeEffect effect = CreateEffect(
+                "Utility",
+                e =>
+                {
+                    e.duration = 0.3f;
+                    e.resetDurationOnReapplication = true;
+                    e.effectTags.Add("Buff");
+                    e.modifications.Add(
+                        new AttributeModification
+                        {
+                            attribute = nameof(TestAttributesComponent.health),
+                            action = ModificationAction.Addition,
+                            value = 5f,
+                        }
+                    );
+                }
+            );
+
+            List<string> tagsBuffer = new();
+            List<EffectHandle> handlesBuffer = new();
+
+            Assert.IsFalse(entity.HasAllTags(new[] { "Buff" }));
+            EffectHandle? handle = entity.ApplyEffect(effect);
+            Assert.IsTrue(handle.HasValue);
+
+            Assert.IsTrue(entity.HasAllTags(new[] { "Buff" }));
+            Assert.IsFalse(entity.HasAllTags(new[] { "Buff", "Missing" }));
+            Assert.IsTrue(entity.HasNoneOfTags(new[] { "Missing" }));
+            List<string> none = new() { "Buff" };
+            Assert.IsFalse(entity.HasNoneOfTags(none));
+
+            Assert.IsTrue(entity.TryGetTagCount("Buff", out int tagCount));
+            Assert.AreEqual(1, tagCount);
+
+            Assert.AreNotEqual(0, entity.GetActiveTags(tagsBuffer).Count);
+            CollectionAssert.Contains(tagsBuffer, "Buff");
+
+            Assert.AreNotEqual(0, entity.GetHandlesWithTag("Buff", handlesBuffer).Count);
+            Assert.AreEqual(1, handlesBuffer.Count);
+
+            Assert.IsTrue(entity.IsEffectActive(effect));
+            Assert.AreEqual(1, entity.GetEffectStackCount(effect));
+
+            List<EffectHandle> activeEffects = entity.GetActiveEffects(new List<EffectHandle>());
+            Assert.AreEqual(1, activeEffects.Count);
+
+            EffectHandle activeHandle = handlesBuffer[0];
+            Assert.IsTrue(entity.TryGetRemainingDuration(activeHandle, out float remaining));
+            Assert.Greater(remaining, 0f);
+
+            yield return null;
+            Assert.IsTrue(entity.TryGetRemainingDuration(activeHandle, out float beforeEnsure));
+
+            EffectHandle? ensured = entity.EnsureHandle(effect);
+            Assert.IsTrue(ensured.HasValue);
+            Assert.AreEqual(activeHandle, ensured.Value);
+            Assert.IsTrue(entity.TryGetRemainingDuration(activeHandle, out float afterEnsure));
+            Assert.Greater(afterEnsure, beforeEnsure);
+
+            yield return null;
+            Assert.IsTrue(entity.TryGetRemainingDuration(activeHandle, out float beforeNoRefresh));
+            EffectHandle? ensuredNoRefresh = entity.EnsureHandle(effect, refreshDuration: false);
+            Assert.IsTrue(ensuredNoRefresh.HasValue);
+            Assert.AreEqual(activeHandle, ensuredNoRefresh.Value);
+            Assert.IsTrue(entity.TryGetRemainingDuration(activeHandle, out float afterNoRefresh));
+            Assert.LessOrEqual(afterNoRefresh, beforeNoRefresh);
+
+            Assert.IsTrue(entity.RefreshEffect(activeHandle));
+
+            entity.RemoveAllEffects();
+            tagsBuffer.Clear();
+            Assert.AreEqual(0, entity.GetActiveTags(tagsBuffer).Count);
+            Assert.IsEmpty(tagsBuffer);
+            handlesBuffer.Clear();
+            Assert.AreEqual(0, entity.GetHandlesWithTag("Buff", handlesBuffer).Count);
+        }
+
+        [UnityTest]
+        public IEnumerator ApplyEffectsNoAllocAppendsToProvidedHandlesBuffer()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            yield return null;
+
+            List<AttributeEffect> effects = new() { CreateEffect("BuffA"), CreateEffect("BuffB") };
+
+            EffectHandle sentinel = EffectHandle.CreateInstance(CreateEffect("Sentinel"));
+            List<EffectHandle> handles = new() { sentinel };
+            entity.ApplyEffectsNoAlloc(effects, handles);
+
+            Assert.AreEqual(effects.Count + 1, handles.Count);
+            Assert.AreEqual(sentinel, handles[0]);
+        }
+
+        [UnityTest]
+        public IEnumerator GetActiveEffectsClearsBufferBeforePopulation()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            yield return null;
+            EffectHandler handler = entity.GetComponent<EffectHandler>();
+
+            AttributeEffect effect = CreateEffect("Tracked");
+            EffectHandle handle = handler.ApplyEffect(effect).Value;
+
+            EffectHandle sentinel = EffectHandle.CreateInstance(CreateEffect("Sentinel"));
+            List<EffectHandle> buffer = new() { sentinel };
+            List<EffectHandle> populated = entity.GetActiveEffects(buffer);
+            Assert.AreSame(buffer, populated);
+            Assert.AreEqual(1, populated.Count);
+            Assert.AreEqual(handle, populated[0]);
+            Assert.AreNotEqual(sentinel, populated[0]);
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator RefreshEffectIgnorePolicyExtensionRefreshesWhenDisallowed()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            yield return null;
+            AttributeEffect effect = CreateEffect(
+                "Policy",
+                e =>
+                {
+                    e.duration = 0.2f;
+                    e.resetDurationOnReapplication = false;
+                }
+            );
+
+            EffectHandle handle = entity.ApplyEffect(effect).Value;
+            yield return null;
+            Assert.IsFalse(entity.RefreshEffect(handle));
+            Assert.IsTrue(entity.RefreshEffect(handle, ignoreReapplicationPolicy: true));
+        }
+
         [UnityTest]
         public IEnumerator ApplyEffectsNoAllocSkipsNullTarget()
         {

package/Tests/Runtime/Tags/CosmeticAndCollisionTests.cs

@@ -111,7 +111,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
             yield return null;
             Assert.IsFalse(collider.enabled);
 
-            handler.RemoveTag(CollisionSenses.CollisionDisabledTag, allInstances: false);
+            handler.RemoveTag(CollisionSenses.CollisionDisabledTag);
             yield return null;
             Assert.IsTrue(collider.enabled);
         }

package/Tests/Runtime/Tags/EffectBehaviorTests.cs

@@ -0,0 +1,184 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags
+{
+    using System.Collections;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+    using WallstopStudios.UnityHelpers.Tags;
+    using WallstopStudios.UnityHelpers.Tests.Tags.Helpers;
+
+    [TestFixture]
+    public sealed class EffectBehaviorTests : TagsTestBase
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            ResetEffectHandleId();
+            RecordingEffectBehavior.Reset();
+        }
+
+        [UnityTest]
+        public IEnumerator LifecycleCallbacksProvideContextData()
+        {
+            (GameObject entity, EffectHandler handler, _, _) = CreateEntity();
+
+            PeriodicEffectDefinition periodicDefinition = new()
+            {
+                name = "Pulse",
+                initialDelay = 0f,
+                interval = 0.05f,
+                maxTicks = 1,
+            };
+
+            AttributeEffect effect = CreateEffect(
+                "Lifecycle",
+                e =>
+                {
+                    e.periodicEffects.Add(periodicDefinition);
+                }
+            );
+
+            RecordingEffectBehavior behavior = Track(
+                ScriptableObject.CreateInstance<RecordingEffectBehavior>()
+            );
+            effect.behaviors.Add(behavior);
+
+            EffectHandle handle = handler.ApplyEffect(effect).Value;
+            Assert.AreEqual(1, RecordingEffectBehavior.ApplyCount);
+            Assert.AreEqual(
+                1,
+                RecordingEffectBehavior.ApplyContexts.Count,
+                "OnApply should fire immediately."
+            );
+
+            yield return null;
+            yield return null;
+
+            Assert.IsNotEmpty(
+                RecordingEffectBehavior.TickContexts,
+                "OnTick should run after Update."
+            );
+
+            yield return new WaitForSeconds(0.08f);
+
+            Assert.AreEqual(
+                1,
+                RecordingEffectBehavior.PeriodicInvocations.Count,
+                "Expected one periodic tick."
+            );
+
+            int removeCountBefore = RecordingEffectBehavior.RemoveCount;
+            handler.RemoveEffect(handle);
+            Assert.AreEqual(removeCountBefore + 1, RecordingEffectBehavior.RemoveCount);
+            Assert.AreEqual(
+                1,
+                RecordingEffectBehavior.RemoveContexts.Count,
+                "OnRemove should fire once."
+            );
+
+            EffectBehaviorContext applyContext = RecordingEffectBehavior.ApplyContexts[0];
+            Assert.AreSame(handler, applyContext.handler);
+            Assert.AreSame(entity, applyContext.Target);
+            Assert.AreEqual(effect, applyContext.Effect);
+            Assert.AreEqual(0f, applyContext.deltaTime);
+
+            EffectBehaviorContext tickContext = RecordingEffectBehavior.TickContexts[0];
+            Assert.AreSame(handler, tickContext.handler);
+            Assert.AreSame(entity, tickContext.Target);
+            Assert.AreEqual(effect, tickContext.Effect);
+            Assert.Greater(tickContext.deltaTime, 0f);
+
+            RecordingEffectBehavior.PeriodicInvocation periodicInvocation =
+                RecordingEffectBehavior.PeriodicInvocations[0];
+            Assert.AreSame(handler, periodicInvocation.Context.handler);
+            Assert.AreSame(entity, periodicInvocation.Context.Target);
+            Assert.AreEqual(effect, periodicInvocation.Context.Effect);
+            Assert.Greater(periodicInvocation.Context.deltaTime, 0f);
+            Assert.AreSame(periodicDefinition, periodicInvocation.TickContext.definition);
+            Assert.AreEqual(1, periodicInvocation.TickContext.executedTicks);
+            Assert.GreaterOrEqual(periodicInvocation.TickContext.currentTime, 0f);
+
+            EffectBehaviorContext removeContext = RecordingEffectBehavior.RemoveContexts[0];
+            Assert.AreSame(handler, removeContext.handler);
+            Assert.AreSame(entity, removeContext.Target);
+            Assert.AreEqual(effect, removeContext.Effect);
+            Assert.AreEqual(0f, removeContext.deltaTime);
+        }
+
+        [UnityTest]
+        public IEnumerator PeriodicTickContextTracksExecutedTicksAndTime()
+        {
+            (GameObject entity, EffectHandler handler, _, _) = CreateEntity();
+
+            PeriodicEffectDefinition periodicDefinition = new()
+            {
+                name = "Stacking Pulse",
+                initialDelay = 0f,
+                interval = 0.05f,
+                maxTicks = 3,
+            };
+
+            AttributeEffect effect = CreateEffect(
+                "Periodic",
+                e =>
+                {
+                    e.periodicEffects.Add(periodicDefinition);
+                }
+            );
+
+            RecordingEffectBehavior behavior = Track(
+                ScriptableObject.CreateInstance<RecordingEffectBehavior>()
+            );
+            effect.behaviors.Add(behavior);
+
+            EffectHandle handle = handler.ApplyEffect(effect).Value;
+
+            yield return new WaitForSeconds(0.18f);
+
+            Assert.AreEqual(
+                3,
+                RecordingEffectBehavior.PeriodicInvocations.Count,
+                "Expected periodic callbacks for each executed tick."
+            );
+
+            for (int i = 0; i < RecordingEffectBehavior.PeriodicInvocations.Count; ++i)
+            {
+                RecordingEffectBehavior.PeriodicInvocation invocation =
+                    RecordingEffectBehavior.PeriodicInvocations[i];
+                Assert.AreSame(periodicDefinition, invocation.TickContext.definition);
+                Assert.AreEqual(i + 1, invocation.TickContext.executedTicks);
+                Assert.Greater(invocation.Context.deltaTime, 0f);
+
+                if (i > 0)
+                {
+                    float previousTime = RecordingEffectBehavior
+                        .PeriodicInvocations[i - 1]
+                        .TickContext
+                        .currentTime;
+                    Assert.GreaterOrEqual(invocation.TickContext.currentTime, previousTime);
+                }
+            }
+
+            handler.RemoveEffect(handle);
+        }
+
+        private (
+            GameObject entity,
+            EffectHandler handler,
+            TestAttributesComponent attributes,
+            TagHandler tags
+        ) CreateEntity()
+        {
+            GameObject entity = CreateTrackedGameObject(
+                "EffectBehaviorEntity",
+                typeof(TestAttributesComponent)
+            );
+            return (
+                entity,
+                entity.GetComponent<EffectHandler>(),
+                entity.GetComponent<TestAttributesComponent>(),
+                entity.GetComponent<TagHandler>()
+            );
+        }
+    }
+}

package/Tests/Runtime/Tags/EffectBehaviorTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 978c882cc7a7493b934680f4aef33214
+timeCreated: 1761254817