public void GetHashCode_ShouldNotBeZero()
{
// Arrange
var factory = new ChallengePayoutFactory();
var instance = factory.CreateInstance();
var payout = instance.GetChallengePayout(ChallengePayoutEntries.OneHundred, new EntryFee(500, CurrencyType.Money));
// Act Assert
payout.GetHashCode().Should().NotBe(0);
}
public void CreateInstance_WithPayoutStrategy_ShouldNotBeNull()
{
// Arrange
var payoutFactory = new ChallengePayoutFactory(TestMock.ChallengePayoutStrategy.Object);
// Act
var payoutStrategy = payoutFactory.CreateInstance();
// Assert
payoutStrategy.Should().NotBeNull();
}
public async Task HandleAsync_ChallengeSynchronizedIntegrationEventIsValid_ShouldBeCompletedTask()
{
// Arrange
var challengeId = new ChallengeId();
var factory = new ChallengePayoutFactory();
var strategy = factory.CreateInstance();
var payout = strategy.GetChallengePayout(ChallengePayoutEntries.Five, MoneyEntryFee.Fifty);
var challenge = new Challenge(challengeId, payout);
var mockLogger = new MockLogger <ChallengeSynchronizedIntegrationEventHandler>();
TestMock.ChallengeService.Setup(challengeService => challengeService.ChallengeExistsAsync(It.IsAny <ChallengeId>())).ReturnsAsync(true).Verifiable();
TestMock.ChallengeService.Setup(challengeService => challengeService.FindChallengeAsync(It.IsAny <ChallengeId>()))
.ReturnsAsync(challenge)
.Verifiable();
TestMock.ChallengeService
.Setup(
challengeService => challengeService.CloseChallengeAsync(
It.IsAny <IChallenge>(),
It.IsAny <Dictionary <UserId, decimal?> >(),
It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
var handler = new ChallengeSynchronizedIntegrationEventHandler(TestMock.ChallengeService.Object, mockLogger.Object);
var integrationEvent = new ChallengeSynchronizedIntegrationEvent
{
ChallengeId = new ChallengeId()
};
// Act
await handler.HandleAsync(integrationEvent);
// Assert
TestMock.ChallengeService.Verify(challengeService => challengeService.ChallengeExistsAsync(It.IsAny <ChallengeId>()), Times.Once);
TestMock.ChallengeService.Verify(challengeService => challengeService.FindChallengeAsync(It.IsAny <ChallengeId>()), Times.Once);
TestMock.ChallengeService.Verify(
challengeService => challengeService.CloseChallengeAsync(
It.IsAny <IChallenge>(),
It.IsAny <Dictionary <UserId, decimal?> >(),
It.IsAny <CancellationToken>()),
Times.Once);
mockLogger.Verify(Times.Once());
}
public void ToString_ShouldNotBeNullOrEmpty()
{
// Arrange
var factory = new ChallengePayoutFactory(new DefaultChallengePayoutStrategy());
var instance = factory.CreateInstance();
var payout = instance.GetChallengePayout(ChallengePayoutEntries.OneHundred, new EntryFee(500, CurrencyType.Money));
// Act
var result = payout.ToString();
// Assert
result.Should().NotBeNullOrEmpty();
}
public void ChallengeScoreboard_Constructor_ShouldHaveCount(Dictionary <UserId, decimal?> scoreboard, int winnerCount, int loserCount)
{
// Arrange
var factory = new ChallengePayoutFactory();
var instance = factory.CreateInstance();
var entries = scoreboard.Count;
var payoutEntries = entries / 2;
// Act
var challengeScoreboard = new ChallengeScoreboard(
instance.GetChallengePayout(new ChallengePayoutEntries(payoutEntries), new EntryFee(100, CurrencyType.Money)),
scoreboard);
// Assert
challengeScoreboard.Winners.Should().HaveCount(winnerCount);
challengeScoreboard.Losers.Should().HaveCount(loserCount);
}
public void Close_DomainEvents_ShouldHaveCountOfParticipantWithScore(Dictionary <UserId, decimal?> scoreboard)
{
// Arrange
var factory = new ChallengePayoutFactory();
var instance = factory.CreateInstance();
var challenge = new Challenge(
new ChallengeId(),
instance.GetChallengePayout(new ChallengePayoutEntries(scoreboard.Count / 2), new EntryFee(100, CurrencyType.Money)));
var challengeScoreboard = new ChallengeScoreboard(challenge.Payout, scoreboard);
var participantCount = scoreboard.Count(participant => participant.Value != null);
// Act
challenge.Close(challengeScoreboard);
// Assert
challenge.DomainEvents.Where(domainEvent => domainEvent is ChallengeParticipantPayoutDomainEvent).Should().HaveCount(participantCount);
}
public void GetHashCode_ShouldNotBeZero()
{
// Arrange
var challengeId = new ChallengeId();
var factory = new ChallengePayoutFactory();
var instance = factory.CreateInstance();
var scoreboard = new Dictionary <UserId, decimal?>
{
{ new UserId(), 50 },
{ new UserId(), 100 }
};
var challenge = new Challenge(
challengeId,
instance.GetChallengePayout(new ChallengePayoutEntries(scoreboard.Count / 2), new EntryFee(100, CurrencyType.Money)));
// Act Assert
challenge.GetHashCode().Should().NotBe(0);
}
public void Equals_WithSameId_ShouldBeTrue()
{
// Arrange
var challengeId = new ChallengeId();
var factory = new ChallengePayoutFactory();
var instance = factory.CreateInstance();
var scoreboard = new Dictionary <UserId, decimal?>
{
{ new UserId(), 50 },
{ new UserId(), 100 }
};
var challenge1 = new Challenge(
challengeId,
instance.GetChallengePayout(new ChallengePayoutEntries(scoreboard.Count / 2), new EntryFee(100, CurrencyType.Money)));
var challenge2 = new Challenge(
challengeId,
instance.GetChallengePayout(new ChallengePayoutEntries(scoreboard.Count / 2), new EntryFee(100, CurrencyType.Money)));
// Act Assert
challenge1.Equals(challenge2).Should().BeTrue();
}
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);
}
