public void Refresh_OfCollectionProperty_RevalidatesItems() { ParameterizedTest .TestCase("InstanceProperty", new Func <RootVMDescriptor, IVMPropertyDescriptor <IVMCollection <ChildVM> > >(x => x.InstanceProperty)) .TestCase("WrapperProperty", x => x.WrapperProperty) .TestCase("PopulatedProperty", x => x.PopulatedProperty) .Run(propertySelector => { var collection = VM.GetValue(propertySelector); var item = new ChildVM(new ChildSource()); collection.Add(item); VM.PopulatedPropertyResult = new List <ChildVM> { item }; VM.ValidatorResults.Reset(); VM.Refresh(propertySelector); VM.ValidatorResults.VerifySetupValidationResults(); VM.ValidatorResults.SetupFailing().CollectionPropertyValidation .Targeting(item, x => x.ChildProperty) .On(VM); VM.Refresh(propertySelector); VM.ValidatorResults.VerifySetupValidationResults(); }); }
public void VariousOperations_PublishCorrectEvents() { ParameterizedTest .TestCase <Action <ScreenLifecycleOperations>, IEvent>(x => x.Initialize(), ScreenEvents.Initialize()) .TestCase(x => x.Initialize(new Subject()), ScreenEvents.Initialize <Subject>()) .TestCase(x => x.Activate(), ScreenEvents.Activate) .TestCase(x => x.Deactivate(), ScreenEvents.Deactivate) .TestCase(x => x.RequestClose(), ScreenEvents.RequestClose) .TestCase(x => x.Close(), ScreenEvents.Close) .Run((lifecycleAction, expectedEvent) => { List <IEvent> actualEvents = new List <IEvent>(); TestScreen screen = new TestScreen(); ScreenLifecycleOperations ops = new ScreenLifecycleOperations(Aggregator, screen); AddEventHandlerForAllEvents( screen, handlerAction: actualEvents.Add, includeExceptionOccured: true ); lifecycleAction(ops); IEvent actualEvent = actualEvents.SingleOrDefault(); Assert.AreEqual(expectedEvent, actualEvent); }); }
public void ExceptionState_HandlesEventsCorrectly() { ParameterizedTest .TestCase(InvalidStateException(LifecycleState.ExceptionOccured, TriggerEvent.LifecycleException)) .TestCase(InvalidStateException(LifecycleState.ExceptionOccured, TriggerEvent.Initialize)) .TestCase(InvalidStateException(LifecycleState.ExceptionOccured, TriggerEvent.InitializeSubject)) .TestCase(InvalidStateException(LifecycleState.ExceptionOccured, TriggerEvent.Activate)) .TestCase(InvalidStateException(LifecycleState.ExceptionOccured, TriggerEvent.Deactivate)) .TestCase(InvalidStateException(LifecycleState.ExceptionOccured, TriggerEvent.RequestClose)) .TestCase(InvalidStateException(LifecycleState.ExceptionOccured, TriggerEvent.Close)) .Run(ExecuteTestCase); }
public void InitializedState_HandlesEventsCorrectly() { ParameterizedTest .TestCase(Success(LifecycleState.Initialized, TriggerEvent.Initialize, LifecycleState.Initialized)) .TestCase(Success(LifecycleState.Initialized, TriggerEvent.InitializeSubject, LifecycleState.Initialized)) .TestCase(Success(LifecycleState.Initialized, TriggerEvent.Activate, LifecycleState.Activated, ScreenEvents.Activate)) .TestCase(Success(LifecycleState.Initialized, TriggerEvent.Close, LifecycleState.Closed, ScreenEvents.Close)) .TestCase(Success(LifecycleState.Initialized, TriggerEvent.RequestClose, LifecycleState.Initialized, ScreenEvents.RequestClose)) .TestCase(Success(LifecycleState.Initialized, TriggerEvent.LifecycleException, LifecycleState.ExceptionOccured, ScreenEvents.Close)) .TestCase(InvalidStateException(LifecycleState.Initialized, TriggerEvent.Deactivate)) .Run(ExecuteTestCase); }
public void SetValue_RaisesAppropriateChangeNotifications() { ValueStage noChangeNotifciation = null; EmployeeVM vm = EmployeeVM.Create(b => { b.Check(x => x.NumericProperty).ValueInRange(min: 1, max: 10); }); Action <int, int, int, ValueStage> testCode = ( oldValue, oldSourceValue, newValue, expectedChangeNotification ) => { vm.SetValue(x => x.NumericProperty, oldSourceValue); vm.SetValue(x => x.NumericProperty, oldValue); vm.OnChangeInvocations.Clear(); vm.SetValue(x => x.NumericProperty, newValue); IEnumerable <ChangeArgs> args = vm .OnChangeInvocations .Where(x => x.ChangeType == ChangeType.PropertyChanged); if (expectedChangeNotification != null) { Assert.AreEqual(1, args.Count(), "Expected a single change notification."); ChangeArgs arg = args.Single(); Assert.AreEqual(expectedChangeNotification, arg.Stage); } else { Assert.AreEqual(0, args.Count(), "Expected no change notification."); } }; // Valid values: { 5, 6 }, invalid values: { 77, 78 } ParameterizedTest // oldValue | oldSourceValue | newValue | expectedChange .TestCase(5, 5, 5, noChangeNotifciation) .TestCase(5, 5, 6, ValueStage.ValidatedValue) .TestCase(5, 5, 77, ValueStage.Value) .TestCase(77, 5, 77, noChangeNotifciation) .TestCase(77, 5, 78, ValueStage.Value) .TestCase(77, 5, 5, ValueStage.Value) .TestCase(77, 5, 6, ValueStage.ValidatedValue) .Run(testCode); }
public void Refresh_OfViewModelProperty_RevalidatesPropertyValue() { ParameterizedTest .TestCase("InstanceProperty", new Func <RootVMDescriptor, IVMPropertyDescriptor>(x => x.InstanceProperty)) .TestCase("MappedProperty", x => x.WrapperProperty) .TestCase("DelegateProperty", x => x.DelegateProperty) .Run(propertySelector => { var property = propertySelector(VM.Descriptor); var expectedError = "Validation error"; VM.ValidationErrors[property] = expectedError; VM.Refresh(propertySelector); ValidationAssert.ErrorMessages(VM.GetValidationResult(property), expectedError); }); }
public void ConvertFrom_String() { ParameterizedTest<string, OutlinerVersion> tester = new ParameterizedTest<string, OutlinerVersion>(); tester.Method = delegate(string input) { OutlinerVersionConverter converter = new OutlinerVersionConverter(); return converter.ConvertFrom(input) as OutlinerVersion; }; tester.Test("1.0.0", new OutlinerVersion(1, 0, 0)); tester.Test("1.0.0 ", new OutlinerVersion(1, 0, 0)); tester.Test("1.0.0 alpha", new OutlinerVersion(1, 0, 0, ReleaseStage.Alpha)); tester.Test("1.0.0 beta", new OutlinerVersion(1, 0, 0, ReleaseStage.Beta)); tester.Test("2.3.4", new OutlinerVersion(2, 3, 4)); }
public void VariousOperations_WhenHandlerThrowsException_RaiseLifecycleExceptionOccuredEventAndThrowLifecycleException() { ParameterizedTest .TestCase <Action <ScreenLifecycleOperations>, IEvent>(x => x.Initialize(), ScreenEvents.Initialize()) .TestCase(x => x.Initialize(new Subject()), ScreenEvents.Initialize <Subject>()) .TestCase(x => x.Activate(), ScreenEvents.Activate) .TestCase(x => x.Deactivate(), ScreenEvents.Deactivate) .TestCase(x => x.RequestClose(), ScreenEvents.RequestClose) .TestCase(x => x.Close(), ScreenEvents.Close) .Run((lifecycleAction, expectedEvent) => { List <IEvent> actualEvents = new List <IEvent>(); TestScreen screen = new TestScreen(); ScreenLifecycleOperations ops = new ScreenLifecycleOperations(Aggregator, screen); InvalidOperationException sourceException = new InvalidOperationException(); AddEventHandlerForAllEvents( screen, handlerAction: e => { actualEvents.Add(e); throw sourceException; }, includeExceptionOccured: false ); AddEventHandlerFor( ScreenEvents.LifecycleExceptionOccured, screen, handlerAction: (ev, _) => actualEvents.Add(ev) ); var exceptionExpr = AssertHelper.Throws <ScreenLifecycleException>(() => lifecycleAction(ops) ); CollectionAssert.AreEquivalent( new IEvent[] { expectedEvent, ScreenEvents.LifecycleExceptionOccured }, actualEvents ); Assert.AreEqual(sourceException, exceptionExpr.Exception.InnerException); }); }
public void CompareTo() { ParameterizedTest<OutlinerVersion, OutlinerVersion, int> tester = new ParameterizedTest<OutlinerVersion, OutlinerVersion, int>(); tester.Method = delegate(OutlinerVersion vX, OutlinerVersion vY) { return vX.CompareTo(vY); }; tester.Test(new OutlinerVersion(), null, 1); tester.Test(new OutlinerVersion(), new OutlinerVersion(), 0); tester.Test(new OutlinerVersion(1, 0, 0), new OutlinerVersion(2, 0, 0), -1); tester.Test(new OutlinerVersion(1, 0, 0), new OutlinerVersion(1, 1, 0), -1); tester.Test(new OutlinerVersion(1, 0, 0), new OutlinerVersion(1, 0, 1), -1); tester.Test(new OutlinerVersion(1, 0, 0, ReleaseStage.Alpha), new OutlinerVersion(1, 0, 0, ReleaseStage.Beta), -1); tester.Test(new OutlinerVersion(1, 0, 0, ReleaseStage.Beta), new OutlinerVersion(1, 0, 0, ReleaseStage.Release), -1); tester.Test(new OutlinerVersion(2, 0, 0), new OutlinerVersion(1, 0, 0, 0), 1); }
public void Refresh_OfSimpleProperty_CallsNotifyChange() { ParameterizedTest .TestCase("InstanceProperty", new Func <RootVMDescriptor, IVMPropertyDescriptor>(x => x.InstanceProperty)) .TestCase("MappedProperty", x => x.MappedProperty) .TestCase("DelegateProperty", x => x.DelegateProperty) .Run(propertySelector => { VM.OnChangeInvocations.Clear(); VM.Refresh(propertySelector); var expectedChangaArgs = ChangeArgs .PropertyChanged(propertySelector(VM.Descriptor), ValueStage.ValidatedValue) .PrependViewModel(VM); DomainAssert.AreEqual(new[] { expectedChangaArgs }, VM.OnChangeInvocations); }); }
public void GetValidationResult_Initially_ReturnsValidResults() { var vm = new TestVM(); ParameterizedTest .TestCase(ValidationResultScope.PropertiesOnly) .TestCase(ValidationResultScope.ViewModelValidationsOnly) .TestCase(ValidationResultScope.Self) .TestCase(ValidationResultScope.Descendants) .TestCase(ValidationResultScope.All) .Run(scope => { var result = vm .Behavior .GetValidationResult(vm.GetContext(), scope); ValidationAssert.IsValid(result); }); }
public void Refresh_OfCollectionProperty_CallCollectionValidatorOnlyOnceForAllItems() { ParameterizedTest .TestCase("InstanceProperty", new Func <RootVMDescriptor, IVMPropertyDescriptor <IVMCollection <ChildVM> > >(x => x.InstanceProperty)) .TestCase("WrapperProperty", x => x.WrapperProperty) .TestCase("PopulatedProperty", x => x.PopulatedProperty) .Run(propertySelector => { var collection = VM.GetValue(propertySelector); var firstItem = new ChildVM(new ChildSource()); var secondItem = new ChildVM(new ChildSource()); collection.Add(firstItem); collection.Add(secondItem); VM.PopulatedPropertyResult = new List <ChildVM> { firstItem, secondItem }; VM.ValidatorResults.Reset(); VM.ValidatorResults.ExpectInvocationOf.CollectionPropertyValidation .Targeting(collection, x => x.ChildProperty) .On(VM); VM.Refresh(propertySelector); VM.ValidatorResults.VerifyInvocationSequence(); }); }