def test_02_copy_from_unmonitored_to_monitored(self):
"""
Copy an file from unmonitored directory to monitored directory
and verify if data base is updated accordingly
"""
source = os.path.join(MINER_TMP_DIR, "test-no-monitored", "file0.txt")
dest = os.path.join(MINER_TMP_DIR, "test-monitored", "file0.txt")
shutil.copyfile(source, dest)
dest_id, dest_urn = self.system.store.await_resource_inserted(
'nfo:TextDocument', uri(dest))
# verify if miner indexed this file.
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)
# Clean the new file so the test directory is as before
log("Remove and wait")
os.remove(dest)
self.system.store.await_resource_deleted(dest_id)
def test_05_move_from_unmonitored_to_monitored(self):
"""
Move a file from unmonitored to monitored directory
"""
source = os.path.join(MINER_TMP_DIR, "test-no-monitored", "file0.txt")
dest = os.path.join(MINER_TMP_DIR, "test-monitored", "dir1",
"file-test05.txt")
shutil.move(source, dest)
dest_id, dest_urn = self.system.store.await_resource_inserted(
'nfo:TextDocument', uri(dest))
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)
# Clean the file
os.remove(dest)
self.system.store.await_resource_deleted(dest_id)
self.assertEquals(3, self.tracker.count_instances("nfo:TextDocument"))
def test_09_deletion_directory (self):
"""
Delete a directory
"""
victim = path("test-monitored/dir1")
victim_id = self.system.store.get_resource_id (uri(victim))
shutil.rmtree (victim)
file_inside_victim_url = uri (os.path.join (victim, "file2.txt"))
file_inside_victim_id = self.system.store.get_resource_id (file_inside_victim_url)
self.system.store.await_resource_deleted (file_inside_victim_id)
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)
# Restore the dirs
os.makedirs (path("test-monitored/dir1"))
os.makedirs (path("test-monitored/dir1/dir2"))
for f in ["test-monitored/dir1/file2.txt",
"test-monitored/dir1/dir2/file3.txt"]:
filename = path(f)
writer = open (filename, "w")
writer.write ("Don't panic, everything is fine")
writer.close ()
self.system.store.await_resource_inserted ('nfo:TextDocument', uri(f))
# Check everything is fine
result = self.__get_text_documents ()
self.assertEquals (len (result), 3)
def test_09_deletion_directory(self):
"""
Delete a directory
"""
victim = path("test-monitored/dir1")
victim_id = self.system.store.get_resource_id(uri(victim))
shutil.rmtree(victim)
file_inside_victim_url = uri(os.path.join(victim, "file2.txt"))
file_inside_victim_id = self.system.store.get_resource_id(
file_inside_victim_url)
self.system.store.await_resource_deleted(file_inside_victim_id)
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)
# Restore the dirs
os.makedirs(path("test-monitored/dir1"))
os.makedirs(path("test-monitored/dir1/dir2"))
for f in [
"test-monitored/dir1/file2.txt",
"test-monitored/dir1/dir2/file3.txt"
]:
filename = path(f)
writer = open(filename, "w")
writer.write("Don't panic, everything is fine")
writer.close()
self.system.store.await_resource_inserted('nfo:TextDocument',
uri(f))
# Check everything is fine
result = self.__get_text_documents()
self.assertEquals(len(result), 3)
def test_02_multiple_words (self):
TEXT = "automobile with unlimited power"
self.set_text (TEXT)
results = self.search_word ("automobile")
self.assertEquals (len (results), 1)
self.assertIn (uri (self.testfile), results)
results = self.search_word ("unlimited")
self.assertEquals (len (results), 1)
self.assertIn (uri (self.testfile), results)
def test_02_multiple_words (self):
TEXT = "automobile with unlimited power"
self.set_text (TEXT)
results = self.search_word ("automobile")
self.assertEquals (len (results), 1)
self.assertIn (uri (self.testfile), results)
results = self.search_word ("unlimited")
self.assertEquals (len (results), 1)
self.assertIn (uri (self.testfile), results)
def test_05_word_in_multiple_files (self):
# Safeguard, in the case we modify the DEFAULT_TEXT later...
assert "content" in DEFAULT_TEXT
self.set_text (DEFAULT_TEXT)
results = self.search_word ("content")
self.assertEquals (len (results), 4)
self.assertIn ( uri (self.testfile), results)
self.assertIn ( uri ("test-monitored/file1.txt"), results)
self.assertIn ( uri ("test-monitored/dir1/file2.txt"), results)
self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), results)
def test_05_word_in_multiple_files (self):
# Safeguard, in the case we modify the DEFAULT_TEXT later...
assert "content" in DEFAULT_TEXT
self.set_text (DEFAULT_TEXT)
results = self.search_word ("content")
self.assertEquals (len (results), 4)
self.assertIn ( uri (self.testfile), results)
self.assertIn ( uri ("test-monitored/file1.txt"), results)
self.assertIn ( uri ("test-monitored/dir1/file2.txt"), results)
self.assertIn ( uri ("test-monitored/dir1/dir2/file3.txt"), results)
def test_01_initial_crawling (self):
"""
The precreated files and folders should be there
"""
# Maybe the information hasn't been committed yet
time.sleep (1)
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)
def test_01_initial_crawling(self):
"""
The precreated files and folders should be there
"""
# Maybe the information hasn't been committed yet
time.sleep(1)
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)
def test_09_deletion_directory (self):
"""
Delete a directory
"""
victim = os.path.join (MINER_TMP_DIR, "test-monitored", "dir1")
shutil.rmtree (victim)
self.system.tracker_miner_fs_wait_for_idle ()
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)
# Restore the dirs
# Wait after each operation to be sure of the results
os.makedirs (os.path.join (MINER_TMP_DIR, "test-monitored", "dir1"))
self.system.tracker_miner_fs_wait_for_idle ()
os.makedirs (os.path.join (MINER_TMP_DIR, "test-monitored", "dir1", "dir2"))
self.system.tracker_miner_fs_wait_for_idle ()
for f in ["test-monitored/dir1/file2.txt",
"test-monitored/dir1/dir2/file3.txt"]:
filename = os.path.join (MINER_TMP_DIR, f)
writer = open (filename, "w")
writer.write ("Don't panic, everything is fine")
writer.close ()
self.system.tracker_miner_fs_wait_for_idle ()
# Wait a bit more... some time one idle is not enough
self.system.tracker_miner_fs_wait_for_idle (3)
# Check everything is fine
result = self.__get_text_documents ()
self.assertEquals (len (result), 3)
def test_reextraction(self):
"""Tests whether known files are still re-extracted on user request."""
miner_fs = self.system.miner_fs
store = self.system.store
# Insert a valid file and wait extraction of its metadata.
file_path = os.path.join(MINER_TMP_DIR, os.path.basename(VALID_FILE))
shutil.copy(VALID_FILE, file_path)
file_id, file_urn = store.await_resource_inserted(
VALID_FILE_CLASS, title=VALID_FILE_TITLE)
# Remove a key piece of metadata.
store.update(
'DELETE { <%s> nie:title ?title }'
' WHERE { <%s> nie:title ?title }' % (file_urn, file_urn))
store.await_property_changed(file_id, 'nie:title')
assert not store.ask('ASK { <%s> nie:title ?title }' % file_urn)
log("Sending re-index request")
# Request re-indexing (same as `tracker index --file ...`)
miner_fs.index_file(uri(file_path))
# The extractor should reindex the file and re-add the metadata that we
# deleted, so we should see the nie:title property change.
store.await_property_changed(file_id, 'nie:title')
title_result = store.query('SELECT ?title { <%s> nie:title ?title }' % file_urn)
assert len(title_result) == 1
self.assertEqual(title_result[0][0], VALID_FILE_TITLE)
def test_05_move_file_unmonitored_monitored (self):
"""
Move file from unmonitored location to monitored location and index should be updated
"""
TEXT = "airplane is beautiful"
TEST_16_SOURCE = "test-no-monitored/fts-indexing-text-16.txt"
TEST_16_DEST = "test-monitored/fts-indexing-text-16.txt"
self.__recreate_file (path (TEST_16_SOURCE), TEXT)
# the file is supposed to be ignored by tracker, so there is no notification..
time.sleep (5)
results = self.search_word ("airplane")
self.assertEquals (len (results), 0)
shutil.copyfile ( path (TEST_16_SOURCE), path (TEST_16_DEST))
self.tracker.await_resource_inserted (rdf_class = 'nfo:Document',
url = uri(TEST_16_DEST),
required_property = 'nie:plainTextContent')
results = self.search_word ("airplane")
self.assertEquals (len (results), 1)
os.remove ( path (TEST_16_SOURCE))
os.remove ( path (TEST_16_DEST))
def set_text (self, text):
f = open (path (self.testfile), "w")
f.write (text)
f.close ()
self.tracker.await_resource_inserted (rdf_class = 'nfo:Document',
url = uri (self.testfile))
self.tracker.reset_graph_updates_tracking ()
def test_05_move_file_unmonitored_monitored (self):
"""
Move file from unmonitored location to monitored location and index should be updated
"""
# Maybe the miner hasn't finished yet with the setUp deletion!
self.system.tracker_miner_fs_wait_for_idle ()
TEXT = "airplane is beautiful"
TEST_16_SOURCE = "test-no-monitored/fts-indexing-text-16.txt"
TEST_16_DEST = "test-monitored/fts-indexing-text-16.txt"
self.__recreate_file (path (TEST_16_SOURCE), TEXT)
# the file is supposed to be ignored by tracker, so there is no notification..
time.sleep (5)
results = self.search_word ("airplane")
self.assertEquals (len (results), 0)
shutil.copyfile ( path (TEST_16_SOURCE), path (TEST_16_DEST))
self.tracker.await_resource_inserted (rdf_class = 'nfo:Document',
url = uri (TEST_16_DEST))
results = self.search_word ("airplane")
self.assertEquals (len (results), 1)
os.remove ( path (TEST_16_SOURCE))
os.remove ( path (TEST_16_DEST))
def test_reextraction(self):
"""Tests whether known files are still re-extracted on user request."""
miner_fs = self.system.miner_fs
store = self.system.store
# Insert a valid file and wait extraction of its metadata.
file_path = os.path.join(MINER_TMP_DIR, os.path.basename(VALID_FILE))
shutil.copy(VALID_FILE, file_path)
file_id, file_urn = store.await_resource_inserted(
VALID_FILE_CLASS, title=VALID_FILE_TITLE)
# Remove a key piece of metadata.
store.update('DELETE { <%s> nie:title ?title }'
' WHERE { <%s> nie:title ?title }' % (file_urn, file_urn))
store.await_property_changed(file_id, 'nie:title')
assert not store.ask('ASK { <%s> nie:title ?title }' % file_urn)
log("Sending re-index request")
# Request re-indexing (same as `tracker index --file ...`)
miner_fs.index_file(uri(file_path))
# The extractor should reindex the file and re-add the metadata that we
# deleted, so we should see the nie:title property change.
store.await_property_changed(file_id, 'nie:title')
title_result = store.query('SELECT ?title { <%s> nie:title ?title }' %
file_urn)
assert len(title_result) == 1
self.assertEqual(title_result[0][0], VALID_FILE_TITLE)
def setUp (self):
self.tracker.reset_graph_updates_tracking ()
self.testfile = "test-monitored/miner-fts-test.txt"
if os.path.exists (path (self.testfile)):
id = self._query_id (uri (self.testfile))
os.remove (path (self.testfile))
self.tracker.await_resource_deleted (id)
self.tracker.reset_graph_updates_tracking ()
def set_text (self, text):
exists = os.path.exists(path(self.testfile))
f = open (path (self.testfile), "w")
f.write (text)
f.close ()
if exists:
subject_id = self.tracker.get_resource_id(uri(self.testfile))
self.tracker.await_property_changed(
subject_id=subject_id, property_uri='nie:plainTextContent')
else:
self.tracker.await_resource_inserted(
rdf_class='nfo:Document', url=uri(self.testfile),
required_property='nie:plainTextContent')
self.tracker.reset_graph_updates_tracking()
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]
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 create_test_file(self, file_name):
file_path = path(file_name)
file = open(file_path, 'w')
file.write("Test")
file.close()
return self.tracker.await_resource_inserted(rdf_class='nfo:Document',
url=uri(file_name))
def create_test_file (self, file_name):
file_path = path(file_name)
file = open (file_path, 'w')
file.write ("Test")
file.close ()
return self.tracker.await_resource_inserted (rdf_class = 'nfo:Document',
url = uri(file_name))
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]
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 test_08_deletion_single_file (self):
"""
Delete one of the files
"""
victim = os.path.join (MINER_TMP_DIR, "test-monitored", "dir1", "file2.txt")
os.remove (victim)
self.system.tracker_miner_fs_wait_for_idle ()
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)
# Restore the file
f = open (victim, "w")
f.write ("Don't panic, everything is fine")
f.close ()
self.system.tracker_miner_fs_wait_for_idle ()
def test_06_move_from_monitored_to_unmonitored (self):
"""
Move a file from monitored to unmonitored directory
"""
source = os.path.join (MINER_TMP_DIR, "test-monitored", "dir1", "file2.txt")
dest = os.path.join (MINER_TMP_DIR, "test-no-monitored", "file2.txt")
shutil.move (source, dest)
self.system.tracker_miner_fs_wait_for_idle ()
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)
# Restore the file
shutil.move (dest, source)
self.system.tracker_miner_fs_wait_for_idle ()
self.assertEquals (3, self.tracker.count_instances ("nfo:TextDocument"))
def test_08_deletion_single_file (self):
"""
Delete one of the files
"""
victim = path("test-monitored/dir1/file2.txt")
victim_id = self.system.store.get_resource_id (uri(victim))
os.remove (victim)
self.system.store.await_resource_deleted (victim_id)
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)
# Restore the file
f = open (victim, "w")
f.write ("Don't panic, everything is fine")
f.close ()
self.system.store.await_resource_inserted ('nfo:TextDocument', uri(victim))
def test_06_move_from_monitored_to_unmonitored (self):
"""
Move a file from monitored to unmonitored directory
"""
source = path("test-monitored/dir1/file2.txt")
dest = path("test-no-monitored/file2.txt")
source_id = self.system.store.get_resource_id (uri(source))
shutil.move (source, dest)
self.system.store.await_resource_deleted (source_id)
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)
# Restore the file
shutil.move (dest, source)
self.system.store.await_resource_inserted ('nfo:TextDocument', uri(source))
self.assertEquals (3, self.tracker.count_instances ("nfo:TextDocument"))
def test_04_copy_from_monitored_to_monitored (self):
"""
Copy a file between monitored directories
"""
source = os.path.join (MINER_TMP_DIR, "test-monitored", "file1.txt")
dest = os.path.join (MINER_TMP_DIR, "test-monitored", "dir1", "dir2", "file-test04.txt")
shutil.copyfile (source, dest)
self.system.tracker_miner_fs_wait_for_idle ()
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)
# Clean the file
os.remove (dest)
self.system.tracker_miner_fs_wait_for_idle ()
self.assertEquals (3, self.tracker.count_instances ("nfo:TextDocument"))
def test_05_move_from_unmonitored_to_monitored (self):
"""
Move a file from unmonitored to monitored directory
"""
source = os.path.join (MINER_TMP_DIR, "test-no-monitored", "file0.txt")
dest = os.path.join (MINER_TMP_DIR, "test-monitored", "dir1", "file-test05.txt")
shutil.move (source, dest)
dest_id, dest_urn = self.system.store.await_resource_inserted ('nfo:TextDocument', uri(dest))
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)
# Clean the file
os.remove (dest)
self.system.store.await_resource_deleted (dest_id)
self.assertEquals (3, self.tracker.count_instances ("nfo:TextDocument"))
def basic_test (self, text, word):
"""
Save the text on the testfile, search the word
and assert the testfile is only result.
Be careful with the default contents of the text files
( see common/utils/minertest.py DEFAULT_TEXT )
"""
self.set_text (text)
results = self.search_word (word)
self.assertEquals (len (results), 1)
self.assertIn ( uri (self.testfile), results)
def basic_test (self, text, word):
"""
Save the text on the testfile, search the word
and assert the testfile is only result.
Be careful with the default contents of the text files
( see common/utils/minertest.py DEFAULT_TEXT )
"""
self.set_text (text)
results = self.search_word (word)
self.assertEquals (len (results), 1)
self.assertIn ( uri (self.testfile), results)
def test_07_move_from_monitored_to_monitored(self):
"""
Move a file between monitored directories
"""
source = path("test-monitored/dir1/file2.txt")
dest = path("test-monitored/file2.txt")
resource_id = self.tracker.get_resource_id(url=uri(source))
source_dir_urn = self.__get_file_urn(os.path.dirname(source))
parent_before = self.__get_parent_urn(source)
self.assertEquals(source_dir_urn, parent_before)
shutil.move(source, dest)
self.tracker.await_property_changed(resource_id, 'nie:url')
# 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.dirname(dest))
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()
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)
# Restore the file
shutil.move(dest, source)
self.tracker.await_property_changed(resource_id, 'nie:url')
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)
def test_06_move_from_monitored_to_unmonitored(self):
"""
Move a file from monitored to unmonitored directory
"""
source = path("test-monitored/dir1/file2.txt")
dest = path("test-no-monitored/file2.txt")
source_id = self.system.store.get_resource_id(uri(source))
shutil.move(source, dest)
self.system.store.await_resource_deleted(source_id)
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)
# Restore the file
shutil.move(dest, source)
self.system.store.await_resource_inserted('nfo:TextDocument',
uri(source))
self.assertEquals(3, self.tracker.count_instances("nfo:TextDocument"))
def test_08_deletion_single_file(self):
"""
Delete one of the files
"""
victim = path("test-monitored/dir1/file2.txt")
victim_id = self.system.store.get_resource_id(uri(victim))
os.remove(victim)
self.system.store.await_resource_deleted(victim_id)
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)
# Restore the file
f = open(victim, "w")
f.write("Don't panic, everything is fine")
f.close()
self.system.store.await_resource_inserted('nfo:TextDocument',
uri(victim))
def test_03_copy_from_monitored_to_unmonitored (self):
"""
Copy an file from a monitored location to an unmonitored location
Nothing should change
"""
# Copy from monitored to unmonitored
source = os.path.join (MINER_TMP_DIR, "test-monitored", "file1.txt")
dest = os.path.join (MINER_TMP_DIR, "test-no-monitored", "file1.txt")
shutil.copyfile (source, dest)
time.sleep (1)
# Nothing changed
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)
# Clean the file
os.remove (dest)
def test_07_move_from_monitored_to_monitored (self):
"""
Move a file between monitored directories
"""
source = path("test-monitored/dir1/file2.txt")
dest = path("test-monitored/file2.txt")
resource_id = self.tracker.get_resource_id(url=uri(source))
source_dir_urn = self.__get_file_urn (os.path.dirname(source))
parent_before = self.__get_parent_urn (source)
self.assertEquals (source_dir_urn, parent_before)
shutil.move (source, dest)
self.tracker.await_property_changed(resource_id, 'nie:url')
# 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.dirname(dest))
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 ()
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)
# Restore the file
shutil.move (dest, source)
self.tracker.await_property_changed(resource_id, 'nie:url')
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)
def test_01_removal_of_file (self):
"""
When removing the file, its text contents disappear from the index
"""
TEXT = "automobile is red and big and whatnot"
self.basic_test (TEXT, "automobile")
id = self._query_id (uri (self.testfile))
os.remove ( path (self.testfile))
self.tracker.await_resource_deleted (id)
results = self.search_word ("automobile")
self.assertEquals (len (results), 0)
def test_02_copy_from_unmonitored_to_monitored (self):
"""
Copy an file from unmonitored directory to monitored directory
and verify if data base is updated accordingly
"""
source = os.path.join (MINER_TMP_DIR, "test-no-monitored", "file0.txt")
dest = os.path.join (MINER_TMP_DIR, "test-monitored", "file0.txt")
shutil.copyfile (source, dest)
self.system.tracker_miner_fs_wait_for_idle ()
# verify if miner indexed this file.
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)
# Clean the new file so the test directory is as before
log ("Remove and wait")
os.remove (dest)
self.system.tracker_miner_fs_wait_for_idle ()
def test_03_copy_from_monitored_to_unmonitored(self):
"""
Copy an file from a monitored location to an unmonitored location
Nothing should change
"""
# Copy from monitored to unmonitored
source = os.path.join(MINER_TMP_DIR, "test-monitored", "file1.txt")
dest = os.path.join(MINER_TMP_DIR, "test-no-monitored", "file1.txt")
shutil.copyfile(source, dest)
time.sleep(1)
# Nothing changed
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)
# Clean the file
os.remove(dest)
def test_07_move_from_monitored_to_monitored (self):
"""
Move a file between monitored directories
"""
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)
self.assertEquals (source_dir_urn, parent_before)
shutil.move (source, dest)
self.system.tracker_miner_fs_wait_for_idle ()
# 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)
self.assertNotEquals (parent_before, parent_after)
self.assertEquals (dest_dir_urn, parent_after)
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)
# Restore the file
shutil.move (dest, source)
self.system.tracker_miner_fs_wait_for_idle ()
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)
