Changeset 397 for elixir/trunk/tests/test_m2m.py

Timestamp:

08/21/08 17:32:31 (5 years ago)

Author:

ged

Message:

New features:
- The local_colname and remote_colname arguments on ManyToMany relationships

can now also be used to set custom names for the ManyToMany table columns.
This effectively replace the column_format on ManyToMany relationships which
is now deprecated. Change based on a patch from Diez B. Roggisch.

- Added (or rather fixed and documented) a "table" argument on ManyToMany

relationships to allow using a manually-defined Table (closes #44).

- Added a "schema" argument on ManyToMany relationship to be able to create the

ManyToMany table in a custom schema and not necessarily the same schema as
the table of the "source" entity (patch from Diez B. Roggisch).

Changes:
- Renamed remote_side and local_side ManyToMany arguments to remote_colname and

local_colname respectively to not collide with the remote_side argument
provided by SA (it doesn't make much sense on ManyToMany relationships but
still).

Bug fixes:
- Changed slightly the algorithm to generate the name of the table for

bidirectional self-referential ManyToMany relationships so that it doesn't
depend on the order of declaration of each side (closes #19). If you are
upgrading an application with existing data from an earlier version of
Elixir, you are STRONGLY ADVISED to read the upgrade notes!
=============================
TEMPORARY BUT IMPORTANT NOTE:
=============================
For now it is even worse: the table works but the relationship's meaning is
reversed. Will be fixed before 0.7 ships (see ticket #69).
=============================

- Added missing documentation for the "filter" argument on OneToMany

relationships

Not logged in CHANGES:
- bumped version
- added a few tests
- completed/fixed the API doc a bit
- added some comments in the code so that I remember why things are done this

way.

Files:

• elixir/trunk/tests/test_m2m.py (modified) (2 diffs)

elixir/trunk/tests/test_m2m.py

@@ -121 +121 @@
     def test_selfref(self):
         class Person(Entity):
+            using_options(shortnames=True)
             name = Field(String(30))
 
             friends = ManyToMany('Person')
+
+        setup_all(True)
+
+        barney = Person(name="Barney")
+        homer = Person(name="Homer", friends=[barney])
+        barney.friends.append(homer)
+
+        session.commit()
+        session.clear()
+
+        homer = Person.get_by(name="Homer")
+        barney = Person.get_by(name="Barney")
+
+        assert homer in barney.friends
+        assert barney in homer.friends
+
+    def test_bidirectional_selfref(self):
+        class Person(Entity):
+            using_options(shortnames=True)
+            name = Field(String(30))
+
+            friends = ManyToMany('Person')
+            is_friend_of = ManyToMany('Person')
 
         setup_all(True)
@@ -170 +194 @@
         assert not a3.bs
 
+    def test_local_and_remote_colnames(self):
+        class A(Entity):
+            using_options(shortnames=True)
+            key1 = Field(Integer, primary_key=True, autoincrement=False)
+            key2 = Field(String(40), primary_key=True)
+
+            bs_ = ManyToMany('B', local_colname=['foo', 'bar'],
+                                  remote_colname="baz")
+
+        class B(Entity):
+            using_options(shortnames=True)
+            name = Field(String(60))
+            as_ = ManyToMany('A', remote_colname=['foo', 'bar'],
+                                  local_colname="baz")
+
+        setup_all(True)
+
+        b1 = B(name='b1', as_=[A(key1=10, key2='a1')])
+
+        session.commit()
+        session.clear()
+
+        a = A.query.one()
+        b = B.query.one()
+
+        assert a in b.as_
+        assert b in a.bs_
+
+    def test_manual_table_auto_joins(self):
+        from sqlalchemy import Table, Column, ForeignKey, ForeignKeyConstraint
+
+        a_b = Table('a_b', metadata,
+                    Column('a_key1', None),
+                    Column('a_key2', None),
+                    Column('b_id', None, ForeignKey('b.id')),
+                    ForeignKeyConstraint(['a_key1', 'a_key2'],
+                                         ['a.key1', 'a.key2']))
+
+        class A(Entity):
+            using_options(shortnames=True)
+            key1 = Field(Integer, primary_key=True, autoincrement=False)
+            key2 = Field(String(40), primary_key=True)
+
+            bs_ = ManyToMany('B', table=a_b)
+
+        class B(Entity):
+            using_options(shortnames=True)
+            name = Field(String(60))
+            as_ = ManyToMany('A', table=a_b)
+
+        setup_all(True)
+
+        b1 = B(name='b1', as_=[A(key1=10, key2='a1')])
+
+        session.commit()
+        session.clear()
+
+        a = A.query.one()
+        b = B.query.one()
+
+        assert a in b.as_
+        assert b in a.bs_
+
+    def test_manual_table_manual_joins(self):
+        from sqlalchemy import Table, Column, ForeignKey, \
+                               ForeignKeyConstraint, and_
+
+        a_b = Table('a_b', metadata,
+                    Column('a_key1', Integer),
+                    Column('a_key2', String(40)),
+                    Column('b_id', String(60)))
+
+        class A(Entity):
+            using_options(shortnames=True)
+            key1 = Field(Integer, primary_key=True, autoincrement=False)
+            key2 = Field(String(40), primary_key=True)
+
+            bs_ = ManyToMany('B', table=a_b,
+                             primaryjoin=lambda: and_(A.key1 == a_b.c.a_key1,
+                                                      A.key2 == a_b.c.a_key2),
+                             secondaryjoin=lambda: B.id == a_b.c.b_id,
+                             foreign_keys=[a_b.c.a_key1, a_b.c.a_key2,
+                                 a_b.c.b_id])
+
+        class B(Entity):
+            using_options(shortnames=True)
+            name = Field(String(60))
+
+        setup_all(True)
+
+        a1 = A(key1=10, key2='a1', bs_=[B(name='b1')])
+
+        session.commit()
+        session.clear()
+
+        a = A.query.one()
+        b = B.query.one()
+
+        assert b in a.bs_