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));
}
