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 async Task Subscribe_With_Observable_Async()
{
Snapshot.FullName();
await TryTest(async ct =>
{
// arrange
var observable = new TestObservable();
// act
ISchema schema = SchemaBuilder.New()
.AddSubscriptionType(t => t
.Field("test")
.Type <StringType>()
.Resolve(ctx => ctx.GetEventMessage <string>())
.Subscribe(_ => Task.FromResult <IObservable <string> >(observable)))
.ModifyOptions(t => t.StrictValidation = false)
.Create();
// assert
IRequestExecutor executor = schema.MakeExecutable();
var stream = (IResponseStream)await executor.ExecuteAsync(
"subscription { test }", ct);
var results = new StringBuilder();
await foreach (IQueryResult result in
stream.ReadResultsAsync().WithCancellation(ct))
{
results.AppendLine(result.ToJson());
}
Assert.True(observable.DisposeRaised);
results.ToString().MatchSnapshot();
});
}
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);
}
}
public void An_ObservableSource_must_drop_newest_element_on_DropTail_overflow()
{
this.AssertAllStagesStopped(() =>
{
var o = new TestObservable <int>();
var s = this.CreateManualSubscriberProbe <int>();
Source.FromObservable(o, maxBufferCapacity: 2, overflowStrategy: OverflowStrategy.DropTail)
.To(Sink.FromSubscriber(s))
.Run(_materializer);
var sub = s.ExpectSubscription();
o.Event(1);
o.Event(2); // this should be dropped
o.Event(3);
sub.Request(3);
s.ExpectNext(1);
s.ExpectNext(3);
s.ExpectNoMsg();
sub.Cancel();
}, _materializer);
}
public void Can_Bind_Completed_Binding_Back_To_Original_Value_When_Ending_Batch_Update()
{
var target = new TestClass();
var raised = 0;
var notifications = new List <AvaloniaPropertyChangedEventArgs>();
var observable1 = new TestObservable <string>("foo");
var observable2 = new TestObservable <string>("foo");
target.Bind(TestClass.FooProperty, observable1);
target.BeginBatchUpdate();
observable1.OnCompleted();
target.PropertyChanged += (sender, e) =>
{
if (e.Property == TestClass.FooProperty && e.NewValue is null)
{
target.Bind(TestClass.FooProperty, observable2);
++raised;
}
notifications.Add(e);
};
target.EndBatchUpdate();
Assert.Equal("foo", target.Foo);
Assert.Equal(1, raised);
Assert.Equal(2, notifications.Count);
Assert.Equal(null, notifications[0].NewValue);
Assert.Equal("foo", notifications[1].NewValue);
}
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 Observable_PropertyChanged()
{
var vm = new TestObservable();
string propertyChanged = null;
vm.PropertyChanged += (sender, e) => propertyChanged = e.PropertyName;
vm.String = "MyString";
Assert.AreEqual("MyString", vm.String);
Assert.AreEqual("String", propertyChanged);
vm.Int = 42;
Assert.AreEqual(42, vm.Int);
Assert.AreEqual("Int", propertyChanged);
vm.Double = 3.1456;
Assert.AreEqual(3.1456, vm.Double);
Assert.AreEqual("Double", propertyChanged);
vm.Bool = true;
Assert.IsTrue(vm.Bool);
Assert.AreEqual("Bool", propertyChanged);
vm.Object = new TestObject { String = "TestString", Int = 13 };
Assert.IsNotNull(vm.Object);
Assert.AreEqual("TestString", vm.Object.String);
Assert.AreEqual(13, vm.Object.Int);
Assert.AreEqual("Object", propertyChanged);
}
public void Observable_PropertyChanged()
{
var vm = new TestObservable();
string propertyChanged = null;
vm.PropertyChanged += (sender, e) => propertyChanged = e.PropertyName;
vm.String = "MyString";
Assert.AreEqual("MyString", vm.String);
Assert.AreEqual("String", propertyChanged);
vm.Int = 42;
Assert.AreEqual(42, vm.Int);
Assert.AreEqual("Int", propertyChanged);
vm.Double = 3.1456;
Assert.AreEqual(3.1456, vm.Double);
Assert.AreEqual("Double", propertyChanged);
vm.Bool = true;
Assert.IsTrue(vm.Bool);
Assert.AreEqual("Bool", propertyChanged);
vm.Object = new TestObject {
String = "TestString", Int = 13
};
Assert.IsNotNull(vm.Object);
Assert.AreEqual("TestString", vm.Object.String);
Assert.AreEqual(13, vm.Object.Int);
Assert.AreEqual("Object", propertyChanged);
}
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();
}
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 An_ObservableSource_must_receive_events_from_an_observable()
{
this.AssertAllStagesStopped(() =>
{
var o = new TestObservable <int>();
var s = this.CreateManualSubscriberProbe <int>();
Source.FromObservable(o)
.To(Sink.FromSubscriber(s))
.Run(_materializer);
var sub = s.ExpectSubscription();
sub.Request(2);
o.Event(1);
o.Event(2);
o.Event(3);
s.ExpectNext(1);
s.ExpectNext(2);
s.ExpectNoMsg();
sub.Request(2);
s.ExpectNext(3);
s.ExpectNoMsg();
o.Event(4);
s.ExpectNext(4);
o.Complete();
}, _materializer);
}
public async Task Subscribe_With_Observable()
{
// arrange
using var cts = new CancellationTokenSource(30000);
var observable = new TestObservable();
// act
ISchema schema = SchemaBuilder.New()
.AddSubscriptionType(t => t
.Field("test")
.Type <StringType>()
.Resolver(ctx => ctx.CustomProperty <string>(WellKnownContextData.EventMessage))
.Subscribe(ctx => observable))
.ModifyOptions(t => t.StrictValidation = false)
.Create();
// assert
IQueryExecutor executor = schema.MakeExecutable();
var stream = (IResponseStream)await executor.ExecuteAsync(
"subscription { test }", cts.Token);
var results = new List <IReadOnlyQueryResult>();
await foreach (IReadOnlyQueryResult result in stream.WithCancellation(cts.Token))
{
results.Add(result);
}
Assert.True(observable.DisposeRaised);
results.MatchSnapshot();
}
public void DefaultConstructor_ExpectedValues()
{
// Call
var observable = new TestObservable();
// Assert
Assert.IsInstanceOf <IObservable>(observable);
CollectionAssert.IsEmpty(observable.Observers);
}
public void Observable_Dispose()
{
var vm = new TestObservable();
bool disposed = false;
vm.Disposed += (sender, e) => disposed = true;
vm.Dispose();
Assert.IsTrue(disposed);
}
public void ObservableObjectPropertiesBehaveNormally()
{
var testObject = new TestObservable();
Assert.That(testObject.Name, Is.Null);
testObject.Name = "Test String";
Assert.That(testObject.Name, Is.EqualTo("Test String"));
}
public void Observable_Dispose()
{
var vm = new TestObservable();
bool disposed = false;
vm.Disposed += (sender, e) => disposed = true;
vm.Dispose();
Assert.IsTrue(disposed);
}
public void Binding_Should_Not_Raise_Property_Changes_During_Batch_Update()
{
var target = new TestClass();
var observable = new TestObservable <string>("foo");
var raised = new List <string>();
target.GetObservable(TestClass.FooProperty).Skip(1).Subscribe(x => raised.Add(x));
target.BeginBatchUpdate();
target.Bind(TestClass.FooProperty, observable, BindingPriority.LocalValue);
Assert.Empty(raised);
}
public void Non_Active_Binding_Should_Not_Be_Subscribed_Before_Batch_Update()
{
var target = new TestClass();
var observable1 = new TestObservable <string>("foo");
var observable2 = new TestObservable <string>("bar");
target.Bind(TestClass.FooProperty, observable1, BindingPriority.LocalValue);
target.Bind(TestClass.FooProperty, observable2, BindingPriority.Style);
Assert.Equal(1, observable1.SubscribeCount);
Assert.Equal(0, observable2.SubscribeCount);
}
public void Style_Bindings_Should_Not_Be_Subscribed_During_Batch_Update()
{
var target = new TestClass();
var observable1 = new TestObservable <string>("foo");
var observable2 = new TestObservable <string>("bar");
target.BeginBatchUpdate();
target.Bind(TestClass.FooProperty, observable1, BindingPriority.Style);
target.Bind(TestClass.FooProperty, observable2, BindingPriority.StyleTrigger);
Assert.Equal(0, observable1.SubscribeCount);
Assert.Equal(0, observable2.SubscribeCount);
}
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();
}
public void Active_Style_Binding_Should_Be_Subscribed_After_Batch_Uppdate_1()
{
var target = new TestClass();
var observable1 = new TestObservable <string>("foo");
var observable2 = new TestObservable <string>("bar");
target.BeginBatchUpdate();
target.Bind(TestClass.FooProperty, observable1, BindingPriority.Style);
target.Bind(TestClass.FooProperty, observable2, BindingPriority.Style);
target.EndBatchUpdate();
Assert.Equal(0, observable1.SubscribeCount);
Assert.Equal(1, observable2.SubscribeCount);
}
public void An_ObservableSource_must_subscribe_to_an_observable()
{
this.AssertAllStagesStopped(() =>
{
var o = new TestObservable <int>();
var s = this.CreateManualSubscriberProbe <int>();
Source.FromObservable(o)
.To(Sink.FromSubscriber(s))
.Run(_materializer);
var sub = s.ExpectSubscription();
o.Complete();
}, _materializer);
}
public void ObservableObjectPropertiesRaisePropertyChanged()
{
var propertiesChanged = new List <string>();
var testObject = new TestObservable();
testObject.PropertyChanged += (source, args) => propertiesChanged.Add(args.PropertyName);
testObject.Name = "Another String";
testObject.X = Math.PI;
Assert.That(propertiesChanged.Count, Is.EqualTo(2));
Assert.That(propertiesChanged, Contains.Item(nameof(testObject.Name)));
Assert.That(propertiesChanged, Contains.Item(nameof(testObject.X)));
}
private static void InitializeHierarchy(int nestingLevel, ref TestContainer currentNestedContainer, ref TestObservable currentTestObservable)
{
for (var i = 0; i < nestingLevel; i++)
{
var newNestedContainer = new TestContainer();
var newTestObservable = new TestObservable();
currentNestedContainer.Children.Add(new object());
currentNestedContainer.Children.Add(newTestObservable);
currentNestedContainer.Children.Add(newNestedContainer);
currentTestObservable = newTestObservable;
currentNestedContainer = newNestedContainer;
}
}
public void Binding_Change_Should_Be_Raised_After_Batch_Update_1()
{
var target = new TestClass();
var observable = new TestObservable <string>("foo");
var raised = new List <AvaloniaPropertyChangedEventArgs>();
target.PropertyChanged += (s, e) => raised.Add(e);
target.BeginBatchUpdate();
target.Bind(TestClass.FooProperty, observable, BindingPriority.LocalValue);
target.EndBatchUpdate();
Assert.Equal(1, raised.Count);
Assert.Equal("foo", target.Foo);
Assert.Null(raised[0].OldValue);
Assert.Equal("foo", raised[0].NewValue);
}
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();
}
public void Binding_Change_Should_Be_Raised_After_Batch_Update_3()
{
var target = new TestClass();
var observable = new TestObservable <Orientation>(Orientation.Horizontal);
var raised = new List <AvaloniaPropertyChangedEventArgs>();
target.PropertyChanged += (s, e) => raised.Add(e);
target.BeginBatchUpdate();
target.Bind(TestClass.BazProperty, observable, BindingPriority.LocalValue);
target.EndBatchUpdate();
Assert.Equal(1, raised.Count);
Assert.Equal(TestClass.BazProperty, raised[0].Property);
Assert.Equal(Orientation.Vertical, raised[0].OldValue);
Assert.Equal(Orientation.Horizontal, raised[0].NewValue);
Assert.Equal(Orientation.Horizontal, target.Baz);
}
public void BaseObservableObjectPropertyChangedRaisingTest()
{
// arrange
var testObject = new TestObservable();
var propertiesRaised = new List <string>();
testObject.PropertyChanged += (s, e) =>
{
propertiesRaised.Add(e.PropertyName);
};
// act
testObject.SomeProperty = Guid.NewGuid().ToString();
testObject.SomeProperty = null;
testObject.SomeProperty = null;
testObject.SomeProperty = string.Empty;
// assert
Assert.AreEqual(3, propertiesRaised.Count);
}
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);
}
}
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);
}
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 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'
}
