public void When_assigned_to_its_value_type_variable_the_reactive_should_be_cast_to_its_value_type() { // Arrange var message = Reactive.Of("Hey"); // Act string text = message; // Assert text.Should().Be(message.Value); }
public void IsValid_method_should_return_True_if_Validate_method_was_called_and_result_error_is_Null() { // Arrange var counter = Reactive.Of(0).Validate(x => x != 1, "error"); // Act counter.Value = 2; // Assert counter.IsValid.Value.Should().BeTrue(); }
public void Can_set_reactive_value_while_getting_it() { // Arrange var source = Reactive.Of <object>(); // Act var ensureNotNull = source.Get(x => x.Value ?? (x.Value = new object())); // Assert ensureNotNull.Should().NotBeNull(); }
public void Getters_can_be_chained() { // Arrange var counter = Reactive.Of(1); // Act var adjustedCounter = counter.Get(i => i * 2).Get(x => x.Value + 1); // Assert adjustedCounter.Value.Should().Be(3); }
public void Can_create_reactive_with_validation_error() { // Arrange const string message = "Name is too long"; var name = Reactive.Of <string>().Validate(x => x.Length <= 10, message); // Act name.Value = "America-America"; // Assert name.ValidationError.Value.Should().Be(message); }
public void Can_decorate_reactive_value_setter() { // Arrange var counter = Reactive.Of(0); var twiceCounter = counter.Set(i => i * 2); // Act twiceCounter.Value = 1; // Assert counter.Value.Should().Be(2); }
public void Can_produce_readonly_reactive_of_one_type_from_another() { // Arrange var counter = Reactive.Of(0); var greaterThanZero = counter.To(i => i > 0); // Act counter.Value = 1; // Assert greaterThanZero.Value.Should().BeTrue(); }
public void Should_be_able_to_execute_provided_action_after_value_is_set() { // Arrange var counterValue = 0; var counter = Reactive.Of(0).OnChange(x => counterValue = x); // Act counter.Value = 1; // Assert counterValue.Should().Be(1); }
public void Can_create_reactive_proxy_from_multiple_reactives_without_change_sources() { // Arrange var counter = Reactive.Of(0); var message = Reactive.Of("hey"); // Act var counterMessage = Reactive.Of(() => message.Value + ":" + counter.Value); // Assert counterMessage.Value.Should().Be(message.Value + ":" + counter.Value); }
public void Can_produce_reactive_of_one_type_from_another() { // Arrange var counter = Reactive.Of(0); var message = counter.To( x => "" + x.Value, (x, value) => x.Value = Int32.Parse(value)); // Act message.Value = "10"; // Assert counter.Value.Should().Be(10); }
public void Can_produce_reactive_of_one_type_from_another_based_on_another_reactive_value() { // Arrange var counter = Reactive.Of(0); var message = counter.To( value => "" + value, int.Parse); // Act message.Value = "10"; // Assert counter.Value.Should().Be(10); }
public void Non_validating_reactive_should_always_be_valid() { // Arrange var counter = Reactive.Of(10); // Act counter.Value = 0; var isValid = counter.IsValid(); var validationError = counter.ValidationError(); // Assert isValid.Value.Should().BeTrue(); validationError.Value.Should().BeNull(); }
public void When_CanExecute_reactive_condition_changed_then_command_CanExecute_should_changed_accordignly() { // Arrange var result = false; var condition = Reactive.Of(false); var command = Reactive.Command(() => result = true, condition); // Act condition.Value = true; command.TryExecute(null); // Assert result.Should().BeTrue(); }
public void When_reactive_value_changed_then_PropertyChanged_event_should_be_raised() { // Arrange var counter = Reactive.Of(0); var eventRaised = false; counter.PropertyChanged += (s, e) => eventRaised = true; // Act ++counter.Value; // Assert eventRaised.Should().BeTrue(); }
public void Getters_and_setters_can_be_chained() { // Arrange var counter = Reactive.Of(1); // Act var adjustedCounter = counter .Set((x, value) => x.Value = value < 1 ? 1 : value) .Get(x => x.Value == 1 ? 10 : x); adjustedCounter.Value = 0; // Assert adjustedCounter.Value.Should().Be(10); }
public void For_Value_reactive_when_value_is_set_silently_then_PropertyChanged_should_not_be_raised() { // Arrange var counter = Reactive.Of(0); var eventRaised = false; counter.PropertyChanged += (sender, args) => eventRaised = true; // Act counter.SetValueSilently(1); // Assert eventRaised.Should().BeFalse(); counter.Value.Should().Be(1); }
public void Setters_can_be_chained() { // Arrange var counter = Reactive.Of(0); // Act var adjustedCounter = counter .Set((x, value) => x.Value = value < 0 ? 0 : value) .Set(i => - i); adjustedCounter.Value = 1; // Assert adjustedCounter.Value.Should().Be(0); }
public void Validation_result_should_be_available_from_IDataErrorInfo_Indexer_ignoring_indexer_argument() { // Arrange var counter = Reactive.Of(0); const string invalidValueResultFormat = "Invalid value provided: {0}"; var validatingCounter = counter.Validate(x => false, x => string.Format(invalidValueResultFormat, x)); // Act validatingCounter.Value = 1; // Assert const string ignored = null; validatingCounter[ignored].Should().Be(string.Format(invalidValueResultFormat, 1)); }
public void When_CanExecute_reactive_condition_changed_then_command_CanExecuteChanged_event_should_be_raised() { // Arrange var canExecute = Reactive.Of(false); var command = Reactive.Command(() => { }, canExecute); var eventRaised = false; command.CanExecuteChanged += (sender, args) => eventRaised = true; // Act canExecute.Value = !canExecute.Value; // Assert eventRaised.Should().BeTrue(); }
public void When_more_than_one_validation_applied_and_first_is_failed_then_the_second_should_not_be_called() { // Arrange const string a = "a"; var secondValidationCalled = false; var message = Reactive.Of <string>() .Validate(x => !x.Contains(a), string.Empty) .Validate(x => secondValidationCalled = true, string.Empty); // Act message.Value = a; // Assert secondValidationCalled.Should().BeFalse(); }
public void The_same_validation_result_should_be_obtained_both_from_IDataErrorInfo_Indexer_and_Error_property() { // Arrange var counter = Reactive.Of(0); const string invalidValueResultFormat = "Invalid value provided: {0}"; var validatingCounter = counter.Validate(x => false, x => string.Format(invalidValueResultFormat, x)); // Act validatingCounter.Value = 1; // Assert const string ignored = null; var validationInfo = (IDataErrorInfo)validatingCounter; validationInfo.Error.Should().Be(validationInfo[ignored]); }
// NOTE Test is indicator that Reactive.OnChange is not working as expected public void OnChange_should_not_call_handler_when_subscriber_is_collected() { // Arrange var observer = new Observer(); var model = new SomeModel(observer); var counter = Reactive.Of(0).OnChange(model.Change); // Act model = null; GC.Collect(); counter.Value = 1; // Assert observer.ChangedObserved.Should().BeFalse(); }
public void When_more_than_one_validation_is_failing_then_Error_should_contain_message_from_the_first() { // Arrange const string a = "a"; const string b = "b"; var message = Reactive.Of <string>() .Validate(x => !x.Contains(a), a) .Validate(x => !x.Contains(b), b); // Act message.Value = a + b; // Assert message.Error.Should().Be(a); }
public void Should_be_able_to_get_reactive_validation_info_for_validating_reactive() { // Arrange const string counterShouldbeGreaterThanZero = "Should be greater than 0"; Reactive <int> counter = Reactive.Of(10) .Validate(x => x > 0, counterShouldbeGreaterThanZero); // Act counter.Value = 0; var isValid = counter.IsValid(); var validationError = counter.ValidationError(); // Assert isValid.Value.Should().BeFalse(); validationError.Value.Should().Be(counterShouldbeGreaterThanZero); }
public void PropertyChanged_should_not_call_weakly_subscribed_subscriber_when_subscriber_is_collected() { // Arrange var observer = new Observer(); var model = new SomeModel(observer); var counter = Reactive.Of(0); counter.SubscribeWeakly(model, (m, s, e) => m.Change(s)); // Act model = null; GC.Collect(); counter.Value = 1; // Assert observer.ChangedObserved.Should().BeFalse(); }
public void CanExecuteChanged_is_weak_event_so_when_handler_collected_then_event_should_not_be_handled() { // Arrange var canExecute = Reactive.Of(false); var command = Reactive.Command(() => { }, canExecute); var handled = false; command.CanExecuteChanged += (sender, args) => handled = true; // Act GC.Collect(); canExecute.Value = true; // Assert handled.Should().BeFalse(); }
public void PropertyChanged_should_call_weakly_subscribed_handler_when_handler_is_collected2() { // Arrange var observer = new Observer(); var model = new SomeModel(observer); var counter = Reactive.Of(0); counter.SubscribeWeakly(x => x.Value, model.Change); // Act model = null; GC.Collect(); counter.Value = 1; // Assert observer.ChangedObserved.Should().BeFalse(); }
public void CanExecuteChanged_wont_be_raised_if_condition_is_not_reactive() { // Arrange bool[] nonReactiveConditionSource = { false }; var canExecute = Reactive.Of(() => nonReactiveConditionSource[0]); var command = Reactive.Command(() => { }, canExecute); var raised = false; command.CanExecuteChanged += (sender, e) => raised = true; // Act nonReactiveConditionSource[0] = true; // Assert raised.Should().BeFalse(); }
public void Framework_should_be_able_to_unsubscribe_from_CanExecuteChanged() { // Arrange var condition = Reactive.Of(false); var command = Reactive.Command(() => { }, condition); var handled = false; EventHandler onCanExecuteChanged = (sender, args) => handled = true; command.CanExecuteChanged += onCanExecuteChanged; // Act command.CanExecuteChanged -= onCanExecuteChanged; condition.Value = true; // Assert handled.Should().BeFalse(); }
public void After_GC_collecting_proxy_and_notifying_change_source_the_Proxy_should_be_unsubscribed_from_change_source() { // Arrange var counter = Reactive.Of(0); var twiceCounter = Reactive.Of(() => counter.Value * 2, counter); var handled = false; twiceCounter.PropertyChanged += ((sender, args) => handled = true); // Act // ReSharper disable RedundantAssignment twiceCounter = null; // ReSharper restore RedundantAssignment GC.Collect(); counter.Value = 1; // Assert handled.Should().BeFalse(); }