public async Task DeleteDivisionAsync_ShouldBeOfTypeBadRequestObjectResult() { // Arrange var userId = new UserId(); var clan = new Clan("testClan", userId); TestMock.ClanService.Setup(clanService => clanService.FindClanAsync(It.IsAny <ClanId>())).ReturnsAsync(clan).Verifiable(); TestMock.ClanService.Setup(clanService => clanService.DeleteDivisionAsync(It.IsAny <Clan>(), It.IsAny <UserId>(), It.IsAny <DivisionId>())) .ReturnsAsync(DomainValidationResult <Division> .Failure("Test error")) .Verifiable(); var clanDivisionsController = new ClanDivisionsController(TestMock.ClanService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; // Act var result = await clanDivisionsController.DeleteDivisionAsync(new ClanId(), new DivisionId()); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.ClanService.Verify(clanService => clanService.FindClanAsync(It.IsAny <ClanId>()), Times.Once); TestMock.ClanService.Verify( clanService => clanService.DeleteDivisionAsync(It.IsAny <Clan>(), It.IsAny <UserId>(), It.IsAny <DivisionId>()), Times.Once); }
public async Task SendCandidatureAsync_ShouldBeOfTypeBadRequestObjectResult() { // Arrange TestMock.CandidatureService.Setup(clanService => clanService.SendCandidatureAsync(It.IsAny <UserId>(), It.IsAny <ClanId>())) .ReturnsAsync(DomainValidationResult <Candidature> .Failure("Error")) .Verifiable(); var candidatureController = new CandidaturesController(TestMock.CandidatureService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; // Act var result = await candidatureController.SendCandidatureAsync( new SendCandidatureRequest { ClanId = new ClanId(), UserId = new UserId() }); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.CandidatureService.Verify(clanService => clanService.SendCandidatureAsync(It.IsAny <UserId>(), It.IsAny <ClanId>()), Times.Once); }
public async Task CreateClanAsync_ShouldBeOfTypeBadRequestObjectResult() { // Arrange TestMock.ClanService.Setup(clanService => clanService.CreateClanAsync(It.IsAny <UserId>(), It.IsAny <string>())) .ReturnsAsync(DomainValidationResult <Clan> .Failure("Test error")) .Verifiable(); var clansController = new ClansController(TestMock.ClanService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; var request = new CreateClanRequest { Name = "DONTINVADE", Summary = "URSSINWINTER" }; // Act var result = await clansController.CreateClanAsync(request); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.ClanService.Verify(clanService => clanService.CreateClanAsync(It.IsAny <UserId>(), It.IsAny <string>()), Times.Once); }
public async Task LinkCredentialAsync_ShouldBeOfTypeBadRequestObjectResult() { // Arrange TestMock.GameCredentialService.Setup(credentialService => credentialService.LinkCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>())) .ReturnsAsync(DomainValidationResult <Credential> .Failure("test error")) .Verifiable(); var authFactorController = new GameAuthenticationsController( TestMock.GameAuthenticationService.Object, TestMock.GameCredentialService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; // Act var result = await authFactorController.LinkCredentialAsync(Game.LeagueOfLegends); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.GameCredentialService.Verify(credentialService => credentialService.LinkCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>()), Times.Once); }
public async Task KickMemberFromClanAsync_ShouldBeOfTypeBadRequestObjectResult() { // Arrange TestMock.ClanService.Setup(clanService => clanService.FindClanAsync(It.IsAny <ClanId>())).ReturnsAsync(new Clan("Test", new UserId())).Verifiable(); TestMock.ClanService.Setup(clanService => clanService.KickMemberFromClanAsync(It.IsAny <Clan>(), It.IsAny <UserId>(), It.IsAny <MemberId>())) .ReturnsAsync(DomainValidationResult <Member> .Failure("Error")) .Verifiable(); var clanMemberController = new ClanMembersController(TestMock.ClanService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; // Act var result = await clanMemberController.KickMemberFromClanAsync(new ClanId(), new MemberId()); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.ClanService.Verify(clanService => clanService.FindClanAsync(It.IsAny <ClanId>()), Times.Once); TestMock.ClanService.Verify( clanService => clanService.KickMemberFromClanAsync(It.IsAny <Clan>(), It.IsAny <UserId>(), It.IsAny <MemberId>()), Times.Once); }
public async Task AcceptInvitationAsync_ShouldBeOfTypeBadRequestObjectResult() { // Arrange TestMock.InvitationService.Setup(clanService => clanService.FindInvitationAsync(It.IsAny <InvitationId>())) .ReturnsAsync(new Invitation(new UserId(), new ClanId())) .Verifiable(); TestMock.InvitationService.Setup(clanService => clanService.AcceptInvitationAsync(It.IsAny <Invitation>(), It.IsAny <UserId>())) .ReturnsAsync(DomainValidationResult <Invitation> .Failure("Error")) .Verifiable(); var invitationController = new InvitationsController(TestMock.InvitationService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; // Act var result = await invitationController.AcceptInvitationAsync(new InvitationId()); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.InvitationService.Verify(clanService => clanService.FindInvitationAsync(It.IsAny <InvitationId>()), Times.Once); TestMock.InvitationService.Verify(clanService => clanService.AcceptInvitationAsync(It.IsAny <Invitation>(), It.IsAny <UserId>()), Times.Once); }
public override async Task <DomainValidationResult <object> > GenerateAuthenticationAsync(UserId userId, LeagueOfLegendsRequest request) { try { var result = new DomainValidationResult <object>(); var summoner = await _leagueOfLegendsService.Summoner.GetSummonerByNameAsync(Region.Na, request.SummonerName); if (await _gameCredentialRepository.CredentialExistsAsync(PlayerId.Parse(summoner.AccountId), Game)) { result.AddFailedPreconditionError("Summoner's name is already linked by another eDoxa account"); } if (result.IsValid) { if (await _gameAuthenticationRepository.AuthenticationExistsAsync(userId, Game)) { await _gameAuthenticationRepository.RemoveAuthenticationAsync(userId, Game); } var gameAuthentication = await this.GenerateAuthFactor(summoner); await _gameAuthenticationRepository.AddAuthenticationAsync(userId, Game, gameAuthentication); return(gameAuthentication.Factor); } return(result); } catch (RiotSharpException) { return(DomainValidationResult <object> .Failure("Summoner name is invalid")); } }
public async Task <DomainValidationResult <Invitation> > DeclineInvitationAsync(Invitation invitation, UserId userId) { if (invitation.UserId != userId) { return(DomainValidationResult <Invitation> .Failure($"The user {userId} can not decline someone else invitation.")); } _invitationRepository.Delete(invitation); await _invitationRepository.UnitOfWork.CommitAsync(); return(new DomainValidationResult <Invitation>()); }
public async Task <DomainValidationResult <Invitation> > AcceptInvitationAsync(Invitation invitation, UserId userId) { if (invitation.UserId != userId) { return(DomainValidationResult <Invitation> .Failure($"The user {userId} can not accept someone else invitation.")); } invitation.Accept(); await _invitationRepository.UnitOfWork.CommitAsync(); return(new DomainValidationResult <Invitation>()); }
public async Task <DomainValidationResult <Candidature> > DeclineCandidatureAsync(Candidature candidature, UserId userId) { if (!await _clanRepository.IsOwnerAsync(candidature.ClanId, userId)) { return(DomainValidationResult <Candidature> .Failure("Permission required.")); } _candidatureRepository.Delete(candidature); await _candidatureRepository.UnitOfWork.CommitAsync(); return(new DomainValidationResult <Candidature>()); }
public async Task <DomainValidationResult <object> > UploadLogoAsync( Clan clan, UserId userId, Stream stream, string fileName ) { if (!clan.MemberIsOwner(userId)) { return(DomainValidationResult <object> .Failure($"The user ({userId}) isn't the clan owner.")); } await _clanRepository.UploadLogoAsync(clan.Id, stream, fileName); return(new DomainValidationResult <object>()); }
private async Task <DomainValidationResult <ITransaction> > CreateTransactionAsync( IMoneyAccount account, Money money, TransactionType type, TransactionMetadata?metadata = null, CancellationToken cancellationToken = default ) { if (type == TransactionType.Deposit) { return(await this.CreateDepositTransactionAsync(account, money, cancellationToken)); } if (type == TransactionType.Withdraw) { return(await this.CreateWithdrawTransactionAsync(account, money, cancellationToken)); } if (type == TransactionType.Charge) { return(await this.CreateChargeTransactionAsync( account, money, metadata, cancellationToken)); } if (type == TransactionType.Payout) { return(await this.CreatePayoutTransactionAsync( account, money, metadata, cancellationToken)); } if (type == TransactionType.Promotion) { return(await this.CreatePromotionTransactionAsync( account, money, metadata, cancellationToken)); } return(DomainValidationResult <ITransaction> .Failure("Unsupported transaction type for money currency.")); }
public async Task <DomainValidationResult <Member> > AddMemberToDivisionAsync( Clan clan, UserId userId, DivisionId divisionId, MemberId memberId ) { if (!clan.MemberIsOwner(userId)) { return(DomainValidationResult <Member> .Failure($"The user ({userId}) isn't the clan owner.")); } clan.AddMemberToDivision(divisionId, memberId); await _clanRepository.UnitOfWork.CommitAsync(); return(new DomainValidationResult <Member>()); }
public async Task CancelPromotionAsync_ShouldBeBadRequestObjectResult() { // Arrange var promotion = GeneratePromotion(); TestMock.PromotionService .Setup( promotionService => promotionService.FindPromotionOrNullAsync( It.IsAny <string>())) .ReturnsAsync(promotion) .Verifiable(); TestMock.PromotionService .Setup( promotionService => promotionService.CancelPromotionAsync( It.IsAny <Promotion>(), It.IsAny <IDateTimeProvider>())) .ReturnsAsync(DomainValidationResult <Promotion> .Failure("error message")) .Verifiable(); var controller = new PromotionController(TestMock.PromotionService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; // Act var result = await controller.CancelPromotionAsync(TestCode); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.PromotionService.Verify( promotionService => promotionService.FindPromotionOrNullAsync( It.IsAny <string>()), Times.Once); TestMock.PromotionService.Verify( promotionService => promotionService.CancelPromotionAsync( It.IsAny <Promotion>(), It.IsAny <IDateTimeProvider>()), Times.Once); }
public async Task <DomainValidationResult <Division> > UpdateDivisionAsync( Clan clan, UserId userId, DivisionId divisionId, string name, string description ) { if (!clan.MemberIsOwner(userId)) { return(DomainValidationResult <Division> .Failure($"The user ({userId}) isn't the clan owner.")); } clan.UpdateDivision(divisionId, name, description); await _clanRepository.UnitOfWork.CommitAsync(); return(new DomainValidationResult <Division>()); }
public async Task CreatePromotionAsync_ShouldBeBadRequestObjectResult() { // Arrange TestMock.PromotionService .Setup( promotionService => promotionService.CreatePromotionAsync( It.IsAny <string>(), It.IsAny <Currency>(), It.IsAny <TimeSpan>(), It.IsAny <DateTime>())) .ReturnsAsync(DomainValidationResult <Promotion> .Failure("error message")) .Verifiable(); var controller = new PromotionController(TestMock.PromotionService.Object, TestMapper); var request = new CreatePromotionRequest { Currency = new CurrencyDto { Amount = 50, Type = EnumCurrencyType.Money }, Duration = new Duration(), ExpiredAt = DateTime.UtcNow.ToTimestamp(), PromotionalCode = "code1" }; // Act var result = await controller.CreatePromotionAsync(request); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.PromotionService.Verify( promotionService => promotionService.CreatePromotionAsync( It.IsAny <string>(), It.IsAny <Currency>(), It.IsAny <TimeSpan>(), It.IsAny <DateTime>()), Times.Once); }
public async Task ShouldBeHttpStatusCodeBadRequest() { // Arrange var userId = new UserId(); var credential = new Credential( userId, Game.LeagueOfLegends, new PlayerId(), new DateTimeProvider(DateTime.Now)); var factory = TestHost.WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, userId.ToString())) .WithWebHostBuilder( builder => builder.ConfigureTestContainer <ContainerBuilder>( container => { var mockCredentialService = new Mock <IGameCredentialService>(); mockCredentialService.Setup(credentialService => credentialService.FindCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>())) .ReturnsAsync(credential) .Verifiable(); mockCredentialService.Setup(credentialService => credentialService.UnlinkCredentialAsync(It.IsAny <Credential>())) .ReturnsAsync(DomainValidationResult <Credential> .Failure("test", "validation failure test")) .Verifiable(); container.RegisterInstance(mockCredentialService.Object).As <IGameCredentialService>().SingleInstance(); })); _httpClient = factory.CreateClient(); var testServer = factory.Server; testServer.CleanupDbContext(); // Act using var response = await this.ExecuteAsync(Game.LeagueOfLegends); // Assert response.StatusCode.Should().Be(HttpStatusCode.BadRequest); }
public async Task UnlinkCredentialAsync_ShouldBeOfTypeBadRequestObjectResult() { // Arrange var userId = new UserId(); var credential = new Credential( userId, Game.LeagueOfLegends, new PlayerId(), new UtcNowDateTimeProvider()); TestMock.GameCredentialService.Setup(credentialService => credentialService.FindCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>())) .ReturnsAsync(credential) .Verifiable(); TestMock.GameCredentialService.Setup(credentialService => credentialService.UnlinkCredentialAsync(It.IsAny <Credential>())) .ReturnsAsync(DomainValidationResult <Credential> .Failure("test", "test error")) .Verifiable(); var authFactorController = new GameCredentialsController(TestMock.GameCredentialService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; // Act var result = await authFactorController.UnlinkCredentialAsync(Game.LeagueOfLegends); // Assert result.Should().BeOfType <BadRequestObjectResult>(); TestMock.GameCredentialService.Verify(credentialService => credentialService.FindCredentialAsync(It.IsAny <UserId>(), It.IsAny <Game>()), Times.Once); TestMock.GameCredentialService.Verify(credentialService => credentialService.UnlinkCredentialAsync(It.IsAny <Credential>()), Times.Once); }