Example #1
0
        public void MultipleValuesReturnTrue()
        {
            bool?valuereturned = null;
            var  subscribed    = _observable.Subscribe(result =>
            {
                valuereturned = result;
            });

            var item1 = new ObjectWithObservable(1);
            var item2 = new ObjectWithObservable(2);
            var item3 = new ObjectWithObservable(3);

            _source.AddOrUpdate(item1);
            _source.AddOrUpdate(item2);
            _source.AddOrUpdate(item3);
            Assert.AreEqual(false, valuereturned.Value, "Value should be false");

            item1.InvokeObservable(true);
            item2.InvokeObservable(true);
            item3.InvokeObservable(true);
            Assert.AreEqual(true, valuereturned.Value, "Value should be true");

            //_source.Remove(item3);

            //Assert.AreEqual(false, valuereturned.Value, "Value should be true");
            subscribed.Dispose();
        }
        public void MultipleValuesReturnTrue()
        {
            bool? valuereturned = null;
            var subscribed = _observable.Subscribe(result =>
            {
                valuereturned = result;
            });

            var item1 = new ObjectWithObservable(1);
            var item2 = new ObjectWithObservable(2);
            var item3 = new ObjectWithObservable(3);
            _source.AddOrUpdate(item1);
            _source.AddOrUpdate(item2);
            _source.AddOrUpdate(item3);
            Assert.AreEqual(false, valuereturned.Value, "Value should be false");

            item1.InvokeObservable(true);
            item2.InvokeObservable(true);
            item3.InvokeObservable(true);
            Assert.AreEqual(true, valuereturned.Value, "Value should be true");

            //_source.Remove(item3);

            //Assert.AreEqual(false, valuereturned.Value, "Value should be true");
            subscribed.Dispose();
        }
        public void MultipleValuesReturnTrue()
        {
            bool?valueReturned = null;
            var  subscribed    = _observable.Subscribe(result => { valueReturned = result; });

            var item1 = new ObjectWithObservable(1);
            var item2 = new ObjectWithObservable(2);
            var item3 = new ObjectWithObservable(3);

            _source.AddOrUpdate(item1);
            _source.AddOrUpdate(item2);
            _source.AddOrUpdate(item3);

            if (valueReturned is null)
            {
                throw new InvalidOperationException(nameof(valueReturned));
            }

            valueReturned.Value.Should().Be(false, "Value should be false");

            item1.InvokeObservable(true);
            item2.InvokeObservable(true);
            item3.InvokeObservable(true);
            valueReturned.Value.Should().Be(true, "Value should be true");

            subscribed.Dispose();
        }
        public void InlineObservableChangeProducesResult()
        {
            bool?valuereturned = null;
            var  subscribed    = _observable.Subscribe(result => { valuereturned = result; });

            var item = new ObjectWithObservable(1);

            item.InvokeObservable(true);
            _source.AddOrUpdate(item);

            Assert.AreEqual(true, valuereturned.Value, "Value should be true");
            subscribed.Dispose();
        }
Example #5
0
        public void EverythingIsUnsubscribedWhenStreamIsDisposed()
        {
            bool invoked = false;
            var  stream  = _source.Connect().MergeMany(o => o.Observable).Subscribe(o => { invoked = true; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            stream.Dispose();

            item.InvokeObservable(true);
            invoked.Should().BeFalse();
        }
        public void InitialItemReturnsFalseWhenObservaleHasNoValue()
        {
            bool?valuereturned = null;
            var  subscribed    = _observable.Subscribe(result => { valuereturned = result; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            Assert.IsTrue(valuereturned.HasValue, "An intial value should have been called");
            Assert.AreEqual(false, valuereturned.Value, "The intial value should be false");

            subscribed.Dispose();
        }
        public void InitialItemReturnsFalseWhenObservaleHasNoValue()
        {
            bool?valuereturned = null;
            var  subscribed    = _observable.Subscribe(result => { valuereturned = result; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            valuereturned.HasValue.Should().BeTrue();
            valuereturned.Value.Should().Be(false, "The intial value should be false");

            subscribed.Dispose();
        }
Example #8
0
        public void RemovedItemWillNotCauseInvocation()
        {
            bool invoked = false;
            var  stream  = _source.Connect().MergeMany(o => o.Observable).Subscribe(o => { invoked = true; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);
            _source.Remove(item);
            invoked.Should().BeFalse();

            item.InvokeObservable(true);
            invoked.Should().BeFalse();
            stream.Dispose();
        }
        public void SingleItemFailWillNotFailMergedStream()
        {
            var failed = false;
            var stream = _source.Connect().MergeMany((o, key) => o.Observable).Subscribe(_ => { }, ex => failed = true);

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            item.FailObservable(new Exception("Test exception"));

            stream.Dispose();

            failed.Should().BeFalse();
        }
        public void InlineObservableChangeProducesResult()
        {
            bool? valuereturned = null;
            var subscribed = _observable.Subscribe(result =>
            {
                valuereturned = result;
            });

            var item = new ObjectWithObservable(1);
            item.InvokeObservable(true);
            _source.AddOrUpdate(item);

            Assert.AreEqual(true, valuereturned.Value, "Value should be true");
            subscribed.Dispose();
        }
        public void EverythingIsUnsubscribedWhenStreamIsDisposed()
        {
            bool invoked = false;
            var  stream  = _source.Connect()
                           .MergeMany((o, key) => o.Observable)
                           .Subscribe(o => { invoked = true; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            stream.Dispose();

            item.InvokeObservable(true);
            Assert.IsFalse(invoked, "The stream has been disposed so there should be no notificiation");
        }
        public void SingleItemCompleteWillNotMergedStream()
        {
            var completed = false;
            var stream    = _source.Connect().MergeMany((o, key) => o.Observable).Subscribe(_ => { }, () => completed = true);

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            item.InvokeObservable(true);
            item.CompleteObservable();

            stream.Dispose();

            completed.Should().BeFalse();
        }
Example #13
0
        public void InvocationOnlyWhenChildIsInvoked()
        {
            bool invoked = false;

            var stream = _source.Connect().MergeMany(o => o.Observable).Subscribe(o => { invoked = true; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            invoked.Should().BeFalse();

            item.InvokeObservable(true);
            invoked.Should().BeTrue();
            stream.Dispose();
        }
        public void InitialItemReturnsFalseWhenObservaleHasNoValue()
        {
            bool? valuereturned = null;
            var subscribed = _observable.Subscribe(result =>
            {
                valuereturned = result;
            });

            var item = new ObjectWithObservable(1);
            _source.AddOrUpdate(item);

            Assert.IsTrue(valuereturned.HasValue, "An intial value should have been called");
            Assert.AreEqual(false, valuereturned.Value, "The intial value should be false");

            subscribed.Dispose();
        }
        public void RemovedItemWillNotCauseInvocation()
        {
            bool invoked = false;
            var  stream  = _source.Connect()
                           .MergeMany((o, key) => o.Observable)
                           .Subscribe(o => { invoked = true; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);
            _source.Remove(item);
            Assert.IsFalse(invoked, "Error. The operator should not have been invoked");

            item.InvokeObservable(true);
            Assert.IsFalse(invoked, "The observable should not have notified as it is no longer in  the stream");
            stream.Dispose();
        }
        public void InlineObservableChangeProducesResult()
        {
            bool?valueReturned = null;
            var  subscribed    = _observable.Subscribe(result => { valueReturned = result; });

            var item = new ObjectWithObservable(1);

            item.InvokeObservable(true);
            _source.AddOrUpdate(item);

            if (valueReturned is null)
            {
                throw new InvalidOperationException(nameof(valueReturned));
            }

            valueReturned.Value.Should().Be(true, "Value should be true");
            subscribed.Dispose();
        }
        public void EverythingIsUnsubscribedWhenStreamIsDisposed()
        {
            bool invoked = false;
            var stream = _source.Connect()
                    .MergeMany(o => o.Observable)
                    .Subscribe(o =>
                    {
                        invoked = true;
                    });

            var item = new ObjectWithObservable(1);
            _source.AddOrUpdate(item);

            stream.Dispose();

            item.InvokeObservable(true);
            Assert.IsFalse(invoked, "The stream has been disposed so there should be no notificiation");
        }
        public void InvocationOnlyWhenChildIsInvoked()
        {
            bool invoked = false;

            var stream = _source.Connect()
                         .MergeMany((o, key) => o.Observable)
                         .Subscribe(o => { invoked = true; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            Assert.IsFalse(invoked, "Error. The operator should not have been invoked");

            item.InvokeObservable(true);
            Assert.IsTrue(invoked, "The observable should have notified");
            stream.Dispose();
        }
		public void RemovedItemWillNotCauseInvocation()
		{
			bool invoked = false;
			var stream = _source.Connect()
					.MergeMany(o => o.Observable)
					.Subscribe(o =>
					{
						invoked = true;
					});

			var item = new ObjectWithObservable(1);
			_source.Add(item);
			_source.Remove(item);
			Assert.IsFalse(invoked, "Error. The operator should not have been invoked");

			item.InvokeObservable(true);
			Assert.IsFalse(invoked, "The observable should not have notified as it is no longer in  the stream");
			stream.Dispose();
		}
        public void InitialItemReturnsFalseWhenObservableHasNoValue()
        {
            bool?valueReturned = null;
            var  subscribed    = _observable.Subscribe(result => { valueReturned = result; });

            var item = new ObjectWithObservable(1);

            _source.AddOrUpdate(item);

            valueReturned.HasValue.Should().BeTrue();

            if (valueReturned is null)
            {
                throw new InvalidOperationException(nameof(valueReturned));
            }

            valueReturned.Value.Should().Be(false, "The initial value should be false");

            subscribed.Dispose();
        }
        public void InvocationOnlyWhenChildIsInvoked()
        {
            bool invoked=false;

            var stream = _source.Connect()
                    .MergeMany(o => o.Observable)
                    .Subscribe(o =>
                               {
                                   invoked = true;
                               });

            var item = new ObjectWithObservable(1);
            _source.AddOrUpdate(item);

            Assert.IsFalse(invoked,"Error. The operator should not have been invoked");

            item.InvokeObservable(true);
            Assert.IsTrue(invoked, "The observable should have notified");
            stream.Dispose();
        }