public async Task UploadLogoAsync_ShouldBeOfTypeValidationResult()
{
// Arrange
var memoryStream = new MemoryStream();
TestMock.ClanRepository.Setup(repository => repository.UploadLogoAsync(It.IsAny <ClanId>(), It.IsAny <Stream>(), It.IsAny <string>()))
.Returns(Task.CompletedTask)
.Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
var ownerId = new UserId();
var clan = new Clan("test", ownerId);
// Act
var result = await service.UploadLogoAsync(
clan,
ownerId,
memoryStream,
"testFile");
// Assert
result.Should().BeOfType <DomainValidationResult <object> >();
TestMock.ClanRepository.Verify(repository => repository.UploadLogoAsync(It.IsAny <ClanId>(), It.IsAny <Stream>(), It.IsAny <string>()), Times.Once);
}
public PlayerService(ApiDbContext context, WowsPublicApiClient wgApi, WowsVortexApiClient vortex, ClanService clanService)
{
_context = context;
_wgApi = wgApi;
_vortex = vortex;
_clanService = clanService;
}
public async Task KickMemberFromClanAsync_ShouldBeOfTypeValidationResult()
{
// Arrange
var ownerId = new UserId();
var clan = new Clan("test", ownerId);
var memberUserId = new UserId();
clan.AddMember(new Member(clan.Id, memberUserId));
var member = clan.FindMember(memberUserId);
TestMock.ClanRepository.Setup(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
var result = await service.KickMemberFromClanAsync(clan, ownerId, member.Id);
// Assert
result.Should().BeOfType <DomainValidationResult <Member> >();
TestMock.ClanRepository.Verify(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task CreateClanAsync_ShouldBeOfTypeValidationResult()
{
// Arrange
TestMock.ClanRepository.Setup(repository => repository.IsMemberAsync(It.IsAny <UserId>())).ReturnsAsync(false).Verifiable();
TestMock.ClanRepository.Setup(repository => repository.ExistsAsync(It.IsAny <string>())).ReturnsAsync(false).Verifiable();
TestMock.ClanRepository.Setup(repository => repository.Create(It.IsAny <Clan>())).Verifiable();
TestMock.ClanRepository.Setup(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
var result = await service.CreateClanAsync(new UserId(), "test clan");
// Assert
result.Should().BeOfType <DomainValidationResult <Clan> >();
TestMock.ClanRepository.Verify(repository => repository.IsMemberAsync(It.IsAny <UserId>()), Times.Once);
TestMock.ClanRepository.Verify(repository => repository.ExistsAsync(It.IsAny <string>()), Times.Once);
TestMock.ClanRepository.Verify(repository => repository.Create(It.IsAny <Clan>()), Times.Once);
TestMock.ClanRepository.Verify(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task <IActionResult> GetDiplomacies()
{
if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView))
{
return(Ok(await ClanService.RetrieveDiplomacies(accountSessionView.AccountID)));
}
return(Ok(ValidatedView <List <ClanDiplomacyView> > .Invalid(ErrorCode.OPERATION_FAILED)));
}
public async Task <IActionResult> AssingRole(int id, int role)
{
if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView))
{
return(Ok(await ClanService.AssignRole(accountSessionView.AccountID, id, (ClanRole)role)));
}
return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)));
}
public async Task <IActionResult> GetPending()
{
if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView))
{
return(Ok(await ClanService.RetrievePendingFromMember(accountSessionView.AccountID)));
}
return(Ok(ValidatedView <List <AccountClanView> > .Invalid(ErrorCode.OPERATION_FAILED)));
}
public async Task <IActionResult> Leave()
{
if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView))
{
return(Ok(await ClanService.Leave(accountSessionView.AccountID)));
}
return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)));
}
public async Task <IActionResult> RejectJoinRequest(int id)
{
if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView))
{
return(Ok(await ClanService.RejectJoinRequest(accountSessionView.AccountID, id)));
}
return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)));
}
public async Task <IActionResult> Post([FromBody] ClanCreateView clanCreateView)
{
if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView))
{
return(Ok(await ClanService.CreateClan(accountSessionView.AccountID, clanCreateView)));
}
return(Ok(ValidatedView.Invalid(ErrorCode.OPERATION_FAILED)));
}
public async Task <IActionResult> Get([FromQuery] string query, [FromQuery] int offset, [FromQuery] int count)
{
if (HttpContext.TryGetCurrentSession(out AccountSessionView accountSessionView))
{
return(Ok(await ClanService.RetrieveClans(accountSessionView.AccountID, (query ?? "").ToLower(), offset, count)));
}
return(Ok(ValidatedView <EnumerableResultView <ClanView> > .Invalid(ErrorCode.OPERATION_FAILED)));
}
protected void Confirm()
{
if (!ClanService.Edit(new ClanCreateView {
Name = Name,
Tag = Tag,
Description = Description
}, out string message, out HttpStatusCode code))
{
NotificationService.ShowError(message, "Failed to change clan informations!");
}
protected void Confirm()
{
if (!ClanService.CreateJoinRequest(
new ClanJoinView {
ClanID = Clan.ID, Description = Description
},
out string message, out HttpStatusCode code))
{
NotificationService.ShowError(message, "Failed to send join request!");
}
private static async Task <bool> CallListClanMembers()
{
var svc = new ClanService();
var task = svc.ListClanMembers("#YP9U0J");
await Task.WhenAll(task);
Console.WriteLine("Done...");
return(true);
}
protected void Refresh()
{
if (!ClanService.RetrieveDiplomacies(out List <ClanDiplomacyView> diplomacies, out string message, out HttpStatusCode code))
{
NotificationService.ShowError(message, "Failed to load diplomacies!");
if (code == HttpStatusCode.Unauthorized)
{
ComponentService.Show(new Login());
}
else
{
ComponentService.Show(new CriticalError());
}
}
else
{
Diplomacies = diplomacies;
}
if (!ClanService.RetrievePendingDiplomacies(out List <ClanDiplomacyView> pending, out message, out code))
{
NotificationService.ShowError(message, "Failed to load pending diplomacies!");
if (code == HttpStatusCode.Unauthorized)
{
ComponentService.Show(new Login());
}
else
{
ComponentService.Show(new CriticalError());
}
}
else
{
Pending = pending;
}
if (!ClanService.RetrieveSelf(out AccountClanView account, out message, out code))
{
NotificationService.ShowError(message, "Failed to load self!");
if (code == HttpStatusCode.Unauthorized)
{
ComponentService.Show(new Login());
}
else
{
ComponentService.Show(new CriticalError());
}
}
else
{
Current = account;
}
}
public async Task DeleteLogoAsync()
{
// Arrange
TestMock.ClanRepository.Setup(repository => repository.DeleteLogoAsync(It.IsAny <ClanId>())).Returns(Task.CompletedTask).Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
await service.DeleteLogoAsync(new ClanId());
// Assert;
TestMock.ClanRepository.Verify(repository => repository.DeleteLogoAsync(It.IsAny <ClanId>()), Times.Once);
}
public async Task IsMemberAsync()
{
// Arrange
var service = new ClanService(TestMock.ClanRepository.Object);
TestMock.ClanRepository.Setup(repository => repository.IsMemberAsync(It.IsAny <UserId>())).ReturnsAsync(true).Verifiable();
// Act
await service.IsMemberAsync(new UserId());
// Assert
TestMock.ClanRepository.Verify(repository => repository.IsMemberAsync(It.IsAny <UserId>()), Times.Once);
}
private Task LeaveClanAsync()
{
if (clan == null || Player == null)
{
return(Task.CompletedTask);
}
return(Task.Run(() =>
{
ClanService.RemoveMember(clan.Id, Player.Id);
InvokeAsync(() => NavigationManager.NavigateTo("/characters", true));
}));
}
private static async Task <bool> CallRetreiveInformationAboutClansCurrentWar()
{
var svc = new ClanService();
var task = svc.RetrieveInformationAboutClansCurrentWar("#88GYPPRQ");
await Task.WhenAll(task);
var result = task.Result;
Console.WriteLine($"{result.Clan.Name} V. {result.Opponent.Name}");
Console.WriteLine("Done...");
return(true);
}
private static async Task <bool> CallSearchClans()
{
var svc = new ClanService();
var task = svc.SearchClans(new ClanSearchCriteria
{
Name = "U.S.A"
});
await Task.WhenAll(task);
Console.WriteLine("Done...");
return(true);
}
protected void Refresh()
{
if (!ClanService.RetrieveClans(Query, (Page - 1) * 25, 25,
out EnumerableResultView <ClanView> clans, out string message, out HttpStatusCode code))
{
NotificationService.ShowError(message, "Failed to load clans!");
if (code == HttpStatusCode.Unauthorized)
{
ComponentService.Show(new Login());
}
else
{
ComponentService.Show(new CriticalError());
}
}
public async Task FindClanAsync_ShouldBeOfTypeClan()
{
// Arrange
TestMock.ClanRepository.Setup(repository => repository.FindClanAsync(It.IsAny <ClanId>())).ReturnsAsync(new Clan("test", new UserId())).Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
var result = await service.FindClanAsync(new ClanId());
// Assert
result.Should().BeOfType <Clan>();
TestMock.ClanRepository.Verify(repository => repository.FindClanAsync(It.IsAny <ClanId>()), Times.Once);
}
public async Task LeaveClanAsync_WhenNotMember_ShouldBeOfTypeValidationResultWithErrors()
{
// Arrange
var ownerId = new UserId();
var clan = new Clan("test", ownerId);
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
var result = await service.LeaveClanAsync(clan, new UserId());
// Assert
result.Should().BeOfType <DomainValidationResult <Clan> >();
result.Errors.Should().NotBeEmpty();
}
private static async Task <bool> CallGetClanInformation()
{
var svc = new ClanService();
var task = svc.GetClanInformation("#YP9U0J");
await Task.WhenAll(task);
var result = task.Result;
Console.WriteLine(result.Name);
Console.WriteLine(result.Description);
Console.WriteLine("Done...");
return(true);
}
public async Task CreateClanAsync_WhenMember_ShouldBeOfTypeValidationResultWithErrors()
{
// Arrange
TestMock.ClanRepository.Setup(repository => repository.IsMemberAsync(It.IsAny <UserId>())).ReturnsAsync(true).Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
var result = await service.CreateClanAsync(new UserId(), "test clan");
// Assert
result.Should().BeOfType <DomainValidationResult <Clan> >();
result.Errors.Should().NotBeEmpty();
TestMock.ClanRepository.Verify(repository => repository.IsMemberAsync(It.IsAny <UserId>()), Times.Once);
}
public void AddMemberToClanAsync_WhenClanDoesNotExists_ShouldThrowInvalidOperationException()
{
// Arrange
var ownerId = new UserId();
var clan = new Clan("test", ownerId);
TestMock.ClanRepository.Setup(repository => repository.FindClanAsync(It.IsAny <ClanId>())).Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
var action = new Func <Task>(async() => await service.AddMemberToClanAsync(clan.Id, new Candidature(new UserId(), clan.Id)));
// Assert;
action.Should().Throw <InvalidOperationException>();
TestMock.ClanRepository.Verify(repository => repository.FindClanAsync(It.IsAny <ClanId>()), Times.Once);
}
public async Task DownloadLogoAsync_ShouldBeOfTypeStream()
{
// Arrange
var memoryStream = new MemoryStream();
TestMock.ClanRepository.Setup(repository => repository.DownloadLogoAsync(It.IsAny <ClanId>())).ReturnsAsync(memoryStream).Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
var clan = new Clan("test", new UserId());
// Act
var result = await service.DownloadLogoAsync(clan);
// Assert
result.Should().BeOfType <MemoryStream>();
TestMock.ClanRepository.Verify(repository => repository.DownloadLogoAsync(It.IsAny <ClanId>()), Times.Once);
}
public async Task FindMemberAsync_ShouldBeOfTypeMember()
{
// Arrange
var ownerId = new UserId();
var clan = new Clan("test", ownerId);
TestMock.ClanRepository.Setup(repository => repository.FindMemberAsync(It.IsAny <ClanId>(), It.IsAny <MemberId>()))
.ReturnsAsync(new Member(new ClanId(), new UserId()))
.Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
var result = await service.FindMemberAsync(clan, new MemberId());
// Assert
result.Should().BeOfType <Member>();
TestMock.ClanRepository.Verify(repository => repository.FindMemberAsync(It.IsAny <ClanId>(), It.IsAny <MemberId>()), Times.Once);
}
public async Task AddMemberToClanAsync()
{
// Arrange
var ownerId = new UserId();
var clan = new Clan("test", ownerId);
TestMock.ClanRepository.Setup(repository => repository.FindClanAsync(It.IsAny <ClanId>())).ReturnsAsync(clan).Verifiable();
TestMock.ClanRepository.Setup(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
var service = new ClanService(TestMock.ClanRepository.Object);
// Act
await service.AddMemberToClanAsync(clan.Id, new Candidature(new UserId(), clan.Id));
// Assert;
TestMock.ClanRepository.Verify(repository => repository.FindClanAsync(It.IsAny <ClanId>()), Times.Once);
TestMock.ClanRepository.Verify(repository => repository.UnitOfWork.CommitAsync(It.IsAny <bool>(), It.IsAny <CancellationToken>()), Times.Once);
}
protected void Create()
{
Loading = true;
StateHasChanged();
if (!ClanService.CreateClan(new ClanCreateView {
Tag = Tag,
Name = Name,
Description = Description
}, out string message, out HttpStatusCode code))
{
NotificationService.ShowError(message, "Failed to create clan!");
if (code == HttpStatusCode.Unauthorized)
{
ComponentService.Show(new Login());
}
else
{
Loading = false;
}
}
