Esempio n. 1
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 DoPostImport_AfterImport_CallUpdateStrategyAndObserversNotified()
        {
            // Setup
            var updateSectionsWithImportedDataObservable = new TestObservable();
            var doPostUpdateActionsObservable            = new TestObservable();

            var mocks          = new MockRepository();
            var updateStrategy = mocks.StrictMock <IFailureMechanismSectionUpdateStrategy>();

            updateStrategy.Expect(us => us.UpdateSectionsWithImportedData(null, null))
            .IgnoreArguments()
            .Return(new[]
            {
                updateSectionsWithImportedDataObservable
            });
            updateStrategy.Expect(us => us.DoPostUpdateActions())
            .Return(new[]
            {
                doPostUpdateActionsObservable
            });
            var messageProvider = mocks.Stub <IImporterMessageProvider>();

            var updateSectionsWithImportedDataObserver = mocks.StrictMock <IObserver>();

            updateSectionsWithImportedDataObserver.Expect(o => o.UpdateObserver());

            var doPostUpdateActionsObserver = mocks.StrictMock <IObserver>();

            doPostUpdateActionsObserver.Expect(o => o.UpdateObserver());
            mocks.ReplayAll();

            string referenceLineFilePath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO,
                                                                      Path.Combine("ReferenceLine", "traject_1-1.shp"));
            string sectionsFilePath = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Common.IO,
                                                                 Path.Combine("FailureMechanismSections", "traject_1-1_vakken.shp"));

            ReferenceLine importReferenceLine = ImportReferenceLine(referenceLineFilePath);

            var failureMechanism = new TestFailureMechanism();
            var importer         = new FailureMechanismSectionsImporter(failureMechanism, importReferenceLine, sectionsFilePath, updateStrategy, messageProvider);

            importer.Import();
            updateSectionsWithImportedDataObservable.Attach(updateSectionsWithImportedDataObserver);
            doPostUpdateActionsObservable.Attach(doPostUpdateActionsObserver);

            // Call
            importer.DoPostImport();

            // Assert
            mocks.VerifyAll();
        }
Esempio n. 3
0
        public void Observers_WhenAttachingObserver_ContainsExpectedObserver()
        {
            // Setup
            var mocks          = new MockRepository();
            var testObservable = new TestObservable();
            var observer       = mocks.Stub <IObserver>();

            testObservable.Attach(observer);
            mocks.ReplayAll();

            // Call
            IEnumerable <IObserver> observers = testObservable.Observers;

            // Assert
            Assert.AreSame(observer, observers.Single());

            mocks.VerifyAll();
        }
Esempio n. 4
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'
        }
Esempio n. 5
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();
        }