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); } } }