Example #1
0
    def testWords(self):
        sm = SearchModule(None)

        #Required words
        sr = SearchRequest(forbiddenWords=[], requiredWords=["rqa", "rqb", "rq-c", "rq.d"], category=Bunch({"category": categories.getCategoryByName("all")}))
        
        nsr = NzbSearchResult(pubdate_utc="", title="xyz rqa", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="rqa", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="a.title.rqa.xyz", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="a title rqa xyz", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="a-title-rq-c", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="a title rq.d", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="rqatsch", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz.rqa", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz rqa rqb", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)
        
        nsr = NzbSearchResult(pubdate_utc="", title="xyz", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("None of the required" in reason)

        #Forbidden words
        sr = SearchRequest(forbiddenWords=["fba", "fbb", "fb-c", "fb.d"], requiredWords=[], category=Bunch({"category": categories.getCategoryByName("all")}))
        
        nsr = NzbSearchResult(pubdate_utc="", title="xyz fba")
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fba\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyzfba")
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)
        

        nsr = NzbSearchResult(pubdate_utc="", title="xyzfb-ca")
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fb-c\" is in the list" in reason)
        

        #Both
        sr = SearchRequest(forbiddenWords=["fba", "fbb", "fb-c", "fb.d"], requiredWords=["rqa", "rqb", "rq-c", "rq.d"], category=Bunch({"category": categories.getCategoryByName("all")}))

        nsr = NzbSearchResult(pubdate_utc="", title="xyz fba rqa")
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fba\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz FBA rqb")
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fba\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz rqa.rqb.fbb")
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fbb\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz rqa.rqb.fba.fbc")
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fba\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz acd")
        sr = SearchRequest(forbiddenWords=["ACD"])
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"ACD\" is in the list" in reason)

        sr = SearchRequest(forbiddenWords=[], requiredWords=[], category=Bunch({"category": categories.getCategoryByName("all")}))
        config.settings.searching.applyRestrictions = "both"
        config.settings.searching.requiredWords = ""
        config.settings.searching.forbiddenWords = ""
        config.settings.searching.requiredRegex = ""
        config.settings.searching.forbiddenRegex = ""
        sr.category.category.applyRestrictions = "both"
        sr.category.category.forbiddenWords = ""
        sr.category.category.requiredWords = ""
        sr.category.category.forbiddenRegex = ""
        sr.category.category.requiredRegex = ""
        
        sr.internal = True
        config.settings.searching.applyRestrictions = "both"
        config.settings.searching.forbiddenRegex = "abc"
        
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        config.settings.searching.applyRestrictions = "internal"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        config.settings.searching.applyRestrictions = "external"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        sr.internal = False
        config.settings.searching.applyRestrictions = "both"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        config.settings.searching.applyRestrictions = "internal"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        config.settings.searching.applyRestrictions = "external"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        sr.internal = True
        config.settings.searching.forbiddenRegex = ""
        sr.category.category.forbiddenRegex = "abc"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        sr.category.category.applyRestrictions = "internal"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        sr.category.category.applyRestrictions = "external"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        sr.internal = False
        sr.category.category.applyRestrictions = "both"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        sr.category.category.applyRestrictions = "internal"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        sr.category.category.applyRestrictions = "external"
        nsr = NzbSearchResult(pubdate_utc="", title="abc", category=categories.getCategoryByName("all"))
        accepted, reason, ri = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
Example #2
0
    def testWords(self):
        sm = SearchModule(None)

        #Required words
        sr = SearchRequest(
            forbiddenWords=[],
            requiredWords=["rqa", "rqb", "rq-c", "rq.d"],
            category=Bunch({"category": categories.getCategoryByName("all")}))

        nsr = NzbSearchResult(pubdate_utc="",
                              title="xyz rqa",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="rqa",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="a.title.rqa.xyz",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="a title rqa xyz",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="a-title-rq-c",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="a title rq.d",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="rqatsch",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="xyz.rqa",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="xyz rqa rqb",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="",
                              title="xyz",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("None of the required" in reason)

        #Forbidden words
        sr = SearchRequest(
            forbiddenWords=["fba", "fbb", "fb-c", "fb.d"],
            requiredWords=[],
            category=Bunch({"category": categories.getCategoryByName("all")}))

        nsr = NzbSearchResult(pubdate_utc="", title="xyz fba")
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fba\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyzfba")
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        nsr = NzbSearchResult(pubdate_utc="", title="xyzfb-ca")
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fb-c\" is in the list" in reason)

        #Both
        sr = SearchRequest(
            forbiddenWords=["fba", "fbb", "fb-c", "fb.d"],
            requiredWords=["rqa", "rqb", "rq-c", "rq.d"],
            category=Bunch({"category": categories.getCategoryByName("all")}))

        nsr = NzbSearchResult(pubdate_utc="", title="xyz fba rqa")
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fba\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz FBA rqb")
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fba\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz rqa.rqb.fbb")
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fbb\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz rqa.rqb.fba.fbc")
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"fba\" is in the list" in reason)

        nsr = NzbSearchResult(pubdate_utc="", title="xyz acd")
        sr = SearchRequest(forbiddenWords=["ACD"])
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
        self.assertTrue("\"ACD\" is in the list" in reason)

        sr = SearchRequest(
            forbiddenWords=[],
            requiredWords=[],
            category=Bunch({"category": categories.getCategoryByName("all")}))
        config.settings.searching.applyRestrictions = "both"
        config.settings.searching.requiredWords = ""
        config.settings.searching.forbiddenWords = ""
        config.settings.searching.requiredRegex = ""
        config.settings.searching.forbiddenRegex = ""
        sr.category.category.applyRestrictions = "both"
        sr.category.category.forbiddenWords = ""
        sr.category.category.requiredWords = ""
        sr.category.category.forbiddenRegex = ""
        sr.category.category.requiredRegex = ""

        sr.internal = True
        config.settings.searching.applyRestrictions = "both"
        config.settings.searching.forbiddenRegex = "abc"

        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        config.settings.searching.applyRestrictions = "internal"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        config.settings.searching.applyRestrictions = "external"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        sr.internal = False
        config.settings.searching.applyRestrictions = "both"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        config.settings.searching.applyRestrictions = "internal"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        config.settings.searching.applyRestrictions = "external"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        sr.internal = True
        config.settings.searching.forbiddenRegex = ""
        sr.category.category.forbiddenRegex = "abc"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        sr.category.category.applyRestrictions = "internal"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        sr.category.category.applyRestrictions = "external"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        sr.internal = False
        sr.category.category.applyRestrictions = "both"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)

        sr.category.category.applyRestrictions = "internal"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertTrue(accepted)

        sr.category.category.applyRestrictions = "external"
        nsr = NzbSearchResult(pubdate_utc="",
                              title="abc",
                              category=categories.getCategoryByName("all"))
        accepted, reason = sm.accept_result(nsr, sr, None)
        self.assertFalse(accepted)
Example #3
0
    def test_pick_indexers(self):
        config.settings.searching.generate_queries = []
        config.settings.indexers.extend([self.newznab1, self.newznab2])
        getIndexerSettingByName("womble").enabled = True
        getIndexerSettingByName("womble").accessType = "both"
        getIndexerSettingByName("nzbclub").enabled = True
        getIndexerSettingByName("nzbclub").accessType = "both"
        read_indexers_from_config()
        search_request = SearchRequest()

        indexers = search.pick_indexers(search_request)
        self.assertEqual(3, len(indexers))

        # Indexers with tv search and which support queries (actually searching for particular releases)
        search_request.query = "bla"
        indexers = search.pick_indexers(search_request)
        self.assertEqual(3, len(indexers))

        # Indexers with tv search, including those that only provide a list of latest releases (womble) but excluding the one that needs a query (nzbclub)
        search_request.query = None
        indexers = search.pick_indexers(search_request)
        self.assertEqual(3, len(indexers))

        search_request.identifier_key = "tvdbid"
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))
        self.assertEqual("newznab1", indexers[0].name)
        self.assertEqual("newznab2", indexers[1].name)

        search_request.identifier_key = "imdbid"
        search_request.category = getCategoryByName("movies")
        indexers = search.pick_indexers(search_request)
        self.assertEqual(1, len(indexers))
        self.assertEqual("newznab1", indexers[0].name)

        # WIth query generation NZBClub should also be returned
        infos.title_from_id = mock
        config.settings.searching.generate_queries = ["internal"]
        search_request.identifier_key = "tvdbid"
        search_request.query = None
        search_request.category = None
        indexers = search.pick_indexers(search_request)
        self.assertEqual(3, len(indexers))
        self.assertEqual("nzbclub", indexers[0].name)
        self.assertEqual("newznab1", indexers[1].name)
        self.assertEqual("newznab2", indexers[2].name)

        # Test picking depending on internal, external, both
        getIndexerSettingByName("womble").enabled = False
        getIndexerSettingByName("nzbclub").enabled = False

        getIndexerSettingByName("newznab1").accessType = "both"
        search_request.internal = True
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))
        search_request.internal = False
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))

        config.settings.indexers = [self.newznab1, self.newznab2]
        getIndexerSettingByName("newznab1").accessType = "external"
        read_indexers_from_config()
        search_request.internal = True
        indexers = search.pick_indexers(search_request)
        self.assertEqual(1, len(indexers))
        search_request.internal = False
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))

        getIndexerSettingByName("newznab1").accessType = "internal"
        read_indexers_from_config()
        search_request.internal = True
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))
        search_request.internal = False
        indexers = search.pick_indexers(search_request)
        self.assertEqual(1, len(indexers))
Example #4
0
    def test_pick_indexers(self):
        config.settings.searching.generate_queries = []
        config.settings.indexers.extend([self.newznab1, self.newznab2])
        getIndexerSettingByName("womble").enabled = True
        getIndexerSettingByName("womble").accessType = "both"
        getIndexerSettingByName("nzbclub").enabled = True
        getIndexerSettingByName("nzbclub").accessType = "both"
        read_indexers_from_config()
        search_request = SearchRequest()

        indexers = search.pick_indexers(search_request)
        self.assertEqual(3, len(indexers))

        # Indexers with tv search and which support queries (actually searching for particular releases)
        search_request.query = "bla"
        indexers = search.pick_indexers(search_request)
        self.assertEqual(3, len(indexers))

        # Indexers with tv search, including those that only provide a list of latest releases (womble) but excluding the one that needs a query (nzbclub)
        search_request.query = None
        indexers = search.pick_indexers(search_request)
        self.assertEqual(3, len(indexers))

        search_request.identifier_key = "tvdbid"
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))
        self.assertEqual("newznab1", indexers[0].name)
        self.assertEqual("newznab2", indexers[1].name)

        search_request.identifier_key = "imdbid"
        search_request.category = getCategoryByName("movies")
        indexers = search.pick_indexers(search_request)
        self.assertEqual(1, len(indexers))
        self.assertEqual("newznab1", indexers[0].name)

        # WIth query generation NZBClub should also be returned
        infos.title_from_id = mock
        config.settings.searching.generate_queries = ["internal"]
        search_request.identifier_key = "tvdbid"
        search_request.query = None
        search_request.category = None
        indexers = search.pick_indexers(search_request)
        self.assertEqual(3, len(indexers))
        self.assertEqual("nzbclub", indexers[0].name)
        self.assertEqual("newznab1", indexers[1].name)
        self.assertEqual("newznab2", indexers[2].name)

        # Test picking depending on internal, external, both
        getIndexerSettingByName("womble").enabled = False
        getIndexerSettingByName("nzbclub").enabled = False

        getIndexerSettingByName("newznab1").accessType = "both"
        search_request.internal = True
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))
        search_request.internal = False
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))

        config.settings.indexers = [self.newznab1, self.newznab2]
        getIndexerSettingByName("newznab1").accessType = "external"
        read_indexers_from_config()
        search_request.internal = True
        indexers = search.pick_indexers(search_request)
        self.assertEqual(1, len(indexers))
        search_request.internal = False
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))

        getIndexerSettingByName("newznab1").accessType = "internal"
        read_indexers_from_config()
        search_request.internal = True
        indexers = search.pick_indexers(search_request)
        self.assertEqual(2, len(indexers))
        search_request.internal = False
        indexers = search.pick_indexers(search_request)
        self.assertEqual(1, len(indexers))