public void GivenContextWithObserverAttachedThatThrowsInvalidOperationException_WhenNotifyingLocationCalculationsElementInEnumerationToObserve_ThenNoExceptionThrown()
        {
            // Given
            var mockRepository = new MockRepository();
            var observer       = mockRepository.StrictMock <IObserver>();

            observer.Expect(o => o.UpdateObserver()).Do((Action)(() => throw new InvalidOperationException()));
            mockRepository.ReplayAll();

            var observable = new TestObservable();
            var locationCalculationsEnumerationToObserve = new ObservableList <IObservable>
            {
                observable
            };

            var context = new TestLocationCalculationsContext(new object(), locationCalculationsEnumerationToObserve);

            context.Attach(observer);

            // When
            observable.NotifyObservers();

            // Then
            mockRepository.VerifyAll();
        }
Beispiel #2
0
        public void NotifyObservers_MultipleObserversDetachingOrAttachingOthers_NoUpdatesForAttachedAndDetachedObservers()
        {
            // Setup
            var mocks          = new MockRepository();
            var testObservable = new TestObservable();

            var observer1 = mocks.Stub <IObserver>();
            var observer2 = mocks.Stub <IObserver>();
            var observer3 = mocks.Stub <IObserver>();
            var observer4 = mocks.Stub <IObserver>();
            var observer5 = mocks.Stub <IObserver>();
            var observer6 = mocks.Stub <IObserver>();

            testObservable.Attach(observer1);
            testObservable.Attach(observer2);
            testObservable.Attach(observer3);
            testObservable.Attach(observer4);
            testObservable.Attach(observer6);

            observer1.Expect(o => o.UpdateObserver());
            observer2.Expect(o => o.UpdateObserver()).Do((Action)(() => testObservable.Detach(observer3)));
            observer3.Expect(o => o.UpdateObserver()).Repeat.Never(); // A detached observer should no longer be updated
            observer4.Expect(o => o.UpdateObserver()).Do((Action)(() => testObservable.Attach(observer5)));
            observer5.Expect(o => o.UpdateObserver()).Repeat.Never(); // An attached observer should not be updated too
            observer6.Expect(o => o.UpdateObserver());

            mocks.ReplayAll();

            // Call
            testObservable.NotifyObservers();

            // Assert
            mocks.VerifyAll();
        }
        public void GivenContextWithObserverAttached_WhenNotifyingLocationCalculationsElementInEnumerationToObserve_ThenObserverCorrectlyNotified()
        {
            // Given
            var mockRepository = new MockRepository();
            var observer       = mockRepository.StrictMock <IObserver>();

            observer.Expect(o => o.UpdateObserver());
            mockRepository.ReplayAll();

            var observable = new TestObservable();
            var locationCalculationsEnumerationToObserve = new ObservableList <IObservable>
            {
                observable
            };

            var context = new TestLocationCalculationsContext(new object(), locationCalculationsEnumerationToObserve);

            context.Attach(observer);

            // When
            observable.NotifyObservers();

            // Then
            mockRepository.VerifyAll();
        }
        public void RecursiveObserverObservingItemsInContainers_NotifyObserversAtSpecifiedLevel_UpdateObserversActionShouldBePerformed(int nestingLevel)
        {
            // Given
            var           counter                = 0;
            var           rootContainer          = new TestContainer();
            TestContainer currentNestedContainer = rootContainer;
            var           currentTestObservable  = new TestObservable();

            InitializeHierarchy(nestingLevel, ref currentNestedContainer, ref currentTestObservable);

            using (new RecursiveObserver <TestContainer, TestObservable>(() => counter++, GetChildren)
            {
                Observable = rootContainer
            })
            {
                // When
                currentTestObservable.NotifyObservers();

                // Then
                Assert.AreEqual(1, counter);

                currentNestedContainer.NotifyObservers();
                Assert.AreEqual(1, counter); // Nothing should have happened
            }
        }
        public void RecursiveObserverObservingItemsInContainers_ContainerItemsRemoved_UpdateObserversActionShouldNoLongerBePerformed(int nestingLevel)
        {
            // Given
            var           counter                = 0;
            var           rootContainer          = new TestContainer();
            TestContainer currentNestedContainer = rootContainer;
            var           currentTestObservable  = new TestObservable();

            InitializeHierarchy(nestingLevel, ref currentNestedContainer, ref currentTestObservable);

            using (new RecursiveObserver <TestContainer, TestObservable>(() => counter++, GetChildren)
            {
                Observable = rootContainer
            })
            {
                // When
                rootContainer.Children.Clear();
                rootContainer.NotifyObservers(); // Collection changes should always be notified

                currentTestObservable.NotifyObservers();

                // Then
                Assert.AreEqual(0, counter);
            }
        }
Beispiel #6
0
        public void Observer_WithObservableSetAndThenDisposed_NotifyObserversNoLongerResultsInPerformingUpdateObserversAction()
        {
            // Setup
            var counter    = 0;
            var observable = new TestObservable();
            var observer   = new Observer(() => counter++)
            {
                Observable = observable
            };

            observer.Dispose();

            // Call
            observable.NotifyObservers();

            // Assert
            Assert.AreEqual(0, counter);
        }
Beispiel #7
0
        public void Observer_WithObservable_NotifyObserversResultsInPerformingUpdateObserversAction()
        {
            // Setup
            var counter    = 0;
            var observable = new TestObservable();

            using (new Observer(() => counter++)
            {
                Observable = observable
            })
            {
                // Call
                observable.NotifyObservers();

                // Assert
                Assert.AreEqual(1, counter);
            }
        }
Beispiel #8
0
        public void NotifyObserver_AttachedObserverDetachedAgain_ObserverNoLongerNotified()
        {
            // Setup
            var mocks    = new MockRepository();
            var observer = mocks.StrictMock <IObserver>();

            mocks.ReplayAll();

            var observable = new TestObservable();

            observable.Attach(observer);
            observable.Detach(observer);

            // Call
            observable.NotifyObservers();

            // Assert
            mocks.VerifyAll(); // Expect no calls on 'observer'
        }
Beispiel #9
0
        public void NotifyObservers_WithObserverAttached_ObserverIsNotified()
        {
            // Setup
            var mocks    = new MockRepository();
            var observer = mocks.StrictMock <IObserver>();

            observer.Expect(o => o.UpdateObserver()); // Expect to be called once
            mocks.ReplayAll();

            var observable = new TestObservable();

            observable.Attach(observer);

            // Call
            observable.NotifyObservers();

            // Assert
            mocks.VerifyAll();
        }
        public void RecursiveObserverObservingItemsInContainers_RecursiveObserverDispose_UpdateObserversActionShouldNoLongerBePerformed(int nestingLevel)
        {
            // Given
            var           counter                = 0;
            var           rootContainer          = new TestContainer();
            TestContainer currentNestedContainer = rootContainer;
            var           currentTestObservable  = new TestObservable();

            InitializeHierarchy(nestingLevel, ref currentNestedContainer, ref currentTestObservable);

            var recursiveObserver = new RecursiveObserver <TestContainer, TestObservable>(() => counter++, GetChildren)
            {
                Observable = rootContainer
            };

            // When
            recursiveObserver.Dispose();
            currentTestObservable.NotifyObservers();

            // Then
            Assert.AreEqual(0, counter);
            Assert.IsNull(recursiveObserver.Observable);
        }