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 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 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 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 InvokeConstructorTest()
{
var spreadsheet = Mock.Create<SpreadsheetView>(Behavior.CallOriginal);
var privateAccessor = new PrivateAccessor(spreadsheet);
//Check properties
Assert.AreEqual(privateAccessor.GetProperty("DefaultStyleKey"), typeof(SpreadsheetView));
Assert.IsNotNull(spreadsheet.Columns);
Assert.IsTrue(spreadsheet.AllowDrop);
Assert.IsNotNull(privateAccessor.GetField("_childSpreadsheets"));
var expSpreadsheetView_LayoutUpdated = Mock.NonPublic.Arrange(spreadsheet, "SpreadsheetView_LayoutUpdated", ArgExpr.IsAny<object>(), ArgExpr.IsAny<EventArgs>());
var expAutoSize = Mock.NonPublic.Arrange(spreadsheet, "AutoSize");
//Check if AutoSize is called on LayoutUpdated
Mock.Raise(() => spreadsheet.LayoutUpdated += null, EventArgs.Empty);
expSpreadsheetView_LayoutUpdated.MustBeCalled();
expAutoSize.MustBeCalled();
//Check if _loaded is set to true on Loaded
Assert.IsFalse((bool)privateAccessor.GetField("_loaded"));
Mock.Raise(() => spreadsheet.Loaded += null, new RoutedEventArgs());
Assert.IsTrue((bool)privateAccessor.GetField("_loaded"));
}
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 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 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 OnItemsChangedItemReplaceTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
//Create data
var oldItem = ItemWrap.BuildNew(new TestData());
var newItem = ItemWrap.BuildNew(new TestData());
var oldContainer = new SpreadsheetItemContainer(spreadsheet);
var newContainer = new SpreadsheetItemContainer(spreadsheet);
//Prepare event arguments and container dictionary
var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Replace, newItem, oldItem, 0);
var containerDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
containerDict.Add(oldItem, oldContainer);
//Arrange methods
Mock.Arrange(() => spreadsheet.ItemContainerGenerator.ContainerFromItem(newItem)).Returns(newContainer);
Mock.NonPublic.Arrange(spreadsheet, "BindContainerToItem", newContainer, newItem).CallOriginal();
//Call OnItemsChanged and Assert results
privateAccessor.CallMethod("OnItemsChanged", args);
Assert.AreEqual(containerDict.Count, 1);
Assert.AreEqual(containerDict.First().Key, newItem);
Assert.AreEqual(containerDict[newItem], newContainer);
Mock.NonPublic.Assert(spreadsheet, "BindContainerToItem", Occurs.Once(), newContainer, newItem);
Assert.IsTrue(oldContainer.IsDisposed);
}
public void OnItemsChangedItemRemoveTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
//Initialize ItemCollection
Mock.NonPublic.Arrange(spreadsheet, "OnItemsChanged", ArgExpr.IsAny<NotifyCollectionChangedEventArgs>()).DoNothing();
var list = new List<TestData>
{
new TestData {Text = "fff", FractionalNumber = 0},
new TestData {Text = "item", FractionalNumber = 55},
new TestData {Text = "last item", FractionalNumber = -5}
};
spreadsheet.ItemsSource = list;
spreadsheet.OnApplyTemplate();
Assert.IsNotNull(spreadsheet.ItemsCollection);
Mock.Reset();
var item1 = spreadsheet.ItemsCollection[0];
var item2 = spreadsheet.ItemsCollection[1];
var item3 = spreadsheet.ItemsCollection[2];
//Bind item1 to container
var container = new SpreadsheetItemContainer(spreadsheet);
Mock.NonPublic.Arrange(container, "InitializeCellsWithValues");
privateAccessor.CallMethod("BindContainerToItem", container, item1);
privateAccessor.CallMethod("BindContainerToItem", container, item3);
//Assert dictionary with containers
var containerDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
Assert.IsNotNull(containerDict);
Assert.AreEqual(containerDict.Count, 2);
containerDict.Add(item2, null);
Assert.AreEqual(containerDict.Count, 3);
//Remove second item from collection (when container is null)
Mock.Arrange(() => containerDict.Remove(item2)).CallOriginal();
spreadsheet.ItemsCollection.Remove(item2);
Mock.Assert(() => containerDict.Remove(item2), Occurs.Once());
Assert.AreEqual(containerDict.Count, 2);
//Remove first item from collection (when container is disposed)
Mock.Arrange(() => container.IsDisposed).Returns(true);
spreadsheet.ItemsCollection.Remove(item1);
Mock.Assert(() => containerDict.Remove(item1), Occurs.Once());
Assert.AreEqual(containerDict.Count, 1);
//Remove item and dispose container
Mock.Arrange(() => container.IsDisposed).Returns(false);
spreadsheet.ItemsCollection.Remove(item3);
Mock.Assert(() => containerDict.Remove(item3), Occurs.Exactly(2));
Assert.AreEqual(containerDict.Count, 0);
Mock.Reset();
Assert.IsTrue(container.IsDisposed);
}
public void OnItemsChangedItemAddTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
//Initialize ItemCollection
Mock.NonPublic.Arrange(spreadsheet, "OnItemsChanged", ArgExpr.IsAny<NotifyCollectionChangedEventArgs>()).DoNothing();
spreadsheet.ItemsSource = new List<TestData>();
spreadsheet.OnApplyTemplate();
Assert.IsNotNull(spreadsheet.ItemsCollection);
Mock.Reset();
//Create data item and its wrapper
var dataItem = new TestData {Text = "test", FractionalNumber = 3.5};
var itemWrap = ItemWrap.BuildNew(dataItem);
//Arrabge ManageExpandStates and BindContainerToItem
Mock.Arrange(() => spreadsheet.ManageExpandStates(Arg.IsAny<IDetailColumn>()));
Mock.NonPublic.Arrange(spreadsheet, "BindContainerToItem", ArgExpr.IsAny<SpreadsheetItemContainer>(), ArgExpr.IsAny<IWrap>());
//Make spreadsheet disposed
privateAccessor.SetField("_disposed", true);
spreadsheet.ItemsCollection.Add(itemWrap);
//Check ManageExpandStates and BindContainerToItem invocations when spreadsheet is disposed
Assert.IsTrue((bool)privateAccessor.GetField("_disposed"));
Mock.NonPublic.Assert(spreadsheet, "BindContainerToItem", Occurs.Never(), ArgExpr.IsAny<SpreadsheetItemContainer>(), ArgExpr.IsAny<IWrap>());
Mock.Assert(() => spreadsheet.ManageExpandStates(Arg.IsAny<IDetailColumn>()), Occurs.Never());
//Mock ItemContainerGenerator.ContainerFromItem method and add new item to ItemsCollection
//this invokes OnItemsChanged
privateAccessor.SetField("_disposed", false);
var container = new SpreadsheetItemContainer(spreadsheet);
Mock.Arrange(() => spreadsheet.ItemContainerGenerator.ContainerFromItem(Arg.IsAny<object>())).Returns(container);
Mock.Arrange(() => spreadsheet.ParentColumn).Returns(Mock.Create<IDetailColumn>());
spreadsheet.ItemsCollection.Add(itemWrap);
//Check ManageExpandStates and BindContainerToItem invocations when spreadsheet is not disposed
Assert.IsFalse((bool)privateAccessor.GetField("_disposed"));
Mock.NonPublic.Assert(spreadsheet, "BindContainerToItem", Occurs.Once(), container, itemWrap);
Mock.Assert(() => spreadsheet.ManageExpandStates(Arg.IsAny<IDetailColumn>()), Occurs.Once());
}
public void PrivateMessageFields()
{
// arrange
var vm = new FieldFileViewModel();
var privateAccessor = new PrivateAccessor(vm);
// act
var message2 = privateAccessor.GetField("_message2");
var message3 = privateAccessor.GetField("_message3");
var message4 = privateAccessor.GetField("_message4");
var message5 = privateAccessor.GetField("_message5");
var message6 = privateAccessor.GetField("_message6");
var message8 = privateAccessor.GetField("_message8");
var message13 = privateAccessor.GetField("_message13");
// assert
Assert.AreEqual(LanguageService.Translate("Msg_TemplateNotFound"), message2);
Assert.AreEqual(LanguageService.Translate("Msg_SaveToSeeFileOptions"), message3);
Assert.AreEqual(LanguageService.Translate("Msg_SystemPathsIsEmpty"), message4);
Assert.AreEqual(LanguageService.Translate("Msg_InvalidSystemPath"), message5);
Assert.AreEqual(LanguageService.Translate("Msg_DocumentProcessorNotResponding"), message6);
Assert.AreEqual(LanguageService.Translate("Msg_FileUploadError"), message8);
Assert.AreEqual(LanguageService.Translate("Msg_FileNotFound"), message13);
}
public void UnselectMethodTest()
{
var spreadsheetMock = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheetMock);
//Load data
Mock.NonPublic.Arrange(typeof(CellBase), "SetEditorParams").IgnoreInstance().DoNothing();
spreadsheetMock.ItemsSource = new List<TestData> { new TestData { Text = "text 1" }, new TestData { Text = "another text" } };
spreadsheetMock.OnApplyTemplate();
var item1 = spreadsheetMock.ItemsCollection[0];
var item2 = spreadsheetMock.ItemsCollection[1];
//Call ItemContainerGenerator overrides
var container = privateAccessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
Assert.IsNotNull(container);
spreadsheetMock.ItemContainerStyle = new Style(typeof(SpreadsheetItemContainer));
privateAccessor.CallMethod("PrepareContainerForItemOverride", container, item1);
privateAccessor.CallMethod("PrepareContainerForItemOverride", (SpreadsheetItemContainer)null, item2);
//Unselect cells from local spreadsheet
Mock.Arrange(() => spreadsheetMock.Unselect(Arg.IsAny<CellBase>(), Arg.IsAny<SpreadsheetView>()));
Mock.Arrange(() => container.Unselect(Arg.IsAny<CellBase>())).IgnoreInstance().OccursOnce();
var cell = Mock.Create<CellBase>(Constructor.Mocked, Behavior.Loose);
spreadsheetMock.Unselect(cell);
Mock.Assert(container);
//Create child spreadsheets
var childSpreadsheet1 = Mock.Create<SpreadsheetView>(Constructor.Mocked, Behavior.Loose);
Mock.Arrange(() => childSpreadsheet1.IsVisible).Returns(true);
var childSpreadsheet2 = Mock.Create<SpreadsheetView>(Constructor.Mocked, Behavior.Loose);
Mock.Arrange(() => childSpreadsheet2.IsVisible).Returns(false);
var childSpreadsheet3 = Mock.Create<SpreadsheetView>(Constructor.Mocked, Behavior.Loose);
Mock.Arrange(() => childSpreadsheet3.IsVisible).Returns(true);
//Add child spreadsheets
var childSpreadsheets = privateAccessor.GetField("_childSpreadsheets") as List<SpreadsheetView>;
childSpreadsheets.Add(childSpreadsheet1);
childSpreadsheets.Add(childSpreadsheet2);
childSpreadsheets.Add(childSpreadsheet3);
//Call method with child spreadsheets and with caller (the second argument)
Mock.Arrange(() => spreadsheetMock.Unselect(Arg.IsAny<CellBase>(), Arg.IsAny<SpreadsheetView>())).CallOriginal();
spreadsheetMock.Unselect(cell, childSpreadsheet1);
Mock.Assert(() => childSpreadsheet1.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Never());
Mock.Assert(() => childSpreadsheet2.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Never());
Mock.Assert(() => childSpreadsheet3.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Once());
//Call method with child spreadsheets
Mock.Arrange(() => container.Unselect(Arg.IsAny<CellBase>())).IgnoreInstance().Occurs(2);
spreadsheetMock.Unselect(cell);
Mock.Assert(() => childSpreadsheet1.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Once());
Mock.Assert(() => childSpreadsheet2.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Never());
Mock.Assert(() => childSpreadsheet3.Unselect(cell, Arg.IsAny<SpreadsheetView>()), Occurs.Exactly(2));
}
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 AlternateRowsMethodTest()
{
//Create spreadsheet and load data
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
var itemList = new List<TestData>
{
new TestData(),
new TestData()
};
spreadsheet.ItemsSource = itemList;
spreadsheet.OnApplyTemplate();
Mock.NonPublic.Arrange(typeof(SpreadsheetView), "PopulateCells", ArgExpr.IsAny<SpreadsheetItemContainer>(), ArgExpr.IsAny<IWrap>()).DoNothing();
//Get item wrappers
var item1 = spreadsheet.ItemsCollection[0];
var item2 = spreadsheet.ItemsCollection[1];
//Call ItemContainerGenerator overrides
Mock.NonPublic.Arrange(typeof(CellBase), "SetEditorParams").IgnoreInstance().DoNothing();
spreadsheet.ItemContainerStyle = new Style(typeof(SpreadsheetItemContainer));
var container1 = privateAccessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
privateAccessor.CallMethod("PrepareContainerForItemOverride", container1, item1);
var container2 = privateAccessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
privateAccessor.CallMethod("PrepareContainerForItemOverride", container2, item2);
//Mock SetIsAlternate method for all SpreadsheetItemContainer instances
var containerMock = Mock.Create<SpreadsheetItemContainer>(Constructor.Mocked);
Mock.Arrange(() => containerMock.SetIsAlternate()).IgnoreInstance();
//Make spreadsheet invisible
Mock.Arrange(() => spreadsheet.IsVisible).Returns(false);
Mock.Arrange(() => spreadsheet.Items).CallOriginal().OccursNever();
spreadsheet.AlternateRows();
Mock.Assert(spreadsheet);
//Test AlternateRows method in normal conditions
Mock.Arrange(() => spreadsheet.IsVisible).Returns(true);
Mock.Arrange(() => spreadsheet.Items).CallOriginal().MustBeCalled();
spreadsheet.AlternateRows();
var containersDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
Mock.Assert(() => containersDict[item1].SetIsAlternate(), Occurs.Once());
Mock.Assert(() => containersDict[item2].SetIsAlternate(), Occurs.Once());
Mock.Assert(spreadsheet);
}
public void CurrentState()
{
// arrange
var vm = new FieldFileViewModel();
var currentStateWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "CurrentState").DoInstead(() => { currentStateWasRaises = true; });
var valueWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "Value").DoInstead(() => { valueWasRaises = true; });
var messageWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "Message").DoInstead(() => { messageWasRaises = true; });
var lockedByMessageWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "LockedByMessage").DoInstead(() => { lockedByMessageWasRaises = true; });
var lockedByMessageVisibilityWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "LockedByMessageVisibility").DoInstead(() => { lockedByMessageVisibilityWasRaises = true; });
var fileNameMessageWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "FileNameMessage").DoInstead(() => { fileNameMessageWasRaises = true; });
var clipboardCopyErrorVisibilityWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "ClipboardCopyErrorVisibility").DoInstead(() => { clipboardCopyErrorVisibilityWasRaises = true; });
var fileSavedMessageVisibilityWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "FileSavedMessageVisibility").DoInstead(() => { fileSavedMessageVisibilityWasRaises = true; });
var templateListWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "TemplateList").DoInstead(() => { templateListWasRaises = true; });
vm.IsFocused = false;
// act
vm.CurrentState = FileControlMode.Busy;
// assert
var privateAccessor = new PrivateAccessor(vm);
Assert.AreEqual(FileControlMode.Download, privateAccessor.GetField("_previousState"));
Assert.IsTrue(currentStateWasRaises);
Assert.IsTrue(valueWasRaises);
Assert.IsTrue(messageWasRaises);
Assert.IsTrue(lockedByMessageWasRaises);
Assert.IsTrue(lockedByMessageVisibilityWasRaises);
Assert.IsTrue(fileNameMessageWasRaises);
Assert.IsTrue(clipboardCopyErrorVisibilityWasRaises);
Assert.IsTrue(fileSavedMessageVisibilityWasRaises);
Assert.IsTrue(templateListWasRaises);
Assert.AreEqual(FileControlMode.Busy, vm.CurrentState);
// act
vm.CurrentState = FileControlMode.Locked;
// assert
Assert.AreNotEqual(FileControlMode.Busy, privateAccessor.GetField("_previousState"));
Assert.AreEqual(FileControlMode.Download, privateAccessor.GetField("_previousState"));
}
public void GetFileCommand()
{
// arrange
var vm = new FieldFileViewModel();
var saveFileDialog = Mock.Create<SaveFileDialog>(Behavior.CallOriginal);
Mock.Arrange(() => saveFileDialog.ShowDialog()).Returns(true);
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.SetField("_dialog", saveFileDialog);
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
fileProcess.OriginalFileName = "1.txt";
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.txt";
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
Mock.Arrange(() => vm.DialogFilter).Returns("File (*.txt)|*.txt");
vm.DocHandlerUrl = "http://localhost:5558/";
vm.CurrentState = FileControlMode.Upload;
// act
vm.GetFileCommand.Execute(null);
// assert
var dialog = (SaveFileDialog)privateAccessor.GetField("_dialog");
Assert.AreEqual("File (*.txt)|*.txt", dialog.Filter);
Assert.AreEqual("1.txt", dialog.DefaultFileName);
Assert.AreEqual("Downloading ...", vm.DownloadPercent);
Assert.AreEqual(FileControlMode.Download, vm.CurrentState);
// arrange
vm.DownloadPercent = null;
Mock.Arrange(() => saveFileDialog.ShowDialog()).Returns(false);
// act
vm.GetFileCommand.Execute(null);
// assert
Assert.IsNull(vm.DownloadPercent);
}
public void DownloadImageCommand()
{
// arrange
var vm = new ImageFieldViewModel();
var saveFileDialog = Mock.Create<SaveFileDialog>(Behavior.CallOriginal);
Mock.Arrange(() => saveFileDialog.ShowDialog()).Returns(false);
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.SetField("_saveFileDialog", saveFileDialog);
Mock.NonPublic.Arrange<bool>(vm, "IsImageExists", new object[] { ArgExpr.IsAny<object>() }).Returns(true);
var editableRoot = Mock.Create<IEditableRoot>(Behavior.Loose);
Mock.Arrange(() => editableRoot.ProcessName).Returns("eCar_p");
Mock.Arrange(() => editableRoot.Id).Returns(1);
Mock.Arrange(() => vm.ParentModel).Returns(editableRoot);
Mock.Arrange(() => vm.Property).Returns(GetType().GetProperty("Image2"));
// act
try
{
vm.DownloadImageCommand.Execute(null);
}
catch(Exception ex)
{
// assert
Assert.Fail("Expected no exception, but got: " + ex.Message);
}
// arrange
Mock.Arrange(() => saveFileDialog.ShowDialog()).Returns(true);
Mock.Arrange(() => saveFileDialog.OpenFile()).Returns(new MemoryStream());
var array = new byte[8 * 1024 + 1];
for (var i = 0; i < array.Length; i++)
{
array[i] = new byte();
}
vm.Value = array;
var popupFactory = new PopupFactory();
var notifySuccessCalled = false;
Mock.Arrange(() => popupFactory.NotifySuccess(LanguageService.Translate("Msg_SuccessfullySaved"), "Popup_Success")).DoInstead(() => notifySuccessCalled = true);
vm.ThePopupFactory = popupFactory;
// act
vm.DownloadImageCommand.Execute(null);
// assert
Assert.IsTrue(notifySuccessCalled);
Assert.IsNull(privateAccessor.GetField("_saveFileDialog"));
}
public void UploadImageCommand()
{
// arrange
var vm = new ImageFieldViewModel();
var openFileDialog = Mock.Create<OpenFileDialog>(Behavior.CallOriginal);
Mock.Arrange(() => openFileDialog.ShowDialog()).Returns(false);
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.SetField("_openFileDialog", openFileDialog);
try
{
// act
vm.UploadImageCommand.Execute(null);
}
catch (Exception ex)
{
// assert
Assert.Fail("Expected no exception, but got: " + ex.Message);
}
// arrange
Mock.Arrange(() => openFileDialog.ShowDialog()).Returns(true);
var file = Mock.Create<FileInfo>(Behavior.CallOriginal);
Mock.Arrange(() => file.Length).Returns(8 * 1024);
Mock.Arrange(() => openFileDialog.File).Returns(file);
var popupFactory = new PopupFactory();
var notifyFailureCalled = false;
Mock.Arrange(() => popupFactory.NotifyFailure(Arg.AnyString, "Popup_Error", 3, false)).DoInstead(() => notifyFailureCalled = true);
vm.ThePopupFactory = popupFactory;
// act
vm.UploadImageCommand.Execute(null);
// assert
Assert.IsTrue(notifyFailureCalled);
// arrange
Mock.NonPublic.Arrange<ulong>(vm, "MaxFileSize").Returns((ulong)file.Length + 1);
var fileStream = Mock.Create<FileStream>(Behavior.Loose);
var exit = false;
Mock.Arrange(() => fileStream.Read(Arg.IsAny<byte[]>(), 0, Arg.AnyInt)).Returns(() =>
{
if (!exit)
{
exit = true;
return 1;
}
return 0;
});
Mock.Arrange(() => file.OpenRead()).Returns(fileStream);
var imageVisibilityRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", ArgExpr.IsAny<Expression<Func<bool>>>()).DoInstead(() => imageVisibilityRaises = true);
var downloadImageCommandRaises = false;
Mock.Arrange(() => vm.DownloadImageCommand.RaiseCanExecuteChanged()).DoInstead(() => downloadImageCommandRaises = true);
var clearImageCommandRaises = false;
Mock.Arrange(() => vm.ClearImageCommand.RaiseCanExecuteChanged()).DoInstead(() => clearImageCommandRaises = true);
// act
vm.UploadImageCommand.Execute(null);
// assert
Assert.AreEqual(8 * 1024, ((byte[])vm.Value).Length);
Assert.IsTrue(imageVisibilityRaises);
Assert.IsTrue(downloadImageCommandRaises);
Assert.IsTrue(clearImageCommandRaises);
Assert.IsNull(privateAccessor.GetField("_openFileDialog"));
}
public void EndWebRequest()
{
// arrange
var vm = new FieldFileViewModel();
var asyncResult = Mock.Create<IAsyncResult>(Behavior.CallOriginal);
var httpWebRequest = Mock.Create<HttpWebRequest>(Behavior.CallOriginal);
var httpWebResponse = Mock.Create<HttpWebResponse>(Behavior.Loose);
Mock.Arrange(() => httpWebRequest.EndGetResponse(asyncResult)).Returns(httpWebResponse);
Mock.Arrange(() => asyncResult.AsyncState).Returns(httpWebRequest);
Mock.Arrange(() => Deployment.Current.Dispatcher.BeginInvoke(Arg.IsAny<Action>())).DoInstead<Action>(a => a());
var saveFileDialog = Mock.Create<SaveFileDialog>(Behavior.CallOriginal);
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.SetField("_dialog", saveFileDialog);
// act
privateAccessor.CallMethod("EndWebRequest", new object[] { asyncResult });
// assert
Assert.IsNull(privateAccessor.GetField("_dialog"));
Assert.AreEqual(FileControlMode.Error, vm.CurrentState);
// arrange
Mock.Arrange(() => httpWebResponse.ContentLength).Returns(Constants.FileProcessBufferSize);
var outputStream = Mock.Create<Stream>(Behavior.Loose);
Mock.Arrange(() => saveFileDialog.OpenFile()).Returns(outputStream);
privateAccessor.SetField("_dialog", saveFileDialog);
var task = new Task(() => { });
task.RunSynchronously();
Mock.Arrange(() => Task.Factory.StartNew(Arg.IsAny<Action>())).DoInstead<Action>(a => a()).Returns(() => task);
var inputStream = Mock.Create<Stream>(Behavior.Loose);
var exit = false;
Mock.Arrange(() => inputStream.Read(Arg.IsAny<byte[]>(), 0, Arg.AnyInt)).Returns(() =>
{
if (!exit)
{
exit = true;
return Constants.FileProcessBufferSize;
}
return 0;
});
Mock.Arrange(() => httpWebResponse.GetResponseStream()).Returns(inputStream);
var inputStreamWasClosed = false;
Mock.Arrange(() => inputStream.Close()).DoInstead(() => inputStreamWasClosed = true);
var responseWasClosed = false;
Mock.Arrange(() => httpWebResponse.Close()).DoInstead(() => responseWasClosed = true);
var outputStreamWasClosed = false;
Mock.Arrange(() => outputStream.Close()).DoInstead(() => outputStreamWasClosed = true);
// act
privateAccessor.CallMethod("EndWebRequest", new object[] { asyncResult });
// assert
Assert.AreEqual(Constants.FileProcessBufferSize, vm.ProgressBarMaximumValue);
Assert.AreEqual(Constants.FileProcessBufferSize, vm.ProgressBarValue);
Assert.AreEqual("Downloading 100%" + Environment.NewLine, vm.DownloadPercent);
Assert.IsTrue(inputStreamWasClosed);
Assert.IsTrue(responseWasClosed);
Assert.IsTrue(outputStreamWasClosed);
Assert.AreEqual(FileControlMode.Locked, vm.CurrentState);
Assert.IsNull(privateAccessor.GetField("_dialog"));
}
public void OnItemsChangedItemResetTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
var container = new SpreadsheetItemContainer(spreadsheet);
//Arrange ContainerFromItem and initialize spreadsheet ItemsSource collection
Mock.Arrange(() => spreadsheet.ItemContainerGenerator.ContainerFromItem(Arg.IsAny<IWrap>())).Returns(container);
spreadsheet.ItemsSource = new List<TestData> {new TestData{Text = "data1"}};
spreadsheet.OnApplyTemplate();
var containersDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
Assert.AreEqual(containersDict.Count, 1);
Assert.AreEqual(((TestData)containersDict.First().Key.Data).Text, "data1");
//Re-initialize collection to call OnItemsChanged with Reset action and assert results
Mock.NonPublic.Arrange(spreadsheet, "DisposeContainers").CallOriginal().MustBeCalled();
spreadsheet.ItemsSource = new List<TestData> { new TestData { Text = "data2" } };
Assert.AreEqual(containersDict.Count, 1);
Assert.AreEqual(((TestData)containersDict.First().Key.Data).Text, "data2");
Mock.Assert(spreadsheet);
}
public void AssignItemsSourceAfterTemplateAppliedTest()
{
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);
//First we call OnApplyTemplate and only then set value to ItemsSource
spreadsheet.OnApplyTemplate();
//FillItemsSource can not be called if ItemsSource is null
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Never(), ArgExpr.IsAny<IEnumerable>());
Assert.IsTrue((bool)privateAccessor.GetField("_templateApplied"));
//FillItemsSource is invoked from OnItemsSourceChanged
Mock.NonPublic.Arrange(spreadsheet, "FillItemsSource", ArgExpr.IsAny<IEnumerable>()).MustBeCalled();
spreadsheet.ItemsSource = spreadsheetData;
Mock.Assert(spreadsheet);
}
public void GetContainerFromItemMethodTest()
{
//Mock spreadsheet
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
//Prepare data
var item = ItemWrap.BuildNew(new TestData());
var container = new SpreadsheetItemContainer(spreadsheet);
var containerHash = container.GetHashCode();
var containersDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
containersDict.Add(item, container);
//Call GetContainerFromItem and assert results
var result = spreadsheet.GetContainerFromItem(item);
Assert.AreEqual(result.GetHashCode(), containerHash);
}
public void CheckPropertiesInitialValuesTest()
{
var spreadsheet = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheet);
Assert.IsNotNull(privateAccessor.GetField("_sharedColumns"));
Assert.IsNotNull(privateAccessor.GetField("_containersDict"));
Assert.IsFalse((bool)privateAccessor.GetField("_loaded"));
Assert.IsFalse((bool)privateAccessor.GetField("_templateApplied"));
Assert.IsFalse(spreadsheet.IsDisposed);
Assert.IsFalse(spreadsheet.HasNested);
Assert.IsTrue(spreadsheet.IsTopLevel);
Assert.AreEqual(spreadsheet.FirstRowIndex, 1);
Assert.IsFalse(spreadsheet.HasSelection);
Assert.IsNull(spreadsheet.ParentColumn);
Assert.IsNull(spreadsheet.GlobalDataContext);
Assert.IsNotNull(spreadsheet.Columns);
Assert.IsFalse(spreadsheet.Columns.Any());
Assert.IsNull(spreadsheet.ItemsSource);
Assert.IsTrue(spreadsheet.AutoGenerateColumns);
Assert.IsNull(spreadsheet.ParentSpreadsheet);
Assert.IsNull(spreadsheet.CustomDataContextInitializer);
Assert.IsNull(spreadsheet.ParentCell);
Assert.IsFalse(spreadsheet.IsNested);
Assert.IsTrue(spreadsheet.IsVisible);
Assert.IsNull(spreadsheet.ItemContainerStyle);
Assert.IsTrue(spreadsheet.ShowColumnHeader);
Assert.IsNull(spreadsheet.SelectedHeaderStyle);
Assert.IsNull(spreadsheet.AlternateRowStyle);
Assert.AreEqual(((SolidColorBrush)spreadsheet.AlternateRowBackground).Color, Colors.Yellow);
Assert.AreEqual(spreadsheet.AlternateStyle, AlternateStyles.None);
Assert.AreEqual(((SolidColorBrush)spreadsheet.ColumnHeaderBackground).Color, Color.FromArgb(0xFF, 0x25, 0xA0, 0xDC));
Assert.AreEqual(((SolidColorBrush)spreadsheet.ColumnSelectionBackground).Color, Color.FromArgb(0xFF, 0x2F, 0xD3, 0xFF));
Assert.AreEqual(spreadsheet.GridLinesVisibility, GridLinesVisibility.Both);
Assert.AreEqual(spreadsheet.RowIndicatorVisibility, Visibility.Visible);
Assert.IsNull(spreadsheet.SelectedRowIndicatorStyle);
}
public void GetEditedCellsMethodTest()
{
//Mock spreadsheet
var spreadsheetMock = new SpreadsheetView();
var privateAccessor = new PrivateAccessor(spreadsheetMock);
//Load data
Mock.NonPublic.Arrange(typeof(CellBase), "SetEditorParams").IgnoreInstance().DoNothing();
spreadsheetMock.ItemsSource = new List<TestData> { new TestData { Text = "text 1" }, new TestData { Text = "another text" } };
spreadsheetMock.OnApplyTemplate();
var item1 = spreadsheetMock.ItemsCollection[0];
var item2 = spreadsheetMock.ItemsCollection[1];
//Call ItemContainerGenerator overrides
var container = privateAccessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
Assert.IsNotNull(container);
spreadsheetMock.ItemContainerStyle = new Style(typeof(SpreadsheetItemContainer));
privateAccessor.CallMethod("PrepareContainerForItemOverride", container, item1);
privateAccessor.CallMethod("PrepareContainerForItemOverride", (SpreadsheetItemContainer)null, item2);
//Assert _containersDict field
var containersDict = privateAccessor.GetField("_containersDict") as Dictionary<IWrap, SpreadsheetItemContainer>;
Assert.IsNotNull(containersDict);
Assert.AreEqual(containersDict.Count, 2);
Assert.IsTrue(containersDict.ContainsKey(item1));
Assert.AreEqual(containersDict[item1], container);
Assert.IsTrue(containersDict.ContainsKey(item2));
Assert.IsNull(containersDict[item2]);
//Assert cells
Assert.IsNotNull(container.Cells);
Assert.AreEqual(container.Cells.Count, 3);
//Assert GetEditedCells call with only container from one of two elements and with no child spreadsheets
var cell = container.Cells[1];
Mock.Arrange(() => cell.IsEditMode).Returns(true);
var editedCells = spreadsheetMock.GetEditedCells();
Assert.AreEqual(editedCells.Count(), 1);
Assert.AreEqual(editedCells[0], container.Cells[1]);
//Add child spreadsheet
var childSpreadsheet = new SpreadsheetView();
var accessor = new PrivateAccessor(childSpreadsheet);
childSpreadsheet.ItemsSource = new List<TestData> { new TestData { Text = "child item 1" }, new TestData { Text = "child item 2" } };
childSpreadsheet.OnApplyTemplate();
var item3 = childSpreadsheet.ItemsCollection[0];
var item4 = childSpreadsheet.ItemsCollection[1];
var childcontainer1 = accessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
var childcontainer2 = accessor.CallMethod("GetContainerForItemOverride") as SpreadsheetItemContainer;
childSpreadsheet.ItemContainerStyle = new Style(typeof(SpreadsheetItemContainer));
accessor.CallMethod("PrepareContainerForItemOverride", childcontainer1, item3);
accessor.CallMethod("PrepareContainerForItemOverride", childcontainer2, item4);
var cell2 = childcontainer1.Cells[1];
Mock.Arrange(() => cell2.IsEditMode).Returns(true);
var cell3 = childcontainer2.Cells[2];
Mock.Arrange(() => cell3.IsEditMode).Returns(true);
((List<SpreadsheetView>)privateAccessor.GetField("_childSpreadsheets")).Add(childSpreadsheet);
//Assert GetEditedCells call involving invisible child spreadsheet
Mock.Arrange(() => childSpreadsheet.IsVisible).Returns(false);
editedCells = spreadsheetMock.GetEditedCells();
Assert.AreEqual(editedCells.Count(), 1);
Assert.AreEqual(editedCells[0], container.Cells[1]);
//Assert GetEditedCells call involving visible child spreadsheet
Mock.Arrange(() => childSpreadsheet.IsVisible).Returns(true);
editedCells = spreadsheetMock.GetEditedCells();
Assert.AreEqual(editedCells.Count(), 3);
Assert.AreEqual(editedCells[0], childcontainer1.Cells[1]);
Assert.AreEqual(editedCells[1], childcontainer2.Cells[2]);
Assert.AreEqual(editedCells[2], container.Cells[1]);
}
public void OnApplyTemplateTest()
{
var spreadsheet = Mock.Create<SpreadsheetView>(Behavior.CallOriginal);
var privateAccessor = new PrivateAccessor(spreadsheet);
spreadsheet.OnApplyTemplate();
//FillItemsSource can not be called if ItemsSource is null
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Never(), ArgExpr.IsAny<IEnumerable>());
Assert.IsTrue((bool)privateAccessor.GetField("_templateApplied"));
privateAccessor.SetField("_templateApplied", false);
spreadsheet.ItemsSource = new List<TestData>();
spreadsheet.OnApplyTemplate();
//AutoGenerateColumns is true and Columns is not null
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Once(), ArgExpr.IsAny<IEnumerable>());
Assert.IsTrue((bool)privateAccessor.GetField("_templateApplied"));
spreadsheet.Columns = null;
spreadsheet.OnApplyTemplate();
//AutoGenerateColumns is true and Columns is null
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Once(), ArgExpr.IsAny<IEnumerable>());
Assert.IsTrue((bool)privateAccessor.GetField("_templateApplied"));
spreadsheet.Columns = new SpreadsheetColumnCollection();
spreadsheet.AutoGenerateColumns = false;
spreadsheet.OnApplyTemplate();
//AutoGenerateColumns is false but Columns collection is empty
Mock.NonPublic.Assert(spreadsheet, "FillItemsSource", Occurs.Once(), ArgExpr.IsAny<IEnumerable>());
Assert.IsTrue((bool)privateAccessor.GetField("_templateApplied"));
}
public void SwitchVisibilityIncludingChildrenMethodTest()
{
//Mock spreadsheet
var spreadsheetMock = Mock.Create<SpreadsheetView>(Behavior.CallOriginal);
var privateAccessor = new PrivateAccessor(spreadsheetMock);
//Mock columns
var parentColumn = Mock.Create<IDetailColumn>(Constructor.Mocked);
var column = Mock.Create<IDetailColumn>(Constructor.Mocked);
//Arrange
Mock.Arrange(() => spreadsheetMock.ParentColumn).Returns(parentColumn);
var childSpreadsheet = Mock.Create<SpreadsheetView>(Constructor.Mocked);
((List<SpreadsheetView>)privateAccessor.GetField("_childSpreadsheets")).Add(childSpreadsheet);
//Call SwitchVisibilityIncludingChildren when ParentColumn is not equal to column parameter
spreadsheetMock.SwitchVisibilityIncludingChildren(column);
Mock.Assert(() => childSpreadsheet.SwitchVisibilityIncludingChildren(column), Occurs.Once());
Mock.Assert(() => spreadsheetMock.SwitchVisibility(), Occurs.Never());
//Call SwitchVisibilityIncludingChildren when ParentColumn equals column parameter
spreadsheetMock.SwitchVisibilityIncludingChildren(parentColumn);
Mock.Assert(() => childSpreadsheet.SwitchVisibilityIncludingChildren(column), Occurs.Once());
Mock.Assert(() => spreadsheetMock.SwitchVisibility(), Occurs.Once());
}
public void Save()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
fileProcess.OriginalFileName = "1.txt";
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var newValue = Mock.Create<IFileProcess>(Behavior.Loose);
var dataPortalResult = new DataPortalResult<IFileProcess>(newValue, null, null);
Mock.Arrange(() => fileProcess.BeginSaveNew(Arg.IsAny<Action<object, IDataPortalResult>>()))
.DoInstead<Action<object, IDataPortalResult>>(a => a(null, dataPortalResult));
var privateAccessor = new PrivateAccessor(vm);
// act
privateAccessor.CallMethod("Save");
// assert
Assert.AreEqual(newValue, vm.Value);
Assert.AreEqual("File '1.txt' uploaded successfully.", vm.Message);
Assert.AreEqual(FileControlMode.NotifySuccess, privateAccessor.GetField("_previousState"));
// arrange
dataPortalResult = new DataPortalResult<IFileProcess>(null, new Exception(), null);
// act
privateAccessor.CallMethod("Save");
// assert
Assert.AreEqual("Error uploading file.", vm.Message);
Assert.AreEqual(new Exception().ToString(), privateAccessor.GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.NotifyFail, privateAccessor.GetField("_previousState"));
// arrange
fileProcess.Id = 1;
vm.Value = null;
dataPortalResult = new DataPortalResult<IFileProcess>(newValue, null, null);
Mock.Arrange(() => fileProcess.BeginUnlock(Arg.IsAny<Action<object, IDataPortalResult>>()))
.DoInstead<Action<object, IDataPortalResult>>(a => a(null, dataPortalResult));
// act
privateAccessor.CallMethod("Save");
// assert
Assert.AreEqual(newValue, vm.Value);
Assert.AreEqual("File '1.txt' uploaded successfully.", vm.Message);
Assert.AreEqual(FileControlMode.NotifySuccess, vm.CurrentState);
// arrange
vm.Message = null;
privateAccessor.SetProperty("ExceptionMessage", null);
dataPortalResult = new DataPortalResult<IFileProcess>(null, new Exception(), null);
var logger = Mock.Create<ILogger>(Behavior.CallOriginal);
var logWasCalled = false;
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(FieldFileViewModel).ToString(), Arg.IsAny<Exception>())).DoInstead(() => logWasCalled = true);
vm.Logger = logger;
// act
privateAccessor.CallMethod("Save");
// assert
Assert.AreEqual(string.Format(@"Error saving instance of new uploaded file{0}Please try again{0}If the problem persists, try to create a new record, and re-check the System Options\System Paths", Environment.NewLine), vm.Message);
Assert.AreEqual(new Exception().ToString(), privateAccessor.GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
Assert.IsTrue(logWasCalled);
}
