public void PropAndMethodCall()
{
var f1 = (Expression <Func <Uri, bool> >)(arg1 => Uri.IsWellFormedUriString(arg1.ToString(), UriKind.Absolute));
var f2 = (Expression <Func <Uri, bool> >)(u => Uri.IsWellFormedUriString(u.ToString(), UriKind.Absolute));
Assert.IsTrue(Lambda.Eq(f1, f2));
}
private IKAnonimization GetAlgorithm(Expression <Func <Person, object> > property)
{
if (_parameterK == _maxKParameterK - 2)
{
return(new CharacterMasking <object>(property));
}
if (Lambda.Eq(property, p => p.Age))
{
return(new KNumberAnonimization <string>(_parameterK, p => p.Age));
}
if (Lambda.Eq(property, p => p.FirstName))
{
return(new KAttributeLengthAnonimization <string>(_parameterK, p => p.FirstName));
}
if (Lambda.Eq(property, p => p.Surname))
{
return(new KAttributeLengthAnonimization <string>(_parameterK, p => p.Surname));
}
if (Lambda.Eq(property, p => p.Job) && _dictionaries.ContainsKey(p => p.Job))
{
return(new KJobAnonimization(_parameterK, _dictionaries[p => p.Job]));
}
if (Lambda.Eq(property, p => p.City) && _dictionaries.ContainsKey(p => p.City))
{
return(new KCityAnonimization(_parameterK, _dictionaries[p => p.City]));
}
if (Lambda.Eq(property, p => p.Gender))
{
return(new CharacterMasking <string>(p => p.Gender));
}
throw new Exception($"No algorithm for {property} defined");
}
public async Task DeleteUserAsync_Should_Delete_UserAsync(DbUser dbUser, UserModel userModel)
{
_mapper.Map <DbUser>(userModel).Returns(dbUser);
_mapper.Map <UserModel>(dbUser).Returns(userModel);
Expression <Func <DbUser, bool> > getExpression = null;
Expression <Func <DbUser, bool> > deleteExpression = null;
_mongoCollectionClient
.When(x => x.DeleteOneAsync(CollectionName, Arg.Any <Expression <Func <DbUser, bool> > >()))
.Do(info => { getExpression = (Expression <Func <DbUser, bool> >)info[1]; });
_mongoCollectionClient
.When(x => x.FindOneAsync(CollectionName, Arg.Any <Expression <Func <DbUser, bool> > >()))
.Do(info => { deleteExpression = (Expression <Func <DbUser, bool> >)info[1]; });
_mongoCollectionClient
.FindOneAsync(CollectionName, Arg.Any <Expression <Func <DbUser, bool> > >())
.Returns(dbUser);
await _userRepositoryInstance.DeleteUserAsync(dbUser.Id);
Expression <Func <DbUser, bool> > expectedExpression = x => x.Id == dbUser.Id;
await _mongoCollectionClient
.Received(1)
.DeleteOneAsync(CollectionName, Arg.Any <Expression <Func <DbUser, bool> > >());
Assert.IsTrue(Lambda.Eq(expectedExpression, getExpression));
Assert.IsTrue(Lambda.Eq(expectedExpression, deleteExpression));
}
public void GetPreLoginElectionData_ShouldReturnAValid_RetrievedPageDataModel()
{
// Arrange
// because the LoginServices class requires an instance of the
// IElectionsRepository
var mockElectionsRepo = new Mock <IElectionsRepository>();
mockElectionsRepo.Setup(x => x.GetById(It.IsAny <int>()))
.Returns <int>(electionId =>
{
var newElection = new Election
{
Id = electionId,
OpenDate = ExpectedOpenDate,
CloseDate = ExpectedCloseDate,
LoginScreenOpenMessage = ExpectedLoginScreenOpenMessage,
LoginScreenCloseMessage = ExpectedLoginScreenCloseMessage,
LoginIdLabelTxt = ExpectedLoginIdLabelTxt,
LoginPinLabelTxt = ExpectedLoginPinLabelTxt,
LandingPageTitle = ExpectedLandingPageTitle,
LandingPageMessage = ExpectedLandingPageMessage
};
return(newElection);
});
var mockVotersRepo = new Mock <IVotersRepository>();
Expression <Func <Voter, bool> > testExpression = expr => (expr.LoginId == "22222222");
mockVotersRepo.Setup(x => x.Get(It.Is <Expression <Func <Voter, bool> > >(
criteria => Lambda.Eq(criteria, testExpression))))
.Returns <Voter>(voter =>
{
var newVoter = new Voter
{
LoginId = voter.LoginId,
LoginPin = "1234"
};
return(newVoter);
});
var loginServices = new LoginServices(
mockElectionsRepo.Object,
mockVotersRepo.Object);
// Act
var result = loginServices.GetPreLoginElectionData(1);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(RetrievedPageDataModel));
Assert.AreEqual(ExpectedOpenDate, result.OpenDate);
Assert.AreEqual(ExpectedCloseDate, result.CloseDate);
Assert.AreEqual(ExpectedLoginScreenOpenMessage, result.LoginScreenOpenMessage);
Assert.AreEqual(ExpectedLoginScreenCloseMessage, result.LoginScreenCloseMessage);
Assert.AreEqual(ExpectedLoginIdLabelTxt, result.LoginIdLabelTxt);
Assert.AreEqual(ExpectedLoginPinLabelTxt, result.LoginPinLabelTxt);
Assert.AreEqual(ExpectedLandingPageTitle, result.LandingPageTitle);
Assert.AreEqual(ExpectedLandingPageMessage, result.LandingPageMessage);
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <GameRoot, bool> > expectedExpression = game => true && _keys.Contains(game.Key);
var expression = _keysPipelineNode.Execute(game => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <Product, bool> > expectedExpression = product => true && !_keys.Contains(product.Key);
var expression = _excludeKeysPipelineNode.Execute(product => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <GameRoot, bool> > expectedExpression =
root => true && (root.Localizations.Any(l => l.Name.Contains(Name)) || root.Details == null);
var expression = _namePipelineNode.Execute(game => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsInputExpression_WhenNotValidConstructorArgument()
{
_namePipelineNode = new NamePipelineNode(string.Empty);
Expression <Func <GameRoot, bool> > input = root => root.Details.Id.Contains(Name);
var expression = _namePipelineNode.Execute(input);
var areEquals = Lambda.Eq(input, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsInputExpression_WhenNotValidConstructorArgument()
{
_excludeKeysPipelineNode = new ExcludeKeysPipelineNode(Enumerable.Empty <string>());
Expression <Func <Product, bool> > input = product => product.ProductName.Contains(string.Empty);
var expression = _excludeKeysPipelineNode.Execute(input);
var areEquals = Lambda.Eq(input, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <GameRoot, bool> > expectedExpression =
root => true && (root.Details.Price >= MinPrice && root.Details.Price <= MaxPrice || root.Details == null);
var expression = _priceRangePipelineNode.Execute(game => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsInputExpression_WhenNotValidConstructorArgument()
{
_priceRangePipelineNode = new PriceRangePipelineNode(0, 0);
Expression <Func <Product, bool> > input = product => product.ProductName.Contains(string.Empty);
var expression = _priceRangePipelineNode.Execute(input);
var areEquals = Lambda.Eq(input, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsNewExpression_WhenNullParameter()
{
Expression <Func <Product, bool> > expected = product =>
product.UnitPrice >= MinPrice && product.UnitPrice <= MaxPrice;
var expression = _priceRangePipelineNode.Execute(null);
var areEquals = Lambda.Eq(expected, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <Product, bool> > expectedExpression =
product => true && (product.UnitPrice >= MinPrice && product.UnitPrice <= MaxPrice);
var expression = _priceRangePipelineNode.Execute(game => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsInputExpression_WhenNotValidConstructorArgument()
{
_namePipelineNode = new NamePipelineNode(string.Empty, _keysWhereExistLocalization);
Expression <Func <Product, bool> > input = product => product.ProductName.Contains(Name);
var expression = _namePipelineNode.Execute(input);
var areEquals = Lambda.Eq(input, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <GameRoot, bool> > expectedExpression = game => true &&
game.GamePlatforms.Any(gamePlatform => _platformNames.Contains(gamePlatform.PlatformId));
var expression = _platformsPipelineNode.Execute(game => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <Product, bool> > expectedExpression = product => true &&
(product.ProductName.Contains(Name) || _keysWhereExistLocalization.Contains(product.Key));
var expression = _namePipelineNode.Execute(game => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsInputExpression_WhenNotValidConstructorArgument()
{
_platformsPipelineNode = new PlatformsPipelineNode(Enumerable.Empty <string>());
Expression <Func <GameRoot, bool> > input = game => game.IsDeleted == false;
var expression = _platformsPipelineNode.Execute(input);
var areEquals = Lambda.Eq(input, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsNewExpression_WhenNullParameter()
{
Expression <Func <GameRoot, bool> > expected = game =>
game.GameGenres.Any(gameGenre => _genreNames.Contains(gameGenre.GenreId));
var expression = _genresPipelineNode.Execute(null);
var areEquals = Lambda.Eq(expected, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsInputExpression_WhenNotValidConstructorArgument()
{
_publishersPipelineNode =
new PublishersPipelineNode(Enumerable.Empty <string>(), Enumerable.Empty <string>());
Expression <Func <Product, bool> > input = product => product.Discontinued == false;
var expression = _publishersPipelineNode.Execute(input);
var areEquals = Lambda.Eq(input, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <GameRoot, bool> > expectedExpression =
game => true && (_publisherIds.Contains(game.PublisherEntityId) ||
game.PublisherEntityId == null && game.Details == null);
var expression = _publishersPipelineNode.Execute(game => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsCombinedExpression_WhenNotNullParameter()
{
Expression <Func <Product, bool> > expectedExpression = product
=> true && (_keysWherePublishersAreInitialized.Contains(product.Key) ||
_publishersId.Contains(product.SupplierId));
var expression = _publishersPipelineNode.Execute(game => true);
var areEquals = Lambda.Eq(expectedExpression, expression);
areEquals.Should().BeTrue();
}
public void Execute_ReturnsNewExpression_WhenNullParameter()
{
Expression <Func <GameRoot, bool> > expected = gameRoot =>
_publisherIds.Contains(gameRoot.PublisherEntityId) ||
gameRoot.PublisherEntityId == null && gameRoot.Details == null;
var expression = _publishersPipelineNode.Execute(null);
var areEquals = Lambda.Eq(expected, expression);
areEquals.Should().BeTrue();
}
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 BasicConst()
{
var const1 = 25;
var f1 = (Expression <Func <int, string, string> >)((first, second) =>
$"{(first + const1).ToString(CultureInfo.InvariantCulture)}{first + second}{"some const value".ToUpper()}{const1}");
var const2 = "some const value";
var const3 = "{0}{1}{2}{3}";
var f2 = (Expression <Func <int, string, string> >)((i, s) =>
string.Format(const3, (i + 25).ToString(CultureInfo.InvariantCulture), i + s, const2.ToUpper(), 25));
Assert.IsTrue(Lambda.Eq(f1, f2));
}
public async Task DeleteJsonAsync_Should_Delete_User_Json_With_Same_IdAsync(string username, Guid jsonId)
{
Expression <Func <DbJson, bool> > expression = null;
_mongoCollectionClient
.When(x => x.DeleteOneAsync(username, Arg.Any <Expression <Func <DbJson, bool> > >()))
.Do(info => { expression = (Expression <Func <DbJson, bool> >)info[1]; });
await _jsonRepositoryInstance.DeleteJsonAsync(username, jsonId);
Expression <Func <DbJson, bool> > expectedExpression = x => x.Id == jsonId;
Assert.IsTrue(Lambda.Eq(expectedExpression, expression));
}
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 async Task IsUsernameExistAsync_Should_Return_Search_User_With_Same_UsernameAsync(string username, bool exist)
{
Expression <Func <DbUser, bool> > expression = null;
_mongoCollectionClient
.When(x => x.ExistAsync(CollectionName, Arg.Any <Expression <Func <DbUser, bool> > >()))
.Do(info => { expression = (Expression <Func <DbUser, bool> >)info[1]; });
_mongoCollectionClient
.ExistAsync(CollectionName, Arg.Any <Expression <Func <DbUser, bool> > >())
.Returns(exist);
var result = await _userRepositoryInstance.IsUsernameExistAsync(username);
Expression <Func <DbUser, bool> > expectedExpression = x => x.Username == username;
Assert.AreEqual(exist, result);
Assert.IsTrue(Lambda.Eq(expectedExpression, expression));
}
public void MemberInitWithConditional()
{
var port = 443;
var f1 = (Expression <Func <Uri, UriBuilder> >)(x => new UriBuilder(x)
{
Port = port,
Host = string.IsNullOrEmpty(x.Host) ? "abc" : "def"
});
var isSecure = true;
var f2 = (Expression <Func <Uri, UriBuilder> >)(u => new UriBuilder(u)
{
Host = string.IsNullOrEmpty(u.Host) ? "abc" : "def",
Port = isSecure ? 443 : 80
});
Assert.IsTrue(Lambda.Eq(f1, f2));
}
public async Task GetJsonAsync_Should_Return_User_Json_With_Same_IdAsync(string username, DbJson dbJson, JsonModel jsonModel)
{
Expression <Func <DbJson, bool> > expression = null;
_mongoCollectionClient
.When(x => x.FindOneAsync(username, Arg.Any <Expression <Func <DbJson, bool> > >()))
.Do(info => { expression = (Expression <Func <DbJson, bool> >)info[1]; });
_mongoCollectionClient
.FindOneAsync(username, Arg.Any <Expression <Func <DbJson, bool> > >())
.Returns(dbJson);
_mapper.Map <JsonModel>(dbJson).Returns(jsonModel);
var result = await _jsonRepositoryInstance.GetJsonAsync(username, dbJson.Id);
Expression <Func <DbJson, bool> > expectedExpression = x => x.Id == dbJson.Id;
Assert.AreEqual(jsonModel, result);
Assert.IsTrue(Lambda.Eq(expectedExpression, expression));
}
