Store the path, as given by the user, to each of the backup roots in the name portion of the DIR objects. Previously we were buggy and only stored the basename, which was different from the FILELIST era.

4 files changed, 42 insertions, 19 deletions

diff --git a/obnam/app.py b/obnam/app.py
index fd892d29..c085a70b 100644
--- a/obnam/app.py
+++ b/obnam/app.py
@@ -400,7 +400,7 @@ class Application:
             logging.debug("Did not find directory in previous generation")
             return [], filenames
 
-    def backup_one_dir(self, dirname, subdirs, filenames):
+    def backup_one_dir(self, dirname, subdirs, filenames, is_root=False):
         """Back up non-recursively one directory.
         
         Return obnam.obj.DirObject that refers to the directory.
@@ -427,8 +427,12 @@ class Application:
             basename = os.path.basename(dirname[:-len(os.sep)])
         assert basename
         logging.debug("Creating DirObject, basename: %s" % basename)
+        if is_root:
+            name = obnam.io.unsolve(self.get_context(), dirname)
+        else:
+            name = basename
         dir = obnam.obj.DirObject(id=obnam.obj.object_id_new(),
-                                  name=basename,
+                                  name=name,
                                   stat=os.lstat(dirname),
                                   dirrefs=dirrefs,
                                   filegrouprefs=filegrouprefs)
@@ -468,9 +472,12 @@ class Application:
 
             subdirs = subdirs_for_dir.get(dirname, [])
             
-            dir = self.backup_one_dir(dirname, subdirs, filenames)
+            is_root = (dirname == resolved)
+            
+            dir = self.backup_one_dir(dirname, subdirs, filenames, 
+                                      is_root=is_root)
 
-            if obnam.io.unsolve(self._context, dirname) != root:
+            if not is_root:
                 parent = os.path.dirname(dirname)
                 if parent not in subdirs_for_dir:
                     subdirs_for_dir[parent] = []
diff --git a/obnam/appTests.py b/obnam/appTests.py
index ecac4ca6..3973706d 100644
--- a/obnam/appTests.py
+++ b/obnam/appTests.py
@@ -590,8 +590,8 @@ class ApplicationBackupsOneDirectoryTests(unittest.TestCase):
         shutil.rmtree(self.dirname)
 
     def testWithCorrectName(self):
-        dir = self.app.backup_one_dir(self.dirname, [], [])
-        self.failUnlessEqual(dir.get_name(), os.path.basename(self.dirname))
+        dir = self.app.backup_one_dir(self.dirname, [], [], is_root=True)
+        self.failUnlessEqual(dir.get_name(), self.dirname)
 
     def testWithCorrectStat(self):
         dir = self.app.backup_one_dir(self.dirname, [], [])
@@ -651,12 +651,13 @@ class ApplicationBackupOneRootTests(unittest.TestCase):
                 self.files.append(name)
                 file(name, "w").close()
 
-    def mock_backup_one_dir(self, dirname, subdirs, filenames):
+    def mock_backup_one_dir(self, dirname, subdirs, filenames, is_root=False):
         self.dirs_walked.append(dirname)
         assert dirname not in self.subdirs_walked
         self.subdirs_walked[dirname] = [os.path.join(dirname, x.get_name())
                                         for x in subdirs]
-        return self.real_backup_one_dir(dirname, subdirs, filenames)
+        return self.real_backup_one_dir(dirname, subdirs, filenames,
+                                        is_root=is_root)
 
     def find_subdirs(self):
         dict = {}
diff --git a/obnam/store.py b/obnam/store.py
index 4672af1c..3ca6ba55 100644
--- a/obnam/store.py
+++ b/obnam/store.py
@@ -213,8 +213,24 @@ class Store:
         
         """
 
+        dirrefs = generation.get_dirrefs()
         parts = self.parse_pathname(pathname)
-        return self._lookup_dir_from_refs(generation.get_dirrefs(), parts)
+        
+        for dirref in dirrefs:
+            dir = self.get_object(dirref)
+            name = dir.get_name()
+            if name == pathname:
+                return dir
+            else:
+                if not name.endswith(os.sep):
+                    name += os.sep
+                if pathname.startswith(name):
+                    subpath = pathname[len(name):]
+                    subparts = self.parse_pathname(subpath)
+                    return self._lookup_dir_from_refs(dir.get_dirrefs(),
+                                                      subparts)
+
+        return self._lookup_dir_from_refs(dirrefs, parts)
 
     def lookup_file(self, generation, pathname):
         """Find a non-directory thingy in a generation.
diff --git a/obnam/storeTests.py b/obnam/storeTests.py
index 24113268..4a2c732f 100644
--- a/obnam/storeTests.py
+++ b/obnam/storeTests.py
@@ -237,7 +237,6 @@ class StoreLookupTests(unittest.TestCase):
 
     def setUp(self):
         self.datadir = self.create_data_dir()
-        self.dirbasename = os.path.basename(self.datadir)
 
         app = obnam.Application(self.create_context())
         app.load_host()
@@ -255,16 +254,16 @@ class StoreLookupTests(unittest.TestCase):
         shutil.rmtree(self.store._context.config.get("backup", "store"))
 
     def testFindsBackupRoot(self):
-        dir = self.store.lookup_dir(self.gen, self.dirbasename)
-        self.failUnless(dir.get_name(), self.dirbasename)
+        dir = self.store.lookup_dir(self.gen, self.datadir)
+        self.failUnless(dir.get_name(), self.datadir)
 
     def testFindsFirstSubdir(self):
-        pathname = os.path.join(self.dirbasename, "dir1")
+        pathname = os.path.join(self.datadir, "dir1")
         dir = self.store.lookup_dir(self.gen, pathname)
         self.failUnless(dir.get_name(), "dir1")
 
     def testFindsSecondSubdir(self):
-        pathname = os.path.join(self.dirbasename, "dir1", "dir2")
+        pathname = os.path.join(self.datadir, "dir1", "dir2")
         dir = self.store.lookup_dir(self.gen, pathname)
         self.failUnless(dir.get_name(), "dir2")
 
@@ -273,17 +272,17 @@ class StoreLookupTests(unittest.TestCase):
                              None)
 
     def testDoesNotFindNonExistentFileInSubDirectory(self):
-        pathname = os.path.join(self.dirbasename, "dir1", "notexist")
+        pathname = os.path.join(self.datadir, "dir1", "notexist")
         file = self.store.lookup_file(self.gen, pathname)
         self.failUnlessEqual(file, None)
 
     def testDoesNotFindNonExistentFileInSubSubDirectory(self):
-        pathname = os.path.join(self.dirbasename, "dir1", "dir2", "notexist")
+        pathname = os.path.join(self.datadir, "dir1", "dir2", "notexist")
         file = self.store.lookup_file(self.gen, pathname)
         self.failUnlessEqual(file, None)
 
     def testDoesNotFindNonExistentFileInRoot(self):
-        pathname = os.path.join(self.dirbasename, "notexist")
+        pathname = os.path.join(self.datadir, "notexist")
         file = self.store.lookup_file(self.gen, pathname)
         self.failUnlessEqual(file, None)
 
@@ -291,11 +290,11 @@ class StoreLookupTests(unittest.TestCase):
         return file.first_string_by_kind(obnam.cmp.FILENAME)
 
     def testFindsFileInRootDirectory(self):
-        pathname = os.path.join(self.dirbasename, "file1")
+        pathname = os.path.join(self.datadir, "file1")
         file = self.store.lookup_file(self.gen, pathname)
         self.failUnlessEqual(self.filename(file), "file1")
 
     def testFindsFileInSubDirectory(self):
-        pathname = os.path.join(self.dirbasename, "dir1", "dir2", "file2")
+        pathname = os.path.join(self.datadir, "dir1", "dir2", "file2")
         file = self.store.lookup_file(self.gen, pathname)
         self.failUnlessEqual(self.filename(file), "file2")