public void CreateQueryParameters_WhenFilterExpressionIsNull_ThrowsArgumentNullException <TKey>(TKey defaultValue)
{
// Arrange & Act & Assert
var exception = Assert.Throws <ArgumentNullException>(
() => FilterExpressionExtensions.CreateQueryParameters <IEntity <TKey>, TKey>(null)
);
Assert.NotNull(defaultValue);
Assert.Equal("filterExpression", exception.ParamName);
}
public async Task GetAsync_Success <TKey>(
TKey defaultKey,
FakeDto <TKey> item,
FakeDto <TKey> expectedResult)
{
// Arrange
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <FakeEntity <TKey>, TKey>(defaultKey);
var mockRepository = new Mock <IRepository <FakeEntity <TKey>, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.GetAsync <FakeDto <TKey> >(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.ReturnsAsync(item);
var businessService = new FakeBusinessService <TKey>(
_mockUnitOfWork.Object,
_ => mockRepository.Object,
_mockBusinessMapper.Object,
_mockLogger.Object
);
// Act
var result = await businessService.GetAsync(defaultKey);
// Assert
mockRepository
.Verify(
x => x.GetAsync <FakeDto <TKey> >(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
),
Times.Once
);
Assert.Equal(expectedResult, result, new FakeDtoEqualityComparer <TKey>());
}
public void GetModel_ById_ReturnsModel <TEntity, TKey>(
TKey defaultKey,
TEntity entity,
object id,
bool expectedResult)
where TEntity : class, IEntity <TKey>
{
// Arrange
var model = new FakeModel();
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <TEntity, TKey>((TKey)id);
var mockRepository = new Mock <IRepository <TEntity, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.Get <FakeModel>(
It.Is <QueryParameters <TEntity, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.Returns(model);
var repository = mockRepository.Object;
// Act
var result = repository.Get <FakeModel, TEntity, TKey>((TKey)id);
// Assert
if (id != null)
{
Assert.IsType(defaultKey.GetType(), id);
}
Assert.Equal(
expectedResult,
filterExpression.Compile().Invoke(entity)
);
Assert.Equal(model, result);
}
public async Task ExistsAsync_ById_ReturnsEntity <TEntity, TKey>(
TKey defaultKey,
TEntity entity,
object id,
bool expectedResult)
where TEntity : class, IEntity <TKey>
{
// Arrange
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <TEntity, TKey>((TKey)id);
var mockRepository = new Mock <IRepository <TEntity, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.ExistsAsync(
It.Is <QueryParameters <TEntity, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.ReturnsAsync(true);
var repository = mockRepository.Object;
// Act
var result = await repository.ExistsAsync((TKey)id);
// Assert
if (id != null)
{
Assert.IsType(defaultKey.GetType(), id);
}
Assert.Equal(
expectedResult,
filterExpression.Compile().Invoke(entity)
);
Assert.True(result);
}
public void CreateIdFilterExpression <TEntity, TKey>(
TKey defaultKey,
TEntity entity,
object id,
bool expectedResult)
where TEntity : class, IEntity <TKey>
{
// Arrange & Act
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <TEntity, TKey>((TKey)id);
// Assert
if (id != null)
{
Assert.IsType(defaultKey.GetType(), id);
}
Assert.Equal(
expectedResult,
filterExpression.Compile().Invoke(entity)
);
}
public static ISolrQuery HandleMemberAccess(this MemberExpression memberExpression, MemberContext context)
{
if (memberExpression.Type != typeof(bool))
{
throw new InvalidOperationException(
$"Member '{memberExpression.Member.Name}' must be boolean to be a part of filter");
}
if (context.IsAccessToMember(memberExpression))
{
return(new SolrQueryByField(context.GetSolrMemberProduct(memberExpression, true),
context.TrueStringSerialized));
}
if (memberExpression.IsNullableMember())
{
if (memberExpression.Expression.HandleConversion() is MemberExpression inner)
{
if (context.IsAccessToMember(inner))
{
if (memberExpression.Member.Name == nameof(Nullable <int> .HasValue))
{
return(new SolrHasValueQuery(context.GetSolrMemberProduct(inner)));
}
if (memberExpression.Member.Name == nameof(Nullable <int> .Value))
{
return(new SolrQueryByField(context.GetSolrMemberProduct(inner),
context.TrueStringSerialized));
}
}
}
}
// try to calculate values
return(FilterExpressionExtensions.ConstantToConstant(memberExpression, Expression.Constant(true), (a, b) => (bool)a == (bool)b));
}
public void Delete_ById_WhenEntityIsNotNull <TEntity, TKey>(
TKey defaultKey,
TEntity entity,
object id,
bool expectedResult)
where TEntity : class, IEntity <TKey>
{
// Arrange
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <TEntity, TKey>((TKey)id);
var mockRepository = new Mock <IRepository <TEntity, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.Get(
It.Is <QueryParameters <TEntity, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.Returns(entity);
mockRepository
.Setup(x => x.Delete(entity));
var repository = mockRepository.Object;
// Act
repository.Delete((TKey)id);
// Assert
if (id != null)
{
Assert.IsType(defaultKey.GetType(), id);
}
Assert.Equal(
expectedResult,
filterExpression.Compile().Invoke(entity)
);
mockRepository
.Verify(
x => x.Get(
It.Is <QueryParameters <TEntity, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
),
Times.Once
);
mockRepository
.Verify(
x => x.Delete(entity),
Times.Once
);
}
public async Task EditAsync_WhenNotFound_ReturnsNull <TKey>(
TKey defaultKey)
{
// Arrange
var item = new FakeEditDto <TKey>
{
Id = defaultKey
};
Expression <Action <ILogger> > loggerExpressionEdit = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
$"Edit item: {item}"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger
.Setup(x => x.IsEnabled(LogLevel.Information))
.Returns(true);
_mockLogger
.Setup(x => x.IsEnabled(LogLevel.Warning))
.Returns(true);
_mockLogger.Setup(loggerExpressionEdit);
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <FakeEntity <TKey>, TKey>(defaultKey);
var mockRepository = new Mock <IRepository <FakeEntity <TKey>, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.GetAsync(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.ReturnsAsync(() => null);
Expression <Action <ILogger> > loggerExpressionNotFound = x => x.Log(
LogLevel.Warning,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
$"Item not found: {item.Id}"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger.Setup(loggerExpressionNotFound);
var businessService = new FakeBusinessService <TKey>(
_mockUnitOfWork.Object,
_ => mockRepository.Object,
_mockBusinessMapper.Object,
_mockLogger.Object
);
// Act
var result = await businessService.EditAsync(item);
// Assert
_mockLogger.Verify(loggerExpressionEdit, Times.Once);
mockRepository
.Verify(
x => x.GetAsync(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
),
Times.Once
);
_mockLogger.Verify(loggerExpressionNotFound, Times.Once);
Assert.Null(result);
}
public async Task EditAsync_Success <TKey>(
TKey defaultKey,
FakeEditDto <TKey> item,
FakeEntity <TKey> entity,
FakeDto <TKey> expectedResult)
{
// Arrange
Expression <Action <ILogger> > loggerExpressionEdit = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
$"Edit item: {item}"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger
.Setup(x => x.IsEnabled(LogLevel.Information))
.Returns(true);
_mockLogger.Setup(loggerExpressionEdit);
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <FakeEntity <TKey>, TKey>(defaultKey);
var mockRepository = new Mock <IRepository <FakeEntity <TKey>, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.GetAsync(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.ReturnsAsync(entity);
_mockBusinessMapper
.Setup(
x => x.Map(item, entity)
)
.Returns(entity);
mockRepository
.Setup(
x => x.Update(entity, false)
)
.Returns(entity);
Expression <Action <ILogger> > loggerExpressionSave = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
"Save changes"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger.Setup(loggerExpressionSave);
_mockUnitOfWork
.Setup(
x => x.CommitAsync()
)
.ReturnsAsync(1);
_mockBusinessMapper
.Setup(
x => x.Map <FakeEntity <TKey>, FakeDto <TKey> >(entity)
)
.Returns(expectedResult);
var businessService = new FakeBusinessService <TKey>(
_mockUnitOfWork.Object,
_ => mockRepository.Object,
_mockBusinessMapper.Object,
_mockLogger.Object
);
// Act
var result = await businessService.EditAsync(item);
// Assert
_mockLogger.Verify(loggerExpressionEdit, Times.Once);
mockRepository
.Verify(
x => x.GetAsync(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
),
Times.Once
);
_mockBusinessMapper
.Verify(
x => x.Map(item, entity),
Times.Once
);
mockRepository
.Verify(
x => x.Update(entity, false),
Times.Once
);
_mockLogger.Verify(loggerExpressionSave, Times.Once);
_mockUnitOfWork
.Verify(
x => x.CommitAsync(),
Times.Once
);
_mockBusinessMapper
.Verify(
x => x.Map <FakeEntity <TKey>, FakeDto <TKey> >(entity),
Times.Once
);
Assert.Equal(expectedResult, result, new FakeDtoEqualityComparer <TKey>());
}
public async Task DeleteAsync_Success <TKey>(
TKey defaultKey,
int numberOfRowsAffected,
bool expectedResult)
{
// Arrange
Expression <Action <ILogger> > loggerExpressionDelete = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
$"Delete item: {defaultKey}"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger.Setup(loggerExpressionDelete);
var entity = new FakeEntity <TKey>();
var filterExpression = FilterExpressionExtensions.CreateIdFilterExpression <FakeEntity <TKey>, TKey>(defaultKey);
var mockRepository = new Mock <IRepository <FakeEntity <TKey>, TKey> >(MockBehavior.Strict);
mockRepository
.Setup(
x => x.Get(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
)
)
.Returns(entity);
mockRepository
.Setup(
x => x.Delete(entity)
);
Expression <Action <ILogger> > loggerExpressionSave = x => x.Log(
LogLevel.Information,
0,
It.Is <It.IsAnyType>((v, t) =>
v.ToString() ==
"Save changes"
),
null,
It.Is <Func <It.IsAnyType, Exception, string> >((v, t) => true)
);
_mockLogger
.Setup(x => x.IsEnabled(LogLevel.Information))
.Returns(true);
_mockLogger.Setup(loggerExpressionSave);
_mockUnitOfWork
.Setup(
x => x.CommitAsync()
)
.ReturnsAsync(numberOfRowsAffected);
var businessService = new FakeBusinessService <TKey>(
_mockUnitOfWork.Object,
_ => mockRepository.Object,
_mockBusinessMapper.Object,
_mockLogger.Object
);
// Act
var result = await businessService.DeleteAsync(defaultKey);
// Assert
Assert.NotNull(defaultKey);
_mockLogger.Verify(loggerExpressionDelete, Times.Once);
mockRepository
.Verify(
x => x.Get(
It.Is <QueryParameters <FakeEntity <TKey>, TKey> >(
y => Lambda.Eq(
y.Filter.Expression,
filterExpression
) &&
y.Sort == null &&
y.Page == null
)
),
Times.Once
);
mockRepository
.Verify(
x => x.Delete(entity),
Times.Once
);
_mockLogger.Verify(loggerExpressionSave, Times.Once);
_mockUnitOfWork
.Verify(
x => x.CommitAsync(),
Times.Once
);
Assert.Equal(expectedResult, result);
}
