com.fofx.observething 1.0.0

package/Tests/ValueObservableTests.cs

@@ -0,0 +1,322 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace ObserveThing.Tests
+{
+    public class ObservableValueTests
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            Settings.DefaultExceptionHandler = UnityEngine.Debug.LogException;
+        }
+
+        [Test]
+        public void TestErrorLogging()
+        {
+            var source = new ObservableValue<bool>();
+            var errorSelect = source
+                .ObservableSelect(x => x)
+                .ObservableSelect(x => x)
+                .ObservableSelect(x => x)
+                .ObservableSelect(x =>
+                {
+                    if (x)
+                        throw new Exception("This is an exception");
+
+                    return x;
+                });
+
+            var errorObservable = errorSelect.Subscribe();
+
+            LogAssert.Expect(UnityEngine.LogType.Exception, "Exception: This is an exception");
+            source.value = true;
+
+            errorObservable.Dispose();
+            source.value = false;
+
+            errorObservable = errorSelect.Subscribe(
+                onError: exc => UnityEngine.Debug.Log("Got exception")
+            );
+
+            LogAssert.Expect(UnityEngine.LogType.Log, "Got exception");
+            source.value = true;
+        }
+
+        [Test]
+        public void TestSelect()
+        {
+            int callCount = 0;
+            int result = 0;
+
+            Exception exception = null;
+            bool disposed = false;
+
+            var toggle = new ObservableValue<bool>();
+            var selectObservable = toggle
+                .ObservableSelect(x => x ? 0 : 1)
+                .Subscribe(
+                    x =>
+                    {
+                        callCount++;
+                        result = x;
+                    },
+                    exc => exception = exc,
+                    () => disposed = true
+                );
+
+            // init call
+            Assert.AreEqual(1, callCount);
+            Assert.AreEqual(1, result);
+
+            toggle.value = true;
+            Assert.AreEqual(2, callCount);
+            Assert.AreEqual(0, result);
+
+            toggle.value = false;
+            Assert.AreEqual(3, callCount);
+            Assert.AreEqual(1, result);
+
+            toggle.value = false;
+            Assert.AreEqual(3, callCount);
+            Assert.AreEqual(1, result);
+
+            toggle.Dispose();
+            Assert.IsTrue(disposed);
+
+            Assert.Throws(typeof(ObjectDisposedException), () => toggle.value = true);
+            Assert.AreEqual(3, callCount);
+        }
+
+        [Test]
+        public void TestSelectRaisesException()
+        {
+            Exception exception = null;
+            var source = new ObservableValue<bool>();
+            var selectChain = source.ObservableSelect(x => x).ObservableSelect(x => x);
+
+            var stream = selectChain.Subscribe(
+                onNext: x =>
+                {
+                    if (x)
+                        throw new Exception("This is an exception");
+                },
+                onError: exc => exception = exc
+            );
+
+            source.value = true;
+            Assert.IsNotNull(exception);
+
+            exception = null;
+
+            source.value = false;
+            Assert.IsNull(exception);
+
+            stream.Dispose();
+
+            source.value = true;
+            Assert.IsNull(exception);
+
+            source.value = false;
+            Assert.IsNull(exception);
+
+            stream = selectChain.Subscribe(
+                onNext: x =>
+                {
+                    if (x)
+                        throw new Exception("This is an exception");
+                }
+            );
+
+            LogAssert.Expect(UnityEngine.LogType.Exception, "Exception: This is an exception");
+            source.value = true;
+        }
+
+        [Test]
+        public void TestWithPrevious()
+        {
+            bool disposed = false;
+            bool receivedCall = false;
+            int currentValue = 0;
+            int previousValue = 0;
+            var source = new ObservableValue<int>();
+            var stream = source.ObservableWithPrevious().Subscribe(
+                onNext: x =>
+                {
+                    currentValue = x.current;
+                    previousValue = x.previous;
+                },
+                onDispose: () => disposed = true
+            );
+
+            Assert.AreEqual(currentValue, 0);
+            Assert.AreEqual(previousValue, 0);
+
+            source.value = 1;
+
+            Assert.AreEqual(currentValue, 1);
+            Assert.AreEqual(previousValue, 0);
+
+            source.value = 2;
+
+            Assert.AreEqual(currentValue, 2);
+            Assert.AreEqual(previousValue, 1);
+
+            receivedCall = false;
+            stream.Dispose();
+            Assert.IsTrue(disposed);
+            source.value = 100;
+            Assert.IsFalse(receivedCall);
+        }
+
+        [Test]
+        public void TestShallowCopy()
+        {
+            var result = 0;
+            var nestedSource = new ObservableValue<int>(10);
+            var source = new ObservableValue<IValueObservable<int>>(nestedSource);
+            bool disposed = false;
+            bool receivedCall = false;
+            var d = source.ObservableSelect(x => x.AsObservable());
+            var subscription = source.ObservableUnwrap().Subscribe(
+                onNext: x =>
+                {
+                    result = x;
+                    receivedCall = true;
+                },
+                onDispose: () => disposed = true
+            );
+
+            Assert.AreEqual(10, result);
+
+            nestedSource.value = 100;
+
+            Assert.AreEqual(100, result);
+
+            source.value = new ObservableValue<int>(-3);
+
+            Assert.AreEqual(-3, result);
+
+            nestedSource.value = 2;
+
+            Assert.AreEqual(-3, result);
+
+            source.value = null;
+
+            Assert.AreEqual(0, result);
+
+            source.value = nestedSource;
+
+            Assert.AreEqual(2, result);
+
+            receivedCall = false;
+            subscription.Dispose();
+            Assert.IsTrue(disposed);
+            nestedSource.value = 100;
+            Assert.IsFalse(receivedCall);
+            Assert.AreEqual(2, result);
+        }
+
+        [Test]
+        public void TestImmediateObserverOrder()
+        {
+            ObservableValue<int> observable = new ObservableValue<int>();
+            bool streamCalledFirst = false;
+            bool immediateStreamCalledFirst = false;
+            var chainedObservable = observable.ObservableSelect(x => x * 2);
+
+            var stream = chainedObservable.Subscribe(
+                onNext: x =>
+                {
+                    if (!immediateStreamCalledFirst)
+                        streamCalledFirst = true;
+                },
+                onDispose: () =>
+                {
+                    if (!immediateStreamCalledFirst)
+                        streamCalledFirst = true;
+                }
+            );
+
+            var immediateStream = chainedObservable.Subscribe(
+                immediate: true,
+                onNext: x =>
+                {
+                    if (!streamCalledFirst)
+                        immediateStreamCalledFirst = true;
+                },
+                onDispose: () =>
+                {
+                    if (!streamCalledFirst)
+                        immediateStreamCalledFirst = true;
+                }
+            );
+
+            streamCalledFirst = false;
+            immediateStreamCalledFirst = false;
+
+            observable.value++;
+
+            Assert.IsTrue(immediateStreamCalledFirst);
+            Assert.IsFalse(streamCalledFirst);
+
+            streamCalledFirst = false;
+            immediateStreamCalledFirst = false;
+
+            observable.Dispose();
+
+            Assert.IsTrue(immediateStreamCalledFirst);
+            Assert.IsFalse(streamCalledFirst);
+        }
+
+        [Test]
+        public void TestImmediateSubscription()
+        {
+            ObservableValue<int> observable = new ObservableValue<int>();
+
+            bool standardFired = false;
+            bool immediateFired = false;
+
+            bool standardFiredFirst = false;
+            bool immediateFiredFirst = false;
+
+            var standardStream = observable.Subscribe(
+                onNext: x =>
+                {
+                    standardFired = true;
+
+                    if (!immediateFiredFirst)
+                        standardFiredFirst = true;
+                }
+            );
+
+            var immediateStream = observable.Subscribe(
+                immediate: true,
+                onNext: x =>
+                {
+                    immediateFired = true;
+
+                    if (!standardFiredFirst)
+                        immediateFiredFirst = true;
+                }
+            );
+
+            standardFired = false;
+            immediateFired = false;
+
+            standardFiredFirst = false;
+            immediateFiredFirst = false;
+
+            observable.value = 1;
+
+            Assert.IsTrue(standardFired);
+            Assert.IsTrue(immediateFired);
+            Assert.IsTrue(immediateFiredFirst);
+            Assert.IsFalse(standardFiredFirst);
+        }
+    }
+}

package/Tests/ValueObservableTests.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 7b1583b136ecdfd4bbb60bb53181d3bc

package/Tests/com.fofx.observething.tests.asmdef

@@ -0,0 +1,24 @@
+{
+    "name": "ObserveThing.Tests",
+    "rootNamespace": "",
+    "references": [
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner",
+        "ObserveThing"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Tests/com.fofx.observething.tests.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2d1f165c65c945b42a1d7cff671b382b
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Tests.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 80dccb6759bb2ce478581c23242a5d0f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "com.fofx.observething",
+  "version": "1.0.0",
+  "description": "An observable event stream library.",
+  "keywords": [
+    "observability",
+    "event stream",
+    "linq",
+    "C#",
+    "csharp"
+  ],
+  "homepage": "https://github.com/outernet-foundation/ObserveThing#readme",
+  "bugs": {
+    "url": "https://github.com/outernet-foundation/ObserveThing/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/outernet-foundation/ObserveThing.git"
+  },
+  "license": "MIT",
+  "author": "Elliot Pjecha <epjecha@gmail.com>",
+  "displayName": "ObserveThing",
+  "unity": "6000.0"
+}

package/package.json.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 933d3d97ef4a4d2439b3adc91b985026
+PackageManifestImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: