public StatisticsDTO GetStatistics(int userId, StatisticsRequestDTO dto) { if (dto == null) { throw new ArgumentNullException("dto"); } var key = _keyFactory .CreateKey() .Add("statistics") .AddTag("expence", "create", userId) .AddTag("expence", "update", userId) .AddTag("expence", "delete", userId) .Add("from").Add(dto.From.ToShortDateString()) .Add("to").Add(dto.To.ToShortDateString()) .GetKey(); var resultDTO = _cache.Get<StatisticsDTO>(key); if (resultDTO == null) { var spec = new AndSpecification<Expence>( ExpenceSpecifications.ByUserId(userId), ExpenceSpecifications.DateFilter(dto.From, dto.To)); //TODO: make async calls var summary = _statsRepostiory .GetSummary(spec); var topCategories = _statsRepostiory .GetCategoriesRating(spec) .Take(5); resultDTO = new StatisticsDTO { Summary = new SummaryStatisticsDTO { Total = summary.Total }, TopCategories = topCategories.Select(c => new CategorySummaryDTO { Name = c.CategoryName, Total = c.Total }) }; _cache.Set( key, resultDTO, new System.Runtime.Caching.CacheItemPolicy { SlidingExpiration = TimeSpan.FromDays(1) }); } return resultDTO; }
public void Test_And_AllTrue() { AndSpecification s = new AndSpecification(); s.Add(AlwaysTrue); s.Add(AlwaysTrue); Assert.IsTrue(s.Test(null).Success); }
public void CreateAndSpecificationTest() { //Arrange DirectSpecification<SampleEntity> leftAdHocSpecification; DirectSpecification<SampleEntity> rightAdHocSpecification; var identifier = Guid.NewGuid(); Expression<Func<SampleEntity, bool>> leftSpec = s => s.Id == identifier; Expression<Func<SampleEntity, bool>> rightSpec = s => s.SampleProperty.Length > 2; leftAdHocSpecification = new DirectSpecification<SampleEntity>(leftSpec); rightAdHocSpecification = new DirectSpecification<SampleEntity>(rightSpec); //Act AndSpecification<SampleEntity> composite = new AndSpecification<SampleEntity>(leftAdHocSpecification, rightAdHocSpecification); //Assert Assert.IsNotNull(composite.SatisfiedBy()); Assert.ReferenceEquals(leftAdHocSpecification, composite.LeftSideSpecification); Assert.ReferenceEquals(rightAdHocSpecification, composite.RightSideSpecification); var list = new List<SampleEntity>(); var sampleA = new SampleEntity() { SampleProperty = "1" }; sampleA.ChangeCurrentIdentity(identifier); var sampleB = new SampleEntity() { SampleProperty = "the sample property" }; sampleB.ChangeCurrentIdentity(identifier); list.AddRange(new SampleEntity[] { sampleA, sampleB }); var result = list.AsQueryable().Where(composite.SatisfiedBy()).ToList(); Assert.IsTrue(result.Count == 1); }
public void Test_And_Mixed() { AndSpecification s = new AndSpecification(); s.Add(AlwaysFalse); s.Add(AlwaysTrue); Assert.IsFalse(s.Test(null).Success); }
public void TwoPassingSpecsShouldPass() { var sut = new AndSpecification<int>(new FunctionSpecification<int>(i => i > 0), new FunctionSpecification<int>(i => i > 0)); var result = sut.IsSatisfiedBy(1); result.Should().BeTrue(); }
public void IsSatisfiedByReturnsFalseIBothArentSatisfied() { _left = SpecificationGenerator.GetSpecification(false); _right = SpecificationGenerator.GetSpecification(false); var andSpecification = new AndSpecification<object>(_left, _right); Assert.False(andSpecification.IsSatisfiedBy(string.Empty)); }
/// <summary> /// 获取登录用户信息 /// </summary> /// <param name="userName"></param> /// <param name="password"></param> /// <returns></returns> public EmployeeDataObject GetLoginEmployee(string userName, string password) { ISpecification<Employee> specification = new AndSpecification<Employee>(new EmployeeUserNameEqualSpecification(userName), new EmployeePasswordEqualSpecification(password)); Employee entity = this._employeeRepository.Find(specification); return Mapper.Map<Employee, EmployeeDataObject>(entity); }
public void IsSatisfiedByReturnsTrueIfBothAreSatisfiedBy() { _left = SpecificationGenerator.GetSpecification(true); _right = SpecificationGenerator.GetSpecification(true); var andSpecification = new AndSpecification<object>(_left, _right); Assert.True(andSpecification.IsSatisfiedBy(string.Empty)); }
public void TwoFailingSpecsShouldFail() { var sut = new AndSpecification<int>(new FunctionSpecification<int>(i => i > 0), new FunctionSpecification<int>(i => i > 0)); var result = sut.IsSatisfiedBy(0); result.Should().BeFalse(); }
public void WhenSpecificationsAreDefinedThenResultIsAndSpecification() { var hasDrm = new HasDrmSpecification(); var hasEps = new HasAtLeaseOneEpisodeSpecification(); var sut = new AndSpecification<TvShow>(hasDrm, hasEps); Assert.IsInstanceOf<AndSpecification<TvShow>>(sut); Assert.IsTrue(sut.IsSatisfiedBy(new TvShow { Drm = true, EpisodeCount = 1 })); }
public void Should_Be_Fine_If_None_Are_Null() { var p1 = new PredicateSpecification<int>(x => x == 5); var p2 = new PredicateSpecification<int>(x => x >= 5); var spec = new AndSpecification<int>(p1, p2); Assert.AreEqual(spec.Left, p1); Assert.AreEqual(spec.Right, p2); }
public void AndMethodWithValidArgumentsShouldReturnAndSpecification() { Specification<object> spec1 = SpecificationUtils.CreateSatisfiedSpecification(); Specification<object> spec2 = SpecificationUtils.CreateSatisfiedSpecification(); Specification<object> expectedResult = new AndSpecification<object>(spec1, spec2); Specification<object> result = spec1.And(spec2); Assert.AreEqual(expectedResult, result); }
public void AndTestCase3() { var left = new ExpressionSpecification<String>( x => false ); var right = new ExpressionSpecification<String>( x => true ); var target = new AndSpecification<String>( left, right ); var actual = target.And( new ExpressionSpecification<String>( x => false ) ); var result = actual.IsSatisfiedBy( String.Empty ); Assert.IsFalse( result ); }
public void AndTestCaseNullCheck() { var left = new ExpressionSpecification<String>( x => false ); var right = new ExpressionSpecification<String>( x => true ); var target = new AndSpecification<String>( left, right ); ExpressionSpecification<String> other = null; Action test = () => target.And( other ); test.ShouldThrow<ArgumentNullException>(); }
public bool Match(MethodInfo method) { TypeInformationExtractor typeExtractor = new TypeInformationExtractor(_parameter); ISpecification<MethodInfo> exactlyOneParameter = new ExactlyOneMethodParameterSpecification(); ISpecification<MethodInfo> parameterTypeMatch = new FirstMethodParameterTypeSpecification(typeExtractor.ExtractType()); ISpecification<MethodInfo> exactlyOneParameterAndParameterTypeMatch = new AndSpecification<MethodInfo>(exactlyOneParameter, parameterTypeMatch); return exactlyOneParameterAndParameterTypeMatch.IsSatisfiedBy(method); }
public void CriaAndSpecificationComLambdaRightNullEThrowArgumentNullExceptionTest() { //Arrange CompositeSpecification<ClienteStub> compoSpecification; Expression<Func<ClienteStub, bool>> lambda = s => s.Nome != string.Empty; DirectSpecification<ClienteStub> direct = new DirectSpecification<ClienteStub>(lambda); //Act compoSpecification = new AndSpecification<ClienteStub>(direct, null); }
public void AndSpecificationSatisfiedTest() { // Arrange var specification = new AndSpecification<int>( new Specification<int>(x => x > 0), new Specification<int>(y => y < 10)); // Act var sut = specification.IsSatisfiedBy().Compile().Invoke(5); // Assert Assert.True(sut); }
private void AssertIsSatisfiedBy(bool leftSpecificationIsSatisfiedBy, bool rightSpecificationIsSatisfiedBy, bool expected) { var mockRepository = new MockRepository(MockBehavior.Strict); var leftSpecification = mockRepository.CreateSpecificationMock<string>(leftSpecificationIsSatisfiedBy); var rightSpecification = !leftSpecificationIsSatisfiedBy ? mockRepository.CreateSpecificationMock<string>() : mockRepository.CreateSpecificationMock<string>( rightSpecificationIsSatisfiedBy); var specification = new AndSpecification<string>(leftSpecification, rightSpecification); Assert.AreEqual(expected, specification.IsSatisfiedBy("test")); mockRepository.VerifyAll(); }
public void CreateAndSpecificationTest() { var leftAdHocSpecification = new DirectSpecification<SampleEntity>(s => s.Name == EntityName); var rightAdHocSpecification = new DirectSpecification<SampleEntity>(s => s.Order > 1); var composite = new AndSpecification<SampleEntity>(leftAdHocSpecification, rightAdHocSpecification); Assert.IsNotNull(composite.SatisfiedBy()); Assert.AreEqual(leftAdHocSpecification, composite.LeftSideSpecification); Assert.AreEqual(rightAdHocSpecification, composite.RightSideSpecification); var result = EntityList.AsQueryable().Where(composite.SatisfiedBy()).ToList(); Assert.AreEqual(1, result.Count); }
public void CreateAndSpecificationNullRightSpecThrowArgumentNullExceptionTest() { //Arrange DirectSpecification<SampleEntity> leftAdHocSpecification; DirectSpecification<SampleEntity> rightAdHocSpecification; Expression<Func<SampleEntity, bool>> rightSpec = s => s.Id == IdentityGenerator.NewSequentialGuid(); Expression<Func<SampleEntity, bool>> leftSpec = s => s.SampleProperty.Length > 2; leftAdHocSpecification = new DirectSpecification<SampleEntity>(leftSpec); rightAdHocSpecification = new DirectSpecification<SampleEntity>(rightSpec); //Act AndSpecification<SampleEntity> composite = new AndSpecification<SampleEntity>(leftAdHocSpecification, null); }
public void AndSpecification_Creation_NullRightSpecThrowArgumentNullException_Test() { //Arrange DirectSpecification<TEntity> leftAdHocSpecification; DirectSpecification<TEntity> rightAdHocSpecification; Expression<Func<TEntity, bool>> rightSpec = s=>s.Id==0; Expression<Func<TEntity, bool>> leftSpec = s => s.SampleProperty.Length > 2; leftAdHocSpecification = new DirectSpecification<TEntity>(leftSpec); rightAdHocSpecification = new DirectSpecification<TEntity>(rightSpec); //Act AndSpecification<TEntity> composite = new AndSpecification<TEntity>(leftAdHocSpecification, null); }
public void TestColorAndSizeFilter() { Size size = Size.Large; Color color = Color.Red; var spec1 = new SizeSpecification(size); var spec2 = new ColorSpecification(color); var andSizeSpecification = new AndSpecification(spec1, spec2); IList<IProduct> filterList = filter.Filter(_productList, andSizeSpecification); foreach (var product in filterList) { bool matched = (product.Color == color) && (product.Size == size); Assert.IsTrue(matched); } }
public When_First_Option_Is_True() { subject = new object(); option = new AndSpecification( new TrueSpecification(), new Specification( s => { funcSubject = s; funcCalled = true; return false; } ) ); option.IsSatisfiedBy(subject); }
public When_Invoked() { subject = new object(); option = new AndSpecification( new Specification( s => { option1Subject = s; option1Called = true; return false; } ), new NoSpecification() ); option.IsSatisfiedBy(subject); }
public void And_Should_Return_True_If_Both_Arguments_Are_True() { var mocks = new MockRepository(); var s1 = mocks.StrictMock<ISpecification<int>>(); var s2 = mocks.StrictMock<ISpecification<int>>(); Expect.Call(s1.IsSatisfiedBy(5)).Return(true); Expect.Call(s2.IsSatisfiedBy(5)).Return(true); mocks.ReplayAll(); var andSpecification = new AndSpecification<int>(s1, s2); Assert.AreEqual(andSpecification.IsSatisfiedBy(5), true); mocks.VerifyAll(); }
public void testAndIsSatisifedBy() { AlwaysTrueSpec trueSpec = new AlwaysTrueSpec(); AlwaysFalseSpec falseSpec = new AlwaysFalseSpec(); AndSpecification<object> andSpecification = new AndSpecification<object>(trueSpec, trueSpec); Assert.True(andSpecification.isSatisfiedBy(new object())); andSpecification = new AndSpecification<object>(falseSpec, trueSpec); Assert.False(andSpecification.isSatisfiedBy(new object())); andSpecification = new AndSpecification<object>(trueSpec, falseSpec); Assert.False(andSpecification.isSatisfiedBy(new object())); andSpecification = new AndSpecification<object>(falseSpec, falseSpec); Assert.False(andSpecification.isSatisfiedBy(new object())); }
public void CriaAndSpecificationTest() { Expression<Func<ClienteStub, bool>> leftLambda = s => string.IsNullOrWhiteSpace(s.Nome) == false; Expression<Func<ClienteStub, bool>> rightLambda = s => s.Nome.ToUpper() != "MARCUS"; var leftSpecification = new DirectSpecification<ClienteStub>(leftLambda); var rightSpecification = new DirectSpecification<ClienteStub>(rightLambda); CompositeSpecification<ClienteStub> andSpec = new AndSpecification<ClienteStub>(leftSpecification, rightSpecification); List<ClienteStub> listaCliente = new List<ClienteStub>(); listaCliente.Add(new ClienteStub() { Nome = "luiz" }); var result = listaCliente.AsQueryable().Where(andSpec.SatisfiedBy()).ToList(); Assert.IsTrue(result.Count == 1); }
public void ItShouldReturnTheCorrectValueForAllPossibleLHSAndRHSCombinations(bool lhsResult, bool rhsResult, bool expected) { // Arrange var item = new TestType(); var lhs = A.Fake<ISpecification<TestType>>(); A.CallTo(() => lhs.IsSatisfiedBy(item)).Returns(lhsResult); var rhs = A.Fake<ISpecification<TestType>>(); A.CallTo(() => rhs.IsSatisfiedBy(item)).Returns(rhsResult); var sut = new AndSpecification<TestType>(lhs, rhs); // Act var result = sut.IsSatisfiedBy(item); // Assert result.Should().Be(expected); }
public void Filter_GetLargeBlackProducts_ReturnListWithSingleElement() { IEnumerable <Product> products = new List <Product>() { new Product("Polo Shirt", ProductColor.Black, ProductSize.L), new Product("T-Shirt", ProductColor.Blue, ProductSize.XS), new Product("T-Shirt", ProductColor.Red, ProductSize.S), new Product("Jeans", ProductColor.Blue, ProductSize.XL), new Product("Jeans", ProductColor.Black, ProductSize.XL), }; var betterFilter = new BetterFilter(); var andSpecification = new AndSpecification <Product>( new ColorSpecification(ProductColor.Black), new SizeSpecification(ProductSize.L)); var filteredProducts = betterFilter.Filter(products, andSpecification).ToList(); Assert.That(filteredProducts.Count, Is.EqualTo(1)); return; }
public void AndSpecification_Creation_Test() { //Arrange DirectSpecification <TEntity> leftAdHocSpecification; DirectSpecification <TEntity> rightAdHocSpecification; Expression <Func <TEntity, bool> > leftSpec = s => s.Id == 0; Expression <Func <TEntity, bool> > rightSpec = s => s.SampleProperty.Length > 2; leftAdHocSpecification = new DirectSpecification <TEntity>(leftSpec); rightAdHocSpecification = new DirectSpecification <TEntity>(rightSpec); //Act AndSpecification <TEntity> composite = new AndSpecification <TEntity>(leftAdHocSpecification, rightAdHocSpecification); //Assert Assert.IsNotNull(composite.SatisfiedBy()); Assert.ReferenceEquals(leftAdHocSpecification, composite.LeftSideSpecification); Assert.ReferenceEquals(rightAdHocSpecification, composite.RightSideSpecification); }
public void ResolveValueRefsError() { SpecificationValue refValue = SpecificationValue.Ref("qwe"); AndSpecification and = new AndSpecification( new EqualSpecification("qwe", SpecificationValue.Single(1)), new LessOrEqualSpecification("qwe", refValue)); Dictionary <string, object> values = new Dictionary <string, object> { { "qwe", TimeSpan.FromDays(1) } }; AndSpecification resolved = and.ResolveValueRefs( values, new ReferenceResolutionSettings { ThrowValueErrors = false }); var kv = Assert.IsType <LessOrEqualSpecification>(resolved.Specifications.Last()); Assert.True(kv.Value.IsReference); Assert.Same(refValue, kv.Value); }
//[ExpectedException(typeof(ArgumentNullException))] public void CreateAndSpecificationNullRightSpecThrowArgumentNullExceptionTest() { //Arrange DirectSpecification <SampleEntity> leftAdHocSpecification; DirectSpecification <SampleEntity> rightAdHocSpecification; Expression <Func <SampleEntity, bool> > rightSpec = s => s.Id == Guid.NewGuid(); Expression <Func <SampleEntity, bool> > leftSpec = s => s.SampleProperty.Length > 2; leftAdHocSpecification = new DirectSpecification <SampleEntity>(leftSpec); rightAdHocSpecification = new DirectSpecification <SampleEntity>(rightSpec); //Act AndSpecification <SampleEntity> composite = new AndSpecification <SampleEntity>(leftAdHocSpecification, null); Assert.IsTrue(composite.IsSatisfiedBy(new SampleEntity() { SampleProperty = "asdasd" })); }
public void And_Should_Return_False_If_Different_Or_Both_Are_False() { var mocks = new MockRepository(); var s1 = mocks.StrictMock <ISpecification <int> >(); var s2 = mocks.StrictMock <ISpecification <int> >(); Expect.Call(s1.IsSatisfiedBy(5)).Return(true); Expect.Call(s2.IsSatisfiedBy(5)).Return(false); Expect.Call(s1.IsSatisfiedBy(5)).Return(false); mocks.ReplayAll(); var andSpecification = new AndSpecification <int>(s1, s2); Assert.AreEqual(andSpecification.IsSatisfiedBy(5), false); Assert.AreEqual(andSpecification.IsSatisfiedBy(5), false); mocks.VerifyAll(); }
public DTO.ClientDTOList GetAll(string keywords = "", Guid?departmentId = null) { var clients = new ClientDTOList(); ISpecification <Client> spec = Specification <Client> .Eval(item => true); spec = new AndSpecification <Client>(spec, Specification <Client> .Eval(item => keywords == "" || item.Name.Contains(keywords))); spec = new AndSpecification <Client>(spec, Specification <Client> .Eval(item => !departmentId.HasValue || item.DepartmentId == departmentId.Value)); this._IClientRepository.GetAll(spec).ToList().ForEach(item => clients.Add(AutoMapper.Mapper.Map <Client, ClientDTO>(item)) ); this.AppendUserInfo(clients, this._IUserRepository.Data); return(clients); }
public F_UserDTOList GetUsers(bool?isActive = true, string keywords = "", F_UserTypeEnum?userType = null, string sort = "createddate_desc") { var userDTOList = new F_UserDTOList(); ISpecification <F_User> spec = Specification <F_User> .Eval(user => true); spec = new AndSpecification <F_User>(spec, Specification <F_User> .Eval(user => isActive == null || user.IsActive == isActive.Value)); spec = new AndSpecification <F_User>(spec, Specification <F_User> .Eval(user => (keywords == "") || user.UserName.Contains(keywords))); spec = new AndSpecification <F_User>(spec, Specification <F_User> .Eval(user => (userType == null) || user.UserType == userType)); this._IF_UserRepository.GetAll(spec, sort).ToList().ForEach(item => userDTOList.Add(Mapper.Map <F_User, F_UserDTO>(item))); this.F_AppendUserInfo(userDTOList, this._IF_UserRepository.Data); return(userDTOList); }
public static void Main(string[] args) { var mobiles = new List<Mobile>() { new Mobile(MobileBrand.Apple, MobileType.Smart), new Mobile(MobileBrand.Samsung, MobileType.Smart), new Mobile(MobileBrand.Samsung, MobileType.Basic) }; var smartSpecification = new ExpressionSpecification<Mobile>(mobile => mobile.Type == MobileType.Smart); var appleSpecification = new ExpressionSpecification<Mobile>(mobile => mobile.Brand == MobileBrand.Apple); // find all smart mobiles; var smartMobiles = mobiles.FindAll(mobile => smartSpecification.IsSatisfiedBy(mobile)); // find all apple smart mobiles; var andSpecification = new AndSpecification<Mobile>(smartSpecification, appleSpecification); var appleSmartMobiles = mobiles.FindAll(mobile => andSpecification.IsSatisfiedBy(mobile)); Console.WriteLine("Hello World!"); Console.ReadKey(); }
public void AndSpecification_Creation_Test() { //Arrange DirectSpecification<TEntity> leftAdHocSpecification; DirectSpecification<TEntity> rightAdHocSpecification; Expression<Func<TEntity, bool>> leftSpec = s => s.Id == 0; Expression<Func<TEntity, bool>> rightSpec = s => s.SampleProperty.Length > 2; leftAdHocSpecification = new DirectSpecification<TEntity>(leftSpec); rightAdHocSpecification = new DirectSpecification<TEntity>(rightSpec); //Act AndSpecification<TEntity> composite = new AndSpecification<TEntity>(leftAdHocSpecification, rightAdHocSpecification); //Assert Assert.IsNotNull(composite.SatisfiedBy()); Assert.ReferenceEquals(leftAdHocSpecification, composite.LeftSideSpecification); Assert.ReferenceEquals(rightAdHocSpecification, composite.RightSideSpecification); }
/// <summary> /// 根据银行编码获取银行用户 /// </summary> /// <param name="bankCode">银行编码</param> /// <returns></returns> public List <G_UserDetailDTO> GetUserByBank(string bankCode) { ISpecification <G_UserDetail> spec = Specification <G_UserDetail> .Eval(item => true); spec = new AndSpecification <G_UserDetail>(spec, Specification <G_UserDetail> .Eval(item => bankCode == null || bankCode == "" || item.BankCode.Equals(bankCode) )); spec = new AndSpecification <G_UserDetail>(spec, Specification <G_UserDetail> .Eval(item => item.G_User.UserType == G_UserTypeEnum.BC || item.G_User.UserType == G_UserTypeEnum.BM )); var list = new List <G_UserDetailDTO>(); this._IG_UserDetailRepository.GetAll(spec).ToList().ForEach(item => list.Add(Mapper.Map <G_UserDetail, G_UserDetailDTO>(item)) ); return(list); }
public List <F_ActivityDTO> GetAll(Guid?referenceId, bool?isRead, bool?isGlobal) { ISpecification <F_Activity> spec = Specification <F_Activity> .Eval(item => true); spec = new AndSpecification <F_Activity>(spec, Specification <F_Activity> .Eval(item => referenceId == null || item.ReferenceId.Equals(referenceId.Value))); spec = new AndSpecification <F_Activity>(spec, Specification <F_Activity> .Eval(item => isRead == null || item.IsRead.Equals(isRead.Value))); spec = new AndSpecification <F_Activity>(spec, Specification <F_Activity> .Eval(item => isGlobal == null || item.IsGlobal.Equals(isGlobal.Value))); var list = new List <F_ActivityDTO>(); this._IF_ActivityRepository.GetAll(spec).ToList().ForEach(item => list.Add(Mapper.Map <F_Activity, F_ActivityDTO>(item)) ); return(list); }
public List <F_BankOptionDTO> GetAll(bool?isAdmin = null, string sort = "order_desc") { ISpecification <F_BankOption> spec = Specification <F_BankOption> .Eval(item => true); spec = new AndSpecification <F_BankOption>(spec, Specification <F_BankOption> .Eval(item => item.F_Bank.IsActive)); if (isAdmin != null) { spec = new AndSpecification <F_BankOption>(spec, Specification <F_BankOption> .Eval(item => isAdmin == null || isAdmin.HasValue || item.F_Bank.IsAdmin.Equals(isAdmin.Value) )); } var list = new List <F_BankOptionDTO>(); this._IF_BankOptionRepository.GetAll(spec, sort).ToList().ForEach(item => list.Add(Mapper.Map <F_BankOption, F_BankOptionDTO>(item)) ); return(list); }
public void IsSatisfiedBy_04() { // arrange: object candidate = new object(); ISpecification <object> left = MockRepository.GenerateMock <ISpecification <object> >(); left.Expect(s => s.IsSatisfiedBy(candidate)).Return(false); ISpecification <object> right = MockRepository.GenerateMock <ISpecification <object> >(); right.Expect(s => s.IsSatisfiedBy(candidate)).Return(false); // act: ISpecification <object> target = new AndSpecification <object>(left, right); bool satisfied = target.IsSatisfiedBy(candidate); // assert: Assert.IsFalse(satisfied); left.VerifyAllExpectations(); right.AssertWasNotCalled(s => s.IsSatisfiedBy(candidate)); }
public void ResolveSpecRefGeneric() { AndSpecification and = new AndSpecification( new EqualSpecification("qwe", SpecificationValue.Single(1)), new ReferenceSpecification("qwe")); LessOrEqualSpecification specification = new LessOrEqualSpecification("qwe", SpecificationValue.Single(1)); Dictionary <string, object> values = new Dictionary <string, object> { { "qwe", specification } }; AndSpecification resolved = and.ResolveSpecificationRefs(values); var kv = Assert.IsType <LessOrEqualSpecification>(resolved.Specifications.Last()); Assert.Same(specification, kv); }
public void CriaAndSpecificationTest() { Expression <Func <ClienteStub, bool> > leftLambda = s => string.IsNullOrWhiteSpace(s.Nome) == false; Expression <Func <ClienteStub, bool> > rightLambda = s => s.Nome.ToUpper() != "MARCUS"; var leftSpecification = new DirectSpecification <ClienteStub>(leftLambda); var rightSpecification = new DirectSpecification <ClienteStub>(rightLambda); CompositeSpecification <ClienteStub> andSpec = new AndSpecification <ClienteStub>(leftSpecification, rightSpecification); List <ClienteStub> listaCliente = new List <ClienteStub>(); listaCliente.Add(new ClienteStub() { Nome = "luiz" }); var result = listaCliente.AsQueryable().Where(andSpec.SatisfiedBy()).ToList(); Assert.IsTrue(result.Count == 1); }
public List <G_NewsDTO> GetAll(string code = "", string title = "") { ISpecification <G_News> spec = Specification <G_News> .Eval(item => true); spec = new AndSpecification <G_News>(spec, Specification <G_News> .Eval(item => code == "" || item.Code.Equals(code))); spec = new AndSpecification <G_News>(spec, Specification <G_News> .Eval(item => title == "" || item.Title.Contains(title))); spec = new AndSpecification <G_News>(spec, Specification <G_News> .Eval(item => item.IsActive)); var list = new List <G_NewsDTO>(); this._IG_NewsRepository.GetAll(spec).ToList().ForEach(item => list.Add(Mapper.Map <G_News, G_NewsDTO>(item)) ); return(list); }
public void GetTotalAmountForCategory_ReturnsCorrectTotal() { // Arrange var manualEntryManager = GenerateManualEntryManager(); manualEntryManager.Add(DateTime.ParseExact("01/02/2017", "dd/MM/yyyy", CultureInfo.InvariantCulture), "petrol", 2000, "testDescription"); var startDate = DateTime.ParseExact("01/01/2017", "dd/MM/yyyy", CultureInfo.InvariantCulture); var endDate = DateTime.ParseExact("01/01/2018", "dd/MM/yyyy", CultureInfo.InvariantCulture); var specifications = new AndSpecification <Entry>(new EntryDateSpecification(startDate, endDate), new EntryCategorySpecification("petrol")); // Act var total = manualEntryManager.GetTotal(specifications); // Assert Assert.AreEqual(2500, actual: total); }
public void Filter_Based_On_AlbumSongSpecification_And_FilterSongSpecification() { var specification = new AndSpecification <Song>(new AlbumSongSpecification(2), new FilterSongSpecification { GenreIdsToInclude = new List <int> { 1, 2, 3 }, AlbumIdsToinclude = new List <int> { 1, 2, 3, 5 }, ArtistsToInclude = new List <string> { "Eagles", "Michael Jackson", "Pink Floyd" }, TitleFilter = "Th", MinRating = 4 }); var songs = new SongRepository().Read(specification); Assert.Single(songs); Assert.Equal("Thriller", songs.First().Title); }
//------------------------------------------------------------------------- private void RefreshProfilingInformation() { double totalExpenditure = _infoCollection.ManualEntriesInfo.GetTotal(new EntryMonthSpecification(endDatePicker.Value.Date)); double totalBudget = _infoCollection.CategoriesInfo.GetTotalBudgetAmount(); totalsOutput.Text = Convert.ToString(totalExpenditure, CultureInfo.InvariantCulture); totalsOutput.BackColor = totalExpenditure > totalBudget ? Color.Red : Color.Green; budgetTotalOutput.Text = Convert.ToString(totalBudget, CultureInfo.InvariantCulture); totalsTable.Rows.Clear(); foreach (var category in _infoCollection.CategoriesInfo.GetCategoryNames()) { var specifications = new AndSpecification <Entry>(new EntryMonthSpecification(endDatePicker.Value.Date), new EntryCategorySpecification(category)); var index = totalsTable.Rows.Add(); totalsTable.Rows[index].Cells["totalsCategory"].Value = category; totalsTable.Rows[index].Cells["totalsAmount"].Value = _infoCollection.ManualEntriesInfo.GetTotal(specifications); } }
public void ResolveValueRefPartial() { AndSpecification and = new AndSpecification( new EqualSpecification("qwe", SpecificationValue.Single(1)), new LessOrEqualSpecification("qwe", SpecificationValue.Ref("qwe"))); Dictionary <string, object> values = new Dictionary <string, object> { { "qwe", SpecificationValue.Ref("qwe2") }, }; ReferenceResolutionSettings settings = new ReferenceResolutionSettings(); settings.AllowedUnresolvedValueReferenceKeys.Add("qwe2"); AndSpecification resolved = and.ResolveValueRefs( values, settings); var kv = Assert.IsType <LessOrEqualSpecification>(resolved.Specifications.Last()); Assert.True(kv.Value.IsReference); Assert.Equal("qwe2", kv.Value.Values.Single()); }
public DTO.ContractDTOList GetAll(string keywords = "", Guid?clientId = null, Guid?userId = null, Guid?departmentId = null) { var Contracts = new ContractDTOList(); ISpecification <Contract> spec = Specification <Contract> .Eval(item => true); spec = new AndSpecification <Contract>(spec, Specification <Contract> .Eval(item => !userId.HasValue || item.OwnerId == userId.Value)); spec = new AndSpecification <Contract>(spec, Specification <Contract> .Eval(item => !departmentId.HasValue || item.DepartmentId == userId.Value)); spec = new AndSpecification <Contract>(spec, Specification <Contract> .Eval(item => !clientId.HasValue || item.ClientId == clientId.Value)); spec = new AndSpecification <Contract>(spec, Specification <Contract> .Eval(item => keywords == "" || item.Title.Contains(keywords))); this._IContractRepository.GetAll(spec).ToList().ForEach(item => Contracts.Add(AutoMapper.Mapper.Map <Contract, ContractDTO>(item)) ); foreach (var item in Contracts) { item.Department = this._IDepartmentService.GetByKey(item.DepartmentId); item.Owner = this._IUserService.GetByKey(item.OwnerId); if (item.PrincipalId.HasValue) { item.Principal = this._IUserService.GetByKey(item.PrincipalId.Value); } } return(Contracts); }
public G_ActivityDTOListWithPagination GetAll(int pageIndex, int pageSize, Guid?referenceId, bool?isRead, bool?isGlobal, string sort = "createddate_desc") { ISpecification <G_Activity> spec = Specification <G_Activity> .Eval(item => true); spec = new AndSpecification <G_Activity>(spec, Specification <G_Activity> .Eval(item => referenceId == null || item.ReferenceId.Equals(referenceId.Value))); spec = new AndSpecification <G_Activity>(spec, Specification <G_Activity> .Eval(item => isRead == null || item.IsRead.Equals(isRead.Value))); spec = new AndSpecification <G_Activity>(spec, Specification <G_Activity> .Eval(item => isGlobal == null || item.IsGlobal.Equals(isGlobal.Value))); var list = new List <G_ActivityDTO>(); var result = this._IG_ActivityRepository.GetAll(pageIndex, pageSize, spec, sort); int totalPages = 0; int totalRecords = 0; if (result != null) { result.Data.ForEach(item => list.Add(Mapper.Map <G_Activity, G_ActivityDTO>(item)) ); totalPages = result.TotalPages; totalRecords = result.TotalRecords; } return(new G_ActivityDTOListWithPagination { TotalRecords = totalRecords, PageSize = pageSize, PageIndex = pageIndex, TotalPages = totalPages, Data = list }); }
public void IsSatisfiedByExample() { // Our model to test on var p = new Person { Name = "Hilton", Surname = "Goosen" }; // Build up two specifications to AND together var nameSpecification = new PredicateSpecification <Person>(x => x.Name == "Hilton"); var surnameSpecification = new PredicateSpecification <Person>(x => x.Surname == "Goosen"); // Create a new And Specification var specification = new AndSpecification <Person>(nameSpecification, surnameSpecification); Assert.IsTrue(specification.IsSatisfiedBy(p)); // Set the surname to something else surnameSpecification = new PredicateSpecification <Person>(x => x.Surname == "Hanekom"); specification = new AndSpecification <Person>(nameSpecification, surnameSpecification); // Surname specification is not satisfied by this person Assert.IsFalse(specification.IsSatisfiedBy(p)); }
public void AndSpecificationTestAndSpecification() { // arrange var specFirstName = new AdHocSpecification <Sample>(x => x.FirstName.StartsWith("J")); var specLastName = new AdHocSpecification <Sample>(x => x.LastName.StartsWith("R")); var spec = new AndSpecification <Sample>(specFirstName, specLastName); // act var resultFirstName = TestData.List.Where(specFirstName.IsSatisfied()).OrderBy(c => c.FirstName); var resultLastName = TestData.List.Where(specLastName.IsSatisfied()).OrderBy(c => c.FirstName); var result = TestData.List.Where(spec.IsSatisfied()).OrderBy(c => c.FirstName); // assert Assert.That(resultFirstName.Count(), Is.EqualTo(2)); Assert.That(resultFirstName.First().FirstName, Is.EqualTo("Jose")); Assert.That(resultFirstName.Last().FirstName, Is.EqualTo("Julian")); Assert.That(resultLastName.Count(), Is.EqualTo(2)); Assert.That(resultLastName.First().LastName, Is.EqualTo("Rodriguez")); Assert.That(resultLastName.Last().LastName, Is.EqualTo("Rivera")); Assert.That(result.Count(), Is.EqualTo(1)); Assert.That(result.First().FirstName, Is.EqualTo("Jose")); Assert.That(result.First().LastName, Is.EqualTo("Rodriguez")); }
public IEnumerable <Product> Filter(IEnumerable <Product> unfilteredProducts, Group group, Subgroup subgroup, string name, string sequence) { var specsList = new List <ISpecification <Product> > { new ProductNameSpecification(name), new ProductSequenceSpecification(sequence) }; if (group != null) { specsList.Add(new ProductGroupSpecification(group)); } if (subgroup != null) { specsList.Add(new ProductSubgroupSpecification(subgroup)); } var andSpecification = new AndSpecification <Product>(specsList); var specificationChecker = new SpecificationChecker <Product>(); return(specificationChecker.Filter(unfilteredProducts, andSpecification)); }
private static Specification <T> CreateExpression <T>(FilterDefinition filterdata, FilterMetadata metadata) { Specification <T> spec = null; if (filterdata is SimpleFilterDefinition) { var data = filterdata as SimpleFilterDefinition; spec = new FieldSpecification <T>(data, metadata.GetTypeCodeOfField(data.FieldName)); } else if (filterdata is ComplexFilterDefinition) { var data = filterdata as ComplexFilterDefinition; if (data.FiltersConnector == ComplexFilterDefinition.Connector.And) { spec = new AndSpecification <T>(CreateExpression <T>(data.LeftFilter, metadata), CreateExpression <T>(data.RightFilter, metadata)); } else { spec = new OrSpecification <T>(CreateExpression <T>(data.LeftFilter, metadata), CreateExpression <T>(data.RightFilter, metadata)); } } return(spec); }
public List <G_BankDTO> GetBanks(string bankCode = "", bool?isAdmin = null, string sort = "order") { ISpecification <G_Bank> spec = Specification <G_Bank> .Eval(item => true); spec = new AndSpecification <G_Bank>(spec, Specification <G_Bank> .Eval(item => bankCode == null || bankCode == "" || item.Code.Equals(bankCode) )); spec = new AndSpecification <G_Bank>(spec, Specification <G_Bank> .Eval(item => isAdmin == null || item.IsAdmin.Equals(isAdmin.Value) )); spec = new AndSpecification <G_Bank>(spec, Specification <G_Bank> .Eval(item => item.IsActive)); var list = new List <G_BankDTO>(); this._IG_BankRepository.GetAll(spec, sort).ToList().ForEach(item => list.Add(Mapper.Map <G_Bank, G_BankDTO>(item)) ); return(list); }
public F_OrderDTO GetComplexOrder(Guid id) { ISpecification <F_Order> spec = Specification <F_Order> .Eval(item => true); spec = new AndSpecification <F_Order>(spec, Specification <F_Order> .Eval(item => item.Id.Equals(id))); var order = this._IF_OrderRepository.GetAll(1, int.MaxValue, spec).ToList().FirstOrDefault(); if (order == null) { return(null); } var result = Mapper.Map <ComplexOrder, F_OrderDTO>(order); var orderRecordList = new List <F_OrderRecordDTO>(); this._IF_OrderRecordRepository.GetOrderRecordByOrderId(order.Id).OrderByDescending(item => item.CreatedDate).ToList().ForEach(item => orderRecordList.Add(Mapper.Map <ComplexOrderRecord, F_OrderRecordDTO>(item)) ); result.OrderRecordList = orderRecordList; result.Files = this._IF_FileService.GetFilesByReferenceId(result.Id); return(result); }
public static IEnumerable <TestCaseData> SpecificationExtensionsTestIsSameCaseSource() { // single spec types var specFirstNull = new FirstNameSpec(null); var specFirstNull2 = new FirstNameSpec(null); var specFirstBob = new FirstNameSpec("bob"); var specFirstBob2 = new FirstNameSpec("bob"); var specFirstBobbette = new FirstNameSpec("bobbette"); var specFirstAndLastBob = new FirstAndLastNameSpec("bob", "le"); var specFirstAndLastBob2 = new FirstAndLastNameSpec("bob", "le"); var specFirstAndLastBobbbette = new FirstAndLastNameSpec("bobbette", "le"); var specLastBob = new LastNameSpec("bob"); yield return(new TestCaseData("Check on null type", specFirstBob, null, false)); yield return(new TestCaseData("Check non reference type", specFirstBob, "dinge", false)); yield return(new TestCaseData("SameReference", specFirstBob, specFirstBob, true)); yield return(new TestCaseData("Different type", specFirstBob, specLastBob, false)); yield return(new TestCaseData("Same single content (null)", specFirstNull, specFirstNull2, true)); yield return(new TestCaseData("Same single content", specFirstBob, specFirstBob2, true)); yield return(new TestCaseData("Same multiple content", specFirstAndLastBob, specFirstAndLastBob2, true)); yield return(new TestCaseData("Different single content", specFirstBob, specFirstBobbette, false)); // operator specs var orSpecBob = new OrSpecification <Sample>(specFirstBob, specFirstBob2); var orSpecBob2 = new OrSpecification <Sample>(specFirstBob, specFirstBob2); var orSpecBob3 = new OrSpecification <Sample>(specFirstBob, specLastBob); var andSpecBob = new AndSpecification <Sample>(specFirstBob, specFirstBob); var andSpecBob2 = new AndSpecification <Sample>(specFirstBob, specFirstBob2); var andSpecBob3 = new AndSpecification <Sample>(specFirstBob, specLastBob); yield return(new TestCaseData("OR Same containing specs", orSpecBob, orSpecBob2, true)); yield return(new TestCaseData("Or Different containing specs", orSpecBob, orSpecBob3, false)); yield return(new TestCaseData("And Same containing specs", andSpecBob, andSpecBob2, true)); yield return(new TestCaseData("And Different containing specs", andSpecBob, andSpecBob3, false)); // array specs: value compares var array = new int[] { 1, 2, 3 }; var arraySpecNull = new ArraySpec <int>(null); var arraySpec = new ArraySpec <int>(array); var arraySpec2 = new ArraySpec <int>(array); var arraySpec3 = new ArraySpec <int>(new int[] { 1, 2, 3 }); var arraySpec4 = new ArraySpec <int>(new int[] { 1, 2, 3, 4 }); yield return(new TestCaseData("Array - same array", arraySpec, arraySpec2, true)); yield return(new TestCaseData("Array - different array - same content", arraySpec, arraySpec3, true)); yield return(new TestCaseData("Array - different array - different content", arraySpec, arraySpec4, false)); yield return(new TestCaseData("Array - different array - different content (null)", arraySpec, arraySpecNull, false)); yield return(new TestCaseData("Array(obj) - same array", arraySpec, arraySpec2, true)); // array specs: object compares var sample = new Sample("le", "bob"); var arraySpecSample = new ArraySpec <Sample>(new Sample[] { sample, sample }); var arraySpecSample2 = new ArraySpec <Sample>(new Sample[] { sample, sample }); var arraySpecSampleNull = new ArraySpec <Sample>(new Sample[] { sample, null, sample }); var arraySpecSampleNull2 = new ArraySpec <Sample>(new Sample[] { sample, null, sample }); var arraySpecObject = new ArraySpec <object>(new object[] { "a", 1 }); var arraySpecObject2 = new ArraySpec <object>(new object[] { "a", "b" }); var arraySpecObject3 = new ArraySpec <object>(new object[] { "a", "c" }); var arraySpecObjectnull = new ArraySpec <object>(null); yield return(new TestCaseData("Array(obj) - different array - same content", arraySpecSample, arraySpecSample2, true)); yield return(new TestCaseData("Array(obj) - different array - different content (null)", arraySpecSampleNull, arraySpecSampleNull2, false)); yield return(new TestCaseData("Array(obj) - different array - different content (type)", arraySpecObject, arraySpecObject2, false)); yield return(new TestCaseData("Array(obj) - different array - different content (value)", arraySpecObject3, arraySpecObject2, false)); yield return(new TestCaseData("Array(obj) - different array - one is null", arraySpecObject3, arraySpecObjectnull, false)); }
public OutageReport Generate(ReportOptions options) { bool isScope = false; List <Specification <ConsumerHistorical> > specs = new List <Specification <ConsumerHistorical> >(); if (options.StartDate.HasValue) { specs.Add(new HistoricalConsumerStartDateQuery(options.StartDate.Value)); } if (options.EndDate.HasValue) { specs.Add(new HistoricalConsumerEndDateQuery(options.EndDate.Value)); } if (options.ElementId != null) { specs.Add(new HistoricalConsumerElementIdQuery((long)options.ElementId)); isScope = true; } specs.Add(new HistoricalConsumerOperationQuery(DatabaseOperation.DELETE)); IEnumerable <ConsumerHistorical> outages; if (specs.Count > 1) { AndSpecification <ConsumerHistorical> andQuery = new AndSpecification <ConsumerHistorical>(specs); outages = _outageRepository.Find(andQuery.IsSatisfiedBy).ToList(); } else if (specs.Count == 1) { outages = _outageRepository.Find(specs[0].IsSatisfiedBy).ToList(); } else { outages = _outageRepository.GetAll().ToList(); } var type = DateHelpers.GetType(options.StartDate, options.EndDate); var outageReportGrouping = outages.GroupBy(o => type == "Monthly" ? o.OperationTime.Month : o.OperationTime.Year).Select(o => o).ToList(); var numOfConsumers = 1; if (!isScope) { numOfConsumers = _consumerRepository.GetAll().Count(); } var reportData = new Dictionary <string, float>(); foreach (var outage in outageReportGrouping) { var outageCount = outage.Count(); reportData.Add(type == "Monthly" ? DateHelpers.Months[outage.Key] : outage.Key.ToString(), (float)outageCount / (float)numOfConsumers);; } return(new OutageReport { Type = type, Data = reportData }); }
public ISpecificationBuilder <T> And(ISpecification <T> specification) { _criteria = new AndSpecification <T>(_criteria, specification); return(this); }
public void AndToString() { AndSpecification and = new AndSpecification(ConstantSpecification.True, ConstantSpecification.True); Assert.Equal("(true and true)", and.ToString()); }