rer.solrpush 1.3.4__py3-none-any.whl

rer/solrpush/tests/test_search.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+"""Setup tests for this package."""
+from plone import api
+from plone.api.portal import set_registry_record
+from plone.app.testing import setRoles
+from plone.app.testing import TEST_USER_ID
+from rer.solrpush.interfaces.settings import IRerSolrpushSettings
+from rer.solrpush.utils import init_solr_push
+from rer.solrpush.utils import reset_solr
+from rer.solrpush.utils import search
+from rer.solrpush.utils.solr_search import escape_special_characters
+from rer.solrpush.testing import (
+    RER_SOLRPUSH_API_FUNCTIONAL_TESTING,
+)  # noqa: E501
+from transaction import commit
+
+import unittest
+
+
+class TestSearch(unittest.TestCase):
+    """Test show in search field behavior."""
+
+    layer = RER_SOLRPUSH_API_FUNCTIONAL_TESTING
+
+    def setUp(self):
+        """
+        We create objects before initializing solr settings, so solr core is
+        always empty on setUp.
+        """
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        set_registry_record(
+            "enabled_types",
+            [u"Document", u"News Item"],
+            interface=IRerSolrpushSettings,
+        )
+        init_solr_push()
+        # set_registry_record("active", True, interface=IRerSolrpushSettings)
+        self.docs = {}
+        for i in range(20):
+            searchwords = []
+            id = "doc-%03d" % i
+            if i == 5:
+                id = "odd"
+                title = "Document %s" % i
+                searchwords = ["odd"]
+            elif i % 2 == 0:
+                title = "Document %s even even" % i
+            else:
+                title = "Document %s odd odd" % i
+            obj = self.docs[i] = api.content.create(
+                container=self.portal,
+                type="Document",
+                id=id,
+                title=title,
+                searchwords=searchwords,
+            )
+            # obj.reindexObject(idxs=['Title'])
+            api.content.transition(obj=obj, transition="publish")
+        commit()
+
+    def tearDown(self):
+        reset_solr()
+        set_registry_record("qf", u"", interface=IRerSolrpushSettings)
+        set_registry_record("bq", u"", interface=IRerSolrpushSettings)
+        set_registry_record("bf", u"", interface=IRerSolrpushSettings)
+        commit()
+
+    def test_all_items(self):
+        solr_results = search(query={}, fl="UID")
+        self.assertEqual(solr_results.hits, len(self.docs))
+
+    def test_search_odd(self):
+        solr_results = search(query={"SearchableText": "odd"}, fl="UID")
+        self.assertEqual(solr_results.hits, len(self.docs) / 2)
+
+    def test_search_qf(self):
+        solr_results = search(query={"": "odd"}, fl=["UID", "id", "Title"])
+        self.assertEqual(solr_results.hits, len(self.docs) / 2)
+        self.assertNotEqual(solr_results.docs[0]["id"], "odd")
+
+        set_registry_record(
+            "qf",
+            u"id^1000.0 SearchableText^1.0",
+            interface=IRerSolrpushSettings,
+        )
+        commit()
+        solr_results = search(query={"": "odd"}, fl=["UID", "id", "Title"])
+        self.assertEqual(solr_results.hits, len(self.docs) / 2)
+        self.assertEqual(solr_results.docs[0]["id"], "odd")
+
+    def test_search_qf_for_searchwords(self):
+        solr_results = search(query={"": "odd"}, fl=["UID", "id", "Title"])
+        self.assertEqual(solr_results.hits, len(self.docs) / 2)
+        self.assertNotEqual(solr_results.docs[0]["id"], "odd")
+
+        set_registry_record(
+            "qf",
+            u"searchwords^1000.0 SearchableText^1.0",
+            interface=IRerSolrpushSettings,
+        )
+        commit()
+
+        solr_results = search(query={"": "odd"}, fl=["UID", "id", "Title"])
+        self.assertEqual(solr_results.hits, len(self.docs) / 2)
+        self.assertEqual(solr_results.docs[0]["id"], "odd")
+
+    def test_search_bq(self):
+        solr_results = search(query={"": "odd"}, fl=["UID", "id", "Title"])
+        self.assertEqual(solr_results.hits, len(self.docs) / 2)
+        self.assertNotEqual(solr_results.docs[0]["id"], "odd")
+
+        set_registry_record("bq", u"id:odd", interface=IRerSolrpushSettings)
+        commit()
+
+        solr_results = search(query={"": "odd"}, fl=["UID", "id", "Title"])
+        self.assertEqual(solr_results.hits, len(self.docs) / 2)
+        self.assertEqual(solr_results.docs[0]["id"], "odd")
+
+    def test_escape_chars(self):
+        self.assertEqual(escape_special_characters("*:*", False), "\\*\\:\\*")
+        self.assertEqual(
+            escape_special_characters("* : *", True), '"\\* \\: \\*"'
+        )
+
+    def test_search_words_case_insensitive(self):
+        """because it's indexed as lowercase"""
+        obj = api.content.create(
+            container=self.portal,
+            type="Document",
+            id="insensitive",
+            title="Insensitive",
+            searchwords=["FOO", "bar", "bAz"],
+        )
+        api.content.transition(obj=obj, transition="publish")
+
+        commit()
+
+        self.assertEqual(
+            search(
+                query={"searchwords": "FOO"}, fl=["UID", "id", "Title"]
+            ).hits,
+            1,
+        )
+        self.assertEqual(
+            search(
+                query={"searchwords": "foo"}, fl=["UID", "id", "Title"]
+            ).hits,
+            1,
+        )
+
+        self.assertEqual(
+            search(
+                query={"searchwords": "bar"}, fl=["UID", "id", "Title"]
+            ).hits,
+            1,
+        )
+        self.assertEqual(
+            search(
+                query={"searchwords": "Bar"}, fl=["UID", "id", "Title"]
+            ).hits,
+            1,
+        )
+
+        self.assertEqual(
+            search(
+                query={"searchwords": "baz"}, fl=["UID", "id", "Title"]
+            ).hits,
+            1,
+        )
+        self.assertEqual(
+            search(
+                query={"searchwords": "BAZ"}, fl=["UID", "id", "Title"]
+            ).hits,
+            1,
+        )

rer/solrpush/tests/test_setup.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+"""Setup tests for this package."""
+from rer.solrpush.testing import (
+    RER_SOLRPUSH_API_INTEGRATION_TESTING,
+)  # noqa: E501
+from plone import api
+from plone.app.testing import setRoles
+from plone.app.testing import TEST_USER_ID
+
+import unittest
+
+try:
+    from Products.CMFPlone.utils import get_installer
+except ImportError:
+    get_installer = None
+
+
+class TestSetup(unittest.TestCase):
+    """Test that rer.solrpush is properly installed."""
+
+    layer = RER_SOLRPUSH_API_INTEGRATION_TESTING
+
+    def setUp(self):
+        """Custom shared utility setup for tests."""
+        self.portal = self.layer["portal"]
+        if get_installer:
+            self.installer = get_installer(self.portal, self.layer["request"])
+        else:
+            self.installer = api.portal.get_tool("portal_quickinstaller")
+
+    def test_product_installed(self):
+        """Test if rer.solrpush is installed."""
+        self.assertTrue(self.installer.isProductInstalled("rer.solrpush"))
+
+    def test_browserlayer(self):
+        """Test that IRerSolrpushLayer is registered."""
+        from rer.solrpush.interfaces import IRerSolrpushLayer
+        from plone.browserlayer import utils
+
+        self.assertIn(IRerSolrpushLayer, utils.registered_layers())
+
+
+class TestUninstall(unittest.TestCase):
+
+    layer = RER_SOLRPUSH_API_INTEGRATION_TESTING
+
+    def setUp(self):
+        self.portal = self.layer["portal"]
+        if get_installer:
+            self.installer = get_installer(self.portal, self.layer["request"])
+        else:
+            self.installer = api.portal.get_tool("portal_quickinstaller")
+        roles_before = api.user.get_roles(TEST_USER_ID)
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        self.installer.uninstallProducts(["rer.solrpush"])
+        setRoles(self.portal, TEST_USER_ID, roles_before)
+
+    def test_product_uninstalled(self):
+        """Test if rer.solrpush is cleanly uninstalled."""
+        self.assertFalse(self.installer.isProductInstalled("rer.solrpush"))
+
+    def test_browserlayer_removed(self):
+        """Test that IRerSolrpushLayer is removed."""
+        from rer.solrpush.interfaces import IRerSolrpushLayer
+        from plone.browserlayer import utils
+
+        self.assertNotIn(IRerSolrpushLayer, utils.registered_layers())

rer/solrpush/tests/test_solr_interface.py

@@ -0,0 +1,359 @@
+# -*- coding: utf-8 -*-
+"""Setup tests for this package."""
+from plone import api
+from plone.api.portal import set_registry_record
+from plone.app.testing import setRoles
+from plone.app.testing import TEST_USER_ID
+from rer.solrpush.interfaces.settings import IRerSolrpushSettings
+from rer.solrpush.utils import init_solr_push
+from rer.solrpush.utils import reset_solr
+from rer.solrpush.utils import search
+from rer.solrpush.utils import push_to_solr
+from rer.solrpush.utils import remove_from_solr
+from rer.solrpush.testing import RER_SOLRPUSH_API_FUNCTIONAL_TESTING
+import time
+from transaction import commit
+
+import unittest
+
+
+class TestSolrIndexActions(unittest.TestCase):
+    """Test that rer.solrpush is properly installed."""
+
+    layer = RER_SOLRPUSH_API_FUNCTIONAL_TESTING
+
+    def setUp(self):
+        """"""
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        set_registry_record(
+            "enabled_types", [u"Document"], interface=IRerSolrpushSettings
+        )
+        self.published_doc = api.content.create(
+            container=self.portal, type="Document", title="Published Document"
+        )
+        api.content.transition(obj=self.published_doc, transition="publish")
+        self.unpublished_doc = api.content.create(
+            container=self.portal,
+            type="Document",
+            title="Unpublished Document",
+        )
+        self.published_news = api.content.create(
+            container=self.portal, type="News Item", title="Published News"
+        )
+        self.unpublished_news = api.content.create(
+            container=self.portal, type="News Item", title="Unpublished News"
+        )
+        api.content.transition(obj=self.published_news, transition="publish")
+        init_solr_push()
+
+    def tearDown(self):
+        set_registry_record("active", True, interface=IRerSolrpushSettings)
+        reset_solr()
+
+    def test_push_to_solr(self):
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 0)
+
+        # try to push an indexable and published content
+        push_to_solr(self.published_doc)
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 1)
+        self.assertEqual(solr_results.docs[0]["UID"], self.published_doc.UID())
+
+        # try to push an indexable and private content
+        push_to_solr(self.unpublished_doc)
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 1)
+        self.assertEqual(solr_results.docs[0]["UID"], self.published_doc.UID())
+
+        # try to push a non indexable published content
+        push_to_solr(self.published_news)
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 1)
+        self.assertEqual(solr_results.docs[0]["UID"], self.published_doc.UID())
+
+        # try to push a non indexable private content
+        push_to_solr(self.unpublished_news)
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 1)
+        self.assertEqual(solr_results.docs[0]["UID"], self.published_doc.UID())
+
+    def test_update_content(self):
+        push_to_solr(self.published_doc)
+        solr_results = search(
+            query={"*": "*", "b_size": 100000}, fl="UID Description"
+        )
+        self.assertEqual(solr_results.hits, 1)
+        self.assertEqual(solr_results.docs[0]["UID"], self.published_doc.UID())
+        self.assertEqual(solr_results.docs[0].get("Description", ""), "")
+
+        self.published_doc.setDescription("foo description")
+        push_to_solr(self.published_doc)
+        solr_results = search(
+            query={"*": "*", "b_size": 100000}, fl="UID Description"
+        )
+        self.assertEqual(solr_results.hits, 1)
+        self.assertEqual(solr_results.docs[0]["UID"], self.published_doc.UID())
+        self.assertIn("Description", solr_results.docs[0])
+        self.assertEqual(
+            solr_results.docs[0]["Description"], "foo description"
+        )
+
+    def test_remove_from_solr(self):
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 0)
+
+        api.content.transition(obj=self.unpublished_doc, transition="publish")
+        # commit()
+        # try to push an indexable and published content
+        push_to_solr(self.published_doc)
+        push_to_solr(self.unpublished_doc)
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 2)
+        self.assertEqual(solr_results.docs[0]["UID"], self.published_doc.UID())
+
+        # try to remove content from solr
+        remove_from_solr(uid=self.published_doc.UID())
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 1)
+        self.assertEqual(
+            solr_results.docs[0]["UID"], self.unpublished_doc.UID()
+        )
+
+    def test_reset_solr(self):
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 0)
+
+        api.content.transition(obj=self.unpublished_doc, transition="publish")
+        # commit()
+        # try to push an indexable and published content
+        push_to_solr(self.published_doc)
+        push_to_solr(self.unpublished_doc)
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 2)
+        self.assertEqual(solr_results.docs[0]["UID"], self.published_doc.UID())
+
+        # cleanup catalog
+        reset_solr()
+        solr_results = search(query={"*": "*", "b_size": 100000}, fl="UID")
+        self.assertEqual(solr_results.hits, 0)
+
+
+class TestSolrSearch(unittest.TestCase):
+    """"""
+
+    layer = RER_SOLRPUSH_API_FUNCTIONAL_TESTING
+
+    def setUp(self):
+        """"""
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        set_registry_record(
+            "enabled_types",
+            [u"Document", u"News Item"],
+            interface=IRerSolrpushSettings,
+        )
+        #  initialize solr push, so solr will be populated automatically
+        # on commits
+        init_solr_push()
+        commit()
+        self.doc1 = api.content.create(
+            container=self.portal,
+            type="Document",
+            title="First Document",
+            description="lorem ipsum",
+            subject=["foo", "bar"],
+        )
+        self.doc2 = api.content.create(
+            container=self.portal,
+            type="Document",
+            title="Second Document",
+            description="lorem ipsum dolor sit amet",
+        )
+        self.unpublished_doc = api.content.create(
+            container=self.portal,
+            type="Document",
+            title="Unpublished Document",
+        )
+        self.published_news = api.content.create(
+            container=self.portal,
+            type="News Item",
+            title="Published News",
+            subject=["foo", "news category"],
+        )
+        self.unpublished_news = api.content.create(
+            container=self.portal,
+            type="News Item",
+            title="Unpublished News",
+            subject=["foo"],
+        )
+        self.event = api.content.create(
+            container=self.portal, type="Event", title="Event", subject=["foo"]
+        )
+        api.content.transition(obj=self.doc1, transition="publish")
+        # commit()
+        api.content.transition(obj=self.doc2, transition="publish")
+        # commit()
+        api.content.transition(obj=self.published_news, transition="publish")
+        # commit()
+        api.content.transition(obj=self.event, transition="publish")
+        commit()
+
+    def tearDown(self):
+        set_registry_record("active", True, interface=IRerSolrpushSettings)
+        reset_solr()
+
+    def test_search_all(self):
+        solr_results = search(query={"*": "*"})
+        # only published and indexable contents are on solr
+        self.assertEqual(solr_results.hits, 3)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertIn(self.doc1.UID(), uids)
+        self.assertIn(self.doc2.UID(), uids)
+        self.assertIn(self.published_news.UID(), uids)
+        self.assertNotIn(self.unpublished_doc.UID(), uids)
+        self.assertNotIn(self.unpublished_news.UID(), uids)
+        self.assertNotIn(self.event.UID(), uids)
+
+    def test_search_q(self):
+        solr_results = search(query={"SearchableText": "Document"})
+        self.assertEqual(solr_results.hits, 2)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertIn(self.doc1.UID(), uids)
+        self.assertIn(self.doc2.UID(), uids)
+        self.assertNotIn(self.published_news.UID(), uids)
+        self.assertNotIn(self.unpublished_doc.UID(), uids)
+        self.assertNotIn(self.unpublished_news.UID(), uids)
+        self.assertNotIn(self.event.UID(), uids)
+
+        solr_results = search(query={"SearchableText": "lorem ipsum"})
+        self.assertEqual(solr_results.hits, 2)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertIn(self.doc1.UID(), uids)
+        self.assertIn(self.doc2.UID(), uids)
+
+        solr_results = search(query={"SearchableText": "lorem amet"})
+        self.assertEqual(solr_results.hits, 1)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertNotIn(self.doc1.UID(), uids)
+        self.assertIn(self.doc2.UID(), uids)
+
+        solr_results = search(query={"SearchableText": "lorem OR amet"})
+        self.assertEqual(solr_results.hits, 2)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertIn(self.doc1.UID(), uids)
+        self.assertIn(self.doc2.UID(), uids)
+
+    def test_search_fq(self):
+        #  same result if we search by portal_type
+        solr_results = search(query={"portal_type": "Document"})
+        self.assertEqual(solr_results.hits, 2)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertIn(self.doc1.UID(), uids)
+        self.assertIn(self.doc2.UID(), uids)
+        self.assertNotIn(self.published_news.UID(), uids)
+        self.assertNotIn(self.unpublished_doc.UID(), uids)
+        self.assertNotIn(self.unpublished_news.UID(), uids)
+        self.assertNotIn(self.event.UID(), uids)
+
+        solr_results = search(query={"portal_type": "News Item"})
+        self.assertEqual(solr_results.hits, 1)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertNotIn(self.doc1.UID(), uids)
+        self.assertNotIn(self.doc2.UID(), uids)
+        self.assertIn(self.published_news.UID(), uids)
+        self.assertNotIn(self.unpublished_doc.UID(), uids)
+        self.assertNotIn(self.unpublished_news.UID(), uids)
+        self.assertNotIn(self.event.UID(), uids)
+
+        solr_results = search(query={"Subject": "foo"})
+        self.assertEqual(solr_results.hits, 2)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertIn(self.doc1.UID(), uids)
+        self.assertNotIn(self.doc2.UID(), uids)
+        self.assertIn(self.published_news.UID(), uids)
+        self.assertNotIn(self.unpublished_doc.UID(), uids)
+        self.assertNotIn(self.unpublished_news.UID(), uids)
+        self.assertNotIn(self.event.UID(), uids)
+
+        solr_results = search(query={"Subject": "bar"})
+        self.assertEqual(solr_results.hits, 1)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertIn(self.doc1.UID(), uids)
+        self.assertNotIn(self.doc2.UID(), uids)
+        self.assertNotIn(self.published_news.UID(), uids)
+        self.assertNotIn(self.unpublished_doc.UID(), uids)
+        self.assertNotIn(self.unpublished_news.UID(), uids)
+        self.assertNotIn(self.event.UID(), uids)
+
+        solr_results = search(query={"Subject": ["foo", "bar"]})
+        self.assertEqual(solr_results.hits, 2)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertIn(self.doc1.UID(), uids)
+        self.assertNotIn(self.doc2.UID(), uids)
+        self.assertIn(self.published_news.UID(), uids)
+        self.assertNotIn(self.unpublished_doc.UID(), uids)
+        self.assertNotIn(self.unpublished_news.UID(), uids)
+        self.assertNotIn(self.event.UID(), uids)
+
+        solr_results = search(query={"Subject": ["news category"]})
+        self.assertEqual(solr_results.hits, 1)
+        uids = [x["UID"] for x in solr_results.docs]
+        self.assertNotIn(self.doc1.UID(), uids)
+        self.assertNotIn(self.doc2.UID(), uids)
+        self.assertIn(self.published_news.UID(), uids)
+        self.assertNotIn(self.unpublished_doc.UID(), uids)
+        self.assertNotIn(self.unpublished_news.UID(), uids)
+        self.assertNotIn(self.event.UID(), uids)
+
+    def test_search_fl(self):
+        """
+        with fl we can select which fields solr returns for results
+        """
+        solr_results = search(query={"*": "*"})
+        self.assertEqual(solr_results.hits, 3)
+        for doc in solr_results.docs:
+            self.assertIn("UID", list(doc.keys()))
+            self.assertIn("Title", list(doc.keys()))
+
+        solr_results = search(query={"*": "*"}, fl="UID")
+        self.assertEqual(solr_results.hits, 3)
+        for doc in solr_results.docs:
+            self.assertIn("UID", list(doc.keys()))
+            self.assertNotIn("Title", list(doc.keys()))
+
+        solr_results = search(query={"*": "*"}, fl="UID Subject")
+        self.assertEqual(solr_results.hits, 3)
+        for doc in solr_results.docs:
+            self.assertIn("UID", list(doc.keys()))
+            self.assertNotIn("Title", list(doc.keys()))
+            if not api.content.get(UID=doc["UID"]).Subject():
+                self.assertNotIn("Subject", list(doc.keys()))
+            else:
+                self.assertIn("Subject", list(doc.keys()))
+
+    def test_search_sort_on(self):
+        """"""
+        # update modification date
+        time.sleep(1)
+        self.doc2.reindexObject()
+        commit()
+        solr_results = search(
+            query={"portal_type": "Document", "sort_on": "modified"}
+        )
+        self.assertEqual(solr_results.hits, 2)
+        self.assertEqual(solr_results.docs[0]["UID"], self.doc1.UID())
+        self.assertEqual(solr_results.docs[1]["UID"], self.doc2.UID())
+        solr_results = search(
+            query={
+                "portal_type": "Document",
+                "sort_on": "modified",
+                "sort_order": "reverse",
+            }
+        )
+        self.assertEqual(solr_results.hits, 2)
+        self.assertEqual(solr_results.docs[0]["UID"], self.doc2.UID())
+        self.assertEqual(solr_results.docs[1]["UID"], self.doc1.UID())

rer/solrpush/tests/test_tika.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+"""Setup tests for this package."""
+from plone import api
+from plone.api.portal import set_registry_record
+from plone.app.testing import setRoles
+from plone.app.testing import TEST_USER_ID
+from plone.namedfile.file import NamedFile
+from rer.solrpush.interfaces.settings import IRerSolrpushSettings
+from rer.solrpush.utils import init_solr_push
+from rer.solrpush.utils import reset_solr
+from rer.solrpush.utils import search
+from rer.solrpush.testing import RER_SOLRPUSH_API_FUNCTIONAL_TESTING
+from transaction import commit
+
+import unittest
+import os
+
+
+class TestTika(unittest.TestCase):
+    """Test solr indexing for files"""
+
+    layer = RER_SOLRPUSH_API_FUNCTIONAL_TESTING
+
+    def setUp(self):
+        """Custom shared utility setup for tests."""
+        self.portal = self.layer["portal"]
+        self.request = self.layer["request"]
+        setRoles(self.portal, TEST_USER_ID, ["Manager"])
+        set_registry_record(
+            "enabled_types", [u"File"], interface=IRerSolrpushSettings
+        )
+        init_solr_push()
+        commit()
+
+    def tearDown(self):
+        set_registry_record("active", True, interface=IRerSolrpushSettings)
+        reset_solr()
+        commit()
+
+    def create_file_item(self, filename):
+        item_file = None
+        with open(
+            os.path.join(os.path.dirname(__file__), "docs", filename), "rb"
+        ) as f:
+            item_file = NamedFile(data=f.read(), filename=filename)
+
+        file_item = api.content.create(
+            container=self.portal, type="File", title=filename, file=item_file
+        )
+        commit()
+        return file_item
+
+    def test_index_and_extract_pdf(self):
+        file_item = self.create_file_item(u"example.pdf")
+
+        solr_results = search(query={"*": "*"}, fl="UID")
+        self.assertEqual(solr_results.hits, 1)
+        st_results = search(query={"SearchablesText": "lorem"}, fl="UID")
+        self.assertEqual(st_results.hits, 1)
+        self.assertEqual(file_item.UID(), st_results.docs[0]["UID"])
+
+    def test_index_and_extract_docx(self):
+        file_item = self.create_file_item(u"example.docx")
+
+        solr_results = search(query={"*": "*"}, fl="UID SearchableText")
+        self.assertEqual(solr_results.hits, 1)
+        st_results = search(query={"SearchableText": "ipsum"}, fl="UID")
+        self.assertEqual(st_results.hits, 1)
+        self.assertEqual(file_item.UID(), st_results.docs[0]["UID"])
+
+    def test_index_and_extract_ods(self):
+        file_item = self.create_file_item(u"example.ods")
+
+        solr_results = search(query={"*": "*"}, fl="UID SearchableText")
+        self.assertEqual(solr_results.hits, 1)
+        st_results = search(query={"SearchableText": "yyy"}, fl="UID")
+        self.assertEqual(st_results.hits, 1)
+        self.assertEqual(file_item.UID(), st_results.docs[0]["UID"])
+
+    def test_indexed_file_has_right_mimetype(self):
+        self.create_file_item(u"example.pdf")
+
+        solr_results = search(query={"*": "*"}, fl="UID mime_type")
+        self.assertEqual(solr_results.hits, 1)
+        self.assertEqual(solr_results.docs[0]["mime_type"], "application/pdf")