functional-tests: Updates to miner test cases and framework

5 files changed, 179 insertions, 159 deletions

diff --git a/tests/functional-tests/300-miner-basic-ops.py b/tests/functional-tests/300-miner-basic-ops.py
index c8875607f..fa82623cb 100755
--- a/tests/functional-tests/300-miner-basic-ops.py
+++ b/tests/functional-tests/300-miner-basic-ops.py
@@ -25,55 +25,52 @@
 Monitor a test directory and copy/move/remove/update files and folders there.
 Check the basic data of the files is updated accordingly in tracker.
 """
+
+from common.utils import configuration as cfg
+from common.utils.helpers import log
+from common.utils.minertest import CommonTrackerMinerTest, MINER_TMP_DIR, get_test_uri, get_test_path
+from common.utils.system import TrackerSystemAbstraction
+
 import os
 import shutil
 import time
-
 import unittest2 as ut
-from common.utils.helpers import log
-from common.utils.minertest import CommonTrackerMinerTest, MINER_TMP_DIR, uri, path
+
+CONF_OPTIONS = [
+    (cfg.DCONF_MINER_SCHEMA, "index-recursive-directories", [os.path.join (MINER_TMP_DIR, "test-monitored")]),
+    (cfg.DCONF_MINER_SCHEMA, "index-single-directories", "[]"),
+    (cfg.DCONF_MINER_SCHEMA, "index-optical-discs", "false"),
+    (cfg.DCONF_MINER_SCHEMA, "index-removable-devices", "false"),
+    (cfg.DCONF_MINER_SCHEMA, "throttle", 5)
+    ]
 
 class MinerCrawlTest (CommonTrackerMinerTest):
     """
     Test cases to check if miner is able to monitor files that are created, deleted or moved
     """
-    def __get_text_documents (self):
-        return self.tracker.query ("""
-          SELECT ?url WHERE {
-              ?u a nfo:TextDocument ;
-                 nie:url ?url.
-          }
-          """)
-
-    def __get_parent_urn (self, filepath):
-        result = self.tracker.query ("""
-          SELECT nfo:belongsToContainer(?u) WHERE {
-              ?u a nfo:FileDataObject ;
-                 nie:url \"%s\" .
-          }
-          """ % (uri (filepath)))
-        self.assertEquals (len (result), 1)
-        return result[0][0]
-
-    def __get_file_urn (self, filepath):
-        result = self.tracker.query ("""
-          SELECT ?u WHERE {
-              ?u a nfo:FileDataObject ;
-                 nie:url \"%s\" .
-          }
-          """ % (uri (filepath)))
-        self.assertEquals (len (result), 1)
-        return result[0][0]
+
+    @classmethod
+    def setUpClass (self):
+        self._create_test_data_simple ()
+
+        self.system = TrackerSystemAbstraction ()
+        self.system.tracker_miner_fs_testing_start (CONF_OPTIONS)
+        self.system.tracker_miner_fs_wait_for_idle ()
+        self.store = self.system.store
+
+    @classmethod
+    def tearDownClass (self):
+        self.system.tracker_miner_fs_testing_stop ()
 
     def tearDown (self):
         # Give it a 2 seconds chance
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         if (len (result) != 3):
             time.sleep (2)
         else:
             return
 
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         if (len (result) != 3):
             print "WARNING: Previous test has modified the test files and didn't restore the origina state."
 
@@ -86,12 +83,12 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         """
         # Maybe the information hasn't been committed yet
         time.sleep (1)
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 3)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/file2.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/file2.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
 
         # We don't check (yet) folders, because Applications module is injecting results
 
@@ -112,13 +109,13 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         self.system.tracker_miner_fs_wait_for_idle ()
 
         # verify if miner indexed this file.
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 4)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/file2.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/file0.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/file2.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file0.txt"), unpacked_result)
 
         # Clean the new file so the test directory is as before
         log ("Remove and wait")
@@ -138,12 +135,12 @@ class MinerCrawlTest (CommonTrackerMinerTest):
 
         time.sleep (1)
         # Nothing changed
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 3, "Results:" + str(result))
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/file2.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/file2.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
 
         # Clean the file
         os.remove (dest)
@@ -157,18 +154,18 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         shutil.copyfile (source, dest)
         self.system.tracker_miner_fs_wait_for_idle ()
 
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 4)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/file2.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file-test04.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/file2.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file-test04.txt"), unpacked_result)
 
         # Clean the file
         os.remove (dest)
         self.system.tracker_miner_fs_wait_for_idle ()
-        self.assertEquals (3, self.tracker.count_instances ("nfo:TextDocument"))
+        self.assertEquals (3, self.store.count_instances ("nfo:TextDocument"))
 
 
     def test_05_move_from_unmonitored_to_monitored (self):
@@ -180,18 +177,18 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         shutil.move (source, dest)
         self.system.tracker_miner_fs_wait_for_idle ()
 
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 4)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/file2.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/file-test05.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/file2.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/file-test05.txt"), unpacked_result)
 
         # Clean the file
         os.remove (dest)
         self.system.tracker_miner_fs_wait_for_idle ()
-        self.assertEquals (3, self.tracker.count_instances ("nfo:TextDocument"))
+        self.assertEquals (3, self.store.count_instances ("nfo:TextDocument"))
 
 ## """ move operation and tracker-miner response test cases """
 ## class move(TestUpdate):
@@ -206,16 +203,16 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         shutil.move (source, dest)
         self.system.tracker_miner_fs_wait_for_idle ()
 
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 2)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
 
         # Restore the file
         shutil.move (dest, source)
         self.system.tracker_miner_fs_wait_for_idle ()
-        self.assertEquals (3, self.tracker.count_instances ("nfo:TextDocument"))
+        self.assertEquals (3, self.store.count_instances ("nfo:TextDocument"))
 
 
     def test_07_move_from_monitored_to_monitored (self):
@@ -225,8 +222,8 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         source = os.path.join (MINER_TMP_DIR, "test-monitored", "dir1", "file2.txt")
         dest = os.path.join (MINER_TMP_DIR, "test-monitored", "file2.txt")
 
-        source_dir_urn = self.__get_file_urn (os.path.join (MINER_TMP_DIR, "test-monitored", "dir1"))
-        parent_before = self.__get_parent_urn (source)
+        source_dir_urn = self._get_file_urn (os.path.join (MINER_TMP_DIR, "test-monitored", "dir1"))
+        parent_before = self._get_parent_urn (source)
         self.assertEquals (source_dir_urn, parent_before)
 
         shutil.move (source, dest)
@@ -234,26 +231,26 @@ class MinerCrawlTest (CommonTrackerMinerTest):
 
         # Checking fix for NB#214413: After a move operation, nfo:belongsToContainer
         # should be changed to the new one
-        dest_dir_urn = self.__get_file_urn (os.path.join (MINER_TMP_DIR, "test-monitored"))
-        parent_after = self.__get_parent_urn (dest)
+        dest_dir_urn = self._get_file_urn (os.path.join (MINER_TMP_DIR, "test-monitored"))
+        parent_after = self._get_parent_urn (dest)
         self.assertNotEquals (parent_before, parent_after)
         self.assertEquals (dest_dir_urn, parent_after)
 
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 3)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/file2.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file2.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
 
         # Restore the file
         shutil.move (dest, source)
         self.system.tracker_miner_fs_wait_for_idle ()
 
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 3)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/dir1/file2.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/file2.txt"), unpacked_result)
 
 
     def test_08_deletion_single_file (self):
@@ -264,11 +261,11 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         os.remove (victim)
         self.system.tracker_miner_fs_wait_for_idle ()
 
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 2)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
-        self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/dir1/dir2/file3.txt"), unpacked_result)
 
         # Restore the file
         f = open (victim, "w")
@@ -284,10 +281,10 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         shutil.rmtree (victim)
         self.system.tracker_miner_fs_wait_for_idle ()
 
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 1)
         unpacked_result = [ r[0] for r in result]
-        self.assertIn ( uri ("test-monitored/file1.txt"), unpacked_result)
+        self.assertIn ( get_test_uri ("test-monitored/file1.txt"), unpacked_result)
 
         # Restore the dirs
         #  Wait after each operation to be sure of the results
@@ -307,9 +304,10 @@ class MinerCrawlTest (CommonTrackerMinerTest):
         self.system.tracker_miner_fs_wait_for_idle (3)
 
         # Check everything is fine
-        result = self.__get_text_documents ()
+        result = self._get_text_documents ()
         self.assertEquals (len (result), 3)
 
+
 if __name__ == "__main__":
     print """
      Tests for Copy/move/delete operations of FILES between monitored/unmonitored locations.
diff --git a/tests/functional-tests/301-miner-resource-removal.py b/tests/functional-tests/301-miner-resource-removal.py
index 506e8d457..d95aad604 100755
--- a/tests/functional-tests/301-miner-resource-removal.py
+++ b/tests/functional-tests/301-miner-resource-removal.py
@@ -23,8 +23,8 @@ especially in the case where nie:InformationElement != nie:DataObject
 """
 
 from common.utils import configuration as cfg
-from common.utils.dconf import DConfClient
 from common.utils.helpers import MinerFsHelper, StoreHelper, ExtractorHelper, log
+from common.utils.minertest import CommonTrackerMinerTest, MINER_TMP_DIR, get_test_uri, get_test_path
 from common.utils.system import TrackerSystemAbstraction
 
 import dbus
@@ -33,14 +33,6 @@ import os
 import shutil
 import unittest2 as ut
 
-MINER_TMP_DIR = cfg.TEST_MONITORED_TMP_DIR
-
-def get_test_path (filename):
-    return os.path.join (MINER_TMP_DIR, filename)
-
-def get_test_uri (filename):
-    return "file://" + os.path.join (MINER_TMP_DIR, filename)
-
 
 CONF_OPTIONS = [
     (cfg.DCONF_MINER_SCHEMA, "enable-writeback", "false"),
@@ -53,7 +45,7 @@ CONF_OPTIONS = [
 
 REASONABLE_TIMEOUT = 30
 
-class MinerResourceRemovalTest (ut.TestCase):
+class MinerResourceRemovalTest (CommonTrackerMinerTest):
     graph_updated_handler_id = 0
 
     # Use the same instances of store and miner-fs for the whole test suite,
@@ -303,30 +295,6 @@ class MinerResourceRemovalTest (ut.TestCase):
         self.assertResourceExists (file_2_urn)
         self.assertResourceExists (ie_2_urn)
 
-    def test_02_removable_device_data (self):
-        """
-        Tracker does periodic cleanups of data on removable volumes that haven't
-        been seen since 'removable-days-threshold', and will also remove all data
-        from removable volumes if 'index-removable-devices' is disabled.
-
-        FIXME: not yet possible to test this - we need some way of mounting
-        a fake removable volume: https://bugzilla.gnome.org/show_bug.cgi?id=659739
-        """
-
-        #dconf = DConfClient ()
-        #dconf.write (cfg.DCONF_MINER_SCHEMA, 'index-removable-devices', 'true')
-
-        #self.mount_test_removable_volume ()
-
-        #self.add_test_resource ("urn:test:1", test_volume_urn)
-        #self.add_test_resource ("urn:test:2", None)
-
-        # Trigger removal of all resources from removable devices
-        #dconf.write (cfg.DCONF_MINER_SCHEMA, 'index-removable-devices', 'false')
-
-        # Check that only the data on the removable volume was deleted
-        #self.await_updates (2)
-
 
 if __name__ == "__main__":
     ut.main()
diff --git a/tests/functional-tests/common/utils/helpers.py b/tests/functional-tests/common/utils/helpers.py
index d0b1a8177..1301b3faa 100644
--- a/tests/functional-tests/common/utils/helpers.py
+++ b/tests/functional-tests/common/utils/helpers.py
@@ -331,28 +331,35 @@ class MinerFsHelper (Helper):
         if (status == "Idle"):
             self.loop.quit ()
 
+    def _device_completed_cb (self):
+        self.completed_devices += 1
+
+        if self.awaiting_device == True:
+            self.awaiting_device = False
+            self.loop.quit ()
+
     def start (self):
         Helper.start (self)
 
-        self.status_match = self.bus.add_signal_receiver (self._minerfs_status_cb,
-                                                          signal_name="Progress",
-                                                          path=cfg.MINERFS_OBJ_PATH,
-                                                          dbus_interface=cfg.MINER_IFACE)
-
-        # It should step out of this loop after progress changes to "Idle"
-        self.timeout_id = glib.timeout_add_seconds (REASONABLE_TIMEOUT, self._timeout_on_idle_cb)
-        self.loop.run ()
-        glib.source_remove (self.timeout_id)
+        self.device_completed_id = self.bus.add_signal_receiver (self._device_completed_cb,
+                                                                 signal_name="DeviceCompleted",
+                                                                 path=cfg.MINERFS_OBJ_PATH,
+                                                                 dbus_interface=cfg.MINER_IFACE)
 
         bus_object = self.bus.get_object (cfg.MINERFS_BUSNAME,
                                           cfg.MINERFS_OBJ_PATH)
         self.miner_fs = dbus.Interface (bus_object,
                                         dbus_interface = cfg.MINER_IFACE)
 
+        self.wait_for_idle ()
+
+        self.completed_devices = 0
+        self.awaiting_device = False
+
     def stop (self):
         Helper.stop (self)
 
-        self.bus._clean_up_signal_match (self.status_match)
+        self.bus._clean_up_signal_match (self.device_completed_id)
 
     def ignore (self, filelist):
         self.miner_fs.IgnoreNextUpdate (filelist)
@@ -366,13 +373,39 @@ class MinerFsHelper (Helper):
                                                           signal_name="Progress",
                                                           path=cfg.MINERFS_OBJ_PATH,
                                                           dbus_interface=cfg.MINER_IFACE)
-        self.timeout_id = glib.timeout_add_seconds (REASONABLE_TIMEOUT, self._timeout_on_idle_cb)
+
+        self.timeout_id = glib.timeout_add_seconds (timeout, self._timeout_on_idle_cb)
+
+        log ("Wait for idle ...")
+
+        # FIXME: check self.miner_fs.GetStatus() != "Idle" before running the
+        # loop, but ONLY if we're sure the miner will already be running ...
+        # when waiting for notifications, don't.
+        # Actually, you should adapt your GraphUpdated code for 301 rather
+        # than using that hack.
 
         self.loop.run ()
 
         glib.source_remove (self.timeout_id)
         self.bus._clean_up_signal_match (self.status_match)
 
+    def wait_for_device_complete (self, timeout=REASONABLE_TIMEOUT):
+        """
+        Block until we receive notification of a device having completed.
+        Returns True on success, False on timeout.
+        """
+        if self.completed_devices == 0:
+            self.awaiting_device = True
+            self.timeout_id = glib.timeout_add_seconds (timeout, self._timeout_on_idle_cb)
+            self.loop.run ()
+            glib.source_remove (self.timeout_id)
+
+        if self.completed_devices == 0:
+            return False
+
+        self.completed_devices -= 1
+        return True
+
 
 class ExtractorHelper (Helper):
 
diff --git a/tests/functional-tests/common/utils/minertest.py b/tests/functional-tests/common/utils/minertest.py
index 8651b05ed..7be1bd8b4 100644
--- a/tests/functional-tests/common/utils/minertest.py
+++ b/tests/functional-tests/common/utils/minertest.py
@@ -17,38 +17,29 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 # 02110-1301, USA.
 #
+
 from common.utils import configuration as cfg
-from common.utils.system import TrackerSystemAbstraction
 from common.utils.helpers import StoreHelper
-import unittest2 as ut
+from common.utils.system import TrackerSystemAbstraction
 
 import shutil
 import os
+import unittest2 as ut
 
 MINER_TMP_DIR = cfg.TEST_MONITORED_TMP_DIR
 
-def path (filename):
+def get_test_path (filename):
     return os.path.join (MINER_TMP_DIR, filename)
 
-def uri (filename):
+def get_test_uri (filename):
     return "file://" + os.path.join (MINER_TMP_DIR, filename)
 
-
 DEFAULT_TEXT = "Some stupid content, to have a test file"
 
-CONF_OPTIONS = [
-    (cfg.DCONF_MINER_SCHEMA, "index-recursive-directories", [os.path.join (MINER_TMP_DIR, "test-monitored")]),
-    (cfg.DCONF_MINER_SCHEMA, "index-single-directories", "[]"),
-    (cfg.DCONF_MINER_SCHEMA, "index-optical-discs", "false"),
-    (cfg.DCONF_MINER_SCHEMA, "index-removable-devices", "false"),
-    (cfg.DCONF_MINER_SCHEMA, "throttle", 5)
-    ]
-
-
 class CommonTrackerMinerTest (ut.TestCase):
 
     @classmethod
-    def __prepare_directories (self):
+    def _create_test_data_simple (self):
         #
         #     ~/test-monitored/
         #                     /file1.txt
@@ -82,26 +73,53 @@ class CommonTrackerMinerTest (ut.TestCase):
             f.write (DEFAULT_TEXT)
             f.close ()
 
-    
-    @classmethod 
-    def setUpClass (self):
-        #print "Starting the daemon in test mode"
-        self.__prepare_directories ()
-        
-        self.system = TrackerSystemAbstraction ()
-
-        if (os.path.exists (os.getcwd() + "/test-configurations/miner-basic-ops")):
-            # Use local directory if available
-            confdir = os.getcwd() + "/test-configurations/miner-basic-ops"
-        else:
-            confdir = os.path.join (cfg.DATADIR, "tracker-tests",
-                                    "test-configurations", "miner-basic-ops")
-        self.system.tracker_miner_fs_testing_start (CONF_OPTIONS)
-        self.system.tracker_miner_fs_wait_for_idle ()
-        self.tracker = self.system.store
-        
     @classmethod
-    def tearDownClass (self):
-        #print "Stopping the daemon in test mode (Doing nothing now)"
-        self.system.tracker_miner_fs_testing_stop ()
+    def _create_test_data_many_files (self):
+        # Create 10000 text files, so extraction takes a long time.
+
+        directory = os.path.join (MINER_TMP_DIR, 'slow-extraction-data')
+        #if (os.path.exists (directory)):
+        #    shutil.rmtree (directory)
+        if not os.path.exists (directory):
+            os.makedirs (directory)
+
+        # Extraction of 10,000 text files takes about 10 seconds on my system;
+        # this is long enough to be able to detect bugs in extraction.
+        # A more robust solution would be to create a mock subclass of
+        # TrackerMinerFS in C and make it block in the process_files() callback.
+        for i in range(10000):
+            testfile = os.path.join (directory, "test-%i.txt" % i)
+            if not os.path.exists (testfile):
+                #    os.remove (testfile)
+                f = open (testfile, 'w')
+                f.write (DEFAULT_TEXT)
+                f.close ()
+
+
+    def _get_text_documents (self):
+        return self.store.query ("""
+          SELECT ?url WHERE {
+              ?u a nfo:TextDocument ;
+                 nie:url ?url.
+          }
+          """)
+
+    def _get_parent_urn (self, filepath):
+        result = self.store.query ("""
+          SELECT nfo:belongsToContainer(?u) WHERE {
+              ?u a nfo:FileDataObject ;
+                 nie:url \"%s\" .
+          }
+          """ % (get_test_uri (filepath)))
+        self.assertEquals (len (result), 1)
+        return result[0][0]
 
+    def _get_file_urn (self, filepath):
+        result = self.store.query ("""
+          SELECT ?u WHERE {
+              ?u a nfo:FileDataObject ;
+                 nie:url \"%s\" .
+          }
+          """ % (get_test_uri (filepath)))
+        self.assertEquals (len (result), 1)
+        return result[0][0]
diff --git a/tests/functional-tests/common/utils/system.py b/tests/functional-tests/common/utils/system.py
index 3490b64de..f9b10a859 100644
--- a/tests/functional-tests/common/utils/system.py
+++ b/tests/functional-tests/common/utils/system.py
@@ -23,7 +23,10 @@ TEST_ENV_DIRS =  { "XDG_DATA_HOME" : os.path.join (cfg.TEST_TMP_DIR, "xdg-data-h
 
 TEST_ENV_VARS = {  "TRACKER_DISABLE_MEEGOTOUCH_LOCALE": "",
                    "LC_COLLATE": "en_GB.utf8",
-                   "DCONF_PROFILE": "trackertest"}
+                   "DCONF_PROFILE": "trackertest",
+                   # FIXME: should be tracker-0.14
+                   "GIO_EXTRA_MODULES": os.path.join (cfg.LIBDIR, 'tracker'),
+                   "GIO_USE_VOLUME_MONITOR": 'tracker-test-volume-monitor'}
 
 EXTRA_DIRS = [os.path.join (cfg.TEST_TMP_DIR, "xdg-data-home", "tracker"),
               os.path.join (cfg.TEST_TMP_DIR, "xdg-cache-home", "tracker")]