def test_no_agrs(self):
''' Retorna normalmente quando não há agregações. '''
repo = StubHadoopRepository()
cats = [
'cd_indicador', 'nu_competencia', 'vl_indicador', 'lat_mun',
'long_mun'
]
valor = ['vl_indicador']
agregacao = None
joined = 'municipio'
result = repo.build_joined_categorias(cats, valor, agregacao, joined)
self.assertEqual(
result, 'cd_indicador, nu_competencia, vl_indicador, lat, long')
def test_no_agrs(self):
''' Retorna normalmente quando não há agregações. '''
repo = StubHadoopRepository()
cats = ['cd_indicador', 'nu_competencia', 'vl_indicador']
options = {
"categorias": cats,
"valor": ['vl_indicador'],
"agregacao": None
}
result = repo.build_categorias(cats, options)
self.assertEqual(
result,
' cd_indicador, nu_competencia, vl_indicador, vl_indicador')
def test_in_clause(self):
''' Retorna cláusula where de consulta com cláusula IN. '''
repo = StubHadoopRepository()
whrs = [
'eq-nu_competencia-2010', 'and',
'in-cd_indicador-01_02_03_04-01_02_03_05-01_02_03_06'
]
is_on = False
joined = None
result = repo.build_filter_string(whrs, joined, is_on)
self.assertEqual(
result, ('nu_competencia = 2010 and cd_indicador IN (01_02_03_04,'
'01_02_03_05,01_02_03_06)'))
def test_full(self):
''' Retorna normalmente quando não há agregações. '''
repo = StubHadoopRepository()
cats = ['cd_indicador', 'nu_competencia', 'vl_indicador']
options = {
"categorias": cats,
"valor": ['vl_indicador'],
"agregacao": ['sum', 'pct_sum']
}
expected = (' cd_indicador, nu_competencia, vl_indicador, '
'sum(vl_indicador) AS agr_sum_vl_indicador, '
'SUM(vl_indicador) * 100 / SUM(vl_indicador) OVER() AS '
'agr_pct_sum_vl_indicador')
result = repo.build_categorias(cats, options)
self.assertEqual(result, expected)
def test_no_valor(self):
''' Retorna normalmente quando não há valor. '''
repo = StubHadoopRepository()
cats = [
'cd_indicador', 'nu_competencia', 'vl_indicador', 'lat_mun',
'long_mun'
]
valor = None
agregacao = ['sum']
joined = 'municipio'
result = repo.build_joined_categorias(cats, valor, agregacao, joined)
self.assertEqual(
result,
('cd_indicador, nu_competencia, vl_indicador, lat, long, sum(*) '
'AS agr_sum'))
def test_sz_criteria(self):
""" Tests string size comparison criteria """
w_clause = ['ltsz', 'column', 'value']
self.assertEqual(
StubHadoopRepository.build_complex_criteria(
w_clause, self.SIMPLE_OPERATORS),
"LENGTH(CAST(column AS STRING)) < value")
def test_full_join(self):
''' Retorna normalmente. '''
repo = StubHadoopRepository()
cats = [
'cd_indicador', 'nu_competencia', 'vl_indicador', 'lat_mun',
'long_mun'
]
valor = ['vl_indicador']
agregacao = ['sum', 'pct_sum']
joined = 'municipio'
expected = ('cd_indicador, nu_competencia, vl_indicador, lat, long, '
'sum(vl_indicador) AS agr_sum_vl_indicador, '
'SUM(vl_indicador) * 100 / SUM(vl_indicador) OVER() AS '
'agr_pct_sum_vl_indicador')
result = repo.build_joined_categorias(cats, valor, agregacao, joined)
self.assertEqual(result, expected)
def test_invalid_agregation(self):
''' Lança erro ao tentar agrupar sem join. '''
repo = StubHadoopRepository()
cats = ['nm_indicador', 'vl_indicador']
agrs = None
joined = 'municipio'
self.assertRaises(ValueError, repo.build_joined_grouping_string, cats,
agrs, joined)
def test_invalid_cats(self):
''' Lança erro ao tentar agrupar sem categoria. '''
repo = StubHadoopRepository()
cats = None
agrs = None
joined = 'municipio'
self.assertRaises(ValueError, repo.build_joined_grouping_string, cats,
agrs, joined)
def test_on_criteria(self):
""" Tests only_numbers criteria """
w_clause = ['eqon', 'column', 'value']
self.assertEqual(
StubHadoopRepository.build_complex_criteria(
w_clause, self.SIMPLE_OPERATORS),
"regexp_replace(CAST(column AS STRING), '[^[:digit:]]','') = 'value'"
)
def test_lponstr_criteria(self):
""" Tests only_numbers_against_string criteria with left padding """
w_clause = ['nelponstr', 'column', 'value']
self.assertEqual(
StubHadoopRepository.build_complex_criteria(
w_clause, self.SIMPLE_OPERATORS),
"regexp_replace(CAST(column AS STRING), '[^[:digit:]]','') != 'value'"
)
def test_on_criteria_substring(self):
""" Tests only_numbers criteria with substring """
w_clause = ['eqon', 'column', 'value', 'slice_start', 'slice_end']
self.assertEqual(
StubHadoopRepository.build_complex_criteria(
w_clause, self.SIMPLE_OPERATORS),
"substring(regexp_replace(CAST(column AS STRING), "
"'[^[:digit:]]',''), slice_start, slice_end) = 'value'")
def test_empty_cats(self):
''' Lança exceção quando há categorias vazias. '''
repo = StubHadoopRepository()
cats = []
valor = ['vl_indicador']
agregacao = ['sum']
joined = 'municipio'
self.assertRaises(ValueError, repo.build_joined_categorias, cats,
valor, agregacao, joined)
def test_no_join(self):
''' Retorna normalmente quando não há join. '''
repo = StubHadoopRepository()
cats = ['cd_indicador', 'nu_competencia', 'vl_indicador']
valor = ['vl_indicador']
agregacao = ['sum', 'pct_sum']
joined = None
self.assertRaises(KeyError, repo.build_joined_categorias, cats, valor,
agregacao, joined)
def test_invalid(self):
''' Lança exceção quando um campo é inválido. '''
repo = StubHadoopRepository()
cats = ['cd_indicador;', 'nu_competencia', 'vl_indicador']
valor = ['vl_indicador']
agregacao = ['sum', 'pct_sum']
joined = 'municipio'
self.assertRaises(ValueError, repo.build_joined_categorias, cats,
valor, agregacao, joined)
def test_no_cats(self):
''' Lança exceção se não houver categoria nos parâmetros '''
repo = StubHadoopRepository()
options = {
"valor": ['vl_indicador'],
"agregacao": ['sum'],
"ordenacao": ['-vl_indicador'],
"where": ['eq-nu_competencia-2010']
}
self.assertRaises(KeyError, repo.find_dataset, options)
def test_std_calc_invalid_calc(self):
''' Testa se lança exceção quando envia um tipo de cálculo não previsto '''
options = {
"valor": "vl_indicador",
"calcs": ["sum"],
"categorias": ["cd_mun_ibge", "nu_ano"],
"partition": "nu_ano"
}
repo = StubHadoopRepository()
self.assertRaises(KeyError, repo.build_std_calcs, options)
def test_str_criteria(self):
""" Tests substrings comparison criteria """
w_clause = [
'lestr', 'column', "'quoted_value'", 'slice_start', 'slice_end'
]
self.assertEqual(
StubHadoopRepository.build_complex_criteria(
w_clause, self.SIMPLE_OPERATORS),
"substring(CAST(column AS STRING), slice_start, slice_end) <= 'quoted_value'"
)
def test_empty_cats(self):
''' Lança exceção quando há categorias vazias. '''
repo = StubHadoopRepository()
cats = []
options = {
"categorias": cats,
"valor": ['vl_indicador'],
"agregacao": ['sum']
}
self.assertRaises(ValueError, repo.build_categorias, cats, options)
def test_invalid(self):
''' Lança exceção quando um campo é inválido. '''
repo = StubHadoopRepository()
cats = ['cd_indicador;', 'nu_competencia', 'vl_indicador']
options = {
"categorias": cats,
"valor": ['vl_indicador'],
"agregacao": ['sum', 'pct_sum']
}
self.assertRaises(ValueError, repo.build_categorias, cats, options)
def test_full_query(self):
''' Verifica correta formação da query '''
repo = StubHadoopRepository()
options = {
"categorias": ['nm_indicador', 'nu_competencia', 'vl_indicador'],
"valor": ['vl_indicador'],
"agregacao": ['sum'],
"ordenacao": ['-nm_indicador'],
"where": ['eq-nu_competencia-2010'],
"pivot": None,
"limit": None,
"offset": None,
"calcs": None
}
result = repo.find_dataset(options)
self.assertEqual(
result,
('SELECT nm_indicador, nu_competencia, vl_indicador, '
'sum(vl_indicador) AS agr_sum_vl_indicador FROM indicadores '
'WHERE nu_competencia = 2010 GROUP BY nm_indicador, '
'nu_competencia, vl_indicador ORDER BY nm_indicador DESC '))
def test_lpint_criteria(self):
""" Tests integer with left padding comparison criteria """
w_clause = [
'gtlpint', 'column', 'value', 'string_size', 'padding_char',
'slice_start', 'slice_end'
]
self.assertEqual(
StubHadoopRepository.build_complex_criteria(
w_clause, self.SIMPLE_OPERATORS),
"CAST(substring(LPAD(CAST(column AS VARCHAR(string_size)), "
"string_size, 'padding_char'), slice_start, slice_end) AS INTEGER) > value"
)
def test_sql_injection_rejection(self):
''' Lança exceção se houver categorias com palavra bloqueada '''
repo = StubHadoopRepository()
options = {
"categorias":
['nm_indicador;select', 'nu_competencia', 'vl_indicador'],
"valor": ['vl_indicador'],
"agregacao": ['sum'],
"ordenacao": ['-vl_indicador'],
"where": ['eq-nu_competencia-2010']
}
self.assertRaises(ValueError, repo.find_dataset, options)
def test_lponstr_criteria_substring(self):
""" Tests only_numbers_against_string criteria with left padding """
w_clause = [
'nelponstr', 'column', 'value', 'string_size', 'padding_char',
'slice_start', 'slice_end'
]
self.assertEqual(
StubHadoopRepository.build_complex_criteria(
w_clause, self.SIMPLE_OPERATORS),
"substring(LPAD(regexp_replace(CAST(column AS STRING), "
"'[^[:digit:]]',''), string_size, 'padding_char'), slice_start, slice_end) "
"!= 'value'")
def test_lpstr_criteria(self):
""" Tests string with left padding comparison criteria """
w_clause = [
'gelpstr', 'column', "'quoted_value'", 'string_size',
'padding_char', 'slice_start', 'slice_end'
]
self.assertEqual(
StubHadoopRepository.build_complex_criteria(
w_clause, self.SIMPLE_OPERATORS),
"substring(LPAD(CAST(column AS VARCHAR(string_size)), "
"string_size, 'padding_char'), slice_start, slice_end) >= 'quoted_value'"
)
def test_empty_cats(self):
''' Lança exceção se houver categorias vazias '''
repo = StubHadoopRepository()
options = {
"categorias": [],
"valor": ['vl_indicador'],
"agregacao": ['sum'],
"ordenacao": ['-vl_indicador'],
"where": ['eq-nu_competencia-2010'],
"pivot": None
}
self.assertRaises(ValueError, repo.find_dataset, options)
def test_invoke_complex_criteria(self):
''' Tests if a complex op is correctly built '''
self.assertEqual(
StubHadoopRepository().build_criteria(['ltsz', 'column', 'value']),
"LENGTH(CAST(column AS STRING)) < value")
def test_build_criteria_in_op(self):
''' Tests if a IN operator string is correctly built '''
self.assertEqual(
StubHadoopRepository().build_criteria(['in', 'field', 'a', 'b']),
'field IN (a,b)')
def test_build_criteria_boolean_op(self):
''' Tests if a boolean op string is correctly built '''
self.assertEqual(
StubHadoopRepository().build_criteria(['nn', 'field']),
'field IS NOT NULL')
def test_build_criteria_simple_op(self):
''' Tests if a simple op string is correctly built '''
self.assertEqual(
StubHadoopRepository().build_criteria(['eq', 'field', 'value']),
'field = value')