[Test] // Ensures that updates to property values are stored and can be retrieved
public void Test_UpdateVehicle()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Vehicle vehicle = TestUtilsVehicle.CreateSavedVehicle();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForVehicleType = TestUtilsShared.GetRandomString();
vehicle.VehicleType = (System.String)valueForVehicleType;
object valueForMaxSpeed = (double)TestUtilsShared.GetRandomInt();
vehicle.MaxSpeed = (System.Double)valueForMaxSpeed;
vehicle.Save();
//---------------Test Result -----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
Vehicle retrievedVehicle =
Broker.GetBusinessObject <Vehicle>(vehicle.ID);
Assert.AreEqual(valueForVehicleType, retrievedVehicle.VehicleType);
Assert.AreEqual(valueForMaxSpeed, retrievedVehicle.MaxSpeed);
}
/// <summary>
/// Creates a new unsaved Vehicle with a random value assigned to every property
/// </summary>
public static Vehicle CreateUnsavedValidVehicle()
{
Vehicle vehicle = new Vehicle();
vehicle.MaxSpeed = (double)TestUtilsShared.GetRandomInt();
return(vehicle);
}
[Test] // Ensures that gets and sets in the code refer to the same property
public void Test_PropertyGetters()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Driver driver = new Driver();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForDriverName = TestUtilsShared.GetRandomString();
driver.DriverName = (System.String)valueForDriverName;
object valueForAge = TestUtilsShared.GetRandomInt();
driver.Age = (System.Int32)valueForAge;
object valueForDOB = TestUtilsShared.GetRandomDate();
driver.DOB = (System.DateTime)valueForDOB;
object valueForLicenseRaing = (double)TestUtilsShared.GetRandomInt();
driver.LicenseRaing = (System.Double)valueForLicenseRaing;
object valueForCarID = Guid.NewGuid();
driver.CarID = (System.Guid)valueForCarID;
//---------------Test Result -----------------------
Assert.AreEqual(valueForDriverName, driver.DriverName);
Assert.AreEqual(valueForAge, driver.Age);
Assert.AreEqual(valueForDOB, driver.DOB);
Assert.AreEqual(valueForLicenseRaing, driver.LicenseRaing);
Assert.AreEqual(valueForCarID, driver.CarID);
}
[Test] // Checks that a related collection loads correctly (no tampering with class defs)
public void Test_LoadThroughMultipleRelationship_Drivers()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
Car car = TestUtilsCar.CreateSavedCar();
TestProject.BO.Driver boForRelationshipDrivers = TestUtilsDriver.CreateUnsavedValidDriver();
boForRelationshipDrivers.CarID = car.VehicleID;
boForRelationshipDrivers.Save();
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
//---------------Assert Preconditions---------------
Assert.AreEqual(1, car.Drivers.Count);
//---------------Execute Test ----------------------
TestProject.BO.Driver loadedRelatedBO =
Broker.GetBusinessObject <TestProject.BO.Driver>(boForRelationshipDrivers.ID);
Car loadedCar = Broker.GetBusinessObject <Car>(car.ID);
//---------------Test Result -----------------------
Assert.AreEqual(1, loadedCar.Drivers.Count);
Assert.AreEqual(boForRelationshipDrivers, loadedCar.Drivers[0]);
Assert.AreEqual(loadedRelatedBO, loadedCar.Drivers[0]);
Assert.AreEqual(loadedRelatedBO, car.Drivers[0]);
}
[Test] // Checks that deleting this instance has no effect in the related class
public void Test_SingleRelationshipDeletion_DoNothing_Car()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Driver driver = TestUtilsDriver.CreateSavedDriver();
TestProject.BO.Car boForRelationshipCar = TestUtilsCar.CreateSavedCar();
driver.Car = boForRelationshipCar;
driver.Save();
//---------------Assert Preconditions---------------
IRelationshipDef relationshipDef = ClassDef.Get <Driver>().RelationshipDefCol["Car"];
Assert.AreEqual(DeleteParentAction.DoNothing, relationshipDef.DeleteParentAction);
//---------------Execute Test ----------------------
driver.MarkForDelete();
driver.Save();
//---------------Execute Test ----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
try
{
Broker.GetBusinessObject <Driver>(driver.ID);
Assert.Fail("BO should no longer exist and exception should be thrown");
}
catch (BusObjDeleteConcurrencyControlException ex)
{
StringAssert.Contains("There are no records in the database for the Class: Driver", ex.Message);
}
TestProject.BO.Car relatedBO = Broker.GetBusinessObject <TestProject.BO.Car>(boForRelationshipCar.ID);
Assert.AreEqual(relatedBO.ID.ToString(), boForRelationshipCar.ID.ToString());
}
[Test] // Ensures that property setters in the code point to the correct property
public void Test_PropertySettersUseCorrectPropertyNames()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Driver driver = new Driver();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForDriverName = TestUtilsShared.GetRandomString();
driver.SetPropertyValue("DriverName", valueForDriverName);
object valueForAge = TestUtilsShared.GetRandomInt();
driver.SetPropertyValue("Age", valueForAge);
object valueForDOB = TestUtilsShared.GetRandomDate();
driver.SetPropertyValue("DOB", valueForDOB);
object valueForLicenseRaing = (double)TestUtilsShared.GetRandomInt();
driver.SetPropertyValue("LicenseRaing", valueForLicenseRaing);
object valueForCarID = TestUtilsCar.CreateSavedCar().VehicleID;
driver.SetPropertyValue("CarID", valueForCarID);
//---------------Test Result -----------------------
Assert.AreEqual(valueForDriverName, driver.DriverName);
Assert.AreEqual(valueForAge, driver.Age);
Assert.AreEqual(valueForDOB, driver.DOB);
Assert.AreEqual(valueForLicenseRaing, driver.LicenseRaing);
Assert.AreEqual(valueForCarID, driver.CarID);
}
[Test] // Ensures that updates to property values are stored and can be retrieved
public void Test_UpdateCar()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Car car = TestUtilsCar.CreateSavedCar();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForMake = TestUtilsShared.GetRandomString();
car.Make = (System.String)valueForMake;
object valueForModel = TestUtilsShared.GetRandomString();
car.Model = (System.String)valueForModel;
object valueForVehicleType = TestUtilsShared.GetRandomString();
car.VehicleType = (System.String)valueForVehicleType;
object valueForMaxSpeed = (double)TestUtilsShared.GetRandomInt();
car.MaxSpeed = (System.Double)valueForMaxSpeed;
car.Save();
//---------------Test Result -----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
Car retrievedCar = Broker.GetBusinessObject <Car>(car.ID);
Assert.AreEqual(valueForMake, retrievedCar.Make);
Assert.AreEqual(valueForModel, retrievedCar.Model);
Assert.AreEqual(valueForVehicleType, retrievedCar.VehicleType);
Assert.AreEqual(valueForMaxSpeed, retrievedCar.MaxSpeed);
}
[Test] // Ensures that gets and sets in the code refer to the same property
public void Test_PropertyGetters()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Car car = new Car();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForMake = TestUtilsShared.GetRandomString();
car.Make = (System.String)valueForMake;
object valueForModel = TestUtilsShared.GetRandomString();
car.Model = (System.String)valueForModel;
object valueForVehicleType = TestUtilsShared.GetRandomString();
car.VehicleType = (System.String)valueForVehicleType;
object valueForMaxSpeed = (double)TestUtilsShared.GetRandomInt();
car.MaxSpeed = (System.Double)valueForMaxSpeed;
//---------------Test Result -----------------------
Assert.AreEqual(valueForMake, car.Make);
Assert.AreEqual(valueForModel, car.Model);
Assert.AreEqual(valueForVehicleType, car.VehicleType);
Assert.AreEqual(valueForMaxSpeed, car.MaxSpeed);
}
[Test] // Makes sure there are no non-null rules in the database that don't have corresponding compulsory rules
public void Test_SetPropertyValue_Null()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Driver driver = TestUtilsDriver.CreateSavedDriver();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
driver.DriverName = null;
driver.Age = null;
driver.DOB = null;
driver.LicenseRaing = null;
driver.CarID = null;
driver.Save();
//---------------Test Result -----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
Driver retrievedDriver =
Broker.GetBusinessObject <Driver>(driver.ID);
Assert.IsNull(retrievedDriver.DriverName);
Assert.IsNull(retrievedDriver.Age);
Assert.IsNull(retrievedDriver.DOB);
Assert.IsNull(retrievedDriver.LicenseRaing);
Assert.IsNull(retrievedDriver.CarID);
}
public static DateTime GetRandomDate(string min, string max)
{
DateTime start = DateTime.Parse(min);
int range = (DateTime.Parse(max) - start).Days;
return(start.AddDays(TestUtilsShared.GetRandomInt(range)));
}
/// <summary>
/// Creates a new unsaved Car with a random value assigned to every property
/// </summary>
public static Car CreateUnsavedValidCar()
{
Car car = new Car();
car.Make = TestUtilsShared.GetRandomString();
car.Model = TestUtilsShared.GetRandomString();
car.MaxSpeed = (double)TestUtilsShared.GetRandomInt();
return(car);
}
/// <summary>
/// Creates a new unsaved Driver with a random value assigned to every property
/// </summary>
public static Driver CreateUnsavedValidDriver()
{
Driver driver = new Driver();
driver.DriverName = TestUtilsShared.GetRandomString();
driver.Age = TestUtilsShared.GetRandomInt();
driver.DOB = TestUtilsShared.GetRandomDate();
driver.LicenseRaing = (double)TestUtilsShared.GetRandomInt();
driver.Car = TestUtilsCar.CreateSavedCar();
return(driver);
}
[Test] // Ensures that property setters in the code point to the correct property
public void Test_PropertySettersUseCorrectPropertyNames()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Vehicle vehicle = new Vehicle();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForVehicleType = TestUtilsShared.GetRandomString();
vehicle.SetPropertyValue("VehicleType", valueForVehicleType);
object valueForMaxSpeed = (double)TestUtilsShared.GetRandomInt();
vehicle.SetPropertyValue("MaxSpeed", valueForMaxSpeed);
//---------------Test Result -----------------------
Assert.AreEqual(valueForVehicleType, vehicle.VehicleType);
Assert.AreEqual(valueForMaxSpeed, vehicle.MaxSpeed);
}
[Test] // Ensures that property setters in the code point to the correct property
public void Test_PropertySettersUseCorrectPropertyNames()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Car car = new Car();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForMake = TestUtilsShared.GetRandomString();
car.SetPropertyValue("Make", valueForMake);
object valueForModel = TestUtilsShared.GetRandomString();
car.SetPropertyValue("Model", valueForModel);
//---------------Test Result -----------------------
Assert.AreEqual(valueForMake, car.Make);
Assert.AreEqual(valueForModel, car.Model);
}
[Test] // Makes sure there are no non-null rules in the database that don't have corresponding compulsory rules
public void Test_SetPropertyValue_Null()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
SteeringWheel steeringWheel = TestUtilsSteeringWheel.CreateSavedSteeringWheel();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
steeringWheel.CarID = null;
steeringWheel.Save();
//---------------Test Result -----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
SteeringWheel retrievedSteeringWheel =
Broker.GetBusinessObject <SteeringWheel>(steeringWheel.ID);
Assert.IsNull(retrievedSteeringWheel.CarID);
}
[Test] // Checks that BOs in a single relationship load correctly (no tampering with class defs)
public void Test_LoadThroughSingleRelationship_Car()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
Driver driver = TestUtilsDriver.CreateSavedDriver();
TestProject.BO.Car boForRelationshipCar = driver.Car;
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
//---------------Execute Test ----------------------
TestProject.BO.Car loadedRelatedBO = Broker.GetBusinessObject <TestProject.BO.Car>(boForRelationshipCar.ID);
Driver loadedDriver = Broker.GetBusinessObject <Driver>(driver.ID);
//---------------Test Result -----------------------
Assert.AreEqual(boForRelationshipCar, loadedDriver.Car);
Assert.AreEqual(loadedRelatedBO, loadedDriver.Car);
Assert.AreEqual(loadedRelatedBO, driver.Car);
}
[Test] // Ensures that updates to property values are stored and can be retrieved
public void Test_UpdateSteeringWheel()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
SteeringWheel steeringWheel = TestUtilsSteeringWheel.CreateSavedSteeringWheel();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForCarID = Guid.NewGuid();
steeringWheel.CarID = (System.Guid)valueForCarID;
steeringWheel.Save();
//---------------Test Result -----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
SteeringWheel retrievedSteeringWheel =
Broker.GetBusinessObject <SteeringWheel>(steeringWheel.ID);
Assert.AreEqual(valueForCarID, retrievedSteeringWheel.CarID);
}
[Test] // Ensures that updates to property values are stored and can be retrieved
public void Test_UpdateDriver()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Driver driver = TestUtilsDriver.CreateSavedDriver();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
object valueForDriverName = TestUtilsShared.GetRandomString();
driver.DriverName = (System.String)valueForDriverName;
object valueForAge = TestUtilsShared.GetRandomInt();
driver.Age = (System.Int32)valueForAge;
object valueForDOB = TestUtilsShared.GetRandomDate();
driver.DOB = (System.DateTime)valueForDOB;
object valueForLicenseRaing = (double)TestUtilsShared.GetRandomInt();
driver.LicenseRaing = (System.Double)valueForLicenseRaing;
object valueForCarID = Guid.NewGuid();
driver.CarID = (System.Guid)valueForCarID;
driver.Save();
//---------------Test Result -----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
Driver retrievedDriver =
Broker.GetBusinessObject <Driver>(driver.ID);
Assert.AreEqual(valueForDriverName, retrievedDriver.DriverName);
Assert.AreEqual(valueForAge, retrievedDriver.Age);
Assert.AreEqual(valueForDOB, retrievedDriver.DOB);
Assert.AreEqual(valueForLicenseRaing, retrievedDriver.LicenseRaing);
Assert.AreEqual(valueForCarID, retrievedDriver.CarID);
}
[Test] // Makes sure there are no non-null rules in the database that don't have corresponding compulsory rules
public void Test_SetPropertyValue_Null()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Car car = TestUtilsCar.CreateSavedCar();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
car.Make = null;
car.Model = null;
car.Save();
//---------------Test Result -----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
Car retrievedCar =
Broker.GetBusinessObject <Car>(car.ID);
Assert.IsNull(retrievedCar.Make);
Assert.IsNull(retrievedCar.Model);
}
[Test] // Makes sure there are no non-null rules in the database that don't have corresponding compulsory rules
public void Test_SetPropertyValue_Null()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
Vehicle vehicle = TestUtilsVehicle.CreateSavedVehicle();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
vehicle.VehicleType = null;
vehicle.MaxSpeed = null;
vehicle.Save();
//---------------Test Result -----------------------
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
Vehicle retrievedVehicle =
Broker.GetBusinessObject <Vehicle>(vehicle.ID);
Assert.IsNull(retrievedVehicle.VehicleType);
Assert.IsNull(retrievedVehicle.MaxSpeed);
}
[Test] // Checks that BOs in a single relationship load correctly (no tampering with class defs)
public void Test_LoadThroughSingleRelationship_SteeringWheel()
{
CheckIfTestShouldBeIgnored();
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
SteeringWheel wheel = TestUtilsSteeringWheel.CreateSavedSteeringWheel();
Car car = wheel.Car;
TestProject.BO.SteeringWheel boForRelationshipSteeringWheel = car.SteeringWheel;
BusinessObjectManager.Instance.ClearLoadedObjects();
GC.Collect();
TestUtilsShared.WaitForGC();
//---------------Execute Test ----------------------
TestProject.BO.SteeringWheel loadedRelatedBO =
Broker.GetBusinessObject <TestProject.BO.SteeringWheel>(boForRelationshipSteeringWheel.ID);
Car loadedCar = Broker.GetBusinessObject <Car>(car.ID);
//---------------Test Result -----------------------
Assert.AreEqual(boForRelationshipSteeringWheel, loadedCar.SteeringWheel);
Assert.AreEqual(loadedRelatedBO, loadedCar.SteeringWheel);
Assert.AreEqual(loadedRelatedBO, car.SteeringWheel);
}
/// <summary>
/// Takes a lookup list generated by Habanero and randomly selects a value
/// from the list
/// </summary>
public static object GetRandomLookupListValue(Dictionary <string, string> lookupList)
{
string[] values = new string[lookupList.Count];
lookupList.Values.CopyTo(values, 0);
return(values[TestUtilsShared.GetRandomInt(0, values.Length - 1)]);
}
