public void Execute_WhenCalledWithEmptyList_Throw()
{
var rule = new ChecklistDisplayFieldsShouldBeUniqueRule(ChecklistFieldsStepEdit.DisplayFieldsProperty);
var context = Mock.Create<RuleContext>(Constructor.Mocked, Behavior.CallOriginal);
var mock1 = Mock.Create<ChecklistDisplayFieldEdit>();
Mock.Arrange(() => mock1.SystemName).Returns("s1");
var mock2 = Mock.Create<ChecklistDisplayFieldEdit>();
Mock.Arrange(() => mock2.SystemName).Returns("s1");
var list = new List<ChecklistDisplayFieldEdit>{mock1, mock2};
Mock.Arrange(() => context.InputPropertyValues).Returns(new Dictionary<IPropertyInfo, object> { { ChecklistFieldsStepEdit.DisplayFieldsProperty, list }});
var checklistFieldsStepEditMock = Mock.Create<ChecklistFieldsStepEdit>();
Mock.Arrange(() => checklistFieldsStepEditMock.GetParent<FieldEdit>()).Returns(new FieldEdit());
Mock.Arrange(() => context.Target).Returns(checklistFieldsStepEditMock);
var ruleWasThrown = false;
Mock.Arrange(() => context.AddErrorResult(Arg.AnyString)).DoInstead(() => ruleWasThrown = true);
// act
var privateAccessor = new PrivateAccessor(rule);
privateAccessor.CallMethod("Execute", new object[] { context });
//Assert
Assert.IsTrue(ruleWasThrown);
}
public void Execute()
{
// arrange
var rule = new ScheduleFrequencyPatternRule(null, null);
var context = Mock.Create<RuleContext>(Constructor.Mocked, Behavior.CallOriginal);
Mock.Arrange(() => context.InputPropertyValues)
.Returns(new Dictionary<IPropertyInfo, object> { { ProcessScheduleEdit.HighlightScheduleFrequencyPatternProperty, 0 }, { ProcessScheduleEdit.ScheduleFrequencyPatternIdProperty, 0 } });
var ruleWasThrown = false;
Mock.Arrange(() => context.AddErrorResult(Arg.IsAny<IPropertyInfo>(), Arg.AnyString)).DoInstead(() => ruleWasThrown = true);
// act
var privateAccessor = new PrivateAccessor(rule);
privateAccessor.CallMethod("Execute", new object[] { context });
// assert
Assert.IsTrue(ruleWasThrown);
// arrange
ruleWasThrown = false;
Mock.Arrange(() => context.InputPropertyValues)
.Returns(new Dictionary<IPropertyInfo, object> { { ProcessScheduleEdit.HighlightScheduleFrequencyPatternProperty, 0 }, { ProcessScheduleEdit.ScheduleFrequencyPatternIdProperty, 1 } });
// act
privateAccessor.CallMethod("Execute", new object[] { context });
// assert
Assert.IsFalse(ruleWasThrown);
}
public void TestOnStepAsyncAtCancel()
{
GeneralThreadAffineContext.Run(
async () =>
{
Mock.Arrange(() => Application.Current.Dispatcher.InvokeAsync(null))
.IgnoreArguments()
.DoNothing();
var managementMock = Mock.Create<CollectionsManagementViewModel>(Behavior.CallOriginal);
var editQueueMock = Mock.Create<EditQueueViewModel>(
Behavior.CallOriginal, managementMock);
Mock.NonPublic.Arrange<Task>(editQueueMock, "UnLockAsync").Returns(Task.Run(() => { }));
Mock.Arrange(() => editQueueMock.SelectedQueue).Returns(new QueueDetailsModel());
Mock.Arrange(
() => managementMock.OnStepAsync(CollectionsManagementViewModel.EnumSteps.SelectQueue))
.Returns(Task.Run(() => { }));
var mainView = new PrivateAccessor(editQueueMock);
mainView.SetProperty("IsCheckedOut", true);
await editQueueMock.OnStepAsync(EditQueueViewModel.EnumSteps.Cancel);
bool isCheckedOutOnMainViewModel = mainView.GetProperty("IsCheckedOut") is bool && (bool)mainView.GetProperty("IsCheckedOut");
Assert.IsFalse(isCheckedOutOnMainViewModel);
});
}
public void CheckPropertiesInitialValuesTest()
{
//Mock spreadsheet
var spreadsheetMock = Mock.Create<SpreadsheetView>(Constructor.Mocked, Behavior.Loose);
Mock.Arrange(() => spreadsheetMock.GetTopLevelSpreadsheet()).CallOriginal();
//Call constructor
var container = new SpreadsheetItemContainer(spreadsheetMock);
var privateAccessor = new PrivateAccessor(container);
//Assert fields
Assert.IsNotNull(privateAccessor.GetField("_topLevelSpreadsheet"));
Assert.AreEqual(privateAccessor.GetField("_topLevelSpreadsheet"), spreadsheetMock);
Assert.IsNotNull(privateAccessor.GetField("_owner"));
Assert.AreEqual(privateAccessor.GetField("_owner"), spreadsheetMock);
Assert.IsNull(privateAccessor.GetField("_item"));
Assert.IsFalse((bool)privateAccessor.GetField("_disposed"));
//Assert properties
Assert.IsFalse(container.IsOdd);
Assert.IsFalse(container.IsDisposed);
Assert.AreEqual(container.Owner, spreadsheetMock);
Assert.AreEqual(container.TopLevelSpreadsheet, spreadsheetMock);
Assert.IsNull(container.Item);
Assert.IsNotNull(container.Cells);
Assert.IsFalse(container.Cells.Any());
Assert.IsFalse(container.IsAlternate);
Assert.IsFalse(container.IsSelected);
}
public void CanSortOrGroupLayout()
{
// arrange
var vm = new ProcessLayoutsViewModel();
var model = Mock.Create<ProcessEdit>(Behavior.Loose);
model.SystemName = Constants.CalendarProcessName;
Mock.Arrange(() => vm.Model).Returns(model);
// act
var privateAccessor = new PrivateAccessor(vm);
var result = (bool)privateAccessor.CallMethod("CanSortOrGroupLayout", new object[] { null });
// assert
Assert.IsFalse(result);
// arrage
model.SystemName = "eCar_p";
// act
result = (bool)privateAccessor.CallMethod("CanSortOrGroupLayout", new object[] { null });
// assert
Assert.IsTrue(result);
}
public void Ctor()
{
// arrange
Mock.SetupStatic(typeof(Ioc));
// act
var handler = new DocHandler();
// assert
var privateAccessor = new PrivateAccessor(handler);
Assert.IsNull(privateAccessor.GetField("_fileProcessorUri"));
Assert.IsNull(privateAccessor.GetField("_tempDocumentUnc"));
// arrange
Mock.Arrange(() => SystemOptionsInfo.GetSystemOptionsInfo()).Returns(new SystemOptionsInfo
{
FileProcessorURI = "http://*****:*****@"D:\Projects\Cebos\release-2.2\Cebos.Veyron.Web\FileStorage"
});
// act
handler = new DocHandler();
// assert
privateAccessor = new PrivateAccessor(handler);
Assert.AreEqual("http://*****:*****@"D:\Projects\Cebos\release-2.2\Cebos.Veyron.Web\FileStorage", privateAccessor.GetField("_tempDocumentUnc"));
}
public void WhenCalledConvert_CreatesNewViewOrReturnsCachedOneIfAny()
{
var converter = new EditorSelector();
var privateAccessor = new PrivateAccessor(converter);
EditorSelector.ResetComposedConverter();
var view = new UserControl();
const string fieldType = "testFieldType";
converter.EditorFactories = new[]
{
new ExportFactory<UserControl, IExportAsControlForTypeMetadata>(
() => new Tuple<UserControl, Action>(view, () => { }),
new ExportAsControlForTypeAttribute(fieldType))
};
var fieldItemMock = Mock.Create<IFieldItem>(Behavior.CallOriginal);
Mock.Arrange(() => fieldItemMock.FieldType).Returns(fieldType);
Mock.Arrange(() => fieldItemMock.CanEdit).Returns(true);
Mock.Arrange(() => fieldItemMock.CanView()).Returns(true);
Mock.Arrange(() => fieldItemMock.IsInformationOnly).Returns(false);
var returnedView = (UserControl)converter.Convert(fieldItemMock, new TypeDelegator(typeof (object)), new object(), null);
Assert.AreEqual(view.GetType(), returnedView.GetType());
Assert.AreSame(fieldItemMock, returnedView.DataContext);
Assert.IsTrue(returnedView.IsEnabled);
//check that view was cached in RegisteredViews table
UserControl cachedView;
var registeredViews = privateAccessor.GetField("RegisteredViews") as ConditionalWeakTable<IFieldItem, UserControl>;
Assert.IsNotNull(registeredViews);
Assert.IsTrue(registeredViews.TryGetValue(fieldItemMock, out cachedView));
//remove cached view to ensure that converter will create a new one
registeredViews.Remove(fieldItemMock);
Mock.Arrange(() => fieldItemMock.CanEdit).Returns(false);
Mock.Arrange(() => fieldItemMock.CanView()).Returns(false);
returnedView = (UserControl)converter.Convert(fieldItemMock, new TypeDelegator(typeof(object)), new object(), null);
Assert.AreEqual(view.GetType(), returnedView.GetType());
Assert.AreSame(fieldItemMock, returnedView.DataContext);
Assert.IsFalse(returnedView.IsEnabled);
//now converter should return the cached view
Mock.Arrange(() => fieldItemMock.CanEdit).Returns(true);
Mock.Arrange(() => fieldItemMock.CanView()).Returns(true);
var returnedCachedView = (UserControl)converter.Convert(fieldItemMock, new TypeDelegator(typeof(object)), new object(), null);
Assert.IsTrue(ReferenceEquals(returnedView, returnedCachedView));
Assert.AreSame(fieldItemMock, returnedCachedView.DataContext);
Assert.IsFalse(returnedCachedView.IsEnabled);
}
public void PrivateAccessor_ShouldCallPrivateMethod()
{
// ACT
// Wrapping the instance holding the private method.
var inst = new PrivateAccessor(new ClassWithNonPublicMembers());
// Calling the non-public method by giving its exact name.
var actual = inst.CallMethod("MePrivate");
// ASSERT
Assert.AreEqual(1000, actual);
}
public void IsDeletingCommand()
{
// arrange
var command = Mock.Create<InsertImageToRichtextCommand>(Constructor.Mocked, Behavior.CallOriginal);
// act
var result = new PrivateAccessor(command).GetProperty("IsDeletingCommand");
// assert
Assert.IsTrue((bool)result);
}
public void PrivateAccessor_ShouldGetSetProperty()
{
// ACT
// Wrapping the instance holding the private property.
var inst = new PrivateAccessor(new ClassWithNonPublicMembers());
// Setting the value of the private property.
inst.SetProperty("Prop", 555);
// ASSERT - Asserting with getting the value of the private property.
Assert.AreEqual(555, inst.GetProperty("Prop"));
}
public void OnMouseLeftButtonUp_NodesShouldBeConnectedFromSourceToDestination()
{
var thumbMock = Mock.Create<ConnectorThumb>(Constructor.Mocked);
var privateAccessor = new PrivateAccessor(thumbMock);
//Arrange
Mock.NonPublic.Arrange(thumbMock, "OnMouseLeftButtonUp", ArgExpr.IsAny<MouseButtonEventArgs>()).CallOriginal();
var dcMock = Mock.Create<ExpressionConnectorViewModel>();
Mock.Arrange(() => dcMock.ConnectorType).Returns(ConnectorType.In);
Mock.Arrange(() => dcMock.Item.CreateConnection(Arg.IsAny<IDiagramItem>(), Arg.IsAny<IDiagramItem>()))
.Returns(Mock.Create<ExpressionConnection>(Constructor.Mocked, Behavior.Loose));
Mock.Arrange(() => thumbMock.DataContext).Returns(dcMock);
var panelMock = Mock.Create<DiagramPanel>(Constructor.Mocked);
Mock.Arrange(() => DiagramPanel.GetParentPanel<DiagramPanel>(thumbMock)).Returns(panelMock);
var panelDcMock = Mock.Create<DiagramViewModel>();
Mock.Arrange(() => panelDcMock.Items).Returns(new Collection<IDiagramItemViewModel>());
Mock.Arrange(() => panelMock.DataContext).Returns(panelDcMock);
var connectionEndMock = Mock.Create<ExpressionConnectorViewModel>();
Mock.Arrange(() => connectionEndMock.CreateConnectionTo(Arg.IsAny<IDiagramItemViewModel>())).CallOriginal();
Mock.Arrange(() => connectionEndMock.CanConnectTo(Arg.IsAny<IDiagramItemViewModel>(), Arg.IsAny<ICollection<IDiagramItemViewModel>>())).Returns(ConnectivityState.Allow);
Mock.Arrange(() => panelMock.GetViewModelByLocation<IDiagramItemViewModel>(Arg.IsAny<Point>())).Returns(connectionEndMock);
privateAccessor.SetField("_isDragging", true);
//Act
privateAccessor.CallMethod("OnMouseLeftButtonUp", Mock.Create<MouseButtonEventArgs>());
//Assert
IConnectionViewModel newConnection = null;
try
{
newConnection = panelDcMock.Items.ToList()[0] as IConnectionViewModel;
}
catch (Exception)
{
Assert.Fail("No connections where created");
return;
}
Assert.AreEqual(1, panelDcMock.Items.Count);
if (newConnection != null)
{
Assert.AreEqual(connectionEndMock, newConnection.Source);
Assert.AreEqual(dcMock, newConnection.Destination);
}
else
Assert.Fail("Type of the object does not inherit IConnectionViewModel");
}
public void GetTitleTests()
{
// arrange
var vm = NewAccountListViewModel();
// act
var privateAccessor = new PrivateAccessor(vm);
var result = privateAccessor.CallMethod("GetTitle");
// assert
Assert.AreEqual("Account Management", result);
}
public void Child_Update_test()
{
// Arrange
var mockedClass = Mock.Create<ConnectionSetupEdit>(Behavior.CallOriginal);
var setup = Mock.Create<IConnectionsSetupDAL>();
Mock.Arrange(() => setup.UpdateConnectionSetup(Arg.IsAny<ConnectionSettingsDto>())).DoNothing();
Mock.Arrange(() => mockedClass.ConnectionsSetupDAL).Returns(setup);
// Act
var inst = new PrivateAccessor(mockedClass);
inst.CallMethod("Child_Update");
}
public void TestFieldDefaultValues()
{
var vm = new GageRRFieldViewModel();
var privateAccessor = new PrivateAccessor(vm);
Assert.IsNull(privateAccessor.GetField("_detailsViewModel"));
Assert.IsNull(privateAccessor.GetField("_settingsPropertyName"));
Assert.IsNull(privateAccessor.GetField("_sourceProcessName"));
Assert.IsNull(privateAccessor.GetField("_msaResults"));
Assert.IsNull(privateAccessor.GetField("_dataGroupingItem"));
Assert.IsNull(privateAccessor.GetField("_showItemSelectorCommand"));
}
public void TestFunctionGetCategoryTask()
{
Mock.Arrange(() => Application.Current.Dispatcher.InvokeAsync(null))
.IgnoreArguments().DoNothing();
var viewModel = Mock.Create<QueueNoteTaskViewModel>(Behavior.CallOriginal);
Mock.Arrange(() => QueueAssignmentFunctions.GetCategoryTaskActivity())
.Returns(FakeData.FakeSelectList());
Mock.SetupStatic(typeof(CollectionsQueueSettingsFunctions), StaticConstructor.Mocked);
Mock.Arrange(() => CollectionsQueueSettingsFunctions.ReadCollectionSystemDefaultAsync())
.Returns(FakeData.FakesCollectionDefault());
var inst = new PrivateAccessor(viewModel);
inst.CallMethod("GetCategoryTask");
Assert.IsNotNull(viewModel.ListCategory);
}
public void ConstructorTest()
{
var stepEditMock = Mock.Create<GageRROptionsStepEdit>(Constructor.Mocked, Behavior.Loose);
stepEditMock.SampleFilterDefinition = "FilterDefinition";
var vm = new GageRROptionsStepViewModel(stepEditMock, null, null);
Assert.IsNotNull(vm.AvailableProcesses);
Assert.IsNotNull(vm.SelectedProcessAvailableFields);
Assert.IsNotNull(vm.AnswerProcessAvailableFields);
Assert.AreEqual(vm.FilterDefinition, "FilterDefinition");
var privateAccessor = new PrivateAccessor(vm);
Assert.IsTrue((bool)privateAccessor.GetField("_isLoading"));
}
public void IsDropDownOpen_WhenSetToTrue_CreatesSelectorView()
{
//Arrange
var crossRef = new FieldSingleCrossRef();
//Act
crossRef.IsDropDownOpen = true;
//Assert
var inst = new PrivateAccessor(crossRef);
var d = inst.GetField("selectorView");
Assert.IsNotNull(d);
}
public void AssignItemsSourceFirstTest()
{
var spreadsheet = new SpreadsheetView();
var spreadsheetData = new List<TestData>
{
new TestData{Text = "string1", FractionalNumber = 10.0},
new TestData{Text = "string2", FractionalNumber = 20.0},
new TestData{Text = "test text", FractionalNumber = 30.2}
};
var privateAccessor = new PrivateAccessor(spreadsheet);
//By default ItemsSource of SpreadsheetView is null
Assert.IsNull(spreadsheet.ItemsSource);
Mock.NonPublic.Arrange<SpreadsheetView>("OnItemsSourceChanged", ArgExpr.IsAny<DependencyObject>(), ArgExpr.IsAny<DependencyPropertyChangedEventArgs>())
.CallOriginal()
.MustBeCalled();
spreadsheet.ItemsSource = spreadsheetData;
Assert.AreEqual(spreadsheet.ItemsSource, spreadsheetData);
Mock.NonPublic.Assert<SpreadsheetView>("OnItemsSourceChanged", ArgExpr.IsAny<DependencyObject>(), ArgExpr.IsAny<DependencyPropertyChangedEventArgs>());
//FillItemsSource must be called from OnApplyTemplate if it hasn't been invoked yet
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Never(), ArgExpr.IsAny<IEnumerable>());
Assert.IsFalse((bool)privateAccessor.GetField("_templateApplied"));
//We've set SpreadsheetView.ItemsSource but ItemsControl.ItemsSource is still null
var itemsControl = spreadsheet as ItemsControl;
Assert.IsNull(itemsControl.ItemsSource);
//Invoke OnApplyTemplate manually
spreadsheet.OnApplyTemplate();
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Once(), ArgExpr.IsAny<IEnumerable>());
Assert.IsTrue((bool)privateAccessor.GetField("_templateApplied"));
//FillItemsSource calls PopulateColumns
Mock.NonPublic.Assert(spreadsheet, "PopulateColumns", Occurs.Once(), ArgExpr.IsAny<SpreadsheetElementCollection>());
//Now ItemsControl.ItemsSource has value as well
Assert.IsNotNull(itemsControl.ItemsSource);
Assert.AreEqual(itemsControl.ItemsSource.GetType(), typeof(SpreadsheetElementCollection));
//SpreadsheetView.ItemsCollection has only getter which retrieves data from ItemsControl.ItemsSource and casts it to SpreadsheetElementCollection
Assert.AreEqual(itemsControl.ItemsSource, spreadsheet.ItemsCollection);
//Assure that all our elements are there
Assert.AreEqual(((IList)spreadsheet.ItemsSource).Count, spreadsheetData.Count);
Assert.AreEqual(((IList)itemsControl.ItemsSource).Count, spreadsheetData.Count);
}
public void Execute()
{
// arrange
var rule = new RichTextMaxLengthRule(null, 0);
var privateAccessor = new PrivateAccessor(rule);
// act
try
{
privateAccessor.CallMethod("Execute", new object[] { null });
}
catch (Exception ex)
{
// assert
Assert.Fail("Expected no exception, but got: " + ex.Message);
}
// arrange
var property = Mock.Create<IPropertyInfo>(Behavior.RecursiveLoose);
var context = Mock.Create<RuleContext>(Constructor.Mocked, Behavior.CallOriginal);
Mock.Arrange(() => context.InputPropertyValues).Returns(new Dictionary<IPropertyInfo, object>
{
{ property, string.Empty }
});
rule.PrimaryProperty = property;
var ruleWasThrown = false;
Mock.Arrange(() => context.AddErrorResult(Arg.IsAny<IPropertyInfo>(), Arg.AnyString)).DoInstead(() => ruleWasThrown = true);
// act
privateAccessor.CallMethod("Execute", new object[] { context });
// assert
Assert.IsFalse(ruleWasThrown);
// arrange
Mock.Arrange(() => context.InputPropertyValues).Returns(new Dictionary<IPropertyInfo, object>
{
{ property, "Hello World!" + Constants.InvokeRichTextMaxLengthRule }
});
// act
privateAccessor.CallMethod("Execute", new object[] { context });
// assert
Assert.IsTrue(ruleWasThrown);
}
public void InvokeConstructorTest()
{
//Mock spreadsheet
var spreadsheetMock = Mock.Create<SpreadsheetView>(Constructor.Mocked, Behavior.Loose);
Mock.Arrange(() => spreadsheetMock.GetTopLevelSpreadsheet()).CallOriginal();
//Call constructor
var container = new SpreadsheetItemContainer(spreadsheetMock);
var privateAccessor = new PrivateAccessor(container);
//Assert fields and properties
Assert.AreEqual(privateAccessor.GetField("_owner"), spreadsheetMock);
Assert.AreEqual(container.TopLevelSpreadsheet, spreadsheetMock);
Assert.IsNotNull(container.Cells);
}
public void FlushQueueTest()
{
var hid = Mock.Create<Hid>(Behavior.CallOriginal);
const string Method = "FlushQueue";
var iscalled = false;
Mock.NonPublic.Arrange(hid, Method, ArgExpr.IsAny<IntPtr>()).DoInstead(
() =>
{
iscalled = true;
});
var inst = new PrivateAccessor(hid);
inst.CallMethod(Method, new IntPtr());
Assert.IsTrue(iscalled);
}
public void GiveFeedbackHandler_Cursors_NoneTest()
{
var mainMenu = new MainMenuMetroView();
var arg = Mock.Create<GiveFeedbackEventArgs>(Behavior.RecursiveLoose);
arg.SetCursor(Cursors.None);
Mock.Arrange(() => arg.Effects).Returns(DragDropEffects.None);
// act
var privateAccessor = new PrivateAccessor(mainMenu);
privateAccessor.CallMethod("GiveFeedbackHandler", new object[] { null, arg });
Assert.IsTrue(arg.Handled);
Assert.IsTrue(arg.Effects == DragDropEffects.None);
}
public void TestGetClientFinancialAsync_OnstepAsync_EnumStepsStart()
{
GeneralThreadAffineContext.Run(
async () =>
{
Mock.Arrange(() => Application.Current.Dispatcher.InvokeAsync(null))
.IgnoreArguments()
.DoNothing();
var viewModel = Mock.Create<CollectionsManagementViewModel>(Behavior.CallOriginal);
viewModel.ClientFinancials = FakeData.FakeDropdownLists();
Mock.SetupStatic(typeof(QueueManagmentFunctions), StaticConstructor.Mocked);
Mock.Arrange(() => QueueManagmentFunctions.GetClientFinancialsAsync())
.Returns(FakeData.FakeSystemConstant());
var inst = new PrivateAccessor(viewModel);
await Task.WhenAll(inst.CallMethod("GetClientFinancialAsync") as Task);
Assert.AreEqual(3, viewModel.ClientFinancials.Count);
});
}
public void IsSelectedPropertyTests()
{
var tvrs = new TreeViewRequiredStepEdit { DisplayFields = new TreeViewDisplayFields() };
var tree = new TreeViewRequiredStepViewModel(tvrs, new StepInfo(), new ProcessFieldViewModel(new FieldEdit(), new ProcessSectionViewModel(new SectionEdit())));
// Arrange
var mockedClass = Mock.Create<TreeViewDisplayFieldViewModel>(Behavior.Loose);
Mock.NonPublic.Arrange<ITreeViewRequiredStepViewModel>(mockedClass, "ParentStepViewModel").Returns(tree);
// Act
var inst = new PrivateAccessor(mockedClass);
inst.SetProperty("IsSelected", true);
var vm = inst.GetProperty("ParentStepViewModel");
// Assert
Assert.IsNotNull(vm);
}
public void DisplayExceptionTest()
{
var hid = Mock.Create<Hid>(Behavior.CallOriginal);
const string Method = "DisplayException";
var iscalled = false;
Mock.NonPublic.Arrange(hid, Method, new[] { ArgExpr.IsAny<string>(), ArgExpr.IsAny<Exception>() }).DoInstead(
() =>
{
iscalled = true;
});
var inst = new PrivateAccessor(hid);
inst.CallMethod(Method, new object[] { "test", new Exception("test") });
Assert.IsTrue(iscalled);
}
public void SupportedExtensions()
{
// arrange
var command = Mock.Create<InsertImageToRichtextCommand>(Constructor.Mocked, Behavior.CallOriginal);
var list = new List<string>
{
".bmp",
".jpg",
".jpeg",
".png"
};
// act
var privateAccessor = new PrivateAccessor(command);
var result = privateAccessor.GetField("SupportedExtensions");
// assert
CollectionAssert.AreEqual(list, (ICollection)result);
}
public void Execute_WhenCalledWithEmptyList_AddsErrorResult()
{
// arrange
var rule = new ApprovalLevelsRequiredRule(ApprovalOptionsStepEdit.LevelDefinitionsProperty);
var context = Mock.Create<RuleContext>(Constructor.Mocked, Behavior.CallOriginal);
Mock.Arrange(() => context.InputPropertyValues)
.Returns(new Dictionary<IPropertyInfo, object> { { ApprovalOptionsStepEdit.LevelDefinitionsProperty, new List<string>{}}});
var ruleWasThrown = false;
Mock.Arrange(() => context.AddErrorResult(Arg.AnyString)).DoInstead(() => ruleWasThrown = true);
//Act
var privateAccessor = new PrivateAccessor(rule);
privateAccessor.CallMethod("Execute", new object[] { context });
// assert
Assert.IsTrue(ruleWasThrown);
}
public void AddDestinationVersionFieldsTest()
{
// Arrange.
var vm = new ExpressionDesignerWindowViewModelBase();
var accessor = new PrivateAccessor(vm);
var processInfo = Mock.Create<PublishedProcessInfo>();
Mock.Arrange(() => processInfo.ProcessOption).Returns(ProcessOption.VersionEnabled);
var destination = new DestinationFieldList();
// Act.
accessor.CallMethod("AddVersionFields", processInfo, destination);
// Assert.
Assert.AreEqual(3, destination.Fields.Count);
var versionNumber = destination.Fields.FirstOrDefault(f => f.SystemName == Constants.VersionNumber);
var versionDate = destination.Fields.FirstOrDefault(f => f.SystemName == Constants.VersionDate);
var versionMasterId = destination.Fields.FirstOrDefault(f => f.SystemName == Constants.VersionMasterId);
Assert.IsNotNull(versionNumber);
Debug.Assert(versionNumber != null, "versionNumber != null");
Assert.AreEqual(NodeDataType.String, versionNumber.DataType);
Assert.AreEqual(Constants.VersionNumberName, versionNumber.Name);
Assert.AreEqual(Constants.VersionNumber, versionNumber.InnerName);
Assert.AreEqual(Constants.VersionNumber, versionNumber.SystemName);
Assert.IsNotNull(versionDate);
Debug.Assert(versionDate != null, "versionDate != null");
Assert.AreEqual(NodeDataType.DateTime, versionDate.DataType);
Assert.AreEqual("Version Date", versionDate.Name);
Assert.AreEqual(Constants.VersionDate, versionDate.InnerName);
Assert.AreEqual(Constants.VersionDate, versionDate.SystemName);
Assert.IsNotNull(versionMasterId);
Debug.Assert(versionMasterId != null, "versionMasterId != null");
Assert.AreEqual(NodeDataType.Int, versionMasterId.DataType);
Assert.AreEqual("Version Master Id", versionMasterId.Name);
Assert.AreEqual(Constants.VersionMasterId, versionMasterId.InnerName);
Assert.AreEqual(Constants.VersionMasterId, versionMasterId.SystemName);
}
public void TestCollectionQueue_QueueNameAndAssignment_NotEmpty()
{
Mock.Arrange(() => Application.Current.Dispatcher.InvokeAsync(null))
.IgnoreArguments()
.DoNothing();
var viewModel = Mock.Create<EditQueueViewModel>(
Behavior.CallOriginal,
new CollectionsManagementViewModel());
viewModel.SelectedQueue = FakeData.FakeQueueDetailModel();
Mock.Arrange(() => viewModel.SelectedQueue.CollectionQueue).Returns(FakeData.FakeCollectionQueue());
Mock.Arrange(() => viewModel.HasErrors).Returns(true);
var inst = new PrivateAccessor(viewModel);
inst.CallMethod("Validate");
var vali = new PrivateAccessor(viewModel);
var faile = vali.GetField("_Failures") as List<ValidationFailure>;
Assert.IsNotNull(faile);
Assert.AreEqual(2, faile.Count);
}
public void RefreshTests()
{
// arrange
var vm = new SelectPersonViewModel();
var getFilterWasCalled = false;
Mock.NonPublic.Arrange<MobileObservableCollection<IFilterDescriptor>>(vm, "GetFilter").DoInstead(() => getFilterWasCalled = true);
var dynamicTypeManager = Mock.Create<IDynamicTypeManager>(Behavior.CallOriginal);
Mock.Arrange(() => dynamicTypeManager.GetCustomType(Constants.AccountProcessName, "LinkablePersonList", true))
.DoInstead(() => Assert.IsTrue(vm.IsBusy))
.Returns(typeof(object));
vm.TheDynamicTypeManager = dynamicTypeManager;
var account = Mock.Create<IAccount>(Behavior.Loose);
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.SetField("_selectedAccount", account);
var basePersonList = Mock.Create<IList>(Behavior.Loose);
Mock.Arrange(() => MethodCaller.CallFactoryMethod(Arg.IsAny<Type>(), "Get__AccountLinkablePersonListAsync", Arg.AnyInt, Arg.IsAny<int?>(), Arg.IsAny<PagedCriteria>()))
.Returns(() =>
{
var tcs = new TaskCompletionSource<IList>();
tcs.SetResult(basePersonList);
return tcs.Task;
});
// act
privateAccessor.CallMethod("Refresh");
// assert
Assert.IsTrue(getFilterWasCalled);
Assert.AreEqual(basePersonList, vm.PersonList);
Assert.IsFalse(vm.IsBusy);
}
