public void SpillLanguageService_PostUpdateSpillLanguageDB_GetSpillLanguageWithSpillIDAndLanguageDB_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
LanguageEnum LangToAdd = LanguageEnum.es;
SpillLanguageModel spillLanguageModelRet = AddSpillLanguageModel(LangToAdd, spillModelRet);
using (ShimsContext.Create())
{
SetupShim();
FillSpillLanguageModelUpdate(spillLanguageModelRet);
//string ErrorText = "ErrorText";
shimSpillLanguageService.GetSpillLanguageWithSpillIDAndLanguageDBInt32LanguageEnum = (a, b) =>
{
return(null);
};
SpillLanguageModel spillLanguageModelRet2 = spillLanguageService.PostUpdateSpillLanguageDB(spillLanguageModelRet);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.SpillLanguage), spillLanguageModelRet2.Error);
}
}
}
}
public void SpillLanguageService_PostUpdateSpillLanguageDB_DoUpdateChanges_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
LanguageEnum LangToAdd = LanguageEnum.es;
SpillLanguageModel spillLanguageModelRet = AddSpillLanguageModel(LangToAdd, spillModelRet);
using (ShimsContext.Create())
{
SetupShim();
FillSpillLanguageModelUpdate(spillLanguageModelRet);
string ErrorText = "ErrorText";
shimSpillLanguageService.DoUpdateChanges = () =>
{
return(ErrorText);
};
SpillLanguageModel spillLanguageModelRet2 = spillLanguageService.PostUpdateSpillLanguageDB(spillLanguageModelRet);
Assert.AreEqual(ErrorText, spillLanguageModelRet2.Error);
}
}
}
}
public void SpillLanguageService_PostAddSpillLanguageDB_Add_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
using (ShimsContext.Create())
{
SetupShim();
LanguageEnum LangToAdd = LanguageEnum.es;
FillSpillLanguageModelNew(LangToAdd, spillModelRet, spillLanguageModelNew);
//string ErrorText = "ErrorText";
shimSpillLanguageService.FillSpillLanguageSpillLanguageSpillLanguageModelContactOK = (a, b, c) =>
{
return("");
};
SpillLanguageModel spillLanguageModelRet = spillLanguageService.PostAddSpillLanguageDB(spillLanguageModelNew);
Assert.IsTrue(spillLanguageModelRet.Error.StartsWith(string.Format(ServiceRes.CouldNotAddError_, "").Substring(0, 10)));
}
}
}
}
public void SpillLanguageService_PostDeleteSpillLanguageDB_IsContactOK_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
LanguageEnum LangToAdd = LanguageEnum.es;
SpillLanguageModel spillLanguageModelRet = AddSpillLanguageModel(LangToAdd, spillModelRet);
SpillLanguageModel spillLanguageModelRet2 = UpdateSpillLanguageModel(spillLanguageModelRet);
using (ShimsContext.Create())
{
SetupShim();
string ErrorText = "ErrorText";
shimSpillLanguageService.IsContactOK = () =>
{
return(new ContactOK()
{
Error = ErrorText
});
};
SpillLanguageModel spillLanguageModelRet3 = spillLanguageService.PostDeleteSpillLanguageDB(spillLanguageModelRet2.SpillID, LangToAdd);
Assert.AreEqual(ErrorText, spillLanguageModelRet3.Error);
}
}
}
}
// Check
public string SpillLanguageModelOK(SpillLanguageModel spillLanguageModel)
{
string retStr = FieldCheckNotZeroInt(spillLanguageModel.SpillID, ServiceRes.SpillID);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.LanguageOK(spillLanguageModel.Language);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckIfNotNullMaxLengthString(spillLanguageModel.SpillComment, ServiceRes.SpillComment, 10000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.DBCommandOK(spillLanguageModel.DBCommand);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
return("");
}
public void SpillLanguageService_PostAddSpillLanguageDB_SpillModelOK_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
LanguageEnum LangToAdd = LanguageEnum.es;
FillSpillLanguageModelNew(LangToAdd, spillModelRet, spillLanguageModelNew);
string ErrorText = "ErrorText";
ShimSpillLanguageService shimSpillLanguageService = new ShimSpillLanguageService(spillLanguageService);
shimSpillLanguageService.SpillLanguageModelOKSpillLanguageModel = (a) =>
{
return(ErrorText);
};
SpillLanguageModel spillLanguageModelRet = spillLanguageService.PostAddSpillLanguageDB(spillLanguageModelNew);
Assert.AreEqual(ErrorText, spillLanguageModelRet.Error);
}
}
}
}
private void FillSpillLanguageModelUpdate(SpillLanguageModel spillLanguageModel)
{
spillLanguageModel.SpillComment = randomService.RandomString("SpillName", 30);
spillLanguageModel.TranslationStatus = TranslationStatusEnum.Translated;
Assert.IsTrue(spillLanguageModel.SpillComment.Length == 30);
Assert.IsTrue(spillLanguageModel.TranslationStatus == TranslationStatusEnum.Translated);
}
// Post
public SpillLanguageModel PostAddSpillLanguageDB(SpillLanguageModel spillLanguageModel)
{
string retStr = SpillLanguageModelOK(spillLanguageModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
SpillLanguageModel spillLanguageModelExist = GetSpillLanguageModelWithSpillIDAndLanguageDB(spillLanguageModel.SpillID, spillLanguageModel.Language);
if (string.IsNullOrWhiteSpace(spillLanguageModelExist.Error))
{
return(ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.SpillLanguage)));
}
SpillLanguage spillLanguageNew = new SpillLanguage();
retStr = FillSpillLanguage(spillLanguageNew, spillLanguageModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.SpillLanguages.Add(spillLanguageNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("SpillLanguages", spillLanguageNew.SpillLanguageID, LogCommandEnum.Add, spillLanguageNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetSpillLanguageModelWithSpillIDAndLanguageDB(spillLanguageNew.SpillID, spillLanguageModel.Language));
}
public void SpillLanguageService_ReturnError_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
string ErrorText = "ErrorText";
SpillLanguageModel spillLanguageModelRet = spillLanguageService.ReturnError(ErrorText);
Assert.AreEqual(ErrorText, spillLanguageModelRet.Error);
}
}
}
private SpillLanguageModel UpdateSpillLanguageModel(SpillLanguageModel spillLanguageModelRet)
{
FillSpillLanguageModelUpdate(spillLanguageModelRet);
SpillLanguageModel spillLanguageModelRet2 = spillLanguageService.PostUpdateSpillLanguageDB(spillLanguageModelRet);
if (!string.IsNullOrWhiteSpace(spillLanguageModelRet2.Error))
{
return(spillLanguageModelRet2);
}
Assert.IsNotNull(spillLanguageModelRet2);
CompareSpillLanguageModels(spillLanguageModelRet, spillLanguageModelRet2);
return(spillLanguageModelRet2);
}
public void SetupTest(ContactModel contactModelToDo, CultureInfo culture)
{
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
contactModel = contactModelToDo;
user = new GenericPrincipal(new GenericIdentity(contactModel.LoginEmail, "Forms"), null);
spillService = new SpillService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), user);
spillLanguageService = new SpillLanguageService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), user);
testDBService = new TestDBService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), user, TableName, Plurial);
randomService = new RandomService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), user);
spillLanguageModelNew = new SpillLanguageModel();
spillLanguage = new SpillLanguage();
spillServiceTest = new SpillServiceTest();
spillServiceTest.SetupTest(contactModelToDo, culture);
}
public SpillLanguageModel PostUpdateSpillLanguageDB(SpillLanguageModel spillLanguageModel)
{
string retStr = SpillLanguageModelOK(spillLanguageModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
SpillLanguage spillLanguageToUpdate = GetSpillLanguageWithSpillIDAndLanguageDB(spillLanguageModel.SpillID, spillLanguageModel.Language);
if (spillLanguageToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.SpillLanguage)));
}
retStr = FillSpillLanguage(spillLanguageToUpdate, spillLanguageModel, 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("SpillLanguages", spillLanguageToUpdate.SpillLanguageID, LogCommandEnum.Change, spillLanguageToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetSpillLanguageModelWithSpillIDAndLanguageDB(spillLanguageToUpdate.SpillID, spillLanguageModel.Language));
}
private SpillLanguageModel AddSpillLanguageModel(LanguageEnum LangToAdd, SpillModel spillModel)
{
SpillLanguageModel spillLanguageModelNew = new SpillLanguageModel();
FillSpillLanguageModelNew(LangToAdd, spillModel, spillLanguageModelNew);
SpillLanguageModel spillLanguagModelRet = spillLanguageService.PostAddSpillLanguageDB(spillLanguageModelNew);
if (!string.IsNullOrWhiteSpace(spillLanguagModelRet.Error))
{
return(spillLanguagModelRet);
}
Assert.IsNotNull(spillLanguagModelRet);
CompareSpillLanguageModels(spillLanguageModelNew, spillLanguagModelRet);
return(spillLanguagModelRet);
}
public void SpillLanguageService_GetSpillModelCountDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
LanguageEnum LangToAdd = LanguageEnum.es;
SpillLanguageModel spillModelLanguageRet = AddSpillLanguageModel(LangToAdd, spillModelRet);
int spillCount = spillLanguageService.GetSpillLanguageModelCountDB();
Assert.AreEqual(testDBService.Count + 3, spillCount);
}
}
}
// Fill
public string FillSpillLanguage(SpillLanguage spillLanguageNew, SpillLanguageModel spillLanguageModel, ContactOK contactOK)
{
spillLanguageNew.DBCommand = (int)spillLanguageModel.DBCommand;
spillLanguageNew.SpillID = spillLanguageModel.SpillID;
spillLanguageNew.Language = (int)spillLanguageModel.Language;
spillLanguageNew.TranslationStatus = (int)spillLanguageModel.TranslationStatus;
spillLanguageNew.SpillComment = spillLanguageModel.SpillComment;
spillLanguageNew.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
spillLanguageNew.LastUpdateContactTVItemID = 2;
}
else
{
spillLanguageNew.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
private void CompareSpillModels(SpillModel spillModelNew, SpillModel spillModelRet)
{
Assert.AreEqual(spillModelNew.MunicipalityTVItemID, spillModelRet.MunicipalityTVItemID);
Assert.AreEqual(spillModelNew.InfrastructureTVItemID, spillModelRet.InfrastructureTVItemID);
Assert.AreEqual(spillModelNew.StartDateTime_Local, spillModelRet.StartDateTime_Local);
Assert.AreEqual(spillModelNew.EndDateTime_Local, spillModelRet.EndDateTime_Local);
Assert.AreEqual(spillModelNew.AverageFlow_m3_day, spillModelRet.AverageFlow_m3_day);
foreach (LanguageEnum Lang in spillService.LanguageListAllowable)
{
SpillLanguageModel spillLanguageModel = spillService._SpillLanguageService.GetSpillLanguageModelWithSpillIDAndLanguageDB(spillModelRet.SpillID, Lang);
Assert.AreEqual("", spillLanguageModel.Error);
if (Lang == spillService.LanguageRequest)
{
Assert.AreEqual(spillModelRet.SpillComment, spillLanguageModel.SpillComment);
}
}
}
public void SpillLanguageService_GetSpillLanguageWithSpillIDAndLanguageDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
LanguageEnum LangToAdd = LanguageEnum.es;
SpillLanguageModel spillLanguageModelRet = AddSpillLanguageModel(LangToAdd, spillModelRet);
SpillLanguage spillLanguageRet2 = spillLanguageService.GetSpillLanguageWithSpillIDAndLanguageDB(spillLanguageModelRet.SpillID, LangToAdd);
Assert.AreEqual(spillLanguageModelRet.SpillID, spillLanguageRet2.SpillID);
Assert.AreEqual(spillLanguageModelRet.Language, (LanguageEnum)spillLanguageRet2.Language);
Assert.AreEqual(LangToAdd, (LanguageEnum)spillLanguageRet2.Language);
}
}
}
public void SpillLanguageService_PostAddSpillLanguageDB_Good_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
LanguageEnum LangToAdd = LanguageEnum.es;
SpillLanguageModel spillLanguageModelRet = AddSpillLanguageModel(LangToAdd, spillModelRet);
SpillLanguageModel spillLanguageModelRet2 = UpdateSpillLanguageModel(spillLanguageModelRet);
SpillLanguageModel spillLanguageModelRet3 = spillLanguageService.PostDeleteSpillLanguageDB(spillLanguageModelRet2.SpillID, LangToAdd);
Assert.AreEqual("", spillLanguageModelRet3.Error);
}
}
}
public void SpillLanguageService_PostAddSpillLanguageDB_UserEmailNotValidated_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
SpillModel spillModelRet = spillServiceTest.AddSpillModel();
LanguageEnum LangToAdd = LanguageEnum.es;
ContactModel contactModelBad = contactModelListGood[2];
IPrincipal userBad = new GenericPrincipal(new GenericIdentity(contactModelBad.LoginEmail, "Forms"), null);
spillLanguageService = new SpillLanguageService((culture.TwoLetterISOLanguageName == "fr" ? LanguageEnum.fr : LanguageEnum.en), userBad);
SpillLanguageModel spillLanguageModelRet = AddSpillLanguageModel(LangToAdd, spillModelRet);
// Assert 1
Assert.AreEqual(ServiceRes.EmailRequiresValidation, spillLanguageModelRet.Error);
}
}
}
public SpillLanguageModel GetSpillLanguageModelWithSpillIDAndLanguageDB(int SpillID, LanguageEnum Language)
{
SpillLanguageModel spillLanguageModel = (from c in db.SpillLanguages
where c.SpillID == SpillID &&
c.Language == (int)Language
select new SpillLanguageModel
{
Error = "",
SpillID = c.SpillID,
DBCommand = (DBCommandEnum)c.DBCommand,
Language = (LanguageEnum)c.Language,
TranslationStatus = (TranslationStatusEnum)c.TranslationStatus,
SpillComment = c.SpillComment,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).FirstOrDefault <SpillLanguageModel>();
if (spillLanguageModel == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.SpillLanguage, ServiceRes.SpillID + "," + ServiceRes.Language, SpillID.ToString() + "," + Language)));
}
return(spillLanguageModel);
}
public SpillModel PostUpdateSpillDB(SpillModel spillModel)
{
string retStr = SpillModelOK(spillModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
TVItemModel tvItemModelMunicipality = _TVItemService.GetTVItemModelWithTVItemIDDB(spillModel.MunicipalityTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelMunicipality.Error))
{
return(ReturnError(tvItemModelMunicipality.Error));
}
if (spillModel.InfrastructureTVItemID != null)
{
TVItemModel tvItemModelInfrastructure = _TVItemService.GetTVItemModelWithTVItemIDDB((int)spillModel.InfrastructureTVItemID);
if (!string.IsNullOrWhiteSpace(tvItemModelInfrastructure.Error))
{
return(ReturnError(tvItemModelInfrastructure.Error));
}
}
Spill spillToUpdate = GetSpillWithSpillIDDB(spillModel.SpillID);
if (spillToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.Spill)));
}
retStr = FillSpill(spillToUpdate, spillModel, 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("Spills", spillToUpdate.SpillID, LogCommandEnum.Change, spillToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
foreach (LanguageEnum Lang in LanguageListAllowable)
{
if (Lang == LanguageRequest)
{
SpillLanguageModel spillLanguageModel = new SpillLanguageModel()
{
SpillID = spillModel.SpillID,
Language = Lang,
SpillComment = spillModel.SpillComment,
TranslationStatus = (Lang == LanguageRequest ? TranslationStatusEnum.Translated : TranslationStatusEnum.NotTranslated),
};
SpillLanguageModel spillLanguageModelRet = _SpillLanguageService.PostUpdateSpillLanguageDB(spillLanguageModel);
if (!string.IsNullOrEmpty(spillLanguageModelRet.Error))
{
return(ReturnError(spillLanguageModelRet.Error));
}
}
}
ts.Complete();
}
return(GetSpillModelWithSpillIDDB(spillToUpdate.SpillID));
}
private void CompareSpillLanguageModels(SpillLanguageModel spillLanguageModelNew, SpillLanguageModel spillLanguageModelRet)
{
Assert.AreEqual(spillLanguageModelNew.Language, spillLanguageModelRet.Language);
Assert.AreEqual(spillLanguageModelNew.SpillComment, spillLanguageModelRet.SpillComment);
}
private void FillSpillLanguageModelNew(LanguageEnum Language, SpillModel spillModel, SpillLanguageModel spillLanguageModel)
{
spillLanguageModel.SpillID = spillModel.SpillID;
spillLanguageModel.SpillComment = randomService.RandomString("SpillName", 30);
spillLanguageModel.Language = Language;
spillLanguageModel.TranslationStatus = TranslationStatusEnum.Translated;
Assert.IsTrue(spillLanguageModel.SpillID != 0);
Assert.IsTrue(spillLanguageModel.SpillComment.Length == 30);
Assert.IsTrue(spillLanguageModel.Language == Language);
Assert.IsTrue(spillLanguageModel.TranslationStatus == TranslationStatusEnum.Translated);
}
