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();
}