http-api/tst/Application.IntegrationTests/CountriesTests.cs

using MediatR;
using cuqmbr.TravelGuide.Application.Common.Models;
using cuqmbr.TravelGuide.Application.Common.Exceptions;
using cuqmbr.TravelGuide.Application.Countries.Commands.AddCountry;
using cuqmbr.TravelGuide.Application.Countries.Commands.UpdateCountry;
using cuqmbr.TravelGuide.Application.Countries.Commands.DeleteCountry;
using cuqmbr.TravelGuide.Application.Countries.Queries.GetCountry;
using cuqmbr.TravelGuide.Application.Countries.Queries.GetCountriesPage;


namespace cuqmbr.TravelGuide.Application.IntegrationTests;

public class CountriesTests : TestBase
{
    [Fact]
    public async Task AddCountry_WithAdminRole_CountryCreated()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        string name = "Name";

        var createCountryResult = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name
            }, TestContext.Current.CancellationToken);

        var getCountryResult = await mediator.Send(
            new GetCountryQuery()
            {
                Guid = createCountryResult.Uuid,
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountryResult);
        Assert.NotNull(getCountryResult.Name);
        Assert.Equal(name, getCountryResult.Name);
    }

    [Fact]
    public async Task
        AddDuplicateCountry_WithAdminRole_ThrowsDuplicateEntityException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        string name = "Name";

        await mediator.Send(
            new AddCountryCommand()
            {
                Name = name
            }, TestContext.Current.CancellationToken);

        await Assert.ThrowsAsync<DuplicateEntityException>(() =>
            mediator.Send(new AddCountryCommand()
            {
                Name = name
            }, TestContext.Current.CancellationToken));
    }

    [Theory]
    // Empty
    [InlineData("")]
    // Length > 64 (65)
    [InlineData("01234567890123456789012345678901234567890123456789012345678901234")]
    public async Task
        AddCountry_WithInvalidName_WithAdminRole_ThrowsValidationException
            (string name)
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ValidationException>(() =>
            mediator.Send(new AddCountryCommand()
            {
                Name = name
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task AddCountry_WithUserRole_ThrowsForbiddenException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.User });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ForbiddenException>(() =>
            mediator.Send(new AddCountryCommand()
            {
                Name = "Name"
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task
        AddCountry_WithUnAuthenticatedUser_ThrowsUnAuthorizedException()
    {
        SetUnAuthenticatedUser();

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ForbiddenException>(() =>
            mediator.Send(new AddCountryCommand()
            {
                Name = "Name"
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task UpdateCountry_WithAdminRole_CountryUpdated()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        var createCountryResult = await mediator.Send(
            new AddCountryCommand()
            {
                Name = "Name"
            }, TestContext.Current.CancellationToken);

        string newName = "Different Name";

        var editCountryResult = await mediator.Send(
            new UpdateCountryCommand()
            {
                Guid = createCountryResult.Uuid,
                Name = newName
            }, TestContext.Current.CancellationToken);

        var getCountryResult = await mediator.Send(
            new GetCountryQuery()
            {
                Guid = createCountryResult.Uuid,
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountryResult);
        Assert.Equal(newName, getCountryResult.Name);
        Assert.Equal(createCountryResult.Uuid, getCountryResult.Uuid);
    }

    [Fact]
    public async Task
        UpdateDuplicateCountry_WithAdminRole_ThrowsDuplicateEntityException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        var createCountryResult1 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = "Name 1"
            }, TestContext.Current.CancellationToken);

        var createCountryResult2 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = "Name 2"
            }, TestContext.Current.CancellationToken);

        await Assert.ThrowsAsync<DuplicateEntityException>(() =>
            mediator.Send(new UpdateCountryCommand()
            {
                Guid = createCountryResult2.Uuid,
                Name = createCountryResult1.Name
            }, TestContext.Current.CancellationToken));
    }

    [Theory]
    // Empty
    [InlineData("")]
    // Length > 64 (65)
    [InlineData("01234567890123456789012345678901234567890123456789012345678901234")]
    public async Task
        UpdateCountry_WithInvalidName_WithAdminRole_ThrowsValidationException
            (string name)
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        var createCountryResult = await mediator.Send(
            new AddCountryCommand()
            {
                Name = "Name 1"
            }, TestContext.Current.CancellationToken);

        await Assert.ThrowsAsync<ValidationException>(() =>
            mediator.Send(new UpdateCountryCommand()
            {
                Guid = createCountryResult.Uuid,
                Name = name
            }, TestContext.Current.CancellationToken));
    }

    [Theory]
    [InlineData("")]
    [InlineData("not an uuid")]
    public async Task
        UpdateCountry_WithInvalidUuid_WithAdminRole_ThrowsValidationException
            (string uuid)
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ValidationException>(() =>
            mediator.Send(new UpdateCountryCommand()
            {
                Guid = Guid.TryParse(uuid, out var guid) ? guid : Guid.Empty,
                Name = "Name"
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task
        UpdateCountry_WithNonExistentUuid_WithAdminRole_ThrowsNotFoundException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<NotFoundException>(() =>
            mediator.Send(new UpdateCountryCommand()
            {
                Guid = Guid.NewGuid(),
                Name = "Name"
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task UpdateCountry_WithUserRole_ThrowsForbiddenException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.User });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ForbiddenException>(() =>
            mediator.Send(new UpdateCountryCommand()
            {
                Guid = Guid.NewGuid(),
                Name = "Name"
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task UpdateCountry_UnAuthnticatedUser_ThrowsForbiddenException()
    {
        SetUnAuthenticatedUser();

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ForbiddenException>(() =>
            mediator.Send(new UpdateCountryCommand()
            {
                Guid = Guid.NewGuid(),
                Name = "Name"
            }, TestContext.Current.CancellationToken));
    }


    [Fact]
    public async Task DeleteCountry_WithAdminRole_CountryDeleted()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        var createCountryResult = await mediator.Send(
            new AddCountryCommand()
            {
                Name = "Name"
            }, TestContext.Current.CancellationToken);

        await mediator.Send(
            new DeleteCountryCommand()
            {
                Guid = createCountryResult.Uuid,
            }, TestContext.Current.CancellationToken);

        await Assert.ThrowsAsync<NotFoundException>(() =>
            mediator.Send(new GetCountryQuery()
            {
                Guid = createCountryResult.Uuid,
            }, TestContext.Current.CancellationToken));
    }

    [Theory]
    [InlineData("")]
    [InlineData("not an uuid")]
    public async Task
        DeleteCountry_WithInvalidUuid_WithAdminRole_ThrowsValidationException
            (string uuid)
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ValidationException>(() =>
            mediator.Send(new DeleteCountryCommand()
            {
                Guid = Guid.TryParse(uuid, out var guid) ? guid : Guid.Empty
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task
        DeleteCountry_WithNonExistentUuid_WithAdminRole_ThrowsNotFoundException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<NotFoundException>(() =>
            mediator.Send(new DeleteCountryCommand()
            {
                Guid = Guid.NewGuid()
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task DeleteCountry_WithUserRole_ThrowsForbiddenException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.User });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ForbiddenException>(() =>
            mediator.Send(new DeleteCountryCommand()
            {
                Guid = Guid.NewGuid()
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task DeleteCountry_UnAuthnticatedUser_ThrowsForbiddenException()
    {
        SetUnAuthenticatedUser();

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ForbiddenException>(() =>
            mediator.Send(new DeleteCountryCommand()
            {
                Guid = Guid.NewGuid()
            }, TestContext.Current.CancellationToken));
    }


    [Fact]
    public async Task GetCountry_WithAdminRole_CountryReturned()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        string name = "Name";

        var createCountryResult = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name
            }, TestContext.Current.CancellationToken);

        var getCountryResult = await mediator.Send(
            new GetCountryQuery()
            {
                Guid = createCountryResult.Uuid,
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountryResult);
        Assert.NotNull(getCountryResult.Name);
        Assert.Equal(name, getCountryResult.Name);
        Assert.Equal(createCountryResult.Uuid, getCountryResult.Uuid);
    }

    [Theory]
    [InlineData("")]
    [InlineData("not an uuid")]
    public async Task
        GetCountry_WithInvalidUuid_WithAdminRole_ThrowsValidationException
            (string uuid)
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ValidationException>(() =>
            mediator.Send(new GetCountryQuery()
            {
                Guid = Guid.TryParse(uuid, out var guid) ? guid : Guid.Empty
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task
        GetCountry_WithNonExistentUuid_WithAdminRole_ThrowsNotFoundException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<NotFoundException>(() =>
            mediator.Send(new GetCountryQuery()
            {
                Guid = Guid.NewGuid()
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task GetCountry_WithUserRole_ThrowsForbiddenException()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.User });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ForbiddenException>(() =>
            mediator.Send(new GetCountryQuery()
            {
                Guid = Guid.NewGuid()
            }, TestContext.Current.CancellationToken));
    }

    [Fact]
    public async Task GetCountry_UnAuthnticatedUser_ThrowsForbiddenException()
    {
        SetUnAuthenticatedUser();

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ForbiddenException>(() =>
            mediator.Send(new GetCountryQuery()
            {
                Guid = Guid.NewGuid()
            }, TestContext.Current.CancellationToken));
    }


    [Fact]
    public async Task GetCountriesPage_WithAdminRole_CountriesPageReturned()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        string name1 = "Name 1";
        string name2 = "Name 2";

        var createCountryResult1 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name1
            }, TestContext.Current.CancellationToken);

        var createCountryResult2 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name2
            }, TestContext.Current.CancellationToken);

        var getCountriesResult = await mediator.Send(
            new GetCountriesPageQuery()
            {
                PageNumber = 1,
                PageSize = 1
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountriesResult);
        Assert.Equal(1, getCountriesResult.PageNumber);
        Assert.Equal(2, getCountriesResult.TotalCount);
        Assert.Equal(2, getCountriesResult.TotalPages);
        Assert.True(getCountriesResult.HasNextPage);
        Assert.False(getCountriesResult.HasPreviousPage);
        Assert.NotNull(getCountriesResult.Items);
        Assert.Single(getCountriesResult.Items);
        Assert.NotNull(getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult1.Name, getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult1.Uuid, getCountriesResult.Items.First().Uuid);

        getCountriesResult = await mediator.Send(
            new GetCountriesPageQuery()
            {
                PageNumber = 2,
                PageSize = 1
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountriesResult);
        Assert.Equal(2, getCountriesResult.PageNumber);
        Assert.Equal(2, getCountriesResult.TotalCount);
        Assert.Equal(2, getCountriesResult.TotalPages);
        Assert.False(getCountriesResult.HasNextPage);
        Assert.True(getCountriesResult.HasPreviousPage);
        Assert.NotNull(getCountriesResult.Items);
        Assert.Single(getCountriesResult.Items);
        Assert.NotNull(getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult2.Name, getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult2.Uuid, getCountriesResult.Items.First().Uuid);

        getCountriesResult = await mediator.Send(
            new GetCountriesPageQuery()
            {
                PageNumber = 1,
                PageSize = 10
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountriesResult);
        Assert.Equal(1, getCountriesResult.PageNumber);
        Assert.Equal(2, getCountriesResult.TotalCount);
        Assert.Equal(1, getCountriesResult.TotalPages);
        Assert.False(getCountriesResult.HasNextPage);
        Assert.False(getCountriesResult.HasPreviousPage);
        Assert.NotNull(getCountriesResult.Items);
        Assert.Equal(2, getCountriesResult.Items.Count());
        Assert.NotNull(getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult1.Name, getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult1.Uuid, getCountriesResult.Items.First().Uuid);
        Assert.NotNull(getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult2.Name, getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult2.Uuid, getCountriesResult.Items.Last().Uuid);
    }

    [Fact]
    public async Task
        GetCountriesPage_WithSearch_WithAdminRole_SearchedCountriesPageReturned()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        string name1 = "Name 1";
        string name2 = "Some 3 String";
        string name3 = "3 Name Some";

        var createCountryResult1 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name1
            }, TestContext.Current.CancellationToken);

        var createCountryResult2 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name2
            }, TestContext.Current.CancellationToken);

        var createCountryResult3 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name3
            }, TestContext.Current.CancellationToken);

        var getCountriesResult = await mediator.Send(
            new GetCountriesPageQuery()
            {
                PageNumber = 1,
                PageSize = 10,
                Search = "name"
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountriesResult);
        Assert.Equal(1, getCountriesResult.PageNumber);
        Assert.Equal(2, getCountriesResult.TotalCount);
        Assert.Equal(1, getCountriesResult.TotalPages);
        Assert.False(getCountriesResult.HasNextPage);
        Assert.False(getCountriesResult.HasPreviousPage);
        Assert.NotNull(getCountriesResult.Items);
        Assert.Equal(2, getCountriesResult.Items.Count());
        Assert.NotNull(getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult1.Name, getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult1.Uuid, getCountriesResult.Items.First().Uuid);
        Assert.NotNull(getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult3.Name, getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult3.Uuid, getCountriesResult.Items.Last().Uuid);

        getCountriesResult = await mediator.Send(
            new GetCountriesPageQuery()
            {
                PageNumber = 1,
                PageSize = 10,
                Search = "3"
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountriesResult);
        Assert.Equal(1, getCountriesResult.PageNumber);
        Assert.Equal(2, getCountriesResult.TotalCount);
        Assert.Equal(1, getCountriesResult.TotalPages);
        Assert.False(getCountriesResult.HasNextPage);
        Assert.False(getCountriesResult.HasPreviousPage);
        Assert.NotNull(getCountriesResult.Items);
        Assert.Equal(2, getCountriesResult.Items.Count());
        Assert.NotNull(getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult2.Name, getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult2.Uuid, getCountriesResult.Items.First().Uuid);
        Assert.NotNull(getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult3.Name, getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult3.Uuid, getCountriesResult.Items.Last().Uuid);
    }

    [Fact]
    public async Task
        GetCountriesPage_WithSort_WithAdminRole_SortedCountriesPageReturned()
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        string name1 = "Name 1";
        string name2 = "Some 2";

        var createCountryResult1 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name1
            }, TestContext.Current.CancellationToken);

        var createCountryResult2 = await mediator.Send(
            new AddCountryCommand()
            {
                Name = name2
            }, TestContext.Current.CancellationToken);

        var getCountriesResult = await mediator.Send(
            new GetCountriesPageQuery()
            {
                PageNumber = 1,
                PageSize = 10,
                Sort = "-name"
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountriesResult);
        Assert.Equal(1, getCountriesResult.PageNumber);
        Assert.Equal(2, getCountriesResult.TotalCount);
        Assert.Equal(1, getCountriesResult.TotalPages);
        Assert.False(getCountriesResult.HasNextPage);
        Assert.False(getCountriesResult.HasPreviousPage);
        Assert.NotNull(getCountriesResult.Items);
        Assert.Equal(2, getCountriesResult.Items.Count());
        Assert.NotNull(getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult2.Name, getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult2.Uuid, getCountriesResult.Items.First().Uuid);
        Assert.NotNull(getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult1.Name, getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult1.Uuid, getCountriesResult.Items.Last().Uuid);

        getCountriesResult = await mediator.Send(
            new GetCountriesPageQuery()
            {
                PageNumber = 1,
                PageSize = 10,
                Sort = "+name"
            }, TestContext.Current.CancellationToken);

        Assert.NotNull(getCountriesResult);
        Assert.Equal(1, getCountriesResult.PageNumber);
        Assert.Equal(2, getCountriesResult.TotalCount);
        Assert.Equal(1, getCountriesResult.TotalPages);
        Assert.False(getCountriesResult.HasNextPage);
        Assert.False(getCountriesResult.HasPreviousPage);
        Assert.NotNull(getCountriesResult.Items);
        Assert.Equal(2, getCountriesResult.Items.Count());
        Assert.NotNull(getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult1.Name, getCountriesResult.Items.First().Name);
        Assert.Equal(
            createCountryResult1.Uuid, getCountriesResult.Items.First().Uuid);
        Assert.NotNull(getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult2.Name, getCountriesResult.Items.Last().Name);
        Assert.Equal(
            createCountryResult2.Uuid, getCountriesResult.Items.Last().Uuid);
    }

    [Theory]
    // Length > 64 (65)
    [InlineData("01234567890123456789012345678901234567890123456789012345678901234")]
    public async Task
        GetCountriesPage_WithInvalidSearch_WithAdminRole_ThrowsValidationException
            (string search)
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ValidationException>(() =>
            mediator.Send(new GetCountriesPageQuery()
            {
                Search = search
            }, TestContext.Current.CancellationToken));
    }

    [Theory]
    [InlineData(int.MinValue)]
    [InlineData(0)]
    public async Task
        GetCountriesPage_WithInvalidPageNumber_WithAdminRole_ThrowsValidationException
            (int pageNumber)
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ValidationException>(() =>
            mediator.Send(new GetCountriesPageQuery()
            {
                PageNumber = pageNumber
            }, TestContext.Current.CancellationToken));
    }

    [Theory]
    [InlineData(int.MinValue)]
    [InlineData(0)]
    [InlineData(51)]
    [InlineData(int.MaxValue)]
    public async Task
        GetCountriesPage_WithInvalidPageSize_WithAdminRole_ThrowsValidationException
            (int pageSize)
    {
        SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });

        var mediator = GetService<IMediator>();

        await Assert.ThrowsAsync<ValidationException>(() =>
            mediator.Send(new GetCountriesPageQuery()
            {
                PageSize = pageSize
            }, TestContext.Current.CancellationToken));
    }
}