예제 #1
0
        public void MapWhile_From_DataReader()
        {
            const string customerId = @"ANATR";

            var capitalizeReaderPersister = new CapitalizeReaderPersister <CustomerOrderHistory>();

            using (var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 종료 조건이 항상 False이므로 모든 데이타를 매핑합니다.
                var histories = reader.MapWhile <CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => true).ToList();

                Assert.Greater(histories.Count, 0);
                histories.All(h => h.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(h => h.Total.HasValue && h.Total.Value > 0).Should().Be.True();
            }

            using (var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 종료조건이 항상 참이므로, 아무런 데이타도 매핑하지 않습니다.
                var histories = reader.MapWhile <CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => false).ToList();

                Assert.AreEqual(0, histories.Count);
            }

            using (var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // Total 값이 0이면, 매핑을 중단합니다.
                var histories =
                    reader.MapWhile <CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => dr.AsInt32("Total") > 0).ToList();

                Assert.Greater(histories.Count, 0);
                histories.All(h => h.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(h => h.Total.HasValue && h.Total.Value > 0).Should().Be.True();
            }
        }
예제 #2
0
        public void Map_FromDataReader_With_Filter()
        {
            const string customerId = @"ANATR";

            var capitalizeReaderPersister = new CapitalizeReaderPersister <CustomerOrderHistory>();

            using (var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 필터링된 데이타 (모두 통과)
                var histories = reader.MapIf <CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => true).ToList();

                Assert.Greater(histories.Count, 0);
                histories.All(h => h.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(h => h.Total.HasValue && h.Total.Value > 0).Should().Be.True();
            }

            using (var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 필터링된 데이타 (모두 거부)
                var histories = reader.MapIf <CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => false).ToList();

                Assert.AreEqual(0, histories.Count);
            }

            using (var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 필터링된 데이타 (Total 이 0보다 큰 레코드만)
                var histories =
                    reader.MapIf <CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => dr.AsInt32("Total") > 0).ToList();

                Assert.Greater(histories.Count, 0);
                histories.All(h => h.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(h => h.Total.HasValue && h.Total.Value > 0).Should().Be.True();
            }
        }
예제 #3
0
        public void MapFromDataReaderByPersister(int firstResult, int maxResults)
        {
            IReaderPersister <CustomerOrderHistory> readerPersister = new CapitalizeReaderPersister <CustomerOrderHistory>();

            using (var reader = NorthwindAdoRepository.ExecuteReaderByProcedure("CustOrderHist2", CustomerTestParameter)) {
                var orderHistories = reader.Map(readerPersister, firstResult, maxResults);
                Assert.IsTrue(orderHistories.Count > 0);
            }
        }
예제 #4
0
        public void ExecuteReaderWithPagingByPersister(int pageIndex, int pageSize)
        {
            var persister = new CapitalizeReaderPersister <State>();

            var jobs =
                Task.Factory
                .StartNew(() => {
                using (var cmd = OdpRepository.GetCommand(SelectDemoStates))
                    return(OdpRepository.ExecuteInstance <State>(persister, cmd, pageIndex, pageSize));
            })
                .Result;

            jobs.All(job => job.St.IsNotWhiteSpace()).Should().Be.True();
            jobs.All(job => job.StateName.IsNotWhiteSpace()).Should().Be.True();
        }
예제 #5
0
        public void MapFromDataReaderByPersister(int firstResult, int maxResults)
        {
            IReaderPersister <CustomerOrderHistory> readerPersister = new CapitalizeReaderPersister <CustomerOrderHistory>();

            using (var reader = NorthwindAdoRepository.ExecuteReaderByProcedure("CustOrderHist2", CustomerTestParameter)) {
                var histories = reader.Map(readerPersister, firstResult, maxResults).ToList();

                if (maxResults > 0)
                {
                    Assert.GreaterOrEqual(maxResults, histories.Count);
                }
                else
                {
                    Assert.Greater(histories.Count, 0);
                }

                histories.All(history => history.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(history => history.Total.GetValueOrDefault() > 0).Should().Be.True();
            }
        }
        public void ExecuteReaderWithPagingByPersister(int pageIndex, int pageSize) {
            var persister = new CapitalizeReaderPersister<State>();

            var jobs =
                Task.Factory
                    .StartNew(() => {
                                  using(var cmd = OracleRepository.GetCommand(SelectDemoStates))
                                      return OracleRepository.ExecuteInstance<State>(persister, cmd, pageIndex, pageSize);
                              })
                    .Result;

            jobs.All(job => job.St.IsNotWhiteSpace()).Should().Be.True();
            jobs.All(job => job.StateName.IsNotWhiteSpace()).Should().Be.True();
        }
예제 #7
0
        public void MapFromDataReaderByPersister(int firstResult, int maxResults) {
            IReaderPersister<CustomerOrderHistory> readerPersister = new CapitalizeReaderPersister<CustomerOrderHistory>();

            using(var reader = NorthwindAdoRepository.ExecuteReaderByProcedure("CustOrderHist2", CustomerTestParameter)) {
                var orderHistories = reader.Map(readerPersister, firstResult, maxResults);
                Assert.IsTrue(orderHistories.Count > 0);
            }
        }
예제 #8
0
        public void MapWhile_From_DataReader() {
            const string customerId = @"ANATR";

            var capitalizeReaderPersister = new CapitalizeReaderPersister<CustomerOrderHistory>();

            using(var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 종료 조건이 항상 False이므로 모든 데이타를 매핑합니다.
                var histories = reader.MapWhile<CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => true).ToList();

                Assert.Greater(histories.Count, 0);
                histories.All(h => h.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(h => h.Total.HasValue && h.Total.Value > 0).Should().Be.True();
            }

            using(var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 종료조건이 항상 참이므로, 아무런 데이타도 매핑하지 않습니다.
                var histories = reader.MapWhile<CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => false).ToList();

                Assert.AreEqual(0, histories.Count);
            }

            using(var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // Total 값이 0이면, 매핑을 중단합니다.
                var histories =
                    reader.MapWhile<CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => dr.AsInt32("Total") > 0).ToList();

                Assert.Greater(histories.Count, 0);
                histories.All(h => h.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(h => h.Total.HasValue && h.Total.Value > 0).Should().Be.True();
            }
        }
예제 #9
0
        public void Map_FromDataReader_With_Filter() {
            const string customerId = @"ANATR";

            var capitalizeReaderPersister = new CapitalizeReaderPersister<CustomerOrderHistory>();

            using(var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 필터링된 데이타 (모두 통과)
                var histories = reader.MapIf<CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => true).ToList();

                Assert.Greater(histories.Count, 0);
                histories.All(h => h.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(h => h.Total.HasValue && h.Total.Value > 0).Should().Be.True();
            }

            using(var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 필터링된 데이타 (모두 거부)
                var histories = reader.MapIf<CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => false).ToList();

                Assert.AreEqual(0, histories.Count);
            }

            using(var reader = GetCustomerOrderHistoryDataReader(customerId)) {
                // 필터링된 데이타 (Total 이 0보다 큰 레코드만)
                var histories =
                    reader.MapIf<CustomerOrderHistory>(capitalizeReaderPersister.Persist, dr => dr.AsInt32("Total") > 0).ToList();

                Assert.Greater(histories.Count, 0);
                histories.All(h => h.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(h => h.Total.HasValue && h.Total.Value > 0).Should().Be.True();
            }
        }
예제 #10
0
        public void MapFromDataReaderByPersister(int firstResult, int maxResults) {
            IReaderPersister<CustomerOrderHistory> readerPersister = new CapitalizeReaderPersister<CustomerOrderHistory>();

            using(var reader = NorthwindAdoRepository.ExecuteReaderByProcedure("CustOrderHist2", CustomerTestParameter)) {
                var histories = reader.Map(readerPersister, firstResult, maxResults).ToList();

                if(maxResults > 0)
                    Assert.GreaterOrEqual(maxResults, histories.Count);
                else
                    Assert.Greater(histories.Count, 0);

                histories.All(history => history.ProductName.IsNotWhiteSpace()).Should().Be.True();
                histories.All(history => history.Total.GetValueOrDefault() > 0).Should().Be.True();
            }
        }