public void AppErrLogService_PostUpdateAppErrLog_GetAppErrLogWithAppErrLogIDDB_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
using (ShimsContext.Create())
{
SetupShim();
//string ErrorText = "ErrorText";
shimAppErrLogService.GetAppErrLogWithAppErrLogIDDBInt32 = (a) =>
{
return(null);
};
AppErrLogModel appErrLogModelRet2 = UpdateAppErrLogModel(appErrLogModelRet);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.AppErrLog), appErrLogModelRet2.Error);
}
}
}
}
public void AppErrLogService_PostUpdateAppErrLog_DoUpdateChanges_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
using (ShimsContext.Create())
{
SetupShim();
string ErrorText = "ErrorText";
shimAppErrLogService.DoUpdateChanges = () =>
{
return(ErrorText);
};
AppErrLogModel appErrLogModelRet2 = UpdateAppErrLogModel(appErrLogModelRet);
Assert.AreEqual(ErrorText, appErrLogModelRet2.Error);
}
}
}
}
public void AppErrLogService_PostDeleteAppErrLog_IsContactOK_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
using (ShimsContext.Create())
{
SetupShim();
string ErrorText = "ErrorText";
shimAppErrLogService.IsContactOK = () =>
{
return(new ContactOK()
{
Error = ErrorText
});
};
AppErrLogModel appErrLogModelRet3 = appErrLogService.PostDeleteAppErrLogDB(appErrLogModelRet.AppErrLogID);
Assert.AreEqual(ErrorText, appErrLogModelRet3.Error);
}
}
}
}
public AppErrLogModel GetAppErrLogModelWithAppErrLogIDDB(int AppErrLogID)
{
AppErrLogModel appErrLogModel = (from c in db.AppErrLogs
where c.AppErrLogID == AppErrLogID
select new AppErrLogModel
{
Error = "",
AppErrLogID = c.AppErrLogID,
DBCommand = (DBCommandEnum)c.DBCommand,
Tag = c.Tag,
LineNumber = c.LineNumber,
Message = c.Message,
Source = c.Source,
DateTime_UTC = c.DateTime_UTC,
LastUpdateDate_UTC = c.LastUpdateDate_UTC,
LastUpdateContactTVItemID = c.LastUpdateContactTVItemID,
}).FirstOrDefault <AppErrLogModel>();
if (appErrLogModel == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.AppErrLog, ServiceRes.AppErrLogID, AppErrLogID)));
}
return(appErrLogModel);
}
private void CompareAppErrLogModels(AppErrLogModel appErrLogModelNew, AppErrLogModel appErrLogModelRet)
{
Assert.AreEqual(appErrLogModelNew.Tag, appErrLogModelRet.Tag);
Assert.AreEqual(appErrLogModelNew.DateTime_UTC, appErrLogModelRet.DateTime_UTC);
Assert.AreEqual(appErrLogModelNew.LineNumber, appErrLogModelRet.LineNumber);
Assert.AreEqual(appErrLogModelNew.Message, appErrLogModelRet.Message);
Assert.AreEqual(appErrLogModelNew.Source, appErrLogModelRet.Source);
}
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);
appErrLogService = new AppErrLogService((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);
appErrLogModelNew = new AppErrLogModel();
appErrLog = new AppErrLog();
}
private void FillAppErrLogModelUpdate(AppErrLogModel appErrLogModel)
{
appErrLogModel.Tag = randomService.RandomString("Tag Text2", 10);
appErrLogModel.DateTime_UTC = randomService.RandomDateTime();
appErrLogModel.LineNumber = randomService.RandomInt(500, 650);
appErrLogModel.Message = randomService.RandomString("Message text2", 20);
appErrLogModel.Source = randomService.RandomString("Source text2", 20);
Assert.IsTrue(appErrLogModel.Tag.Length == 10);
Assert.IsTrue(appErrLogModel.DateTime_UTC != null);
Assert.IsTrue(appErrLogModel.LineNumber >= 500 && appErrLogModel.LineNumber <= 650);
Assert.IsTrue(appErrLogModel.Message.Length == 20);
Assert.IsTrue(appErrLogModel.Source.Length == 20);
}
public AppErrLogModel PostUpdateAppErrLogDB(AppErrLogModel appErrLogModel)
{
string retStr = AppErrLogModelOK(appErrLogModel);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppErrLog appErrLogToUpdate = GetAppErrLogWithAppErrLogIDDB(appErrLogModel.AppErrLogID);
if (appErrLogToUpdate == null)
{
return(ReturnError(string.Format(ServiceRes.CouldNotFind_ToUpdate, ServiceRes.AppErrLog)));
}
retStr = FillAppErrLog(appErrLogToUpdate, appErrLogModel, 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("AppErrLogs", appErrLogToUpdate.AppErrLogID, LogCommandEnum.Change, appErrLogToUpdate);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetAppErrLogModelWithAppErrLogIDDB(appErrLogToUpdate.AppErrLogID));
}
public void AppErrLogService_GetAppErrLogModelCountDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
int appErrLogCount = appErrLogService.GetAppErrLogModelCountDB();
Assert.AreEqual(testDBService.Count + 1, appErrLogCount);
}
}
}
private AppErrLogModel UpdateAppErrLogModel(AppErrLogModel appErrLogModel)
{
FillAppErrLogModelUpdate(appErrLogModel);
AppErrLogModel appErrLogModelRet = appErrLogService.PostUpdateAppErrLogDB(appErrLogModel);
if (!string.IsNullOrWhiteSpace(appErrLogModelRet.Error))
{
return(appErrLogModelRet);
}
Assert.IsNotNull(appErrLogModelRet);
CompareAppErrLogModels(appErrLogModel, appErrLogModelRet);
return(appErrLogModelRet);
}
public void AppErrLogService_PostAddAppErrLogDB_UserEmailNotValidated_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[2], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
Assert.IsNotNull(appErrLogModelRet);
Assert.AreEqual(ServiceRes.EmailRequiresValidation, appErrLogModelRet.Error);
}
}
}
public void AppErrLogService_PostAddAppErrLogDB_BadUser_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListBad[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
Assert.IsNotNull(appErrLogModelRet);
Assert.AreEqual(ServiceRes.NeedToBeLoggedIn, appErrLogModelRet.Error);
}
}
}
public void AppErrLogService_ReturnError_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
string ErrorText = "ErrorText";
AppErrLogModel appErrLogModelRet2 = appErrLogService.ReturnError(ErrorText);
Assert.AreEqual(ErrorText, appErrLogModelRet2.Error);
}
}
}
public void AppErrLogService_PostAddUpdateDeleteAppErrLog_Good_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
AppErrLogModel appErrLogModelRet2 = UpdateAppErrLogModel(appErrLogModelRet);
AppErrLogModel appErrLogModelRet3 = appErrLogService.PostDeleteAppErrLogDB(appErrLogModelRet2.AppErrLogID);
Assert.AreEqual("", appErrLogModelRet3.Error);
}
}
}
// Post
public AppErrLogModel PostAddAppErrLogDB(AppErrLogModel appErrLogModel)
{
string retStr = AppErrLogModelOK(appErrLogModel);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
ContactOK contactOK = IsContactOK();
if (!string.IsNullOrEmpty(contactOK.Error))
{
return(ReturnError(contactOK.Error));
}
AppErrLog appErrLogNew = new AppErrLog();
retStr = FillAppErrLog(appErrLogNew, appErrLogModel, contactOK);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
using (TransactionScope ts = new TransactionScope())
{
db.AppErrLogs.Add(appErrLogNew);
retStr = DoAddChanges();
if (!string.IsNullOrWhiteSpace(retStr))
{
return(ReturnError(retStr));
}
LogModel logModel = _LogService.PostAddLogForObj("AppErrLogs", appErrLogNew.AppErrLogID, LogCommandEnum.Add, appErrLogNew);
if (!string.IsNullOrWhiteSpace(logModel.Error))
{
return(ReturnError(logModel.Error));
}
ts.Complete();
}
return(GetAppErrLogModelWithAppErrLogIDDB(appErrLogNew.AppErrLogID));
}
public void AppErrLogService_GetAppErrLogModelOrderByDateDescDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
int skip = 0;
int take = 100000;
List <AppErrLogModel> appErrLogModelList = appErrLogService.GetAppErrLogModelOrderByDateDescDB(skip, take);
Assert.AreEqual(testDBService.Count + 1, appErrLogModelList.Count);
}
}
}
public void AppErrLogService_GetAppErrLogModelFilterMessageOrderByDateDescDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
int skip = 0;
int take = 100000;
string FilterMessage = appErrLogModelNew.Message;
List <AppErrLogModel> appErrLogModelList = appErrLogService.GetAppErrLogModelFilterMessageOrderByDateDescDB(FilterMessage, skip, take);
Assert.IsTrue(appErrLogModelList.Count >= 1);
}
}
}
public void AppErrLogService_GetAppErrLogWithAppErrLogIDDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
AppErrLog appErrLogRet2 = appErrLogService.GetAppErrLogWithAppErrLogIDDB(appErrLogModelRet.AppErrLogID);
Assert.IsNotNull(appErrLogRet2);
Assert.AreEqual(appErrLogModelRet.AppErrLogID, appErrLogRet2.AppErrLogID);
AppErrLog appErrLogRet3 = appErrLogService.GetAppErrLogWithAppErrLogIDDB(0);
Assert.IsNull(appErrLogRet3);
}
}
}
public void AppErrLogService_GetAppErrLogModelWithAppErrLogIDDB_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
AppErrLogModel appErrLogModelRet2 = appErrLogService.GetAppErrLogModelWithAppErrLogIDDB(appErrLogModelRet.AppErrLogID);
Assert.IsNotNull(appErrLogModelRet2);
CompareAppErrLogModels(appErrLogModelRet, appErrLogModelRet2);
int AppErrLogID = 0;
AppErrLogModel appErrLogModelRet3 = appErrLogService.GetAppErrLogModelWithAppErrLogIDDB(AppErrLogID);
Assert.AreEqual(string.Format(ServiceRes.CouldNotFind_With_Equal_, ServiceRes.AppErrLog, ServiceRes.AppErrLogID, AppErrLogID), appErrLogModelRet3.Error);
}
}
}
// Check
public string AppErrLogModelOK(AppErrLogModel appErrLogModel)
{
string retStr = FieldCheckNotNullAndMinMaxLengthString(appErrLogModel.Tag, ServiceRes.Tag, 2, 100);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotEmptyAndMaxLengthString(appErrLogModel.Source, ServiceRes.Source, 1000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotEmptyAndMaxLengthString(appErrLogModel.Message, ServiceRes.Message, 1000);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotZeroInt(appErrLogModel.LineNumber, ServiceRes.LineNumber);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = FieldCheckNotNullDateTime(appErrLogModel.DateTime_UTC, ServiceRes.DateTime_UTC);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
retStr = _BaseEnumService.DBCommandOK(appErrLogModel.DBCommand);
if (!string.IsNullOrWhiteSpace(retStr))
{
return(retStr);
}
return("");
}
// Fill
public string FillAppErrLog(AppErrLog appErrLog, AppErrLogModel appErrLogModel, ContactOK contactOK)
{
appErrLog.DBCommand = (int)appErrLogModel.DBCommand;
appErrLog.Tag = appErrLogModel.Tag;
appErrLog.LineNumber = appErrLogModel.LineNumber;
appErrLog.Source = appErrLogModel.Source;
appErrLog.Message = appErrLogModel.Message;
appErrLog.DateTime_UTC = appErrLogModel.DateTime_UTC;
appErrLog.LastUpdateDate_UTC = DateTime.UtcNow;
if (contactOK == null)
{
appErrLog.LastUpdateContactTVItemID = 2;
}
else
{
appErrLog.LastUpdateContactTVItemID = contactOK.ContactTVItemID;
}
return("");
}
public void AppErrLogService_PostAddAppErrLogDB_FillAppErrLog_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
SetupShim();
string ErrorText = "ErrorText";
shimAppErrLogService.FillAppErrLogAppErrLogAppErrLogModelContactOK = (a, b, c) =>
{
return(ErrorText);
};
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
Assert.AreEqual(ErrorText, appErrLogModelRet.Error);
}
}
}
}
public void AppErrLogService_PostAddAppErrLogDB_Add_Error_Test()
{
foreach (CultureInfo culture in setupData.cultureListGood)
{
SetupTest(contactModelListGood[0], culture);
using (TransactionScope ts = new TransactionScope())
{
using (ShimsContext.Create())
{
SetupShim();
//string ErrorText = "ErrorText";
shimAppErrLogService.FillAppErrLogAppErrLogAppErrLogModelContactOK = (a, b, c) =>
{
return("");
};
AppErrLogModel appErrLogModelRet = AddAppErrLogModel();
Assert.IsTrue(appErrLogModelRet.Error.StartsWith(string.Format(ServiceRes.CouldNotAddError_, "").Substring(0, 10)));
}
}
}
}
