public void PersonAggregate_Create_HasEmptyAddress()
{
var person = PersonAggregate.Create("John", "Smith");
person.Addresses.Should().NotBeNull();
person.Addresses.Should().BeEmpty();
}
public void Address_Create_ValidValues_IsValid()
{
var person = PersonAggregate.Create("John", "Smith");
var address = Address.Create(person, "Street", "City", "Country", "ZipCode");
address.IsValid.Should().BeTrue();
}
static void Main(string[] args)
{
PersonAggregate aggregate = new PersonAggregate();
aggregate.Add(new Person()
{
FirstName = "Robert", Height = 168, LastName = "Kanasz"
});
aggregate.Add(new Person()
{
FirstName = "John", Height = 181, LastName = "Doe"
});
aggregate.Add(new Person()
{
FirstName = "Jane", Height = 158, LastName = "Doe"
});
IPersonIterator iterator = aggregate.GetIterator();
iterator.Reset();
while (iterator.MoveNext())
{
Console.WriteLine(iterator.Current.FirstName + " " + iterator.Current.LastName);
}
}
public void PersonAggregate_Delete_WithAddresses_WillCascade()
{
/// create
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
var person = PersonAggregate.Create("John", "Smith");
person.AddAddress("Street", "City", "Country", "ZipCode");
databaseContext.Set <PersonAggregate>().Add(person);
databaseContext.SaveChanges();
}
/// delete
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
var person = databaseContext.Set <PersonAggregate>().First();
databaseContext.Set <PersonAggregate>().Remove(person);
databaseContext.SaveChanges();
}
/// verify
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
databaseContext.Set <PersonAggregate>().Count().Should().Be(0);
databaseContext.Set <Address>().Count().Should().Be(0);
}
}
public static PersonAggregate Person()
{
var person = PersonAggregate.Create("John", "Smith");
person.AddAddress("Main Street", "New York", "USA", "11100");
return(person);
}
public void PersonController_Get_ReturnPersons()
{
using (DatabaseContext databaseContext = DatabaseTestFactory.GetSession())
{
var person01 = PersonAggregate.Create("John", "Smith");
var person02 = PersonAggregate.Create("Mary", "Jane");
databaseContext.Set <PersonAggregate>().AddRange(new[] { person01, person02 });
databaseContext.SaveChanges();
}
using (WebApp.Start <Startup>(url: iisAddress))
{
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
var response = client.GetAsync(String.Format("{0}PersonRead", iisAddress)).Result;
response.StatusCode.Should().Be(HttpStatusCode.OK);
var result = response.Content.ReadAsStringAsync().Result;
Debug.WriteLine(response.Content.ReadAsStringAsync().Result);
var persons = JsonConvert.DeserializeObject <PersonMessage[]>(result);
persons.Should()
.ContainSingle(x => x.FirstName == "John" && x.LastName == "Smith");
persons.Should()
.ContainSingle(x => x.FirstName == "Mary" && x.LastName == "Jane");
}
}
public void PersonAggregate_Add_InvalidAddress_Fail()
{
var person = PersonAggregate.Create("John", "Smith");
person.AddAddress(string.Empty, string.Empty, string.Empty, string.Empty);
person.Addresses.Should().BeEmpty();
}
public void TestInit()
{
_bdContext = BdContextBuilder.CreateInMemoryContext(Guid.NewGuid().ToString());
_aliveRepository = new AliveRepository(_bdContext);
_deadRepository = new DeadRepository(_bdContext);
_personAggregate = new PersonAggregate(_aliveRepository, _deadRepository, _bdContext);
}
public Task <Unit> Handle(CreatePersonCommand request, CancellationToken cancellationToken)
{
var aggregate = new PersonAggregate(request);
_personRepository.Save(aggregate);
return(Unit.Task);
}
public static Person ToPerson(this PersonAggregate aggregate)
{
var dto = aggregate.ConvertTo <Person>();
dto.Id = aggregate.Id;
dto.DisplayName = aggregate.DisplayName?.DisplayName;
return(dto);
}
private void Commit(PersonAggregate aggregate)
{
var changes = _repository.Save(aggregate);
foreach (var change in changes)
{
_publisher.Publish(change);
}
}
public void Handle(RegisterPerson c)
{
var aggregate = new PersonAggregate {
AggregateIdentifier = c.AggregateIdentifier
};
aggregate.RegisterPerson(c.FirstName, c.LastName, DateTimeOffset.UtcNow);
Commit(aggregate);
}
public void PersonAggregate_Add_ValidAddress_WillContain()
{
var person = PersonAggregate.Create("John", "Smith");
person.AddAddress("Street", "City", "Country", "ZipCode");
person.Addresses.Should().NotBeEmpty();
person.Addresses.Count.Should().Be(1);
}
public static PersonAggregate Create(string id, string name)
{
var agg = new PersonAggregate(new PersonAggregateState());
agg.Create(new RegisterPerson()
{
Id = id, Name = name
});
return(agg);
}
public void Constructor_GivenLastName_SetsLastName()
{
// Arrange
// Act
var sut = new PersonAggregate(_validFirstName, _validLastName);
// Assert
Assert.Same(_validLastName, sut.LastName);
}
public void NewPersonHasNonDefaultId()
{
// Arrange
// Act
var sut = new PersonAggregate(_validFirstName, _validLastName).Id;
// Assert
Assert.NotEqual(default(Guid), sut);
}
public void Person_IsAssignableFromAggregateRootBase()
{
// Arrange
// Act
var sut = new PersonAggregate(_validFirstName, _validLastName);
// Assert
Assert.IsAssignableFrom <AggregateRootBase>(sut);
}
public void Constructor_GivenPaddedFirstName_TrimsName(string paddedName)
{
// Arrange
// Act
var sut = new PersonAggregate(paddedName, _validLastName).FirstName;
// Assert
Assert.Equal("Bobby Sue", sut);
}
public void Constructor_GivenPaddedLastName_TrimsName(string paddedName)
{
// Arrange
// Act
var sut = new PersonAggregate(_validFirstName, paddedName).LastName;
// Assert
Assert.Equal("Giffords", sut);
}
protected virtual void Add(Person person)
{
var aggregate = new PersonAggregate(person);
var nameAggregate = new NameAggregate(person.Name, person.Id);
var addressAggregate = new AddressAggregate(person.Address, person.Id);
context.Set <PersonAggregate>().Add(aggregate);
context.Set <NameAggregate>().Add(nameAggregate);
context.Set <AddressAggregate>().Add(addressAggregate);
}
public Task <Unit> Handle(UpdatePersonCommand request, CancellationToken cancellationToken)
{
var user = _personRepository.GetById(request.PersonId);
var aggregate = new PersonAggregate(user);
aggregate.UpdatePerson(request);
_personRepository.Update(aggregate);
return(Unit.Task);
}
public void Initialize()
{
this.logger = new Mock <ILogger>();
this.identifierFactory = new Mock <IIdentifierFactory>();
this.identifierFactory.Setup(f => f.Create(It.IsAny <IIdentifiableEntity>()))
.Returns("apersonid".ToIdentifier);
this.uniqueEmailService = new Mock <IEmailService>();
this.uniqueEmailService.Setup(ues => ues.EnsureEmailIsUnique(It.IsAny <string>(), It.IsAny <string>()))
.Returns(true);
this.aggregate = new PersonAggregate(this.logger.Object, this.identifierFactory.Object,
this.uniqueEmailService.Object);
}
public void TestTransaction()
{
var bdContext = BdContextBuilder.CreateSqliteContext(Guid.NewGuid().ToString());
var aliveRepository = new AliveRepository(bdContext);
var deadRepository = new DeadRepository(bdContext);
var personAggregate = new PersonAggregate(aliveRepository, deadRepository, bdContext);
personAggregate.Kill(12345);
bdContext.Alive.Count(a => a.Document == 12345).Should().Be(0);
bdContext.Dead.Count().Should().Be(1);
}
public Person Create(ICurrentCaller caller, string firstName, string lastName)
{
caller.GuardAgainstNull(nameof(caller));
var person = new PersonAggregate(this.logger, this.idFactory, this.emailService);
person.SetName(new PersonName(firstName, lastName));
var created = this.storage.Save(person);
this.logger.LogInformation("Person {Id} was created by {Caller}", created.Id, caller.Id);
return(created.ToPerson());
}
public HttpResponseMessage Post(PersonMessage person)
{
using (DatabaseContext databaseContext = new DatabaseContext())
{
var personAggregate = PersonAggregate.Create(
person.FirstName, person.LastName);
databaseContext.Set <PersonAggregate>().Add(personAggregate);
databaseContext.SaveChanges();
var response = Request.CreateResponse(HttpStatusCode.Created, personAggregate.Id);
return(response);
}
}
public static PersonAggregate CreateWithUncommitedUpdates(string id, int nrOfUpdates)
{
var p = new PersonAggregate(new PersonAggregateState());
p.Create(new RegisterPerson()
{
Id = id, Name = "0"
});
for (int i = 0; i < nrOfUpdates; i++)
{
p.Rename(new RenamePerson()
{
Id = id, Name = $"Name {i + 1}"
});
}
return(p);
}
public void WhenCreate_ThenReturnsPerson()
{
var entity = new PersonAggregate(this.logger.Object, this.idFactory.Object, this.uniqueEmailService.Object);
this.storage.Setup(s =>
s.Save(It.IsAny <PersonAggregate>()))
.Returns(entity);
var result = this.personsApplication.Create(this.caller.Object, "afirstname", "alastname");
result.Id.Should().Be("anid");
this.storage.Verify(s =>
s.Save(It.Is <PersonAggregate>(e =>
e.Name == new PersonName("afirstname", "alastname") &&
e.DisplayName == new PersonDisplayName("afirstname")
)));
}
public Task <Unit> Handle(UnfollowPersonCommand request, CancellationToken cancellationToken)
{
var user = _personRepository.GetById(request.PersonId);
var unfollow = _personRepository.GetById(request.UnfollowId);
if (!user.Following.Contains(unfollow))
{
throw new Exception("Esse não está sendo seguido");
}
;
var aggregate = new PersonAggregate(user);
aggregate.Unfollow(unfollow);
_personRepository.Update(aggregate);
return(Unit.Task);
}
public Task <Unit> Handle(FollowPersonCommand request, CancellationToken cancellationToken)
{
var person = _personRepository.GetById(request.PersonId);
var follow = _personRepository.GetById(request.FollowId);
if (person.Following.Contains(follow))
{
throw new Exception("Esse usuario já esta sendo seguido");
}
;
var aggregate = new PersonAggregate(person);
aggregate.Follow(follow);
_personRepository.Update(aggregate);
return(Unit.Task);
}
public void MustThrowExceptionWhenUserIdIsNotFromUserPost()
{
//Given
var cmd = Fixture.Create <DeletePost>();
var person = Fixture.Create <Person>();
var aggregate = new PersonAggregate(person);
var post = Fixture.Create <Post>();
cmd.Id = post.PostId;
post.Person = person;
person.Posts.Clear();;
aggregate.AddPost(post);
_personRepository.GetAggregateByUserId(_userService.UserId).Returns(aggregate);
//When and //Then
Assert.ThrowsAsync <Exception>(() => _sut.Handle(cmd, CancellationToken.None));
}
