public VPResultModel GetVPResultModelWithVPScenarioIDAndOrdinalDB(int VPScenarioID, int Ordinal)
{
VPResultModel vpResultModel = (from c in db.VPResults
where c.VPScenarioID == VPScenarioID &&
c.Ordinal == Ordinal
select new VPResultModel
{
Error = "",
VPResultID = c.VPResultID,
DBCommand = (DBCommandEnum)c.DBCommand,
VPScenarioID = c.VPScenarioID,
Ordinal = c.Ordinal,
Concentration_MPN_100ml = c.Concentration_MPN_100ml,
Dilution = c.Dilution,
FarFieldWidth_m = c.FarFieldWidth_m,
DispersionDistance_m = c.DispersionDistance_m,
TravelTime_hour = c.TravelTime_hour,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).FirstOrDefault <VPResultModel>();
if (vpResultModel == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.VPResult, ServiceRes.VPScenarioID + "," + ServiceRes.Ordinal, VPScenarioID.ToString() + "," + Ordinal)));
}
return(vpResultModel);
}
public void VPResultService_PostUpdateVPResultDB_GetVPResultWithVPScenarioIDAndOrdinalDB_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
using (ShimsContext.Create())
{
//string ErrorText = "ErrorText";
SetupShim();
shimVPResultService.GetVPResultWithVPScenarioIDAndOrdinalDBInt32Int32 = (a, b) =>
{
return(null);
};
VPResultModel vpResultModelret2 = UpdateVPResultModel(vpResultModelRet);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.VPResult), vpResultModelret2.Error);
}
}
}
}
public void VPResultService_PostDeleteVPResultDB_IsContactOK_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
using (ShimsContext.Create())
{
string ErrorText = "ErrorText";
SetupShim();
shimVPResultService.IsContactOK = () =>
{
return(new ContactOK()
{
Error = ErrorText
});
};
VPResultModel vpResultModelRet2 = vpResultService.PostDeleteVPResultDB(vpResult.VPScenarioID, vpResult.Ordinal);
Assert.AreEqual(ErrorText, vpResultModelRet2.Error);
}
}
}
}
public void VPResultService_FillVPResult_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
FillVPResultModel(vpResultModelRet);
ContactOK contactOK = vpResultService.IsContactOK();
string retStr = vpResultService.FillVPResult(vpResult, vpResultModelRet, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(contactOK.ContactTVItemID, vpResult.LastUpdateContactTVItemID);
contactOK = null;
retStr = vpResultService.FillVPResult(vpResult, vpResultModelRet, contactOK);
Assert.AreEqual("", retStr);
Assert.AreEqual(2, vpResult.LastUpdateContactTVItemID);
}
}
}
public void VPResultService_PostUpdateVPResultDB_DoUpdateChanges_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
using (ShimsContext.Create())
{
string ErrorText = "ErrorText";
SetupShim();
shimVPResultService.DoUpdateChanges = () =>
{
return(ErrorText);
};
VPResultModel vpResultModelret2 = UpdateVPResultModel(vpResultModelRet);
Assert.AreEqual(ErrorText, vpResultModelret2.Error);
}
}
}
}
public void VPResultService_PostAddUpdateDeleteVPResultDB_BadUser_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListBad[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
Assert.AreEqual(ServiceRes.NeedToBeLoggedIn, vpResultModelRet.Error);
}
}
}
// Check
public string VPResultModelOK(VPResultModel vpResultModel)
{
string retStr = FieldCheckNotZeroInt(vpResultModel.VPScenarioID, ServiceRes.VPScenarioID);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotZeroInt(vpResultModel.Ordinal, ServiceRes.Ordinal);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeInt(vpResultModel.Concentration_MPN_100ml, ServiceRes.Concentration_MPN_100ml, 0, 10000000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(vpResultModel.Dilution, ServiceRes.Dilution, 1, 1000000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(vpResultModel.FarFieldWidth_m, ServiceRes.FarFieldWidth_m, 0, 10000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(vpResultModel.DispersionDistance_m, ServiceRes.DispersionDistance_m, 0, 50000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullAndWithinRangeDouble(vpResultModel.TravelTime_hour, ServiceRes.TravelTime_hour, 0, 200);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.DBCommandOK(vpResultModel.DBCommand);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
return("");
}
// Post
public VPResultModel PostAddVPResultDB(VPResultModel vpResultModel)
{
string retStr = VPResultModelOK(vpResultModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
VPResult vpResultExist = GetVPResultWithVPScenarioIDAndOrdinalDB(vpResultModel.VPScenarioID, vpResultModel.Ordinal);
if (vpResultExist != null)
{
return(ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.VPResult)));
}
VPResult vpResultNew = new VPResult();
retStr = FillVPResult(vpResultNew, vpResultModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.VPResults.Add(vpResultNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("VPResults", vpResultNew.VPResultID, LogCommandEnum.Add, vpResultNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetVPResultModelWithVPScenarioIDAndOrdinalDB(vpResultNew.VPScenarioID, vpResultNew.Ordinal));
}
public void VPResultService_ReturnError_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
string ErrorText = "ErrorText";
VPResultModel vpResultModelRet = vpResultService.ReturnError(ErrorText);
Assert.AreEqual(ErrorText, vpResultModelRet.Error);
}
}
}
public void VPResultService_GetVPResultModelListWithVPScenarioIDDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
List <VPResultModel> vpResultModelList = vpResultService.GetVPResultModelListWithVPScenarioIDDB(vpResultModelRet.VPScenarioID);
Assert.AreEqual(testDBService.Count + 1, vpResultModelList.Count);
}
}
}
public void VPResultService_GetVPResultWithVPScenarioIDAndOrdinalDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
VPResult vpResultRet = vpResultService.GetVPResultWithVPScenarioIDAndOrdinalDB(vpResultModelRet.VPScenarioID, vpResultModelRet.Ordinal);
Assert.AreEqual(vpResultModelRet.VPScenarioID, vpResultRet.VPScenarioID);
}
}
}
public VPResultModel PostUpdateVPResultDB(VPResultModel vpResultModel)
{
string retStr = VPResultModelOK(vpResultModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
VPResult vpResultToUpdate = GetVPResultWithVPScenarioIDAndOrdinalDB(vpResultModel.VPScenarioID, vpResultModel.Ordinal);
if (vpResultToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.VPResult)));
}
retStr = FillVPResult(vpResultToUpdate, vpResultModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
retStr = DoUpdateChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("VPResults", vpResultToUpdate.VPResultID, LogCommandEnum.Change, vpResultToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetVPResultModelWithVPScenarioIDAndOrdinalDB(vpResultToUpdate.VPScenarioID, vpResultToUpdate.Ordinal));
}
public void VPResultService_PostAddUpdateDeleteVPResultDB_Good_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
VPResultModel vpResultModelRet2 = UpdateVPResultModel(vpResultModelRet);
VPResultModel vpResultModelRet3 = vpResultService.PostDeleteVPResultDB(vpResultModelRet2.VPScenarioID, vpResultModelRet2.Ordinal);
Assert.AreEqual("", vpResultModelRet3.Error);
}
}
}
public void VPResultService_GetVPResultModelWithVPScenarioIDAndOrdinalDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
VPResultModel vpResultModelRet2 = vpResultService.GetVPResultModelWithVPScenarioIDAndOrdinalDB(vpResultModelRet.VPScenarioID, vpResultModelRet.Ordinal);
Assert.AreEqual(vpResultModelRet.VPScenarioID, vpResultModelRet2.VPScenarioID);
int VPScenarioID = 0;
vpResultModelRet2 = vpResultService.GetVPResultModelWithVPScenarioIDAndOrdinalDB(VPScenarioID, vpResultModelRet.Ordinal);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.VPResult, ServiceRes.VPScenarioID + "," + ServiceRes.Ordinal, VPScenarioID.ToString() + "," + vpResultModelRet.Ordinal), vpResultModelRet2.Error);
}
}
}
// Fill
public string FillVPResult(VPResult vpResult, VPResultModel vpResultModel, ContactOK contactOK)
{
vpResult.DBCommand = (int)vpResultModel.DBCommand;
vpResult.VPScenarioID = vpResultModel.VPScenarioID;
vpResult.Ordinal = vpResultModel.Ordinal;
vpResult.Concentration_MPN_100ml = vpResultModel.Concentration_MPN_100ml;
vpResult.Dilution = vpResultModel.Dilution;
vpResult.FarFieldWidth_m = vpResultModel.FarFieldWidth_m;
vpResult.DispersionDistance_m = vpResultModel.DispersionDistance_m;
vpResult.TravelTime_hour = vpResultModel.TravelTime_hour;
vpResult.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
vpResult.LastUpdateContactTVItemID = 2;
}
else
{
vpResult.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public void VPResultService_PostAddVPResultDB_Add_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
//string ErrorText = "ErrorText";
SetupShim();
shimVPResultService.FillVPResultVPResultVPResultModelContactOK = (a, b, c) =>
{
return("");
};
VPResultModel vpResultModelRet = AddVPResultModel();
Assert.IsTrue(vpResultModelRet.Error.StartsWith(string.Format(ServiceRes.CouldNotAddError_, "").Substring(0, 10)));
}
}
}
}
public void VPResultService_PostAddVPResultDB_FillVPResultModel_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
string ErrorText = "ErrorText";
SetupShim();
shimVPResultService.FillVPResultVPResultVPResultModelContactOK = (a, b, c) =>
{
return(ErrorText);
};
VPResultModel vpResultModelRet = AddVPResultModel();
Assert.AreEqual(ErrorText, vpResultModelRet.Error);
}
}
}
}
public void VPResultService_VPResultModelOK_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
VPResultModel vpResultModelRet = AddVPResultModel();
vpResultModelNew.VPScenarioID = vpResultModelRet.VPScenarioID;
#region Good
FillVPResultModel(vpResultModelNew);
string retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.IsNotNull("", retStr);
#endregion Good
#region VPScenarioID
FillVPResultModel(vpResultModelNew);
vpResultModelNew.VPScenarioID = 0;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.IsNotNull(string.Format(ServiceRes._IsRequired, ServiceRes.VPScenarioID), retStr);
vpResultModelNew.VPScenarioID = vpResultModelRet.VPScenarioID;
FillVPResultModel(vpResultModelNew);
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.IsNotNull("", retStr);
#endregion VPScenarioID
#region Ordinal
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Ordinal = 0;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.Ordinal), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Ordinal = 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
#endregion Ordinal
#region Concentration_MPN_100ml
FillVPResultModel(vpResultModelNew);
int MinInt = 0;
int MaxInt = 10000000;
vpResultModelNew.Concentration_MPN_100ml = MinInt - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.Concentration_MPN_100ml, MinInt, MaxInt), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Concentration_MPN_100ml = MaxInt + 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.Concentration_MPN_100ml, MinInt, MaxInt), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Concentration_MPN_100ml = MaxInt - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Concentration_MPN_100ml = MinInt;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Concentration_MPN_100ml = MaxInt;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
#endregion Concentration_MPN_100ml
#region Dilution
FillVPResultModel(vpResultModelNew);
double Min = 1D;
double Max = 1000000D;
vpResultModelNew.Dilution = Min - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.Dilution, Min, Max), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Dilution = Max + 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.Dilution, Min, Max), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Dilution = Max - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Dilution = Min;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.Dilution = Max;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
#endregion Dilution
#region FarFieldWidth_m
FillVPResultModel(vpResultModelNew);
Min = 0D;
Max = 10000D;
vpResultModelNew.FarFieldWidth_m = Min - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.FarFieldWidth_m, Min, Max), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.FarFieldWidth_m = Max + 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.FarFieldWidth_m, Min, Max), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.FarFieldWidth_m = Max - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.FarFieldWidth_m = Min;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.FarFieldWidth_m = Max;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
#endregion FarFieldWidth_m
#region DispersionDistance_m
FillVPResultModel(vpResultModelNew);
Min = 0D;
Max = 50000D;
vpResultModelNew.DispersionDistance_m = Min - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.DispersionDistance_m, Min, Max), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.DispersionDistance_m = Max + 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.DispersionDistance_m, Min, Max), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.DispersionDistance_m = Max - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.DispersionDistance_m = Min;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.DispersionDistance_m = Max;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
#endregion DispersionDistance_m
#region TravelTime_hour
FillVPResultModel(vpResultModelNew);
Min = 0D;
Max = 200D;
vpResultModelNew.TravelTime_hour = Min - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.TravelTime_hour, Min, Max), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.TravelTime_hour = Max + 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual(string.Format(ServiceRes._RangeIsBetween_And_, ServiceRes.TravelTime_hour, Min, Max), retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.TravelTime_hour = Max - 1;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.TravelTime_hour = Min;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
FillVPResultModel(vpResultModelNew);
vpResultModelNew.TravelTime_hour = Max;
retStr = vpResultService.VPResultModelOK(vpResultModelNew);
Assert.AreEqual("", retStr);
#endregion TravelTime_hour
}
}
}
