コード例 #1
0
        public void CreateAndSpecificationTest()
        {
            //Arrange
            var identifier              = Guid.NewGuid();
            var leftAdHocSpecification  = new DirectSpecification <SampleEntity>(s => s.Id == identifier);
            var rightAdHocSpecification = new DirectSpecification <SampleEntity>(s => s.SampleProperty.Length > 2);

            //Act
            var composite = new AndSpecification <SampleEntity>(leftAdHocSpecification, rightAdHocSpecification);

            //Assert
            Assert.NotNull(composite.SatisfiedBy());
            Assert.Equal(leftAdHocSpecification, composite.LeftSideSpecification);
            Assert.Equal(rightAdHocSpecification, composite.RightSideSpecification);

            var list    = new List <SampleEntity>();
            var sampleA = new SampleEntity(identifier)
            {
                SampleProperty = "1"
            };
            var sampleB = new SampleEntity(identifier)
            {
                SampleProperty = "the sample property"
            };

            list.AddRange(new[] { sampleA, sampleB });


            var result = list.AsQueryable().Where(composite.SatisfiedBy()).ToList();

            Assert.True(result.Count == 1);
        }
コード例 #2
0
        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);
        }
コード例 #3
0
        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);
        }
コード例 #4
0
        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
            var composite = new AndSpecification <SampleEntity>(leftAdHocSpecification, rightAdHocSpecification);

            //Assert
            Assert.IsNotNull(composite.SatisfiedBy());
            ReferenceEquals(leftAdHocSpecification, composite.LeftSideSpecification);
            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);
        }
コード例 #5
0
        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);
        }
コード例 #6
0
        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);
        }
コード例 #7
0
        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);
        }
コード例 #8
0
        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);
        }
コード例 #9
0
        public void CreateAndSpecificationTest()
        {
            //Arrange
            DirectSpecification<SampleEntity> leftAdHocSpecification;
            DirectSpecification<SampleEntity> rightAdHocSpecification;

            Expression<Func<SampleEntity, bool>> leftSpec = s => s.Id == IdentityGenerator.NewSequentialGuid();
            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);
        }