public async Task Should_get_department_details(SliceFixture fixture)
{
var admin = new Instructor
{
FirstMidName = "George",
LastName = "Costanza",
HireDate = DateTime.Today,
};
var dept = new Department
{
Name = "History",
Administrator = admin,
Budget = 123m,
StartDate = DateTime.Today
};
await fixture.InsertAsync(admin, dept);
var query = new Details.Query
{
Id = dept.Id
};
var result = await fixture.SendAsync(query);
result.ShouldNotBeNull();
result.Name.ShouldBe(dept.Name);
result.AdministratorFullName.ShouldBe(admin.FullName);
}
public async Task QueryingForExistingCampaign_ReturnsThatCampaign()
{
var sp = new ServiceProviderBuilder().BuildServiceProvider(ConfigureServices);
var start = new NodaTime.LocalDateTime(2019, 09, 01, 12, 00).InMainTimezone().ToOffsetDateTime();
var end = new NodaTime.LocalDateTime(2019, 09, 01, 12, 00).InMainTimezone().ToOffsetDateTime();
using (var scope = sp.CreateScope())
{
var dbSession = scope.ServiceProvider.GetRequiredService <DbSessionProvider>();
await dbSession.CreateSession().SaveAsync(new Campaign(
startDateTime: start, endDateTime: end,
editionId: 1, name: "test"));
}
using (var scope = sp.CreateScope())
{
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
var query = new Details.Query()
{
CampaignID = 1
};
var result = await mediator.Send(query);
result.IsSuccess.Should().BeTrue();
result.Value.Should().BeEquivalentTo(new Details.Campaign()
{
ID = 1, Name = "test",
StartDateTime = start, EndDateTime = end,
CanScheduleTraining = true, IsRecruitmentFormOpen = false,
Trainings = Array.Empty <Recruitment.Trainings.TrainingSummary>()
});
}
}
public async Task GetReservations_ShouldReturnReservation_WhenItExists()
{
// Arrange
var reservationId = Guid.NewGuid();
var mediatorMock = new Mock <IMediator>();
var query = new Details.Query {
Id = reservationId
};
// var DetailesHandler = new Details.Handler(_context);
var reservationDto = new Reservation {
Id = reservationId, Title = "Med cool", Date = DateTime.Today, Description = "well done"
};
// Act
mediatorMock.Setup(x => x.Send(query, new System.Threading.CancellationToken())).ReturnsAsync(reservationDto);
// var reservation = await DetailesHandler.Handle(query, new System.Threading.CancellationToken());
var reservation = await mediatorMock.Object.Send(query);
// Assert
Assert.Equal(reservationId, reservation.Id);
Assert.Equal(reservationDto.Title, reservation.Title);
}
public async Task Get_WorksAsync()
{
var(storage, opt) = _fixture.CreateStorageWithSoldOption();
var query = new Details.Query {
Id = opt.State.Id
};
var mock = new Mock <IStocksService2>();
mock.Setup(x => x.GetPrice(opt.State.Ticker))
.Returns(Task.FromResult(
new StockServiceResponse <core.Price>(
new core.Price(100)
)
));
query.WithUserId(opt.State.UserId);
var handler = new Details.Handler(storage, mock.Object);
var result = await handler.Handle(query, CancellationToken.None);
Assert.NotNull(result);
}
public async Task <Maybe <Details.TrainingDetails> > Handle(Details.Query request, CancellationToken cancellationToken)
{
var now = _clock.GetCurrentInstant();
var maybeTraining = await _trainingRepo.GetById(request.TrainingId);
if (maybeTraining.HasNoValue)
{
return(Maybe <Details.TrainingDetails> .None);
}
var training = maybeTraining.Value;
var trainer = await _trainerProvider.GetTrainerDetails(training.CoordinatorID);
if (trainer.HasNoValue)
{
throw new ApplicationException($"inconsistent data in DB: cannot find trainer with Id={training.CoordinatorID}");
}
if (now < training.StartDateTime.ToInstant())
{
return(Maybe <Details.TrainingDetails> .From(await BuildFutureTrainingDetails(training, trainer.Value, now)));
}
else if (training.EndDateTime.ToInstant() < now)
{
return(Maybe <Details.TrainingDetails> .From(await BuildPastTrainingDetails(training, trainer.Value)));
}
else
{
return(Maybe <Details.TrainingDetails> .From(await BuildCurrentTrainingDetails(training, trainer.Value)));
}
}
public async Task Should_get_department_details()
{
var adminId = await SendAsync(new ContosoUniversity.Features.Instructors.CreateEdit.Command
{
FirstMidName = "George",
LastName = "Costanza",
HireDate = DateTime.Today,
});
var dept = new Department
{
Name = "History",
InstructorID = adminId,
Budget = 123m,
StartDate = DateTime.Today
};
await InsertAsync(dept);
var query = new Details.Query
{
Id = dept.Id
};
var result = await SendAsync(query);
var admin = await FindAsync <Instructor>(adminId);
result.ShouldNotBeNull();
result.Name.ShouldBe(dept.Name);
result.AdministratorFullName.ShouldBe(admin.FullName);
}
public async Task CanGetDetails(SliceFixture fixture)
{
//Arrange
var student = new Student
{
FirstName = "Another",
LastName = "Student",
EnrollmentDate = new DateTime(2014, 01, 04)
};
await fixture.InsertAsync(student);
var detailsQuery = new Details.Query
{
Id = student.Id
};
//Act
var response = await fixture.SendAsync(detailsQuery);
//Assert
response.ShouldNotBeNull();
response.FirstName.ShouldBe(student.FirstName);
response.LastName.ShouldBe(student.LastName);
response.EnrollmentDate.ShouldBe(student.EnrollmentDate);
}
public async Task CanGetDetails(SliceFixture fixture)
{
//Arrange
var department = new Department
{
Name = "Some department"
};
var course = new Course
{
Title = "Course",
Credits = 3,
Department = department
};
await fixture.InsertAsync(course);
var createInstructorCommand = new CreateEdit.Command
{
FirstName = "John",
LastName = "Smith",
HireDate = new DateTime(2012, 03, 01),
SelectedCourses = new List <CourseInstructor>()
{
new CourseInstructor()
{
Course = course, CourseId = course.Id
}
}
};
var createdInstructor = await fixture.SendAsync(createInstructorCommand);
//Act
var detailsQuery = new Details.Query
{
Id = createdInstructor.Id
};
var response = await fixture.SendAsync(detailsQuery);
//Assert
var instructorInDb = await fixture.ExecuteDbContextAsync(context => context
.Instructors
.Include(i => i.CourseInstructors)
.ThenInclude(c => c.Course)
.FirstOrDefaultAsync(i => i.Id == createdInstructor.Id));
response.ShouldNotBeNull();
response.Id.ShouldBe(instructorInDb.Id);
response.FirstName.ShouldBe(instructorInDb.FirstName);
response.LastName.ShouldBe(instructorInDb.LastName);
response.HireDate.ShouldBe(instructorInDb.HireDate);
response.Courses.ElementAt(0).Id
.ShouldBe(instructorInDb.CourseInstructors.ElementAt(0).CourseId);
response.Courses.ElementAt(0).Title
.ShouldBe(instructorInDb.CourseInstructors.ElementAt(0).Course.Title);
}
public async Task Get_Component_Inexistent_ShouldReturn_RestException()
{
var mockedContext = new EletronicPartsCatalogContextMock().GetMockedContextWithData();
var sut = new Details.QueryHandler(mockedContext);
var message = new Details.Query("slug");
await Assert.ThrowsAsync <RestException>(() => sut.Handle(message, CancellationToken.None));
}
public async Task <ActionResult <Activity> > Get(Guid id)
{
var query = new Details.Query {
Id = id
};
var activity = await Mediator.Send(query);
return(Ok(activity));
}
// GET: /Student/Details/5
public async Task <ActionResult> Details(Details.Query query)
{
var student = await _mediator.SendAsync(query);
if (student == null)
{
return(HttpNotFound());
}
return(View(student));
}
public async Task Details_CheckNotExistingUser_ReturnException()
{
await CreateUser("email", "name", "bio");
var query = new Details.Query("otherMail");
Func <Task> getUserDetailFunc = async() => await SendAsync(query);
getUserDetailFunc.Should().Throw <RestException>();
}
public void Should_Throw_NotFoundException_If_User_Cannot_Be_Found()
{
// Arrange
var query = new Details.Query(Guid.NewGuid());
// Act
Func <Task <User> > func = async() => await _handler.Handle(query, new CancellationToken());
// Assert
func.Should().ThrowExactly <NotFoundException>().WithMessage("User could not be found.");
}
public async Task Get_User_Inexistent_ShouldReturn_RestException()
{
var mockedContext = new EletronicPartsCatalogContextMock().GetMockedContextWithData();
var mockedMapper = new Mock <IMapper>();
var sut = new Details.QueryHandler(mockedContext, mockedMapper.Object);
var message = new Details.Query
{
Username = "******"
};
await Assert.ThrowsAsync <RestException>(() => sut.Handle(message, CancellationToken.None));
}
public async Task Should_Get_User_By_Id()
{
// Arrange
User expectedUser = FakeUsers.LockedOutUser;
var query = new Details.Query(expectedUser.Id);
// Act
User user = await _handler.Handle(query, new CancellationToken());
// Assert
user.Should().BeEquivalentTo(expectedUser, opt => opt.Excluding(u => u.ConcurrencyStamp));
}
public async Task Get_Profile_Inexistent_ShouldReturn_NoResult()
{
var mockedProfileReader = new Mock <IProfileReader>();
var sut = new Details.QueryHandler(mockedProfileReader.Object);
var message = new Details.Query
{
Username = "******"
};
var result = await sut.Handle(message, CancellationToken.None);
Assert.Null(result);
}
public async Task Handle_InvalidGuidIsProvided_ThrowsArgumentException()
{
//Arrange
var invalidGuidRequest = new Details.Query()
{
Id = It.IsAny <Guid>()
};
var cancellationToken = new CancellationToken();
//Assert with Action
await Assert.ThrowsAsync <ArgumentException>(async() => await detailsHandler.Handle(invalidGuidRequest, cancellationToken));
}
public async Task QueryingForNonExistentId_ReturnsResourceNotFound(int id)
{
var sp = new ServiceProviderBuilder().BuildServiceProvider(ConfigureServices);
var mediator = sp.GetRequiredService <IMediator>();
var query = new Details.Query()
{
CampaignID = id
};
var result = await mediator.Send(query);
Assert.False(result.IsSuccess);
Assert.IsType <Error.ResourceNotFound>(result.Error);
}
public void GivenAnOrderViewOrderDetails()
{
using var factory = new DbContextFactory <ShopContext>();
var options = factory.CreateOptions();
using var context = factory.CreateContext(options);
var createProductHandler = new Features.Products.Create.Handler(context);
var foo = createProductHandler.Handle(new Features.Products.Create.Command {
Code = "Foo", Description = "Foo description"
}, default).Result;
var bar = createProductHandler.Handle(new Features.Products.Create.Command {
Code = "Bar", Description = "Bar description"
}, default).Result;
// Create an order
var createCommand = new Create.Command
{
DateCreated = new DateTime(2019, 1, 1),
Lines = new List <Create.Command.OrderLine>
{
new Create.Command.OrderLine {
ProductCode = foo, Quantity = 1
},
new Create.Command.OrderLine {
ProductCode = bar, Quantity = 3
},
}
};
var createHandler = new Create.Handler(context);
var orderNumber = createHandler.Handle(createCommand, default).Result;
// View order details
var query = new Details.Query {
Number = orderNumber
};
var detailsHandler = new Details.Handler(context);
var orderDetails = detailsHandler.Handle(query, default).Result;
Assert.AreEqual(createCommand.DateCreated, orderDetails.CreatedDate);
Assert.AreEqual(createCommand.Lines.Count(), orderDetails.Lines.Count());
foreach (var(line, index) in orderDetails.Lines.Select((l, i) => (l, i)))
{
var orderLine = createCommand.Lines.Single(x => x.ProductCode == line.ProductCode);
var orderLineNumber = index + 1;
Assert.AreEqual(orderLineNumber, line.Number);
Assert.AreEqual(orderLine.Quantity, line.Quantity);
}
}
public async Task Details_CheckExistingBoard_ReturnBoard()
{
var userId = await CreateUser();
var boardName = "name";
var boardId = await BoardTestHelper.CreateBoard(ContextInjector.WriteContext, userId, boardName);
var query = new Details.Query(boardId);
var boardEnvelope = await SendAsync(query);
boardEnvelope.Should().NotBeNull();
boardEnvelope.Board.Should().NotBeNull();
boardEnvelope.Board.Name.Should().BeEquivalentTo(boardName);
boardEnvelope.Board.OwnerId.Should().Be(userId);
}
public void GetJobDetails_WithEmptyJobId_ShouldThrowException()
{
//Arrange
var query = new Details.Query {
Id = 0
};
var handler = new Details.Handler(testContext, testMapper);
//Assert
var ex = Assert.CatchAsync <Exception>(() => handler.Handle(query, CancellationToken.None));
if (ex.Equals(typeof(RestException)))
{
Assert.That(ex.Message, Is.EqualTo("Not Found"));
}
}
public void SearchByInvalidCartIdShouldThrowRestException()
{
using (var context = GetDbContext())
{
//arrange
InitDatabaseTablesForOrderTests(context);
var command = new Details.Query()
{
CartId = "1234-5678-0000-3333"
};
var handler = new Details.Handler(context);
//assert
Assert.ThrowsExceptionAsync <RestException>(() => handler.Handle(command, (new CancellationTokenSource()).Token));
}
}
public async Task Should_read_block()
{
//Arrange
var createdId = await EntitySetupHelper.CreateOwner().ConfigureAwait(false);
var query = new Details.Query {
Id = createdId
};
//Act
var entity = await SendAsync(query).ConfigureAwait(false);
//Assert
entity.ShouldNotBeNull();
entity.Id.ShouldBe(createdId);
}
public async Task Details_CheckExistingUser_ReturnUser()
{
var userEmail = "email";
var userName = "******";
var userBio = "bio";
await CreateUser(userEmail, userName, userBio);
var query = new Details.Query(userEmail);
var user = await SendAsync(query);
user.Should().NotBeNull();
user.User.Should().NotBeNull();
user.User.Email.Should().BeEquivalentTo(userEmail);
user.User.Name.Should().BeEquivalentTo(userName);
user.User.Biography.Should().BeEquivalentTo(userBio);
}
public async Task <object> Get(Guid id)
{
var query = new Details.Query {
Id = id
};
query.WithUserId(User.Identifier());
var option = await _mediator.Send(query);
if (option == null)
{
return(NotFound());
}
return(option);
}
public async Task Details_CheckExistingColumn_ReturnTask()
{
var userId = await CreateUser();
var boardId = await ColumnTestHelper.CreateBoard(ContextInjector.WriteContext, userId);
var columnHeader = "column";
var columnColor = "color";
var columnId = await ColumnTestHelper.CreateColumn(ContextInjector.WriteContext, userId, boardId, columnHeader, columnColor);
var query = new Details.Query(columnId);
var columnEnvelope = await SendAsync(query);
columnEnvelope.Should().NotBeNull();
columnEnvelope.Column.Should().NotBeNull();
columnEnvelope.Column.Header.Should().BeEquivalentTo(columnHeader);
columnEnvelope.Column.Color.Should().BeEquivalentTo(columnColor);
}
public async Task Details_CheckNotExistingBoard_ReturnException()
{
var userId = await CreateUser();
var boardId = await BoardTestHelper.CreateBoard(ContextInjector.WriteContext, userId);
var rndNotExistingGuid = Guid.NewGuid();
while (rndNotExistingGuid == boardId)
{
rndNotExistingGuid = Guid.NewGuid();
}
var query = new Details.Query(rndNotExistingGuid);
Func <Task> getBoardDetailFunc = async() => await SendAsync(query);
getBoardDetailFunc.Should().Throw <RestException>();
}
public async Task SearchByValidCartIdShouldReturnOrder()
{
using (var context = GetDbContext())
{
//arrange
InitDatabaseTablesForOrderTests(context);
var command = new Details.Query()
{
CartId = "1234-5678-0000-1111"
};
var handler = new Details.Handler(context);
//act
var order = await handler.Handle(command, (new CancellationTokenSource()).Token);
//assert
Assert.IsTrue(order.CartId == "1234-5678-0000-1111" && order.OrderDetails.Count() == 3 && order.Id == 1);
}
}
public async Task Details_CheckNotExistingTask_ReturnException()
{
var userId = await CreateUser();
var columnId = await TaskTestHelper.CreateColumn(ContextInjector.WriteContext, userId);
var taskId = await TaskTestHelper.CreateTask(ContextInjector.WriteContext, userId, columnId);
var rndNotExistingGuid = Guid.NewGuid();
while (rndNotExistingGuid == taskId)
{
rndNotExistingGuid = Guid.NewGuid();
}
var query = new Details.Query(rndNotExistingGuid);
Func <Task> getTaskDetailFunc = async() => await SendAsync(query);
getTaskDetailFunc.Should().Throw <RestException>();
}
public async Task ShouldMatchDatabaseContract()
{
var addedContract = await AlreadyInDatabaseContract();
var query = new Details.Query()
{
ContractId = addedContract.Id,
VersionNumber = addedContract.VersionNumber
};
var contract = await Send(query);
contract.Id.ShouldMatch(addedContract.Id);
contract.Description.ShouldMatch(addedContract.Description);
contract.ContractString.ShouldMatch(addedContract.ContractString);
contract.VersionNumber.ShouldMatch(addedContract.VersionNumber);
contract.Namespace.ShouldMatch(addedContract.Namespace);
contract.Type.ShouldMatch(addedContract.Type);
contract.UpdateInst.ShouldMatch(addedContract.UpdateInst);
contract.CreatedDate.ShouldMatch(addedContract.CreatedDate);
}
