public async Task GetCategoryByIdQueryHandler_WhenCalled_ReturnGetCategoryByIdLookupModel()
{
var returnModel = new GetCategoryByIdLookupModel
{
CategoryId = 1,
Name = "Category1"
};
_categoryServiceMock
.Setup(x => x.GetCategoryByIdAsync(It.IsAny <int>(), CancellationToken.None))
.ReturnsAsync(returnModel);
var query = new GetCategoryByIdQuery {
CategoryId = 1
};
var container = Registrations();
await using var scope = container.BeginLifetimeScope();
var options = scope.Resolve <DbContextOptions <TechnicalTestDbContext> >();
await using var context = new TechnicalTestDbContext(options);
await SeedMockDataAsync(context);
var handler = new GetCategoryByIdQueryHandler(_categoryServiceMock.Object);
var result = await handler.Handle(query, CancellationToken.None);
Assert.AreEqual("Category1", result.Name);
}
public async Task <IActionResult> GetCategoryById(int categoryId)
{
var query = new GetCategoryByIdQuery(categoryId);
var result = await Mediator.Send(query);
return(result != null ? (IActionResult)Ok(result) : NotFound());
}
public async Task <IActionResult> Get(int catId)
{
var query = new GetCategoryByIdQuery();
var results = await _queryExecutor.ExecuteAsync(query);
return(_apiResponseHelper.SimpleQueryResponse(this, results));
}
public async Task <CategoryDto> Handle(GetCategoryByIdQuery request, CancellationToken cancellationToken)
{
using var connection = new SqlConnection(_connectionStringProvider.ConnectionString);
connection.Open();
return(await connection.QueryFirstOrDefaultAsync <CategoryDto>(sql, new { request.Id }));
}
public async Task GetCategoryByIdQueryTestAsync(int categoryId, int?result)
{
GetCategoryByIdQuery request = new GetCategoryByIdQuery
{
CategoryId = categoryId,
};
GetCategoryByIdQueryHandler handler = new GetCategoryByIdQueryHandler(_fixture.Context);
var expectedResult = await handler.Handle(request, new CancellationToken());
Assert.Equal(expectedResult?.Id, result);
}
public async Task <IActionResult> GetCategoryById(int libraryId, int categoryId, CancellationToken token = default(CancellationToken))
{
var query = new GetCategoryByIdQuery(libraryId, categoryId);
var category = await _queryProcessor.ExecuteAsync(query, token);
if (category == null)
{
return(new NotFoundResult());
}
return(new OkObjectResult(_categoryRenderer.Render(category, libraryId)));
}
public async Task <OperationResult <Category> > Handle(GetCategoryByIdQuery request, CancellationToken cancellationToken)
{
try
{
var getAllCatgory = await unitOfWork.CategoryRepository.GetCategoryByIdAsync(request.Id, cancellationToken);
return(OperationResult <Category> .BuildSuccessResult(getAllCatgory.Result));
}
catch (Exception ex)
{
return(OperationResult <Category> .BuildFailure(ex.Message));
}
}
public async Task <IActionResult> GetCategoryAsync(Guid id)
{
var query = new GetCategoryByIdQuery()
{
Id = id
};
var category = await _mediator.Send(query);
if (category == null)
{
return(NotFound());
}
return(Ok(category));
}
public async Task GetCategoryById_Success_ReturnCategoryDto()
{
//Arrange
var category = new Category()
{
CategoryId = Constants.CategoryId,
Name = "Phone",
Thumbnail = "no-image.jpg"
};
var products = new List <Product>()
{
new Product()
{
ProductId = Constants.ProductId,
BrandName = "Pineapple",
ProductName = "PinePhone X",
CategoryId = category.CategoryId,
Price = 1200,
Stock = 12,
Sku = "12312",
Category = category,
Images = "no-images"
}
};
await _fuhoDbContext.Categories.AddRangeAsync(category);
await _fuhoDbContext.Products.AddRangeAsync(products);
await _fuhoDbContext.SaveChangesAsync();
var getCategoryByIdQuery = new GetCategoryByIdQuery()
{
CategoryId = Constants.CategoryId
};
//Act
var sut = new GetCategoryByIdHandler(_fuhoDbContext, _logger.Object);
var result = await sut.Handle(getCategoryByIdQuery, CancellationToken.None);
//Assert
Assert.NotNull(sut);
Assert.IsType <CategoryDto>(result);
}
public async Task <IActionResult> EditCategory(long id)
{
var gcbiq = new GetCategoryByIdQuery
{
Id = id
};
var c = await _qpa.ProcessAsync(gcbiq);
if (c != null)
{
return(View(new CategoryViewModel {
Id = c.Id, Name = c.Name, Description = c.Description
}));
}
_logger.LogWarning("EditCategory called with non-existant id {0}", id);
// todo: better error handling
return(NotFound());
}
public async Task Handler_get_category_by_id_with_the_correct_properties()
{
var category = new Data.Entity.Category
{
Name = DateTime.Now.ToString(CultureInfo.InvariantCulture),
Description = "Test description",
Active = true
};
await Context.Categories.AddAsync(category);
await Context.SaveChangesAsync();
var query = new GetCategoryByIdQuery(category.Id);
var dbCategory = await mediator.ProcessQueryAsync(query);
Assert.IsNotNull(dbCategory);
Assert.That.This(dbCategory).HasSameProperties(category);
}
public async Task <IActionResult> EditCategory(long id)
{
var gcbiq = new GetCategoryByIdQuery()
{
Id = id
};
var c = await _qpa.ProcessAsync(gcbiq);
if (c != null)
{
return(View(new CategoryViewModel()
{
Id = c.Id, Name = c.Name, Description = c.Description
}));
}
else
{
return(NotFound());
}
}
public async Task <IDataResult <CategoryDto> > GetById(GetCategoryByIdQuery query)
{
var searchResults = await this.GetByField(nameof(SearchableCategory.Id), query.Id);
return(this.HandleSingleResult(searchResults));
}
public async Task <ActionResult <CategoryDto> > GetCategory([FromHybrid] GetCategoryByIdQuery query)
{
var result = await _mediator.Send(query);
return(Ok(result));
}
