def test_copy(self) -> None:
"""Test JoinedQuery.copy()"""
template_query = census.Query('collection')
template_query_list = census.Query('join').limit(100)
template_join = census.JoinedQuery('join')
# Query from non-list query
copy_query = census.JoinedQuery.copy(template_query)
self.assertEqual(
copy_query.data.collection, template_query.data.collection)
self.assertFalse(copy_query.data.is_list)
self.assertEqual(copy_query.data.hide, template_join.data.hide)
self.assertEqual(copy_query.data.show, template_join.data.show)
self.assertEqual(copy_query.data.terms, template_join.data.terms)
# Query from list query
copy_query_list = census.JoinedQuery.copy(template_query_list)
self.assertEqual(
copy_query_list.data.collection, template_join.data.collection)
self.assertTrue(copy_query_list.data.is_list)
# Query from list join
copy_join_list = census.JoinedQuery.copy(template_join)
self.assertEqual(
copy_join_list.data.collection, template_join.data.collection)
self.assertEqual(copy_join_list.data, template_join.data)
# Try copying a collection-less query
template_empty_query = census.Query()
with self.assertRaises(TypeError):
_ = census.JoinedQuery.copy(template_empty_query)
def test_join(self) -> None:
"""Test the c:join query command."""
# Basic join
query = census.Query('character')
query.create_join('characters_world')
url = query.url()
self.assertDictEqual(
dict(url.query), {'c:join': 'characters_world'},
'Incorrect query command: c:join (test #1)')
# Join with fields and show
query = census.Query('outfit')
join = query.create_join('character')
join.set_fields('leader_character_id', 'character_id')
join.show('name.first')
url = query.url()
self.assertDictEqual(
dict(url.query),
{'c:join': 'character^on:leader_character_id'
'^to:character_id^show:name.first'},
'Incorrect query command: c:join (test #2)')
# Join with hide, list, and inject_at
query.joins.clear()
join = query.create_join('outfit_member')
join.hide('outfit_id')
join.set_list(True)
join.set_inject_at('members')
url = query.url()
self.assertDictEqual(
dict(url.query),
{'c:join': 'outfit_member^list:1'
'^hide:outfit_id^inject_at:members'},
'Incorrect query command: c:join (test #3)')
# Nested inner joins with list
query = census.Query('character')
join = query.create_join('characters_item')
join.set_outer(False)
nested = join.create_join('item', faction_id=0, max_stack_size='>1')
nested.set_outer(False)
nested.set_list(True)
url = query.url()
self.assertDictEqual(
dict(url.query),
{'c:join': 'characters_item^outer:0(item^list:1^outer:0'
'^terms:faction_id=0\'max_stack_size=>1)'},
'Incorrect query command: c:join (test #4)')
# Multiple nested joins with siblings
query.joins.clear()
join = query.create_join('parent')
child_1 = join.create_join('child_1')
child_2 = join.create_join('child_2')
grandchild_1 = child_1.create_join('grandchild_1')
grandchild_1.create_join('great_grandchild_1')
child_2.create_join('grandchild_2_a')
child_2.create_join('grandchild_2_b')
url = query.url()
self.assertDictEqual(
dict(url.query),
{'c:join': 'parent(child_1(grandchild_1(great_grandchild_1)),'
'child_2(grandchild_2_a,grandchild_2_b))'},
'Incorrect query command: c:join (test #5)')
def test_start(self) -> None:
"""Test the c:start query command."""
query = census.Query('weapon')
url = query.sort('weapon_id').start(20).url()
self.assertDictEqual(
dict(url.query), {'c:sort': 'weapon_id', 'c:start': '20'},
'Incorrect query command: c:start')
query = census.Query('item')
url = query.sort('item_id').offset(30).url()
self.assertDictEqual(
dict(url.query), {'c:sort': 'item_id', 'c:start': '30'},
'Incorrect query command: c:start (aliased')
def test_qc_multi(self) -> None:
"""Generate a query using multiple query commands."""
url = census.Query('vehicle').limit(10).start(20).url()
self.assertDictEqual(dict(url.query), {
'c:limit': '10',
'c:start': '20'
}, 'Incorrect query string')
def test_qc_mixed(self) -> None:
"""Generate a query using query commands and terms."""
url = census.Query('item', faction=1).limit(100).url()
self.assertDictEqual(dict(url.query), {
'faction': '1',
'c:limit': '100'
}, 'Incorrect query string')
def test_url(self) -> None:
"""Test Query.url()"""
query = census.Query()
url = query.url()
self.assertIsInstance(url, yarl.URL)
comparison = yarl.URL(f'{ENDPOINT}s:example/get/ps2:v2')
self.assertEqual(url, comparison)
def test_has(self) -> None:
"""Test the c:has query command."""
query = census.Query('weapon')
url = query.has('heat_capacity').url()
self.assertDictEqual(
dict(url.query), {'c:has': 'heat_capacity'},
'Incorrect query command: c:has')
def test_hide(self) -> None:
"""Test the c:hide query command."""
query = census.Query('character')
url = query.hide('name.first_lower').url()
self.assertDictEqual(
dict(url.query), {'c:hide': 'name.first_lower'},
'Incorrect query command: c:hide')
def test_include_null(self) -> None:
"""Test the c:includeNull query command."""
query = census.Query('weapon')
url = query.include_null(True).url()
self.assertDictEqual(
dict(url.query), {'c:includeNull': '1'},
'Incorrect query command: c:includeNull')
def test_limit_per_db(self) -> None:
"""Test the c:limit_per_db query command."""
query = census.Query('character')
url = query.limit_per_db(20).url()
self.assertDictEqual(
dict(url.query), {'c:limitPerDB': '20'},
'Incorrect query command: c:limitPerDB')
def test_lang(self) -> None:
"""Test the c:lang query command."""
query = census.Query('item')
url = query.lang('en').url()
self.assertDictEqual(
dict(url.query), {'c:lang': 'en'},
'Incorrect query command: c:lang')
def test_resolve(self) -> None:
"""Test the c:resolve query command."""
query = census.Query('character')
url = query.resolve('online_status').url()
self.assertDictEqual(
dict(url.query), {'c:resolve': 'online_status'},
'Incorrect query command: c:resolve')
def test_include_null(self) -> None:
"""Test Query.include_null()"""
query = census.Query()
self.assertEqual(query.data.include_null, False)
query.include_null(True)
self.assertEqual(query.data.include_null, True)
query.include_null(False)
self.assertEqual(query.data.include_null, False)
def test_retry(self) -> None:
"""Test Query.retry()"""
query = census.Query()
self.assertTrue(query.data.retry)
query.retry(False)
self.assertFalse(query.data.retry)
query.retry(True)
self.assertTrue(query.data.retry)
def test_resolve(self) -> None:
"""Test Query.resolve()"""
query = census.Query()
self.assertListEqual(query.data.resolve, [])
query.resolve('one')
self.assertListEqual(query.data.resolve, ['one'])
query.resolve('two', 'three')
self.assertListEqual(query.data.resolve, ['two', 'three'])
def test_lang(self) -> None:
"""Test Query.lang()"""
query = census.Query()
self.assertEqual(query.data.lang, None)
query.lang('en')
self.assertEqual(query.data.lang, 'en')
query.lang(None)
self.assertEqual(query.data.lang, None)
def test_exact_match_first(self) -> None:
"""Test Query.exact_match_first()"""
query = census.Query()
self.assertEqual(query.data.exact_match_first, False)
query.exact_match_first(True)
self.assertEqual(query.data.exact_match_first, True)
query.exact_match_first(False)
self.assertEqual(query.data.exact_match_first, False)
def test_case(self) -> None:
"""Test the c:case query command."""
query = census.Query('item')
query.add_term('name.en', 'Pulsar',
modifier=census.SearchModifier.CONTAINS)
url = query.case(False).url()
self.assertDictEqual(
dict(url.query), {'name.en': '*Pulsar', 'c:case': '0'},
'Incorrect query command: c:case')
def test_tree(self) -> None:
"""Test Query.tree()"""
query = census.Query()
self.assertIsNone(query.data.tree)
query.tree('field_', is_list=True, prefix='prefix_', start='start_')
self.assertIsNotNone(query.data.tree)
assert query.data.tree is not None # Just here to satisfy linters
self.assertDictEqual(
query.data.tree, {'field': 'field_', 'is_list': True,
'prefix': 'prefix_', 'start': 'start_'})
def test_start(self) -> None:
"""Test Query.start()"""
query = census.Query()
self.assertEqual(query.data.start, 0)
query.start(10)
self.assertEqual(query.data.start, 10)
with self.assertRaises(ValueError):
query.start(-1)
query.start(0)
self.assertEqual(query.data.start, 0)
def test_sort(self) -> None:
"""Test the c:sort query command."""
query = census.Query('item')
url = query.sort('faction_id', ('item_id', False)).url()
self.assertDictEqual(
dict(url.query), {'c:sort': 'faction_id,item_id:-1'},
'Incorrect query command: c:sort')
# Test invalid argument
with self.assertRaises(ValueError):
query.sort(('field',)) # type: ignore
_ = query.url()
def test_sort(self) -> None:
"""Test Query.sort()"""
query = census.Query()
self.assertListEqual(query.data.sort, [])
query.sort('field')
self.assertListEqual(query.data.sort, ['field'])
query.sort(('field', False))
self.assertListEqual(query.data.sort, [('field', False)])
query.sort(('field_1', False), ('field_2', True))
self.assertListEqual(
query.data.sort, [('field_1', False), ('field_2', True)])
def test_warnings_empty_url(self) -> None:
"""Test warnings when using terms with empty collections."""
query_empty = census.Query(service_id='s:dummy')
query_empty_terms = census.Query(service_id='s:dummy', field='name')
query_empty_joins = census.Query(service_id='s:dummy')
query_empty_joins.create_join('other')
with warnings.catch_warnings(record=True) as caught:
assert caught is not None
_ = query_empty.url()
self.assertFalse(find_warning(caught, 'No collection specified'))
with warnings.catch_warnings(record=True) as caught:
assert caught is not None
_ = query_empty_terms.url()
self.assertTrue(find_warning(
caught, 'No collection specified, but 1 query terms provided'))
with warnings.catch_warnings(record=True) as caught:
assert caught is not None
_ = query_empty_joins.url()
self.assertTrue(find_warning(
caught, 'No collection specified, but 1 joined queries'))
def test_limit_per_db(self) -> None:
"""Test Query.limit_per_db()"""
query = census.Query()
self.assertEqual(query.data.limit_per_db, 1)
query.limit_per_db(10)
self.assertEqual(query.data.limit_per_db, 10)
with self.assertRaises(ValueError):
query.limit_per_db(-1)
with self.assertRaises(ValueError):
query.limit_per_db(0)
query.limit(1)
self.assertEqual(query.data.limit_per_db, 1)
def test_simple_query(self) -> None:
"""Generate a simple query for a non-standard namespace."""
url = census.Query('character', namespace='eq2').url()
parts = url.parts[1:] # Remove leading '/'
self.assertEqual(len(parts), 4,
f'Expected 4 URL components, got {len(parts)}')
self.assertMultiLineEqual(parts[0], 's:example',
'Unexpected service ID')
self.assertMultiLineEqual(parts[1], 'get', 'Unexpected query verb')
self.assertMultiLineEqual(parts[2], 'eq2', 'Unexpected namespace/game')
self.assertMultiLineEqual(parts[3], 'character',
'Unexpected collection')
def test_count_query(self) -> None:
"""Generate a simple query using the 'count' query verb."""
url = census.Query('faction').url(verb='count')
parts = url.parts[1:] # Remove leading '/'
self.assertEqual(len(parts), 4,
f'Expected 4 URL components, got {len(parts)}')
self.assertMultiLineEqual(parts[0], 's:example',
'Unexpected service ID')
self.assertMultiLineEqual(parts[1], 'count', 'Unexpected query verb')
self.assertMultiLineEqual(parts[2], 'ps2:v2',
'Unexpected namespace/game')
self.assertMultiLineEqual(parts[3], 'faction', 'Unexpected collection')
def test_term_single(self) -> None:
"""Generate a query using a single, manually added term."""
url = census.Query('item').add_term('name.en', 'Force-Blade').url()
parts = url.parts[1:] # Remove leading '/'
self.assertMultiLineEqual(parts[0], 's:example',
'Unexpected service ID')
self.assertMultiLineEqual(parts[1], 'get', 'Unexpected query verb')
self.assertMultiLineEqual(parts[2], 'ps2:v2',
'Unexpected namespace/game')
self.assertMultiLineEqual(parts[3], 'item', 'Unexpected collection')
self.assertDictEqual(dict(url.query), {'name.en': 'Force-Blade'},
'Incorrect query string')
def test_term_implicit(self) -> None:
"""Generate a query using a single, implicitly added term."""
url = census.Query('vehicle', name__fr='Offenseur').url()
parts = url.parts[1:] # Remove leading '/'
self.assertMultiLineEqual(parts[0], 's:example',
'Unexpected service ID')
self.assertMultiLineEqual(parts[1], 'get', 'Unexpected query verb')
self.assertMultiLineEqual(parts[2], 'ps2:v2',
'Unexpected namespace/game')
self.assertMultiLineEqual(parts[3], 'vehicle', 'Unexpected collection')
self.assertDictEqual(dict(url.query), {'name.fr': 'Offenseur'},
'Incorrect query string')
def test_search_modifiers(self) -> None:
"""Generate a query using each of the search modifiers."""
# NOTE: This check does intentionally not use sensible field names.
# It only cares about whether the search modifier literals are
# added correctly.
modifiers = ['', '<', '[', '>', ']', '^', '*', '!']
for index, prefix in enumerate(modifiers):
query = census.Query('dummy')
mod = census.SearchModifier(index)
url = query.add_term('field', 'value', modifier=mod).url()
self.assertDictEqual(
dict(url.query), {'field': f'{prefix}value'},
f'Incorrect search modifier prefix; expected {prefix}')
def test_limit(self) -> None:
"""Test the c:limit query command."""
query = census.Query('faction')
url = query.limit(5).url()
self.assertDictEqual(
dict(url.query), {'c:limit': '5'},
'Incorrect query command: c:limit')
# Test both limit and limit_per_idea being added
query.data.limit_per_db = 10
with warnings.catch_warnings(record=True) as caught:
assert caught is not None
_ = query.url()
self.assertTrue(find_warning(
caught, 'Query.limit and Query.limit_per_db are mutually'))
