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