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

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/EffectHandlerTests.cs

@@ -1,6 +1,7 @@
 namespace WallstopStudios.UnityHelpers.Tests.Tags
 {
     using System.Collections;
+    using System.Collections.Generic;
     using NUnit.Framework;
     using UnityEngine;
     using UnityEngine.TestTools;
@@ -238,6 +239,196 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
             Assert.AreEqual(1, RecordingCosmeticComponent.RemovedCount);
         }
 
+        [UnityTest]
+        public IEnumerator IsEffectActiveReflectsState()
+        {
+            (
+                GameObject entity,
+                EffectHandler handler,
+                TestAttributesComponent attributes,
+                TagHandler tags
+            ) = CreateEntity();
+            yield return null;
+
+            AttributeEffect effect = CreateEffect("Buff");
+            Assert.IsFalse(handler.IsEffectActive(effect));
+
+            EffectHandle handle = handler.ApplyEffect(effect).Value;
+            Assert.IsTrue(handler.IsEffectActive(effect));
+
+            handler.RemoveEffect(handle);
+            Assert.IsFalse(handler.IsEffectActive(effect));
+        }
+
+        [UnityTest]
+        public IEnumerator GetEffectStackCountSupportsMultipleHandles()
+        {
+            (
+                GameObject entity,
+                EffectHandler handler,
+                TestAttributesComponent attributes,
+                TagHandler tags
+            ) = CreateEntity();
+            yield return null;
+
+            AttributeEffect effect = CreateEffect(
+                "Stacking",
+                e =>
+                {
+                    e.durationType = ModifierDurationType.Infinite;
+                }
+            );
+
+            EffectHandle first = handler.ApplyEffect(effect).Value;
+            EffectHandle second = handler.ApplyEffect(effect).Value;
+
+            Assert.AreEqual(2, handler.GetEffectStackCount(effect));
+
+            handler.RemoveEffect(first);
+            Assert.AreEqual(1, handler.GetEffectStackCount(effect));
+
+            handler.RemoveEffect(second);
+            Assert.AreEqual(0, handler.GetEffectStackCount(effect));
+        }
+
+        [UnityTest]
+        public IEnumerator GetActiveEffectsPopulatesBuffer()
+        {
+            (
+                GameObject entity,
+                EffectHandler handler,
+                TestAttributesComponent attributes,
+                TagHandler tags
+            ) = CreateEntity();
+            yield return null;
+
+            AttributeEffect effect = CreateEffect(
+                "Active",
+                e =>
+                {
+                    e.durationType = ModifierDurationType.Infinite;
+                }
+            );
+
+            EffectHandle first = handler.ApplyEffect(effect).Value;
+            EffectHandle second = handler.ApplyEffect(effect).Value;
+
+            List<EffectHandle> buffer = new();
+            handler.GetActiveEffects(buffer);
+            CollectionAssert.AreEquivalent(new[] { first, second }, buffer);
+
+            handler.RemoveEffect(first);
+            buffer.Clear();
+            handler.GetActiveEffects(buffer);
+            CollectionAssert.AreEqual(new[] { second }, buffer);
+
+            handler.RemoveEffect(second);
+        }
+
+        [UnityTest]
+        public IEnumerator TryGetRemainingDurationReportsTime()
+        {
+            (
+                GameObject entity,
+                EffectHandler handler,
+                TestAttributesComponent attributes,
+                TagHandler tags
+            ) = CreateEntity();
+            yield return null;
+
+            AttributeEffect effect = CreateEffect(
+                "Timed",
+                e =>
+                {
+                    e.duration = 0.5f;
+                }
+            );
+
+            EffectHandle handle = handler.ApplyEffect(effect).Value;
+            Assert.IsTrue(handler.TryGetRemainingDuration(handle, out float remaining));
+            Assert.Greater(remaining, 0f);
+            Assert.LessOrEqual(remaining, effect.duration);
+
+            handler.RemoveEffect(handle);
+            Assert.IsFalse(handler.TryGetRemainingDuration(handle, out float afterRemoval));
+            Assert.AreEqual(0f, afterRemoval);
+        }
+
+        [UnityTest]
+        public IEnumerator EnsureHandleRefreshesDurationWhenRequested()
+        {
+            (
+                GameObject entity,
+                EffectHandler handler,
+                TestAttributesComponent attributes,
+                TagHandler tags
+            ) = CreateEntity();
+            yield return null;
+
+            AttributeEffect effect = CreateEffect(
+                "Refreshable",
+                e =>
+                {
+                    e.duration = 0.2f;
+                    e.resetDurationOnReapplication = true;
+                }
+            );
+
+            EffectHandle handle = handler.ApplyEffect(effect).Value;
+            Assert.IsTrue(handler.TryGetRemainingDuration(handle, out float initialRemaining));
+            yield return null;
+            Assert.IsTrue(handler.TryGetRemainingDuration(handle, out float beforeRefresh));
+            Assert.Less(beforeRefresh, initialRemaining);
+
+            EffectHandle? ensured = handler.EnsureHandle(effect);
+            Assert.IsTrue(ensured.HasValue);
+            Assert.AreEqual(handle, ensured.Value);
+            Assert.IsTrue(handler.TryGetRemainingDuration(handle, out float afterRefresh));
+            Assert.Greater(afterRefresh, beforeRefresh);
+
+            yield return null;
+            Assert.IsTrue(handler.TryGetRemainingDuration(handle, out float beforeNoRefresh));
+            EffectHandle? ensuredNoRefresh = handler.EnsureHandle(effect, refreshDuration: false);
+            Assert.IsTrue(ensuredNoRefresh.HasValue);
+            Assert.AreEqual(handle, ensuredNoRefresh.Value);
+            Assert.IsTrue(handler.TryGetRemainingDuration(handle, out float afterNoRefresh));
+            Assert.LessOrEqual(afterNoRefresh, beforeNoRefresh);
+
+            handler.RemoveEffect(handle);
+        }
+
+        [UnityTest]
+        public IEnumerator RefreshEffectHonorsReapplicationPolicy()
+        {
+            (
+                GameObject entity,
+                EffectHandler handler,
+                TestAttributesComponent attributes,
+                TagHandler tags
+            ) = CreateEntity();
+            yield return null;
+
+            AttributeEffect effect = CreateEffect(
+                "Policy",
+                e =>
+                {
+                    e.duration = 0.3f;
+                    e.resetDurationOnReapplication = false;
+                }
+            );
+
+            EffectHandle handle = handler.ApplyEffect(effect).Value;
+            yield return null;
+            Assert.IsTrue(handler.TryGetRemainingDuration(handle, out float beforeRefresh));
+
+            Assert.IsFalse(handler.RefreshEffect(handle));
+            Assert.IsTrue(handler.RefreshEffect(handle, ignoreReapplicationPolicy: true));
+            Assert.IsTrue(handler.TryGetRemainingDuration(handle, out float afterRefresh));
+            Assert.Greater(afterRefresh, beforeRefresh);
+
+            handler.RemoveEffect(handle);
+        }
+
         private (
             GameObject entity,
             EffectHandler handler,

package/Tests/Runtime/Tags/TagHandlerTests.cs

@@ -33,18 +33,19 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
 
             handler.ApplyTag("Buff");
             handler.ApplyTag("Buff");
-            handler.RemoveTag("Buff", allInstances: false);
-            handler.RemoveTag("Buff", allInstances: false);
+            handler.ApplyTag("Buff");
+            handler.RemoveTag("Buff");
 
             Assert.AreEqual(new[] { "Buff" }, added);
+            Assert.AreEqual(2, changed.Count);
             Assert.AreEqual(("Buff", 2U), changed[0]);
-            Assert.AreEqual(("Buff", 1U), changed[1]);
+            Assert.AreEqual(("Buff", 3U), changed[1]);
             Assert.AreEqual(new[] { "Buff" }, removed);
             yield return null;
         }
 
         [UnityTest]
-        public IEnumerator RemoveTagAllInstancesClearsWithoutEvents()
+        public IEnumerator RemoveTagAllInstancesClearsWithEvents()
         {
             GameObject entity = CreateTrackedGameObject("Tags", typeof(TagHandler));
             TagHandler handler = entity.GetComponent<TagHandler>();
@@ -53,10 +54,10 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
             handler.OnTagRemoved += _ => ++removedCount;
 
             handler.ApplyTag("Buff");
-            handler.RemoveTag("Buff", allInstances: true);
+            handler.RemoveTag("Buff");
 
             Assert.IsFalse(handler.HasTag("Buff"));
-            Assert.AreEqual(0, removedCount);
+            Assert.AreEqual(1, removedCount);
             yield return null;
         }
 
@@ -104,5 +105,128 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
             Assert.IsFalse(handler.ForceRemoveTags(handle));
             yield return null;
         }
+
+        [UnityTest]
+        public IEnumerator HasAllTagsAndHasNoneTagSupport()
+        {
+            GameObject entity = CreateTrackedGameObject("Tags", typeof(TagHandler));
+            TagHandler handler = entity.GetComponent<TagHandler>();
+
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Shield");
+
+            Assert.IsTrue(handler.HasAllTags(new[] { "Buff" }));
+            List<string> required = new() { "Buff", "Shield" };
+            Assert.IsTrue(handler.HasAllTags(required));
+            Assert.IsFalse(handler.HasAllTags(new[] { "Buff", "Missing" }));
+
+            List<string> none = new() { "Missing", "Other" };
+            Assert.IsTrue(handler.HasNoneOfTags(none));
+            none[1] = "Buff";
+            Assert.IsFalse(handler.HasNoneOfTags(none));
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator TryGetTagCountAndActiveTagsPopulateBuffer()
+        {
+            GameObject entity = CreateTrackedGameObject("Tags", typeof(TagHandler));
+            TagHandler handler = entity.GetComponent<TagHandler>();
+
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Shield");
+
+            Assert.IsTrue(handler.TryGetTagCount("Buff", out int buffCount));
+            Assert.AreEqual(2, buffCount);
+            Assert.IsFalse(handler.TryGetTagCount("Missing", out int missingCount));
+            Assert.AreEqual(0, missingCount);
+
+            List<string> active = new();
+            handler.GetActiveTags(active);
+            CollectionAssert.AreEquivalent(new[] { "Buff", "Shield" }, active);
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator GetHandlesWithTagTracksHandleLifecycle()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            TagHandler handler = entity.GetComponent<TagHandler>();
+            EffectHandler effectHandler = entity.GetComponent<EffectHandler>();
+
+            AttributeEffect effect = CreateEffect(
+                "Buff",
+                e =>
+                {
+                    e.effectTags.Add("Buff");
+                }
+            );
+            EffectHandle handle = effectHandler.ApplyEffect(effect).Value;
+
+            List<EffectHandle> handles = new();
+            Assert.AreNotEqual(0, handler.GetHandlesWithTag("Buff", handles).Count);
+            Assert.AreEqual(1, handles.Count);
+            Assert.AreEqual(handle, handles[0]);
+
+            handles.Clear();
+            handler.RemoveTag("Buff");
+            Assert.AreEqual(0, handler.GetHandlesWithTag("Buff", handles).Count);
+
+            handles.Clear();
+            effectHandler.RemoveEffect(handle);
+            Assert.AreEqual(0, handler.GetHandlesWithTag("Buff", handles).Count);
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator GetActiveTagsReturnsNewBufferWhenNeeded()
+        {
+            GameObject entity = CreateTrackedGameObject("Tags", typeof(TagHandler));
+            TagHandler handler = entity.GetComponent<TagHandler>();
+
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Shield");
+
+            List<string> firstCall = handler.GetActiveTags();
+            Assert.IsNotNull(firstCall);
+            CollectionAssert.AreEquivalent(new[] { "Buff", "Shield" }, firstCall);
+
+            List<string> reusable = new() { "Sentinel" };
+            List<string> secondCall = handler.GetActiveTags(reusable);
+            Assert.AreSame(reusable, secondCall);
+            CollectionAssert.AreEquivalent(new[] { "Buff", "Shield" }, secondCall);
+            Assert.IsFalse(secondCall.Contains("Sentinel"));
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator RemoveTagReturnsContributingHandles()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            yield return null;
+            TagHandler handler = entity.GetComponent<TagHandler>();
+            EffectHandler effectHandler = entity.GetComponent<EffectHandler>();
+
+            AttributeEffect effect = CreateEffect(
+                "Buff",
+                e =>
+                {
+                    e.effectTags.Add("Buff");
+                }
+            );
+            EffectHandle handle = effectHandler.ApplyEffect(effect).Value;
+
+            List<EffectHandle> removed = handler.RemoveTag("Buff");
+            Assert.AreEqual(1, removed.Count);
+            Assert.AreEqual(handle, removed[0]);
+            Assert.IsFalse(handler.HasTag("Buff"));
+            Assert.AreEqual(0, handler.GetHandlesWithTag("Buff").Count);
+
+            List<EffectHandle> empty = handler.RemoveTag("Missing");
+            Assert.IsNotNull(empty);
+            Assert.AreEqual(0, empty.Count);
+            yield return null;
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},