public void IsInvalidWhen_UserName_MatchesExistingUser() { const string userName = "******"; const string userDisplayName = "Bruce Wayne"; const string personDisplayName = "Adam West"; var command = new CreatePersonCommand { DisplayName = personDisplayName, UserName = userName, }; var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict); queryProcessor.Setup(m => m.Execute(It.Is<GetUserByNameQuery>(q => q.Name == command.UserName))) .Returns(new User { Person = new Person { DisplayName = userDisplayName, } }); var validator = new CreatePersonValidator(queryProcessor.Object); var results = validator.Validate(command); results.IsValid.ShouldBeFalse(); results.Errors.Count.ShouldBeInRange(1, int.MaxValue); var error = results.Errors.SingleOrDefault(e => e.PropertyName == "UserName"); error.ShouldNotBeNull(); // ReSharper disable PossibleNullReferenceException error.ErrorMessage.ShouldEqual(string.Format( ValidateUser.FailedBecauseNameMatchedEntity, userName)); // ReSharper restore PossibleNullReferenceException }
public void IsValidWhen_DisplayName_IsNotEmpty() { var command = new CreatePersonCommand { DisplayName = "Adam West" }; var validator = new CreatePersonValidator(null); var results = validator.Validate(command); var error = results.Errors.SingleOrDefault(e => e.PropertyName == "DisplayName"); error.ShouldBeNull(); }
public void IsInvalidWhen_DisplayName_IsWhiteSpace() { var command = new CreatePersonCommand { DisplayName = " " }; var validator = new CreatePersonValidator(null); var results = validator.Validate(command); results.IsValid.ShouldBeFalse(); results.Errors.Count.ShouldBeInRange(1, int.MaxValue); var error = results.Errors.SingleOrDefault(e => e.PropertyName == "DisplayName"); error.ShouldNotBeNull(); // ReSharper disable PossibleNullReferenceException error.ErrorMessage.ShouldEqual(ValidatePerson.FailedBecauseDisplayNameWasEmpty); // ReSharper restore PossibleNullReferenceException }
public Person Create(CreatePersonCommand command) { var Person = new Person(command.Name, command.CPF, command.BirthDate, command.Genre, command.Address, command.Phone, command.Photograph); Person.Validate(); _repository.Create(Person); if (Commit()) { return(Person); } return(null); }
public async Task TestValidator_InvalidSex() { //Arrange var validator = new PersonCommandValidator(); CreatePersonCommand createCommand = MakeCommand(); createCommand.Sex = "S"; //Act var result = await validator.ValidateAsync(createCommand); //Assert Assert.Equal("Sex", result.Errors[0].PropertyName); }
public async Task <IActionResult> Post([FromBody] CreatePersonCommand command) { bool commandResult = false; var id = Guid.NewGuid(); var requestPersonCreate = new IdentifiedCommand <CreatePersonCommand, bool>(new CreatePersonCommand(command.FirstName, command.LastName, command.Email), id); commandResult = await _mediator.Send(requestPersonCreate); return(commandResult ? (IActionResult)Ok() : (IActionResult)BadRequest()); /* var result = await _mediator.Send(command); * * return result ? (IActionResult)Accepted() : (IActionResult)BadRequest(); */ }
public void Setup() { // Arrange _personRepositoryMock = new Mock <IPersonRepository>(); _personRepositoryMock .Setup(x => x.Add(It.IsAny <Person>())) .Callback <Person>(x => { _personAdded = x; }); _command = new CreatePersonCommand(_oid, FirstName, LastName); _dut = new CreatePersonCommandHandler(_personRepositoryMock.Object, UnitOfWorkMock.Object); }
public PersonAggregate(CreatePersonCommand cmd) { Id = Guid.NewGuid(); State = new Person { PersonId = Id, UserId = cmd.IdentifierId, Username = cmd.Username, Name = cmd.Name.Capitalize(), Description = "Eu sou novo no Flue!", Email = cmd.Email, Following = new List <Person>(), Followers = new List <Person>() }; }
public async Task <Person> Create(CreatePersonCommand command) { var coffeePlaces = await GetCoffeePlaces(command.CoffeePlaceIds); var eventRooms = await GetEventRooms(command.EventRoomIds); command.AddCoffeePlaces(coffeePlaces); command.AddEventRooms(eventRooms); var eventRoom = new Person(command); await _personRepository .AddAsync(eventRoom); return(eventRoom); }
public void ThrowExeptionWhenCommandParametersAreLessThanItShouldCorrectly() { string name = "PersonName"; IMember person = new Member(name); database.Members.Add(person); List <string> parameters = new List <string> { }; CreatePersonCommand command = new CreatePersonCommand(parameters); command.Execute(); Assert.IsTrue(database.Members.Any(x => x.Name == name)); }
public void ThrowException_WhenPassedInvalidParametersCount() { var expectedMessage = "Failed to parse CreatePerson command parameters."; var databaseMock = new Mock <IDataBase>(); var factoryMock = new Mock <IFactory>(); var parameters = new List <string>() { "name", "name" }; var sut = new CreatePersonCommand(factoryMock.Object, databaseMock.Object); var ex = Assert.ThrowsException <ArgumentException>(() => sut.Execute(parameters)); Assert.AreEqual(expectedMessage, ex.Message); }
public ActionResult CreatePerson(CreatePersonCommand createPerson) { var person = personService.Load(User.Identity.GetUserId()); if (person != null) { return(RedirectToAction("Index", "Home")); } if (person == null && ModelState.IsValid) { personService.Create(createPerson, User.Identity.GetUserId()); return(RedirectToAction("Index", "Home")); } return(View()); }
public void ThrowArgumentException_WhenNullPersonIsReturned() { //Arrange this.componentsFactoryMock .Setup(x => x.CreatePerson(this.validPersonName)); var sut = new CreatePersonCommand(this.historyEventWriterMock.Object, personsCollectionMock.Object, this.componentsFactoryMock.Object); var parameters = new List <string>() { this.validPersonName }; var expectedReturn = string.Format(CommandsConsts.ObjectCreated, nameof(Person), validPersonName); //Act, Assert Assert.ThrowsException <ArgumentException>(() => sut.Execute(parameters)); }
public void CreatePersonCommand() { string name = "PersonName"; IMember person = new Member(name); database.Members.Add(person); List <string> parameters = new List <string> { name }; CreatePersonCommand command = new CreatePersonCommand(parameters); command.Execute(); Assert.IsTrue(database.Members.Any(x => x.Name == name)); }
public async Task <IActionResult> Insert([FromBody] CreatePersonCommand command) { try { Response <IPersonCreatedEvent> response = await _createPersonClient.GetResponse <IPersonCreatedEvent>(command); return(Ok(_factory.Data(response.Message))); } catch (MongoWriteException exception) { return(CreateExceptionError(exception, "1001", "Error writing new person")); } catch (ArgumentNullException exception) { return(CreateExceptionError(exception, "1001", "Error writing new person")); } }
public async Task Handle_FutureDateOfBirth_ShouldReturnValidationErrors() { var handler = new CreatePersonCommandHandler(_mapper, _mockPersonRepository.Object, _mockLogger.Object, _cacheService.Object); var newPerson = new CreatePersonCommand { Firstname = "Test Firstname", Surname = "Test Surname", Gender = "Male", EmailAddress = "Test Email", PhoneNumber = "Test Phonenumber", DateOfBirth = DateTime.Now.AddDays(1) }; CreatePersonCommandResponse response = await handler.Handle(newPerson, CancellationToken.None); response.ValidationErrors.Count.ShouldBeGreaterThan(0); }
public async Task <BaseResponse <CreatePersonDto> > Handle(CreatePersonCommand request, CancellationToken cancellationToken) { try { var personId = await _personRepository.CreatePersonAsync( new Person(request.FirstName, request.LastName, request.DateOfBirth, request.Pesel)); return(new BaseResponse <CreatePersonDto>(new CreatePersonDto() { Id = personId })); } catch (Exception e) { // there should be logging return(new BaseResponse <CreatePersonDto>("An error occurred when handling request.")); } }
public void CreatesPerson_WithLastName() { var command = new CreatePersonCommand { LastName = "West", }; var entities = new Mock<ICommandEntities>(MockBehavior.Strict); Person outPerson = null; entities.Setup(m => m.Create(It.IsAny<Person>())) .Callback((Entity entity) => outPerson = (Person)entity); var handler = new CreatePersonHandler(entities.Object); handler.Handle(command); outPerson.ShouldNotBeNull(); outPerson.LastName.ShouldEqual(command.LastName); entities.Verify(m => m.Create(It.Is<Person>(p => p.LastName == command.LastName)), Times.Once()); }
public IActionResult Create(CreatePersonCommand command) { try { if (ModelState.IsValid) { var id = _service.CreatePerson(command); return(RedirectToAction(nameof(View), new { id = id })); } } catch (Exception) { ModelState.AddModelError( string.Empty, "An error occured saving the person" ); _logger.LogWarning("Could not save"); } return(View(command)); }
public async Task Handle_ValidPerson_AddedToPersonsRepo() { var handler = new CreatePersonCommandHandler(_mapper, _mockPersonRepository.Object, _mockLogger.Object, _cacheService.Object); var newPerson = new CreatePersonCommand { Firstname = "Test Firstname", Surname = "Test Surname", Gender = "Male", EmailAddress = "Test Email", PhoneNumber = "Test Phonenumber", DateOfBirth = DateTime.Now.AddYears(-30) }; await handler.Handle(newPerson, CancellationToken.None); var allPersons = await _mockPersonRepository.Object.ListAllAsync(); allPersons.Count.ShouldBe(3); }
public async Task Create_New_Person() { using (var context = GetContextWithData()) { var handler = new CreatePersonCommandHandler(context); var command = new CreatePersonCommand { Name = "Name", Email = "*****@*****.**", IsAdmin = false }; await handler.Handle(command, CancellationToken.None); var person = await context.Persons.SingleOrDefaultAsync(c => c.Name == command.Name); Assert.Equal(command.Name, person.Name); Assert.Equal(command.Email, person.Email); Assert.Equal(command.IsAdmin, person.IsAdmin); } }
public int CreatePerson(CreatePersonCommand cmd) { var person = new Person { FirstName = cmd.FirstName, LastName = cmd.LastName, BirthDate = cmd.BirthDate, City = cmd.City, State = cmd.State, Accomplishments = cmd.Accomplishments?.Select(i => new Accomplishment { Name = i.Name, DateOfAccomplishment = i.DateOfAccomplishment, }).ToList() }; _context.Add(person); _context.SaveChanges(); return(person.Id); }
public void ReturnCorrectMessage_WhenCorrectParametrsArePassed() { //Arrange this.componentsFactoryMock .Setup(x => x.CreatePerson(this.validPersonName)) .Returns(this.personMock.Object); var sut = new CreatePersonCommand(this.historyEventWriterMock.Object, personsCollectionMock.Object, this.componentsFactoryMock.Object); var parameters = new List <string>() { this.validPersonName }; var expectedReturn = string.Format(CommandsConsts.ObjectCreated, nameof(Person), validPersonName); //Act var actualReturn = sut.Execute(parameters); //Assert Assert.AreEqual(expectedReturn, actualReturn); }
protected Person Seed(int?establishmentId, CreatePersonCommand command) { // make sure entity does not already exist var person = _queryProcessor.Execute(new GetPersonByEmailQuery { Email = command.EmailAddresses.First().Value, }); if (person != null) { return(person); } if (string.IsNullOrWhiteSpace(command.DisplayName)) { command.DisplayName = string.Format("{0} {1}", command.FirstName, command.LastName); } _createPerson.Handle(command); _unitOfWork.SaveChanges(); person = command.CreatedPerson; if (establishmentId.HasValue) { _createAffiliation.Handle(new CreateAffiliationCommand { EstablishmentId = establishmentId.Value, PersonId = person.RevisionId, IsClaimingEmployee = true, IsClaimingStudent = false, }); _unitOfWork.SaveChanges(); } else { throw new NotSupportedException("Why is the person not affiliated with an employer?"); } return(person); }
public IActionResult Create(CreatePersonCommand command) { try { if (ModelState.IsValid) { var id = _service.CreatePerson(command); return(RedirectToAction(nameof(View), new { id = id })); } } catch (Exception) { // TODO: Log error // Add a model-level error by using an empty string key ModelState.AddModelError( string.Empty, "An error occured saving the person" ); } return(View(command)); }
public IActionResult Create(CreatePersonCommand command) { try { if (ModelState.IsValid) { var id = _person.CreatePerson(command); return(RedirectToAction(nameof(View), new { id = id })); } } catch (Exception) { // Add a model-level error by using an empty string key ModelState.AddModelError( string.Empty, "An error occured saving person" ); } //If we got to here, something went wrong return(View(command)); }
public async Task <IActionResult> CreateAsync([FromBody] CreatePersonCommand command) { var user = HttpContext.User.Identity as ClaimsIdentity; if (user == null) { return(BadRequest()); } IList <Claim> claim = user.Claims.ToList(); command.UserId = Convert.ToInt32(claim[1].Value); var result = await _commandExecutor.ExecuteAsync(command); if (!result.Success) { return(BadRequest(new { success = false })); } return(Ok(new { success = true })); }
public void AddCreatedPersonToPeople_WhenUserNameNotExist() { var people = new Dictionary <string, IPerson>(); var databaseMock = new Mock <IDataBase>(); var factoryMock = new Mock <IFactory>(); var personMock = new Mock <IPerson>(); var parameters = new List <string>() { "userName", "firstName", "lastName" }; databaseMock.SetupGet(x => x.People).Returns(people); factoryMock.Setup(x => x.CreatePerson("userName", "firstName", "lastName")).Returns(personMock.Object); var sut = new CreatePersonCommand(factoryMock.Object, databaseMock.Object); sut.Execute(parameters); Assert.AreEqual(1, people.Count); }
public Task <Response <PersonDto> > AddAsync(CreatePersonCommand query) { // Creates entity var person = new Person { Id = PeopleDB.Items.Count + 1, FirstName = query.FirstName, MiddleName = query.MiddleName, LastName = query.LastName, }; // Insert it PeopleDB.Items.Add(person); // Returns DTO return(Task.FromResult(Response.Ok(new PersonDto { Id = person.Id, FirstName = query.FirstName, MiddleName = query.MiddleName, LastName = query.LastName }))); }
private static Person BindPerson(CreatePersonCommand cmd) { return(new Person { Id = cmd.Id, RecordId = !cmd.Id.HasValue ? Guid.NewGuid() : null, Name = cmd.Name, Document = cmd.Document, Email = cmd.Email, Gender = cmd.Gender, BirthDate = cmd.BirthDate, Phone = cmd.Phone, ZipCode = cmd.ZipCode, Street = cmd.Street, Number = cmd.Number, Neighborhood = cmd.Neighborhood, City = cmd.City, FederativeUnit = cmd.FederativeUnit, Complement = cmd.Complement, Profile = cmd.Profile, Active = true }); }
public void ReturnMessage_WhenUserNameExist() { var userName = "******"; var people = new Dictionary <string, IPerson>(); var databaseMock = new Mock <IDataBase>(); var factoryMock = new Mock <IFactory>(); var personMock = new Mock <IPerson>(); var parameters = new List <string>() { userName, "firstName", "lastName" }; people.Add(userName, personMock.Object); databaseMock.SetupGet(x => x.People).Returns(people); factoryMock.Setup(x => x.CreatePerson(userName, "firstName", "lastName")).Returns(personMock.Object); var sut = new CreatePersonCommand(factoryMock.Object, databaseMock.Object); var ex = Assert.ThrowsException <ArgumentException>(() => sut.Execute(parameters)); Assert.AreEqual($" {userName} already exists.", ex.Message); }
public async Task GivenValidCreatePersonCommand_ReturnsSuccessCode() { // Arrange var client = await _factory.GetAuthenticatedClientAsync(); var command = new CreatePersonCommand() { FirstName = "fname", LastName = "lname", Address = "addr", City = "city", State = "st", Zip = "12345", BirthDate = DateTime.Now }; var context = IntegrationTestHelper.GetRequestContent(command); // Act var response = await client.PostAsync("/api/persons", context); // Assert response.EnsureSuccessStatusCode(); }
protected Person Seed(int? establishmentId, CreatePersonCommand command) { // make sure entity does not already exist var person = _queryProcessor.Execute(new GetPersonByEmailQuery { Email = command.EmailAddresses.First().Value, }); if (person != null) return person; if (string.IsNullOrWhiteSpace(command.DisplayName)) { command.DisplayName = string.Format("{0} {1}", command.FirstName, command.LastName); } _createPerson.Handle(command); _unitOfWork.SaveChanges(); person = command.CreatedPerson; if (establishmentId.HasValue) { _createAffiliation.Handle(new CreateAffiliationCommand { EstablishmentId = establishmentId.Value, PersonId = person.RevisionId, IsClaimingEmployee = true, IsClaimingStudent = false, }); _unitOfWork.SaveChanges(); } else { throw new NotSupportedException("Why is the person not affiliated with an employer?"); } return person; }
public void IsValidWhen_UserName_DoesNotMatchExistingUser() { const string userName = "******"; const string personDisplayName = "Adam West"; var command = new CreatePersonCommand { DisplayName = personDisplayName, UserName = userName, }; var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict); queryProcessor.Setup(m => m.Execute(It.Is<GetUserByNameQuery>(q => q.Name == command.UserName))) .Returns(null as User); var validator = new CreatePersonValidator(queryProcessor.Object); var results = validator.Validate(command); var error = results.Errors.SingleOrDefault(e => e.PropertyName == "UserName"); error.ShouldBeNull(); }
public void IsValidWhen_UserName_IsWhiteSpace() { const string personDisplayName = "Adam West"; var command = new CreatePersonCommand { DisplayName = personDisplayName, UserName = "******", }; var validator = new CreatePersonValidator(null); var results = validator.Validate(command); var error = results.Errors.SingleOrDefault(e => e.PropertyName == "UserName"); error.ShouldBeNull(); }
public void CreatesPerson_AndUnregisteredUser() { var command = new CreatePersonCommand { UserName = "******", }; var entities = new Mock<ICommandEntities>(MockBehavior.Strict); Person outPerson = null; entities.Setup(m => m.Create(It.IsAny<Person>())) .Callback((Entity entity) => outPerson = (Person)entity); var handler = new CreatePersonHandler(entities.Object); handler.Handle(command); outPerson.ShouldNotBeNull(); outPerson.ShouldEqual(command.CreatedPerson); outPerson.User.ShouldNotBeNull(); outPerson.User.Name.ShouldEqual(command.UserName); outPerson.User.IsRegistered.ShouldBeFalse(); entities.Verify(m => m.Create(It.Is<Person>(p => p.User.Name == command.UserName)), Times.Once()); }
public Task <PersonViewModel> CreateAsync(CreatePersonCommand request) { return(commandProcessor.ProcessAsync <CreatePersonCommand, PersonViewModel>(request)); }
public async Task <IActionResult> Post([FromBody] CreatePersonCommand createPerson) { return(await Create <CreatePersonCommand, long>(createPerson)); }