def test_no_accounts(self): """ Tests the _handle_combined_trm_fol_limit method for a query that doesn't include any accounts. """ terms = SearchTerm.objects.all() # exceeds search terms limit query = ReservoirQuery(searchterms=terms) specs = PipeSpecSheet.objects.get(pipe=1) # Twitter Search API engineer = Engineer(query=query, specs=specs) queries = engineer._handle_combined_trm_fol_limit([query]) self.assertEqual(len(queries), 1)
def test_and_specs_and_query(self): """ Tests the _separate_components method for a query that joins SearchTerms and Locations with AND logic, with an API that can't join SearchTerms and Accounts using OR logic. """ self.query.trm_loc_logic = 'AND' specs = PipeSpecSheet.objects.get(pipe=5) # YouTube Data API engineer = Engineer(query=self.query, specs=specs) queries = engineer._separate_components() self.assertEqual(len(queries), 2)
def test_no_limits_exceeded(self): """ Tests the _factor_components method for a query that doesn't exceed any API limits on number of arguments. """ specs = PipeSpecSheet(searchterms_limit=10, locations_limit=10, followees_limit=10) engineer = Engineer(query=self.query, specs=specs) queries = engineer._factor_components([self.query]) self.assertEqual(len(queries), 1)
def test_exceeds_searchterms_limit(self): """ Tests the _factor_components method for a query that exceeds the API limit on number of terms. """ specs = PipeSpecSheet(searchterms_limit=1, locations_limit=10, followees_limit=10) engineer = Engineer(query=self.query, specs=specs) queries = engineer._factor_components([self.query]) self.assertEqual(len(queries), 3)
def test_dup_terms(self): """ Tests the _handle_phrases method for terms with duplicate words. """ terms = [SearchTerm(term='police'), SearchTerm(term='police officer')] query = ReservoirQuery(searchterms=terms) specs = PipeSpecSheet(accepts_phrases=False) engineer = Engineer(query=query, specs=specs) engineer._handle_phrases() searchterms = engineer.get_searchterms() self.assertEqual(len(searchterms), 3)
def test_for_small_circle(self): """ Tests the factor_query method for a circular location smaller than the radius limit. """ locations = Location.objects.filter(pk=2) query = ReservoirQuery(locations=locations) specs = PipeSpecSheet(location_format='radius', radius_limit_km=1) engineer = Engineer(query=query, specs=specs) queries = engineer.factor_query() self.assertTrue(len(queries[0].locations) == 1)
def test_or_specs_or_query(self): """ Tests the _separate_components method for a query that joins SearchTerms and Locations with OR logic, with an API that joins SearchTerms and Accounts using OR logic. """ self.query.trm_loc_logic = 'OR' specs = PipeSpecSheet.objects.get(pipe=2) # Twitter Public Streams API engineer = Engineer(query=self.query, specs=specs) queries = engineer._separate_components() self.assertEqual(len(queries), 1)
def test_for_negation_not_allowed(self): """ Tests the _handle_negation method for an API that doesn't allow negation of search terms. """ terms = [SearchTerm(term='police'), SearchTerm(term='car', negate=True)] query = ReservoirQuery(searchterms=terms) engineer = Engineer(query=query, specs=PipeSpecSheet()) engineer._handle_negation() searchterms = engineer.get_searchterms() self.assertEqual(len(searchterms), 1)
def test_no_searchterms(self): """ Tests the _handle_combined_trm_fol_limit method for a query that doesn't include any search terms. """ accounts = Account.objects.filter(pk__in=[1, 2, 3]) accounts = list(accounts).extend(accounts) # exceeds search terms limit query = ReservoirQuery(accounts=accounts) specs = PipeSpecSheet.objects.get(pipe=1) # Twitter Search API engineer = Engineer(query=query, specs=specs) queries = engineer._handle_combined_trm_fol_limit([query]) self.assertEqual(len(queries), 1)
def test_for_accepts_phrases(self): """ Tests the _handle_phrases method for an API that accepts phrases. """ terms = [SearchTerm(term='police officer')] query = ReservoirQuery(searchterms=terms) specs = PipeSpecSheet(accepts_phrases=True) engineer = Engineer(query=query, specs=specs) engineer._handle_phrases() searchterms = engineer.get_searchterms() self.assertEqual(len(searchterms), 1) self.assertEqual(searchterms[0].term, 'police officer')
def test_exceeds_twitter_search_api(self): """ Tests the _exceeds_searchterms_limit method for the Twitter Search API when the search terms exceed the limit. """ terms = SearchTerm.objects.filter(pk__in=[1, 2, 3, 4]) accounts = Account.objects.filter(pk__in=[1, 2]) query = ReservoirQuery(searchterms=terms, accounts=accounts) specs = PipeSpecSheet.objects.get(pipe=1) # Twitter Search API engineer = Engineer(query=query, specs=specs) # expect 10 terms: 4 for SearchTerms, 2 for Accounts, 5 for "OR" operators self.assertTrue(engineer._exceeds_searchterms_limit(query))
def test_do_not_count_operator(self): """ Tests the get_num_searchterms method when operators are not counted as search terms. Uses the Twitter Public Streams API as an example. """ terms = SearchTerm.objects.filter(pk=1) accounts = Account.objects.filter(pk__in=[1, 2]) query = ReservoirQuery(searchterms=terms, accounts=accounts) specs = PipeSpecSheet.objects.get(pipe=2) # Twitter Public Streams API engineer = Engineer(query=query, specs=specs) # expect 1: 1 for SearchTerm self.assertEqual(engineer.get_num_searchterms(query), 1)
def test_factor_queries_by_component(self): """ Tests the _factor_queries_by_component method for searchterms. """ specs = PipeSpecSheet(searchterms_limit=1) engineer = Engineer(query=self.query, specs=specs) queries1 = engineer._factor_queries_by_component([self.query], 'locations', 1) self.assertEqual(len(queries1), 4) queries2 = engineer._factor_queries_by_component([self.query], 'accounts', 1) self.assertEqual(len(queries2), 2)
def test_with_or_operator(self): """ Tests the get_num_searchterms method when operators are counted as search terms, the default logic is "AND", and an "OR" operator can be used to join terms. Uses the Twitter Search API as an example. """ terms = SearchTerm.objects.filter(pk=1) accounts = Account.objects.filter(pk__in=[1, 2]) query = ReservoirQuery(searchterms=terms, accounts=accounts) specs = PipeSpecSheet.objects.get(pipe=1) # Twitter Search API engineer = Engineer(query=query, specs=specs) # expect 5: 1 for SearchTerm, 2 for Accounts, 2 for "OR" operators self.assertEqual(engineer.get_num_searchterms(query), 5)
def test_for_multiple_phrases(self): """ Tests the _handle_phrases method for an API that accepts phrases. """ # 'police', 'police oficeer', 'bank robbery' terms = SearchTerm.objects.filter(pk__in=[1, 2, 3]) query = ReservoirQuery(searchterms=terms) specs = PipeSpecSheet(accepts_phrases=False) engineer = Engineer(query=query, specs=specs) engineer._handle_phrases() searchterms = engineer.get_searchterms() # 'police', 'officer', policeoficeer', 'bank', 'robbery', bankrobbery' self.assertEqual(len(searchterms), 6)
def test_single_term(self): """ Tests the _separate_terms method for a single term. """ terms = SearchTerm.objects.filter(pk=1) accounts = Account.objects.filter(pk__in=[1, 2]) query = ReservoirQuery(searchterms=terms, accounts=accounts) specs = PipeSpecSheet.objects.get(pipe=1) # Twitter Search API engineer = Engineer(query=query, specs=specs) queries = engineer._separate_terms(query) self.assertEqual(len(queries), 1) # make sure Accounts are being copied to the child queries self.assertEqual(queries[0].accounts[0], accounts[0])
def test_needs_splitting(self): """ Tests the _handle_combined_trm_fol_limit method for a query that includes accounts and search terms, but that doesn't exceed the API limit. """ specs = PipeSpecSheet(searchterms_limit=8, combine_trm_fol=True, trm_trm_logic='AND', combine_trm_opr=True, OR_operator='OR') engineer = Engineer(query=self.query, specs=specs) queries = engineer._handle_combined_trm_fol_limit([self.query]) self.assertEqual(len(queries), 2)
def test_without_or(self): """ Tests the get_num_searchterms method when the operators are counted as search terms and the default logic is "OR". """ terms = SearchTerm.objects.filter(pk=1) accounts = Account.objects.filter(pk__in=[1, 2]) query = ReservoirQuery(searchterms=terms, accounts=accounts) specs = PipeSpecSheet(combine_trm_fol=True, combine_trm_opr=True, trm_trm_logic='OR', OR_operator='OR') engineer = Engineer(query=query, specs=specs) # expect 5: 1 for SearchTerm, 2 for Accounts self.assertEqual(engineer.get_num_searchterms(query), 3)
def test_separate_locations_and_terms(self): """ Tests the _separate_locations_and_terms method. """ terms = SearchTerm.objects.filter(pk__in=[1, 2, 3]) locations = Location.objects.filter(pk__in=[2, 3, 5]) query = ReservoirQuery(searchterms=terms, locations=locations) specs = PipeSpecSheet.objects.get(pipe=4) engineer = Engineer(query=query, specs=specs) queries = engineer._separate_locations_and_terms(query) self.assertEqual(len(queries), 2) self.assertEqual(len(queries[0].locations), 3) self.assertEqual(len(queries[0].searchterms), 0) self.assertEqual(len(queries[1].locations), 0) self.assertEqual(len(queries[1].searchterms), 3)
def test_separate_accounts_and_terms(self): """ Tests the _separate_accounts_and_terms method. """ terms = SearchTerm.objects.filter(pk__in=[1, 2, 3]) accounts = Account.objects.filter(pk__in=[1, 2]) query = ReservoirQuery(searchterms=terms, accounts=accounts) specs = PipeSpecSheet.objects.get(pipe=4) engineer = Engineer(query=query, specs=specs) queries = engineer._separate_accounts_and_terms(query) self.assertEqual(len(queries), 2) self.assertEqual(len(queries[0].accounts), 2) self.assertEqual(len(queries[0].searchterms), 0) self.assertEqual(len(queries[1].accounts), 0) self.assertEqual(len(queries[1].searchterms), 3)
def test_format_for_box(self): """ Tests the format_locations method for a 'box' location_format. """ query = ReservoirQuery(locations=self.locations) specs = PipeSpecSheet(location_format='box') engineer = Engineer(query=query, specs=specs) engineer._format_locations() all_boxes = False for new_location in engineer.get_locations(): if new_location.shape == 'Rectangle': all_boxes = True else: all_boxes = False break self.assertTrue(all_boxes)
def test_format_for_radius(self): """ Tests the format_locations method for a 'radius' location_format. """ query = ReservoirQuery(locations=self.locations) specs = PipeSpecSheet(location_format='radius', radius_limit_km=100) engineer = Engineer(query=query, specs=specs) engineer._format_locations() all_circles = False for new_location in engineer.get_locations(): if new_location.shape == 'Circle': all_circles = True else: all_circles = False break self.assertTrue(all_circles)
def setUp(self): super(GetQueryParametersTestCase, self).setUp() self.engineer = Engineer(query=self.query, specs=PipeSpecSheet())