Пример #1
0
        public void ExecutingCriteriaThroughMultiCriteriaTransformsResults()
        {
            CreateItems();

            using (var session = OpenSession())
            {
                var transformer = new ResultTransformerStub();
                var criteria    = session.CreateCriteria(typeof(Item))
                                  .SetResultTransformer(transformer);
                var multiCriteria = session.CreateMultiCriteria()
                                    .Add(criteria);
                multiCriteria.List();

                Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
                Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
            }
        }
Пример #2
0
        public async Task ExecutingCriteriaThroughMultiQueryTransformsResultsAsync()
        {
            await(CreateItemsAsync());

            using (var session = OpenSession())
            {
                var transformer = new ResultTransformerStub();
                var criteria    = session.CreateQuery("from Item")
                                  .SetResultTransformer(transformer);
                await(session.CreateMultiQuery()
                      .Add(criteria)
                      .ListAsync());

                Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
                Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
            }
        }
Пример #3
0
        public void ExecutingCriteriaThroughMultiQueryTransformsResults_When_setting_on_multi_query_directly()
        {
            CreateItems();

            using (var session = OpenSession())
            {
                var transformer = new ResultTransformerStub();
                var query       = session.CreateQuery("from Item");
                session.CreateMultiQuery()
                .Add(query)
                .SetResultTransformer(transformer)
                .List();

                Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
                Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
            }
        }
Пример #4
0
        public void ExecutingCriteriaThroughTransformsResults()
        {
            CreateItems();

            using (var session = OpenSession())
            {
                var transformer = new ResultTransformerStub();
                var criteria    = session.CreateCriteria(typeof(Item))
                                  .SetResultTransformer(transformer);
                var multiCriteria = session.CreateQueryBatch()
                                    .Add <object[]>(criteria);
                multiCriteria.GetResult <object[]>(0);

                Assert.That(transformer.WasTransformTupleCalled, Is.True, "Transform Tuple was not called");
                Assert.That(transformer.WasTransformListCalled, Is.True, "Transform List was not called");
            }
        }
Пример #5
0
        public void ExecutingHqlThroughMultiQueryTransformsResults()
        {
            CreateItems();

            using (var session = OpenSession())
            {
                var transformer = new ResultTransformerStub();
                var criteria    = session.CreateQuery("from Item")
                                  .SetResultTransformer(transformer);
                session.CreateQueryBatch()
                .Add <object[]>(criteria)
                .GetResult <object[]>(0);

                Assert.That(transformer.WasTransformTupleCalled, Is.True, "Transform Tuple was not called");
                Assert.That(transformer.WasTransformListCalled, Is.True, "Transform List was not called");
            }
        }
Пример #6
0
        public void ExecutingQueryThroughMultiQueryTransformsResults()
        {
            CreateItems();

            using (var session = OpenSession())
            {
                var transformer = new ResultTransformerStub();
                var query       = session.CreateSQLQuery("select * from ITEM").AddEntity(typeof(Item))
                                  .SetResultTransformer(transformer);
                session.CreateMultiQuery()
                .Add(query)
                .List();

                Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
                Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
            }
        }
        public async Task ExecutingQueryThroughMultiQueryTransformsResults_When_setting_on_multi_query_directlyAsync()
        {
            await(CreateItemsAsync());

            using (var session = OpenSession())
            {
                var    transformer = new ResultTransformerStub();
                IQuery query       = session.CreateSQLQuery("select * from ITEM").AddEntity(typeof(Item));
                await(session.CreateMultiQuery()
                      .Add(query)
                      .SetResultTransformer(transformer)
                      .ListAsync());

                Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
                Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
            }
        }
Пример #8
0
        public async Task ExecutingHqlThroughMultiQueryTransformsResultsAsync()
        {
            await(CreateItemsAsync());

            using (var session = OpenSession())
            {
                var transformer = new ResultTransformerStub();
                var criteria    = session.CreateQuery("from Item")
                                  .SetResultTransformer(transformer);
                await(session.CreateQueryBatch()
                      .Add <object[]>(criteria)
                      .GetResultAsync <object[]>(0, CancellationToken.None));

                Assert.That(transformer.WasTransformTupleCalled, Is.True, "Transform Tuple was not called");
                Assert.That(transformer.WasTransformListCalled, Is.True, "Transform List was not called");
            }
        }
        public async Task ExecutingQueryThroughMultiQueryTransformsResultsAsync()
        {
            await(CreateItemsAsync());

            using (var session = OpenSession())
            {
                var transformer = new ResultTransformerStub();
                var query       = session.CreateSQLQuery("select * from ITEM")
                                  .AddEntity(typeof(Item))
                                  .SetResultTransformer(transformer);
                await(session.CreateQueryBatch()
                      .Add <object[]>(query)
                      .GetResultAsync <object[]>(0));

                Assert.That(transformer.WasTransformTupleCalled, Is.True, "Transform Tuple was not called");
                Assert.That(transformer.WasTransformListCalled, Is.True, "Transform List was not called");
            }
        }
Пример #10
0
        public void ExecutingCriteriaThroughMultiQueryTransformsResults()
        {
            CreateItems();

            using (ISession session = OpenSession())
            {
                ResultTransformerStub transformer = new ResultTransformerStub();
                IQuery criteria = session.CreateQuery("from Item")
                                  .SetResultTransformer(transformer);
                session.CreateMultiQuery()
                .Add(criteria)
                .List();

                Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
                Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
            }

            RemoveAllItems();
        }
        public void ExecutingQueryThroughMultiQueryTransformsResults_When_setting_on_multi_query_directly()
        {
            CreateItems();

            using (ISession session = OpenSession())
            {
                ResultTransformerStub transformer = new ResultTransformerStub();
                IQuery query = session.CreateSQLQuery("select * from ITEM").AddEntity(typeof(Item));
                session.CreateMultiQuery()
                .Add(query)
                .SetResultTransformer(transformer)
                .List();

                Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
                Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
            }

            RemoveAllItems();
        }
		public void ExecutingQueryThroughMultiQueryTransformsResults_When_setting_on_multi_query_directly()
		{
			CreateItems();

			using (var session = OpenSession())
			{
				var transformer = new ResultTransformerStub();
				IQuery query = session.CreateSQLQuery("select * from ITEM").AddEntity(typeof(Item));
				session.CreateMultiQuery()
					.Add(query)
					.SetResultTransformer(transformer)
					.List();

				Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
				Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
			}
		}
		public void ExecutingQueryThroughMultiQueryTransformsResults()
		{
			CreateItems();

			using (ISession session = OpenSession())
			{
				ResultTransformerStub transformer = new ResultTransformerStub();
				IQuery query = session.CreateSQLQuery("select * from ITEM").AddEntity(typeof(Item))
					.SetResultTransformer(transformer);
				session.CreateMultiQuery()
					.Add(query)
					.List();

				Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
				Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
			}

			RemoveAllItems();
		}
		public void ExecutingCriteriaThroughMultiCriteriaTransformsResults()
		{
			CreateItems();

			using (ISession session = OpenSession())
			{
				ResultTransformerStub transformer = new ResultTransformerStub();
				ICriteria criteria = session.CreateCriteria(typeof(Item))
					.SetResultTransformer(transformer);
				IMultiCriteria multiCriteria = session.CreateMultiCriteria()
					.Add(criteria);
				multiCriteria.List();

				Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
				Assert.IsTrue(transformer.WasTransformListCalled,"Transform List was not called");
			}

			RemoveAllItems();
		}
		public void ExecutingCriteriaThroughMultiQueryTransformsResults_When_setting_on_multi_query_directly()
		{
			CreateItems();

			using (ISession session = OpenSession())
			{
				ResultTransformerStub transformer = new ResultTransformerStub();
				IQuery query = session.CreateQuery("from Item");
				session.CreateMultiQuery()
					.Add(query)
					.SetResultTransformer(transformer)
					.List();

				Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
				Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
			}

			RemoveAllItems();
		}
		public void ExecutingCriteriaThroughMultiQueryTransformsResults()
		{
			CreateItems();

			using (var session = OpenSession())
			{
				var transformer = new ResultTransformerStub();
				var criteria = session.CreateQuery("from Item")
					.SetResultTransformer(transformer);
				session.CreateMultiQuery()
					.Add(criteria)
					.List();

				Assert.IsTrue(transformer.WasTransformTupleCalled, "Transform Tuple was not called");
				Assert.IsTrue(transformer.WasTransformListCalled, "Transform List was not called");
			}
		}