all of LazyTest moved to updated lazy_relations module

diff --git a/test/orm/lazy_relations.py b/test/orm/lazy_relations.py
index e0a6ceeed44a518cf79bba921b16bc0d002adacb..5090ef4ac785f3e9df85ea7712e07db9dce9be81 100644 (file)
--- a/test/orm/lazy_relations.py
+++ b/test/orm/lazy_relations.py
@@ -1,3 +1,5 @@
+"""basic tests of lazy loaded attributes"""
+
 from sqlalchemy import *
 from sqlalchemy.orm import *
 import testbase
@@ -170,7 +172,7 @@ class LazyTest(QueryTest):
         l = q.filter(s.c.u2_id==User.c.id).distinct().all()
         assert self.user_all_result == l
 
-    def test_onetoone(self):
+    def test_one_to_many_scalar(self):
         mapper(User, users, properties = dict(
             address = relation(mapper(Address, addresses), lazy=True, uselist=False)
         ))
@@ -178,5 +180,97 @@ class LazyTest(QueryTest):
         l = q.filter(users.c.id == 7).all()
         assert [User(id=7, address=Address(id=1))] == l
 
+    def test_double(self):
+        """tests lazy loading with two relations simulatneously, from the same table, using aliases.  """
+        openorders = alias(orders, 'openorders')
+        closedorders = alias(orders, 'closedorders')
+
+        mapper(Address, addresses)
+        
+        mapper(User, users, properties = dict(
+            addresses = relation(Address, lazy = True),
+            open_orders = relation(mapper(Order, openorders, entity_name='open'), primaryjoin = and_(openorders.c.isopen == 1, users.c.id==openorders.c.user_id), lazy=True),
+            closed_orders = relation(mapper(Order, closedorders,entity_name='closed'), primaryjoin = and_(closedorders.c.isopen == 0, users.c.id==closedorders.c.user_id), lazy=True)
+        ))
+        q = create_session().query(User)
+
+        assert [
+            User(
+                id=7,
+                addresses=[Address(id=1)],
+                open_orders = [Order(id=3)],
+                closed_orders = [Order(id=1), Order(id=5)]
+            ),
+            User(
+                id=8,
+                addresses=[Address(id=2), Address(id=3), Address(id=4)],
+                open_orders = [],
+                closed_orders = []
+            ),
+            User(
+                id=9,
+                addresses=[Address(id=5)],
+                open_orders = [Order(id=4)],
+                closed_orders = [Order(id=2)]
+            ),
+            User(id=10)
+        
+        ] == q.all()
+
+    def test_many_to_many(self):
+
+        mapper(Keyword, keywords)
+        mapper(Item, items, properties = dict(
+                keywords = relation(Keyword, secondary=item_keywords, lazy=True),
+        ))
+        
+        q = create_session().query(Item)
+        assert [
+            Item(id=1, keywords=[Keyword(name='red'), Keyword(name='big'), Keyword(name='round')]),
+            Item(id=2, keywords=[Keyword(name='red'), Keyword(name='small'), Keyword(name='square')]),
+            Item(id=3, keywords=[Keyword(name='green'), Keyword(name='big'), Keyword(name='round')]),
+            Item(id=4, keywords=[]),
+            Item(id=5, keywords=[]),
+        ] == q.all()
+
+        assert [
+            Item(id=1, keywords=[Keyword(name='red'), Keyword(name='big'), Keyword(name='round')]),
+            Item(id=2, keywords=[Keyword(name='red'), Keyword(name='small'), Keyword(name='square')]),
+        ] == q.join('keywords').filter(keywords.c.name == 'red').all()
+
+    def test_uses_get(self):
+        """test that a simple many-to-one lazyload optimizes to use query.get()."""
+
+        mapper(Address, addresses, properties = dict(
+            user = relation(mapper(User, users), lazy=True)
+        ))
+        
+        sess = create_session()
+        
+        # load address
+        a1 = sess.query(Address).filter_by(email_address="ed@wood.com").one()
+        
+        # load user that is attached to the address
+        u1 = sess.query(User).get(8)
+        
+        def go():
+            # lazy load of a1.user should get it from the session
+            assert a1.user is u1
+        self.assert_sql_count(testbase.db, go, 0)
+
+    def test_many_to_one(self):
+        mapper(Address, addresses, properties = dict(
+            user = relation(mapper(User, users), lazy=True)
+        ))
+        sess = create_session()
+        q = sess.query(Address)
+        a = q.filter(addresses.c.id==1).one()
+
+        assert a.user is not None
+        
+        u1 = sess.query(User).get(7)
+        
+        assert a.user is u1
+
 if __name__ == '__main__':
     testbase.main()

diff --git a/test/orm/mapper.py b/test/orm/mapper.py
index ab53e36c452a45dddf435210a07051388b04700f..370027a8808f1125c2296ee4638ae3238c51e704 100644 (file)
--- a/test/orm/mapper.py
+++ b/test/orm/mapper.py
@@ -868,88 +868,6 @@ class MapperExtensionTest(MapperSuperTest):
         l = q.select();
         self.assert_result(l, User, *user_address_result)
     
-class LazyTest(MapperSuperTest):
-
-
-    def testbackwardsonetoone(self):
-        m = mapper(Address, addresses, properties = dict(
-            user = relation(mapper(User, users), lazy = True)
-        ))
-        q = create_session().query(m)
-        l = q.select(addresses.c.address_id == 1)
-        self.echo(repr(l))
-        print repr(l[0].__dict__)
-        self.echo(repr(l[0].user))
-        self.assert_(l[0].user is not None)
-
-    def testuseget(self):
-        """test that a simple many-to-one lazyload optimizes to use query.get().
-        
-        this is done currently by comparing the 'get' SQL clause of the query
-        to the 'lazy' SQL clause of the lazy loader, so it relies heavily on 
-        ClauseElement.compare()"""
-        
-        m = mapper(Address, addresses, properties = dict(
-            user = relation(mapper(User, users), lazy = True)
-        ))
-        sess = create_session()
-        a1 = sess.query(Address).get_by(email_address = "ed@wood.com")
-        u1 = sess.query(User).get(8)
-        def go():
-            assert a1.user is u1
-        self.assert_sql_count(db, go, 0)
-
-    def testdouble(self):
-        """tests lazy loading with two relations simulatneously, from the same table, using aliases.  """
-        openorders = alias(orders, 'openorders')
-        closedorders = alias(orders, 'closedorders')
-        m = mapper(User, users, properties = dict(
-            addresses = relation(mapper(Address, addresses), lazy = True),
-            open_orders = relation(mapper(Order, openorders, entity_name='open'), primaryjoin = and_(openorders.c.isopen == 1, users.c.user_id==openorders.c.user_id), lazy = True),
-            closed_orders = relation(mapper(Order, closedorders,entity_name='closed'), primaryjoin = and_(closedorders.c.isopen == 0, users.c.user_id==closedorders.c.user_id), lazy = True)
-        ))
-        q = create_session().query(m)
-        l = q.select()
-        self.assert_result(l, User,
-            {'user_id' : 7, 
-                'addresses' : (Address, [{'address_id' : 1}]),
-                'open_orders' : (Order, [{'order_id' : 3}]),
-                'closed_orders' : (Order, [{'order_id' : 1},{'order_id' : 5},])
-            },
-            {'user_id' : 8, 
-                'addresses' : (Address, [{'address_id' : 2}, {'address_id' : 3}, {'address_id' : 4}]),
-                'open_orders' : (Order, []),
-                'closed_orders' : (Order, [])
-            },
-            {'user_id' : 9, 
-                'addresses' : (Address, []),
-                'open_orders' : (Order, [{'order_id' : 4}]),
-                'closed_orders' : (Order, [{'order_id' : 2}])
-            }
-            )
-
-    def testmanytomany(self):
-        """tests a many-to-many lazy load"""
-        mapper(Item, orderitems, properties = dict(
-                keywords = relation(mapper(Keyword, keywords), itemkeywords, lazy = True),
-            ))
-        q = create_session().query(Item)
-        l = q.select()
-        self.assert_result(l, Item, 
-            {'item_id' : 1, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 4}, {'keyword_id' : 6}])},
-            {'item_id' : 2, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 5}, {'keyword_id' : 7}])},
-            {'item_id' : 3, 'keywords' : (Keyword, [{'keyword_id' : 3}, {'keyword_id' : 4}, {'keyword_id' : 6}])},
-            {'item_id' : 4, 'keywords' : (Keyword, [])},
-            {'item_id' : 5, 'keywords' : (Keyword, [])}
-        )
-        l = q.select(and_(keywords.c.name == 'red', keywords.c.keyword_id == itemkeywords.c.keyword_id, Item.c.item_id==itemkeywords.c.item_id))
-        self.assert_result(l, Item, 
-            {'item_id' : 1, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 4}, {'keyword_id' : 6}])},
-            {'item_id' : 2, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 5}, {'keyword_id' : 7}])},
-        )
-    
-
-        
 class EagerTest(MapperSuperTest):
     def testbasic(self):
         """tests a basic one-to-many eager load"""