public async Task HandleAsync_Should_Throw_ConflictException_When_Only_PolishName_Is_Already_Used()
{
var state = State.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.Build();
var getStateResult = GetResult <State> .Ok(state);
var command = new CreateCityCommand(Guid.NewGuid(), "Name", "PolishName", Guid.NewGuid());
var duplicatePolishNameError = new Error(CityErrorCodeEnumeration.PolishNameAlreadyInUse, CityErrorMessage.PolishNameAlreadyInUse);
var nameIsNotTakenVerificationResult = VerificationResult.Ok();
var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
duplicatePolishNameError
});
var errors = new Collection <IError> {
duplicatePolishNameError
};
_stateGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getStateResult);
_cityVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_cityVerificationServiceMock.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ConflictException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task VerifyCityDistrictsExistAsync_Should_Return_Verification_Fail()
{
var cityId = Guid.NewGuid();
var cityDistricts = new List <ICityDistrict>
{
new CityDistrict
{
Id = Guid.NewGuid(),
Name = "Name",
PolishName = "PolishName",
CityId = Guid.NewGuid()
}
};
var cityDistrictIds = new List <Guid> {
Guid.NewGuid()
};
var errors = new Collection <IError>
{
new Error(CityDistrictErrorCodeEnumeration.NotFound, CityDistrictErrorMessage.NotFound)
};
var expectedResult = VerificationResult.Fail(errors);
_rivaAdministrativeDivisionApiClientServiceMock.Setup(x => x.GetCityDistrictsAsync(It.IsAny <Guid>()))
.ReturnsAsync(cityDistricts);
var result = await _service.VerifyCityDistrictsExistAsync(cityId, cityDistrictIds);
result.Should().BeEquivalentTo(expectedResult);
}
public async Task HandleAsync_Should_Throw_ValidationException_When_User_Is_Not_Allowed_To_Change_Announcement_Sending_Frequency()
{
var command = new UpdateUserCommand(Guid.NewGuid(), DefaultUserSettings.ServiceActive,
DefaultUserSettings.AnnouncementPreferenceLimit, AnnouncementSendingFrequencyEnumeration.EveryHour,
null);
var user = User.Builder()
.SetId(command.UserId)
.SetEmail("*****@*****.**")
.SetServiceActive(command.ServiceActive)
.SetAnnouncementPreferenceLimit(command.AnnouncementPreferenceLimit)
.SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency)
.Build();
var getUserResult = GetResult <User> .Ok(user);
var errors = new Collection <IError>
{
new Error(UserErrorCodeEnumeration.InsufficientPrivileges,
UserErrorMessage.InsufficientPrivilegesToEditAnnouncementSendingFrequency)
};
var announcementSendingFrequencyCanBeChangedVerificationResult = VerificationResult.Fail(errors);
_userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult);
_userVerificationServiceMock.Setup(x => x.VerifyAnnouncementSendingFrequencyCanBeChanged())
.Returns(announcementSendingFrequencyCanBeChangedVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task VerifyEmailIsNotTakenAsync_Should_Return_VerificationResult_With_Success_False_When_Email_Is_Already_Taken()
{
const string email = "*****@*****.**";
var account = Account.Builder()
.SetId(Guid.NewGuid())
.SetEmail(email)
.SetConfirmed(true)
.SetPasswordHash("PasswordHash")
.SetSecurityStamp(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetRoles(new List <Guid> {
Guid.NewGuid()
})
.Build();
var getAccountResult = GetResult <Account> .Ok(account);
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.EmailIsAlreadyTaken, AccountErrorMessage.EmailIsAlreadyTaken)
};
var expectedResult = VerificationResult.Fail(errors);
_accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>())).ReturnsAsync(getAccountResult);
var result = await _accountVerificationService.VerifyEmailIsNotTakenAsync(email);
result.Should().BeEquivalentTo(expectedResult);
}
public async Task HandleAsync_Should_Throw_ValidationException_When_Account_Is_Already_Confirmed()
{
var requestAccountConfirmationTokenCommand = new RequestAccountConfirmationTokenCommand("*****@*****.**");
var account = Account.Builder()
.SetId(Guid.NewGuid())
.SetEmail(requestAccountConfirmationTokenCommand.Email)
.SetConfirmed(false)
.SetPasswordHash("PasswordHash")
.SetSecurityStamp(Guid.NewGuid())
.SetCreated(DateTimeOffset.UtcNow)
.SetRoles(new List <Guid> {
Guid.NewGuid()
})
.Build();
var getAccountResult = GetResult <Account> .Ok(account);
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.AlreadyConfirmed, AccountErrorMessage.AlreadyConfirmed)
};
var emailIsNotConfirmedVerificationResult = VerificationResult.Fail(errors);
_accountGetterServiceMock.Setup(x => x.GetByEmailAsync(It.IsAny <string>()))
.ReturnsAsync(getAccountResult);
_accountVerificationServiceMock.Setup(x => x.VerifyAccountIsNotConfirmed(It.IsAny <bool>()))
.Returns(emailIsNotConfirmedVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(requestAccountConfirmationTokenCommand);
var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ValidationException_When_Any_Of_CityDistricts_Is_Not_Found()
{
var cityVerificationResult = VerificationResult.Ok();
var errors = new Collection <IError>
{
new Error(CityDistrictErrorCodeEnumeration.NotFound, CityDistrictErrorMessage.NotFound)
};
var cityDistrictsVerificationResult = VerificationResult.Fail(errors);
var createRoomForRentAnnouncementCommand = new CreateRoomForRentAnnouncementCommand(Guid.NewGuid(), "Title",
"http://sourceUrl", Guid.NewGuid(), "Description", null,
new List <RoomTypeEnumeration> {
RoomTypeEnumeration.Single
}, new List <Guid>());
_cityVerificationServiceMock.Setup(x => x.VerifyCityExistsAsync(It.IsAny <Guid>()))
.ReturnsAsync(cityVerificationResult);
_cityDistrictVerificationServiceMock
.Setup(x => x.VerifyCityDistrictsExistAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(cityDistrictsVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(createRoomForRentAnnouncementCommand);
var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public void VerifyAccountCanBeAuthenticated_Should_Return_VerificationResult_With_Success_False_When_Password_Is_Incorrect()
{
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 errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.IncorrectPassword, AccountErrorMessage.IncorrectPassword)
};
var expectedResult = VerificationResult.Fail(errors);
_passwordServiceMock.Setup(x => x.VerifyHashedPassword(It.IsAny <string>(), It.IsAny <string>()))
.Returns(false);
var result = _accountVerificationService.VerifyAccountCanBeAuthenticated(account, "password");
result.Should().BeEquivalentTo(expectedResult);
}
public async Task HandleAsync_Should_Throw_ConflictException_When_Name_And_PolishName_Are_Already_Used()
{
var command = new CreateStateCommand(Guid.NewGuid(), "Name", "PolishName");
var duplicateNameError = new Error(StateErrorCodeEnumeration.NameAlreadyInUse, StateErrorMessage.NameAlreadyInUse);
var duplicatePolishNameError = new Error(StateErrorCodeEnumeration.PolishNameAlreadyInUse, StateErrorMessage.PolishNameAlreadyInUse);
var nameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
duplicateNameError
});
var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
duplicatePolishNameError
});
var errors = new Collection <IError> {
duplicateNameError, duplicatePolishNameError
};
_stateVerificationServiceMock.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_stateVerificationServiceMock.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ConflictException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public static async Task ExpectNone(this ConnectedProjectionScenario <ProductContext> scenario)
{
var database = Guid.NewGuid().ToString("N");
var specification = scenario.Verify(async context =>
{
var actualRecords = await context.AllRecords();
return(actualRecords.Length == 0
? VerificationResult.Pass()
: VerificationResult.Fail($"Expected 0 records but found {actualRecords.Length}."));
});
using (var context = CreateContextFor(database))
{
var projector = new ConnectedProjector <ProductContext>(specification.Resolver);
foreach (var message in specification.Messages)
{
var envelope = new Envelope(message, new Dictionary <string, object>()).ToGenericEnvelope();
await projector.ProjectAsync(context, envelope);
}
await context.SaveChangesAsync();
}
using (var context = CreateContextFor(database))
{
var result = await specification.Verification(context, CancellationToken.None);
if (result.Failed)
{
throw specification.CreateFailedScenarioExceptionFor(result);
}
}
}
public async Task HandleAsync_Should_Throw_ValidationException_When_Account_Has_No_Password()
{
var changePasswordCommand = new ChangePasswordCommand(Guid.NewGuid(), "OldPassword", "NewPassword");
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 getAccountResult = GetResult <Account> .Ok(account);
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.PasswordIsNotSet, AccountErrorMessage.PasswordIsNotSet)
};
var passwordIsSetVerificationResult = VerificationResult.Fail(errors);
_accountGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getAccountResult);
_accountVerificationServiceMock.Setup(x => x.VerifyPasswordIsSet(It.IsAny <string>()))
.Returns(passwordIsSetVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(changePasswordCommand);
var exceptionResult = await result.Should().ThrowAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public VerificationResult VerifyConfirmationCode(Token token, string confirmationCode)
{
if (token is null)
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.ConfirmationCodeWasNotGenerated, AccountErrorMessage.ConfirmationCodeWasNotGenerated)
};
return(VerificationResult.Fail(errors));
}
if (!token.Value.Equals(confirmationCode))
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.IncorrectConfirmationCode, AccountErrorMessage.IncorrectConfirmationCode)
};
return(VerificationResult.Fail(errors));
}
if (DateTimeOffset.UtcNow > token.Expires)
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.ConfirmationCodeExpired, AccountErrorMessage.ConfirmationCodeExpired)
};
return(VerificationResult.Fail(errors));
}
return(VerificationResult.Ok());
}
public void VerifyRoomForRentAnnouncementPreferences_Should_Return_Fail_VerificationResult_When_Prices_Can_Be_Changed()
{
var cityId = Guid.NewGuid();
var cityDistricts = new List <Guid> {
Guid.NewGuid()
};
var roomForRentAnnouncementPreferences = new List <RoomForRentAnnouncementPreference>
{
RoomForRentAnnouncementPreference.Builder()
.SetId(Guid.NewGuid())
.SetCityId(cityId)
.SetPriceMin(0)
.SetPriceMax(1000)
.SetRoomType(RoomTypeEnumeration.Single)
.SetCityDistricts(cityDistricts)
.Build(),
RoomForRentAnnouncementPreference.Builder()
.SetId(Guid.NewGuid())
.SetCityId(cityId)
.SetPriceMin(0)
.SetPriceMax(1500)
.SetRoomType(RoomTypeEnumeration.Single)
.SetCityDistricts(cityDistricts)
.Build()
};
var errors = new List <IError>
{
new Error(RoomForRentAnnouncementPreferenceErrorCode.ChangeablePrices, RoomForRentAnnouncementPreferenceErrorMessage.ChangeablePrices)
};
var expectedResult = VerificationResult.Fail(errors);
var result = _service.VerifyRoomForRentAnnouncementPreferences(roomForRentAnnouncementPreferences);
result.Should().BeEquivalentTo(expectedResult);
}
public async Task HandleAsync_Should_Throw_ValidationException_When_Parent_Is_Not_Found()
{
var city = City.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build();
var getCityResult = GetResult <City> .Ok(city);
var errors = new Collection <IError>
{
new Error(CityDistrictErrorCodeEnumeration.ParentNotFound, CityDistrictErrorMessage.ParentNotFound)
};
var parentExistsVerificationResult = VerificationResult.Fail(errors);
var command = new CreateCityDistrictCommand(Guid.NewGuid(), "Name",
"PolishName", city.Id, Guid.NewGuid(), new Collection <string> {
"NameVariant"
});
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
_cityDistrictVerificationServiceMock.Setup(x => x.VerifyParentExistsAsync(It.IsAny <Guid>()))
.ReturnsAsync(parentExistsVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ValidationException_When_City_And_City_Districts_Verification_Fails()
{
var command = new CreateRoomForRentAnnouncementPreferenceCommand(Guid.NewGuid(), Guid.NewGuid(), 1, 1000,
RoomTypeEnumeration.Single, new List <Guid> {
Guid.NewGuid()
});
var user = User.Builder()
.SetId(command.UserId)
.SetEmail("*****@*****.**")
.SetServiceActive(DefaultUserSettings.ServiceActive)
.SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit)
.SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency)
.Build();
var getUserResult = GetResult <User> .Ok(user);
var errors = new Collection <IError>
{
new Error(CityErrorCodeEnumeration.IncorrectCityDistricts, CityErrorMessage.IncorrectCityDistricts)
};
var cityAndCityDistrictsVerificationResult = VerificationResult.Fail(errors);
_userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult);
_cityVerificationServiceMock
.Setup(x => x.VerifyCityAndCityDistrictsAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(cityAndCityDistrictsVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public VerificationResult VerifyFlatForRentAnnouncementPreferences(IEnumerable <FlatForRentAnnouncementPreference> flatForRentAnnouncementPreferences)
{
var flatForRentAnnouncementPreferencesGroupedByCityId = GetFlatForRentAnnouncementPreferencesGroupedByCityId(flatForRentAnnouncementPreferences);
var errors = new List <IError>();
if (AreAnyWithExpansibleCityDistricts(flatForRentAnnouncementPreferencesGroupedByCityId))
{
var error = new Error(FlatForRentAnnouncementPreferenceErrorCode.ExpansibleCityDistricts, FlatForRentAnnouncementPreferenceErrorMessage.ExpansibleCityDistricts);
errors.Add(error);
}
if (AreAnyWithChangeablePrices(flatForRentAnnouncementPreferencesGroupedByCityId))
{
var error = new Error(FlatForRentAnnouncementPreferenceErrorCode.ChangeablePrices, FlatForRentAnnouncementPreferenceErrorMessage.ChangeablePrices);
errors.Add(error);
}
if (AreAnyWithChangeableRoomNumbers(flatForRentAnnouncementPreferencesGroupedByCityId))
{
var error = new Error(FlatForRentAnnouncementPreferenceErrorCode.ChangeableRoomNumbers, FlatForRentAnnouncementPreferenceErrorMessage.ChangeableRoomNumbers);
errors.Add(error);
}
return(errors.Any() ? VerificationResult.Fail(errors) : VerificationResult.Ok());
}
public static Task ExpectNone(this ProjectionScenario <IAsyncDocumentSession> scenario)
{
return(scenario
.Verify(async session =>
{
using (var streamer = await session.Advanced.StreamAsync <RavenJObject>(Etag.Empty))
{
if (await streamer.MoveNextAsync())
{
var storedDocumentIdentifiers = new List <string>();
do
{
storedDocumentIdentifiers.Add(streamer.Current.Key);
} while (await streamer.MoveNextAsync());
return VerificationResult.Fail(
string.Format("Expected no documents, but found {0} document(s) ({1}).",
storedDocumentIdentifiers.Count,
string.Join(",", storedDocumentIdentifiers)));
}
return VerificationResult.Pass();
}
})
.Assert());
}
public async Task HandleAsync_Should_Throw_ConflictException_When_Name_And_PolishName_Are_Already_Used()
{
var cityDistrict = CityDistrict.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetCityId(Guid.NewGuid())
.SetParentId(Guid.NewGuid())
.SetNameVariants(new List <string> {
"NameVariant"
})
.Build();
var getCityDistrict = GetResult <CityDistrict> .Ok(cityDistrict);
var city = City.Builder()
.SetId(Guid.NewGuid())
.SetRowVersion(Array.Empty <byte>())
.SetName("Name")
.SetPolishName("PolishName")
.SetStateId(Guid.NewGuid())
.Build();
var getCityResult = GetResult <City> .Ok(city);
var parentExistsVerificationResult = VerificationResult.Ok();
var nameIsNotTakenError = new Error(CityDistrictErrorCodeEnumeration.NameAlreadyInUse, CityDistrictErrorMessage.NameAlreadyInUse);
var nameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
nameIsNotTakenError
});
var polishNameIsNotTakenError = new Error(CityDistrictErrorCodeEnumeration.PolishNameAlreadyInUse, CityDistrictErrorMessage.PolishNameAlreadyInUse);
var polishNameIsNotTakenVerificationResult = VerificationResult.Fail(new Collection <IError> {
polishNameIsNotTakenError
});
var command = new UpdateCityDistrictCommand(cityDistrict.Id, cityDistrict.RowVersion, "NewName",
"NewPolishName", city.Id, Guid.NewGuid(), new Collection <string> {
"NewNameVariant"
});
var errors = new Collection <IError> {
nameIsNotTakenError, polishNameIsNotTakenError
};
_cityDistrictGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(getCityDistrict);
_cityGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getCityResult);
_cityDistrictVerificationServiceMock.Setup(x => x.VerifyParentExistsAsync(It.IsAny <Guid>()))
.ReturnsAsync(parentExistsVerificationResult);
_cityDistrictVerificationServiceMock
.Setup(x => x.VerifyNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(nameIsNotTakenVerificationResult);
_cityDistrictVerificationServiceMock
.Setup(x => x.VerifyPolishNameIsNotTakenAsync(It.IsAny <string>(), It.IsAny <Guid>()))
.ReturnsAsync(polishNameIsNotTakenVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ConflictException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task <VerificationResult> VerifyNameIsNotTakenAsync(string name)
{
return(await IsNameAlreadyUsedAsync(name)
? VerificationResult.Fail(new Collection <IError> {
new Error(StateErrorCodeEnumeration.NameAlreadyInUse, StateErrorMessage.NameAlreadyInUse)
})
: VerificationResult.Ok());
}
public void FailReturnsExpectedResult(string message)
{
var result = VerificationResult.Fail(message);
Assert.That(result.Passed, Is.False);
Assert.That(result.Failed, Is.True);
Assert.That(result.Message, Is.EqualTo(message));
}
public async Task <VerificationResult> VerifyPolishNameIsNotTakenAsync(string polishName, Guid cityId)
{
return(await IsPolishNameAlreadyUsedAsync(polishName, cityId)
? VerificationResult.Fail(new Collection <IError>
{
new Error(CityDistrictErrorCodeEnumeration.PolishNameAlreadyInUse, CityDistrictErrorMessage.PolishNameAlreadyInUse)
})
: VerificationResult.Ok());
}
public async Task HandleAsync_Should_Throw_ValidationException_When_Flat_For_Rent_Announcement_Preferences_Verification_Fails()
{
var command = new CreateFlatForRentAnnouncementPreferenceCommand(Guid.NewGuid(), Guid.NewGuid(), 1, 1000, 1,
1, new List <Guid> {
Guid.NewGuid()
});
var user = User.Builder()
.SetId(command.UserId)
.SetEmail("*****@*****.**")
.SetServiceActive(DefaultUserSettings.ServiceActive)
.SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit)
.SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency)
.Build();
var getUserResult = GetResult <User> .Ok(user);
var cityAndCityDistrictsVerificationResult = VerificationResult.Ok();
var announcementPreferenceLimitIsNotExceededVerificationResult = VerificationResult.Ok();
var flatForRentAnnouncementPreference = FlatForRentAnnouncementPreference.Builder()
.SetId(command.FlatForRentAnnouncementPreferenceId)
.SetCityId(command.CityId)
.SetPriceMin(command.PriceMin)
.SetPriceMax(command.PriceMax)
.SetRoomNumbersMin(command.RoomNumbersMin)
.SetRoomNumbersMax(command.RoomNumbersMax)
.SetCityDistricts(command.CityDistricts)
.Build();
var errors = new Collection <IError>
{
new Error(FlatForRentAnnouncementPreferenceErrorCode.ExpansibleCityDistricts,
FlatForRentAnnouncementPreferenceErrorMessage.ExpansibleCityDistricts)
};
var flatForRentAnnouncementPreferencesVerificationResult = VerificationResult.Fail(errors);
_userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult);
_cityVerificationServiceMock
.Setup(x => x.VerifyCityAndCityDistrictsAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(cityAndCityDistrictsVerificationResult);
_userVerificationServiceMock
.Setup(x => x.VerifyAnnouncementPreferenceLimitIsNotExceeded(It.IsAny <int>(), It.IsAny <int>()))
.Returns(announcementPreferenceLimitIsNotExceededVerificationResult);
_mapperMock.Setup(x =>
x.Map <CreateFlatForRentAnnouncementPreferenceCommand, FlatForRentAnnouncementPreference>(
It.IsAny <CreateFlatForRentAnnouncementPreferenceCommand>()))
.Returns(flatForRentAnnouncementPreference);
_flatForRentAnnouncementPreferenceVerificationServiceMock
.Setup(x => x.VerifyFlatForRentAnnouncementPreferences(
It.IsAny <IEnumerable <FlatForRentAnnouncementPreference> >()))
.Returns(flatForRentAnnouncementPreferencesVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public async Task HandleAsync_Should_Throw_ValidationException_When_Room_For_Rent_Announcement_Preferences_Verification_Fails()
{
var command = new UpdateRoomForRentAnnouncementPreferenceCommand(Guid.NewGuid(), Guid.NewGuid(),
Guid.NewGuid(), 1, 1500, RoomTypeEnumeration.Double, new List <Guid> {
Guid.NewGuid()
});
var user = User.Builder()
.SetId(command.UserId)
.SetEmail("*****@*****.**")
.SetServiceActive(DefaultUserSettings.ServiceActive)
.SetAnnouncementPreferenceLimit(DefaultUserSettings.AnnouncementPreferenceLimit)
.SetAnnouncementSendingFrequency(DefaultUserSettings.AnnouncementSendingFrequency)
.Build();
var getUserResult = GetResult <User> .Ok(user);
var roomForRentAnnouncementPreference = RoomForRentAnnouncementPreference.Builder()
.SetId(command.RoomForRentAnnouncementPreferenceId)
.SetCityId(Guid.NewGuid())
.SetPriceMin(1)
.SetPriceMax(1000)
.SetRoomType(RoomTypeEnumeration.Single)
.SetCityDistricts(new List <Guid> {
Guid.NewGuid()
})
.Build();
var getRoomForRentAnnouncementPreferenceResult =
GetResult <RoomForRentAnnouncementPreference> .Ok(roomForRentAnnouncementPreference);
var cityAndCityDistrictsVerificationResult = VerificationResult.Ok();
var errors = new Collection <IError>
{
new Error(RoomForRentAnnouncementPreferenceErrorCode.ExpansibleCityDistricts,
RoomForRentAnnouncementPreferenceErrorMessage.ExpansibleCityDistricts)
};
var roomForRentAnnouncementPreferencesVerificationResult = VerificationResult.Fail(errors);
_userGetterServiceMock.Setup(x => x.GetByIdAsync(It.IsAny <Guid>())).ReturnsAsync(getUserResult);
_roomForRentAnnouncementPreferenceGetterServiceMock
.Setup(x => x.GetByByUserAndId(It.IsAny <User>(), It.IsAny <Guid>()))
.Returns(getRoomForRentAnnouncementPreferenceResult);
_cityVerificationServiceMock
.Setup(x => x.VerifyCityAndCityDistrictsAsync(It.IsAny <Guid>(), It.IsAny <IEnumerable <Guid> >()))
.ReturnsAsync(cityAndCityDistrictsVerificationResult);
_roomForRentAnnouncementPreferenceVerificationServiceMock
.Setup(x => x.VerifyRoomForRentAnnouncementPreferences(
It.IsAny <IEnumerable <RoomForRentAnnouncementPreference> >()))
.Returns(roomForRentAnnouncementPreferencesVerificationResult);
Func <Task> result = async() => await _commandHandler.HandleAsync(command);
var exceptionResult = await result.Should().ThrowExactlyAsync <ValidationException>();
exceptionResult.And.Errors.Should().BeEquivalentTo(errors);
}
public void VerifyAccountToken_Should_Return_VerificationResult_With_Success_False_When_Token_Is_Null()
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.ConfirmationCodeWasNotGenerated, AccountErrorMessage.ConfirmationCodeWasNotGenerated)
};
var expectedResult = VerificationResult.Fail(errors);
var result = _accountVerificationService.VerifyConfirmationCode(null, "12345");
result.Should().BeEquivalentTo(expectedResult);
}
public static Task Expect(this ProjectionScenario <MemoryCache> scenario, params CacheItem[] items)
{
if (items == null)
{
throw new ArgumentNullException("items");
}
if (items.Length == 0)
{
return(scenario.ExpectNone());
}
return(scenario.
Verify(cache =>
{
if (cache.GetCount() != items.Length)
{
if (cache.GetCount() == 0)
{
return Task.FromResult(
VerificationResult.Fail(
string.Format("Expected {0} cache item(s), but found 0 cache items.",
items.Length)));
}
return Task.FromResult(
VerificationResult.Fail(
string.Format("Expected {0} cache item(s), but found {1} cache item(s) ({2}).",
items.Length,
cache.GetCount(),
string.Join(",", cache.Select(pair => pair.Key)))));
}
if (!cache.Select(pair => cache.GetCacheItem(pair.Key)).SequenceEqual(items, new CacheItemEqualityComparer()))
{
var builder = new StringBuilder();
builder.AppendLine("Expected the following cache items:");
foreach (var expectedItem in items)
{
builder.AppendLine(expectedItem.Key + ": " + JToken.FromObject(expectedItem.Value).ToString());
}
builder.AppendLine();
builder.AppendLine("But found the following cache items:");
foreach (var actualItem in cache)
{
builder.AppendLine(actualItem.Key + ": " + JToken.FromObject(actualItem.Value).ToString());
}
return Task.FromResult(VerificationResult.Fail(builder.ToString()));
}
return Task.FromResult(VerificationResult.Pass());
}).
Assert());
}
public async Task Given_no_messages_Then_list_is_empty()
{
var projection = new MunicipalityListProjections();
var resolver = ConcurrentResolve.WhenEqualToHandlerMessageType(projection.Handlers);
await new ConnectedProjectionScenario <LegacyContext>(resolver)
.Given()
.Verify(async context =>
await context.MunicipalityList.AnyAsync()
? VerificationResult.Fail()
: VerificationResult.Pass())
.Assert();
}
public VerificationResult VerifyPasswordIsNotSet(string passwordHash)
{
if (!string.IsNullOrWhiteSpace(passwordHash))
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.PasswordAlreadySet, AccountErrorMessage.PasswordAlreadySet)
};
return(VerificationResult.Fail(errors));
}
return(VerificationResult.Ok());
}
public VerificationResult VerifyPassword(string passwordHash, string password)
{
if (!_passwordService.VerifyHashedPassword(passwordHash, password))
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.IncorrectPassword, AccountErrorMessage.IncorrectPassword)
};
return(VerificationResult.Fail(errors));
}
return(VerificationResult.Ok());
}
public VerificationResult VerifyAccountIsConfirmed(bool confirmed)
{
if (!confirmed)
{
var errors = new Collection <IError>
{
new Error(AccountErrorCodeEnumeration.NotConfirmed, AccountErrorMessage.NotConfirmed)
};
return(VerificationResult.Fail(errors));
}
return(VerificationResult.Ok());
}
public async Task <VerificationResult> VerifyNameIsNotTakenAsync(string name)
{
var role = await _roleRepository.GetByNameAsync(name);
if (role != null)
{
var errors = new Collection <IError>
{
new Error(RoleErrorCodeEnumeration.NameIsAlreadyTaken, RoleErrorMessage.NameIsAlreadyTaken)
};
return(VerificationResult.Fail(errors));
}
return(VerificationResult.Ok());
}
public static async Task Expect(
this ConnectedProjectionScenario <ProductContext> scenario,
params object[] records)
{
var database = Guid.NewGuid().ToString("N");
var specification = scenario.Verify(async context =>
{
var comparisonConfig = new ComparisonConfig {
MaxDifferences = 5
};
var comparer = new CompareLogic(comparisonConfig);
var actualRecords = await context.AllRecords();
var result = comparer.Compare(
actualRecords,
records
);
return(result.AreEqual
? VerificationResult.Pass()
: VerificationResult.Fail(result.CreateDifferenceMessage(actualRecords, records)));
});
using (var context = CreateContextFor(database))
{
var projector = new ConnectedProjector <ProductContext>(specification.Resolver);
var position = 0L;
foreach (var message in specification.Messages)
{
var envelope = new Envelope(message, new Dictionary <string, object> {
{ "Position", position }
}).ToGenericEnvelope();
await projector.ProjectAsync(context, envelope);
position++;
}
await context.SaveChangesAsync();
}
using (var context = CreateContextFor(database))
{
var result = await specification.Verification(context, CancellationToken.None);
if (result.Failed)
{
throw specification.CreateFailedScenarioExceptionFor(result);
}
}
}
