public async Task FetchInvitationsAsync_WithClanId_ShouldBeOfTypeInvitationList() { // Arrange var clanId = new ClanId(); TestMock.InvitationRepository.Setup(repository => repository.FetchAsync(It.IsAny <ClanId>())) .ReturnsAsync( new List <Invitation> { new Invitation(new UserId(), clanId), new Invitation(new UserId(), clanId), new Invitation(new UserId(), clanId) }) .Verifiable(); var service = new InvitationService(TestMock.InvitationRepository.Object, TestMock.ClanRepository.Object); // Act var result = await service.FetchInvitationsAsync(new ClanId()); // Assert result.Should().BeOfType <List <Invitation> >(); TestMock.InvitationRepository.Verify(repository => repository.FetchAsync(It.IsAny <ClanId>()), Times.Once); }
public async Task FetchDivisionsAsync_ShouldBeOfTypeOkObjectResult() { // Arrange var clanId = new ClanId(); TestMock.ClanService.Setup(clanService => clanService.FetchDivisionsAsync(It.IsAny <ClanId>())) .ReturnsAsync( new List <Division> { new Division(clanId, "Test", "Division"), new Division(clanId, "Test", "Division"), new Division(clanId, "Test", "Division") }) .Verifiable(); var clanDivisionsController = new ClanDivisionsController(TestMock.ClanService.Object, TestMapper) { ControllerContext = { HttpContext = MockHttpContextAccessor.GetInstance() } }; // Act var result = await clanDivisionsController.FetchDivisionsAsync(clanId); // Assert result.Should().BeOfType <OkObjectResult>(); TestMock.ClanService.Verify(clanService => clanService.FetchDivisionsAsync(It.IsAny <ClanId>()), Times.Once); }
public Division(ClanId clanId, string name, string description) : this() { ClanId = clanId; Name = name; Description = description; Members = new HashSet <Member>(); }
public async Task DeleteInvitationsAsync_WithClanId() { // Arrange var clanId = new ClanId(); TestMock.InvitationRepository.Setup(repository => repository.FetchAsync(It.IsAny <ClanId>())) .ReturnsAsync( new List <Invitation> { new Invitation(new UserId(), clanId), new Invitation(new UserId(), clanId), new Invitation(new UserId(), clanId) }) .Verifiable(); TestMock.InvitationRepository.Setup(repository => repository.Delete(It.IsAny <Invitation>())).Verifiable(); TestMock.InvitationRepository.Setup(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask) .Verifiable(); var service = new InvitationService(TestMock.InvitationRepository.Object, TestMock.ClanRepository.Object); // Act await service.DeleteInvitationsAsync(new ClanId()); // Assert TestMock.InvitationRepository.Verify(repository => repository.FetchAsync(It.IsAny <ClanId>()), Times.Once); TestMock.InvitationRepository.Verify(repository => repository.Delete(It.IsAny <Invitation>()), Times.Exactly(3)); TestMock.InvitationRepository.Verify(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()), Times.Once); }
public void Contructor_Tests() { // Arrange var ownerId = new UserId(); var clanId = new ClanId(); var name = "test"; var description = "division"; // Act var division = new Division(clanId, name, description); // Assert division.Id.Should().BeOfType(typeof(DivisionId)); division.Name.Should().Be(name); division.Name.Should().NotBeNull(); division.Description.Should().Be(description); division.Description.Should().NotBeNull(); division.Members.Should().BeOfType(typeof(HashSet <Member>)); division.Members.Should().HaveCount(0); division.Members.Should().NotBeNull(); }
public async Task <IActionResult> UploadLogoAsync(ClanId clanId, [FromForm] IFormFile logo) { var userId = HttpContext.GetUserId(); var clan = await _clanService.FindClanAsync(clanId); if (clan == null) { return(this.NotFound("Clan does not exist.")); } var result = await _clanService.UploadLogoAsync( clan, userId, logo.OpenReadStream(), logo.FileName); if (result.IsValid) { return(this.Ok("The logo has been uploaded.")); } result.AddToModelState(ModelState); return(this.BadRequest(new ValidationProblemDetails(ModelState))); }
public async Task <DomainValidationResult <Invitation> > SendInvitationAsync(ClanId clanId, UserId userId, UserId ownerId) { var result = new DomainValidationResult <Invitation>(); if (!await _clanRepository.IsOwnerAsync(clanId, ownerId)) { result.AddDebugError("Permission required."); } if (await _clanRepository.IsMemberAsync(userId)) { result.AddDebugError("Target already in a clan."); } if (await _invitationRepository.ExistsAsync(ownerId, clanId)) { result.AddFailedPreconditionError("The invitation from this clan to that member already exist."); } if (result.IsValid) { var invitation = new Invitation(userId, clanId); _invitationRepository.Create(invitation); await _invitationRepository.UnitOfWork.CommitAsync(); return(invitation); } return(result); }
public async Task <IActionResult> RemoveMemberFromDivisionAsync(ClanId clanId, DivisionId divisionId, MemberId memberId) { var userId = HttpContext.GetUserId(); var clan = await _clanService.FindClanAsync(clanId); if (clan == null) { return(this.NotFound("Clan does not exist.")); } var result = await _clanService.RemoveMemberFromDivisionAsync( clan, userId, divisionId, memberId); if (result.IsValid) { return(this.Ok("The division has been removed.")); } result.AddToModelState(ModelState); return(this.BadRequest(new ValidationProblemDetails(ModelState))); }
public async Task <IActionResult> UpdateDivisionAsync(ClanId clanId, DivisionId divisionId, UpdateDivisionRequest request) { var userId = HttpContext.GetUserId(); var clan = await _clanService.FindClanAsync(clanId); if (clan == null) { return(this.NotFound("Clan does not exist.")); } var result = await _clanService.UpdateDivisionAsync( clan, userId, divisionId, request.Name, request.Description); if (result.IsValid) { return(this.Ok("Division Updated.")); } result.AddToModelState(ModelState); return(this.BadRequest(new ValidationProblemDetails(ModelState))); }
public async Task AddMemberToClanAsync(ClanId clanId, IMemberInfo memberInfo) { var clan = await _clanRepository.FindClanAsync(clanId) ?? throw new InvalidOperationException(nameof(this.AddMemberToClanAsync)); clan.AddMember(memberInfo); await _clanRepository.UnitOfWork.CommitAsync(); }
public void Validate_WhenClanIdIsValid_ShouldNotHaveValidationErrorFor(ClanId clanId) { // Arrange var validator = new InvitationPostRequestValidator(); // Act - Assert validator.ShouldNotHaveValidationErrorFor(request => request.ClanId, clanId.ToString()); }
public async Task DeleteCandidaturesAsync(ClanId clanId) { foreach (var candidature in await this.FetchCandidaturesAsync(clanId)) { _candidatureRepository.Delete(candidature); } await _candidatureRepository.UnitOfWork.CommitAsync(); }
private async Task <HttpResponseMessage> ExecuteAsync(ClanId clanId, FileStream file) { return(await _httpClient.PostAsync( $"api/clans/{clanId}/logo", new MultipartFormDataContent { { new StreamContent(file), "logo", "edoxa.png" } })); }
public async Task DeleteInvitationsAsync(ClanId clanId) { foreach (var invitation in await this.FetchInvitationsAsync(clanId)) { _invitationRepository.Delete(invitation); } await _invitationRepository.UnitOfWork.CommitAsync(); }
public async Task UploadLogoAsync(ClanId clanId, Stream stream, string fileName) { var container = _storageAccount.GetBlobContainer(); var directory = container.GetDirectoryReference($"organizations/clans/{clanId}/logo"); var blockBlob = directory.GetBlockBlobReference($"{new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds()}{Path.GetExtension(fileName)}"); await blockBlob.UploadFromStreamAsync(stream); }
public async Task DeleteLogoAsync(ClanId clanId) { var container = _storageAccount.GetBlobContainer(); var directory = container.GetDirectoryReference($"organizations/clans/{clanId}/logo"); foreach (var blockBlob in directory.ListBlobs().Cast <CloudBlockBlob>().ToList()) { await blockBlob.DeleteIfExistsAsync(); } }
private async Task DeleteInvitationsAsync(ClanId clanId) { try { await _candidatureService.DeleteCandidaturesAsync(clanId); } catch (Exception exception) { _logger.LogCritical(exception, "The clan's user candidatures have not been deleted correctly."); } }
public async Task <IActionResult> FetchDivisionsAsync(ClanId clanId) { var divisions = await _clanService.FetchDivisionsAsync(clanId); if (!divisions.Any()) { return(this.NoContent()); } return(this.Ok(_mapper.Map <IEnumerable <DivisionDto> >(divisions))); }
public async Task <IActionResult> FindClanAsync(ClanId clanId) { var clan = await _clanService.FindClanAsync(clanId); if (clan == null) { return(this.NotFound("Clan not found.")); } return(this.Ok(_mapper.Map <ClanDto>(clan))); }
/// <summary> /// Returns the <see cref="Clan"/> that matches the id. /// </summary> /// <param name="id"></param> /// <returns></returns> /// <exception cref="ArgumentException"><paramref name="id"/> must be a valid <see cref="ClanId"/>.</exception> public static Clan GetClanById(ClanId id) { var result = ClanList.FirstOrDefault <Clan>(c => c.ClanId == id); if (result == null) { throw new ArgumentException(nameof(id), "Must be a valid " + nameof(ClanId)); } return(result); }
public void HasMember_WithMemberId_ShouldBeTrue() { // Arrange var clanId = new ClanId(); var division = new Division(clanId, "test", "division"); division.AddMember(new Member(clanId, new UserId())); var memberId = division.Members.SingleOrDefault()?.Id; // Act Assert division.HasMember(memberId).Should().BeTrue(); }
public async Task HandleAsync_WhenClanMemberRemovedIntegrationEventIsValid_ShouldBeCompletedTask() { // Arrange var userId = new UserId(); var clanId = new ClanId(); var user = new User(); var mockLogger = new MockLogger <ClanMemberRemovedIntegrationEventHandler>(); TestMock.UserService.Setup(userService => userService.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(user).Verifiable(); TestMock.UserService.Setup(userService => userService.RemoveClaimAsync(It.IsAny <User>(), It.IsAny <Claim>())) .ReturnsAsync(new IdentityResult()) .Verifiable(); var handler = new ClanMemberRemovedIntegrationEventHandler(TestMock.UserService.Object, mockLogger.Object); var integrationEvent = new ClanMemberRemovedIntegrationEvent { Clan = new ClanDto { Id = clanId, Name = "testClan", OwnerId = userId, Summary = null, Members = { new MemberDto { ClanId = clanId, Id = new MemberId(), UserId = userId } } }, UserId = userId }; // Act await handler.HandleAsync(integrationEvent); // Assert TestMock.UserService.Verify(userService => userService.FindByIdAsync(It.IsAny <string>()), Times.Once); TestMock.UserService.Verify(userService => userService.RemoveClaimAsync(It.IsAny <User>(), It.IsAny <Claim>()), Times.Once); mockLogger.Verify(Times.Once()); }
public void Update_WithParameters_ShouldChange(string name, string description) { // Arrange var clanId = new ClanId(); var division = new Division(clanId, "test", "division"); // Act division.Update(name, description); // Assert division.Name.Should().Be(name); division.Name.Should().NotBeNull(); division.Description.Should().Be(description); division.Description.Should().NotBeNull(); }
public void AddMember_WithAmount_ShouldHaveCount(int amount) { // Arrange var clanId = new ClanId(); var division = new Division(clanId, "test", "division"); // Act for (var i = 0; i < amount; i++) { division.AddMember(new Member(clanId, new UserId())); } // Assert division.Members.Should().NotBeNull(); division.Members.Should().HaveCount(amount); }
public void Contructor_Tests() { // Arrange var userId = new UserId(); var clanId = new ClanId(); // Act var candidature = new Candidature(userId, clanId); // Assert candidature.Id.Should().BeOfType(typeof(CandidatureId)); candidature.UserId.Should().Be(userId); candidature.UserId.Should().NotBeNull(); candidature.ClanId.Should().Be(clanId); candidature.ClanId.Should().NotBeNull(); }
public async Task <IActionResult> FetchMembersAsync(ClanId clanId) { var clan = await _clanService.FindClanAsync(clanId); if (clan == null) { return(this.NotFound("Clan not found.")); } var members = await _clanService.FetchMembersAsync(clan); if (!members.Any()) { return(this.NoContent()); } return(this.Ok(_mapper.Map <IEnumerable <MemberDto> >(members))); }
public void Contructor_Tests() { // Arrange var userId = new UserId(); var clanId = new ClanId(); // Act var invitation = new Invitation(userId, clanId); // Assert invitation.Id.Should().BeOfType(typeof(InvitationId)); invitation.UserId.Should().Be(userId); invitation.UserId.Should().NotBeNull(); invitation.ClanId.Should().Be(clanId); invitation.ClanId.Should().NotBeNull(); }
public void Contructor_WithInvitation_Tests() { // Arrange var userId = new UserId(); var clanId = new ClanId(); // Act var member = new Member(new Invitation(userId, clanId)); // Assert member.Id.Should().BeOfType(typeof(MemberId)); member.UserId.Should().Be(userId); member.UserId.Should().NotBeNull(); member.ClanId.Should().Be(clanId); member.ClanId.Should().NotBeNull(); }
public async Task <IActionResult> DownloadLogoAsync(ClanId clanId) { var clan = await _clanService.FindClanAsync(clanId); if (clan == null) { return(this.NotFound("Clan doesn't exist.")); } var logo = await _clanService.DownloadLogoAsync(clan); if (logo.Length == 0) { return(this.NoContent()); } return(this.File(logo, "application/octet-stream")); }
public override global::System.Int32 GetHashCode() { unchecked { int hash = 5; hash ^= 397 * ClanId.GetHashCode(); hash ^= 397 * CreatedAt.GetHashCode(); hash ^= 397 * MembersCount.GetHashCode(); if (Name != null) { hash ^= 397 * Name.GetHashCode(); } if (Tag != null) { hash ^= 397 * Tag.GetHashCode(); } return(hash); } }