public void CreateInstance_WithPayoutStrategy_ShouldNotBeNull()
        {
            // Arrange
            var payoutFactory = new ChallengePayoutFactory(TestMock.ChallengePayoutStrategy.Object);

            // Act
            var payoutStrategy = payoutFactory.CreateInstance();

            // Assert
            payoutStrategy.Should().NotBeNull();
        }
Esempio n. 2
0
        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 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());
        }
Esempio n. 4
0
        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);
        }
Esempio n. 6
0
        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);
        }
Esempio n. 7
0
        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);
        }
Esempio n. 8
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);
        }
Esempio n. 10
0
        protected override async Task SeedProductionAsync()
        {
            await this.SeedAdministratorAccountAsync();

            var assemblyPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) !;

            var file = File.OpenRead(Path.Combine(assemblyPath, "Setup/Challenges.Production.csv"));

            using var csvReader = file.OpenCsvReader();

            Challenges.AddRange(
                csvReader.GetRecords(
                    new
            {
                Id = default(Guid),
                EntryFeeCurrency = default(int),
                EntryFeeAmount   = default(decimal),
                Entries          = default(int)
            })
                .Select(
                    record =>
            {
                var payoutStrategy = new ChallengePayoutFactory().CreateInstance();

                var payoutEntries = new ChallengePayoutEntries(record.Entries / 2);

                var currency = CurrencyType.FromValue(record.EntryFeeCurrency) !;

                var entryFee = new EntryFee(record.EntryFeeAmount, currency);

                var payout = payoutStrategy.GetChallengePayout(payoutEntries, entryFee);

                return(new Challenge(record.Id.ConvertTo <ChallengeId>(), payout));
            })
                .Where(challenge => Challenges.All(x => x.Id != challenge.Id))
                .Select(challenge => challenge.ToModel()));

            await this.CommitAsync();

            var startedAt = DateTimeOffset.FromUnixTimeMilliseconds(1582261200000).UtcDateTime;

            var duration = TimeSpan.FromDays(4);

            var promotion1 = new Promotion(
                "DHANA20REDCUP",
                new Money(5),
                duration,
                new DateTimeProvider(startedAt + duration));

            promotion1.SetEntityId(PromotionId.Parse("885cdd1e-0ed9-4fdc-9c29-d48a9d071cfd"));

            var promotion2 = new Promotion(
                "DHANA20TOK",
                new Token(250),
                duration,
                new DateTimeProvider(startedAt + duration));

            promotion2.SetEntityId(PromotionId.Parse("263aa2ed-3f88-4070-96e6-a098814e44f3"));

            var promotions = new List <Promotion>
            {
                promotion1,
                promotion2
            };

            Promotions.AddRange(promotions.Where(promotion => Promotions.All(x => x.Id != promotion.Id)).Select(promotion => promotion.ToModel()));

            await this.CommitAsync();
        }