public async Task GivenAccountRepository_WhenCallCreate_ShouldSuccess()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
var testData = (memebrId : 0, accountId : 0, memebrAccountId : 1);
var member = MemberDataBuilder.CreateMember(testData.memebrId, new List <MemberAccount>(), null, null);
await context.Members.AddAsync(member);
await context.SaveChangesAsync();
var memberAccount = MemberDataBuilder.CreateMemberAccount(testData.memebrAccountId, testData.accountId, testData.memebrId);
var account = AccountDataBuilder.CreateAccount(testData.accountId, new List <MemberAccount> {
memberAccount
});
// act
var repo = new AccountRepository(context);
await repo.Create(account);
await context.SaveChangesAsync();
// assert
account.Id.ShouldBeGreaterThan(0);
}
}
public async Task GivenQueryExtension_WhenCallListByPaging_IfDataSetIsEmpty_ShouldReturnEmptyPaginationResponse()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// act
var result = await context.AccountSignUpStrategies
.OrderBy(a => a.Id)
.ListByPaging(1, 1);
// assert
result.TotalPageNumber.ShouldBe(0);
result.Data.Count().ShouldBe(0);
}
}
public async Task GivenBaseRepository_WhenCallUndoChange_IfEntityIsAdded_ShouldRollBackEntityState()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
await CreateAccountSingUpStrategy(context);
// act
context.UndoChange();
// assert
context.ChangeTracker.Entries().ShouldAllBe(e => e.State == EntityState.Unchanged);
}
}
public async Task GivenQueryExtension_WhenWhereValueExists_ShouldReturn(string criteria, int expectedRecordNumber)
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
context.AccountSignUpStrategies.Add(AccountSignUpStrategyDataBuilder.CreateAccountSignUpStrategy(10, name: "One"));
await context.SaveChangesAsync();
// act
var result = await context.AccountSignUpStrategies
.WhereWhenValueNotNull(criteria, a => a.Name == criteria)
.ToListAsync();
// assert
result.Count.ShouldBe(expectedRecordNumber);
}
}
public async Task GivenMemberRepository_WhenCallCreate_ShouldSuccess()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
var member = MemberDataBuilder.CreateMember(1, new List <MemberAccount>(), null, null);
// act
var repo = new MemberRepository(context);
await repo.Create(member);
await context.SaveChangesAsync();
// assert
member.Id.ShouldBeGreaterThan(0);
}
}
public async Task GivenAccountRepository_WhenCallGetByAccountNumber_ShouldReturnAccount()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
var account = await CreateOneAccountWithOneMember(1, 1, context);
// act
var repo = new AccountRepository(context);
var actualAccount = await repo.GetByAccountNumber(account.AccountNumber);
// assert
actualAccount.ShouldNotBeNull();
actualAccount.ShouldSatisfyAllConditions(
() => actualAccount.Id.ShouldBe(account.Id),
() => actualAccount.MemberAccounts.ShouldNotBeNull(),
() => actualAccount.MemberAccounts.Count.ShouldBe(1));
}
}
public async Task GivenMemberRepository_WhenCallGetByEmail_ShouldReturnMember()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
var member = await CreateMember(context);
// act
var repo = new MemberRepository(context);
var actualMember = await repo.GetByEmail(member.Email);
// assert
actualMember.ShouldNotBeNull();
actualMember.ShouldSatisfyAllConditions(
() => actualMember.Id.ShouldBe(member.Id),
() => actualMember.MemberAccounts.Count.ShouldBe(0),
() => actualMember.MemberExpense.ShouldNotBeNull(),
() => actualMember.MemberSalary.ShouldNotBeNull());
}
}
public async Task GivenBaseRepository_WhenCallUndoChange_IfEntityIsDeleted_ShouldRollBackEntityState()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
await CreateAccountSingUpStrategy(context);
await context.SaveChangesAsync();
var strategy = await context.AccountSignUpStrategies.FirstAsync();
context.AccountSignUpStrategies.Remove(strategy);
// act
context.UndoChange();
// assert
context.ChangeTracker.Entries().ShouldAllBe(e => e.State == EntityState.Unchanged);
context.AccountSignUpStrategies.ShouldContain(strategy);
}
}
[Fact] public async Task GivenMemberRepository_WhenCallListAll_ShouldSuccess()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
var member1 = MemberDataBuilder.CreateMember(1, new List <MemberAccount>(), null, null, "Rom", "*****@*****.**");
var member2 = MemberDataBuilder.CreateMember(2, new List <MemberAccount>(), null, null, "Shawn", "*****@*****.**");
var member3 = MemberDataBuilder.CreateMember(3, new List <MemberAccount>(), null, null, "Owen", "*****@*****.**");
await context.AddRangeAsync(new[] { member1, member2, member3 });
await context.SaveChangesAsync();
// act
var repo = new MemberRepository(context);
var members = await repo.ListAll(new PaginationRequest { PageSize = 1, PageNumber = 1 }, "n");
// assert
members.ShouldNotBeNull();
members.TotalPageNumber.ShouldBe(2);
members.Data.ShouldContain(m => m.Id == member3.Id);
// act
members = await repo.ListAll(new PaginationRequest { PageSize = 1, PageNumber = 2 }, "n");
// assert
members.ShouldNotBeNull();
members.TotalPageNumber.ShouldBe(2);
members.Data.ShouldContain(m => m.Id == member2.Id);
// act
members = await repo.ListAll(new PaginationRequest { PageSize = 2, PageNumber = 1 }, "n");
// assert
members.ShouldNotBeNull();
members.TotalPageNumber.ShouldBe(1);
members.Data.ShouldContain(m => m.Id == member2.Id);
members.Data.ShouldContain(m => m.Id == member3.Id);
}
}
public async Task GivenQueryExtension_WhenCallListByPaging_IfDataSetIsNotEmpty_ShouldReturnPaginationResponse(
int pageSize, int pageNumber, int totalPageNumber, string[] expectedResult)
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
context.AccountSignUpStrategies.Add(AccountSignUpStrategyDataBuilder.CreateAccountSignUpStrategy(10, name: "One"));
context.AccountSignUpStrategies.Add(AccountSignUpStrategyDataBuilder.CreateAccountSignUpStrategy(11, name: "Two"));
context.AccountSignUpStrategies.Add(AccountSignUpStrategyDataBuilder.CreateAccountSignUpStrategy(12, name: "Three"));
context.AccountSignUpStrategies.Add(AccountSignUpStrategyDataBuilder.CreateAccountSignUpStrategy(13, name: "Four"));
context.AccountSignUpStrategies.Add(AccountSignUpStrategyDataBuilder.CreateAccountSignUpStrategy(14, name: "Five"));
await context.SaveChangesAsync();
// act
var result = await context.AccountSignUpStrategies
.OrderBy(a => a.Id)
.ListByPaging(pageSize, pageNumber);
// assert
result.TotalPageNumber.ShouldBe(totalPageNumber);
result.Data.Count().ShouldBe(expectedResult.Length);
result.Data.Select(a => a.Name).Intersect(expectedResult).Count().ShouldBe(expectedResult.Length);
}
}
public async Task GivenAccountSignUpStrategyRepository_WhenCallGetById_ShouldReturnAccountSignUpStrategy()
{
using (var context = await InMemoryDbContextFactory.CreateUserContext())
{
// assign
await context.AccountSignUpStrategies.AddAsync(
new AccountSignUpStrategy
{
IsDefault = true,
Name = "Master Program",
MonthNetIncomeLimit = 100
});
await context.SaveChangesAsync();
// act
var repo = new AccountSignUpStrategyRepository(context);
var actualAccountStrategy = await repo.GetDefaultStrategy();
// assert
actualAccountStrategy.ShouldNotBeNull();
actualAccountStrategy.IsDefault.ShouldBeTrue();
}
}
