public void Should_validate_command_and_save_new_language()
{
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = "url"
};
var languageRepositoryMock = new Mock <ILanguageRepository>();
languageRepositoryMock.Setup(x => x.Create(It.IsAny <Language>()));
var validatorMock = new Mock <IValidator <CreateLanguage> >();
validatorMock.Setup(x => x.Validate(command)).Returns(new ValidationResult());
var sortOrderGeneratorMock = new Mock <ILanguageSortOrderGenerator>();
var createLanguageHandler = new CreateLanguageHandler(languageRepositoryMock.Object, validatorMock.Object, sortOrderGeneratorMock.Object);
createLanguageHandler.Handle(command);
validatorMock.Verify(x => x.Validate(command));
languageRepositoryMock.Verify(x => x.Create(It.IsAny <Language>()));
}
public void Setup()
{
_languageId = Guid.NewGuid();
_newSortOrder = 1;
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = _languageId,
Name = "My Language",
CultureName = "aa-bb",
Url = "url"
};
var validatorMock = new Mock <IValidator <CreateLanguage> >();
validatorMock.Setup(x => x.Validate(command)).Returns(new ValidationResult());
var sortOrderGeneratorMock = new Mock <ILanguageSortOrderGenerator>();
sortOrderGeneratorMock.Setup(x => x.GenerateNextSortOrder(command.SiteId)).Returns(2);
_language = Language.CreateNew(command, validatorMock.Object, sortOrderGeneratorMock.Object);
_language.Reorder(_newSortOrder);
_event = _language.Events.OfType <LanguageReordered>().SingleOrDefault();
}
public void CreateLanguage_Action_Fails()
{
// Arrange
var languageDto = TestHelper.LanguageDto();
GenericServiceResponse <bool> fakeResponse = null;
mockClientServicesProvider.Setup(x => x.Logger).Returns(mockLogger.Object).Verifiable();
mockClientServicesProvider.Setup(x => x.LanguageService.CreateLanguage(languageDto)).Returns(fakeResponse).Verifiable();
var viewModel = new GenericViewModel();
var action = new CreateLanguage <GenericViewModel>(mockClientServicesProvider.Object)
{
OnComplete = model => viewModel = model
};
// Act
var result = action.Invoke(languageDto);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(GenericViewModel));
Assert.IsNotNull(result.Notifications);
Assert.IsInstanceOfType(result.Notifications, typeof(NotificationCollection));
Assert.IsTrue(result.Notifications.Count() == 1);
Assert.IsTrue(result.HasErrors);
Assert.IsNotNull(result.Success);
Assert.IsInstanceOfType(result.Success, typeof(bool));
Assert.IsFalse(result.Success);
}
public Language Add(CreateLanguage CreateLanguage)
{
Language language = new Language();
language.Name = CreateLanguage.Name;
return(_languageRepo.Create(language));
}
public async Task <IActionResult> Post([FromBody] CreateLanguage model)
{
model.SiteId = SiteId;
await _commandSender.SendAsync <CreateLanguage, Language>(model);
return(new NoContentResult());
}
public void Should_throw_validation_exception_when_validation_fails()
{
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = "url"
};
var languageRepositoryMock = new Mock <ILanguageRepository>();
var validatorMock = new Mock <IValidator <CreateLanguage> >();
validatorMock.Setup(x => x.Validate(command)).Returns(new ValidationResult(new List <ValidationFailure> {
new ValidationFailure("Id", "Id Error")
}));
var sortOrderGeneratorMock = new Mock <ILanguageSortOrderGenerator>();
var createLanguageHandler = new CreateLanguageHandler(languageRepositoryMock.Object, validatorMock.Object, sortOrderGeneratorMock.Object);
Assert.Throws <ValidationException>(() => createLanguageHandler.Handle(command));
}
public async Task <IActionResult> Post([FromBody] CreateLanguage model)
{
model.SiteId = SiteId;
model.Id = Guid.NewGuid();
await Task.Run(() => _commandSender.Send <CreateLanguage, Language>(model));
return(new NoContentResult());
}
public static Language CreateNew(CreateLanguage cmd,
IValidator <CreateLanguage> validator,
ILanguageSortOrderGenerator sortOrderGenerator)
{
validator.ValidateCommand(cmd);
return(new Language(cmd, sortOrderGenerator));
}
public ActionResult Create(CreateLanguage createLanguage)
{
if (ModelState.IsValid)
{
_languageService.Add(createLanguage);
return(RedirectToAction(nameof(Index)));
}
return(View(createLanguage));
}
public Language Add(CreateLanguage createLanguage)
{
Language language = new Language()
{
LanguangeName = createLanguage.LanguangeName
};
return(_languageRepo.Create(language));
}
public Language Edit(int id, CreateLanguage language)
{
Language l = FindbyId(id);
if (l == null)
{
return(null);
}
l.Name = language.Name;
l = _languageRepo.Update(l);
return(l);
}
private Language(CreateLanguage cmd, ILanguageSortOrderGenerator languageSortOrderGenerator)
: base(cmd.Id)
{
AddEvent(new LanguageCreated
{
SiteId = cmd.SiteId,
AggregateRootId = Id,
Name = cmd.Name,
CultureName = cmd.CultureName,
Url = cmd.Url,
SortOrder = languageSortOrderGenerator.GenerateNextSortOrder(cmd.SiteId),
Status = LanguageStatus.Hidden
});
}
static Promise<long> createLanguage()
{
Promise<long> promise = new Promise<long>();
CreateLanguage request = new CreateLanguage();
builder.Build(request);
while (!request.Process().isDone) { }
if (request.Successful()) {
request.ParseResult();
promise.Resolve(request.Model.id);
}
else {
promise.Reject(new Exception(request.GetErrorMessage()));
}
return promise;
}
public void Setup()
{
_command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = "url"
};
_validatorMock = new Mock <IValidator <CreateLanguage> >();
_validatorMock.Setup(x => x.Validate(_command)).Returns(new ValidationResult());
_sortOrderGeneratorMock = new Mock <ILanguageSortOrderGenerator>();
_sortOrderGeneratorMock.Setup(x => x.GenerateNextSortOrder(_command.SiteId)).Returns(4);
_language = Language.CreateNew(_command, _validatorMock.Object, _sortOrderGeneratorMock.Object);
_event = _language.Events.OfType <LanguageCreated>().SingleOrDefault();
}
public void Should_have_validation_error_when_language_name_is_too_short()
{
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "A",
CultureName = "aa-bb",
Url = "url"
};
var languageRulesMock = new Mock <ILanguageRules>();
var siteRulesMock = new Mock <ISiteRules>();
var validator = new CreateLanguageValidator(languageRulesMock.Object, siteRulesMock.Object);
validator.ShouldHaveValidationErrorFor(x => x.Name, command);
}
public void Should_have_validation_error_when_site_id_is_empty()
{
var command = new CreateLanguage
{
SiteId = Guid.Empty,
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = "url"
};
var languageRulesMock = new Mock <ILanguageRules>();
var siteRulesMock = new Mock <ISiteRules>();
var validator = new CreateLanguageValidator(languageRulesMock.Object, siteRulesMock.Object);
validator.ShouldHaveValidationErrorFor(x => x.SiteId, command);
}
public void Should_have_validation_error_when_language_id_already_exists()
{
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = "url"
};
var languageRulesMock = new Mock <ILanguageRules>();
languageRulesMock.Setup(x => x.IsLanguageIdUnique(command.Id)).Returns(false);
var siteRulesMock = new Mock <ISiteRules>();
var validator = new CreateLanguageValidator(languageRulesMock.Object, siteRulesMock.Object);
validator.ShouldHaveValidationErrorFor(x => x.Id, command);
}
public static Language Language(Guid siteId, Guid id, string name, string cultureName, string url)
{
var command = new CreateLanguage
{
SiteId = siteId,
Id = id,
Name = name,
CultureName = cultureName,
Url = url
};
var validatorMock = new Mock <IValidator <CreateLanguage> >();
validatorMock.Setup(x => x.Validate(command)).Returns(new ValidationResult());
var sortOrderGeneratorMock = new Mock <ILanguageSortOrderGenerator>();
sortOrderGeneratorMock.Setup(x => x.GenerateNextSortOrder(command.SiteId)).Returns(2);
return(Domain.Languages.Language.CreateNew(command, validatorMock.Object, sortOrderGeneratorMock.Object));
}
public void Should_have_validation_error_when_site_does_not_exist()
{
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = "url"
};
var languageRulesMock = new Mock <ILanguageRules>();
var siteRulesMock = new Mock <ISiteRules>();
siteRulesMock.Setup(x => x.DoesSiteExist(command.SiteId)).Returns(false);
var validator = new CreateLanguageValidator(languageRulesMock.Object, siteRulesMock.Object);
validator.ShouldHaveValidationErrorFor(x => x.SiteId, command);
}
public void Should_have_validation_error_when_url_is_not_valid()
{
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = "a@b"
};
var languageRulesMock = new Mock <ILanguageRules>();
languageRulesMock.Setup(x => x.IsLanguageUrlValid(command.Url)).Returns(false);
var siteRulesMock = new Mock <ISiteRules>();
var validator = new CreateLanguageValidator(languageRulesMock.Object, siteRulesMock.Object);
validator.ShouldHaveValidationErrorFor(x => x.Url, command);
}
public void Should_have_validation_error_when_culture_name_is_not_unique()
{
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = "url"
};
var languageRulesMock = new Mock <ILanguageRules>();
languageRulesMock.Setup(x => x.IsCultureNameUnique(command.SiteId, command.CultureName, Guid.Empty)).Returns(false);
var siteRulesMock = new Mock <ISiteRules>();
var validator = new CreateLanguageValidator(languageRulesMock.Object, siteRulesMock.Object);
validator.ShouldHaveValidationErrorFor(x => x.CultureName, command);
}
public void Should_have_validation_error_when_url_is_too_long()
{
var url = "";
for (int i = 0; i < 101; i++)
{
url += i;
}
var command = new CreateLanguage
{
SiteId = Guid.NewGuid(),
Id = Guid.NewGuid(),
Name = "My Language",
CultureName = "aa-bb",
Url = url
};
var languageRulesMock = new Mock <ILanguageRules>();
var siteRulesMock = new Mock <ISiteRules>();
var validator = new CreateLanguageValidator(languageRulesMock.Object, siteRulesMock.Object);
validator.ShouldHaveValidationErrorFor(x => x.Url, command);
}
public async Task <CreatedEntity <int> > CreateLanguageAsync([FromBody] CreateLanguage createLanguage)
{
return(await _mediator.Send(createLanguage));
}
public Language Edit(int id, CreateLanguage language)
{
throw new NotImplementedException();
}
