public void CompoundBinaryExpression_And()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
var expectedCriteria =
new Criteria(
Criteria.Create <MyBO, int>(bo => bo.TestInt, Criteria.ComparisonOp.GreaterThan, 5),
Criteria.LogicalOp.And,
Criteria.Create <MyBO, int>(bo => bo.TestInt, Criteria.ComparisonOp.LessThan, 10)
);
//---------------Execute Test ----------------------
var criteria = Criteria.Expr <MyBO>(bo => bo.TestInt > 5 && bo.TestInt < 10).Build();
//---------------Test Result -----------------------
Assert.AreEqual(expectedCriteria, criteria);
}
public void TestChangeFromValueAndBack()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
MyBO bo = new MyBO();
string testValue = TestUtil.GetRandomString();
new PropertyLink <string, string>(bo, "TestProp", "TestProp2", delegate(string input) { return(input); });
bo.TestProp = testValue;
bo.TestProp2 = TestUtil.GetRandomString();
//---------------Execute Test ----------------------
bo.TestProp = bo.TestProp2;
bo.TestProp = testValue;
//---------------Test Result -----------------------
Assert.AreEqual(testValue, bo.TestProp2);
//---------------Tear Down -------------------------
}
public void TestEnableControls()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
MyBO myBO = new MyBO();
PanelBuilder factory = new PanelBuilder(GetControlFactory());
IPanelInfo panelInfo = factory.BuildPanelForForm(myBO.ClassDef.UIDefCol["default"].UIForm);
panelInfo.BusinessObject = myBO;
panelInfo.ControlsEnabled = false;
//---------------Execute Test ----------------------
panelInfo.ControlsEnabled = true;
//---------------Test Result -----------------------
Assert.IsTrue(panelInfo.FieldInfos[TEST_PROP_1].ControlMapper.Control.Enabled);
Assert.IsTrue(panelInfo.FieldInfos[TEST_PROP_2].ControlMapper.Control.Enabled);
//---------------Tear Down -------------------------
}
public void Test_NoPropDef_ShouldSetKeepValuePrivateFalse()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadDefaultClassDef();
const string testPropertyName = "TestPropertyKeepValueNotPrivate";
UIFormField uiFormField = new UIFormField(null, testPropertyName, typeof(TextBox), null, null, true, null, null, LayoutStyle.Label);
AddFieldToClassDef(classDef, uiFormField);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
bool keepValuePrivate = uiFormField.KeepValuePrivate;
//---------------Test Result -----------------------
Assert.IsFalse(keepValuePrivate);
}
public void Test_SelectIndex_SetsSelectedBO()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> col = CreateCollectionWith_4_Objects();
IEditableGrid editableGrid = GetControlFactory().CreateEditableGrid();
AddControlToForm(editableGrid);
SetupGridColumnsForMyBo(editableGrid);
editableGrid.BusinessObjectCollection = col;
MyBO myBO = col[2];
//---------------Execute Test ----------------------
editableGrid.Rows[2].Selected = true;
//---------------Test Result -----------------------
Assert.AreEqual(col.Count + 1, editableGrid.Rows.Count, "should be 4 item 1 adding item");
Assert.AreSame(myBO, editableGrid.SelectedBusinessObject);
}
public void TestSetCollectionOnGrid_NoOfRows()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> col = CreateCollectionWith_4_Objects();
IReadOnlyGrid readOnlyGrid = GetControlFactory().CreateReadOnlyGrid();
DisposeOnTearDown(readOnlyGrid);
AddControlToForm(readOnlyGrid);
SetupGridColumnsForMyBo(readOnlyGrid);
//---------------Execute Test ----------------------
#pragma warning disable 618,612
readOnlyGrid.SetBusinessObjectCollection(col);
#pragma warning restore 618,612
//---------------Test Result -----------------------
Assert.AreEqual(4, readOnlyGrid.Rows.Count);
//---------------Tear Down -------------------------
}
public void TestDisable()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
MyBO bo = new MyBO();
string testValue = TestUtil.GetRandomString();
PropertyLink <string, string> link = new PropertyLink <string, string>(bo, "TestProp", "TestProp2",
delegate(string input) { return(input); });
bo.TestProp = testValue;
//---------------Assert PreConditions---------------
Assert.AreEqual(testValue, bo.TestProp2);
//---------------Execute Test ----------------------
link.Disable();
bo.TestProp = TestUtil.GetRandomString();
//---------------Test Result -----------------------
Assert.AreEqual(testValue, bo.TestProp2);
}
public void Test_UsingDefaultBusinessObjectLoader()
{
//---------------Set up test pack-------------------
DataAccessorMultiSource dataAccessor = new DataAccessorMultiSource(new DataAccessorInMemory());
ITransactionCommitter committer = dataAccessor.CreateTransactionCommitter();
MyBO.LoadDefaultClassDef();
var bo1 = new MyBO();
committer.AddBusinessObject(bo1);
committer.CommitTransaction();
//---------------Execute Test ----------------------
var loadedBo1 = dataAccessor.BusinessObjectLoader.GetBusinessObject <MyBO>(bo1.ID);
//---------------Test Result -----------------------
Assert.AreSame(loadedBo1, bo1);
//---------------Tear down -------------------------
}
public void TestPanelSetup()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
MyBO myBO = new MyBO();
myBO.TestProp = START_VALUE_1;
myBO.SetPropertyValue(TEST_PROP_2, START_VALUE_2);
PanelBuilder factory = new PanelBuilder(GetControlFactory());
//---------------Execute Test ----------------------
IPanelInfo panelInfo = factory.BuildPanelForForm(myBO.ClassDef.UIDefCol["default"].UIForm);
panelInfo.BusinessObject = myBO;
//---------------Test Result -----------------------
Assert.AreEqual(START_VALUE_1, panelInfo.FieldInfos[TEST_PROP_1].ControlMapper.Control.Text);
Assert.AreEqual(START_VALUE_2, panelInfo.FieldInfos[TEST_PROP_2].ControlMapper.Control.Text);
}
public void Test_ShouldThrowError_WhenAddingObjectsOfDifferentTypesWithDifferentDataAccessors()
{
//---------------Set up test pack-------------------
IDataAccessor defaultDataAccessor = new DataAccessorInMemory();
DataStoreInMemory dataStore1 = new DataStoreInMemory();
DataStoreInMemory dataStore2 = new DataStoreInMemory();
DataAccessorInMemory dataAccessorInMemory1 = new DataAccessorInMemory(dataStore1);
DataAccessorInMemory dataAccessorInMemory2 = new DataAccessorInMemory(dataStore2);
MyBO.LoadDefaultClassDef();
MyRelatedBo.LoadClassDef();
MyBO bo1 = new MyBO();
MyRelatedBo bo2 = new MyRelatedBo();
Dictionary <Type, IDataAccessor> dataAccessors = new Dictionary <Type, IDataAccessor>();
dataAccessors.Add(typeof(MyBO), dataAccessorInMemory1);
dataAccessors.Add(typeof(MyRelatedBo), dataAccessorInMemory2);
//---------------Execute Test ----------------------
try
{
ITransactionCommitter transactionCommitter1 = new TransactionCommitterMultiSource(defaultDataAccessor, dataAccessors);
transactionCommitter1.AddBusinessObject(bo1);
transactionCommitter1.AddBusinessObject(bo2);
transactionCommitter1.CommitTransaction();
Assert.Fail("Error should have occurred");
} catch (HabaneroDeveloperException ex)
//---------------Test Result -----------------------
{
Assert.IsNull(dataStore1.Find <MyBO>(bo1.ID));
Assert.IsNull(dataStore1.Find <MyRelatedBo>(bo2.ID));
Assert.IsNull(dataStore2.Find <MyBO>(bo1.ID));
Assert.IsNull(dataStore2.Find <MyRelatedBo>(bo2.ID));
StringAssert.Contains("MyRelatedBo", ex.DeveloperMessage);
StringAssert.Contains("was added to a TransactionCommitterMultiSource which has been set up with a different source to this type", ex.DeveloperMessage);
//correct
}
//---------------Tear down -------------------------
}
public void TestVWGInitialise_SelectionEditMode()
{
//---------------Set up test pack-------------------
IEditableGridControl gridControl = GetControlFactory().CreateEditableGridControl();
MyBO.LoadDefaultClassDef();
IClassDef def = ClassDef.ClassDefs[typeof(MyBO)];
//---------------Execute Test ----------------------
gridControl.Initialise(def);
//---------------Test Result -----------------------
Assert.AreEqual
(DataGridViewSelectionMode.RowHeaderSelect,
((DataGridView)gridControl.Grid).SelectionMode);
Assert.AreEqual
(DataGridViewEditMode.EditOnKeystrokeOrF2,
((DataGridView)gridControl.Grid).EditMode);
//---------------Tear Down -------------------------
}
public void Test_Constructor()
{
//--------------- Set up test pack ------------------
const string message = "message";
const ErrorLevel errorLevel = ErrorLevel.Error;
ClassDef.ClassDefs.Clear();
MyBO.LoadDefaultClassDef();
IBusinessObject bo = new MyBO();
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
BOError boError = new BOError(message, errorLevel);
//--------------- Test Result -----------------------
Assert.AreEqual(message, boError.Message);
Assert.AreEqual(errorLevel, boError.Level);
}
public void TestSetListBoxCollection()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
IListBox listBox = CreateListBox();
var manager = CreateListBoxCollectionManager(listBox);
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> myBoCol = new BusinessObjectCollection <MyBO>
{
new MyBO(), new MyBO(), new MyBO()
};
//---------------Execute Test ----------------------
manager.SetCollection(myBoCol);
//---------------Test Result -----------------------
Assert.AreEqual(3, manager.Collection.Count);
//---------------Tear down -------------------------
}
public void Test_CancelEditsItemFromCollection_UpdatesItemInCombo()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
IComboBox cmbox = GetControlFactory().CreateComboBox();
DisposeOnTearDown(cmbox);
IControlFactory controlFactory = GetControlFactory();
ComboBoxCollectionSelector selectorManager = new ComboBoxCollectionSelector(cmbox, controlFactory)
{
IncludeBlankItem = false
};
DisposeOnTearDown(selectorManager);
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> myBOs = new BusinessObjectCollection <MyBO> {
{ new MyBO(), new MyBO() }
};
selectorManager.SetCollection(myBOs);
MyBO myBO = myBOs[0];
Guid newValue = Guid.NewGuid();
int index = cmbox.Items.IndexOf(myBO);
cmbox.SelectedIndex = index;
myBO.MyBoID = newValue;
myBO.Save();
//---------------Assert precondition----------------
Assert.AreEqual(2, cmbox.Items.Count);
Assert.AreEqual(0, cmbox.SelectedIndex);
Assert.AreSame(myBO, cmbox.Items[index]);
Assert.AreEqual(index, cmbox.SelectedIndex);
//---------------Execute Test ----------------------
myBO.MyBoID = Guid.NewGuid();
myBO.CancelEdits();
//---------------Test Result -----------------------
Assert.AreEqual(0, cmbox.SelectedIndex);
Assert.AreEqual(index, cmbox.SelectedIndex);
Assert.AreSame(myBO, cmbox.Items[index]);
string newToString = myBO.ToString();
Assert.AreEqual(newToString, cmbox.Items[index].ToString());
}
public void Test_SetPropertyDisplayValue_WithIntString_ShouldBeAbleGetString()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
MyBO.LoadDefaultClassDef();
var testBo = new MyBO();
var boMapper = new BOMapper(testBo);
const string propName = "TestProp";
boMapper.SetDisplayPropertyValue(propName, "7");
//---------------Assert Precondition----------------
Assert.AreEqual("7", boMapper.GetPropertyValueToDisplay(propName).ToString());
//---------------Execute Test ----------------------
boMapper.SetDisplayPropertyValue(propName, "3");
//---------------Test Result -----------------------
Assert.AreEqual("3", boMapper.GetPropertyValueToDisplay(propName).ToString());
Assert.AreEqual("3", testBo.TestProp);
}
public void Test_GetBusinessObjectAtRow_WhenSetViaCustomLoad_ShouldRetBO()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> col = CreateCollectionWith_4_Objects();
IReadOnlyGrid readOnlyGrid = GetControlFactory().CreateReadOnlyGrid();
DisposeOnTearDown(readOnlyGrid);
AddControlToForm(readOnlyGrid);
SetupGridColumnsForMyBo(readOnlyGrid);
readOnlyGrid.BusinessObjectCollection = col;
//---------------Assert Precondition----------------
Assert.AreEqual(4, readOnlyGrid.Rows.Count);
//---------------Execute Test ----------------------
var actualBO = readOnlyGrid.GetBusinessObjectAtRow(1);
//---------------Test Result -----------------------
Assert.AreSame(col[1], actualBO);
}
public void Test_Using_EditableDataSetProvider()
{
//---------------Set up test pack-------------------
IEditableGridControl gridControl = GetControlFactory().CreateEditableGridControl();
MyBO.LoadDefaultClassDef();
IClassDef def = ClassDef.ClassDefs[typeof(MyBO)];
gridControl.Initialise(def);
BusinessObjectCollection <MyBO> col = new BusinessObjectCollection <MyBO>();
//--------------Assert PreConditions----------------
//---------------Execute Test ----------------------
gridControl.Grid.BusinessObjectCollection = col;
//---------------Test Result -----------------------
Assert.IsInstanceOf(typeof(EditableDataSetProvider), gridControl.Grid.DataSetProvider);
//---------------Tear Down -------------------------
}
public void TestBusinessObejctAddedToCollection_ShouldAddToItems()
{
ClassDef.ClassDefs.Clear();
IListBox listBox = CreateListBox();
var manager = CreateListBoxCollectionManager(listBox);
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> myBoCol = new BusinessObjectCollection <MyBO>();
MyBO addedBo = new MyBO();
myBoCol.Add(new MyBO());
myBoCol.Add(new MyBO());
myBoCol.Add(new MyBO());
manager.SetCollection(myBoCol);
//---------------Execute Test ----------------------
manager.Collection.Add(addedBo);
//---------------Test Result -----------------------
Assert.AreEqual(4, manager.Control.Items.Count);
}
public void Test_AutoSelectsFirstItem()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> col = CreateCollectionWith_4_Objects();
IEditableGridControl editableGridControl = CreateEditableGridControl();
AddControlToForm(editableGridControl);
SetupGridColumnsForMyBo(editableGridControl.Grid);
editableGridControl.AllowUsersToAddBO = true;
//-----------------Assert Preconditions-----------------------
Assert.AreEqual(1, editableGridControl.Grid.Rows.Count, "The number of items in the grid plus the null item");
//---------------Execute Test ----------------------
editableGridControl.BusinessObjectCollection = col;
//---------------Test Result -----------------------
Assert.AreEqual(col.Count + 1, editableGridControl.Grid.Rows.Count, "should be 4 item 1 adding item");
Assert.IsNotNull(editableGridControl.SelectedBusinessObject);
Assert.AreSame(col[0], editableGridControl.SelectedBusinessObject);
}
public void Test_EditUnselectedItemFromCollection_WhenAnotherItemIsSelected_UpdatesItemInCombo_MaintainsSelectedItem_FixBugBug1469()
{
//---------------Set up test pack-------------------
var cmbox = GetControlFactory().CreateComboBox();
DisposeOnTearDown(cmbox);
var controlFactory = GetControlFactory();
var selectorManager = new ComboBoxCollectionSelector(cmbox, controlFactory, false);
DisposeOnTearDown(selectorManager);
MyBO.LoadDefaultClassDef();
var myBOs = new BusinessObjectCollection <MyBO> {
{ new MyBO(), new MyBO(), new MyBO() }
};
selectorManager.SetCollection(myBOs);
var myBO = myBOs[1];
var selectBo = myBOs[2];
selectorManager.SelectedBusinessObject = selectBo;
var origToString = myBO.ToString();
var newValue = Guid.NewGuid();
var index = cmbox.Items.IndexOf(myBO);
//---------------Assert precondition----------------
Assert.AreSame(selectBo, selectorManager.SelectedBusinessObject);
Assert.AreSame(selectBo, cmbox.SelectedItem);
Assert.AreSame(myBO, cmbox.Items[index]);
Assert.AreNotEqual(index, cmbox.SelectedIndex);
//---------------Execute Test ----------------------
myBO.MyBoID = newValue;
//---------------Test Result -----------------------
var newToString = myBO.ToString();
Assert.AreNotEqual(origToString, newToString);
Assert.AreSame(selectBo, selectorManager.SelectedBusinessObject);
Assert.AreSame(selectBo, cmbox.SelectedItem);
// Assert.AreNotEqual(origToString, cmbox.Text);
// Assert.AreEqual(newToString, cmbox.Text);
}
public void Test_DefaultDataAccessor_AddTransaction()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore = new DataStoreInMemory();
IDataAccessor defaultDataAccessor = new DataAccessorInMemory(dataStore);
MyBO.LoadDefaultClassDef();
MyBO bo1 = new MyBO();
MyBO bo2 = new MyBO();
//---------------Execute Test ----------------------
ITransactionCommitter transactionCommitter = new TransactionCommitterMultiSource(defaultDataAccessor, new Dictionary <Type, IDataAccessor>());
transactionCommitter.AddTransaction(new TransactionalBusinessObject(bo1));
transactionCommitter.AddTransaction(new TransactionalBusinessObject(bo2));
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.IsNotNull(dataStore.Find <MyBO>(bo1.ID));
Assert.IsNotNull(dataStore.Find <MyBO>(bo2.ID));
//---------------Tear down -------------------------
}
public void TestAddMethod_IgnoresAddWhenItemAlreadyExists()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> cpCol = new BusinessObjectCollection <MyBO>();
MyBO myBO = new MyBO();
cpCol.Add(myBO);
_businessObjectCollectionTestHelper.RegisterForAddedEvent(cpCol);
//---------------Assert Precondition----------------
BusinessObjectCollectionTestHelper.AssertOneObjectInCurrentAndCreatedCollection(cpCol);
_businessObjectCollectionTestHelper.AssertAddedEventNotFired();
//---------------Execute Test ----------------------
cpCol.Add(myBO);
//---------------Test Result -----------------------
BusinessObjectCollectionTestHelper.AssertOneObjectInCurrentAndCreatedCollection(cpCol);
_businessObjectCollectionTestHelper.AssertAddedEventNotFired();
}
public void Test_UsingGivenDatabaseConnection_Insert()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
MyBO.LoadDefaultClassDef();
MyBO bo = new MyBO();
DatabaseConnection.CurrentConnection = null;
//---------------Assert preconditions---------------
Assert.AreNotSame(_databaseConnection, DatabaseConnection.CurrentConnection);
//---------------Execute Test ----------------------
TransactionalBusinessObjectDB transactional = new TransactionalBusinessObjectDB(bo, _databaseConnection);
SqlStatement sqlStatement = (SqlStatement)transactional.GetPersistSql().FirstOrDefault();
//---------------Test Result -----------------------
Assert.AreSame(_databaseConnection, sqlStatement.Connection);
//---------------Tear down -------------------------
}
public void TestChangeControlValues_DoesNotChangeBusinessObjectValues()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
MyBO myBO = new MyBO();
myBO.TestProp = START_VALUE_1;
myBO.SetPropertyValue(TEST_PROP_2, START_VALUE_2);
Habanero.Faces.Base.PanelBuilder factory = new Habanero.Faces.Base.PanelBuilder(GetControlFactory());
IPanelInfo panelInfo = factory.BuildPanelForForm(myBO.ClassDef.UIDefCol["default"].UIForm);
panelInfo.BusinessObject = myBO;
//---------------Execute Test ----------------------
ChangeValuesInControls(panelInfo);
//---------------Test Result -----------------------
Assert.AreEqual(START_VALUE_1, myBO.GetPropertyValue(TEST_PROP_1));
Assert.AreEqual(START_VALUE_2, myBO.GetPropertyValue(TEST_PROP_2));
}
public void Test_EditSecondItemFromCollection_UpdatesItemInCombo()
{
//---------------Set up test pack-------------------
var cmbox = GetControlFactory().CreateComboBox();
DisposeOnTearDown(cmbox);
var controlFactory = GetControlFactory();
var selectorManager = new ComboBoxCollectionSelector(cmbox, controlFactory)
{
IncludeBlankItem = false
};
DisposeOnTearDown(selectorManager);
MyBO.LoadDefaultClassDef();
var myBOs = new BusinessObjectCollection <MyBO> {
{ new MyBO(), new MyBO() }
};
selectorManager.SetCollection(myBOs);
var myBO = myBOs[1];
string origToString = myBO.ToString();
var newValue = Guid.NewGuid();
var index = cmbox.Items.IndexOf(myBO);
cmbox.SelectedIndex = index;
//---------------Assert precondition----------------
Assert.AreEqual(2, cmbox.Items.Count);
Assert.AreEqual(1, cmbox.SelectedIndex);
Assert.AreSame(myBO, cmbox.Items[index]);
Assert.AreEqual(origToString, cmbox.Items[index].ToString());
Assert.AreEqual(origToString, cmbox.Text);
//---------------Execute Test ----------------------
myBO.MyBoID = newValue;
//---------------Test Result -----------------------
string newToString = myBO.ToString();
Assert.AreNotEqual(origToString, newToString);
Assert.AreEqual(index, cmbox.SelectedIndex);
//Assert.AreNotEqual(origToString, cmbox.Text);
//Assert.AreEqual(newToString, cmbox.Text);
}
public override void TestGetBusinessObjectAtRow_WhenDataSourceNotNullButDataSetProviderNull_ShouldReturnBO()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> col = CreateCollectionWith_4_Objects();
IGridBase gridBase = CreateGridBaseStub();
gridBase.GridLoader = GridLoaderDelegateSetDataSource;
SetupGridColumnsForMyBo(gridBase);
gridBase.BusinessObjectCollection = col;
//---------------Assert Preconditions---------------
Assert.IsNull(gridBase.DataSetProvider);
Assert.IsNotNull(gridBase.DataSource);
//---------------Execute Test ----------------------
IBusinessObject businessObject2 = gridBase.GetBusinessObjectAtRow(2);
IBusinessObject businessObject3 = gridBase.GetBusinessObjectAtRow(3);
//---------------Test Result -----------------------
Assert.AreSame(col[2], businessObject2);
Assert.AreSame(col[3], businessObject3);
}
public void TestVWG_Set_BusinessObjectCollection()
{
//---------------Set up test pack-------------------
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> col = CreateCollectionWith_4_Objects();
IGridBase gridBase = CreateGridBaseStub();
SetupGridColumnsForMyBo(gridBase);
const string propName = "TestProp";
const int rowIndex = 1;
//---------------Execute Test ----------------------
gridBase.BusinessObjectCollection = col;
//---------------Test Result -----------------------
MyBO selectedBo = (MyBO)gridBase.GetBusinessObjectAtRow(rowIndex);
IDataGridViewRow row = gridBase.Rows[rowIndex];
IDataGridViewCell cell = row.Cells[propName];
Assert.AreEqual(selectedBo.TestProp, cell.Value);
}
public void TestIsCompulsory_WhenBOPropFalse_AndShowAsCompTrue_ShouldBeTrue()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadDefaultClassDef();
const string propertyName = "TestProp";
IUIFormField field = classDef.UIDefCol["default"].GetFormField(propertyName);
field.ShowAsCompulsory = true;
var propDef = classDef.PropDefcol[propertyName];
//---------------Assert Precondition----------------
Assert.IsFalse(propDef.Compulsory);
var showAsCompulsory = field.ShowAsCompulsory;
Assert.IsTrue((bool)showAsCompulsory);
//---------------Execute Test ----------------------
bool isCompulsory = field.IsCompulsory;
//---------------Test Result -----------------------
Assert.IsTrue(isCompulsory);
}
public void TestSelectedBusinessObject()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
IListBox listBox = CreateListBox();
var manager = CreateListBoxCollectionManager(listBox);
MyBO.LoadDefaultClassDef();
BusinessObjectCollection <MyBO> myBoCol = new BusinessObjectCollection <MyBO>();
MyBO selectedBO = new MyBO();
myBoCol.Add(new MyBO());
myBoCol.Add(selectedBO);
myBoCol.Add(new MyBO());
//---------------Execute Test ----------------------
manager.SetCollection(myBoCol);
manager.Control.SelectedIndex = 1;
//---------------Test Result -----------------------
Assert.AreEqual(selectedBO, manager.SelectedBusinessObject);
//---------------Tear down -------------------------
}
public void TestBusinessObjectRemovedFromCollection_ShouldRemoveFromItems()
{
ClassDef.ClassDefs.Clear();
var listBox = CreateListBox();
var manager = CreateListBoxCollectionManager(listBox);
MyBO.LoadDefaultClassDef();
var myBoCol = new BusinessObjectCollection <MyBO>();
var removedBo = new MyBO();
myBoCol.Add(new MyBO());
myBoCol.Add(removedBo);
myBoCol.Add(new MyBO());
manager.BusinessObjectCollection = myBoCol;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
manager.BusinessObjectCollection.Remove(removedBo);
//---------------Test Result -----------------------
Assert.AreEqual(2, manager.Control.Items.Count);
}