public void TestDeleteCatchSqlErrorTurnedOn()
{
//SETUP
var options = SqliteInMemory.CreateOptions <EfCoreContext>();
using (var context = new EfCoreContext(options))
{
context.Database.EnsureCreated();
context.SeedDatabaseFourBooks();
var firstBook = context.Books.First();
var status = Order.CreateOrder("J", DateTime.Today,
new List <OrderBooksDto> {
new OrderBooksDto(firstBook.BookId, firstBook, 1)
});
context.Add(status.Result);
var config = new GenericServicesConfig()
{
SaveChangesExceptionHandler = CatchUniqueError19
};
var utData = context.SetupSingleDtoAndEntities <BookTitle>(config);
var service = new CrudServices(context, utData.ConfigAndMapper);
//ATTEMPT
service.DeleteAndSave <Book>(firstBook.BookId);
//VERIFY
service.GetAllErrors().ShouldEqual("Unique constraint failed");
}
}
public void TestBeforeSaveChangesMethodProvidedWithError()
{
//SETUP
var options = SqliteInMemory.CreateOptions <TestDbContext>();
using (var context = new TestDbContext(options))
{
context.Database.EnsureCreated();
var config = new GenericServicesConfig()
{
BeforeSaveChanges = FailOnBadWord
};
var utData = context.SetupSingleDtoAndEntities <UniqueWithConfigDto>(config);
var service = new CrudServices(context, utData.ConfigAndMapper);
//ATTEMPT
service.CreateAndSave(new NormalEntity {
MyString = "bad word"
});
//VERIFY
service.IsValid.ShouldBeFalse();
service.GetAllErrors().ShouldEqual("The NormalEntity class contained a bad word.");
}
using (var context = new TestDbContext(options))
{
context.NormalEntities.Count().ShouldEqual(0);
}
}
public void TestDtoAccessUpdateWithValidationTurnedOnViaGlobalConfig()
{
//SETUP
var options = SqliteInMemory.CreateOptions <TestDbContext>();
using (var context = new TestDbContext(options))
{
context.Database.EnsureCreated();
context.UniqueEntities.Add(new UniqueEntity {
UniqueString = "Hello"
});
var entity = new UniqueEntity {
UniqueString = "Goodbye"
};
context.UniqueEntities.Add(entity);
context.SaveChanges();
var config = new GenericServicesConfig()
{
DtoAccessValidateOnSave = true,
SaveChangesExceptionHandler = CatchUniqueError19
};
var utData = context.SetupSingleDtoAndEntities <UniqueNoConfigDto>(config);
var service = new CrudServices(context, utData.ConfigAndMapper);
//ATTEMPT
service.UpdateAndSave(new UniqueNoConfigDto()
{
Id = entity.Id, UniqueString = "Hello"
});
//VERIFY
service.GetAllErrors().ShouldEqual("Unique Entity: Unique constraint failed");
}
}
public async Task TestUpdateCatchSqlErrorOn()
{
//SETUP
var options = SqliteInMemory.CreateOptions <TestDbContext>();
using (var context = new TestDbContext(options))
{
context.Database.EnsureCreated();
context.UniqueEntities.Add(new UniqueEntity {
UniqueString = "Hello"
});
var entity = new UniqueEntity {
UniqueString = "Goodbye"
};
context.UniqueEntities.Add(entity);
context.SaveChanges();
var config = new GenericServicesConfig()
{
SaveChangesExceptionHandler = CatchUniqueError19
};
var utData = context.SetupSingleDtoAndEntities <UniqueWithConfigDto>(config);
var service = new CrudServicesAsync(context, utData.ConfigAndMapper, new CreateNewDBContextHelper(() => new TestDbContext(options)));
//ATTEMPT
entity.UniqueString = "Hello";
await service.UpdateAndSaveAsync(entity);
//VERIFY
service.GetAllErrors().ShouldEqual("Unique constraint failed");
}
}
/// <summary>
/// This will take an IQueryable request and add single on the end to realise the request.
/// It catches if the single didn't produce an item
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="request">An IQueryable request with a filter that yeilds a single item</param>
/// <param name="methodName">Do not specify. System fills this in with the calling method</param>
/// <returns>Returns status. If Valid then status.Result is the single item, otherwise an new, empty class</returns>
public static ISuccessOrErrors <T> RealiseSingleWithErrorChecking <T>(this IQueryable <T> request, [CallerMemberName] string methodName = "") where T : class, new()
{
var status = new SuccessOrErrors <T>(new T(), "we return empty class if it fails");
try
{
var result = request.SingleOrDefault();
if (result == null)
{
status.AddSingleError(
"We could not find an entry using that filter. Has it been deleted by someone else?");
}
else
{
status.SetSuccessWithResult(result, "successful");
}
}
catch (Exception ex)
{
if (GenericServicesConfig.RealiseSingleExceptionMethod == null)
{
throw; //nothing to catch error
}
var errMsg = GenericServicesConfig.RealiseSingleExceptionMethod(ex, methodName);
if (errMsg != null)
{
status.AddSingleError(errMsg);
}
else
{
throw; //do not understand the error so rethrow
}
}
return(status);
}
public async Task TestBeforeSaveChangesMethodProvidedNoError()
{
//SETUP
var options = SqliteInMemory.CreateOptions <TestDbContext>();
using (var context = new TestDbContext(options))
{
context.Database.EnsureCreated();
var config = new GenericServicesConfig()
{
BeforeSaveChanges = FailOnBadWord
};
var utData = context.SetupSingleDtoAndEntities <UniqueWithConfigDto>(config);
var service = new CrudServicesAsync(context, utData.ConfigAndMapper);
//ATTEMPT
await service.CreateAndSaveAsync(new NormalEntity { MyString = "good word" });
//VERIFY
service.IsValid.ShouldBeTrue(service.GetAllErrors());
}
using (var context = new TestDbContext(options))
{
context.NormalEntities.Count().ShouldEqual(1);
}
}
public async Task TestDirectAccessCreateWithValidationTurnedOn()
{
//SETUP
var options = SqliteInMemory.CreateOptions <TestDbContext>();
using (var context = new TestDbContext(options))
{
context.Database.EnsureCreated();
context.UniqueEntities.Add(new UniqueEntity {
UniqueString = "Hello"
});
context.SaveChanges();
var config = new GenericServicesConfig()
{
DirectAccessValidateOnSave = true,
SaveChangesExceptionHandler = CatchUniqueError19
};
var utData = context.SetupSingleDtoAndEntities <UniqueWithConfigDto>(config);
var service = new CrudServicesAsync(context, utData.ConfigAndMapper);
//ATTEMPT
await service.CreateAndSaveAsync(new UniqueEntity { UniqueString = "Hello" });
//VERIFY
service.GetAllErrors().ShouldEqual("Unique Entity: Unique constraint failed");
}
}
public void TestCreateCatchSqlErrorOn()
{
//SETUP
var options = SqliteInMemory.CreateOptions <TestDbContext>();
using (var context = new TestDbContext(options))
{
context.Database.EnsureCreated();
context.UniqueEntities.Add(new UniqueEntity {
UniqueString = "Hello"
});
context.SaveChanges();
var config = new GenericServicesConfig()
{
SaveChangesExceptionHandler = CatchUniqueError19
};
var utData = context.SetupSingleDtoAndEntities <UniqueWithConfigDto>(config);
var service = new CrudServices(context, utData.ConfigAndMapper);
//ATTEMPT
service.CreateAndSave(new UniqueEntity {
UniqueString = "Hello"
});
//VERIFY
service.GetAllErrors().ShouldEqual("Unique constraint failed");
}
}
public void Test01ClearSqlErrorDictOk()
{
//SETUP
//ATTEMPT
GenericServicesConfig.ClearSqlErrorDict();
//VERIFY
GenericServicesConfig.SqlErrorDict.Count.ShouldEqual(0);
}
public void Test02DefaultSqlErrorDictOk()
{
//SETUP
//ATTEMPT
GenericServicesConfig.ClearSqlErrorDict();
RestoreSqlErrorTextDict();
//VERIFY
CollectionAssert.AreEquivalent(new[] { 547, 2601 }, GenericServicesConfig.SqlErrorDict.Keys);
}
public void Test05AddNewSqlErrorDictItemOk()
{
//SETUP
//ATTEMPT
GenericServicesConfig.ClearSqlErrorDict();
GenericServicesConfig.AddToSqlErrorDict(-1, "A test");
//VERIFY
GenericServicesConfig.SqlErrorDict.Count.ShouldEqual(1);
GenericServicesConfig.SqlErrorDict[-1].ShouldEqual("A test");
}
public void TestDifferntNamesOnDefaultNameMatcher(string name, double score)
{
//SETUP
var globalConfig = new GenericServicesConfig();
//ATTEMPT
var result = globalConfig.NameMatcher(name, typeof(int), MyIntProp);
//VERIFY
Math.Abs(result.Score - score).ShouldBeInRange(0, 0.001);
_output.WriteLine(result.ToString());
}
public void Test21AddTwiceToErrorHandleDictOk()
{
//SETUP
GenericServicesConfig.AddToSqlHandlerDict(2601, TestExceptionNoCatch);
//ATTEMPT
GenericServicesConfig.AddToSqlHandlerDict(2601, TestExceptionCatch, false);
//VERIFY
GenericServicesConfig.SqlHandlerDict.Keys.Count().ShouldEqual(1);
GenericServicesConfig.SqlHandlerDict[2601].Method.Name.ShouldEqual("TestExceptionCatch");
}
public void Test20AddTwiceToErrorHandleDictBad()
{
//SETUP
GenericServicesConfig.AddToSqlHandlerDict(2601, TestExceptionNoCatch);
//ATTEMPT
var ex =
Assert.Throws <InvalidOperationException>(
() => GenericServicesConfig.AddToSqlHandlerDict(2601, TestExceptionCatch));
//VERIFY
ex.Message.ShouldEqual("You tried to add an exception handler for sql error 2601 but a handler called TestExceptionNoCatch was already there.");
}
public void FixtureSetup()
{
//This remembers the SqlErrorTextDict
_rememberDefaultSqlErrorTextDict =
GenericServicesConfig.SqlErrorDict.Select(x => new KeyValuePair <int, string>(x.Key, x.Value))
.ToList();
GenericServicesConfig.ClearSqlHandlerDict();
using (var db = new SampleWebAppDb())
{
DataLayerInitialise.InitialiseThis();
var filepath = TestFileHelpers.GetTestFileFilePath("DbContentSimple.xml");
DataLayerInitialise.ResetDatabaseToTestData(db, filepath);
}
}
public void TestSqlErrorHandlerWorksOk(int sqlErrorCode, bool shouldThrowException)
{
IStatusGeneric CatchUniqueError(Exception e, DbContext context)
{
var dbUpdateEx = e as DbUpdateException;
var sqliteError = dbUpdateEx?.InnerException as SqliteException;
return(sqliteError?.SqliteErrorCode == sqlErrorCode
? new StatusGenericHandler().AddError("Unique constraint failed")
: null);
}
//SETUP
var options = SqliteInMemory.CreateOptions <TestDbContext>();
using (var context = new TestDbContext(options))
{
context.Database.EnsureCreated();
context.UniqueEntities.Add(new UniqueEntity {
UniqueString = "Hello"
});
context.SaveChanges();
var config = new GenericServicesConfig()
{
SaveChangesExceptionHandler = CatchUniqueError
};
var utData = context.SetupSingleDtoAndEntities <UniqueWithConfigDto>(config);
var service = new CrudServices(context, utData.ConfigAndMapper);
//ATTEMPT
try
{
service.CreateAndSave(new UniqueWithConfigDto {
UniqueString = "Hello"
});
}
//VERIFY
catch (Exception)
{
shouldThrowException.ShouldBeTrue();
return;
}
shouldThrowException.ShouldBeFalse();
service.GetAllErrors().ShouldEqual("Unique constraint failed");
}
}
public void Test01ValidateTagCaughtByHandleDictError()
{
//SETUP
GenericServicesConfig.AddToSqlHandlerDict(2601, TestExceptionCatch);
using (var db = new SampleWebAppDb())
{
var existingTag = db.Tags.First();
//ATTEMPT
var dupTag = new Tag {
Name = "duplicate slug", Slug = existingTag.Slug
};
db.Tags.Add(dupTag);
var status = db.SaveChangesWithChecking();
//VERIFY
status.IsValid.ShouldEqual(false);
status.Errors.Count.ShouldEqual(1);
status.Errors[0].ErrorMessage.ShouldEqual("SQL error 2601. Following class types had errors: Tag.");
}
}
public void Test10ValidateTagCaughtBySqlDict()
{
//SETUP
GenericServicesConfig.AddToSqlHandlerDict(2601, TestExceptionNoCatch);
using (var db = new SampleWebAppDb())
{
var existingTag = db.Tags.First();
//ATTEMPT
var dupTag = new Tag {
Name = "duplicate slug", Slug = existingTag.Slug
};
db.Tags.Add(dupTag);
var status = db.SaveChangesWithChecking();
//VERIFY
status.IsValid.ShouldEqual(false);
status.Errors.Count.ShouldEqual(1);
status.Errors[0].ErrorMessage.ShouldEqual("One of the properties is marked as Unique index and there is already an entry with that value.");
}
}
public void FixtureSetUp()
{
GenericServicesConfig.ClearAutoMapperCache();
}
public void FixtureTearDown()
{
GenericServicesConfig.ClearSqlHandlerDict();
}
public void Setup()
{
GenericServicesConfig.ClearSqlHandlerDict();
}
private void RestoreSqlErrorTextDict()
{
_rememberDefaultSqlErrorTextDict.ForEach(x => GenericServicesConfig.AddToSqlErrorDict(x.Key, x.Value));
}
