public Aggregator()
{
UserRepository = new UserRepository();
EntitiesRepository = new EntitiesRepository();
ResourcesRepository = new ResourcesRepository();
IntentionsRepository = new IntentionsRepository();
DifficultyLevelsRepository = new DifficultyLevelsRepository();
}
public IActionResult Get()
{
EntitiesRepository repo = new EntitiesRepository();
List <Entity> results = repo.SelectAll();
if (results == null)
{
return(NotFound());
}
return(Ok(results));
}
public async Task TestPositiveCase()
{
// Arrange / Act
await using var unitOfWork = await UnitOfWorkManager.Begin();
await unitOfWork.TestEntities.Add(1, "one");
// Assert
var readName = await EntitiesRepository.GetNameOrDefault(1);
readName.ShouldBe("one");
}
private List <Entity> GetEntity()
{
//FromRepo
try
{
EntitiesRepository repo = new EntitiesRepository();
List <Entity> results = repo.SelectAll();
PassTest();
return(results);
}
catch (Exception ex)
{
_output.WriteLine(ex.Message);
_output.WriteLine(ex.InnerException.ToString());
FailTest();
return(null);
}
}
public async Task TestPositiveCase()
{
// Arrange / Act
await using var unitOfWork = await UnitOfWorkManager.Begin("a");
unitOfWork.Outbox.IsClosed.ShouldBeFalse();
await unitOfWork.TestEntities.Add(1, "one");
unitOfWork.Outbox.Publish(new TestDomainEvent {
Id = 1
});
unitOfWork.Outbox.Send(new TestDomainCommand {
Id = 2
});
unitOfWork.Outbox.Return(new TestDomainResponse {
Id = 3
});
await unitOfWork.Commit();
await unitOfWork.EnsureOutboxDispatched();
// Assert
var readName = await EntitiesRepository.GetNameOrDefault(1);
readName.ShouldBe("one");
OutboxDispatcher.PublishedEvents.OfType <TestDomainEvent>().ShouldHaveSingleItem();
OutboxDispatcher.PublishedEvents.OfType <TestDomainEvent>().Single().Id.ShouldBe(1);
OutboxDispatcher.SentCommands.OfType <TestDomainCommand>().ShouldHaveSingleItem();
OutboxDispatcher.SentCommands.OfType <TestDomainCommand>().Single().Id.ShouldBe(2);
unitOfWork.Outbox.GetResponse <TestDomainResponse>().ShouldNotBeNull();
unitOfWork.Outbox.GetResponse <TestDomainResponse>().Id.ShouldBe(3);
}
public JsonResult Post([FromBody] string value)
{
EntitiesRepository repo = new EntitiesRepository();
return(new JsonResult(repo.SelectAll()));
}
public DataManager(CustomersRepository customersRepository, EntitiesRepository entitiesRepository, IDistributedCache distributedCache)
{
_customersRepository = customersRepository;
_entitiesRepository = entitiesRepository;
_distributedCache = distributedCache;
}
public async Task TestTransientErrorBeforeCommit()
{
// Arrange
async Task <TestDomainResponse> Act(bool error, int attempt)
{
await using var unitOfWork = await UnitOfWorkManager.Begin("a");
if (!unitOfWork.Outbox.IsClosed)
{
await unitOfWork.TestEntities.Add(1, attempt.ToString());
unitOfWork.Outbox.Publish(new TestDomainEvent {
Id = attempt
});
unitOfWork.Outbox.Send(new TestDomainCommand {
Id = attempt * 10
});
unitOfWork.Outbox.Return(new TestDomainResponse {
Id = attempt * 100
});
if (error)
{
throw new InvalidOperationException("Some transient error");
}
await unitOfWork.Commit();
}
await unitOfWork.EnsureOutboxDispatched();
return(unitOfWork.Outbox.GetResponse <TestDomainResponse>());
}
// Act 1
await Act(error : true, attempt : 1).ShouldThrowAsync <InvalidOperationException>();
// Assert 1
var readName1 = await EntitiesRepository.GetNameOrDefault(1);
readName1.ShouldBeNull();
OutboxDispatcher.PublishedEvents.ShouldBeEmpty();
OutboxDispatcher.SentCommands.ShouldBeEmpty();
// Act 2
OutboxDispatcher.Clear();
var response2 = await Act(error : false, attempt : 2);
// Assert 2
var readName2 = await EntitiesRepository.GetNameOrDefault(1);
readName2.ShouldBe("2");
OutboxDispatcher.PublishedEvents.OfType <TestDomainEvent>().ShouldHaveSingleItem();
OutboxDispatcher.PublishedEvents.OfType <TestDomainEvent>().Single().Id.ShouldBe(2);
OutboxDispatcher.SentCommands.OfType <TestDomainCommand>().ShouldHaveSingleItem();
OutboxDispatcher.SentCommands.OfType <TestDomainCommand>().Single().Id.ShouldBe(2 * 10);
response2.Id.ShouldBe(2 * 100);
}
public async Task TestMissedRollback()
{
// Arrange / Act 1
await using (var unitOfWork = await UnitOfWorkManager.Begin("a"))
{
unitOfWork.Outbox.IsClosed.ShouldBeFalse();
await unitOfWork.TestEntities.Add(1, "one");
unitOfWork.Outbox.Publish(new TestDomainEvent {
Id = 1
});
unitOfWork.Outbox.Send(new TestDomainCommand {
Id = 10
});
unitOfWork.Outbox.Return(new TestDomainResponse {
Id = 100
});
await unitOfWork.Rollback();
}
// Assert 1
var readName1 = await EntitiesRepository.GetNameOrDefault(1);
readName1.ShouldBeNull();
OutboxDispatcher.PublishedEvents.ShouldBeEmpty();
OutboxDispatcher.SentCommands.ShouldBeEmpty();
// Arrange / Act 1
TestDomainResponse response2;
await using (var unitOfWork = await UnitOfWorkManager.Begin("a"))
{
unitOfWork.Outbox.IsClosed.ShouldBeFalse();
await unitOfWork.TestEntities.Add(1, "two");
unitOfWork.Outbox.Publish(new TestDomainEvent {
Id = 2
});
unitOfWork.Outbox.Send(new TestDomainCommand {
Id = 20
});
unitOfWork.Outbox.Return(new TestDomainResponse {
Id = 200
});
await unitOfWork.Commit();
await unitOfWork.EnsureOutboxDispatched();
response2 = unitOfWork.Outbox.GetResponse <TestDomainResponse>();
}
// Assert 1
var readName2 = await EntitiesRepository.GetNameOrDefault(1);
readName2.ShouldBe("two");
OutboxDispatcher.PublishedEvents.OfType <TestDomainEvent>().ShouldHaveSingleItem();
OutboxDispatcher.PublishedEvents.OfType <TestDomainEvent>().Single().Id.ShouldBe(2);
OutboxDispatcher.SentCommands.OfType <TestDomainCommand>().ShouldHaveSingleItem();
OutboxDispatcher.SentCommands.OfType <TestDomainCommand>().Single().Id.ShouldBe(20);
response2.Id.ShouldBe(200);
}
public async Task TestDuplication()
{
// Arrange
async Task <TestDomainResponse> Act(int attempt)
{
await using var unitOfWork = await UnitOfWorkManager.Begin("a");
if (!unitOfWork.Outbox.IsClosed)
{
await unitOfWork.TestEntities.Add(1, attempt.ToString());
unitOfWork.Outbox.Publish(new TestDomainEvent {
Id = attempt
});
unitOfWork.Outbox.Send(new TestDomainCommand {
Id = attempt * 10
});
unitOfWork.Outbox.Return(new TestDomainResponse {
Id = attempt * 100
});
await unitOfWork.Commit();
}
await unitOfWork.EnsureOutboxDispatched();
return(unitOfWork.Outbox.GetResponse <TestDomainResponse>());
}
// Act 1
var response1 = await Act(attempt : 1);
// Assert 1
var readName1 = await EntitiesRepository.GetNameOrDefault(1);
readName1.ShouldBe("1");
OutboxDispatcher.PublishedEvents.OfType <TestDomainEvent>().ShouldHaveSingleItem();
OutboxDispatcher.PublishedEvents.OfType <TestDomainEvent>().Single().Id.ShouldBe(1);
OutboxDispatcher.SentCommands.OfType <TestDomainCommand>().ShouldHaveSingleItem();
OutboxDispatcher.SentCommands.OfType <TestDomainCommand>().Single().Id.ShouldBe(1 * 10);
response1.Id.ShouldBe(1 * 100);
// Act 2
OutboxDispatcher.Clear();
var response2 = await Act(attempt : 2);
// Assert 2
var readName2 = await EntitiesRepository.GetNameOrDefault(1);
readName2.ShouldBe("1");
OutboxDispatcher.PublishedEvents.ShouldBeEmpty();
OutboxDispatcher.SentCommands.ShouldBeEmpty();
response2.Id.ShouldBe(1 * 100);
}
public void TestUniqueWithSave()
{
//new up the repository
EntitiesRepository<Customer, NorthwindEntities> ctx =
new EntitiesRepository<Customer, NorthwindEntities>(new NorthwindEntities());
//new up a specification
Specification<Customer> cust_spec =
new Specification<Customer>(c => c.Country == "Germany" && c.CustomerID == "KOENE");
var unique_german_cust = ctx.Unique("Customers", cust_spec);
var rand_num = new Random(DateTime.Now.Year).Next();
unique_german_cust.Orders.Add(new Order() { ShipName = "Nikovshi" + rand_num.ToString() });
ctx.Save();
Assert.IsNotNull(unique_german_cust);
Console.WriteLine("The Unique customer ID is : {0}", unique_german_cust.CustomerID);
}
public void FailTestForUnique()
{
//new up the repository
EntitiesRepository<Customer, NorthwindEntities> ctx =
new EntitiesRepository<Customer, NorthwindEntities>(new NorthwindEntities());
//new up a specification
Specification<Customer> cust_spec =
new Specification<Customer>(c => c.Country == "Germany");
var unique_german_cust = ctx.Unique("Customers", cust_spec);
Assert.IsNotNull(unique_german_cust);
Console.WriteLine("The Unique customer ID is : {0}", unique_german_cust.CustomerID);
}
public void Multi_Level_Mixed_Hierarchy_With_Persisting_Test()
{
EntitiesRepository<Customer, NorthwindEntities> repos =
new EntitiesRepository<Customer, NorthwindEntities>(new NorthwindEntities());
Specification<Customer> german_cust_spec =
new Specification<Customer>(c => c.CustomerID == "ALFKI");
var german_custs = repos.AllToIList(german_cust_spec, new
MultiLevelMixedStrategy());
foreach (var cust in german_custs)
{
cust.Country = "Germany";
Console.WriteLine("The Customer Name is {0}", cust.CompanyName);
foreach (var order in cust.Orders)
{
order.ShipName = "Battleship Potemkin";
Console.WriteLine("\tThe Order ID is : {0}", order.OrderID);
foreach (var orderline in order.Order_Details)
{
orderline.Discount = 0.15f;
Console.WriteLine("\t\tThe value ordered for Product ID {0} is {1}",
orderline.Product.ProductID, orderline.UnitPrice * orderline.Quantity);
}
}
}
german_custs[0].Orders.Add(Order.CreateOrder(999999));
repos.Save();
}
public MemoryContext()
{
EntitiesRepository = new EntitiesRepository();
}
public void Multi_Level_Mixed_Hierarchy_Test()
{
EntitiesRepository<Customer, NorthwindEntities> repos =
new EntitiesRepository<Customer, NorthwindEntities>(new NorthwindEntities());
var custs = repos.AllToIList(new MultiLevelMixedStrategy());
foreach (var cust in custs)
{
Console.WriteLine("The Customer Name is {0}", cust.CompanyName);
foreach (var order in cust.Orders)
{
Console.WriteLine("\tThe Order ID is : {0}", order.OrderID);
foreach (var orderline in order.Order_Details)
{
Console.WriteLine("\t\tThe value ordered for Product ID {0} is {1}",
orderline.Product.ProductID, orderline.UnitPrice * orderline.Quantity);
}
}
}
}
public void Fetching_Lazy_EntityReference_Eager_EntityCollection()
{
EntitiesRepository<Order, NorthwindEntities> repos =
new EntitiesRepository<Order, NorthwindEntities>(new NorthwindEntities());
Specification<Order> italian_spec =
new Specification<Order>(o => o.Customer.Country == "Italy");
var italian_orders = repos.AllToIList(new LazyEntityReferenceEagerEntityCollection());
foreach (var order in italian_orders)
{
Console.WriteLine("The Customer Name is {0}", order.Customer.CompanyName);
foreach (var orderLine in order.Order_Details)
{
Console.WriteLine("\tThe value ordered for Product ID {0} is {1}",
orderLine.ProductID, orderLine.UnitPrice * orderLine.Quantity);
}
}
}
public void Fetching_Eager_EntityReference_Lazy_EntityCollection()
{
EntitiesRepository<Order, NorthwindEntities> repos =
new EntitiesRepository<Order, NorthwindEntities>(new NorthwindEntities());
var orders = repos.AllToIList(new EagerEntityReferenceLazyEntityCollection());
foreach (var order in orders)
{
//customer is eager
Console.WriteLine("The Customer Name is {0}", order.Customer.CompanyName);
foreach (var orderLine in order.Order_Details)
{
//order details is lazy
Console.WriteLine("\tThe value ordered for Product ID {0} is {1}",
orderLine.ProductID, orderLine.UnitPrice * orderLine.Quantity);
}
}
}
public DataManager(CustomersRepository customersRepository, EntitiesRepository entitiesRepository, IDiskCache cache)
{
_customersRepository = customersRepository;
_entitiesRepository = entitiesRepository;
_cache = cache;
}
public void Test_IQueryable()
{
EntitiesRepository<Customer, NorthwindEntities> repos =
new EntitiesRepository<Customer, NorthwindEntities>(new NorthwindEntities());
var query = repos.AllToIQueryable(new MultiLevelMixedStrategy());
foreach (var cust in query)
{
Console.WriteLine(">> Customer ordering is {0}", cust.CompanyName);
foreach (var ord in cust.Orders)
{
Console.WriteLine("\t-- The customer ID is {0} and the number of lines is {1}",
ord.Customer.CustomerID, ord.Order_Details.Count());
foreach (var line in ord.Order_Details)
{
Console.WriteLine("\t\t++ Product ordered is {0}",
line.Product.ProductName);
}
}
}
}
public void TestFetchingStrateyAllIlist()
{
//new up the repository
EntitiesRepository<Customer, NorthwindEntities> ctx =
new EntitiesRepository<Customer, NorthwindEntities>(new NorthwindEntities());
//new up a specification
Specification<Customer> cust_spec =
new Specification<Customer>(c => c.Country == "Germany" && c.CustomerID == "KOENE");
MakePreferedFetchingStrategy stratey = new MakePreferedFetchingStrategy();
var list = ctx.AllToIList(stratey);
Assert.IsTrue(list.ToList().Count > 0);
}
public void Example_Role_Specified_Strategy_Test()
{
EntitiesRepository<Customer, NorthwindEntities> repos =
new EntitiesRepository<Customer, NorthwindEntities>(new NorthwindEntities());
var custs = repos.AllToIList<ICustomerMakePrefered>();
foreach (var cust in custs)
{
Console.WriteLine("The Customer Name is {0}", cust.CompanyName);
foreach (var order in cust.Orders)
{
Console.WriteLine("\tThe Order ID is : {0}", order.OrderID);
foreach (var orderline in order.Order_Details)
{
Console.WriteLine("\t\tThe value ordered for Product ID {0} is {1}",
orderline.Product.ProductID, orderline.UnitPrice * orderline.Quantity);
}
}
}
}
