com.fofx.observething 1.0.0

package/Tests/CollectionObservableTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 62a831dcf935dd84f897290af875a1db

package/Tests/DictionaryObservableTests.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine.TestTools;
+
+namespace ObserveThing.Tests
+{
+    public class DictionaryObservableTests
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            Settings.DefaultExceptionHandler = UnityEngine.Debug.LogException;
+        }
+
+        [Test]
+        public void TestTrack()
+        {
+            int callCount = 0;
+            (bool keyPresent, string value) value = default;
+            Exception exception = default;
+            bool disposed = false;
+
+            ObservableDictionary<int, string> dict = new ObservableDictionary<int, string>();
+            ObservableValue<int> key = new ObservableValue<int>();
+
+            dict.ObservableTrack(key).Subscribe(
+                x =>
+                {
+                    callCount++;
+                    value = x;
+                },
+                exc => exception = exc,
+                () => disposed = true
+            );
+
+            Assert.AreEqual(1, callCount);
+            Assert.AreEqual(false, value.keyPresent);
+            Assert.AreEqual(default, value.value);
+
+            dict.Add(2, "cat");
+
+            Assert.AreEqual(1, callCount);
+            Assert.AreEqual(false, value.keyPresent);
+            Assert.AreEqual(default, value.value);
+
+            key.value = 2;
+
+            Assert.AreEqual(2, callCount);
+            Assert.AreEqual(true, value.keyPresent);
+            Assert.AreEqual("cat", value.value);
+
+            dict.Remove(2);
+
+            Assert.AreEqual(3, callCount);
+            Assert.AreEqual(false, value.keyPresent);
+            Assert.AreEqual(default, value.value);
+
+            dict.Remove(40);
+
+            Assert.AreEqual(3, callCount);
+            Assert.AreEqual(false, value.keyPresent);
+            Assert.AreEqual(default, value.value);
+
+            dict.Add(2, "dog");
+
+            Assert.AreEqual(4, callCount);
+            Assert.AreEqual(true, value.keyPresent);
+            Assert.AreEqual("dog", value.value);
+
+            // var exc = new Exception();
+            // dict.OnError(exc);
+            // Assert.AreEqual(exc, exception);
+
+            // var keyProviderExc = new Exception();
+            // dict.OnError(keyProviderExc);
+            // Assert.AreEqual(keyProviderExc, exception);
+
+            dict.Dispose();
+            Assert.IsTrue(disposed);
+            Assert.Throws(typeof(ObjectDisposedException), () => dict.Add(100, "me"));
+            Assert.AreEqual(4, callCount);
+        }
+    }
+}

package/Tests/DictionaryObservableTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a94e77255360f7147bf014722956e332

package/Tests/ListObservableTests.cs

@@ -0,0 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ObserveThing.Tests
+{
+    public class ListObservableTests
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            Settings.DefaultExceptionHandler = UnityEngine.Debug.LogException;
+        }
+
+        [Test]
+        public void TestSelect()
+        {
+            var result = new List<string>();
+            var list = new ObservableList<int>();
+            bool disposed = false;
+            bool receivedCall = false;
+            var select = list.ObservableSelect(x => x.ToString()).Subscribe(
+                onAdd: (index, value) =>
+                {
+                    result.Insert(index, value);
+                    receivedCall = true;
+                },
+                onRemove: (index, value) =>
+                {
+                    result.RemoveAt(index);
+                    receivedCall = true;
+                },
+                onDispose: () => disposed = true
+            );
+
+            list.Add(1);
+            list.Add(1);
+            list.Add(2);
+            list.Add(3);
+            list.Add(4);
+            list.Add(45);
+
+            Assert.AreEqual(
+                Enumerable.Select(list, x => x.ToString()),
+                result
+            );
+
+            list.Remove(3);
+            list.Remove(3);
+            list.Add(1);
+            list.Add(45);
+            list.Remove(45);
+
+            Assert.AreEqual(
+                Enumerable.Select(list, x => x.ToString()),
+                result
+            );
+
+            list.Clear();
+
+            Assert.AreEqual(
+                Enumerable.Select(list, x => x.ToString()),
+                result
+            );
+
+            receivedCall = false;
+            select.Dispose();
+            Assert.IsTrue(disposed);
+            list.Add(100);
+            Assert.IsFalse(receivedCall);
+        }
+
+        [Test]
+        public void TestShallowCopy()
+        {
+            var list = new ObservableList<ObservableValue<int>>();
+            var result = new List<string>();
+            bool disposed = false;
+            bool receivedCall = false;
+            var stream = list.ObservableSelect(x => x.ObservableSelect(x => x.ToString())).Subscribe(
+                onAdd: (index, x) =>
+                {
+                    result.Insert(index, x);
+                    receivedCall = true;
+                },
+                onRemove: (index, x) =>
+                {
+                    result.RemoveAt(index);
+                    receivedCall = true;
+                },
+                onDispose: () => disposed = true
+            );
+
+            var element1 = new ObservableValue<int>(2);
+            var element2 = new ObservableValue<int>(3);
+            var element3 = new ObservableValue<int>(45);
+            var element4 = new ObservableValue<int>(11);
+
+            list.Add(element1);
+            list.Add(element2);
+            list.Add(element3);
+            list.Add(element4);
+
+            Assert.AreEqual(
+                Enumerable.Select(list, x => x.value.ToString()),
+                result
+            );
+
+            element1.value = 3;
+            element1.value = 100;
+            element1.value = 22;
+            element1.value = 6;
+
+            Assert.AreEqual(
+                Enumerable.Select(list, x => x.value.ToString()),
+                result
+            );
+
+            element2.value = 3;
+            element3.value = 3;
+            element4.value = 3;
+
+            Assert.AreEqual(
+                Enumerable.Select(list, x => x.value.ToString()),
+                result
+            );
+
+            list.Remove(element2);
+            list.Add(element3);
+
+            element2.value = 5;
+            element3.value = 100;
+            element3.value = 50;
+
+            Assert.AreEqual(
+                Enumerable.Select(list, x => x.value.ToString()),
+                result
+            );
+
+            receivedCall = false;
+            stream.Dispose();
+            Assert.IsTrue(disposed);
+            list.Add(new ObservableValue<int>(150));
+            Assert.IsFalse(receivedCall);
+        }
+    }
+}

package/Tests/ListObservableTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f882eb52ecddecd4e9796cdd37447b08

package/Tests/ObservationContextTests.cs

@@ -0,0 +1,359 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace ObserveThing.Tests
+{
+    public class ObservationContextTests
+    {
+        [Test]
+        public void TestOperationOrder()
+        {
+            var context = new ObservationContext();
+
+            ObservableValue<int> intObservable = new ObservableValue<int>(context, 100);
+            ObservableValue<string> stringObservable = new ObservableValue<string>(context, "200");
+            List<(object source, object value)> operations = new List<(object source, object value)>();
+
+            int callCount = 0;
+
+            var stream = Observables.ObservableCombine(intObservable, stringObservable).Subscribe(
+                onNext: op =>
+                {
+                    callCount++;
+                    operations.Add(new(op.source, ((IValueOp)op).value));
+                }
+            );
+
+            Assert.AreEqual(2, callCount);
+            Assert.AreEqual(
+                new List<(object, object)>
+                {
+                    new(intObservable, 100),
+                    new(stringObservable, "200")
+                },
+                operations
+            );
+
+            callCount = 0;
+            operations.Clear();
+
+            context.ExecuteBatchOperation(() =>
+            {
+                intObservable.value = 1;
+                stringObservable.value = "2";
+                intObservable.value = 3;
+                intObservable.value = 4;
+                stringObservable.value = "5";
+            });
+
+            Assert.AreEqual(5, callCount);
+            Assert.AreEqual(
+                new List<(object, object)>
+                {
+                    new(intObservable, 1),
+                    new(stringObservable, "2"),
+                    new(intObservable, 3),
+                    new(intObservable, 4),
+                    new(stringObservable, "5"),
+                },
+                operations
+            );
+        }
+
+        [Test]
+        public void TestRollingObserverOrder()
+        {
+            var context = new ObservationContext();
+
+            ObservableValue<int> intObservable = new ObservableValue<int>(context);
+
+            List<(int observer, int value)> observerCallOrder = new List<(int observer, int value)>();
+
+            IDisposable subscription1 = default;
+            IDisposable subscription2 = default;
+            IDisposable subscription3 = default;
+            IDisposable subscription4 = default;
+            IDisposable subscription5 = default;
+
+            subscription1 = intObservable.Subscribe(
+                onNext: value => observerCallOrder.Add(new(1, value))
+            );
+
+            subscription2 = intObservable.Subscribe(
+                onNext: value =>
+                {
+                    observerCallOrder.Add(new(2, value));
+
+                    if (value == 1)
+                        intObservable.value = 2;
+                }
+            );
+
+            subscription3 = intObservable.Subscribe(
+                onNext: value =>
+                {
+                    observerCallOrder.Add(new(3, value));
+
+                    if (value == 2)
+                    {
+                        intObservable.value = 3;
+                        subscription4.Dispose();
+                    }
+                }
+            );
+
+            subscription4 = intObservable.Subscribe(
+                onNext: value => observerCallOrder.Add(new(4, value))
+            );
+
+            subscription5 = intObservable.Subscribe(
+                onNext: value => observerCallOrder.Add(new(5, value))
+            );
+
+            intObservable.value = 1;
+
+            Assert.AreEqual(3, intObservable.value);
+
+            Assert.AreEqual(
+                new List<(int observer, int value)>()
+                {
+                    new (1, 0), //init observer1
+                    new (2, 0), //init observer2
+                    new (3, 0), //init observer3
+                    new (4, 0), //init observer4
+                    new (5, 0), //init observer5
+                    new (1, 1), //observer1 observes external setting intObservable to 1
+                    new (2, 1), //observer2 observes external setting intObservable to 1
+                    new (1, 2), //observer1 observes observer2 setting intObservable to 2
+                    new (2, 2), //observer2 observes observer2 setting intObservable to 2
+                    new (3, 1), //observer3 observes external setting intObservable to 1
+                    new (3, 2), //observer3 observes observer2 setting intObservable to 2
+                    //4, //observer4 is never called past the init because it gets unsubscribed by observer3
+                    new (1, 3), //observer1 observes observer3 setting intObservable to 3
+                    new (2, 3), //observer2 observes observer3 setting intObservable to 3
+                    new (3, 3), //observer3 observes observer3 setting intObservable to 3
+                    new (5, 1), //observer5 observes external setting intObservable to 1
+                    new (5, 2), //observer5 observes observer2 setting intObservable to 2
+                    new (5, 3) //observer5 observes observer3 setting intObservable to 3
+                },
+                observerCallOrder
+            );
+        }
+
+        [Test]
+        public void TestCombineObservable()
+        {
+            var context = new ObservationContext();
+
+            ObservableValue<int> intObservable = new ObservableValue<int>(context);
+            ObservableValue<string> stringObservable = new ObservableValue<string>(context);
+
+            var query = Observables.ObservableCombine(intObservable, stringObservable);
+
+            List<(object source, object value)> observerCallOrder = new List<(object source, object value)>();
+
+            IDisposable subscription = query.Subscribe(
+                onNext: op =>
+                {
+                    observerCallOrder.Add(new(op.source, ((IValueOp)op).value));
+
+                    if (intObservable.value == 2)
+                    {
+                        intObservable.value = 6;
+                        intObservable.value = 7;
+                        intObservable.value = 8;
+                        stringObservable.value = "mouse";
+                    }
+                }
+            );
+
+            intObservable.value = 1;
+            stringObservable.value = "cat";
+            stringObservable.value = "dog";
+            intObservable.value = 2;
+            stringObservable.value = "frog";
+            intObservable.value = 3;
+            intObservable.value = 4;
+
+            Assert.AreEqual(
+                new List<(object source, object value)>()
+                {
+                    new(intObservable, 0),
+                    new(stringObservable, null),
+                    new(intObservable, 1),
+                    new(stringObservable, "cat"),
+                    new(stringObservable, "dog"),
+                    new(intObservable, 2),
+                    new(intObservable, 6),
+                    new(intObservable, 7),
+                    new(intObservable, 8),
+                    new(stringObservable, "mouse"),
+                    new(stringObservable, "frog"),
+                    new(intObservable, 3),
+                    new(intObservable, 4),
+                },
+                observerCallOrder
+            );
+        }
+
+        [Test]
+        public void TestAllObservablesDispose()
+        {
+            var context = new ObservationContext();
+            var observable1 = new ObservableValue<int>(context);
+            var observable2 = new ObservableValue<int>(context);
+            var disposeCallCount = 0;
+            var disposed = false;
+
+            var query = Observables.ObservableCombine(observable1, observable2);
+
+            var stream = query.Subscribe(
+                onDispose: () =>
+                {
+                    disposeCallCount++;
+                    disposed = true;
+                }
+            );
+
+            observable1.Dispose();
+
+            Assert.IsFalse(disposed);
+            Assert.AreEqual(0, disposeCallCount);
+
+            observable2.Dispose();
+
+            Assert.IsTrue(disposed);
+            Assert.AreEqual(1, disposeCallCount);
+
+            disposeCallCount = 0;
+            disposed = false;
+
+            Assert.Throws(
+                typeof(ObjectDisposedException),
+                () => query.Subscribe(
+                    onDispose: () =>
+                    {
+                        disposeCallCount++;
+                        disposed = true;
+                    }
+                )
+            );
+        }
+
+        [Test]
+        public void TestBatchObservable()
+        {
+            var context = new ObservationContext();
+            var value = new ObservableValue<int>(context, 2);
+
+            var init = false;
+            var lastValue = 0;
+            var callCount = 0;
+
+            value.ObservableBatch().Subscribe(
+                onNext: ops =>
+                {
+                    callCount++;
+                    lastValue = ops.Last().value;
+                }
+            );
+
+            Assert.AreEqual(1, callCount);
+            Assert.AreEqual(value.value, lastValue);
+
+            init = false;
+            value.value = 4;
+
+            Assert.AreEqual(2, callCount);
+            Assert.IsFalse(init);
+            Assert.AreEqual(value.value, lastValue);
+
+            context.ExecuteBatchOperation(() =>
+            {
+                value.value = 5;
+                value.value = 6;
+                value.value = 7;
+                value.value = 8;
+            });
+
+            Assert.AreEqual(3, callCount);
+            Assert.IsFalse(init);
+            Assert.AreEqual(value.value, lastValue);
+        }
+
+        [Test]
+        public void TestCollectionInitialization()
+        {
+            ObservationContext context = new ObservationContext();
+            var dictionary = new ObservableDictionary<string, int>(context);
+
+            dictionary.Add("cat", 1);
+            dictionary.Add("dog", 2);
+            dictionary.Add("frog", 3);
+
+            var initOps = new List<(object source, object value, bool isRemove)>();
+
+            Observables.ObservableCombine(dictionary).Subscribe(onNext: op =>
+            {
+                var args = (DictionaryOp<string, int>)op;
+                initOps.Add(new(op.source, new KeyValuePair<string, int>(args.key, args.value), args.isRemove));
+            });
+
+            Assert.That(
+                initOps,
+                Is.EqualTo(
+                    new List<(object source, object value, bool isRemove)>()
+                    {
+                        new(dictionary, KeyValuePair.Create("cat", 1), false),
+                        new(dictionary, KeyValuePair.Create("dog", 2), false),
+                        new(dictionary, KeyValuePair.Create("frog", 3), false)
+                    }
+                )
+            );
+
+            initOps.Clear();
+
+            var list = new ObservableList<float>(context);
+
+            list.Add(0.22f);
+            list.Add(0.11f);
+            list.Add(-1000f);
+            list.Insert(1, 50f);
+
+            var subscription = Observables.ObservableCombine(dictionary, list).Subscribe(onNext: op =>
+            {
+                if (op.source == dictionary)
+                {
+                    var args = (DictionaryOp<string, int>)op;
+                    initOps.Add(new(op.source, new KeyValuePair<string, int>(args.key, args.value), args.isRemove));
+                }
+                else
+                {
+                    var args = (ListOp<float>)op;
+                    initOps.Add(new(op.source, args.element, args.isRemove));
+                }
+            });
+
+            Assert.That(
+                initOps,
+                Is.EqualTo(
+                    new List<(object source, object value, bool isRemove)>()
+                    {
+                        new(dictionary, KeyValuePair.Create("cat", 1), false),
+                        new(dictionary, KeyValuePair.Create("dog", 2), false),
+                        new(dictionary, KeyValuePair.Create("frog", 3), false),
+                        new(list, 0.22f, false),
+                        new(list, 50f, false),
+                        new(list, 0.11f, false),
+                        new(list, -1000f, false)
+                    }
+                )
+            );
+        }
+    }
+}

package/Tests/ObservationContextTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4da78d805d539ea4db48bc0b719908d5