public void PrepareSpreadsheet()
{
//Create item
var dataItem = new TestData { Text = "str", FractionalNumber = 1.0 };
//Create spreadsheet, populate Items collection and build columns
_spreadsheet = Mock.Create<SpreadsheetView>(Behavior.CallOriginal);
_spreadsheet.ItemsSource = new List<TestData> { dataItem };
_spreadsheet.OnApplyTemplate();
//Need one of the columns built
var column = _spreadsheet.Columns.FirstOrDefault(x => x.PropertyName == "Text");
if (column == null)
Assert.Fail();
//Create container but suppress cells creation
var container = new SpreadsheetItemContainer(_spreadsheet);
Mock.NonPublic.Arrange(container, "InitializeCellsWithValues").DoNothing();
container.Item = ItemWrap.BuildNew(dataItem);
//Avoid calling original SetValueBinding and SetEditorParams methods from cell's constructor
Mock.NonPublic.Arrange(typeof(Cell), "SetValueBinding", container.Item);
Mock.NonPublic.Arrange(typeof(Cell), "SetEditorParams");
_cell = column.CreateCell(container) as Cell;
//Mock behavior
_cellInteractionBehaviorMock = Mock.Create<CellInteractionBehavior>(Behavior.CallOriginal);
//Attach behavior to the new control and check that OnAttached method was called
_contentControl = Mock.Create<CellControl>(Behavior.CallOriginal);
_contentControl.Content = _cell;
_contentControl.DataContext = _cell;
_cellInteractionBehaviorMock.Attach(_contentControl);
Mock.NonPublic.Assert(_cellInteractionBehaviorMock, "OnAttached", Occurs.Once());
}
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 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 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 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 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 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 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);
}
