public async Task GetGroupByIdHandler_ShouldReturnGroup_WhenGroupExists()
{
// Arrange
GetGroupByIdQuery request = new GetGroupByIdQuery {
GroupId = 1
};
IEnumerable <Group> expectedGroups = new[]
{
new Group {
GroupId = 1
}
};
IQueryable <Group> queryableMock = expectedGroups
.AsQueryable()
.BuildMock()
.Object;
_unitOfWorkMock
.Setup(m => m.Groups.GetById(request.GroupId))
.Returns(queryableMock);
GetGroupByIdQuery.Handler handler = new GetGroupByIdQuery.Handler(_mapperMock, _unitOfWorkMock.Object);
// Act
GroupResource group = await handler.Handle(request);
// Assert
Assert.NotNull(group);
Assert.Equal(request.GroupId, group.GroupId);
}
public async Task GetGroupById_ShouldReturnGroup_WhenGroupExists()
{
// Arrange
const int groupId = 1;
GroupResource expectedGroup = new GroupResource
{
GroupId = groupId
};
Mock <IMediator> mediatorMock = new Mock <IMediator>();
mediatorMock
.Setup(m => m.Send(It.IsAny <GetGroupByIdQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedGroup);
GroupController controller = new GroupController(mediatorMock.Object, null);
// Act
ActionResult <GroupResource> response = await controller.GetGroupById(groupId);
// Assert
OkObjectResult result = Assert.IsType <OkObjectResult>(response.Result);
GroupResource actualGroup = Assert.IsType <GroupResource>(result.Value);
Assert.NotNull(actualGroup);
Assert.Equal(groupId, actualGroup.GroupId);
}
public async Task GetGroupByIdHandler_ShouldReturnNull_WhenGroupDoesNotExist()
{
// Arrange
GetGroupByIdQuery request = new GetGroupByIdQuery {
GroupId = 3891
};
IQueryable <Group> emptyQueryable = Enumerable
.Empty <Group>()
.AsQueryable()
.BuildMock()
.Object;
_unitOfWorkMock
.Setup(m => m.Groups.GetById(request.GroupId))
.Returns(emptyQueryable);
GetGroupByIdQuery.Handler handler = new GetGroupByIdQuery.Handler(_mapperMock, _unitOfWorkMock.Object);
// Act
GroupResource group = await handler.Handle(request);
// Assert
Assert.Null(group);
}
public async Task ThenTheConnectorShouldNotExistAnymore(int connectorId)
{
GroupResource group = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
ChargeStationResource chargeStation = await _chargeStationDriver.ParseFromResponse <ChargeStationResource>((HttpResponseMessage)_scenarioContext["createdChargeStationResponse"]);
await _connectorDriver.ShouldNotExistAnymore(group.Id, chargeStation.Id, connectorId);
}
public async Task WhenTheGroupIsDeleted()
{
GroupResource groupResource = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
groupResource.Id.Should().NotBeEmpty();
_scenarioContext["deletedGroupId"] = groupResource.Id;
_scenarioContext["deletedGroupResponse"] = await _groupDriver.DeleteGroup(groupResource.Id);
}
public async Task ThenTheChargeStationShouldNotExistAnymore()
{
GroupResource group = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
await _chargeStationDriver.ShouldDeleteSuccessfully((HttpResponseMessage)_scenarioContext["deletedChargeStationResponse"],
group.Id,
(Guid)_scenarioContext["deletedChargeStationId"]);
}
public async Task WhenTheChargeStationIsCreated()
{
_scenarioContext["createdGroupResponse"].Should().NotBeNull();
GroupResource groupResponse = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
SaveChargeStationResource _createChargeStation = ((SaveChargeStationResource)_scenarioContext["createChargeStation"]);
_scenarioContext["createdChargeStationResponse"] = await _chargeStationDriver.CreateChargeStation(groupResponse.Id, _createChargeStation.Name, _createChargeStation.Connectors);
}
public async Task WhenTheWrongChargeStationIsDeleted()
{
GroupResource groupResource = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
Guid wrongChargeStationId = new Guid();
_scenarioContext["deletedChargeStationId"] = wrongChargeStationId;
_scenarioContext["deletedChargeStationResponse"] = await _chargeStationDriver.DeleteChargeStation(groupResource.Id, wrongChargeStationId);
}
public async Task ShouldCreateAGroupSuccessfully(HttpResponseMessage response)
{
response.StatusCode.Should().Be(201);
GroupResource groupResourceResponse = await this.ParseFromResponse <GroupResource>(response);
groupResourceResponse.Id.Should().NotBeEmpty();
groupResourceResponse.Name.Should().NotBeEmpty();
groupResourceResponse.Capacity.Should().BePositive();
}
public async Task WhenTheConnectorIsDeleted(int connectorId)
{
GroupResource groupResource = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
ChargeStationResource chargeStationResource = await _chargeStationDriver.ParseFromResponse <ChargeStationResource>((HttpResponseMessage)_scenarioContext["createdChargeStationResponse"]);
chargeStationResource.Id.Should().NotBeEmpty();
chargeStationResource.Name.Should().NotBeEmpty();
_scenarioContext["deletedConnectorId"] = connectorId;
_scenarioContext["deletedConnectorResponse"] = await _connectorDriver.DeleteConnector(groupResource.Id, chargeStationResource.Id, connectorId);
}
public async Task WhenTheWrongChargeStationIsUpdated()
{
_scenarioContext["createdGroupResponse"].Should().NotBeNull();
_scenarioContext["createdChargeStationResponse"].Should().NotBeNull();
GroupResource groupResponse = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
ChargeStationResource chargeStation = await _chargeStationDriver.ParseFromResponse <ChargeStationResource>((HttpResponseMessage)_scenarioContext["createdChargeStationResponse"]);
SaveChargeStationResource _createChargeStation = ((SaveChargeStationResource)_scenarioContext["createChargeStation"]);
_scenarioContext["updatedChargeStation"] = await _chargeStationDriver.UpdateChargeStation(groupResponse.Id, new Guid(), _createChargeStation.Name);
}
public async Task <ActionResult <GroupResource> > CreateGroup([FromBody] CreateGroupBody model, CancellationToken cancellationToken = default)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CreateGroupCommand command = _mapper.Map <CreateGroupBody, CreateGroupCommand>(model);
GroupResource group = await _mediator.Send(command, cancellationToken);
return(CreatedAtAction(nameof(GetGroupById), new { groupId = group.GroupId }, group));
}
public async Task WhenAConnectorIsUpdated(int connectorId)
{
_scenarioContext.Should().ContainKey("createdChargeStationResponse");
_scenarioContext.Should().ContainKey("createdGroupResponse");
_scenarioContext["createdGroupResponse"].Should().NotBeNull();
_scenarioContext["createdChargeStationResponse"].Should().NotBeNull();
GroupResource groupResponse = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
ChargeStationResource chargeStationResource = await _connectorDriver.ParseFromResponse <ChargeStationResource>((HttpResponseMessage)_scenarioContext["createdChargeStationResponse"]);
_scenarioContext["updatedConnector"] = await _connectorDriver.UpdateConnector(groupResponse.Id, chargeStationResource.Id, connectorId, ((SaveConnectorResource)_scenarioContext["createConnector"]).MaxCurrentAmp.Value);
}
public async Task ThenShouldUpdateSuccessfullyAllConnectorsToMaxCurrentForAllChargeStations(float maxCurrent)
{
List <HttpResponseMessage> responses = (List <HttpResponseMessage>)_scenarioContext["chargeStationListResponses"];
GroupResource groupResponse = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
foreach (var response in responses)
{
ChargeStationResource chargeStationResource = await _chargeStationDriver.ParseFromResponse <ChargeStationResource>(response);
var connectorResponse = await _connectorDriver.UpdateConnector(groupResponse.Id, chargeStationResource.Id, 1, maxCurrent);
connectorResponse.StatusCode.Should().Be(200);
}
}
public void UpdateUploadedFiles(Group group, GroupResource groupResource)
{
if (groupResource.UploadedFiles != null && groupResource.UploadedFiles.Count >= 0)
{
//remove old boardEnrollments
group.UploadedFiles.Clear();
//add new enrollments
var newUploadFiles = context.UploadedFiles.Where(e => groupResource.UploadedFiles.Any(id => id == e.UploadedFileId)).ToList();
foreach (var a in newUploadFiles)
{
group.UploadedFiles.Add(a);
}
}
}
public async Task ThenTheConnectorsFromTheSuggestionsShouldNotBeAutomaticallyDeleted()
{
_scenarioContext.ContainsKey("createdConnector");
_scenarioContext.ContainsKey("createdGroupResponse");
HttpResponseMessage response = (HttpResponseMessage)_scenarioContext["createdConnector"];
HttpResponseMessage groupResponse = (HttpResponseMessage)_scenarioContext["createdGroupResponse"];
GroupResource group = await _suggestionDriver.ParseFromResponse <GroupResource>(groupResponse);
CapacityExceededProblemDetail capacityExceeded = await _suggestionDriver.ParseFromResponse <CapacityExceededProblemDetail>(response);
await _suggestionDriver.ValidateIfTheConnectorsStillExists(group.Id, capacityExceeded);
}
public async Task WhenTheConnectorIsCreatedWithRequiredParametersMissing()
{
_scenarioContext.Should().ContainKey("createdChargeStationResponse");
_scenarioContext.Should().ContainKey("createdGroupResponse");
_scenarioContext["createdGroupResponse"].Should().NotBeNull();
_scenarioContext["createdChargeStationResponse"].Should().NotBeNull();
GroupResource groupResponse = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
ChargeStationResource chargeStationResource = await _groupDriver.ParseFromResponse <ChargeStationResource>((HttpResponseMessage)_scenarioContext["createdChargeStationResponse"]);
SaveConnectorResource createConnector = ((SaveConnectorResource)_scenarioContext["createConnector"]);
_scenarioContext["createdConnector"] = await _connectorDriver.CreateConnectorWithEmptyPayload(groupResponse.Id, chargeStationResource.Id);
}
public async Task ShouldUpdateAGroupSuccessfully(HttpResponseMessage response, GroupResource expectedGroupValues)
{
response.StatusCode.Should().Be(200);
GroupResource groupResourceResponse = await this.ParseFromResponse <GroupResource>(response);
if (!string.IsNullOrEmpty(expectedGroupValues.Name))
{
groupResourceResponse.Name.Should().Be(expectedGroupValues.Name);
}
if (expectedGroupValues.Capacity.HasValue)
{
groupResourceResponse.Capacity.Should().Be(expectedGroupValues.Capacity);
}
}
public async Task WhenTheConnectorIsCreated()
{
_scenarioContext.Should().ContainKey("createdChargeStationResponse");
_scenarioContext.Should().ContainKey("createdGroupResponse");
_scenarioContext["createdGroupResponse"].Should().NotBeNull();
_scenarioContext["createdChargeStationResponse"].Should().NotBeNull();
GroupResource groupResponse = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
ChargeStationResource chargeStationResource = _scenarioContext.ContainsKey("createdChargeStation") ? (ChargeStationResource)_scenarioContext["createdChargeStation"]
: await _connectorDriver.ParseFromResponse <ChargeStationResource>((HttpResponseMessage)_scenarioContext["createdChargeStationResponse"]);
SaveConnectorResource createConnector = ((SaveConnectorResource)_scenarioContext["createConnector"]);
_scenarioContext["createdConnector"] = await _connectorDriver.CreateConnector(groupResponse.Id, chargeStationResource.Id, createConnector.MaxCurrentAmp.Value);
}
public async Task ThenShouldCreateSuccessfullyConnectorsForAllChargeStations(int connectorsCount, float maxCurrent)
{
List <HttpResponseMessage> responses = (List <HttpResponseMessage>)_scenarioContext["chargeStationListResponses"];
GroupResource groupResponse = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
foreach (var response in responses)
{
ChargeStationResource chargeStationResource = await _chargeStationDriver.ParseFromResponse <ChargeStationResource>(response);
for (int i = 0; i < connectorsCount; i++)
{
var connectorResponse = await _connectorDriver.CreateConnector(groupResponse.Id, chargeStationResource.Id, maxCurrent);
connectorResponse.StatusCode.Should().Be(201);
}
}
}
public async Task WhenCreateAllChargeStations()
{
_scenarioContext.Should().ContainKey("chargeStationList");
_scenarioContext.Should().ContainKey("createdGroupResponse");
GroupResource groupResponse = await _groupDriver.ParseFromResponse <GroupResource>((HttpResponseMessage)_scenarioContext["createdGroupResponse"]);
List <SaveChargeStationResource> chargeStationToCreate = (List <SaveChargeStationResource>)_scenarioContext["chargeStationList"];
foreach (var item in chargeStationToCreate)
{
var response = await _chargeStationDriver.CreateChargeStation(groupResponse.Id, item.Name, item.Connectors);
((List <HttpResponseMessage>)_scenarioContext["chargeStationListResponses"]).Add(response);
_scenarioContext["createdChargeStationResponse"] = response;
}
}
public async Task GetGroupByIdHandler_ShouldReturnNull_WhenGroupDoesNotExist()
{
// Arrange
GetGroupByIdQuery request = new() { GroupId = 3891 };
_unitOfWorkMock
.Setup(m => m.Groups.GetByIdAsync(request.GroupId))
.ReturnsAsync(null as Group);
GetGroupByIdQuery.Handler handler = new(_mapperMock, _unitOfWorkMock.Object);
// Act
GroupResource group = await handler.Handle(request);
// Assert
Assert.Null(group);
}
public async Task CreateGroup_ShouldReturnCreatedResult_WhenGroupIsCreated()
{
// Arrange
CreateGroupBody model = new CreateGroupBody
{
Name = "Some group name",
Description = "Some group description"
};
GroupResource expectedGroup = new GroupResource
{
GroupId = 1,
Name = model.Name,
Description = model.Description
};
Mock <IMediator> mediatorMock = new Mock <IMediator>();
mediatorMock
.Setup(m => m.Send(It.IsAny <CreateGroupCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expectedGroup);
MapperConfiguration mapperConfiguration = new MapperConfiguration(config =>
{
config.CreateMap <CreateGroupBody, CreateGroupCommand>();
});
IMapper mapperMock = mapperConfiguration.CreateMapper();
GroupController controller = new GroupController(mediatorMock.Object, mapperMock);
// Act
ActionResult <GroupResource> response = await controller.CreateGroup(model);
// Assert
CreatedAtActionResult result = Assert.IsType <CreatedAtActionResult>(response.Result);
GroupResource actualGroup = Assert.IsType <GroupResource>(result.Value);
Assert.NotNull(actualGroup);
Assert.Equal(1, actualGroup.GroupId);
mediatorMock.Verify(m => m.Send(It.IsAny <CreateGroupCommand>(), It.IsAny <CancellationToken>()));
}
public async Task <bool> CheckGroup(GroupResource group)
{
var lecturer = await context.Lecturers
.Include(l => l.Major)
.FirstOrDefaultAsync(l => l.LecturerId == group.LecturerId);
var project = await context.Projects
.Include(p => p.Major)
.FirstOrDefaultAsync(p => p.ProjectId == group.ProjectId);
var major = await context.Majors
.FirstOrDefaultAsync(m => m.MajorId == group.MajorId);
if ((major.MajorId != lecturer.Major.MajorId) || (major.MajorId != project.Major.MajorId) ||
(lecturer.Major.MajorId != project.Major.MajorId))
{
return(false);
}
return(true);
}
public async Task <ActionResult <GroupResource> > GetGroupById([FromRoute] int groupId, CancellationToken cancellationToken = default)
{
GetGroupByIdQuery query = new GetGroupByIdQuery
{
GroupId = groupId
};
GroupResource group = await _mediator.Send(query, cancellationToken);
if (group == null)
{
return(NotFound(new ErrorResource
{
StatusCode = StatusCodes.Status404NotFound,
Message = $"Group with ID '{groupId}' does not exist"
}));
}
return(Ok(group));
}
public async Task <IActionResult> CreateOrUpdateGroupAsync([FromBody] GroupResource body)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var group = _mapper.Map <GroupResource, Group>(body);
var response = await _groupService.CreateOrUpdateGroupAsync(group);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var groupResource = _mapper.Map <Group, GroupResource>(response.Group);
return(Ok(groupResource));
}
public async Task GetGroupByIdHandler_ShouldReturnGroup_WhenGroupExists()
{
// Arrange
GetGroupByIdQuery request = new() { GroupId = 1 };
Group expectedGroups = new() { GroupId = 1 };
_unitOfWorkMock
.Setup(m => m.Groups.GetByIdAsync(request.GroupId))
.ReturnsAsync(expectedGroups);
GetGroupByIdQuery.Handler handler = new(_mapperMock, _unitOfWorkMock.Object);
// Act
GroupResource group = await handler.Handle(request);
// Assert
Assert.NotNull(group);
Assert.Equal(request.GroupId, group.GroupId);
}
}
public IEnumerable <GroupResource> Query()
{
List <GroupResource> result = null;
string sql = @"select GroupId, ResourceId from GroupResources";
using (var dbOperator = new DbOperator(Provider, ConnectionString))
{
using (var reader = dbOperator.ExecuteReader(sql))
{
result = new List <GroupResource>();
while (reader.Read())
{
short groupId = reader.GetInt16(0);
short resourceId = reader.GetInt16(1);
GroupResource item = new GroupResource(groupId, resourceId);
result.Add(item);
}
}
}
return(result);
}
public void UpdateEnrollments(Group group, GroupResource groupResource)
{
if (groupResource.Enrollments != null && groupResource.Enrollments.Count >= 0)
{
//remove old Enrollments
var oldEnrollments = group.Enrollments
.Where(e => !groupResource.StudentEmails.Any(email => email == e.Student.Email)).ToList();
foreach (var enrollment in oldEnrollments)
{
enrollment.IsDeleted = true;
enrollment.Group = null;
}
//group.Enrollments.Clear();
//add new enrollments
//var newEnrollments = context.Enrollments.Where(e => groupResource.Enrollments.Any(id => id == e.EnrollmentId)).ToList();
//foreach (var a in newEnrollments)
//{
// group.Enrollments.Add(a);
//}
var newStudentEmails = groupResource.StudentEmails.Where(s => !group.Enrollments.Any(e => e.Student.Email == s)).ToList();
foreach (var Email in newStudentEmails)
{
var enrollment = new Enrollment
{
StartDate = group.Quarter.QuarterStart,
EndDate = group.Quarter.QuarterEnd,
isConfirm = "Accepted",
IsDeleted = false,
Lecturer = group.Lecturer,
Quarter = group.Quarter,
Student = context.Students.FirstOrDefault(s => s.Email == Email),
Type = group.Project.Type,
Grade = null,
};
group.Enrollments.Add(enrollment);
}
}
}
public async Task WhenDeletingAllConnectorsInTheSuggestionListOfNumber(int suggestionListNumber)
{
_scenarioContext.ContainsKey("createdConnector");
_scenarioContext.ContainsKey("createdGroupResponse");
HttpResponseMessage groupResponse = (HttpResponseMessage)_scenarioContext["createdGroupResponse"];
HttpResponseMessage response = (HttpResponseMessage)_scenarioContext["createdConnector"];
CapacityExceededProblemDetail capacityExceeded = await _suggestionDriver.ParseFromResponse <CapacityExceededProblemDetail>(response);
GroupResource group = await _suggestionDriver.ParseFromResponse <GroupResource>(groupResponse);
capacityExceeded.RemoveSuggestions.Count.Should().BeGreaterOrEqualTo(suggestionListNumber);
{
foreach (var suggestion in capacityExceeded.RemoveSuggestions[suggestionListNumber])
{
var deleteResponse = await _connectorDriver.DeleteConnector(group.Id, suggestion.ChargeStationId, suggestion.ConnectorId);
deleteResponse.StatusCode.Should().Be(204);
}
}
}
