public void be_created_from_periodName()
{
var periodName = PeriodName.From(1, 2018);
var periodId = PeriodId.From(periodName);
periodId.Value.Should().Be("2018-01");
}
public void Create_new_period()
{
var periodCreator = new PeriodCreator(History.Empty);
var period = periodCreator.Create(PeriodName.From(3, 2019));
period.PeriodName.Should().Be(PeriodName.From(3, 2019));
}
public void return_an_incremnte_of_itself(int prevMonth, int prevYear, int nextMonth, int nextYear)
{
var periodName = PeriodName.From(prevMonth, prevYear);
var next = periodName.GetIncrement();
next.Should().Be(PeriodName.From(nextMonth, nextYear));
}
public void be_equatable()
{
var id1 = PeriodId.From(2, 2019);
var id2 = PeriodId.From(PeriodName.From(2, 2019));
id1.Should().Be(id2);
}
public void raise_period_created_when_create_period()
{
var period = Some.Period();
period.UncommittedEvents.GetStream()
.Should().HaveCount(1).And
.ContainEquivalentOf(new PeriodCreated(PeriodName.From(3, 2019)), e => e.Excluding(a => a.AggregateId));
}
public void Not_be_equatable_for_different_period_name(int month, int year)
{
var period1 = PeriodName.From(month, year);
var period2 = PeriodName.From(month + 1, year + 1);
period1.Should().NotBe(period2);
(period1 != period2).Should().BeTrue();
}
public void Throw_error_if_create_same_period_twice()
{
var periodCreator = Some.PeriodCreator();
periodCreator.Create(PeriodName.From(3, 2019));
Action action = () => periodCreator.Create(PeriodName.From(3, 2019));
action.Should().Throw <PeriodAlreadyExistsException>();
}
public void Throw_error_if_create_period_that_already_exists()
{
var periodCreator = Some.PeriodCreator(e =>
e.WithEvent(Some.PeriodCreated(PeriodName.From(3, 2019))));
Action action = () => periodCreator.Create(PeriodName.From(3, 2019));
action.Should().Throw <PeriodAlreadyExistsException>();
}
public void Be_equatable_to_another_period_name(int month, int year)
{
var period1 = PeriodName.From(month, year);
var period2 = PeriodName.From(month, year);
period1.Should().BeEquivalentTo(period2);
period1.Should().Be(period2);
(period1 == period2).Should().BeTrue();
}
public void dont_raise_spending_removed_when_remove_unexisting_spending()
{
var period = Some.Period(p =>
p.WithEvent(new PeriodCreated(PeriodName.From(1, 2019)))
.WithEvent(Some.SpendingAdded(OperationId.From(1))));
period.RemoveOperation(OperationId.From(2));
period.UncommittedEvents.GetStream().OfType <SpendingRemoved>().Should().BeEmpty();
}
public async Task Save_PeriodCreated_in_csv_file()
{
await Make.TestFile("period.es").AndExecute(async environment =>
{
var store = new FileEventStoreWithCache(new CustomJsonSerializer(), environment.FilePath);
await store.Save(new PeriodCreated(PeriodName.From(1, 2017)));
var @event = await store.GetEvents(b => true);
@event.Last().Should().BeOfType <PeriodCreated>().Which.PeriodName.Should().Be(PeriodName.From(1, 2017));
});
}
public void raise_spending_removed_when_remove_existing_spending()
{
var period = Some.Period(p =>
p.WithEvent(new PeriodCreated(PeriodName.From(1, 2019)))
.WithEvent(Some.SpendingAdded(OperationId.From(1))));
period.RemoveOperation(OperationId.From(1));
period.UncommittedEvents.GetStream().Should()
.ContainEquivalentOf(new SpendingRemoved(OperationId.From(1)),
e => e.Excluding(a => a.AggregateId).Excluding(a => a.Sequence));
}
public void RaiseRecipeRemovedWhenRemoveExistingRecipe()
{
var period = Some.Period(p =>
p.WithEvent(new PeriodCreated(PeriodName.From(1, 2019)))
.WithEvent(Some.RecipeAdded(OperationId.From(1))));
period.RemoveOperation(OperationId.From(1));
period.UncommittedEvents.GetStream().Should().HaveCount(2).And
.ContainEquivalentOf(new RecipeRemoved(OperationId.From(1)),
e => e.Excluding(a => a.AggregateId).Excluding(a => a.Sequence));
}
public PeriodState()
{
AddHandler <PeriodCreated>(e => PeriodName = PeriodName.From(e.PeriodName.Month, e.PeriodName.Year));
AddHandler <SpendingAdded>(Handle);
AddHandler <AmountChanged>(Handle);
AddHandler <LabelChanged>(Handle);
AddHandler <PairChanged>(Handle);
AddHandler <SpendingCategoryChanged>(Handle);
AddHandler <RecipeAdded>(Handle);
AddHandler <RecipeCategoryChanged>(Handle);
AddHandler <SpendingRemoved>(Handle);
AddHandler <RecipeRemoved>(Handle);
}
public async Task Run_CreatePeriod_Command()
{
IServiceCollection services = new ServiceCollection();
services.RegisterDependencies(config =>
{
config.AddSingleton <IConnectedUserService, FakeConnectedUserService>();
config.AddSingleton <IEventStore, FakeEventStore>();
config.AddSingleton <IUserProvider, FakeServerUserProvider>();
});
var provider = services.BuildServiceProvider();
var commandBus = provider.GetService <ICommandBus>();
await commandBus.SendAsync(new CreatePeriod(PeriodName.From(1, 2001)));
}
public async Task Reload_all_events_with_their_domainEvent_infos()
{
await Make.TestFile("reload.es").AndExecute(async env =>
{
var store = new FileEventStoreWithCache(new CustomJsonSerializer(), env.FilePath);
var period = Period.Create(PeriodName.From(1, 2007));
period.AddSpending(Amount.From(5), Label.From("test"), Pair.First, SpendingCategory.Common);
await store.Save(period.UncommittedEvents.GetStream());
var store2 = new FileEventStoreWithCache(new CustomJsonSerializer(), env.FilePath);
var allEvents = await store2.GetEvents(a => true);
allEvents.Any(a => a.AggregateId.IsEmpty()).Should().BeFalse();
});
}
public void create_next_period()
{
var periodCreator = Some.PeriodCreator(e =>
e.WithEvent(Some.PeriodCreated(PeriodName.From(1, 2000)))
.WithEvent(Some.PeriodCreated(PeriodName.From(12, 2010)))
.WithEvent(Some.PeriodCreated(PeriodName.From(5, 2005)))
.WithEvent(Some.PeriodCreated(PeriodName.From(8, 2010)))
.WithEvent(Some.PeriodCreated(PeriodName.From(9, 2010)))
.WithEvent(Some.PeriodCreated(PeriodName.From(10, 2010)))
.WithEvent(Some.PeriodCreated(PeriodName.From(11, 2010)))
);
var newPeriod = periodCreator.CreateNext();
newPeriod.PeriodName.Should().Be(PeriodName.From(1, 2011));
newPeriod.UncommittedEvents.GetStream().Should().HaveCount(1);
}
public async Task Retrieve_last_sequence()
{
await Make.TestFile("Sequence.es").AndExecute(async env =>
{
var store = new FileEventStoreWithCache(new CustomJsonSerializer(), env.FilePath);
var period = Period.Create(PeriodName.From(1, 2007));
period.AddSpending(Amount.From(5), Label.From("test"), Pair.First, SpendingCategory.Common);
period.AddSpending(Amount.From(5), Label.From("test2"), Pair.First, SpendingCategory.Common);
period.AddSpending(Amount.From(5), Label.From("test3"), Pair.First, SpendingCategory.Common);
period.AddSpending(Amount.From(5), Label.From("test4"), Pair.First, SpendingCategory.Common);
await store.Save(period.UncommittedEvents.GetStream());
var lastSequence = await store.GetLastSequence(period.AggregateId);
lastSequence.Should().Be(8);
});
}
public static Period Period(Action <EventStack> events = null)
{
var periodName = PeriodName.From(3, 2019);
if (events == null)
{
return(WalletMate.Domain.Periods.Period.Create(periodName));
}
var periodCreated = new PeriodCreated(periodName);
var eventStack = new EventStack();
events.Invoke(eventStack);
var history = new History(new List <IDomainEvent> {
periodCreated
}.Concat(eventStack.All()).ToList());
return(new Period(history));
}
public async Task Write_in_eventstore_from_multiple_thread()
{
await Make.TestFile("MultiThread.es").AndExecute(async env =>
{
var store = new FileEventStoreWithCache(new CustomJsonSerializer(), env.FilePath);
var period = Period.Create(PeriodName.From(1, 2007));
period.AddSpending(Amount.From(5), Label.From("test"), Pair.First, SpendingCategory.Common);
period.AddSpending(Amount.From(5), Label.From("test2"), Pair.First, SpendingCategory.Common);
period.AddSpending(Amount.From(5), Label.From("test3"), Pair.First, SpendingCategory.Common);
period.AddSpending(Amount.From(5), Label.From("test4"), Pair.First, SpendingCategory.Common);
var t1 = Task.Run(() => store.Save(period.UncommittedEvents.GetStream()));
var t2 = Task.Run(() => store.Save(period.UncommittedEvents.GetStream()));
Task.WaitAll(t1, t2);
var lastSequence = await store.GetLastSequence(period.AggregateId);
lastSequence.Should().Be(8);
});
}
public async Task <IActionResult> Create([FromBody] Period input)
{
return(await SendCommandAsync(new CreatePeriod(PeriodName.From(input.Month, input.Year))));
}
internal void Handle(PeriodCreated @event)
{
_allPeriodNames.Add(PeriodName.From(@event.PeriodName.Month, @event.PeriodName.Year));
}
public void Throw_error_if_invalid_year(int year)
{
Action instantiation = () => PeriodName.From(1, year);
instantiation.Should().Throw <InvalidYearInPeriodNameException>().Which.Message.Should().NotBeEmpty();
}
public void Return_period_name_as_string(int month, int year, string expectedName)
{
var periodName = PeriodName.From(month, year);
periodName.ToString().Should().Be(expectedName);
}
public void GivenUnePeriodeEstCreee()
{
_period = Period.Create(PeriodName.From(3, 2019));
}
public void Throw_error_if_invalid_month(int month)
{
Action instantiation = () => PeriodName.From(month, 2007);
instantiation.Should().Throw <InvalidMonthInPeriodNameException>().Which.Message.Should().NotBeEmpty();
}
