public void TestInitGrid_UIDef_ZeroWidthColumn_HidesColumn()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWith_Grid_2Columns_1stHasZeroWidth();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
//---------------Assert Preconditions---------------
Assert.AreEqual(2, uiGridDef.Count, "2 defined columns in the defaultDef");
IUIGridColumn columnDef1 = uiGridDef[0];
Assert.AreEqual("TestProp", columnDef1.PropertyName);
Assert.AreEqual(0, columnDef1.Width);
IUIGridColumn columnDef2 = uiGridDef[1];
Assert.AreEqual("TestProp2", columnDef2.PropertyName);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
//---------------Test Result -----------------------
IDataGridViewColumn dataColumn1 = grid.Grid.Columns[1];
AssertThatDataColumnSetupCorrectly(classDef, columnDef1, dataColumn1);
IDataGridViewColumn dataColumn2 = grid.Grid.Columns[2];
AssertThatDataColumnSetupCorrectly(classDef, columnDef2, dataColumn2);
//---------------Tear Down -------------------------
}
public void TestInitialiseGrid()
{
//---------------Set up test pack-------------------
IClassDef classDef = LoadMyBoDefaultClassDef();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
//---------------Assert Preconditions---------------
Assert.AreEqual(2, uiGridDef.Count, "2 defined columns in the defaultDef");
// Assert.AreEqual("", grid.UiDefName);
Assert.IsNull(grid.ClassDef);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
//---------------Test Result -----------------------
Assert.AreEqual("default", grid.UiDefName);
Assert.AreEqual(classDef, grid.ClassDef);
Assert.AreEqual
(uiGridDef.Count + 1, grid.Grid.Columns.Count,
"There should be 1 ID column and 2 defined columns in the defaultDef");
Assert.IsTrue(initialiser.IsInitialised);
// Assert.IsTrue(grid.IsInitialised);
}
public void Test_Acceptance_Filter_When_On_Page2_Of_Pagination()
{
//---------------Set up test pack-------------------
//Get Grid with 4 items
BusinessObjectCollection <MyBO> col;
IReadOnlyGridControl readOnlyGridControl = GetGridWith_4_Rows(out col, true);
AddControlToForm(readOnlyGridControl);
ITextBox tb = readOnlyGridControl.FilterControl.AddStringFilterTextBox("Test Prop", "TestProp");
//Set items per page to 3 items
readOnlyGridControl.Grid.ItemsPerPage = 3;
//Go to page 2 (pagination page)
readOnlyGridControl.Grid.CurrentPage = 2;
//--------------Assert PreConditions ---------------
Assert.AreEqual(2, readOnlyGridControl.Grid.CurrentPage);
//---------------Execute Test ----------------------
//enter data in filter for 1 item
tb.Text = "b";
readOnlyGridControl.FilterControl.ApplyFilter();
//---------------Test Result -----------------------
// verify that grid has moved back to page 1
Assert.AreEqual(1, readOnlyGridControl.Grid.CurrentPage);
//---------------Tear Down -------------------------
}
public void TestGridFiringItemSelected()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
IReadOnlyGridControl readOnlyGridControl = GetControlFactory().CreateReadOnlyGridControl();
DisposeOnTearDown(readOnlyGridControl);
BusinessObjectCollection <MyBO> myBOS = new BusinessObjectCollection <MyBO>();
myBOS.Add(new MyBO());
MyBO bo = new MyBO();
myBOS.Add(bo);
myBOS.Add(new MyBO());
readOnlyGridControl.SetBusinessObjectCollection(myBOS);
bool gridItemSelected = false;
readOnlyGridControl.Grid.SelectedBusinessObject = null;
readOnlyGridControl.Grid.BusinessObjectSelected += (delegate { gridItemSelected = true; });
//---------------Execute Test ----------------------
readOnlyGridControl.Grid.SelectedBusinessObject = bo;
//---------------Test Result -----------------------
Assert.IsTrue(gridItemSelected);
}
public void Test_InitialiseGrid_NoClassDef_NoColumnsDefined()
{
//---------------Set up test pack-------------------
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
// IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
//--------------Assert PreConditions----------------
Assert.IsFalse(grid.IsInitialised);
//---------------Execute Test ----------------------
try
{
grid.Initialise();
Assert.Fail("Should raise error");
}
catch (GridBaseInitialiseException ex)
{
StringAssert.Contains
("You cannot call initialise with no classdef since the ID column has not been added to the grid",
ex.Message);
}
//---------------Test Result -----------------------
//---------------Tear Down -------------------------
}
public void Test_AddClicked_RowAddedAfterPostEditActionCalled()
{
//---------------Set up test pack-------------------
//Get Grid with 4 items
BusinessObjectCollection <MyBO> col;
IReadOnlyGridControl readOnlyGridControl = GetGridWith_4_Rows(out col, true);
//AddControlToForm(readOnlyGridControl);
IButton button = readOnlyGridControl.Buttons["Add"];
MyBO myNewBo = null;
PostObjectEditDelegate editorPostEditAction = null;
readOnlyGridControl.BusinessObjectEditor = new DelegatedBusinessObjectEditor <MyBO>(
delegate(MyBO obj, string uiDefName, PostObjectEditDelegate postEditAction)
{
myNewBo = obj;
editorPostEditAction = postEditAction;
return(true);
});
button.PerformClick();
//-------------Assert Preconditions -------------
Assert.IsNotNull(editorPostEditAction);
Assert.IsNotNull(myNewBo);
Assert.AreEqual(4, readOnlyGridControl.Grid.Rows.Count);
//---------------Execute Test ----------------------
editorPostEditAction(myNewBo, true);
//---------------Test Result -----------------------
Assert.AreEqual(5, readOnlyGridControl.Grid.Rows.Count);
}
public void TestInitGrid_With_GridDef()
{
//---------------Set up test pack-------------------
IClassDef classDef = LoadMyBoDefaultClassDef();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIGrid uiGridDef = classDef.UIDefCol["default"].UIGrid;
//---------------Assert Preconditions---------------
Assert.AreEqual(2, uiGridDef.Count, "2 defined columns in the defaultDef");
IUIGridColumn columnDef1 = uiGridDef[0];
Assert.AreEqual("TestProp", columnDef1.PropertyName);
IUIGridColumn columnDef2 = uiGridDef[1];
Assert.AreEqual("TestProp2", columnDef2.PropertyName);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef, uiGridDef, "test");
//---------------Test Result -----------------------
IDataGridViewColumn idColumn = grid.Grid.Columns[0];
AssertVerifyIDFieldSetUpCorrectly(idColumn);
IDataGridViewColumn dataColumn1 = grid.Grid.Columns[1];
AssertThatDataColumnSetupCorrectly(classDef, columnDef1, dataColumn1);
IDataGridViewColumn dataColumn2 = grid.Grid.Columns[2];
AssertThatDataColumnSetupCorrectly(classDef, columnDef2, dataColumn2);
//---------------Tear Down -------------------------
}
///<summary>
/// Constructor for <see cref="EditableGridControlManager"/>
///</summary>
///<param name="gridControl"></param>
///<param name="controlFactory"></param>
public ReadOnlyGridControlManager(IReadOnlyGridControl gridControl, IControlFactory controlFactory)
{
GridControl = gridControl;
ControlFactory = controlFactory;
if (gridControl == null) throw new ArgumentNullException("gridControl");
if (controlFactory == null) throw new ArgumentNullException("controlFactory");
GridInitialiser = new GridInitialiser(gridControl, controlFactory);
}
protected override IBOColSelectorControl CreateSelector()
{
IReadOnlyGridControl readOnlyGridControl = GetControlFactory().CreateReadOnlyGridControl();
Gizmox.WebGUI.Forms.Form frm = new Gizmox.WebGUI.Forms.Form();
frm.Controls.Add((Gizmox.WebGUI.Forms.Control)readOnlyGridControl);
return(GetControlledLifetimeFor(readOnlyGridControl));
}
protected override IBOColSelectorControl CreateSelector()
{
IReadOnlyGridControl readOnlyGridControl = GetControlFactory().CreateReadOnlyGridControl();
System.Windows.Forms.Form frm = new System.Windows.Forms.Form();
frm.Controls.Add((System.Windows.Forms.Control)readOnlyGridControl);
return(GetControlledLifetimeFor(readOnlyGridControl));
}
public void TestDisableDefaultRowDoubleClick()
{
//---------------Set up test pack-------------------
IReadOnlyGridControl onlyGridControlgrid = CreateReadOnlyGridControl(true);
// onlyGridControlgrid.Initialise();
//-----Test PreCondition----------------------------------------
Assert.IsTrue(onlyGridControlgrid.DoubleClickEditsBusinessObject);
//---------------Execute Test ----------------------
onlyGridControlgrid.DoubleClickEditsBusinessObject = false;
//---------------Test Result -----------------------
Assert.IsFalse(onlyGridControlgrid.DoubleClickEditsBusinessObject);
}
public void TestInitGrid_UIDef_DateFormat_FormatsDateColumn()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithDateTimeParameterFormat();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
AddControlToForm(grid);
GlobalUIRegistry.DateDisplaySettings = new DateDisplaySettings();
GlobalUIRegistry.DateDisplaySettings.GridDateFormat = "dd MMM yyyy";
//--------------Assert PreConditions----------------
const string formattedPropertyName = "TestDateTimeFormat";
Assert.IsNotNull(uiGridDef[formattedPropertyName]);
Assert.IsNotNull(uiGridDef["TestDateTimeNoFormat"]);
Assert.IsNotNull(uiGridDef["TestDateTime"]);
Assert.IsNull(uiGridDef["TestDateTimeNoFormat"].GetParameterValue("dateFormat"));
Assert.IsNull(uiGridDef["TestDateTime"].GetParameterValue("dateFormat"));
object dateFormatObject = uiGridDef[formattedPropertyName].GetParameterValue("dateFormat");
string dateFormatParameter = dateFormatObject.ToString();
const string expectedFormat = "dd.MMM.yyyy";
Assert.AreEqual(expectedFormat, dateFormatParameter);
MyBO myBo = new MyBO();
DateTime currentDateTime = DateTime.Now;
myBo.SetPropertyValue(formattedPropertyName, currentDateTime);
BusinessObjectCollection <MyBO> col = new BusinessObjectCollection <MyBO>();
col.Add(myBo);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
grid.BusinessObjectCollection = col;
//---------------Test Result -----------------------
Assert.AreEqual(1, col.Count);
Assert.AreEqual(1, grid.Grid.Rows.Count);
IDataGridViewCell dataGridViewCell = grid.Grid.Rows[0].Cells[formattedPropertyName];
//((DataGridViewCellVWG) dataGridViewCell).DataGridViewCell.HasStyle = false;
Assert.AreSame(typeof(DateTime), dataGridViewCell.ValueType);
Assert.AreEqual(currentDateTime.ToString(expectedFormat), dataGridViewCell.FormattedValue);
//---------------Tear Down -------------------------
}
///<summary>
/// Constructor for <see cref="EditableGridControlManager"/>
///</summary>
///<param name="gridControl"></param>
///<param name="controlFactory"></param>
public ReadOnlyGridControlManager(IReadOnlyGridControl gridControl, IControlFactory controlFactory)
{
GridControl = gridControl;
ControlFactory = controlFactory;
if (gridControl == null)
{
throw new ArgumentNullException("gridControl");
}
if (controlFactory == null)
{
throw new ArgumentNullException("controlFactory");
}
GridInitialiser = new GridInitialiser(gridControl, controlFactory);
}
public void TestInitGrid_UIDef_CurrencyFormat_WhenVirtualProp_ShouldFormatColumn()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithCurrencyParameterFormat();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
AddControlToForm(grid);
//--------------Assert PreConditions----------------
const string formattedPropertyName = "TestCurrencyFormat";
Assert.IsNotNull(uiGridDef[formattedPropertyName]);
Assert.IsNotNull(uiGridDef[formattedPropertyName].GetParameterValue("currencyFormat"));
const string unformattedPropName = "TestCurrencyNoFormat";
Assert.IsNotNull(uiGridDef[unformattedPropName]);
Assert.IsNull(uiGridDef[unformattedPropName].GetParameterValue("currencyFormat"));
object currencyFormat = uiGridDef[formattedPropertyName].GetParameterValue("currencyFormat");
string currencyFormatParameter = currencyFormat.ToString();
const string expectedFormat = "### ###.##";
Assert.AreEqual(expectedFormat, currencyFormatParameter);
MyBO myBo = new MyBO();
const double currencyValue = 222222.55555d;
myBo.SetPropertyValue(formattedPropertyName, currencyValue);
BusinessObjectCollection <MyBO> col = new BusinessObjectCollection <MyBO>();
col.Add(myBo);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
grid.BusinessObjectCollection = col;
//---------------Test Result -----------------------
Assert.AreEqual(1, col.Count);
Assert.AreEqual(1, grid.Grid.Rows.Count);
IDataGridViewCell dataGridViewCell = grid.Grid.Rows[0].Cells[formattedPropertyName];
//((DataGridViewCellVWG) dataGridViewCell).DataGridViewCell.HasStyle = false;
Assert.AreSame(typeof(Double), dataGridViewCell.ValueType);
Assert.AreEqual(currencyValue.ToString(expectedFormat), dataGridViewCell.FormattedValue);
}
public override void Test_AllowUsersToDeleteBo_WhenTrue_ShouldHideButton()
{
//---------------Set up test pack-------------------
IReadOnlyGridControl readOnlyGridControl = CreateReadOnlyGridControl(false);
IButton button = readOnlyGridControl.Buttons["Delete"];
//---------------Assert Precondition----------------
Assert.IsFalse(readOnlyGridControl.AllowUsersToDeleteBO);
Assert.IsFalse(button.Visible);
//---------------Execute Test ----------------------
readOnlyGridControl.AllowUsersToDeleteBO = true;
//---------------Test Result -----------------------
Assert.IsTrue(readOnlyGridControl.AllowUsersToDeleteBO);
Assert.IsTrue(button.Visible);
}
public void Test_GridDoubleClickHandlersAssigned()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IReadOnlyGridControl readOnlyGridControl = CreateReadOnlyGridControl();
//---------------Test Result -----------------------
Assert.AreEqual(1, TestUtil.CountEventSubscribers(readOnlyGridControl.Grid, "DoubleClick"));
Assert.IsTrue
(TestUtil.EventHasSubscriber(readOnlyGridControl.Grid, "DoubleClick", "DoubleClickHandler"));
// THESE TESTS DON'T WORK FOR SOME REASON, BUT THE GRID DOUBLE-CLICKING DOES WORK - ERIC
//Assert.AreEqual(1, TestUtil.CountEventSubscribers(readOnlyGridControl.Grid, "RowDoubleClicked"));
//Assert.IsTrue(TestUtil.EventHasSubscriber(readOnlyGridControl.Grid, "RowDoubleClicked", "Buttons_EditClicked"));
}
public void Test_AddClicked_RowNotAddedBeforePostEditActionCalled()
{
//---------------Set up test pack-------------------
//Get Grid with 4 items
BusinessObjectCollection <MyBO> col;
IReadOnlyGridControl readOnlyGridControl = GetGridWith_4_Rows(out col, true);
//AddControlToForm(readOnlyGridControl);
IButton button = readOnlyGridControl.Buttons["Add"];
readOnlyGridControl.BusinessObjectEditor = new DelegatedBusinessObjectEditor <MyBO>(
(obj, uiDefName, postEditAction) => true);
//-------------Assert Preconditions -------------
Assert.IsNotNull(button);
Assert.AreEqual(4, readOnlyGridControl.Grid.Rows.Count);
//---------------Execute Test ----------------------
button.PerformClick();
//---------------Test Result -----------------------
Assert.AreEqual(4, readOnlyGridControl.Grid.Rows.Count);
}
private void SetupReadOnlyGridControl(string gridUiDefName)
{
_readOnlyGridControl = _controlFactory.CreateReadOnlyGridControl();
_readOnlyGridControl.Width = 300;
_readOnlyGridControl.Grid.RowHeadersWidth = 25;
_readOnlyGridControl.Buttons.Visible = false;
_readOnlyGridControl.FilterControl.Visible = false;
//ClassDef classDef = (ClassDef) _businessObject.ClassDef;
if (!string.IsNullOrEmpty(gridUiDefName))
{
_readOnlyGridControl.Initialise(_classDef, gridUiDefName);
int width = GetGridWidthToFitColumns(_readOnlyGridControl.Grid) + 2;
if (width < 300)
{
_readOnlyGridControl.Width = width;
}
}
_readOnlyGridControl.DoubleClickEditsBusinessObject = false;
}
public void TestInitGrid_WithInvalidUIDef()
{
//---------------Set up test pack-------------------
IClassDef classDef = LoadMyBoDefaultClassDef();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
//---------------Execute Test ----------------------
try
{
initialiser.InitialiseGrid(classDef, "NonExistantUIDef");
Assert.Fail("Should raise an error if the class def does not have the UIDef");
//---------------Test Result -----------------------
}
catch (ArgumentException ex)
{
StringAssert.Contains(" does not contain a definition for UIDef ", ex.Message);
}
//---------------Tear Down -------------------------
}
public void Test_InitialiseGrid_NoClassDef_Twice()
{
//---------------Set up test pack-------------------
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
// IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
grid.Grid.Columns.Add(_gridIdColumnName, _gridIdColumnName);
//--------------Assert PreConditions----------------
Assert.IsFalse(grid.IsInitialised);
//---------------Execute Test ----------------------
try
{
grid.Initialise();
grid.Initialise();
Assert.Fail("Should raise error");
}
catch (GridBaseSetUpException ex)
{
StringAssert.Contains("You cannot initialise the grid more than once", ex.Message);
}
}
public void TestInitGrid_WithNonDefaultUIDef()
{
//---------------Set up test pack-------------------
IClassDef classDef = LoadMyBoDefaultClassDef();
const string alternateUIDefName = "Alternate";
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol[alternateUIDefName];
IUIGrid uiGridDef = uiDef.UIGrid;
//---------------Assert Preconditions---------------
Assert.AreEqual(1, uiGridDef.Count, "1 defined column in the alternateUIDef");
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef, alternateUIDefName);
//---------------Test Result -----------------------
Assert.AreEqual(alternateUIDefName, grid.UiDefName);
Assert.AreEqual(classDef, grid.ClassDef);
Assert.AreEqual
(uiGridDef.Count + 1, grid.Grid.Columns.Count,
"There should be 1 ID column and 1 defined column in the alternateUIDef");
//---------------Tear Down -------------------------
}
public void TestInitGrid_DefaultUIDef_VerifyColumnsSetupCorrectly()
{
//---------------Set up test pack-------------------
IClassDef classDef = LoadMyBoDefaultClassDef();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
GlobalUIRegistry.DateDisplaySettings = new DateDisplaySettings();
GlobalUIRegistry.DateDisplaySettings.GridDateFormat = "dd MMM yyyy";
//---------------Assert Preconditions---------------
Assert.AreEqual(2, uiGridDef.Count, "2 defined columns in the defaultDef");
IUIGridColumn columnDef1 = uiGridDef[0];
Assert.AreEqual("TestProp", columnDef1.PropertyName);
IUIGridColumn columnDef2 = uiGridDef[1];
Assert.AreEqual("TestProp2", columnDef2.PropertyName);
Assert.IsNotNull(GlobalUIRegistry.DateDisplaySettings);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
//---------------Test Result -----------------------
IDataGridViewColumn idColumn = grid.Grid.Columns[0];
AssertVerifyIDFieldSetUpCorrectly(idColumn);
IDataGridViewColumn dataColumn1 = grid.Grid.Columns[1];
AssertThatDataColumnSetupCorrectly(classDef, columnDef1, dataColumn1);
Assert.AreEqual("", dataColumn1.DefaultCellStyle.Format);
IDataGridViewColumn dataColumn2 = grid.Grid.Columns[2];
AssertThatDataColumnSetupCorrectly(classDef, columnDef2, dataColumn2);
//---------------Tear Down -------------------------
}
private void SetupReadOnlyGridControl(string gridUiDefName)
{
_readOnlyGridControl = _controlFactory.CreateReadOnlyGridControl();
_readOnlyGridControl.Width = 300;
_readOnlyGridControl.Grid.RowHeadersWidth = 25;
_readOnlyGridControl.Buttons.Visible = false;
_readOnlyGridControl.FilterControl.Visible = false;
//ClassDef classDef = (ClassDef) _businessObject.ClassDef;
if (!string.IsNullOrEmpty(gridUiDefName))
{
_readOnlyGridControl.Initialise(_classDef, gridUiDefName);
int width = GetGridWidthToFitColumns(_readOnlyGridControl.Grid) + 2;
if (width < 300)
{
_readOnlyGridControl.Width = width;
}
}
_readOnlyGridControl.DoubleClickEditsBusinessObject = false;
}
