Merge branch 'master' into dbtests

diff --git a/daklib/dbconn.py b/daklib/dbconn.py
index e685d9190f9bc8b2460e1f379696f05ff83efcaa..6d8d3bd69b230a1a61ceec456cdfbb18a6311d31 100755 (executable)
--- a/daklib/dbconn.py
+++ b/daklib/dbconn.py
@@ -2074,9 +2074,14 @@ __all__.append('get_sections')
 ################################################################################
 
 class DBSource(object):
-    def __init__(self, maintainer = None, changedby = None):
+    def __init__(self, source = None, version = None, maintainer = None, \
+        changedby = None, poolfile = None, install_date = None):
+        self.source = source
+        self.version = version
         self.maintainer = maintainer
         self.changedby = changedby
+        self.poolfile = poolfile
+        self.install_date = install_date
 
     def __repr__(self):
         return '<DBSource %s (%s)>' % (self.source, self.version)
@@ -3036,7 +3041,7 @@ class DBConn(object):
                                  version = self.tbl_source.c.version,
                                  maintainer_id = self.tbl_source.c.maintainer,
                                  poolfile_id = self.tbl_source.c.file,
-                                 poolfile = relation(PoolFile),
+                                 poolfile = relation(PoolFile, backref=backref('source', uselist = False)),
                                  fingerprint_id = self.tbl_source.c.sig_fpr,
                                  fingerprint = relation(Fingerprint),
                                  changedby_id = self.tbl_source.c.changedby,

diff --git a/tests/db_test.py b/tests/db_test.py
index 4f01f6d5d1583a89128a4b12c1fd41c9546fd88e..fc9ce893d61d4c25aef3f1adc269cb6c21c7dc43 100644 (file)
--- a/tests/db_test.py
+++ b/tests/db_test.py
@@ -3,7 +3,7 @@ from base_test import DakTestCase, fixture
 from daklib.config import Config
 from daklib.dbconn import DBConn
 
-from sqlalchemy import create_engine, __version__
+from sqlalchemy import create_engine, func, __version__
 from sqlalchemy.exc import SADeprecationWarning
 from sqlalchemy.schema import DDL
 
@@ -72,6 +72,15 @@ class DBDakTestCase(DakTestCase):
             self.initialize()
         self.session = DBConn().session()
 
+    def now(self):
+        "returns the current time at the db server"
+
+        # we fetch a fresh session each time to avoid caching
+        local_session = DBConn().session()
+        current_time = local_session.query(func.now()).scalar()
+        local_session.close()
+        return current_time
+
     def classes_to_clean(self):
         """
         The function classes_to_clean() returns a list of classes. All objects

diff --git a/tests/dbtest_packages.py b/tests/dbtest_packages.py
index 279d5a0f06702f0d66a4d3301a45f80d51bdf039..8764bc78a4139152d790baf867cf1835711f9107 100755 (executable)
--- a/tests/dbtest_packages.py
+++ b/tests/dbtest_packages.py
@@ -23,21 +23,15 @@ class PackageTestCase(DBDakTestCase):
         # hard code ids for source and all
         self.arch['source'].arch_id = 1
         self.arch['all'].arch_id = 2
-        for _, architecture in self.arch.items():
-            self.session.add(architecture)
-            self.session.flush()
-            self.session.refresh(architecture)
+        self.session.add_all(self.arch.values())
 
     def setup_suites(self):
         "setup a hash of Suite objects in self.suite"
 
         self.suite = {}
         for suite_name in ('lenny', 'squeeze', 'sid'):
-            suite = Suite(suite_name = suite_name, version = '-')
-            self.suite[suite_name] = suite
-            self.session.add(suite)
-            self.session.flush()
-            self.session.refresh(suite)
+            self.suite[suite_name] = Suite(suite_name = suite_name, version = '-')
+        self.session.add_all(self.suite.values())
 
     def setUp(self):
         super(PackageTestCase, self).setUp()
@@ -102,6 +96,7 @@ class PackageTestCase(DBDakTestCase):
     def setup_poolfiles(self):
         'create some PoolFile objects'
 
+        self.setup_locations()
         self.file = {}
         self.file['hello'] = PoolFile(filename = 'main/h/hello/hello_2.2-2.dsc', \
             location = self.loc['main'], filesize = 0, md5sum = '')
@@ -121,7 +116,7 @@ class PackageTestCase(DBDakTestCase):
 
         somelocation.files.append(somefile)
         '''
-        self.setup_locations()
+
         self.setup_poolfiles()
         location = self.session.query(Location)[0]
         self.assertEqual('/srv/ftp-master.debian.org/ftp/pool/', location.path)
@@ -169,16 +164,21 @@ class PackageTestCase(DBDakTestCase):
     def setup_maintainers(self):
         'create some Maintainer objects'
 
-        self.maintainer = Maintainer(name = 'Mr. Maintainer')
-        self.uploader = Maintainer(name = 'Mrs. Uploader')
-        self.lazyguy = Maintainer(name = 'Lazy Guy')
-        self.session.add_all([self.maintainer, self.uploader, self.lazyguy])
+        self.maintainer = {}
+        self.maintainer['maintainer'] = Maintainer(name = 'Mr. Maintainer')
+        self.maintainer['uploader'] = Maintainer(name = 'Mrs. Uploader')
+        self.maintainer['lazyguy'] = Maintainer(name = 'Lazy Guy')
+        self.session.add_all(self.maintainer.values())
 
     def setup_sources(self):
         'create a DBSource object; but it cannot be stored in the DB yet'
 
-        self.source = DBSource(maintainer = self.maintainer,
-            changedby = self.uploader)
+        self.setup_maintainers()
+        self.setup_poolfiles()
+        self.source = DBSource(source = 'hello', version = '2.2-2', \
+            maintainer = self.maintainer['maintainer'], \
+            changedby = self.maintainer['uploader'], \
+            poolfile = self.file['hello'], install_date = self.now())
 
     def test_maintainers(self):
         '''
@@ -187,21 +187,31 @@ class PackageTestCase(DBDakTestCase):
         TODO: add relations to changes_pending_source
         '''
 
-        self.setup_maintainers()
-        self.assertEqual('Mr. Maintainer',
-                self.session.query(Maintainer)[0].name)
-        self.assertEqual('Mrs. Uploader',
-                self.session.query(Maintainer)[1].name)
-        self.assertEqual('Lazy Guy',
-                self.session.query(Maintainer)[2].name)
         self.setup_sources()
-        #TODO: needs File and Location
-        #self.assertEqual(self.maintainer.maintains_sources, [self.source])
-        #self.assertEqual(self.maintainer.changed_sources, [])
-        #self.assertEqual(self.uploader.maintains_sources, [])
-        #self.assertEqual(self.uploader.changed_sources, [self.source])
-        #self.assertEqual(self.lazyguy.maintains_sources, [])
-        #self.assertEqual(self.lazyguy.changed_sources, [])
+        self.session.flush()
+        maintainer = self.maintainer['maintainer']
+        self.assertEqual(maintainer,
+            self.session.query(Maintainer).get(maintainer.maintainer_id))
+        uploader = self.maintainer['uploader']
+        self.assertEqual(uploader,
+            self.session.query(Maintainer).get(uploader.maintainer_id))
+        lazyguy = self.maintainer['lazyguy']
+        self.assertEqual(lazyguy,
+            self.session.query(Maintainer).get(lazyguy.maintainer_id))
+        self.assertEqual(maintainer.maintains_sources, [self.source])
+        self.assertEqual(maintainer.changed_sources, [])
+        self.assertEqual(uploader.maintains_sources, [])
+        self.assertEqual(uploader.changed_sources, [self.source])
+        self.assertEqual(lazyguy.maintains_sources, [])
+        self.assertEqual(lazyguy.changed_sources, [])
+
+    def test_sources(self):
+        'test relation between DBSource and PoolFile'
+
+        self.setup_sources()
+        self.assertEqual(self.file['hello'], self.source.poolfile)
+        self.assertEqual(self.source, self.file['hello'].source)
+        self.assertEqual(None, self.file['sl'].source)
 
 
 if __name__ == '__main__':

diff --git a/tests/dbtest_timestamps.py b/tests/dbtest_timestamps.py
index 1a53ae8665da5c9241370165bc5136c5926533a8..8b35c63f804041f87e51e6e5a77ddc0f741f7d6d 100755 (executable)
--- a/tests/dbtest_timestamps.py
+++ b/tests/dbtest_timestamps.py
@@ -4,7 +4,6 @@ from db_test import DBDakTestCase
 
 from daklib.dbconn import DBConn, Uid
 
-from sqlalchemy import func
 import time
 import unittest
 
@@ -16,15 +15,6 @@ class TimestampTestCase(DBDakTestCase):
     TODO: Should we check all tables?
     """
 
-    def now(self):
-        "returns the current time at the db server"
-
-        # we fetch a fresh session each time to avoid caching
-        local_session = DBConn().session()
-        current_time = local_session.query(func.now()).scalar()
-        local_session.close()
-        return current_time
-
     def sleep(self):
         time.sleep(0.001)