public async Task <List <OperativeResponse> > ExecuteAsync(OperativeRequest searchModel)
        {
            var filter          = _filterBuilder.BuildFilter(searchModel);
            var gatewayResponse = await _operativesGateway.ListByFilterAsync(filter);

            return(gatewayResponse.Select(e => e.ToResponse()).ToList());
        }
示例#2
0
        public async Task RetrievesOperatives(int count)
        {
            // Arrange
            var operatives             = _fixture.CreateMany <Operative>(count);
            var operativesSearchParams = new OperativeRequest();
            var filter = _filterBuilder.BuildFilter(operativesSearchParams);
            await InMemoryDb.Instance.Operatives.AddRangeAsync(operatives);

            await InMemoryDb.Instance.SaveChangesAsync();

            // Act
            var dbResult = await _classUnderTest.ListByFilterAsync(filter);

            // Assert
            dbResult.Should().BeEquivalentTo(operatives);
        }
示例#3
0
        public async Task ReturnsOperatives(int operativeCount)
        {
            // Arrange
            var operatives = _fixture.CreateMany <Operative>(operativeCount);

            _operativeGateway
            .Setup(gateway => gateway.ListByFilterAsync(It.IsAny <IFilter <Operative> >()))
            .ReturnsAsync(operatives);
            var operativesSearchParams = new OperativeRequest();

            // Act
            var useCaseResult = await _classUnderTest.ExecuteAsync(operativesSearchParams);

            // Assert
            useCaseResult.Should().HaveCount(operativeCount);
        }
        public async Task ListsOperatives(int operativeCount)
        {
            // Arrange
            var operatives = _fixture.CreateMany <OperativeResponse>(operativeCount);

            _listOperativesUseCaseMock
            .Setup(m => m.ExecuteAsync(It.IsAny <OperativeRequest>()))
            .ReturnsAsync(operatives.ToList());
            var operativeSearchParams = new OperativeRequest();

            // Act
            var objectResult = await _classUnderTest.ListOperatives(operativeSearchParams);

            var operativesResult = GetResultData <List <OperativeResponse> >(objectResult);
            var statusCode       = GetStatusCode(objectResult);

            // Assert
            statusCode.Should().Be((int)HttpStatusCode.OK);
            operativesResult.Should().HaveCount(operativeCount);
        }
        public async Task <IActionResult> ListOperatives([FromQuery] OperativeRequest operativeRequest)
        {
            var result = await _listOperativesUseCase.ExecuteAsync(operativeRequest);

            return(Ok(result));
        }