1140 lines
40 KiB
C#
1140 lines
40 KiB
C#
using MediatR;
|
|
using cuqmbr.TravelGuide.Domain.Enums;
|
|
using cuqmbr.TravelGuide.Application.Common.Exceptions;
|
|
using cuqmbr.TravelGuide.Application.Countries.Commands.AddCountry;
|
|
using cuqmbr.TravelGuide.Application.Regions.Commands.AddRegion;
|
|
using cuqmbr.TravelGuide.Application.Regions.Commands.UpdateRegion;
|
|
using cuqmbr.TravelGuide.Application.Regions.Commands.DeleteRegion;
|
|
using cuqmbr.TravelGuide.Application.Regions.Queries.GetRegion;
|
|
using cuqmbr.TravelGuide.Application.Regions.Queries.GetRegionsPage;
|
|
|
|
namespace cuqmbr.TravelGuide.Application.IntegrationTests;
|
|
|
|
public class RegionsTests : TestBase
|
|
{
|
|
[Fact]
|
|
public async Task AddRegion_WithAdminRole_RegionAdded()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName = "Country Name";
|
|
|
|
var addCountryResult = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName = "Region Name";
|
|
|
|
var addRegionResult = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName,
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionResult = await mediator.Send(
|
|
new GetRegionQuery()
|
|
{
|
|
Guid = addRegionResult.Uuid,
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionResult);
|
|
Assert.NotNull(getRegionResult.Name);
|
|
Assert.Equal(regionName, getRegionResult.Name);
|
|
Assert.Equal(addCountryResult.Uuid, getRegionResult.CountryUuid);
|
|
Assert.NotNull(getRegionResult.CountryName);
|
|
Assert.Equal(addCountryResult.Name, getRegionResult.CountryName);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
AddDuplicateRegion_WithAdminRole_ThrowsDuplicateEntityException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName = "Country Name";
|
|
|
|
var addCountryResult = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName = "Region Name";
|
|
|
|
var addRegionResult = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName,
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
await Assert.ThrowsAsync<DuplicateEntityException>(() =>
|
|
mediator.Send(new AddRegionCommand()
|
|
{
|
|
Name = regionName,
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
AddSameRegionsToDifferentCountries_WithAdminRole_RegionsAdded()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName1 = "Country Name 1";
|
|
|
|
var addCountryResult1 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName1
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string countryName2 = "Country Name2 ";
|
|
|
|
var addCountryResult2 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName2
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName = "Region Name";
|
|
|
|
var addRegionResult1 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName,
|
|
CountryGuid = addCountryResult1.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult2 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName,
|
|
CountryGuid = addCountryResult2.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionResult1 = await mediator.Send(
|
|
new GetRegionQuery()
|
|
{
|
|
Guid = addRegionResult1.Uuid,
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionResult1);
|
|
Assert.NotNull(getRegionResult1.Name);
|
|
Assert.Equal(regionName, getRegionResult1.Name);
|
|
Assert.Equal(addCountryResult1.Uuid, getRegionResult1.CountryUuid);
|
|
|
|
var getRegionResult2 = await mediator.Send(
|
|
new GetRegionQuery()
|
|
{
|
|
Guid = addRegionResult2.Uuid,
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionResult2);
|
|
Assert.NotNull(getRegionResult2.Name);
|
|
Assert.Equal(regionName, getRegionResult2.Name);
|
|
Assert.Equal(addCountryResult2.Uuid, getRegionResult2.CountryUuid);
|
|
Assert.NotNull(getRegionResult2.CountryName);
|
|
Assert.Equal(addCountryResult2.Name, getRegionResult2.CountryName);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
AddRegion_WithNonExistentCountryUuid_WithAdminRole_ThrowsNotFoundException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<NotFoundException>(() =>
|
|
mediator.Send(new AddRegionCommand()
|
|
{
|
|
Name = "Name",
|
|
CountryGuid = Guid.NewGuid()
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("01234567890123456789012345678901234567890123456789012345678901234")]
|
|
public async Task
|
|
AddRegion_WithInvalidName_WithAdminRole_ThrowsValidationException
|
|
(string name)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(new AddRegionCommand()
|
|
{
|
|
Name = name
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("not an uuid")]
|
|
public async Task
|
|
AddRegion_WithInvalidCountryUuid_WithAdminRole_ThrowsValidationException
|
|
(string uuid)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(new AddRegionCommand()
|
|
{
|
|
Name = "Name",
|
|
CountryGuid =
|
|
Guid.TryParse(uuid, out var guid) ? guid : Guid.Empty
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task AddRegion_WithUserRole_ThrowsForbiddenException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.User });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new AddRegionCommand(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task AddRegion_UnAuthnticatedUser_ThrowsForbiddenException()
|
|
{
|
|
SetUnAuthenticatedUser();
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new AddRegionCommand(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
|
|
[Fact]
|
|
public async Task UpdateRegion_WithAdminRole_RegionUpdated()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName = "Country Name";
|
|
|
|
var addCountryResult = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName = "Region Name";
|
|
|
|
var addRegionResult = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName,
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string newName = "Different Name";
|
|
|
|
var updateRegionResult = await mediator.Send(
|
|
new UpdateRegionCommand()
|
|
{
|
|
Guid = addRegionResult.Uuid,
|
|
Name = newName,
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionResult = await mediator.Send(
|
|
new GetRegionQuery()
|
|
{
|
|
Guid = addRegionResult.Uuid,
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionResult);
|
|
Assert.NotNull(getRegionResult.Name);
|
|
Assert.Equal(newName, getRegionResult.Name);
|
|
Assert.Equal(addCountryResult.Uuid, getRegionResult.CountryUuid);
|
|
Assert.NotNull(getRegionResult.CountryName);
|
|
Assert.Equal(addCountryResult.Name, getRegionResult.CountryName);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("01234567890123456789012345678901234567890123456789012345678901234")]
|
|
public async Task
|
|
UpdateRegion_WithInvalidName_WithAdminRole_ThrowsValidationException
|
|
(string name)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(new UpdateRegionCommand()
|
|
{
|
|
Name = name,
|
|
CountryGuid = Guid.NewGuid()
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("not an uuid")]
|
|
public async Task
|
|
UpdateRegion_WithInvalidCountryUuid_WithAdminRole_ThrowsValidationException
|
|
(string uuid)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(new UpdateRegionCommand()
|
|
{
|
|
Guid = Guid.NewGuid(),
|
|
Name = "Name",
|
|
CountryGuid =
|
|
Guid.TryParse(uuid, out var guid) ? guid : Guid.Empty
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("not an uuid")]
|
|
public async Task
|
|
UpdateRegion_WithInvalidUuid_WithAdminRole_ThrowsValidationException
|
|
(string uuid)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(new UpdateRegionCommand()
|
|
{
|
|
Guid = Guid.TryParse(uuid, out var guid) ? guid : Guid.Empty,
|
|
Name = "Name",
|
|
CountryGuid = Guid.NewGuid()
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
UpdateRegion_WithNonExistentUuid_WithAdminRole_ThrowsNotFoundException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
var addCountryResult = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = "Name"
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
await Assert.ThrowsAsync<NotFoundException>(() =>
|
|
mediator.Send(new UpdateRegionCommand()
|
|
{
|
|
Guid = Guid.NewGuid(),
|
|
Name = "Different Name",
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
UpdateRegion_WithNonExistentCountryUuid_WithAdminRole_ThrowsNotFoundException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
var addCountryResult = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = "Name"
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = "Name",
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
await Assert.ThrowsAsync<NotFoundException>(() =>
|
|
mediator.Send(new UpdateRegionCommand()
|
|
{
|
|
Guid = addCountryResult.Uuid,
|
|
Name = "Different Name",
|
|
CountryGuid = Guid.NewGuid()
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateRegion_WithUserRole_ThrowsForbiddenException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.User });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new UpdateRegionCommand(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task UpdateRegion_UnAuthnticatedUser_ThrowsForbiddenException()
|
|
{
|
|
SetUnAuthenticatedUser();
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new UpdateRegionCommand(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
|
|
[Fact]
|
|
public async Task DeleteRegion_WithAdminRole_RegionDeleted()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
var addCountryResult = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = "Name"
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = "Name",
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
await mediator.Send(
|
|
new DeleteRegionCommand()
|
|
{
|
|
Guid = addRegionResult.Uuid,
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
await Assert.ThrowsAsync<NotFoundException>(() =>
|
|
mediator.Send(new GetRegionQuery()
|
|
{
|
|
Guid = addRegionResult.Uuid,
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("not an uuid")]
|
|
public async Task
|
|
DeleteRegion_WithInvalidUuid_WithAdminRole_ThrowsValidationException
|
|
(string uuid)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(new DeleteRegionCommand()
|
|
{
|
|
Guid = Guid.TryParse(uuid, out var guid) ? guid : Guid.Empty
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
DeleteRegion_WithNonExistentUuid_WithAdminRole_ThrowsNotFoundException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<NotFoundException>(() =>
|
|
mediator.Send(new DeleteRegionCommand()
|
|
{
|
|
Guid = Guid.NewGuid()
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DeleteRegion_WithUserRole_ThrowsForbiddenException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.User });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new DeleteRegionCommand(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DeleteRegion_UnAuthnticatedUser_ThrowsForbiddenException()
|
|
{
|
|
SetUnAuthenticatedUser();
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new DeleteRegionCommand(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
|
|
[Fact]
|
|
public async Task GetRegion_WithAdminRole_RegionReturned()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName = "Name";
|
|
|
|
var addCountryResult = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName = "Name";
|
|
|
|
var addRegionResult = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName,
|
|
CountryGuid = addCountryResult.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionResult = await mediator.Send(
|
|
new GetRegionQuery()
|
|
{
|
|
Guid = addRegionResult.Uuid,
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionResult);
|
|
Assert.NotNull(getRegionResult.Name);
|
|
Assert.Equal(regionName, getRegionResult.Name);
|
|
Assert.Equal(addRegionResult.Uuid, getRegionResult.Uuid);
|
|
Assert.Equal(addCountryResult.Uuid, getRegionResult.CountryUuid);
|
|
Assert.NotNull(getRegionResult.CountryName);
|
|
Assert.Equal(addCountryResult.Name, getRegionResult.CountryName);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("not an uuid")]
|
|
public async Task
|
|
GetRegion_WithInvalidUuid_WithAdminRole_ThrowsValidationException
|
|
(string uuid)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(
|
|
new GetRegionQuery()
|
|
{
|
|
Guid = Guid.TryParse(uuid, out var guid) ? guid : Guid.Empty
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
GetRegion_WithNonExistentUuid_WithAdminRole_ThrowsNotFoundException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<NotFoundException>(() =>
|
|
mediator.Send(
|
|
new GetRegionQuery()
|
|
{
|
|
Guid = Guid.NewGuid()
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task GetRegion_WithUserRole_ThrowsForbiddenException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.User });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new GetRegionQuery(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task GetRegion_UnAuthnticatedUser_ThrowsForbiddenException()
|
|
{
|
|
SetUnAuthenticatedUser();
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new GetRegionQuery(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
|
|
[Fact]
|
|
public async Task GetRegionsPage_WithAdminRole_RegionsPageReturned()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName1 = "Country Name 1";
|
|
string countryName2 = "CountryName 1";
|
|
|
|
var addCountryResult1 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName1
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addCountryResult2 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName2
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName1 = "Region Name 1";
|
|
string regionName2 = "Region Name 2";
|
|
|
|
var addRegionResult1 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName1,
|
|
CountryGuid = addCountryResult1.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult2 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName2,
|
|
CountryGuid = addCountryResult2.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionsResult = await mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = 1,
|
|
PageSize = 1
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionsResult);
|
|
Assert.Equal(1, getRegionsResult.PageNumber);
|
|
Assert.Equal(2, getRegionsResult.TotalCount);
|
|
Assert.Equal(2, getRegionsResult.TotalPages);
|
|
Assert.True(getRegionsResult.HasNextPage);
|
|
Assert.False(getRegionsResult.HasPreviousPage);
|
|
Assert.NotNull(getRegionsResult.Items);
|
|
Assert.Single(getRegionsResult.Items);
|
|
Assert.NotNull(getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult1.Name, getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult1.Uuid, getRegionsResult.Items.First().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult1.Uuid, getRegionsResult.Items.First().CountryUuid);
|
|
|
|
getRegionsResult = await mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = 2,
|
|
PageSize = 1
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionsResult);
|
|
Assert.Equal(2, getRegionsResult.PageNumber);
|
|
Assert.Equal(2, getRegionsResult.TotalCount);
|
|
Assert.Equal(2, getRegionsResult.TotalPages);
|
|
Assert.False(getRegionsResult.HasNextPage);
|
|
Assert.True(getRegionsResult.HasPreviousPage);
|
|
Assert.NotNull(getRegionsResult.Items);
|
|
Assert.Single(getRegionsResult.Items);
|
|
Assert.NotNull(getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Name, getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Uuid, getRegionsResult.Items.First().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult2.Uuid, getRegionsResult.Items.First().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.First().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult2.Name, getRegionsResult.Items.First().CountryName);
|
|
|
|
getRegionsResult = await mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = 1,
|
|
PageSize = 10
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionsResult);
|
|
Assert.Equal(1, getRegionsResult.PageNumber);
|
|
Assert.Equal(2, getRegionsResult.TotalCount);
|
|
Assert.Equal(1, getRegionsResult.TotalPages);
|
|
Assert.False(getRegionsResult.HasNextPage);
|
|
Assert.False(getRegionsResult.HasPreviousPage);
|
|
Assert.Equal(2, getRegionsResult.Items.Count());
|
|
Assert.NotNull(getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult1.Name, getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult1.Uuid, getRegionsResult.Items.First().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult1.Uuid, getRegionsResult.Items.First().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.First().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult1.Name, getRegionsResult.Items.First().CountryName);
|
|
Assert.NotNull(getRegionsResult.Items.Last().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Name, getRegionsResult.Items.Last().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Uuid, getRegionsResult.Items.Last().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult2.Uuid, getRegionsResult.Items.Last().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.First().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult2.Name, getRegionsResult.Items.Last().CountryName);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
GetRegionsPage_WithSearchByCountryName_WithAdminRole_SearchedRegionsPageReturned()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName1 = "Country Name 1";
|
|
string countryName2 = "CountryName 1";
|
|
|
|
var addCountryResult1 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName1
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addCountryResult2 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName2
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName1 = "Region Name 1";
|
|
string regionName2 = "Region Name 2";
|
|
|
|
var addRegionResult1 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName1,
|
|
CountryGuid = addCountryResult1.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult2 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName2,
|
|
CountryGuid = addCountryResult2.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionsResult = await mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = 1,
|
|
PageSize = 10,
|
|
Search = "cOUNTRYn"
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionsResult);
|
|
Assert.Equal(1, getRegionsResult.PageNumber);
|
|
Assert.Equal(1, getRegionsResult.TotalCount);
|
|
Assert.Equal(1, getRegionsResult.TotalPages);
|
|
Assert.False(getRegionsResult.HasNextPage);
|
|
Assert.False(getRegionsResult.HasPreviousPage);
|
|
Assert.NotNull(getRegionsResult.Items);
|
|
Assert.Single(getRegionsResult.Items);
|
|
Assert.NotNull(getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Name, getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Uuid, getRegionsResult.Items.First().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult2.Uuid, getRegionsResult.Items.First().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.First().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult2.Name, getRegionsResult.Items.First().CountryName);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
GetRegionsPage_WithSearchByRegionName_WithAdminRole_SearchedRegionsPageReturned()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName1 = "Country Name 1";
|
|
string countryName2 = "CountryName 1";
|
|
|
|
var addCountryResult1 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName1
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addCountryResult2 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName2
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName1 = "Region Name 1";
|
|
string regionName2 = "Region Name 2";
|
|
|
|
var addRegionResult1 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName1,
|
|
CountryGuid = addCountryResult1.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult2 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName2,
|
|
CountryGuid = addCountryResult2.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionsResult = await mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = 1,
|
|
PageSize = 10,
|
|
Search = "region name 1"
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionsResult);
|
|
Assert.Equal(1, getRegionsResult.PageNumber);
|
|
Assert.Equal(1, getRegionsResult.TotalCount);
|
|
Assert.Equal(1, getRegionsResult.TotalPages);
|
|
Assert.False(getRegionsResult.HasNextPage);
|
|
Assert.False(getRegionsResult.HasPreviousPage);
|
|
Assert.NotNull(getRegionsResult.Items);
|
|
Assert.Single(getRegionsResult.Items);
|
|
Assert.NotNull(getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult1.Name, getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult1.Uuid, getRegionsResult.Items.First().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult1.Uuid, getRegionsResult.Items.First().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.First().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult1.Name, getRegionsResult.Items.First().CountryName);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
GetRegionsPage_WithSort_WithAdminRole_SortedRegionsPageReturned()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName1 = "Country Name 1";
|
|
string countryName2 = "Country Name 2";
|
|
|
|
var addCountryResult1 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName1
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addCountryResult2 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName2
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName1 = "Region Name 1";
|
|
string regionName2 = "Region Name 2";
|
|
|
|
var addRegionResult1 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName1,
|
|
CountryGuid = addCountryResult1.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult2 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName2,
|
|
CountryGuid = addCountryResult2.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionsResult = await mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = 1,
|
|
PageSize = 10,
|
|
Sort = "-countryName"
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionsResult);
|
|
Assert.Equal(1, getRegionsResult.PageNumber);
|
|
Assert.Equal(2, getRegionsResult.TotalCount);
|
|
Assert.Equal(1, getRegionsResult.TotalPages);
|
|
Assert.False(getRegionsResult.HasNextPage);
|
|
Assert.False(getRegionsResult.HasPreviousPage);
|
|
Assert.NotNull(getRegionsResult.Items);
|
|
Assert.Equal(2, getRegionsResult.Items.Count());
|
|
Assert.NotNull(getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Name, getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Uuid, getRegionsResult.Items.First().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult2.Uuid, getRegionsResult.Items.First().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.First().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult2.Name, getRegionsResult.Items.First().CountryName);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task
|
|
GetRegionsPage_WithFilterByCountryUuid_WithAdminRole_SearchedRegionsPageReturned()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
string countryName1 = "Country Name 1";
|
|
string countryName2 = "Country Name 2";
|
|
|
|
var addCountryResult1 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName1
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addCountryResult2 = await mediator.Send(
|
|
new AddCountryCommand()
|
|
{
|
|
Name = countryName2
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
string regionName1 = "Region Name 1";
|
|
string regionName2 = "Region Name 2";
|
|
string regionName3 = "Region Name 3";
|
|
|
|
var addRegionResult1 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName1,
|
|
CountryGuid = addCountryResult1.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult2 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName2,
|
|
CountryGuid = addCountryResult2.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var addRegionResult3 = await mediator.Send(
|
|
new AddRegionCommand()
|
|
{
|
|
Name = regionName3,
|
|
CountryGuid = addCountryResult2.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
var getRegionsResult = await mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = 1,
|
|
PageSize = 10,
|
|
CountryGuid = addCountryResult1.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionsResult);
|
|
Assert.Equal(1, getRegionsResult.PageNumber);
|
|
Assert.Equal(1, getRegionsResult.TotalCount);
|
|
Assert.Equal(1, getRegionsResult.TotalPages);
|
|
Assert.False(getRegionsResult.HasNextPage);
|
|
Assert.False(getRegionsResult.HasPreviousPage);
|
|
Assert.NotNull(getRegionsResult.Items);
|
|
Assert.Single(getRegionsResult.Items);
|
|
Assert.NotNull(getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult1.Name, getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult1.Uuid, getRegionsResult.Items.First().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult1.Uuid, getRegionsResult.Items.First().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.First().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult1.Name, getRegionsResult.Items.First().CountryName);
|
|
|
|
getRegionsResult = await mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = 1,
|
|
PageSize = 10,
|
|
CountryGuid = addCountryResult2.Uuid
|
|
}, TestContext.Current.CancellationToken);
|
|
|
|
Assert.NotNull(getRegionsResult);
|
|
Assert.Equal(1, getRegionsResult.PageNumber);
|
|
Assert.Equal(2, getRegionsResult.TotalCount);
|
|
Assert.Equal(1, getRegionsResult.TotalPages);
|
|
Assert.False(getRegionsResult.HasNextPage);
|
|
Assert.False(getRegionsResult.HasPreviousPage);
|
|
Assert.NotNull(getRegionsResult.Items);
|
|
Assert.Equal(2, getRegionsResult.Items.Count());
|
|
Assert.NotNull(getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Name, getRegionsResult.Items.First().Name);
|
|
Assert.Equal(
|
|
addRegionResult2.Uuid, getRegionsResult.Items.First().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult2.Uuid, getRegionsResult.Items.First().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.First().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult2.Name, getRegionsResult.Items.First().CountryName);
|
|
Assert.NotNull(getRegionsResult.Items.Last().Name);
|
|
Assert.Equal(
|
|
addRegionResult3.Name, getRegionsResult.Items.Last().Name);
|
|
Assert.Equal(
|
|
addRegionResult3.Uuid, getRegionsResult.Items.Last().Uuid);
|
|
Assert.Equal(
|
|
addCountryResult2.Uuid, getRegionsResult.Items.Last().CountryUuid);
|
|
Assert.NotNull(getRegionsResult.Items.Last().CountryName);
|
|
Assert.Equal(
|
|
addCountryResult2.Name, getRegionsResult.Items.First().CountryName);
|
|
}
|
|
|
|
[Theory]
|
|
// Length > 64 (65)
|
|
[InlineData("01234567890123456789012345678901234567890123456789012345678901234")]
|
|
public async Task
|
|
GetRegionsPage_WithInvalidSearch_WithAdminRole_ThrowsValidationException
|
|
(string search)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
Search = search
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(int.MinValue)]
|
|
[InlineData(0)]
|
|
public async Task
|
|
GetRegionsPage_WithInvalidPageNumber_WithAdminRole_ThrowsValidationException
|
|
(int pageNumber)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageNumber = pageNumber
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(int.MinValue)]
|
|
[InlineData(0)]
|
|
[InlineData(51)]
|
|
[InlineData(int.MaxValue)]
|
|
public async Task
|
|
GetRegionsPage_WithInvalidPageSize_WithAdminRole_ThrowsValidationException
|
|
(int pageSize)
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.Administrator });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ValidationException>(() =>
|
|
mediator.Send(
|
|
new GetRegionsPageQuery()
|
|
{
|
|
PageSize = pageSize
|
|
}, TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task GetRegionsPage_WithUserRole_ThrowsForbiddenException()
|
|
{
|
|
SetAuthenticatedUserRoles(new[] { IdentityRole.User });
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new GetRegionsPageQuery(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task GetRegionsPage_UnAuthnticatedUser_ThrowsForbiddenException()
|
|
{
|
|
SetUnAuthenticatedUser();
|
|
|
|
var mediator = GetService<IMediator>();
|
|
|
|
await Assert.ThrowsAsync<ForbiddenException>(() =>
|
|
mediator.Send(
|
|
new GetRegionQuery(),
|
|
TestContext.Current.CancellationToken));
|
|
}
|
|
}
|