Have the generation object obnam.Application.backup returns be filled with useful stuff.

2 files changed, 60 insertions, 5 deletions

diff --git a/obnam/app.py b/obnam/app.py
index 62dd9ab5..808536c5 100644
--- a/obnam/app.py
+++ b/obnam/app.py
@@ -235,7 +235,14 @@ class Application:
 
     def backup_one_root(self, root):
         """Backup one root for the next generation."""
+        
+        if not os.path.isdir(root):
+            raise obnam.ObnamException("Not a directory: %s" % root)
+            # FIXME: This needs to be able to handle non-directories, too!
+        
         subdirs_for_dir = {}
+        root_object = None
+        
         for tuple in obnam.walk.depth_first(root, prune=self.prune):
             dirname, dirnames, filenames = tuple
 
@@ -248,14 +255,22 @@ class Application:
                 if parent not in subdirs_for_dir:
                     subdirs_for_dir[parent] = []
                 subdirs_for_dir[parent].append(dir)
+            else:
+                root_object = dir
 
             if dirname in subdirs_for_dir:
                 del subdirs_for_dir[dirname]
 
+        return root_object
+
     def backup(self, roots):
         """Backup all the roots."""
+
+        root_objs = []
         for root in roots:
-            self.backup_one_root(root)
+            root_objs.append(self.backup_one_root(root))
 
-        gen = obnam.obj.GenerationObject(id=obnam.obj.object_id_new())
+        dirrefs = [o.get_id() for o in root_objs]
+        gen = obnam.obj.GenerationObject(id=obnam.obj.object_id_new(),
+                                         dirrefs=dirrefs)
         return gen
diff --git a/obnam/appTests.py b/obnam/appTests.py
index 6e23a751..f5f34de1 100644
--- a/obnam/appTests.py
+++ b/obnam/appTests.py
@@ -274,6 +274,15 @@ class ApplicationBackupOneRootTests(unittest.TestCase):
     def tearDown(self):
         shutil.rmtree(self.dirname)
 
+    def testRaisesErrorForNonDirectory(self):
+        self.failUnlessRaises(obnam.ObnamException,
+                              self.app.backup_one_root,
+                              self.abs("file0"))
+
+    def testReturnsDirObject(self):
+        ret = self.app.backup_one_root(self.dirname)
+        self.failUnless(isinstance(ret, obnam.obj.DirObject))
+
     def testWalksToTheRightDirectories(self):
         self.app.backup_one_root(self.dirname)
         self.failUnlessEqual(self.dirs_walked, list(reversed(self.dirs)))
@@ -285,19 +294,50 @@ class ApplicationBackupOneRootTests(unittest.TestCase):
 
 class ApplicationBackupTests(unittest.TestCase):
 
+    _tree = (
+        "file0",
+        "pink/",
+        "pink/file1",
+        "pink/dir1/",
+        "pink/dir1/dir2/",
+        "pink/dir1/dir2/file2",
+        "pretty/",
+    )
+
+    def abs(self, relative_name):
+        return os.path.join(self.dirname, relative_name)
+
+    def mktree(self, tree):
+        for name in tree:
+            if name.endswith("/"):
+                name = self.abs(name[:-1])
+                os.mkdir(name)
+            else:
+                name = self.abs(name)
+                file(name, "w").close()
+
     def mock_backup_one_root(self, root):
         self.roots_backed_up.append(root)
+        return self.real_backup_one_root(root)
 
     def setUp(self):
+        self.dirname = tempfile.mkdtemp()
+        self.mktree(self._tree)
         self.roots_backed_up = []
         context = obnam.context.Context()
         self.app = obnam.Application(context)
+        self.real_backup_one_root = self.app.backup_one_root
         self.app.backup_one_root = self.mock_backup_one_root
 
     def testCallsBackupOneRootForEachRoot(self):
-        self.app.backup(["/pink", "/pretty"])
-        self.failUnlessEqual(self.roots_backed_up, ["/pink", "/pretty"])
+        dirs = [self.abs(x) for x in ["pink", "pretty"]]
+        self.app.backup(dirs)
+        self.failUnlessEqual(self.roots_backed_up, dirs)
 
     def testReturnsGenerationObject(self):
-        ret = self.app.backup(["/pink", "/pretty"])
+        ret = self.app.backup([self.abs("pink"), self.abs("pretty")])
         self.failUnless(isinstance(ret, obnam.obj.GenerationObject))
+
+    def testReturnsGenerationWithTheRightRootObjects(self):
+        gen = self.app.backup([self.abs("pink"), self.abs("pretty")])
+        self.failUnlessEqual(len(gen.get_dirrefs()), 2)