some cleanup to tests, adjustments to support mysql quirks

diff --git a/test/mapper.py b/test/mapper.py
index 51bb27c2044ef503c8a3d2f44f692d31199f044a..57ba2f36e1cc5831d8e89ab473a402491becaac8 100644 (file)
--- a/test/mapper.py
+++ b/test/mapper.py
@@ -178,15 +178,15 @@ class LazyTest(MapperSuperTest):
         l = Item.mapper.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' : 7}, {'keyword_id' : 5}])},
-            {'item_id' : 3, 'keywords' : (Keyword, [{'keyword_id' : 6}, {'keyword_id' : 3}, {'keyword_id' : 4}])},
+            {'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 = Item.mapper.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' : 7}, {'keyword_id' : 5}])},
+            {'item_id' : 2, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 5}, {'keyword_id' : 7}])},
         )
 
 class EagerTest(MapperSuperTest):
@@ -302,8 +302,8 @@ class EagerTest(MapperSuperTest):
             )
 
     def testnested(self):
-        """tests eager loading, where one of the eager loaded items also eager loads its own 
-        child items."""
+        """tests eager loading of a parent item with two types of child items,
+        where one of those child items eager loads its own child items."""
         ordermapper = mapper(Order, orders, properties = dict(
                 items = relation(Item, orderitems, lazy = False)
             ))
@@ -344,8 +344,8 @@ class EagerTest(MapperSuperTest):
         l = m.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, 'name':'red'}, {'keyword_id' : 7, 'name':'square'}, {'keyword_id' : 5, 'name':'small'}])},
-            {'item_id' : 3, 'keywords' : (Keyword, [{'keyword_id' : 6,'name':'round'}, {'keyword_id' : 3,'name':'green'}, {'keyword_id' : 4,'name':'big'}])},
+            {'item_id' : 2, 'keywords' : (Keyword, [{'keyword_id' : 2, 'name':'red'}, {'keyword_id' : 5, 'name':'small'}, {'keyword_id' : 7, 'name':'square'}])},
+            {'item_id' : 3, 'keywords' : (Keyword, [{'keyword_id' : 3,'name':'green'}, {'keyword_id' : 4,'name':'big'}, {'keyword_id' : 6,'name':'round'}])},
             {'item_id' : 4, 'keywords' : (Keyword, [])},
             {'item_id' : 5, 'keywords' : (Keyword, [])}
         )
@@ -353,10 +353,12 @@ class EagerTest(MapperSuperTest):
         l = m.select(and_(keywords.c.name == 'red', keywords.c.keyword_id == itemkeywords.c.keyword_id, items.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' : 7}, {'keyword_id' : 5}])},
+            {'item_id' : 2, 'keywords' : (Keyword, [{'keyword_id' : 2}, {'keyword_id' : 5}, {'keyword_id' : 7}])},
         )
     
     def testoneandmany(self):
+        """tests eager load for a parent object with a child object that 
+        contains a many-to-many relationship to a third object."""
         items = orderitems
 
         m = mapper(Item, items, 
@@ -372,10 +374,10 @@ class EagerTest(MapperSuperTest):
             {'order_id' : 1, 'items': (Item, [])}, 
             {'order_id' : 2, 'items': (Item, [
                 {'item_id':1, 'item_name':'item 1', 'keywords': (Keyword, [{'keyword_id':2, 'name':'red'}, {'keyword_id':4, 'name':'big'}, {'keyword_id' : 6, 'name':'round'}])}, 
-                {'item_id':2, 'item_name':'item 2','keywords' : (Keyword, [{'keyword_id' : 2, 'name':'red'}, {'keyword_id' : 7, 'name':'square'}, {'keyword_id' : 5, 'name':'small'}])}
+                {'item_id':2, 'item_name':'item 2','keywords' : (Keyword, [{'keyword_id' : 2, 'name':'red'}, {'keyword_id' : 5, 'name':'small'}, {'keyword_id' : 7, 'name':'square'}])}
                ])},
             {'order_id' : 3, 'items': (Item, [
-                {'item_id':3, 'item_name':'item 3', 'keywords' : (Keyword, [{'keyword_id' : 6, 'name':'round'}, {'keyword_id' : 3, 'name':'green'}, {'keyword_id' : 4, 'name':'big'}])}, 
+                {'item_id':3, 'item_name':'item 3', 'keywords' : (Keyword, [{'keyword_id' : 3, 'name':'green'}, {'keyword_id' : 4, 'name':'big'}, {'keyword_id' : 6, 'name':'round'}])}, 
                 {'item_id':4, 'item_name':'item 4'}, 
                 {'item_id':5, 'item_name':'item 5'}
                ])},

diff --git a/test/objectstore.py b/test/objectstore.py
index 8b27d65d8bbe9b2767348f6e63ed3626a137c8e4..6afa2c60fd2fe4331e007f22a971a71a0c679f64 100644 (file)
--- a/test/objectstore.py
+++ b/test/objectstore.py
@@ -340,56 +340,6 @@ class SaveTest(AssertMixin):
         l = sql.select([users, addresses], sql.and_(users.c.user_id==addresses.c.address_id, addresses.c.address_id==a.address_id)).execute()
         self.echo( repr(l.fetchone().row))
 
-    def testbackwardsnonmatch(self):
-        u2 = Table('users_nm', db,
-            Column('user_id', Integer, primary_key = True),
-            Column('user_name', String(20)),
-        )
-
-        a2 = Table('email_addresses_nm', db,
-            Column('address_id', Integer, primary_key = True),
-            Column('rel_user_id', Integer, ForeignKey(u2.c.user_id)),
-            Column('email_address', String(20)),
-        )
-        u2.create()
-        a2.create()
-        m = mapper(Address, a2, properties = dict(
-            user = relation(User, u2, lazy = True, uselist = False)
-        ))
-        data = [
-            {'user_name' : 'thesub' , 'email_address' : 'bar@foo.com'},
-            {'user_name' : 'assdkfj' , 'email_address' : 'thesdf@asdf.com'},
-        ]
-        objects = []
-        for elem in data:
-            a = Address()
-            a.email_address = elem['email_address']
-            a.user = User()
-            a.user.user_name = elem['user_name']
-            objects.append(a)
-        self.assert_sql(db, lambda: objectstore.commit(), [
-                (
-                    "INSERT INTO users_nm (user_name) VALUES (:user_name)",
-                    {'user_name': 'thesub'}
-                ),
-                (
-                    "INSERT INTO users_nm (user_name) VALUES (:user_name)",
-                    {'user_name': 'assdkfj'}
-                ),
-                (
-                "INSERT INTO email_addresses_nm (rel_user_id, email_address) VALUES (:rel_user_id, :email_address)",
-                {'rel_user_id': 1, 'email_address': 'bar@foo.com'}
-                ),
-                (
-                "INSERT INTO email_addresses_nm (rel_user_id, email_address) VALUES (:rel_user_id, :email_address)",
-                {'rel_user_id': 2, 'email_address': 'thesdf@asdf.com'}
-                )
-                ]
-        )
-        a2.drop()
-        u2.drop()
-        db.commit()
-        
         
 
     def testonetomany(self):
@@ -734,7 +684,70 @@ class SaveTest(AssertMixin):
         
         objectstore.delete(u)
         objectstore.commit()
-        
+    
+class SaveTest2(AssertMixin):
+
+    def setUp(self):
+        db.echo = False
+        objectstore.clear()
+        clear_mappers()
+        self.users = Table('users', db,
+            Column('user_id', Integer, primary_key = True),
+            Column('user_name', String(20)),
+            redefine=True
+        )
+
+        self.addresses = Table('email_addresses', db,
+            Column('address_id', Integer, primary_key = True),
+            Column('rel_user_id', Integer, ForeignKey(self.users.c.user_id)),
+            Column('email_address', String(20)),
+            redefine=True
+        )
+        self.users.create()
+        self.addresses.create()
+        db.echo = testbase.echo
+
+    def tearDown(self):
+        db.echo = False
+        self.addresses.drop()
+        self.users.drop()
+        db.echo = testbase.echo
+    
+    def testbackwardsnonmatch(self):
+        m = mapper(Address, self.addresses, properties = dict(
+            user = relation(User, self.users, lazy = True, uselist = False)
+        ))
+        data = [
+            {'user_name' : 'thesub' , 'email_address' : 'bar@foo.com'},
+            {'user_name' : 'assdkfj' , 'email_address' : 'thesdf@asdf.com'},
+        ]
+        objects = []
+        for elem in data:
+            a = Address()
+            a.email_address = elem['email_address']
+            a.user = User()
+            a.user.user_name = elem['user_name']
+            objects.append(a)
+        self.assert_sql(db, lambda: objectstore.commit(), [
+                (
+                    "INSERT INTO users (user_name) VALUES (:user_name)",
+                    {'user_name': 'thesub'}
+                ),
+                (
+                    "INSERT INTO users (user_name) VALUES (:user_name)",
+                    {'user_name': 'assdkfj'}
+                ),
+                (
+                "INSERT INTO email_addresses (rel_user_id, email_address) VALUES (:rel_user_id, :email_address)",
+                {'rel_user_id': 1, 'email_address': 'bar@foo.com'}
+                ),
+                (
+                "INSERT INTO email_addresses (rel_user_id, email_address) VALUES (:rel_user_id, :email_address)",
+                {'rel_user_id': 2, 'email_address': 'thesdf@asdf.com'}
+                )
+                ]
+        )
+
 
 if __name__ == "__main__":
     testbase.main()        

diff --git a/test/tables.py b/test/tables.py
index b1beff8675e2cf02adc2eb8fe6abfb670bd24f9b..97363aa92d27d9826349beec3b3637b50f9233aa 100644 (file)
--- a/test/tables.py
+++ b/test/tables.py
@@ -110,16 +110,22 @@ def data():
         dict(keyword_id=6, name='round'),
         dict(keyword_id=7, name='square')
     )
+    
+    # this many-to-many table has the keywords inserted
+    # in primary key order, to appease the unit tests.
+    # this is because postgres, oracle, and sqlite all support 
+    # true insert-order row id, but of course our pal MySQL does not,
+    # so the best it can do is order by, well something, so there you go.
     itemkeywords.insert().execute(
         dict(keyword_id=2, item_id=1),
         dict(keyword_id=2, item_id=2),
         dict(keyword_id=4, item_id=1),
         dict(keyword_id=6, item_id=1),
-        dict(keyword_id=7, item_id=2),
-        dict(keyword_id=6, item_id=3),
-        dict(keyword_id=3, item_id=3),
         dict(keyword_id=5, item_id=2),
-        dict(keyword_id=4, item_id=3)
+        dict(keyword_id=3, item_id=3),
+        dict(keyword_id=4, item_id=3),
+        dict(keyword_id=7, item_id=2),
+        dict(keyword_id=6, item_id=3)
     )
 
     db.commit()

diff --git a/test/testbase.py b/test/testbase.py
index 386e903c8c3567b9da5647f22e0cb5976589b5c1..969ed8fd33b377225be5f8ada2b8925667c99277 100644 (file)
--- a/test/testbase.py
+++ b/test/testbase.py
@@ -155,7 +155,7 @@ class TTestSuite(unittest.TestSuite):
 
 unittest.TestLoader.suiteClass = TTestSuite
 
-if len(sys.argv) == 3:
+if len(sys.argv) >= 3:
     (param, DBTYPE) = (sys.argv.pop(1), sys.argv.pop(1))
 else:
     (param, DBTYPE) = None, None