public async Task ShouldCloseBet()
{
var betId = Guid.NewGuid();
var memberId = new MemberId(Guid.Parse("1311e8c9-d993-4346-94c1-1907e3ce65d3"));
var creator = new Member(memberId, "name", 300);
BetState betState = GenerateBet(betId, creator);
var domainEventsListener = new DomainEventsAccessor();
var repository = new InMemoryBetRepository(domainEventsListener, betState);
var command = new CloseBetCommand(betId, true);
var dateTimeClosed = new DateTime(2021, 4, 1);
var dateTimeProvider = new FakeDateTimeProvider(dateTimeClosed);
var handler = new CloseBetCommandHandler(repository, dateTimeProvider, new InMemoryAuthenticationGateway(true, memberId.Value));
await handler.Handle(command, default);
var bet = await repository.GetByIdAsync(new(betId));
Assert.True(bet.State.IsSuccess);
Assert.Equal(dateTimeClosed, bet.State.CloseDate);
var betClosedEvent = domainEventsListener.GetDomainEvents()
.SingleOrDefault(x => x.GetType() == typeof(BetClosed)) as BetClosed;
var betUpdatedEvent = domainEventsListener.GetDomainEvents()
.SingleOrDefault(x => x.GetType() == typeof(BetUpdated)) as BetUpdated;
Assert.NotNull(betClosedEvent);
Assert.NotNull(betUpdatedEvent);
Assert.Equal(betId, betClosedEvent.BetId);
Assert.True(betClosedEvent.IsSuccess);
Assert.Equal(betId, betUpdatedEvent.BetId);
}
public RegisterUserHandlerTest()
{
domainEventsAccessor = new DomainEventsAccessor();
userRepository = new InMemoryUserRepository(domainEventsAccessor: domainEventsAccessor);
fakeDateTimeProvider = new FakeDateTimeProvider(new DateTime(2021, 9, 22));
inMemoryTokenGenerator = new InMemoryTokenGenerator(JWT_TOKEN);
}
public async Task InAndOut9()
{
var theDay = new DateTime(2020, 04, 21);
ctx.TimeBookings.RemoveRange();
await ctx.SaveChangesAsync();
ctx.TimeBookings.Add(new TimeBooking
{
BookingTime = theDay.AddHours(6).AddMinutes(3),
});
ctx.TimeBookings.Add(new TimeBooking
{
BookingTime = theDay.AddHours(15).AddMinutes(3)
});
await ctx.SaveChangesAsync();
var timeProvider = new FakeDateTimeProvider(theDay);
var tbs = new TimeBookingsService(tbsLogger, ctx);
var sut = new ActualWorkTimeService(tbs, timeProvider);
var(inTime, outTime, workTime, pauseTime) = await sut.LoadDataAsync(theDay);
inTime.Hour.Should().Be(6);
inTime.Minute.Should().Be(3);
workTime.Should().Be(TimeSpan.FromMinutes(540));
pauseTime.Should().Be(TimeSpan.Zero);
outTime.Hour.Should().Be(15);
outTime.Minute.Should().Be(3);
}
public async Task Test_that_all_missed_snapshots_created_on_first_execution()
{
// Arrange
var balanceServiceMock = new Mock <IBalanceService>();
var createBalanceSnapshotCron = CronExpression.Parse(CreateBalanceSnapshotCronString);
var createBalanceSnapshotDelay = TimeSpan.Parse(CreateBalanceSnapshotDelayString);
var dateTimeProvider = new FakeDateTimeProvider();
var firstBalanceUpdateTimestamp = ParseUtc("2020-01-01T02:42:00Z");
var actualSnapshots = new List <(DateTime, DateTime)>();
// Setup
dateTimeProvider.UtcNow = ParseUtc("2020-01-01T04:05:00Z");
balanceServiceMock
.Setup(x => x.TryGetLatestSnapshotTimestampAsync())
.ReturnsAsync(default(DateTime?));
balanceServiceMock
.Setup(x => x.TryGetFirstBalanceUpdateTimestampAsync())
.ReturnsAsync(firstBalanceUpdateTimestamp);
balanceServiceMock
.Setup(x => x.CreateSnapshotAsync(It.IsAny <DateTime>(), It.IsAny <DateTime>()))
.Callback <DateTime, DateTime>((from, to) =>
{
actualSnapshots.Add((from, to));
})
.Returns(Task.CompletedTask);
// Act
var job = new CreateBalanceSnapshotJob
(
LogFactory.Create().AddUnbufferedConsole(),
balanceServiceMock.Object,
createBalanceSnapshotCron,
createBalanceSnapshotDelay,
dateTimeProvider
);
await job.ExecuteAsync();
// Assert
var expectedSnapshots = new List <(DateTime, DateTime)>
{
(firstBalanceUpdateTimestamp, ParseUtc("2020-01-01T02:45:00Z")),
(ParseUtc("2020-01-01T02:45:00Z"), ParseUtc("2020-01-01T03:00:00Z")),
(ParseUtc("2020-01-01T03:00:00Z"), ParseUtc("2020-01-01T03:15:00Z")),
(ParseUtc("2020-01-01T03:15:00Z"), ParseUtc("2020-01-01T03:30:00Z")),
(ParseUtc("2020-01-01T03:30:00Z"), ParseUtc("2020-01-01T03:45:00Z")),
(ParseUtc("2020-01-01T03:45:00Z"), ParseUtc("2020-01-01T04:00:00Z"))
};
actualSnapshots
.Should()
.BeEquivalentTo(expectedSnapshots);
}
public void ShouldFailOnReturningACarBeforeItWasRented()
{
Assert.Throws <Exception>(() =>
{
var time = new FakeDateTimeProvider();
var sut = new CarRenter(time);
var bookingNumber = sut.CustomerRentsCar(CarCategories.Minivan, "198506141111", 1);
time.UtcNow = new DateTime(1000, 1, 1);
sut.CustomerReturnsCar(bookingNumber, 2);
});
}
public void ShouldBeAbleToReturnACar(string carCategory, DateTime timeOfRent, DateTime timeOfReturn)
{
var time = new FakeDateTimeProvider(timeOfRent);
var sut = new CarRenter(time);
var bookingNumber = sut.CustomerRentsCar(carCategory, "198506141111", 0M);
time.UtcNow = timeOfReturn;
var result = sut.CustomerReturnsCar(bookingNumber, 0.1M);
Assert.That(result != null && result > 0);
}
private (ActualWorkTimeService awt, TargetWorkTimeService twt) prepare(DateTime theDay)
{
var timeProvider = new FakeDateTimeProvider(theDay);
var fs = new FeiertagService(timeProvider);
var cs = new CoronaService(config, fs);
var tbs = new TimeBookingsService(tbslogger, ctx);
var awt = new ActualWorkTimeService(tbs, timeProvider);
var twt = new TargetWorkTimeService(config, cs);
return(awt, twt);
}
public async Task Test_that_distribution_plan_created_for_period_after_previous_distribution_plan()
{
// Arrange
var balanceServiceMock = new Mock <IBalanceService>();
var createDistributionPlanCron = CronExpression.Parse(CreateDistributionPlanCronString);
var createDistributionPlanDelay = TimeSpan.Parse(CreateDistributionPlanDelayString);
var dateTimeProvider = new FakeDateTimeProvider();
var distributionPlanServiceMock = new Mock <IDistributionPlanService>();
var latestPlanTimestamp = ParseUtc("2020-01-01T03:00:00Z");
var actualPlans = new List <(DateTime, DateTime)>();
// Setup
dateTimeProvider.UtcNow = ParseUtc("2020-02-02T05:00:00Z");
distributionPlanServiceMock
.Setup(x => x.TryGetLatestPlanTimestampAsync())
.ReturnsAsync(latestPlanTimestamp);
distributionPlanServiceMock
.Setup(x => x.CreatePlanAsync(It.IsAny <DateTime>(), It.IsAny <DateTime>()))
.Callback <DateTime, DateTime>((from, to) =>
{
actualPlans.Add((from, to));
})
.Returns(Task.CompletedTask);
// Act
var job = new CreateDistributionPlanJob
(
LogFactory.Create().AddUnbufferedConsole(),
balanceServiceMock.Object,
createDistributionPlanCron,
createDistributionPlanDelay,
dateTimeProvider,
distributionPlanServiceMock.Object
);
await job.ExecuteAsync();
// Assert
var expectedPlans = new List <(DateTime, DateTime)>
{
(latestPlanTimestamp, ParseUtc("2020-02-01T03:00:00Z"))
};
actualPlans
.Should()
.BeEquivalentTo(expectedPlans);
}
public void Metar_day_is_greater_than_current_day()
{
var currentMonth = 4;
var dateTimeProvider = new FakeDateTimeProvider
{
Now = new DateTimeOffset(2020, currentMonth, 1, 0, 0, 0, TimeSpan.Zero)
};
var parser = new TimeOfObservationParser(dateTimeProvider);
var context = new ParserContext();
parser.Parse(context, "020000Z");
var metar = context.GetResult();
Assert.AreEqual(currentMonth - 1, metar.TimeOfObservation.Month);
Assert.AreEqual(2, metar.TimeOfObservation.Day);
Assert.AreEqual(0, metar.TimeOfObservation.Hour);
Assert.AreEqual(0, metar.TimeOfObservation.Minute);
}
public async Task ShouldCreateBet()
{
//arrange
IDateTimeProvider dtNow = new FakeDateTimeProvider(new DateTime(2021, 5, 6, 0, 0, 0));
var endDate = new DateTime(2021, 5, 7, 0, 0, 0);
var command = new LaunchBetCommand(_betId, endDate, coins, description);
var domainEventsListener = new DomainEventsAccessor();
var betRepository = new InMemoryBetRepository(domainEventsListener);
var member = new Member(new MemberId(_creatorId), "name", 25);
var memberRepository = new InMemoryMemberRepository(new List <Member>()
{
member
});
var handler = new LaunchBetCommandHandler(betRepository, memberRepository, new InMemoryAuthenticationGateway(true, _creatorId), dtNow);
BetState expectedBet = new(_betId, member, endDate, description, coins, dtNow.Now, new List <AnswerState>(), null, null);
//act
await handler.Handle(command, default);
//assert
Bet actualBet = await betRepository.GetByIdAsync(new(_betId));
IDomainEvent domainEvent = domainEventsListener.GetDomainEvents()
.SingleOrDefault(x => x.GetType() == typeof(BetCreated));
Assert.Equal(expectedBet.BetId, actualBet.State.BetId);
Assert.Equal(expectedBet.Description, actualBet.State.Description);
Assert.Equal(expectedBet.EndDate, actualBet.State.EndDate);
Assert.Equal(expectedBet.Creator.Id, actualBet.State.Creator.Id);
Assert.Equal(expectedBet.Creator.Name, actualBet.State.Creator.Name);
Assert.Equal(expectedBet.Creator.Wallet, actualBet.State.Creator.Wallet);
Assert.Equal(expectedBet.Coins, actualBet.State.Coins);
Assert.Equal(expectedBet.CreationDate, actualBet.State.CreationDate);
Assert.False(actualBet.IsClosed());
Assert.True(expectedBet.EndDate > actualBet.State.CreationDate);
Assert.True(actualBet.GetEndDateToAnswer().CompareTo(new DateTime(2021, 5, 6, 6, 0, 0)) == 0);
Assert.NotNull(domainEvent);
Assert.Equal(_betId, ((BetCreated)domainEvent).BetId.Value);
Assert.Equal(_creatorId, ((BetCreated)domainEvent).CreatorId.Value);
}
public void FormattedCurrentDate_ReturnsFormattedDate()
{
var sut = new FakeDateTimeProvider(new DateTime(2020, 2, 1));
Assert.Equal("02/01/2020", sut.FormattedCurrentDate);
}
