public async Task <DomainValidationResult <Doxatag> > ChangeDoxatagAsync(User user, string doxatagName)
{
var result = new DomainValidationResult <Doxatag>();
if (result.IsValid)
{
var codes = await _doxatagRepository.FetchDoxatagCodesByNameAsync(doxatagName);
var code = Doxatag.GenerateUniqueCode(codes);
var doxatag = new Doxatag(
UserId.FromGuid(user.Id),
doxatagName,
code,
new UtcNowDateTimeProvider());
_doxatagRepository.Create(doxatag);
await _doxatagRepository.UnitOfWork.CommitAsync();
return(doxatag);
}
return(result);
}
private static DoxatagDto MapDoxatag(Doxatag doxatag)
{
return(new DoxatagDto
{
Code = doxatag.Code,
Name = doxatag.Name,
UserId = doxatag.UserId.ToString()
});
}
public async Task ChangeDoxatagAsync_ShouldBeOkObjectResult()
{
// Arrange
var user = new User
{
Id = Guid.NewGuid()
};
var doxatag = new Doxatag(
UserId.FromGuid(user.Id),
"Name",
1000,
new UtcNowDateTimeProvider());
TestMock.UserService.Setup(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(user).Verifiable();
TestMock.DoxatagService.Setup(doxatagService => doxatagService.ChangeDoxatagAsync(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(DomainValidationResult <Doxatag> .Succeeded(doxatag))
.Verifiable();
var controller = new DoxatagHistoryController(TestMock.UserService.Object, TestMock.DoxatagService.Object, TestMapper);
var request = new ChangeDoxatagRequest
{
Name = doxatag.Name
};
// Act
var result = await controller.ChangeDoxatagAsync(request);
// Assert
result.Should().BeOfType <OkObjectResult>();
TestMock.UserService.Verify(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>()), Times.Once);
TestMock.DoxatagService.Verify(doxatagService => doxatagService.ChangeDoxatagAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Once);
}
public async Task FetchDoxatagHistoryAsync_ShouldBeOkObjectResult()
{
// Arrange
var user = new User
{
Id = Guid.NewGuid()
};
var doxatag = new Doxatag(
UserId.FromGuid(user.Id),
"Name",
1000,
new UtcNowDateTimeProvider());
var doxatagHistory = new List <Doxatag>
{
doxatag
};
TestMock.UserService.Setup(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(user).Verifiable();
TestMock.DoxatagService.Setup(doxatagService => doxatagService.FetchDoxatagHistoryAsync(It.IsAny <User>())).ReturnsAsync(doxatagHistory).Verifiable();
var controller = new DoxatagHistoryController(TestMock.UserService.Object, TestMock.DoxatagService.Object, TestMapper);
// Act
var result = await controller.FetchDoxatagHistoryAsync();
// Assert
result.Should().BeOfType <OkObjectResult>();
result.As <OkObjectResult>().Value.Should().BeEquivalentTo(TestMapper.Map <IEnumerable <DoxatagDto> >(doxatagHistory));
TestMock.UserService.Verify(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>()), Times.Once);
TestMock.DoxatagService.Verify(doxatagService => doxatagService.FetchDoxatagHistoryAsync(It.IsAny <User>()), Times.Once);
}
public async Task Success()
{
// Arrange
var mockServiceBusPubliser = new Mock <IServiceBusPublisher>();
mockServiceBusPubliser.Setup(serviceBusPubliser => serviceBusPubliser.PublishAsync(It.IsAny <ChallengeParticipantRegisteredIntegrationEvent>()))
.Verifiable();
var user = new User
{
Id = Guid.NewGuid(),
Email = "*****@*****.**",
EmailConfirmed = true,
UserName = "******",
Country = Country.Canada
};
var account = new Account(user.Id.ConvertTo <UserId>());
var moneyAccount = new MoneyAccountDecorator(account);
moneyAccount.Deposit(Money.TwoHundred).MarkAsSucceeded();
var doxatag = new Doxatag(
account.Id,
"TestUser",
1000,
new UtcNowDateTimeProvider());
var gamePlayerId = new PlayerId();
var challenge = new Challenge(
new ChallengeId(),
new ChallengeName("TestChallenge"),
Game.LeagueOfLegends,
BestOf.One,
Entries.Two,
new ChallengeTimeline(new UtcNowDateTimeProvider(), ChallengeDuration.OneDay),
Scoring);
var payout = new ChallengePayoutFactory();
var challengePayout = new Cashier.Domain.AggregateModels.ChallengeAggregate.Challenge(
challenge.Id,
payout.CreateInstance().GetChallengePayout(ChallengePayoutEntries.One, MoneyEntryFee.OneHundred));
using var gamesHost = new GamesHostFactory().WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, account.Id));
gamesHost.Server.CleanupDbContext();
await gamesHost.Server.UsingScopeAsync(
async scope =>
{
var gameCredentialRepository = scope.GetRequiredService <IGameCredentialRepository>();
gameCredentialRepository.CreateCredential(
new Credential(
account.Id,
challenge.Game,
gamePlayerId,
new UtcNowDateTimeProvider()));
await gameCredentialRepository.UnitOfWork.CommitAsync(false);
});
var gameServiceClient = new GameService.GameServiceClient(gamesHost.CreateChannel());
using var challengesHost = new ChallengesHostFactory().WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, account.Id))
.WithWebHostBuilder(
builder =>
{
builder.ConfigureTestContainer <ContainerBuilder>(
container =>
{
container.RegisterInstance(mockServiceBusPubliser.Object).As <IServiceBusPublisher>().SingleInstance();
});
});
challengesHost.Server.CleanupDbContext();
await challengesHost.Server.UsingScopeAsync(
async scope =>
{
var challengeRepository = scope.GetRequiredService <IChallengeRepository>();
challengeRepository.Create(challenge);
await challengeRepository.CommitAsync(false);
});
var challengeServiceClient = new ChallengeService.ChallengeServiceClient(challengesHost.CreateChannel());
using var cashierHost = new CashierHostFactory().WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, account.Id));
cashierHost.Server.CleanupDbContext();
await cashierHost.Server.UsingScopeAsync(
async scope =>
{
var accountRepository = scope.GetRequiredService <IAccountRepository>();
accountRepository.Create(account);
await accountRepository.CommitAsync();
});
await cashierHost.Server.UsingScopeAsync(
async scope =>
{
var challengeRepository = scope.GetRequiredService <IChallengePayoutRepository>();
challengeRepository.Create(challengePayout);
await challengeRepository.CommitAsync();
});
var cashierServiceClient = new CashierService.CashierServiceClient(cashierHost.CreateChannel());
using var identityHost = new IdentityHostFactory();
identityHost.Server.CleanupDbContext();
await identityHost.Server.UsingScopeAsync(
async scope =>
{
var doxatagRepository = scope.GetRequiredService <IUserService>();
await doxatagRepository.CreateAsync(user, "Pass@word1");
});
await identityHost.Server.UsingScopeAsync(
async scope =>
{
var doxatagRepository = scope.GetRequiredService <IDoxatagRepository>();
doxatagRepository.Create(doxatag);
await doxatagRepository.UnitOfWork.CommitAsync(false);
});
var identityServiceClient = new IdentityService.IdentityServiceClient(identityHost.CreateChannel());
using var challengesAggregatorHost = new ChallengesWebAggregatorHostFactory()
.WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, account.Id))
.WithWebHostBuilder(
builder =>
{
builder.ConfigureTestContainer <ContainerBuilder>(
container =>
{
container.RegisterInstance(challengeServiceClient).SingleInstance();
container.RegisterInstance(cashierServiceClient).SingleInstance();
container.RegisterInstance(identityServiceClient).SingleInstance();
container.RegisterInstance(gameServiceClient).SingleInstance();
});
});
var client = challengesAggregatorHost.CreateClient();
// Act
var response = await client.PostAsJsonAsync(
$"api/challenges/{challenge.Id}/participants",
new
{
});
// Assert
response.EnsureSuccessStatusCode();
mockServiceBusPubliser.Verify(
serviceBusPubliser => serviceBusPubliser.PublishAsync(It.IsAny <ChallengeParticipantRegisteredIntegrationEvent>()),
Times.Once);
}
