public void AppTaskLanguageService_PostUpdateAppTaskLanguageDB_GetAppTaskLanguageWithAppTaskIDAndLanguageDB_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppTaskModel appTaskModel = appTaskServiceTest.AddAppTaskModel();
LanguageEnum LangToAdd = LanguageEnum.es;
appTaskLanguageModelNew.AppTaskID = appTaskModel.AppTaskID;
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
AppTaskLanguageModel appTaskLanguageModelRet = appTaskLanguageService.PostAddAppTaskLanguageDB(appTaskLanguageModelNew);
using (ShimsContext.Create())
{
SetupShim();
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelRet);
//string ErrorText = "ErrorText";
shimAppTaskLanguageService.GetAppTaskLanguageWithAppTaskIDAndLanguageDBInt32LanguageEnum = (a, b) =>
{
return(null);
};
AppTaskLanguageModel appTaskLanguageModelRet2 = UpdateAppTaskLanguageModel(LangToAdd, appTaskLanguageModelRet);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.AppTaskLanguage), appTaskLanguageModelRet2.Error);
}
}
}
}
public AppTaskModel PostUpdateAppTask(AppTaskModel appTaskModel)
{
string retStr = AppTaskModelOK(appTaskModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppTask appTaskToUpdate = GetAppTaskWithAppTaskIDDB(appTaskModel.AppTaskID);
if (appTaskToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.AppTask)));
}
retStr = FillAppTask(appTaskToUpdate, appTaskModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
retStr = DoUpdateChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
foreach (LanguageEnum Lang in LanguageListAllowable)
{
AppTaskLanguageModel appTaskLanguageModel = new AppTaskLanguageModel()
{
AppTaskID = appTaskModel.AppTaskID,
DBCommand = DBCommandEnum.Original,
ErrorText = appTaskModel.ErrorText,
StatusText = appTaskModel.StatusText,
Language = Lang,
TranslationStatus = (Lang == LanguageRequest ? TranslationStatusEnum.Translated : TranslationStatusEnum.NotTranslated),
};
AppTaskLanguageModel appTaskLanguageModelRet = _AppTaskLanguageService.PostUpdateAppTaskLanguageDB(appTaskLanguageModel);
if (!string.IsNullOrEmpty(appTaskLanguageModelRet.Error))
{
return(ReturnError(appTaskLanguageModelRet.Error));
}
}
ts.Complete();
}
return(GetAppTaskModelWithAppTaskIDDB(appTaskToUpdate.AppTaskID));
}
public void AppTaskLanguageService_PostUpdateAppTaskLanguageDB_DoUpdateChanges_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppTaskModel appTaskModel = appTaskServiceTest.AddAppTaskModel();
LanguageEnum LangToAdd = LanguageEnum.es;
appTaskLanguageModelNew.AppTaskID = appTaskModel.AppTaskID;
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
AppTaskLanguageModel appTaskLanguageModelRet = appTaskLanguageService.PostAddAppTaskLanguageDB(appTaskLanguageModelNew);
using (ShimsContext.Create())
{
SetupShim();
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelRet);
string ErrorText = "ErrorText";
shimAppTaskLanguageService.DoUpdateChanges = () =>
{
return(ErrorText);
};
AppTaskLanguageModel appTaskLanguageModelRet2 = UpdateAppTaskLanguageModel(LangToAdd, appTaskLanguageModelRet);
Assert.AreEqual(ErrorText, appTaskLanguageModelRet2.Error);
}
}
}
}
public AppTaskLanguageModel GetAppTaskLanguageModelWithAppTaskIDAndLanguageDB(int AppTaskID, LanguageEnum Language)
{
AppTaskLanguageModel appTaskLanguageModel = (from c in db.AppTaskLanguages
where c.AppTaskID == AppTaskID &&
c.Language == (int)Language
select new AppTaskLanguageModel
{
Error = "",
AppTaskLanguageID = c.AppTaskLanguageID,
DBCommand = (DBCommandEnum)c.DBCommand,
AppTaskID = (int)c.AppTaskID,
Language = (LanguageEnum)c.Language,
TranslationStatus = (TranslationStatusEnum)c.TranslationStatus,
StatusText = c.StatusText,
ErrorText = c.ErrorText,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).FirstOrDefault <AppTaskLanguageModel>();
if (appTaskLanguageModel == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.AppTaskLanguage, ServiceRes.AppTaskID + "," + ServiceRes.Language, AppTaskID.ToString() + "," + Language)));
}
return(appTaskLanguageModel);
}
// Check
public string AppTaskLanguageModelOK(AppTaskLanguageModel appTaskLanguageModel)
{
string retStr = FieldCheckNotZeroInt(appTaskLanguageModel.AppTaskID, ServiceRes.AppTaskID);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.LanguageOK(appTaskLanguageModel.Language);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckIfNotNullMaxLengthString(appTaskLanguageModel.ErrorText, ServiceRes.ErrorText, 250);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckIfNotNullMaxLengthString(appTaskLanguageModel.StatusText, ServiceRes.StatusText, 250);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.DBCommandOK(appTaskLanguageModel.DBCommand);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
return("");
}
private AppTaskLanguageModel AddAppTaskLanguageModel(LanguageEnum LangToAdd)
{
AppTaskModel appTaskModel = appTaskServiceTest.AddAppTaskModel();
if (!string.IsNullOrWhiteSpace(appTaskModel.Error))
{
return(new AppTaskLanguageModel()
{
Error = appTaskModel.Error
});
}
appTaskLanguageModelNew.AppTaskID = appTaskModel.AppTaskID;
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
AppTaskLanguageModel appTaskLanguagModelRet = appTaskLanguageService.PostAddAppTaskLanguageDB(appTaskLanguageModelNew);
if (!string.IsNullOrWhiteSpace(appTaskLanguagModelRet.Error))
{
return(appTaskLanguagModelRet);
}
CompareAppTaskLanguageModels(appTaskLanguageModelNew, appTaskLanguagModelRet);
return(appTaskLanguagModelRet);
}
public void AppTaskLanguageService_PostAddAppTaskLanguageDB_Add_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppTaskModel appTaskModel = appTaskServiceTest.AddAppTaskModel();
Assert.AreEqual("", appTaskModel.Error);
LanguageEnum LangToAdd = LanguageEnum.es;
using (ShimsContext.Create())
{
SetupShim();
//string ErrorText = "ErrorText";
shimAppTaskLanguageService.FillAppTaskLanguageAppTaskLanguageAppTaskLanguageModelContactOK = (a, b, c) =>
{
return("");
};
appTaskLanguageModelNew.AppTaskID = appTaskModel.AppTaskID;
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
AppTaskLanguageModel appTaskLanguageModelRet = appTaskLanguageService.PostAddAppTaskLanguageDB(appTaskLanguageModelNew);
Assert.IsTrue(appTaskLanguageModelRet.Error.StartsWith(string.Format(ServiceRes.CouldNotAddError_, "").Substring(0, 10)));
}
}
}
}
public AppTaskLanguageModel PostUpdateAppTaskLanguageDB(AppTaskLanguageModel appTaskLanguageModel)
{
string retStr = AppTaskLanguageModelOK(appTaskLanguageModel);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppTaskLanguage appTaskLanguageToUpdate = GetAppTaskLanguageWithAppTaskIDAndLanguageDB(appTaskLanguageModel.AppTaskID, appTaskLanguageModel.Language);
if (appTaskLanguageToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.AppTaskLanguage)));
}
retStr = FillAppTaskLanguage(appTaskLanguageToUpdate, appTaskLanguageModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
retStr = DoUpdateChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
try
{
LogModel logModel = _LogService.PostAddLogForObj("AppTaskLanguages", appTaskLanguageToUpdate.AppTaskLanguageID, LogCommandEnum.Change, appTaskLanguageToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
}
catch (Exception)
{
// nothing for now
}
ts.Complete();
}
return(GetAppTaskLanguageModelWithAppTaskIDAndLanguageDB((int)appTaskLanguageToUpdate.AppTaskID, (LanguageEnum)appTaskLanguageToUpdate.Language));
}
// Post
public AppTaskLanguageModel PostAddAppTaskLanguageDB(AppTaskLanguageModel appTaskLanguageModel)
{
string retStr = AppTaskLanguageModelOK(appTaskLanguageModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppTaskLanguageModel appTaskLanguageModelExist = GetAppTaskLanguageModelWithAppTaskIDAndLanguageDB(appTaskLanguageModel.AppTaskID, appTaskLanguageModel.Language);
if (string.IsNullOrWhiteSpace(appTaskLanguageModelExist.Error))
{
return(ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.AppTaskLanguage)));
}
AppTaskLanguage appTaskLanguageNew = new AppTaskLanguage();
retStr = FillAppTaskLanguage(appTaskLanguageNew, appTaskLanguageModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.AppTaskLanguages.Add(appTaskLanguageNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("AppTaskLanguages", appTaskLanguageNew.AppTaskLanguageID, LogCommandEnum.Add, appTaskLanguageNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetAppTaskLanguageModelWithAppTaskIDAndLanguageDB((int)appTaskLanguageNew.AppTaskID, appTaskLanguageModel.Language));
}
private void FillAppTaskLanguageModel(LanguageEnum Language, AppTaskLanguageModel appTaskLanguageModel)
{
appTaskLanguageModel.AppTaskID = appTaskLanguageModel.AppTaskID;
appTaskLanguageModel.Language = Language;
appTaskLanguageModel.ErrorText = randomService.RandomString("Error Text", 20);
appTaskLanguageModel.StatusText = randomService.RandomString("Status Text", 20);
appTaskLanguageModel.TranslationStatus = TranslationStatusEnum.Translated;
Assert.IsTrue(appTaskLanguageModel.AppTaskID != 0);
Assert.IsTrue(appTaskLanguageModel.Language == Language);
Assert.IsTrue(appTaskLanguageModel.ErrorText.Length == 20);
Assert.IsTrue(appTaskLanguageModel.StatusText.Length == 20);
Assert.IsTrue(appTaskLanguageModel.TranslationStatus == TranslationStatusEnum.Translated);
}
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);
appTaskLanguageService = new AppTaskLanguageService((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);
appTaskLanguageModelNew = new AppTaskLanguageModel();
appTaskLanguage = new AppTaskLanguage();
appTaskServiceTest = new AppTaskServiceTest();
appTaskServiceTest.SetupTest(contactModelToDo, culture);
}
private AppTaskLanguageModel UpdateAppTaskLanguageModel(LanguageEnum LangToAdd, AppTaskLanguageModel appTaskLanguageModelRet)
{
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelRet);
AppTaskLanguageModel appTaskLanguageModelRet2 = appTaskLanguageService.PostUpdateAppTaskLanguageDB(appTaskLanguageModelRet);
if (!string.IsNullOrWhiteSpace(appTaskLanguageModelRet2.Error))
{
return(appTaskLanguageModelRet2);
}
Assert.IsNotNull(appTaskLanguageModelRet2);
CompareAppTaskLanguageModels(appTaskLanguageModelRet, appTaskLanguageModelRet2);
return(appTaskLanguageModelRet2);
}
public void AppTaskLanguageService_PostAddAppTaskLanguageDB_UserEmailNotValidated_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[2], culture);
LanguageEnum LangToAdd = LanguageEnum.es;
using (TransactionScope ts = new TransactionScope())
{
AppTaskLanguageModel appTaskLanguageModelRet = AddAppTaskLanguageModel(LangToAdd);
// Assert 1
Assert.AreEqual(ServiceRes.EmailRequiresValidation, appTaskLanguageModelRet.Error);
}
}
}
public void AppTaskLanguageService_PostAddAppTaskLanguageDB_BadUser_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListBad[0], culture);
LanguageEnum LangToAdd = LanguageEnum.es;
using (TransactionScope ts = new TransactionScope())
{
AppTaskLanguageModel appTaskLanguageModelRet = AddAppTaskLanguageModel(LangToAdd);
// Assert 1
Assert.AreEqual(ServiceRes.NeedToBeLoggedIn, appTaskLanguageModelRet.Error);
}
}
}
public void AppTaskLanguageService_GetAppTaskModelCountDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
LanguageEnum LangToAdd = LanguageEnum.es;
AppTaskLanguageModel appTaskModelLanguageRet = AddAppTaskLanguageModel(LangToAdd);
Assert.AreEqual("", appTaskModelLanguageRet.Error);
int appTaskCount = appTaskLanguageService.GetAppTaskLanguageModelCountDB();
Assert.AreEqual(testDBService.Count + 3, appTaskCount);
}
}
}
// Fill
public string FillAppTaskLanguage(AppTaskLanguage appTaskLanguageNew, AppTaskLanguageModel appTaskLanguageModel, ContactOK contactOK)
{
appTaskLanguageNew.DBCommand = (int)appTaskLanguageModel.DBCommand;
appTaskLanguageNew.AppTaskID = appTaskLanguageModel.AppTaskID;
appTaskLanguageNew.Language = (int)appTaskLanguageModel.Language;
appTaskLanguageNew.TranslationStatus = (int)appTaskLanguageModel.TranslationStatus;
appTaskLanguageNew.StatusText = appTaskLanguageModel.StatusText;
appTaskLanguageNew.ErrorText = appTaskLanguageModel.ErrorText;
appTaskLanguageNew.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
appTaskLanguageNew.LastUpdateContactTVItemID = 2;
}
else
{
appTaskLanguageNew.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public void AppTaskLanguageService_GetAppTaskLanguageWithAppTaskIDAndLanguageDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
LanguageEnum LangToAdd = LanguageEnum.es;
AppTaskLanguageModel appTaskLanguageModelRet = AddAppTaskLanguageModel(LangToAdd);
Assert.AreEqual("", appTaskLanguageModelRet.Error);
AppTaskLanguage appTaskLanguageRet2 = appTaskLanguageService.GetAppTaskLanguageWithAppTaskIDAndLanguageDB(appTaskLanguageModelRet.AppTaskID, LangToAdd);
Assert.AreEqual(appTaskLanguageModelRet.AppTaskID, appTaskLanguageRet2.AppTaskID);
Assert.AreEqual(appTaskLanguageModelRet.Language, (LanguageEnum)appTaskLanguageRet2.Language);
Assert.AreEqual(LangToAdd, (LanguageEnum)appTaskLanguageRet2.Language);
}
}
}
public void AppTaskLanguageService_PostAddAppTaskLanguageDB_Good_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
LanguageEnum LangToAdd = LanguageEnum.es;
AppTaskLanguageModel appTaskLanguageModelRet = AddAppTaskLanguageModel(LangToAdd);
Assert.AreEqual("", appTaskLanguageModelRet.Error);
AppTaskLanguageModel appTaskLanguageModelRet2 = UpdateAppTaskLanguageModel(LangToAdd, appTaskLanguageModelRet);
AppTaskLanguageModel appTaskLanguageModelRet3 = appTaskLanguageService.PostDeleteAppTaskLanguageDB(appTaskLanguageModelRet.AppTaskID, LangToAdd);
Assert.AreEqual("", appTaskLanguageModelRet3.Error);
}
}
}
// Post
public AppTaskModel PostAddAppTask(AppTaskModel appTaskModel)
{
string retStr = AppTaskModelOK(appTaskModel);
if (!string.IsNullOrEmpty(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppTask appTaskExist = GetAppTaskWithTVItemIDTVItemID2AndCommandDB(appTaskModel.TVItemID, appTaskModel.TVItemID2, appTaskModel.AppTaskCommand);
if (appTaskExist != null)
{
return(ReturnError(string.Format(ServiceRes._AlreadyExists, ServiceRes.AppTask)));
}
AppTask appTaskNew = new AppTask();
retStr = FillAppTask(appTaskNew, appTaskModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.AppTasks.Add(appTaskNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
foreach (LanguageEnum Lang in LanguageListAllowable)
{
AppTaskLanguageModel appTaskLanguageModelNew = new AppTaskLanguageModel()
{
AppTaskID = appTaskNew.AppTaskID,
DBCommand = DBCommandEnum.Original,
ErrorText = appTaskModel.ErrorText ?? "",
StatusText = appTaskModel.StatusText ?? "",
Language = Lang,
TranslationStatus = (Lang == LanguageRequest ? TranslationStatusEnum.Translated : TranslationStatusEnum.NotTranslated),
};
AppTaskLanguageModel appTaskLanguageModelRet = _AppTaskLanguageService.PostAddAppTaskLanguageDB(appTaskLanguageModelNew);
if (!string.IsNullOrEmpty(appTaskLanguageModelRet.Error))
{
return(ReturnError(appTaskLanguageModelRet.Error));
}
}
ts.Complete();
}
return(GetAppTaskModelWithAppTaskIDDB(appTaskNew.AppTaskID));
}
private void CompareAppTaskLanguageModels(AppTaskLanguageModel appTaskLanguageModelNew, AppTaskLanguageModel appTaskLanguageModelRet)
{
Assert.AreEqual(appTaskLanguageModelNew.Language, appTaskLanguageModelRet.Language);
Assert.AreEqual(appTaskLanguageModelNew.ErrorText, appTaskLanguageModelRet.ErrorText);
Assert.AreEqual(appTaskLanguageModelNew.StatusText, appTaskLanguageModelRet.StatusText);
}
public void AppTaskLanguageService_AppTaskLanguageModelOK_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
LanguageEnum LangToAdd = LanguageEnum.es;
using (TransactionScope ts = new TransactionScope())
{
AppTaskLanguageModel appTaskLanguageModel = AddAppTaskLanguageModel(LangToAdd);
Assert.AreEqual("", appTaskLanguageModel.Error);
#region AppTaskID
appTaskLanguageModelNew.AppTaskID = appTaskLanguageModel.AppTaskID;
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.AppTaskID = 0;
string retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.AppTaskID), retStr);
appTaskLanguageModelNew.AppTaskID = appTaskLanguageModel.AppTaskID;
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual("", retStr);
#endregion AppTaskID
#region Language
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.Language = LanguageEnum.en;
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual("", retStr);
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.Language = (LanguageEnum)10000;
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual(string.Format(ServiceRes._IsRequired, ServiceRes.Language), retStr);
#endregion Language
#region ErrorText
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
int Max = 250;
appTaskLanguageModelNew.ErrorText = randomService.RandomString("", 0);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual("", retStr);
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.ErrorText = randomService.RandomString("", Max + 1);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual(string.Format(ServiceRes._MaxLengthIs_, ServiceRes.ErrorText, Max), retStr);
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.ErrorText = randomService.RandomString("", Max - 1);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual("", retStr);
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.ErrorText = randomService.RandomString("", Max);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual("", retStr);
#endregion ErrorText
#region StatusText
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
Max = 250;
appTaskLanguageModelNew.StatusText = randomService.RandomString("", 0);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual("", retStr);
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.StatusText = randomService.RandomString("", Max + 1);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual(string.Format(ServiceRes._MaxLengthIs_, ServiceRes.StatusText, Max), retStr);
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.StatusText = randomService.RandomString("", Max - 1);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual("", retStr);
FillAppTaskLanguageModel(LangToAdd, appTaskLanguageModelNew);
appTaskLanguageModelNew.StatusText = randomService.RandomString("", Max);
retStr = appTaskLanguageService.AppTaskLanguageModelOK(appTaskLanguageModelNew);
Assert.AreEqual("", retStr);
#endregion StatusText
}
}
}
