public void AsyncValidation_SyncRule_ExecutedAsyncroniously() { TestUtils.ExecuteWithDispatcher((dispatcher, completedAction) => { var vm = new DummyViewModel(); vm.Foo = null; var validation = new ValidationHelper(); validation.AddRule(() => { Assert.False(dispatcher.Thread.ManagedThreadId == Thread.CurrentThread.ManagedThreadId, "Rule must be executed in a background thread."); if (string.IsNullOrEmpty(vm.Foo)) { return(RuleResult.Invalid("Foo cannot be empty string.")); } return(RuleResult.Valid()); }); validation.ValidateAllAsync().ContinueWith(r => completedAction()); }); }
public void RemoveAllRules_HadTwoNegativeRulesRegisteredForDifferentTargets_ResultChangedIsFiredForAllTargets() { // ARRANGE var dummy = new DummyViewModel(); var validation = new ValidationHelper(); validation.AddRule(() => dummy.Foo, () => RuleResult.Invalid("error1")); validation.AddRule(() => dummy.Bar, () => RuleResult.Invalid("error2")); validation.ValidateAll(); int resultChangedFiredCount = 0; validation.ResultChanged += (sender, args) => { resultChangedFiredCount++; }; // ACT validation.RemoveAllRules(); // VERIFY Assert.Equal(2, resultChangedFiredCount); }
public void GetViewTest() { IView view = new ViewMock(); DummyViewModel viewModel = new DummyViewModel(view); Assert.AreEqual(view, viewModel.View); }
public void DoesNotLeakMemory() { var vm = new DummyViewModel { NullableDoubleValue = null }; var textBox = new TextBox { DataContext = vm }; textBox.SetCulture(new CultureInfo("en-US")); textBox.SetDecimalDigits(2); var binding = new Binding { Path = new PropertyPath(DummyViewModel.NullableDoubleValuePropertyName), Mode = BindingMode.TwoWay }; BindingOperations.SetBinding(textBox, Input.ValueProperty, binding); var wr = new WeakReference(textBox); textBox = null; GC.Collect(); Assert.IsFalse(wr.IsAlive); }
public void UpdatesWhenCultureChanges() { var vm = new DummyViewModel { NullableDoubleValue = 3 }; var textBox = new TextBox { DataContext = vm }; var binding = new Binding { Path = new PropertyPath(DummyViewModel.NullableDoubleValuePropertyName), Mode = BindingMode.TwoWay }; BindingOperations.SetBinding(textBox, Input.ValueProperty, binding); textBox.RaiseLoadedEvent(); textBox.SetCulture(new CultureInfo("en-US")); textBox.WriteText("1,2", true); AssertError <CanParseError>(textBox); Assert.AreEqual(3, textBox.GetValue(Input.ValueProperty)); Assert.AreEqual(3, vm.NullableDoubleValue); textBox.SetCulture(new CultureInfo("sv-SE")); AssertNoError(textBox); Assert.AreEqual(1.2, textBox.GetValue(Input.ValueProperty)); Assert.AreEqual(1.2, vm.NullableDoubleValue); }
public void ValidatedAsync_AsyncRuleDoesnotCallCallback_ThrowsAnExceptionAfterTimeout() { TestUtils.ExecuteWithDispatcher((uiThreadDispatcher, completedAction) => { // ARRANGE var validation = new ValidationHelper(); validation.AsyncRuleExecutionTimeout = TimeSpan.FromSeconds(0.1); var dummy = new DummyViewModel(); validation.AddAsyncRule(() => dummy.Foo, onCompleted => { // Do nothing }); // ACT var ui = TaskScheduler.FromCurrentSynchronizationContext(); validation.ValidateAllAsync().ContinueWith(result => { Assert.True(result.IsFaulted, "Validation task must fail."); Assert.NotNull(result.Exception); completedAction(); }, ui); }); }
public void ValidateAsync_WithCallback_ValidationOccuredAndCallbackIsCalledOnUIThread() { TestUtils.ExecuteWithDispatcher((dispatcher, completedAction) => { var vm = new DummyViewModel(); vm.Foo = null; bool ruleExecuted = false; var validation = new ValidationHelper(); validation.AddAsyncRule(setResult => { ruleExecuted = true; setResult(RuleResult.Invalid("Error1")); }); validation.ValidateAllAsync(result => { Assert.True(ruleExecuted, "Validation rule must be executed before validation callback is called."); Assert.Equal(dispatcher.Thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId); completedAction(); }); }); }
public void UpdatesOnCultureChange() { var vm = new DummyViewModel { NullableDoubleValue = null }; int count = 0; vm.PropertyChanged += (_, __) => count++; var textBox = new TextBox { DataContext = vm }; textBox.SetCulture(new CultureInfo("en-US")); var binding = new Binding { Path = new PropertyPath(DummyViewModel.NullableDoubleValuePropertyName), UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged, Mode = BindingMode.TwoWay }; BindingOperations.SetBinding(textBox, Input.ValueProperty, binding); textBox.RaiseLoadedEvent(); Assert.IsNullOrEmpty(textBox.GetRawText()); Assert.AreEqual(null, textBox.GetRawValue()); textBox.WriteText("1.234"); Assert.AreEqual(1, count); Assert.AreEqual("1.234", textBox.Text); textBox.SetCulture(new CultureInfo("sv-SE")); Assert.AreEqual(1, count); Assert.AreEqual("1,234", textBox.Text); }
public void AsyncValidation_DependantProperties_IfOneInvalidSecondIsInvalidToo() { TestUtils.ExecuteWithDispatcher((dispatcher, testCompleted) => { var vm = new DummyViewModel { Foo = "abc", Bar = "abc" }; Func <bool> validCondition = () => vm.Foo != vm.Bar; var validation = new ValidationHelper(); validation.AddAsyncRule( () => vm.Foo, () => vm.Bar, setResult => { ThreadPool.QueueUserWorkItem(_ => { setResult(RuleResult.Assert(validCondition(), "Foo must be different than bar")); }); }); validation.ValidateAsync(() => vm.Bar).ContinueWith(r => { Assert.False(r.Result.IsValid, "Validation must fail"); Assert.True(r.Result.ErrorList.Count == 2, "There must be 2 errors: one for each dependant property"); testCompleted(); }); }); }
public void ResultChanged_ValidateExecutedForSeveralRules_FiresForEachTarget() { // Arrange var validation = new ValidationHelper(); var dummy = new DummyViewModel(); validation.AddRule(nameof(dummy.Foo), () => RuleResult.Invalid("Error")); validation.AddRule(nameof(dummy.Foo), RuleResult.Valid); validation.AddRule(nameof(dummy.Bar), RuleResult.Valid); validation.AddRule(() => RuleResult.Invalid("Error")); const int expectedTimesToFire = 0 + 1 /*Invalid Foo*/ + 1 /* Invalid general target */; var eventFiredTimes = 0; validation.ResultChanged += (o, e) => { eventFiredTimes++; }; // Act validation.ValidateAll(); // Verify Assert.Equal(expectedTimesToFire, eventFiredTimes); }
public void ResetsOnDataContext() { var textBox = new TextBox(); textBox.SetCulture(new CultureInfo("en-US")); textBox.SetDecimalDigits(2); var binding = new Binding { Path = new PropertyPath(DummyViewModel.NullableDoubleValuePropertyName), Mode = BindingMode.TwoWay }; BindingOperations.SetBinding(textBox, Input.ValueProperty, binding); Assert.Inconclusive("What is most right here? Maybe propagating the value from vm -> view"); textBox.WriteText("1.234"); Assert.AreEqual("1.234", textBox.GetRawText()); Assert.AreEqual(RawValueTracker.Unset, textBox.GetRawValue()); Assert.AreEqual(RawValueSource.User, textBox.GetRawValueSource()); var vm = new DummyViewModel { NullableDoubleValue = null }; textBox.DataContext = vm; Assert.AreEqual("1.234", textBox.GetRawText()); Assert.AreEqual(1.234, textBox.GetRawValue()); Assert.AreEqual(RawValueSource.User, textBox.GetRawValueSource()); }
public void Validate_MultipleRulesForSameTarget_ClearsResultsBeforeValidation() { // ARRANGE var validation = new ValidationHelper(); var dummy = new DummyViewModel(); RuleResult firstRuleResult = RuleResult.Valid(); RuleResult secondRuleResult = RuleResult.Invalid("Error2"); validation.AddRule(nameof(dummy.Foo), () => { return(firstRuleResult); }); validation.AddRule(nameof(dummy.Foo), () => { return(secondRuleResult); }); // ACT validation.ValidateAll(); firstRuleResult = RuleResult.Invalid("Error1"); validation.ValidateAll(); // VERIFY var result = validation.GetResult(nameof(dummy.Foo)); Assert.False(result.IsValid); Assert.Equal(1, result.ErrorList.Count); Assert.Equal("Error1", result.ErrorList[0].ErrorText); }
public void Validate_MultipleRulesForSameTarget_DoesNotExecuteRulesIfPerviousFailed() { // ARRANGE var validation = new ValidationHelper(); var dummy = new DummyViewModel(); bool firstRuleExecuted = false; bool secondRuleExecuted = false; validation.AddRule(nameof(dummy.Foo), () => { firstRuleExecuted = true; return(RuleResult.Invalid("Error1")); }); validation.AddRule(nameof(dummy.Foo), () => { secondRuleExecuted = true; return(RuleResult.Invalid("Error2")); }); // ACT validation.ValidateAll(); // VERIFY Assert.True(firstRuleExecuted, "First rule must have been executed"); Assert.False(secondRuleExecuted, "Second rule should not have been executed because first rule failed."); }
public void RemoveRule_ThereAreTwoFailedRules_RemoveOne_ResultChangedShouldBeFiredWithNewResultStillInvalid() { // ARRANGE var dummy = new DummyViewModel(); var validation = new ValidationHelper(); validation.AddRule(nameof(dummy.Foo), () => RuleResult.Invalid("error2")); var invalidRule = validation.AddRule(nameof(dummy.Foo), () => RuleResult.Invalid("error")); var validationResult = validation.ValidateAll(); Assert.False(validationResult.IsValid); bool resultChangedEventFired = false; validation.ResultChanged += (sender, args) => { Assert.Equal(nameof(dummy.Foo), args.Target); Assert.False(args.NewResult.IsValid); resultChangedEventFired = true; }; // ACT validation.RemoveRule(invalidRule); // VERIFY Assert.True(resultChangedEventFired); }
public void UpdatesWhenVmChanges() { var vm = new DummyViewModel { NullableDoubleValue = null }; var textBox = new TextBox { DataContext = vm }; textBox.SetCulture(new CultureInfo("en-US")); textBox.SetDecimalDigits(2); var binding = new Binding { Path = new PropertyPath(DummyViewModel.NullableDoubleValuePropertyName), Mode = BindingMode.TwoWay }; BindingOperations.SetBinding(textBox, Input.ValueProperty, binding); textBox.RaiseLoadedEvent(); Assert.IsNullOrEmpty(textBox.GetRawText()); Assert.AreEqual(null, textBox.GetRawValue()); vm.NullableDoubleValue = 1.23456; Assert.AreEqual("1.23456", textBox.GetRawText()); Assert.AreEqual(1.23456, textBox.GetRawValue()); Assert.AreEqual(RawValueSource.Binding, textBox.GetRawValueSource()); }
public void UpdatesOnUserErrorInput() { var vm = new DummyViewModel { NullableDoubleValue = null }; var textBox = new TextBox { DataContext = vm }; textBox.SetCulture(new CultureInfo("en-US")); textBox.SetDecimalDigits(2); var binding = new Binding { Path = new PropertyPath(DummyViewModel.NullableDoubleValuePropertyName), Mode = BindingMode.TwoWay }; BindingOperations.SetBinding(textBox, Input.ValueProperty, binding); textBox.RaiseLoadedEvent(); Assert.IsNullOrEmpty(textBox.GetRawText()); Assert.AreEqual(null, textBox.GetRawValue()); textBox.WriteText("1.2dae"); Assert.AreEqual("1.2dae", textBox.GetRawText()); Assert.AreEqual(RawValueTracker.Unset, textBox.GetRawValue()); Assert.AreEqual(RawValueSource.User, textBox.GetRawValueSource()); }
public void PropertyLambaMustNotBeAMethodCall() { var dummyControl = new DummyControl(); var dummyViewModel = new DummyViewModel(); var ex = Record.Exception(() => dummyControl.Bind(_ => _.ToString(), dummyViewModel, _ => _.ToString())); Assert.NotNull(ex); Assert.Equal(string.Format(Extensions.EXPRESSION_REFERS_METHOD, "_ => _.ToString()"), ex.Message); }
/// <summary>A helper method that acts as a receiver for events.</summary> /// <param name="sender">The object that raised the event.</param> /// <param name="e">Information regarding the event.</param> private void ReceivePropertyChangedEvent(object sender, PropertyChangedEventArgs e) { DummyViewModel testSubject = sender as DummyViewModel; if (testSubject != null) { testSubject.IsHandledByEvent = true; } }
public void PropertyLambaMustNotBeAField() { var dummyControl = new DummyControl(); var dummyViewModel = new DummyViewModel(); var ex = Record.Exception(() => dummyControl.Bind(_ => _.DummyString, dummyViewModel, _ => _._DummyString)); Assert.NotNull(ex); Assert.Equal(string.Format(Extensions.EXPRESSION_REFERS_FIELD, "_ => _.DummyString"), ex.Message); }
public void SetUp() { _vm = new DummyViewModel(); _doubleBox = CreateTextBox("DoubleValue"); _intBox = CreateTextBox("IntValue"); _grid = new Grid(); _grid.Children.Add(_doubleBox); _grid.Children.Add(_intBox); _grid.SetIsValidationScope(true); }
public void AsyncValidation_ExecutedInsideUIThreadTask_ValidationRunsInBackgroundThread() { // This test checks the situation described here: // http://stackoverflow.com/questions/6800705/why-is-taskscheduler-current-the-default-taskscheduler // In short: if a continuation of a task runs on the UI thread, then the tasks that you start using // Task.Factory.StartNew will run also on the UI thread. This is unexpected an may cause a deadlock, or freezing UI. TestUtils.ExecuteWithDispatcher((uiThreadDispatcher, completedAction) => { // ARRANGE var validation = new ValidationHelper(); var dummy = new DummyViewModel(); int uiThreadId = Thread.CurrentThread.ManagedThreadId; int validationThreadId = uiThreadId; validation.AddAsyncRule(nameof(dummy.Foo), () => { return(Task.Run(() => { validationThreadId = Thread.CurrentThread.ManagedThreadId; return RuleResult.Valid(); })); }); // ACT // Execute validation within a continuation of another task that runs on // current synchronization context, so that the TaskScheduler.Current is set to the // UI context. Task.Factory.StartNew(() => { }).ContinueWith(t => { Task <ValidationResult> task = validation.ValidateAllAsync(); task.ContinueWith(result => { // VERIFY // Schedule the varification code with the dispatcher in order to take it // out of the ContinueWith continuation. Otherwise the exceptions will be stored inside the task and // unit testing framework will not know about them. uiThreadDispatcher.BeginInvoke(new Action(() => { Assert.False(uiThreadId == validationThreadId, "Validation must be executed in a background thread, so that the UI thread is not blocked."); completedAction(); })); }); }, TaskScheduler.FromCurrentSynchronizationContext()); }); }
public void AsyncValidation_GeneralSmokeTest() { TestUtils.ExecuteWithDispatcher((dispatcher, completedAction) => { var vm = new DummyViewModel { Foo = null }; var validation = new ValidationHelper(); bool ruleExecuted = false; // OK, this is really strange, but if Action<bool> is not mentioned anywhere in the project, then ReSharter would fail to build and run the test... // So including the following line to fix it. Action <RuleResult> dummy = null; Assert.Null(dummy); // Getting rid of the "unused variable" warning. validation.AddAsyncRule(async() => { return(await Task.Run(() => { ruleExecuted = true; return RuleResult.Invalid("Foo cannot be empty string."); })); }); validation.ResultChanged += (o, e) => { Assert.True(ruleExecuted, "Validation rule must be executed before ValidationCompleted event is fired."); var isUiThread = dispatcher.Thread.ManagedThreadId == Thread.CurrentThread.ManagedThreadId; Assert.True(isUiThread, "ValidationResultChanged must be executed on UI thread"); }; var ui = TaskScheduler.FromCurrentSynchronizationContext(); validation.ValidateAllAsync().ContinueWith(r => { var isUiThread = dispatcher.Thread.ManagedThreadId == Thread.CurrentThread.ManagedThreadId; Assert.True(isUiThread, "Validation callback must be executed on UI thread"); Assert.False(r.Result.IsValid, "Validation must fail according to the validaton rule"); Assert.False(validation.GetResult().IsValid, "Validation must fail according to the validaton rule"); Assert.True(ruleExecuted, "Rule must be executed before validation completed callback is executed."); completedAction(); }, ui); }); }
public void SampleSite_DummyTest1() { // Arrange var model = new DummyViewModel(); var firstNumber = 10; var secondNumber = 20; // Act var result = model.Add(firstNumber, secondNumber); // Assert Assert.Equal(30, result); }
/// <summary>A helper method that acts as a receiver for messages.</summary> /// <param name="message">The received message.</param> private void ReceivePropertyChangedMessage(PropertyChangedMessage <int> message) { DummyViewModel testSubject = message.Sender as DummyViewModel; if (testSubject != null) { if (message.PropertyName == "IntegerValue" && message.OldValue == testSubject.OriginalIntegerValue && message.NewValue == testSubject.IntegerValue) { testSubject.IsHandledByMessage = true; } } }
// if we use the same action name as Get action does, then // .RedirectToAction() will incorrectly make the link to Post(!) method // the issue occurs for the route patterns such as [controller]/{tenantId}/action_name public IActionResult Same(DummyViewModel vm) { try { return(Content($"Hello, this is HttpPost action")); } catch (Exception ex) { _logger.LogError(ex.Message); return(Content($"Error : {ex.Message}")); } }
public void AsyncValidation_SeveralAsyncRules_AllExecutedBeforeValidationCompleted() { TestUtils.ExecuteWithDispatcher((dispatcher, completedAction) => { var vm = new DummyViewModel(); vm.Foo = null; var validation = new ValidationHelper(); bool rule1Executed = false; validation.AddAsyncRule(() => { return(Task.Run(() => { rule1Executed = true; return RuleResult.Valid(); })); }); bool rule2Executed = false; validation.AddAsyncRule(() => { return(Task.Run(() => { rule2Executed = true; return RuleResult.Valid(); })); }); bool rule3Executed = false; validation.AddAsyncRule(() => { return(Task.Run(() => { rule3Executed = true; return RuleResult.Valid(); })); }); validation.ValidateAllAsync().ContinueWith(r => { Assert.True(rule1Executed); Assert.True(rule2Executed); Assert.True(rule3Executed); Assert.True(r.Result.IsValid); completedAction(); }); }); }
public void ResultChanged_RuleErrorsChangedButRuleValidityDidNotChange_EventStillFires() { // ARRANGE var validation = new ValidationHelper(); var dummy = new DummyViewModel(); validation.AddRule(() => dummy.Foo, () => { if (string.IsNullOrEmpty(dummy.Foo)) { return(RuleResult.Invalid("Foo should not be empty")); } return (RuleResult.Assert(dummy.Foo.Length > 5, "Length must be greater than 5").Combine( RuleResult.Assert(dummy.Foo.Any(Char.IsDigit), "Must contain digit"))); }); var resultChangedCalledTimes = 0; const int expectedResultChangedCalls = 1 /* First invalid value */ + 1 /* Second invalid value */ + 1 /* Third invalid value */ + 1 /* Valid value */; validation.ResultChanged += (o, e) => { resultChangedCalledTimes++; }; // ACT dummy.Foo = null; // Should generage "Foo should not be empty" error validation.ValidateAll(); dummy.Foo = "123"; // Should generate the "Length must be greater than 5" error validation.ValidateAll(); dummy.Foo = "sdfldlssd"; // Should generate the "Must contain digit" error validation.ValidateAll(); dummy.Foo = "lsdklfjsld2342"; // Now should be valid validation.ValidateAll(); // VERIFY Assert.Equal(expectedResultChangedCalls, resultChangedCalledTimes); }
public static Pageable <DummyViewModel> ToPageableDummyViewModel(IEnumerable <DummyModel> src, Pageable <DummyViewModel> dest) { if (src != null) { foreach (var s in src) { var dummyViewModel = new DummyViewModel(); Map(s, dummyViewModel); dest.Add(dummyViewModel); } } return(dest); }
public void ViewModel_PropertyChanged() { /* First, create an instance of the viewmodel */ DummyViewModel testSubject = new DummyViewModel(); /* Set some properties and fixate the test subject */ testSubject.BooleanValue = true; testSubject.IntegerValue = 42; testSubject.Fixate(); /* Register handlers */ testSubject.PropertyChanged += this.ReceivePropertyChangedEvent; testSubject.Messenger.Register <PropertyChangedMessage <bool> >(this, this.ReceivePropertyChangedMessage); testSubject.Messenger.Register <PropertyChangedMessage <int> >(this, this.ReceivePropertyChangedMessage); /* Change the first property */ testSubject.BooleanValue = false; /* Allow for the messenger to process the send-request and the registered action to complete */ int roundtrips = 0; while (roundtrips < 5 && !testSubject.IsHandledByEvent && !testSubject.IsHandledByMessage) { ++roundtrips; Thread.Yield(); } /* Check if any events or messages where received */ Assert.IsTrue(testSubject.IsHandledByEvent); Assert.IsTrue(testSubject.IsHandledByMessage); /* Reset the handled-flags */ testSubject.IsHandledByEvent = false; testSubject.IsHandledByMessage = false; /* Change the second property */ testSubject.IntegerValue = 88; /* Allow for the messenger to process the send-request and the registered action to complete */ roundtrips = 0; while (roundtrips < 5 && !testSubject.IsHandledByEvent && !testSubject.IsHandledByMessage) { ++roundtrips; Thread.Yield(); } /* Check if any events or messages where received */ Assert.IsTrue(testSubject.IsHandledByEvent); Assert.IsFalse(testSubject.IsHandledByMessage); }
public static void Map(DummyModel source, DummyViewModel target) { target.DummyID = source.DummyID; target.Name = source.Name; target.Description = source.Description; target.Date = source.Date; target.Time = source.Time; target.Currency = source.Currency; target.EmailAddress = source.EmailAddress; target.Url = source.Url; target.Decimal1 = source.Decimal1; target.DateTime = source.DateTime ?? DateTime.MinValue; }
public void Handling_main_request_with_main_NOT_already_active_should_work_but_not_create_a_new_instance() { /* Arrange */ var mocks = new TestAssistant().MockAll(); var main = A.Dummy<MainViewModel>(); var active = new DummyViewModel(); var vm = new ShellViewModel(main, mocks.Messenger, mocks.ViewModelFactory); var handler = vm as IHandle<ViewRequest>; vm.ActiveItem = active; vm.MonitorEvents(); /* Act */ handler.Handle(ViewRequest.MainView); /* Assert */ A.CallTo(() => mocks.ViewModelFactory.Get(typeof(DummyViewModel))).MustNotHaveHappened(); vm.ActiveItem.Should().BeSameAs(main); vm.ShouldRaisePropertyChangeFor((svm) => svm.ActiveItem); }
public void Setup() { model = RandomData.GetViewModel(); this.provider = new FluentValidationModelValidatorProvider(new AttributedValidatorFactory()); ModelValidatorProviders.Providers.Add(this.provider); DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false; var viewData = new ViewDataDictionary<DummyViewModel>(model); var mockHttpContext = HttpMocks.GetHttpContextMock(); var controllerContext = new Mock<ControllerContext>(mockHttpContext.Object, new RouteData(), new Mock<ControllerBase>().Object); var mockViewContext = new Mock<ViewContext>( controllerContext.Object, new Mock<IView>().Object, viewData, new TempDataDictionary(), TextWriter.Null); mockViewContext.SetupGet(c => c.ViewData).Returns(viewData); mockViewContext.SetupGet(c => c.HttpContext).Returns(mockHttpContext.Object); var mockViewDataContainer = new Mock<BaseView<DummyViewModel>>(); mockViewDataContainer.Object.SetViewData(viewData); mockViewDataContainer.Setup(v => v.WebElementTranslations).Returns(new WebElementLocalizer(null)); this.htmlHelper = new HtmlHelper<DummyViewModel>(mockViewContext.Object, mockViewDataContainer.Object); }
public void DropDownForNullValueHtmlAttributestStillCreatesMarkup() { DummyViewModel model = new DummyViewModel { SelectListItemListProperty = RandomData.GetSelectListItemDictionary() }; var res = this.htmlHelper.UmaDropDownFor(o => o.StringProperty, model.SelectListItemListProperty).ToString(); //resulet example //<select class="selectpicker" id="StringProperty" name="StringProperty"><option value="">N:ņęįnпdāē</option> res.Should().NotBeNullOrEmpty(); }
public void InitTestFieldValues() { model = RandomData.GetViewModel(); var viewData = new ViewDataDictionary<DummyViewModel>(model); var mockHttpContext = HttpMocks.GetHttpContextMock(); var controllerContext = new Mock<ControllerContext>(mockHttpContext.Object, new RouteData(), new Mock<ControllerBase>().Object); var mockViewContext = new Mock<ViewContext>( controllerContext.Object, new Mock<IView>().Object, viewData, new TempDataDictionary(), TextWriter.Null); mockViewContext.SetupGet(c => c.ViewData).Returns(viewData); mockViewContext.SetupGet(c => c.HttpContext).Returns(mockHttpContext.Object); var mockViewDataContainer = new Mock<BaseView<DummyViewModel>>(); mockViewDataContainer.Object.SetViewData(viewData); mockViewDataContainer.Setup(v => v.WebElementTranslations).Returns(new WebElementLocalizer(null)); this.htmlHelper = new HtmlHelper<DummyViewModel>(mockViewContext.Object, mockViewDataContainer.Object); this.localizer = new WebElementLocalizer(null); }
public void DropDownForEmptyListThrowsException() { DummyViewModel model = new DummyViewModel { SelectListItemListProperty = new Dictionary<string, string>() }; this.htmlHelper.UmaDropDownFor(o => o.StringProperty, model.SelectListItemListProperty, null); }
public void SetUp() { _stubDummyRepository = MockRepository.GenerateStub<IDummyRepository>(); _stubMessageBoxService = MockRepository.GenerateStub<IMessageBoxService>(); _containerFacade = MockRepository.GenerateStub<IContainerFacade>(); _containerFacade.Stub(x => x.Resolve<DummyBrowserViewModel>()).Return( new DummyBrowserViewModel(_stubDummyRepository)); _containerFacade.Stub(x => x.Resolve<DummyDetailViewModel>()).Return( new DummyDetailViewModel()); //EntityBrowserViewModel = (TBrowser) Activator.CreateInstance(typeof (TBrowser), entityRepository); //EntityBrowserViewModel = ContainerFacade.Resolve<TBrowser>(); ////EntityDetailViewModel = (TDetail) Activator.CreateInstance(typeof (TDetail)); //EntityDetailViewModel = ContainerFacade.Resolve<TDetail>(); _dummyViewModel = new DummyViewModel(_stubDummyRepository, _stubMessageBoxService, _containerFacade); Assert.AreEqual(ViewMode.BrowseMode, _dummyViewModel.CurrentViewMode); }