completed testing the non-forking filesystem state, use as default now

diff --git a/src/file_helpers.py b/src/file_helpers.py
index 22378f6..a682a6e 100644 (file)
--- a/src/file_helpers.py
+++ b/src/file_helpers.py
@@ -22,9 +22,10 @@ Featuring::
 
 * the cd context manager pwd(); with cd(other_dir): pwd();   pwd();
   will print current working dir, then other_dir, then first dir again
-* a wrapper around "df" to determine size and usage of file systems
-
-.. todo:: test and change default method for get_filesystem_fill_states
+* class MountPoint and function to get all mount points
+* class FilesystemFillState and 2 methods to determine it:
+* * a wrapper around "df"
+* * a wrapper around statvfs (default since faster without forking)
 
 .. codeauthor:: Intra2net
 """
@@ -91,7 +92,7 @@ class FilesystemFillState:
                .format(self.name, self.mount_point, self.capacity)
 
 
-def get_filesystem_fill_states(method=FS_FILL_METHOD_DF, *args, **kwargs):
+def get_filesystem_fill_states(method=FS_FILL_METHOD_STATVFS, *args, **kwargs):
     """ get fill state on all filesystems
 
     :param method: FS_FILL_METHOD_DF (use df_wrapper, forks) or
@@ -102,6 +103,9 @@ def get_filesystem_fill_states(method=FS_FILL_METHOD_DF, *args, **kwargs):
     if method == FS_FILL_METHOD_DF:
         return df_wrapper(*args, **kwargs)
     else:
+        # could do this more equal to df-output by
+        # - removing file systems with size 0
+        # - detecting multiple entries for same filesystem
         return get_all_statvfs_fills(*args, **kwargs)
 
 

diff --git a/test/test_file_helpers.py b/test/test_file_helpers.py
index 63c8c82..d09a64f 100644 (file)
--- a/test/test_file_helpers.py
+++ b/test/test_file_helpers.py
@@ -100,39 +100,40 @@ class FileHelperTester(unittest.TestCase):
 
             # is size approx equal to used + available?
             size = stat.used + stat.available
-            self.assertLess(float(abs(stat.size - size))
-                            , 0.1 * float(max(stat.size, size)),
+            self.assertLess(float(abs(stat.size - size)),
+                            0.1 * float(max(stat.size, size)),
                             'size deviates from used+free by more than 10%!')
 
     def test_compare_methods(self):
         """ compares methods to get_filesystem_fill_states
 
-        turns out df does not list everything there is...
+        turns out STATVFS method finds more filesystem thatn df lists; accept
+        that.
         """
 
-        states1 = file_helpers.get_filesystem_fill_states(
+        statesDF = file_helpers.get_filesystem_fill_states(
             method=file_helpers.FS_FILL_METHOD_DF)
-        states2 = file_helpers.get_filesystem_fill_states(
+        statesNF = file_helpers.get_filesystem_fill_states(
             method=file_helpers.FS_FILL_METHOD_STATVFS)
 
-        self.assertEqual(len(states1), len(states2))
+        self.assertLessEqual(len(statesDF), len(statesNF))
 
-        for state1 in states1:
-            state2 = None
-            for state in states2:
-                if state.name == state1.name:
-                    state2 = state
+        for stateDF in statesDF:
+            stateNF = None
+            for state in statesNF:
+                if state.mount_point == stateDF.mount_point:
+                    stateNF = state
                     break
-            self.assertUnequal(state2, None)
+            self.assertNotEqual(stateNF, None)
 
             # now compare the two
-            self.assertEqual(state1.size, state2.size)
-            self.assertLess(abs(state1.used - state2.used),
-                            0.1 * float(state1.size))
-            self.assertTrue(abs(state1.available - state2.available),
-                            0.1 * float(state1.size))
-            self.assertLess(abs(state1.capacity - state2.capacity), 5)
-            self.assertEqual(state1.mount_point, state2.mount_point)
+            self.assertEqual(stateDF.size, stateNF.size)
+            self.assertLess(abs(stateDF.used - stateNF.used),
+                            0.1 * float(stateDF.size))
+            self.assertLess(abs(stateDF.available - stateNF.available),
+                            0.1 * float(stateDF.size))
+            self.assertLess(abs(stateDF.capacity - stateNF.capacity), 5)
+            self.assertEqual(stateDF.name, stateNF.name)
 
     def test_disc_state_statvfs(self):
         for state in file_helpers.get_filesystem_fill_states(
@@ -144,6 +145,18 @@ class FileHelperTester(unittest.TestCase):
             self.assertLessEqual(state.used, state.size)
             self.assertLessEqual(state.available, state.size)
 
+            # does match capacity? (would be very strange since capacity is
+            # calculated from used and size)
+            if state.size > 0:
+                capacity = 100. * state.used / state.size
+                self.assertLess(abs(capacity - state.capacity), 5.,
+                                'capacity deviates from used/size by >5%!')
+
+            # is size approx equal to used + available?
+            size = state.used + state.available
+            self.assertLessEqual(float(abs(state.size - size)),
+                            0.1 * float(max(state.size, size)),
+                            'size deviates from used+free by more than 10%!')
 
 if __name__ == '__main__':
     unittest.main()