public async Task GetStatesAsync_Should_Return_OkObjectResult_With_CollectionResponse_With_StateResponses()
{
var getStatesRequest = new GetStatesRequest
{
Page = 1,
PageSize = 100,
Name = "Name",
PolishName = "PolishName",
Sort = "name:asc"
};
var getStatesInputQuery = new GetStatesInputQuery(getStatesRequest.Page,
getStatesRequest.PageSize, getStatesRequest.Sort, getStatesRequest.Name, getStatesRequest.PolishName);
var stateOutputQuery = new StateOutputQuery(Guid.NewGuid(), Array.Empty <byte>(), "Name", "PolishName");
var stateOutputQueries = new Collection <StateOutputQuery> {
stateOutputQuery
};
var collectionOutputQuery = new CollectionOutputQuery <StateOutputQuery>(stateOutputQueries.Count, stateOutputQueries);
var stateResponses = stateOutputQueries.Select(x => new StateResponse(x.Id, x.RowVersion, x.Name, x.PolishName));
var collectionResponse = new CollectionResponse <StateResponse>(stateOutputQueries.Count, stateResponses);
_mapperMock.Setup(x => x.Map <GetStatesRequest, GetStatesInputQuery>(It.IsAny <GetStatesRequest>()))
.Returns(getStatesInputQuery);
_getStatesQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetStatesInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(collectionOutputQuery);
_mapperMock
.Setup(x => x.Map <CollectionOutputQuery <StateOutputQuery>, CollectionResponse <StateResponse> >(It.IsAny <CollectionOutputQuery <StateOutputQuery> >()))
.Returns(collectionResponse);
var result = await _controller.GetStatesAsync(getStatesRequest);
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(collectionResponse);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_CityOutputQuery_When_Input_Is_Null()
{
var cities = new List <City>
{
City.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build()
};
var cityOutputQueries = cities.Select(x => new CityOutputQuery(x.Id, x.RowVersion, x.Name, x.PolishName, x.StateId)).ToList();
var collectionOutputQuery = new CollectionOutputQuery <CityOutputQuery>(cities.Count, cityOutputQueries);
_cityRepositoryMock.Setup(x => x.GetAllAsync()).ReturnsAsync(cities);
_cityRepositoryMock.Setup(x => x.CountAsync()).ReturnsAsync(cities.Count);
_mapperMock
.Setup(x => x.Map <List <City>, IEnumerable <CityOutputQuery> >(It.IsAny <List <City> >()))
.Returns(cityOutputQueries);
var result = await _queryHandler.HandleAsync(null);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_CityDistrictOutputQuery_When_Input_Is_Not_Null()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetParentId(Guid.NewGuid())
.Build();
var cityDistrictsInputQuery = new GetCityDistrictsInputQuery(1, 100, "name:asc", cityDistrict.Name,
cityDistrict.PolishName, cityDistrict.CityId, cityDistrict.ParentId, new List <Guid>());
var cityDistricts = new List <CityDistrict> {
cityDistrict
};
var cityDistrictOutputQueries = cityDistricts.Select(x =>
new CityDistrictOutputQuery(x.Id, x.RowVersion, x.Name, x.PolishName, x.CityId, x.ParentId, x.NameVariants)).ToList();
var collectionOutputQuery = new CollectionOutputQuery <CityDistrictOutputQuery>(cityDistricts.Count, cityDistrictOutputQueries);
_cityDistrictRepositoryMock
.Setup(x => x.FindAsync(It.IsAny <int?>(), It.IsAny <int?>(), It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid?>(), It.IsAny <Guid?>(), It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(cityDistricts);
_cityDistrictRepositoryMock
.Setup(x => x.CountAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Guid?>(), It.IsAny <Guid?>(), It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(cityDistricts.Count);
_mapperMock.Setup(x =>
x.Map <List <CityDistrict>, IEnumerable <CityDistrictOutputQuery> >(It.IsAny <List <CityDistrict> >()))
.Returns(cityDistrictOutputQueries);
var result = await _queryHandler.HandleAsync(cityDistrictsInputQuery);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_FlatForRentAnnouncementOutputQuery_When_Input_Is_Null()
{
var flatForRentAnnouncement = FlatForRentAnnouncement.Builder()
.SetId(Guid.NewGuid())
.SetTitle("Title")
.SetSourceUrl("http://source")
.SetCityId(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetDescription("Description")
.SetNumberOfRooms(NumberOfRoomsEnumeration.One)
.SetPrice(1000)
.SetCityDistricts(new List <Guid> {
Guid.NewGuid()
})
.Build();
var flatForRentAnnouncements = new List <FlatForRentAnnouncement> {
flatForRentAnnouncement
};
var forRentAnnouncementOutputQueries = flatForRentAnnouncements
.Select(x => new FlatForRentAnnouncementOutputQuery(x.Id, x.Title, x.SourceUrl, x.CityId, x.Created, x.Description,
x.Price, x.NumberOfRooms, x.CityDistricts)).ToList();
var collectionOutputQuery = new CollectionOutputQuery <FlatForRentAnnouncementOutputQuery>(forRentAnnouncementOutputQueries.Count,
forRentAnnouncementOutputQueries);
_flatForRentAnnouncementRepositoryMock.Setup(x => x.GetAllAsync()).ReturnsAsync(flatForRentAnnouncements);
_flatForRentAnnouncementRepositoryMock.Setup(x => x.CountAsync())
.ReturnsAsync(flatForRentAnnouncements.Count);
_mapperMock
.Setup(x => x.Map <List <FlatForRentAnnouncement>, IEnumerable <FlatForRentAnnouncementOutputQuery> >(It.IsAny <List <FlatForRentAnnouncement> >()))
.Returns(forRentAnnouncementOutputQueries);
var result = await _queryHandler.HandleAsync(null);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_GetAccountsOutputQuery_When_Input_Is_Null()
{
var account = Account.Builder()
.SetId(Guid.NewGuid())
.SetEmail("*****@*****.**")
.SetConfirmed(true)
.SetPasswordHash("PasswordHash")
.SetSecurityStamp(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetRoles(new List <Guid> {
Guid.NewGuid()
})
.Build();
var accounts = new List <Account> {
account
};
var getAccountsOutputQueries = accounts
.Select(x => new GetAccountsOutputQuery(x.Id, x.Email, x.Confirmed, x.Created,
!string.IsNullOrWhiteSpace(x.PasswordHash), x.LastLogin)).ToList();
var collectionOutputQuery = new CollectionOutputQuery <GetAccountsOutputQuery>(getAccountsOutputQueries.Count, getAccountsOutputQueries);
_accountRepositoryMock.Setup(x => x.GetAllAsync()).ReturnsAsync(accounts);
_accountRepositoryMock.Setup(x => x.CountAsync()).ReturnsAsync(accounts.Count);
_mapperMock.Setup(x => x.Map <List <Account>, IEnumerable <GetAccountsOutputQuery> >(It.IsAny <List <Account> >()))
.Returns(getAccountsOutputQueries);
var result = await _queryHandler.HandleAsync(null);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_UserOutputQuery_When_InputQuery_Is_Not_Null()
{
var inputQuery = new GetUsersInputQuery(1, 1, "email", "*****@*****.**", true);
var user = User.Builder()
.SetId(Guid.NewGuid())
.SetEmail("*****@*****.**")
.SetServiceActive(DefaultUserSettings.ServiceActive)
.SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit)
.SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency)
.Build();
var users = new List <User> {
user
};
var userOutputQueries = users.Select(x => new UserOutputQuery(user.Id, user.Email, user.Picture,
user.ServiceActive, user.AnnouncementPreferenceLimit, user.AnnouncementSendingFrequency,
new List <RoomForRentAnnouncementPreferenceOutputQuery>(),
new List <FlatForRentAnnouncementPreferenceOutputQuery>())).ToList();
var expectedResult = new CollectionOutputQuery <UserOutputQuery>(userOutputQueries.Count(), userOutputQueries);
_userRepositoryMock.Setup(x => x.FindAsync(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <bool>())).ReturnsAsync(users);
_userRepositoryMock.Setup(x => x.CountAsync(It.IsAny <string>(), It.IsAny <bool>()))
.ReturnsAsync(users.Count);
_mapperMock.Setup(x => x.Map <List <User>, IEnumerable <UserOutputQuery> >(It.IsAny <List <User> >()))
.Returns(userOutputQueries);
var result = await _queryHandler.HandleAsync(inputQuery);
result.Should().BeEquivalentTo(expectedResult);
}
public async Task GetFlatForRentAnnouncementsAsync_Should_Return_OkObjectResult_With_CollectionResponse_With_FlatForRentAnnouncementResponses()
{
var flatForRentAnnouncementOutputQueries = new List <FlatForRentAnnouncementOutputQuery>
{
new FlatForRentAnnouncementOutputQuery(Guid.NewGuid(), "Title", "http://sourceUrl",
Guid.NewGuid(), DateTimeOffset.UtcNow, "Description", 100, NumberOfRoomsEnumeration.One,
new List <Guid>())
};
var collectionOutputQuery =
new CollectionOutputQuery <FlatForRentAnnouncementOutputQuery>(flatForRentAnnouncementOutputQueries.Count, flatForRentAnnouncementOutputQueries);
var flatForRentAnnouncementResponses = flatForRentAnnouncementOutputQueries.Select(output =>
new FlatForRentAnnouncementResponse(output.Id, output.Title, output.SourceUrl, output.CityId,
output.Created, output.Description, output.Price,
FlatForRentAnnouncementProfile.ConvertToNumberOfRoomsEnum(output.NumberOfRooms),
output.CityDistricts))
.ToList();
var collectionResponse = new CollectionResponse <FlatForRentAnnouncementResponse>(flatForRentAnnouncementResponses.Count, flatForRentAnnouncementResponses);
_getFlatForRentAnnouncementsQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetFlatForRentAnnouncementsInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(collectionOutputQuery);
_mapperMock
.Setup(x => x.Map <CollectionOutputQuery <FlatForRentAnnouncementOutputQuery>, CollectionResponse <FlatForRentAnnouncementResponse> >(It.IsAny <CollectionOutputQuery <FlatForRentAnnouncementOutputQuery> >()))
.Returns(collectionResponse);
var result = await _controller.GetFlatForRentAnnouncementsAsync(new GetFlatForRentAnnouncementsRequest());
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(collectionResponse);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_StateOutputQuery_When_Input_Is_Not_Null()
{
var getStatesInputQuery = new GetStatesInputQuery(1, 100, "name:asc", "Name", "PolishName");
var states = new List <State>
{
State.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.Build()
};
var stateOutputQueries = states
.Select(x => new StateOutputQuery(x.Id, x.RowVersion, x.Name, x.PolishName)).ToList();
var collectionOutputQuery = new CollectionOutputQuery <StateOutputQuery>(states.Count, stateOutputQueries);
_stateRepositoryMock.Setup(x => x.FindAsync(It.IsAny <int?>(), It.IsAny <int?>(), It.IsAny <string>(),
It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(states);
_stateRepositoryMock.Setup(x => x.CountAsync(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(states.Count);
_mapperMock.Setup(x => x.Map <List <State>, IEnumerable <StateOutputQuery> >(It.IsAny <List <State> >()))
.Returns(stateOutputQueries);
var result = await _queryHandler.HandleAsync(getStatesInputQuery);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_RoleOutputQuery()
{
var roles = new List <Role>
{
new Role(Guid.NewGuid(), Array.Empty <byte>(), DefaultRoleEnumeration.Administrator.DisplayName)
};
var roleOutputQueries = roles.Select(x => new RoleOutputQuery(x.Id, x.RowVersion, x.Name));
var collectionOutputQuery = new CollectionOutputQuery <RoleOutputQuery>(roles.Count, roleOutputQueries);
_roleRepositoryMock.Setup(x => x.GetAllAsync()).ReturnsAsync(roles);
_mapperMock.Setup(x =>
x.Map <List <Role>, CollectionOutputQuery <RoleOutputQuery> >(It.IsAny <List <Role> >()))
.Returns(collectionOutputQuery);
var result = await _queryHandler.HandleAsync(new GetRolesInputQuery());
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task GetCityDistrictsAsync_Should_Return_OkObjectResult_With_CollectionResponse_With_CityDistrictResponses()
{
var getCityDistrictsRequest = new GetCityDistrictsRequest
{
Page = 1,
PageSize = 100,
CityId = Guid.NewGuid(),
Name = "Name",
PolishName = "PolishName",
Sort = "name:asc"
};
var getCityDistrictsInputQuery = new GetCityDistrictsInputQuery(getCityDistrictsRequest.Page,
getCityDistrictsRequest.PageSize, getCityDistrictsRequest.Sort, getCityDistrictsRequest.Name,
getCityDistrictsRequest.PolishName, getCityDistrictsRequest.CityId, null, new List <Guid>());
var cityDistrictOutputQuery = new CityDistrictOutputQuery(Guid.NewGuid(), Array.Empty <byte>(),
"Name", "PolishName", Guid.NewGuid(), Guid.NewGuid(), new List <string> {
"NameVariant"
});
var cityDistrictOutputQueries = new Collection <CityDistrictOutputQuery> {
cityDistrictOutputQuery
};
var collectionOutputQuery = new CollectionOutputQuery <CityDistrictOutputQuery>(cityDistrictOutputQueries.Count, cityDistrictOutputQueries);
var cityDistrictResponses = cityDistrictOutputQueries.Select(x =>
new CityDistrictResponse(x.Id, x.RowVersion, x.Name, x.PolishName, x.CityId, x.ParentId, x.NameVariants));
var collectionResponse = new CollectionResponse <CityDistrictResponse>(cityDistrictOutputQueries.Count, cityDistrictResponses);
_mapperMock.Setup(x => x.Map <GetCityDistrictsRequest, GetCityDistrictsInputQuery>(It.IsAny <GetCityDistrictsRequest>()))
.Returns(getCityDistrictsInputQuery);
_getCityDistrictsQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetCityDistrictsInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(collectionOutputQuery);
_mapperMock
.Setup(x =>
x.Map <CollectionOutputQuery <CityDistrictOutputQuery>, CollectionResponse <CityDistrictResponse> >(
It.IsAny <CollectionOutputQuery <CityDistrictOutputQuery> >()))
.Returns(collectionResponse);
var result = await _controller.GetCityDistrictsAsync(getCityDistrictsRequest);
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(collectionResponse);
}
public async Task HandleAsync_Should_Return_CollectionOutputQuery_With_RoomForRentAnnouncementOutputQuery_When_Input_Is_Not_Null()
{
var roomForRentAnnouncement = RoomForRentAnnouncement.Builder()
.SetId(Guid.NewGuid())
.SetTitle("Title")
.SetSourceUrl("http://source")
.SetCityId(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetDescription("Description")
.SetPrice(1000)
.SetCityDistricts(new List <Guid> {
Guid.NewGuid()
})
.SetRoomTypes(new [] { RoomTypeEnumeration.Double })
.Build();
var roomForRentAnnouncements = new List <RoomForRentAnnouncement> {
roomForRentAnnouncement
};
var roomForRentAnnouncementOutputQueries = roomForRentAnnouncements.Select(x =>
new RoomForRentAnnouncementOutputQuery(x.Id, x.Title, x.SourceUrl, x.CityId, x.Created, x.Description, x.Price, x.RoomTypes, x.CityDistricts)).ToList();
var roomForRentAnnouncementsInputQuery =
new GetRoomForRentAnnouncementsInputQuery(1, 100, "price:asc", null, null, null, null, null, null, null);
var collectionOutputQuery =
new CollectionOutputQuery <RoomForRentAnnouncementOutputQuery>(roomForRentAnnouncementOutputQueries.Count, roomForRentAnnouncementOutputQueries);
_roomForRentAnnouncementRepositoryMock
.Setup(x => x.FindAsync(It.IsAny <int?>(), It.IsAny <int?>(),
It.IsAny <string>(), It.IsAny <Guid?>(), It.IsAny <DateTimeOffset?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <decimal?>(), It.IsAny <decimal?>(), It.IsAny <Guid?>(), It.IsAny <RoomTypeEnumeration>()))
.ReturnsAsync(roomForRentAnnouncements);
_roomForRentAnnouncementRepositoryMock
.Setup(x => x.CountAsync(It.IsAny <Guid?>(), It.IsAny <DateTimeOffset?>(),
It.IsAny <DateTimeOffset?>(), It.IsAny <decimal?>(), It.IsAny <decimal?>(), It.IsAny <Guid?>(),
It.IsAny <RoomTypeEnumeration>()))
.ReturnsAsync(roomForRentAnnouncements.Count);
_mapperMock
.Setup(x => x.Map <List <RoomForRentAnnouncement>, IEnumerable <RoomForRentAnnouncementOutputQuery> >(It.IsAny <List <RoomForRentAnnouncement> >()))
.Returns(roomForRentAnnouncementOutputQueries);
var result = await _queryHandler.HandleAsync(roomForRentAnnouncementsInputQuery);
result.Should().BeEquivalentTo(collectionOutputQuery);
}
public async Task GetAccountsAsync_Should_Return_OkObjectResult_With_CollectionResponse_With_GetAccountsCollectionItemResponses()
{
var getAccountsRequest = new GetAccountsRequest
{
Email = "*****@*****.**",
Confirmed = true,
Sort = "email:asc",
Page = 1,
PageSize = 100
};
var getAccountsInputQuery = new GetAccountsInputQuery(getAccountsRequest.Page, getAccountsRequest.PageSize,
getAccountsRequest.Sort, getAccountsRequest.Email, getAccountsRequest.Confirmed);
var getAccountsOutputQueries = new List <GetAccountsOutputQuery>
{
new GetAccountsOutputQuery(Guid.NewGuid(), getAccountsRequest.Email, getAccountsRequest.Confirmed.Value,
DateTimeOffset.UtcNow, true, null)
};
var collectionOutputQuery = new CollectionOutputQuery <GetAccountsOutputQuery>(getAccountsOutputQueries.Count, getAccountsOutputQueries);
var getAccountsCollectionItemResponses = getAccountsOutputQueries.Select(x =>
new GetAccountsCollectionItemResponse(x.Id, x.Email, x.Confirmed, x.Created, x.PasswordAssigned, x.LastLogin));
var collectionResponse = new CollectionResponse <GetAccountsCollectionItemResponse>(getAccountsOutputQueries.Count, getAccountsCollectionItemResponses);
_mapperMock.Setup(x => x.Map <GetAccountsRequest, GetAccountsInputQuery>(It.IsAny <GetAccountsRequest>()))
.Returns(getAccountsInputQuery);
_getAccountsQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetAccountsInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(collectionOutputQuery);
_mapperMock.Setup(x =>
x.Map <CollectionOutputQuery <GetAccountsOutputQuery>,
CollectionResponse <GetAccountsCollectionItemResponse> >(
It.IsAny <CollectionOutputQuery <GetAccountsOutputQuery> >())).Returns(collectionResponse);
var result = await _controller.GetAccountsAsync(getAccountsRequest);
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(collectionResponse);
}
public async Task GetRolesAsync_Should_Return_OkObjectResult_With_CollectionResponse_With_GetRoleResponse()
{
var roleOutputQueries = new List <RoleOutputQuery>
{
new RoleOutputQuery(Guid.NewGuid(), Array.Empty <byte>(), DefaultRoleEnumeration.Administrator.DisplayName)
};
var collectionOutputQuery = new CollectionOutputQuery <RoleOutputQuery>(roleOutputQueries.Count, roleOutputQueries);
var getRoleResponses = roleOutputQueries.Select(x => new GetRoleResponse(x.Id, x.RowVersion, x.Name));
var collectionResponse = new CollectionResponse <GetRoleResponse>(roleOutputQueries.Count, getRoleResponses);
_getRolesQueryHandlerMock
.Setup(x => x.HandleAsync(It.IsAny <GetRolesInputQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(collectionOutputQuery);
_mapperMock
.Setup(x => x.Map <CollectionOutputQuery <RoleOutputQuery>, CollectionResponse <GetRoleResponse> >(It.IsAny <CollectionOutputQuery <RoleOutputQuery> >()))
.Returns(collectionResponse);
var result = await _controller.GetRolesAsync();
var okResult = result.As <OkObjectResult>();
okResult.Value.Should().BeEquivalentTo(collectionResponse);
}
public CollectionResponse <FlatForRentAnnouncementResponse> Convert(CollectionOutputQuery <FlatForRentAnnouncementOutputQuery> source, CollectionResponse <FlatForRentAnnouncementResponse> destination, ResolutionContext context)
{
return(new CollectionResponse <FlatForRentAnnouncementResponse>(source.TotalCount,
context.Mapper.Map <IEnumerable <FlatForRentAnnouncementOutputQuery>, IEnumerable <FlatForRentAnnouncementResponse> >(source.Results)));
}
