feat: Complete repository APIs

Mohaymen.GiteaClient.IntegrationTests/Gitea/Repository/DeleteRepository/DeleteRepositoryTests.cs

@@ -0,0 +1,62 @@
+using System.Net;
+using FluentAssertions;
+using FluentValidation;
+using Microsoft.Extensions.DependencyInjection;
+using Mohaymen.GiteaClient.Gitea.Client.Abstractions;
+using Mohaymen.GiteaClient.Gitea.Repository.DeleteRepository.Dto;
+using Mohaymen.GiteaClient.IntegrationTests.Common.Assertions.Abstractions;
+using Mohaymen.GiteaClient.IntegrationTests.Common.Collections.Gitea;
+
+namespace Mohaymen.GiteaClient.IntegrationTests.Gitea.Repository.DeleteRepository;
+
+[Collection("GiteaIntegrationTests")]
+public class DeleteRepositoryTests : IClassFixture<RepositoryClassFixture>
+{
+    private readonly IGiteaClient _sut;
+    private readonly ITestRepositoryChecker _testRepositoryChecker;
+    private readonly GiteaCollectionFixture _giteaCollectionFixture;
+
+    public DeleteRepositoryTests(GiteaCollectionFixture giteaCollectionFixture)
+    {
+        _giteaCollectionFixture = giteaCollectionFixture ?? throw new ArgumentNullException(nameof(giteaCollectionFixture));
+        _testRepositoryChecker = _giteaCollectionFixture.ServiceProvider.GetRequiredService<ITestRepositoryChecker>();
+        _sut = _giteaCollectionFixture.ServiceProvider.GetRequiredService<IGiteaClient>();
+    }
+
+    [Fact]
+    public async Task DeleteRepositoryAsync_ShouldReturnNotContentSuccessResponse_WhenRepositoryExistsAndDeleted()
+    {
+        // Arrange
+        var deletedRepositoryCommandDto = new DeleteRepositoryCommandDto
+        {
+            RepositoryName = RepositoryClassFixture.DeleteRepositoryName 
+        };
+
+        // Act
+        var actual = await _sut.RepositoryClient.DeleteRepositoryAsync(deletedRepositoryCommandDto, _giteaCollectionFixture.CancellationToken);
+
+        // Assert
+        actual.StatusCode.Should().Be(HttpStatusCode.NoContent);
+        var isRepositoryExists = await _testRepositoryChecker.ContainsRepositoryAsync(RepositoryClassFixture.DeleteRepositoryName, _giteaCollectionFixture.CancellationToken);
+        isRepositoryExists.Should().BeFalse();
+    }
+
+    [Fact]
+    public async Task DeleteRepositoryAsync_ShouldReturnNotFound_WhenRepositoryDoesNotExist()
+    {
+        // Arrange
+        const string repositoryName = "sampleFakeRepo";
+        var deletedRepositoryCommandDto = new DeleteRepositoryCommandDto
+        {
+            RepositoryName = repositoryName
+        };
+
+        // Act
+        var actual = await _sut.RepositoryClient.DeleteRepositoryAsync(deletedRepositoryCommandDto, _giteaCollectionFixture.CancellationToken);
+
+        // Assert
+        actual.StatusCode.Should().Be(HttpStatusCode.NotFound);
+        var isRepositoryExists = await _testRepositoryChecker.ContainsRepositoryAsync(repositoryName, _giteaCollectionFixture.CancellationToken);
+        isRepositoryExists.Should().BeFalse();
+    }
+}

Mohaymen.GiteaClient.IntegrationTests/Gitea/Repository/RepositoryClassFixture.cs

@@ -0,0 +1,31 @@
+using Microsoft.Extensions.DependencyInjection;
+using Mohaymen.GiteaClient.IntegrationTests.Common.Collections.Gitea;
+using Mohaymen.GiteaClient.IntegrationTests.Common.Initializers.TestData.Abstractions;
+
+namespace Mohaymen.GiteaClient.IntegrationTests.Gitea.Repository;
+
+internal sealed class RepositoryClassFixture : IAsyncLifetime
+{
+    public const string SearchRepositoryName = "SearchUseCaseRepository";
+    public const string DeleteRepositoryName = "DeleteUseCaseRepository";
+
+    private readonly ITestRepositoryCreator _testRepositoryCreator;
+    private readonly GiteaCollectionFixture _giteaCollectionFixture;
+
+    public RepositoryClassFixture(GiteaCollectionFixture giteaCollectionFixture)
+    {
+        _giteaCollectionFixture = giteaCollectionFixture ?? throw new ArgumentNullException(nameof(giteaCollectionFixture));
+        _testRepositoryCreator = giteaCollectionFixture.ServiceProvider.GetRequiredService<ITestRepositoryCreator>();
+    }
+
+    public async Task InitializeAsync()
+    {
+        await _testRepositoryCreator.CreateRepositoryAsync(SearchRepositoryName, _giteaCollectionFixture.CancellationToken);
+        await _testRepositoryCreator.CreateRepositoryAsync(DeleteRepositoryName, _giteaCollectionFixture.CancellationToken);
+    }
+
+    public Task DisposeAsync()
+    {
+        return Task.CompletedTask;
+    }
+}

Mohaymen.GiteaClient.IntegrationTests/Gitea/Repository/SearchRepository/SearchRepositoryTests.cs

@@ -0,0 +1,64 @@
+using System.Net;
+using FluentAssertions;
+using FluentValidation;
+using Microsoft.Extensions.DependencyInjection;
+using Mohaymen.GiteaClient.Gitea.Client.Abstractions;
+using Mohaymen.GiteaClient.Gitea.Repository.SearchRepository.Dtos;
+using Mohaymen.GiteaClient.IntegrationTests.Common.Assertions.Abstractions;
+using Mohaymen.GiteaClient.IntegrationTests.Common.Collections.Gitea;
+
+namespace Mohaymen.GiteaClient.IntegrationTests.Gitea.Repository.SearchRepository;
+
+[Collection("GiteaIntegrationTests")]
+public class SearchRepositoryTests : IClassFixture<RepositoryClassFixture>
+{
+    private readonly IGiteaClient _sut;
+    private readonly GiteaCollectionFixture _giteaCollectionFixture;
+
+    public SearchRepositoryTests(GiteaCollectionFixture giteaCollectionFixture)
+    {
+        _giteaCollectionFixture = giteaCollectionFixture ?? throw new ArgumentNullException(nameof(giteaCollectionFixture));
+        _sut = giteaCollectionFixture.ServiceProvider.GetRequiredService<IGiteaClient>();
+
+    }
+
+    [Fact]
+    public async Task SearchRepositoryAsync_ShouldReturnListOfMatchedRepositories_WhenSearchQueryIsProvidedAndHasMathc()
+    {
+        // Arrange
+        var searchRepositoryQuery = new SearchRepositoryQueryDto
+        {
+            Query = "Repo",
+            Limit = 10,
+            Page = 1
+        };
+
+        // Act
+        var actual =  await _sut.RepositoryClient.SearchRepositoryAsync(searchRepositoryQuery, _giteaCollectionFixture.CancellationToken);
+
+        // Assert
+        actual.StatusCode.Should().Be(HttpStatusCode.OK);
+        actual.Content!.SearchResult.Select(x => x.RepositoryName).Should()
+            .Contain(RepositoryClassFixture.SearchRepositoryName);
+    }
+
+    [Fact]
+    public async Task SearchRepositoryAsync_ShouldReturnEmptyList_WhenSearchQueryIsProvidedAndNotMatch()
+    {
+        // Arrange
+        var searchRepositoryQuery = new SearchRepositoryQueryDto
+        {
+            Query = "ahmad",
+            Page = 1,
+            Limit = 5
+        };
+
+        // Act
+        var actual =  await _sut.RepositoryClient.SearchRepositoryAsync(searchRepositoryQuery, _giteaCollectionFixture.CancellationToken);
+
+        // Assert
+        actual.StatusCode.Should().Be(HttpStatusCode.OK);
+        actual.Content!.SearchResult.Should().NotBeNull();
+        actual.Content!.SearchResult.Should().BeEmpty();
+    }
+}

Mohaymen.GiteaClient.Tests/Gitea/Repository/Common/Facade/RepositoryFacadeTests.cs

@@ -3,6 +3,10 @@
 using Mohaymen.GiteaClient.Gitea.Repository.Common.Facade.Abstractions;
 using Mohaymen.GiteaClient.Gitea.Repository.CreateRepository.Commands;
 using Mohaymen.GiteaClient.Gitea.Repository.CreateRepository.Dtos;
+using Mohaymen.GiteaClient.Gitea.Repository.DeleteRepository.Commands;
+using Mohaymen.GiteaClient.Gitea.Repository.DeleteRepository.Dto;
+using Mohaymen.GiteaClient.Gitea.Repository.SearchRepository.Dtos;
+using Mohaymen.GiteaClient.Gitea.Repository.SearchRepository.Queries;
 using NSubstitute;
 using Xunit;
 
@@ -40,5 +44,38 @@ await _mediator.Received(1).Send(Arg.Is<CreateRepositoryCommand>(x => x.DefaultB
                                                                               x.Name == repositoryName &&
                                                                               x.IsPrivateBranch == true), default);
     }
-
+
+    [Fact]
+    public async Task SearchRepositoryAsync_ShouldCallSend_WhenEver()
+    {
+        // Arrange
+        const string query = "fakeQuery";
+        var searchRepositoryQueryDto = new SearchRepositoryQueryDto
+        {
+            Query = query
+        };
+
+        // Act
+        await _sut.SearchRepositoryAsync(searchRepositoryQueryDto, default);
+
+        // Assert
+        await _mediator.Received(1).Send(Arg.Is<SearchRepositoryQuery>(x => x.Query == query));
+    }
+
+    [Fact]
+    public async Task DeleteRepositoryAsync_ShouldCallSend_WhenEver()
+    {
+        // Arrange
+        const string repositoryName = "fakeRepoName";
+        var deleteRepositoryCommandDto = new DeleteRepositoryCommandDto
+        {
+            RepositoryName = repositoryName
+        };
+
+        // Act
+        await _sut.DeleteRepositoryAsync(deleteRepositoryCommandDto, default);
+
+        // Assert
+        await _mediator.Received(1).Send(Arg.Is<DeleteRepositoryCommand>(x => x.RepositoryName == repositoryName), default);
+    }
 }

Mohaymen.GiteaClient.Tests/Gitea/Repository/DeleteRepository/Commands/DeleteRepositoryCommandHandlerTests.cs

@@ -0,0 +1,72 @@
+using FluentAssertions;
+using FluentValidation;
+using MediatR;
+using Microsoft.Extensions.Options;
+using Mohaymen.GiteaClient.Core.Configs;
+using Mohaymen.GiteaClient.Gitea.Repository.Common.ApiCall.Abstractions;
+using Mohaymen.GiteaClient.Gitea.Repository.DeleteRepository.Commands;
+using Mohaymen.GiteaClient.Gitea.Repository.DeleteRepository.Dto;
+using NSubstitute;
+using Refit;
+using Xunit;
+
+namespace Mohaymen.GiteaClient.Tests.Gitea.Repository.DeleteRepository.Commands;
+
+public class DeleteRepositoryCommandHandlerTests
+{
+    private readonly InlineValidator<DeleteRepositoryCommand> _validator;
+    private readonly IRepositoryRestClient _repositoryRestClient;
+    private readonly IOptions<GiteaApiConfiguration> _giteaOptions;
+    private readonly IRequestHandler<DeleteRepositoryCommand, ApiResponse<DeleteRepositoryResponseDto>> _sut;
+
+    public DeleteRepositoryCommandHandlerTests()
+    {
+        _validator = new InlineValidator<DeleteRepositoryCommand>();
+        _repositoryRestClient = Substitute.For<IRepositoryRestClient>();
+        _giteaOptions = Substitute.For<IOptions<GiteaApiConfiguration>>();
+        _sut = new DeleteRepositoryCommandHandler(_validator, _repositoryRestClient, _giteaOptions);
+    }
+
+    [Fact]
+    public async Task Handle_ShouldThrowsValidationException_WhenInputIsNotValid()
+    {
+        // Arrange
+        var deleteRepositoryCommand = new DeleteRepositoryCommand
+        {
+            RepositoryName = "fakeRepo"
+        };
+        _validator.RuleFor(x => x).Must(x => false);
+
+        // Act
+        var actual = async () => await _sut.Handle(deleteRepositoryCommand, default);
+
+        // Assert
+        await actual.Should().ThrowAsync<ValidationException>();
+    }
+
+    [Fact]
+    public async Task Handle_ShouldCallDeleteRepositoryAsync_WhenInputIsProvidedProperly()
+    {
+        // Arrange
+        const string repositoryName = "fakeRepo";
+        const string repositoryOwner = "fakeOwner";
+        var deleteRepositoryCommand = new DeleteRepositoryCommand
+        {
+            RepositoryName = repositoryName
+        };
+        var giteaConfig = new GiteaApiConfiguration
+        {
+            BaseUrl = "fakeUrl",
+            PersonalAccessToken = "fakeToken",
+            RepositoriesOwner = repositoryOwner
+        };
+        _giteaOptions.Value.Returns(giteaConfig);
+
+        // Act
+        await _sut.Handle(deleteRepositoryCommand, default);
+
+        // Assert
+        await _repositoryRestClient.Received(1).DeleteRepositoryAsync(repositoryOwner, repositoryName);
+    }
+
+}

Mohaymen.GiteaClient.Tests/Gitea/Repository/DeleteRepository/Validators/DeleteRepositoryCommandValidatorTests.cs

@@ -0,0 +1,52 @@
+using FluentAssertions;
+using FluentValidation;
+using Mohaymen.GiteaClient.Core.Validation;
+using Mohaymen.GiteaClient.Gitea.Repository.DeleteRepository.Commands;
+using Mohaymen.GiteaClient.Gitea.Repository.DeleteRepository.Validators;
+using Xunit;
+
+namespace Mohaymen.GiteaClient.Tests.Gitea.Repository.DeleteRepository.Validators;
+
+public class DeleteRepositoryCommandValidatorTests
+{
+    private readonly IValidator<DeleteRepositoryCommand> _sut;
+
+    public DeleteRepositoryCommandValidatorTests()
+    {
+        _sut = new DeleteRepositoryCommandValidator();
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData(null)]
+    public void Validate_ShouldReturnEmptyRepositoryNameErrorCode_WhenRepositoryNameIsNullOrEmpty(string repositoryName)
+    {
+        // Arrange
+        var deleteRepositoryCommand = new DeleteRepositoryCommand
+        {
+            RepositoryName = repositoryName
+        };
+
+        // Act
+        var actual = _sut.Validate(deleteRepositoryCommand);
+
+        // Assert
+        actual.Errors.Select(x => x.ErrorCode).Should().Contain(ValidationErrorCodes.EmptyRepositoryNameErrorCode);
+    }
+
+    [Fact]
+    public void Validate_ShouldReturnValidResult_WhenRepositoryNameIsProvidedProperly()
+    {
+        // Arrange
+        var deleteRepositoryCommand = new DeleteRepositoryCommand
+        {
+            RepositoryName = "FakeRepositoryName"
+        };
+
+        // Act
+        var actual = _sut.Validate(deleteRepositoryCommand);
+
+        // Assert
+        actual.IsValid.Should().BeTrue();
+    }
+}