def test_obter_relatorio_json_inexistente_por_periodos_diferentes(
self,
mock_model_selector
):
parlamentar = Parlamentar(id='1', cargo='BR1')
brasilia_tz = pytz.timezone('America/Sao_Paulo')
relatorio_inicial = Relatorio(
parlamentar=parlamentar,
data_final=brasilia_tz.localize(datetime(2019, 6, 29)),
data_inicial=brasilia_tz.localize(datetime(2019, 6, 15))
).save()
relatorio_gerado = Relatorio(
parlamentar=parlamentar,
data_final=datetime(2019, 6, 29),
data_inicial=datetime(2019, 6, 22)
)
class FakeModel:
def obter_relatorio(self, *args, **kwargs):
return relatorio_gerado
mock_model_selector.return_value = FakeModel
actual_response = Relatorios().obter_relatorio('1', '2019-06-29', 'BR1', periodo=7)
actual_response['_id'] = 'id'
relatorio_gerado.pk = 'id'
self.assertEqual(mock_model_selector.call_count, 1)
self.assertEqual(actual_response, relatorio_gerado.to_dict())
def test_send_push_notification_message_too_big_sucess(self, mock_urllib3):
def assert_equal(actual, expected):
self.assertEqual(actual, expected)
class FakePoolManager:
def __init__(self, *args, **kwargs):
FakePoolManager.call_count = 0
def request(self, method, url, headers, body):
class responseFail():
status = 200
data = json.dumps({
'results': [{
'error': 'MessageTooBig'
}]
}).encode('utf-8')
class responseSucess():
status = 200
data = json.dumps({
'results': [{
'id': '123'
}]
}).encode('utf-8')
FakePoolManager.call_count += 1
assert_equal(method, "POST")
assert_equal(url, "https://fcm.googleapis.com/fcm/send")
if 'reportsIds' in body.decode('utf-8'):
return responseSucess()
return responseFail()
data_inicial = datetime(2019, 10, 12)
data_final = datetime(2019, 10, 19)
parlamentar1 = Parlamentar(id='1', cargo='BR1', nome='AMANDA')
relatorio1 = Relatorio(
id="123",
parlamentar=parlamentar1,
data_final=data_final,
data_inicial=data_inicial,
proposicoes=[
Proposicao(id="1"),
Proposicao(id="2"),
Proposicao(id="3"),
Proposicao(id="4")
],
eventos_presentes=[Evento(id="1"), Evento(id="2")],
eventos_previstos=None,
eventos_ausentes=[Evento(id="4"),
Evento(id="5"),
Evento(id="6")])
mock_urllib3.side_effect = FakePoolManager
result = send_push_notification("token", [relatorio1.to_dict()])
self.assertTrue(mock_urllib3.called)
self.assertEqual(2, mock_urllib3.side_effect.call_count)
self.assertTrue(result)
def test_obter_por_id(self):
parlamentar = Parlamentar(id='id')
relatorio = Relatorio(parlamentar=parlamentar, data_inicial='2019-01-01')
relatorio.save()
actual = Relatorios().obter_por_id(relatorio.pk)
self.assertEqual(relatorio, actual)
def test_avaliar_item_not_found(self):
parlamentar = Parlamentar(id='id', cargo='BR1')
relatorio = Relatorio(
parlamentar=parlamentar,
data_inicial='2019-01-01'
)
relatorio.save()
with self.assertRaises(ItemNotFound):
Avaliacao().avaliar('123', '1', '*****@*****.**', relatorio.pk)
def test_buscar_por_parlamentar(self):
parlamentar_1 = Parlamentar(id='1', cargo='BR1')
parlamentar_2 = Parlamentar(id='2', cargo='BR1')
parlamentar_3 = Parlamentar(id='1', cargo='BR2')
relatorio_1 = Relatorio(parlamentar=parlamentar_1, data_inicial=datetime(2019, 1, 1)).save()
relatorio_2 = Relatorio(parlamentar=parlamentar_2, data_inicial=datetime(2019, 1, 1)).save()
relatorio_3 = Relatorio(parlamentar=parlamentar_3, data_inicial=datetime(2019, 1, 1)).save()
relatorio_4 = Relatorio(parlamentar=parlamentar_1, data_inicial=datetime(2019, 1, 1)).save()
relatorio_5 = Relatorio(parlamentar=parlamentar_3, data_inicial=datetime(2019, 1, 1)).save()
relatorio_6 = Relatorio(parlamentar=parlamentar_2, data_inicial=datetime(2019, 1, 1)).save()
actual = Relatorios().buscar_por_parlamentar('BR1', '1')
expected = [relatorio_1.to_dict(), relatorio_4.to_dict()]
self.assertEqual(len(actual), len(expected))
def __init__(self):
super().__init__()
self.dep = Deputados()
self.com = Comissoes()
self.prop = Proposicoes()
self.relatorio = Relatorio()
self.brasilia_tz = pytz.timezone('America/Sao_Paulo')
def avaliar(self, avaliado, avaliacao_valor, email, relatorio_id):
avaliacao = Avaliacoes()
try:
relatorio = Relatorio.objects(pk=relatorio_id).first()
except ValidationError:
raise ReportNotFound()
if relatorio == None:
raise ReportNotFound()
for tipo in ['eventosAusentes', 'eventosPresentes', 'proposicoes']:
for item in relatorio.to_dict()[tipo]:
if 'id' in item and str(item['id']) == avaliado:
avaliacao.avaliado = item
break
if avaliacao.avaliado == {}:
raise ItemNotFound()
avaliacao.email = email
avaliacao.relatorioId = ObjectId(relatorio.pk)
avaliacao.avaliacao = avaliacao_valor
avaliacao.parlamentar = relatorio.parlamentar
avaliacao_existente = Avaliacoes.objects(
avaliado__id__=avaliacao.avaliado['id'],
parlamentar__id__=relatorio.parlamentar.id,
parlamentar__cargo=relatorio.parlamentar.cargo,
email=email,
relatorioId=relatorio.pk)
if avaliacao_existente:
Avaliacoes.objects(pk=avaliacao_existente.first().pk).update_one(
set__avaliacao=avaliacao['avaliacao'])
else:
avaliacao.save()
def test_obter_relatorio_json_inexistente_funcao_sem_erro(
self,
mock_model_selector
):
parlamentar = Parlamentar(id='1', cargo='BR1')
relatorio = Relatorio(parlamentar=parlamentar, data_final=datetime(2019, 1, 1))
class FakeModel:
def obter_relatorio(self, *args, **kwargs):
return relatorio
mock_model_selector.return_value = FakeModel
actual_response = Relatorios().obter_relatorio('1', '2019-01-01', 'BR1', periodo=7)
actual_response['_id'] = 'id'
relatorio.pk = 'id'
self.assertEqual(mock_model_selector.call_count, 1)
self.assertEqual(actual_response, relatorio.to_dict())
def test_send_push_notification_invalid_json_response(self, mock_urllib3):
def assert_equal(actual, expected):
self.assertEqual(actual, expected)
class FakePoolManager:
def __init__(self, *args, **kwargs):
FakePoolManager.call_count = 0
def request(self, method, url, headers, body):
class response():
status = 401
data = '<HTML><HEAD><TITLE>Invalid (legacy) Server-key delivered or Sender is not authorized to perform request.</TITLE></HEAD><BODY BGCOLOR="#FFFFFF" TEXT="#000000"><H1>Invalid (legacy) Server-key delivered or Sender is not authorized to perform request.</H1><H2>Error 401</H2></BODY></HTML>'.encode(
'utf-8')
FakePoolManager.call_count += 1
assert_equal(method, "POST")
assert_equal(url, "https://fcm.googleapis.com/fcm/send")
return response()
data_inicial = datetime(2019, 10, 12)
data_final = datetime(2019, 10, 19)
parlamentar1 = Parlamentar(id='1', cargo='BR1', nome='AMANDA')
relatorio1 = Relatorio(
id="123",
parlamentar=parlamentar1,
data_final=data_final,
data_inicial=data_inicial,
proposicoes=[
Proposicao(id="1"),
Proposicao(id="2"),
Proposicao(id="3"),
Proposicao(id="4")
],
eventos_presentes=[Evento(id="1"), Evento(id="2")],
eventos_previstos=None,
eventos_ausentes=[Evento(id="4"),
Evento(id="5"),
Evento(id="6")])
mock_urllib3.side_effect = FakePoolManager
result = send_push_notification("token", [relatorio1.to_dict()])
self.assertTrue(mock_urllib3.called)
self.assertEqual(1, mock_urllib3.side_effect.call_count)
self.assertFalse(result)
def obter_relatorio(self,
parlamentar_id,
data_final=datetime.now(),
periodo_dias=7):
try:
start_time = time()
self.relatorio = Relatorio()
self.relatorio.aviso_dados = u'Dados de sessões plenárias não disponível.'
self.set_period(periodo_dias)
data_final = datetime.strptime(data_final, '%Y-%m-%d')
data_inicial = self.obterDataInicial(data_final, **self.periodo)
logging.info('[ALESP] Parlamentar: {}'.format(parlamentar_id))
logging.info('[ALESP] Data final: {}'.format(data_final))
logging.info('[ALESP] Intervalo: {}'.format(periodo_dias))
self.obter_parlamentar(parlamentar_id)
if self.relatorio.parlamentar == None:
logging.error("[ALESP] Deputado não encontrado")
raise ModelError('Parlamentar não encontrado')
self.relatorio.data_inicial = self.brasilia_tz.localize(
data_inicial)
self.relatorio.data_final = self.brasilia_tz.localize(data_final)
logging.info(
'[ALESP] Deputado obtido em {0:.5f}s'.format(time() -
start_time))
comissoes = self.obterComissoesPorId()
logging.info('[ALESP] Comissoes por id obtidas em {0:.5f}s'.format(
time() - start_time))
votacoes = self.obterVotacoesPorReuniao(parlamentar_id)
logging.info(
'[ALESP] Votos do deputado obtidos em {0:.5f}s'.format(
time() - start_time))
orgaos_nomes = self.obterComissoesDeputado(comissoes,
parlamentar_id,
data_inicial,
data_final)
logging.info(
'[ALESP] Comissoes do deputado obtidas em {0:.5f}s'.format(
time() - start_time))
self.obterEventosPresentes(parlamentar_id, data_inicial,
data_final, votacoes, comissoes,
orgaos_nomes)
self.relatorio.eventos_ausentes_esperados_total = len(
self.relatorio.eventos_previstos)
logging.info(
'[ALESP] Eventos obtidos em {0:.5f}s'.format(time() -
start_time))
self.obterProposicoesDeputado(parlamentar_id, data_inicial,
data_final)
logging.info(
'[ALESP] Proposicoes obtidas em {0:.5f}s'.format(time() -
start_time))
logging.info(
'[ALESP] Relatorio obtido em {0:.5f}s'.format(time() -
start_time))
return self.relatorio
except ALESPError as e:
logging.error("[ALESP] {}".format(e))
raise ModelError('Erro')
def test_avaliar_sucesso(self):
parlamentar = Parlamentar(id='id', cargo='BR1')
evento = Evento(id='123', nome='Evento')
relatorio = Relatorio(
parlamentar=parlamentar,
data_inicial='2019-01-01',
eventos_presentes=[evento]
)
relatorio.save()
Avaliacao().avaliar('123', '1', '*****@*****.**', relatorio.pk)
actual = Avaliacoes.objects().first()
self.assertEqual(actual.email, '*****@*****.**')
self.assertEqual(actual.relatorioId, relatorio.pk)
self.assertEqual(actual.parlamentar.id, 'id')
self.assertEqual(actual.parlamentar.cargo, 'BR1')
self.assertEqual(actual.avaliado['id'], '123')
def test_generate_reports_send_to_active_devices_only(
self,
mock_send_email,
mock_send_push_notification
):
brasilia_tz = pytz.timezone('America/Sao_Paulo')
agora = datetime(2019, 6, 29)
data_final = datetime(agora.year, agora.month, agora.day)
data_final = brasilia_tz.localize(data_final)
parlamentar = Parlamentar(id='1', cargo='BR1')
relatorio = Relatorio(
parlamentar=parlamentar,
data_final=data_final,
data_inicial=data_final - timedelta(days=7)
).save().reload()
mock_send_email.return_value = True
users = [
User(
username='******',
password='******',
email='*****@*****.**',
inscricoes=Inscricoes(
parlamentares=[parlamentar],
intervalo=7
),
devices=[
UserDevice(id="device1", token="token1", name="name1", active=True),
UserDevice(id="device2", token="token2", name="name2", active=False),
UserDevice(id="device3", token="token3", name="name3", active=True),
UserDevice(id="device4", token="token4", name="name4", active=False),
]
),
]
generate_reports(users, data_final=agora)
self.assertEqual(mock_send_push_notification.call_count, 2)
mock_send_push_notification.assert_has_calls(
[
call("token1", [relatorio.to_dict()]),
call("token3", [relatorio.to_dict()])
]
)
def verificar_relatorio(self, parlamentar, data_final, cargo, periodo):
brasilia_tz = pytz.timezone('America/Sao_Paulo')
data_inicial = datetime.strptime(
data_final, '%Y-%m-%d') - timedelta(days=int(periodo))
relatorio = Relatorio.objects(
parlamentar__id__=parlamentar,
parlamentar__cargo=cargo,
data_final=brasilia_tz.localize(
datetime.strptime(data_final, '%Y-%m-%d')),
data_inicial=brasilia_tz.localize(data_inicial))
return relatorio.first() if relatorio else None
def test_solicitar_geracao_relatorio_relatorio_existente(self):
parlamentar = Parlamentar(id='1', cargo='BR1')
brasilia_tz = pytz.timezone('America/Sao_Paulo')
relatorio_inicial = Relatorio(
parlamentar=parlamentar,
data_final=brasilia_tz.localize(datetime(2019, 6, 29)),
data_inicial=brasilia_tz.localize(datetime(2019, 6, 22))
).save()
actual_response = Relatorios().solicitar_geracao_relatorio('1', '2019-06-29', 'BR1', 7)
self.assertEqual(actual_response, relatorio_inicial)
def test_generate_reports_multiplos_parlamentares(
self,
mock_send_email
):
brasilia_tz = pytz.timezone('America/Sao_Paulo')
agora = datetime.now()
data_final = datetime(agora.year, agora.month, agora.day)
data_final = brasilia_tz.localize(data_final)
data_inicial = data_final - timedelta(days=7)
parlamentar1 = Parlamentar(id='1', cargo='BR1')
parlamentar2 = Parlamentar(id='2', cargo='BR2')
parlamentar3 = Parlamentar(id='3', cargo='BR1')
relatorio1 = Relatorio(
parlamentar=parlamentar1,
data_final=data_final,
data_inicial=data_inicial
).save().reload()
relatorio2 = Relatorio(
parlamentar=parlamentar2,
data_final=data_final,
data_inicial=data_inicial
).save().reload()
relatorio3 = Relatorio(
parlamentar=parlamentar3,
data_final=data_final,
data_inicial=data_inicial
).save().reload()
mock_send_email.return_value = True
user = [User(
username='******',
password='******',
email='*****@*****.**',
inscricoes=Inscricoes(
parlamentares=[parlamentar1, parlamentar2, parlamentar3],
intervalo=7
)
)]
generate_reports(user, data_final=agora)
mock_send_email.assert_called_once_with(
"*****@*****.**",
[relatorio1.to_dict(), relatorio2.to_dict(), relatorio3.to_dict()],
dates=ANY
)
def test_solicitar_geracao_relatorio_nova_thread(
self,
mock_model_selector
):
brasilia_tz = pytz.timezone('America/Sao_Paulo')
parlamentar = Parlamentar(id='1', cargo='BR1')
relatorio_gerado = Relatorio(
parlamentar=parlamentar,
data_final=brasilia_tz.localize(datetime(2019, 6, 29)),
data_inicial=brasilia_tz.localize(datetime(2019, 6, 22))
)
def obter_relatorio(self, *args, **kwargs):
return relatorio_gerado
mock_model_selector.return_value = obter_relatorio
actual_response = Relatorios().solicitar_geracao_relatorio('1', '2019-06-29', 'BR1', 7)
self.assertEqual(actual_response, True)
def obter_relatorio(self, parlamentar_id, data_final=None, periodo_dias=7):
try:
self.relatorio = Relatorio()
self.relatorio.aviso_dados = u'Dados de votações em comissões não disponíveis.'
start_time = time()
if data_final:
data_final = datetime.strptime(data_final, '%Y-%m-%d')
else:
data_final = datetime.now()
logging.info('[BR1] Parlamentar: {}'.format(parlamentar_id))
logging.info('[BR1] Data final: {}'.format(data_final))
logging.info('[BR1] Intervalo: {}'.format(periodo_dias))
self.set_period(periodo_dias)
assemblyman_info = self.obter_parlamentar(parlamentar_id)
self.relatorio.data_inicial = self.helper.get_brt(
self.obterDataInicial(data_final, **self.periodo))
self.relatorio.data_final = self.helper.get_brt(data_final)
logging.info('[BR1] Deputado obtido em {0:.5f}s'.format(time() - start_time))
events = self.helper.get_all_events(data_final)
events_attended = self.helper.get_attended_events(events, assemblyman_info['id'])
logging.info('[BR1] Eventos obtidos em {0:.5f}s'.format(time() - start_time))
self.relatorio.orgaos = self.helper.get_commissions(assemblyman_info.id, data_final)
logging.info('[BR1] Orgaos obtidos em {0:.5f}s'.format(time() - start_time))
self._add_attended_events(events_attended)
logging.info('[BR1] Pautas obtidas em {0:.5f}s'.format(time() - start_time))
events_expected = self.helper.get_expected_events(self.relatorio.parlamentar.id, data_final)
events_absent = self.helper.get_absent_events(
events,
events_attended,
events_expected,
self.relatorio.orgaos
)
self._add_absent_events(events_absent)
logging.info('[BR1] Ausencias obtidas em {0:.5f}s'.format(time() - start_time))
self.relatorio.proposicoes = self.helper.get_propositions(assemblyman_info, data_final)
logging.info('[BR1] Proposicoes obtidas em {0:.5f}s'.format(time() - start_time))
logging.info('[BR1] Relatorio obtido em {0:.5f}s'.format(time() - start_time))
return self.relatorio
except CamaraDeputadosError as event:
logging.error("[BR1] {}".format(event))
raise ModelError("API Câmara dos Deputados indisponível")
def test_add_absent_events(self):
absent_events = [
Evento(id='1',
presenca=2,
orgaos=[Orgao(nome='Órgão 1', apelido='')]),
Evento(id='2',
presenca=3,
orgaos=[Orgao(nome='Órgão 1', apelido='')]),
Evento(id='5',
presenca=1,
orgaos=[Orgao(nome='Órgão 4', apelido='')]),
Evento(id='6',
presenca=2,
orgaos=[Orgao(nome='Órgão 4', apelido='PLEN')]),
]
self.dep.relatorio = Relatorio()
self.dep._add_absent_events(absent_events)
self.assertEqual(self.dep.relatorio.eventos_ausentes, absent_events)
absent_events.pop(2)
self.assertEqual(self.dep.relatorio.eventos_previstos, absent_events)
self.assertEqual(self.dep.relatorio.eventos_ausentes_esperados_total,
3)
def test_obter_relatorio_json_existente(self):
brasilia_tz = pytz.timezone('America/Sao_Paulo')
parlamentar = Parlamentar(id='1', cargo='BR1')
relatorio = Relatorio(
parlamentar=parlamentar,
data_final=brasilia_tz.localize(datetime(2019, 1, 8)),
data_inicial=brasilia_tz.localize(datetime(2019, 1, 1)),
).save()
actual_response = Relatorios().obter_relatorio(
'1', '2019-01-08', 'BR1', periodo=7)
self.maxDiff = None
self.assertEqual(
brasilia_tz.normalize(actual_response['dataFinal'].replace(tzinfo=pytz.UTC)),
relatorio.to_dict()['dataFinal']
)
actual_response['dataFinal'] = relatorio.to_dict()['dataFinal']
self.assertEqual(
brasilia_tz.normalize(actual_response['dataInicial'].replace(tzinfo=pytz.UTC)),
relatorio.to_dict()['dataInicial']
)
actual_response['dataInicial'] = relatorio.to_dict()['dataInicial']
self.assertEqual(actual_response, relatorio.to_dict())
def tearDown(self):
Relatorio.drop_collection()
logging.disable(logging.NOTSET)
def __init__(self):
super().__init__()
self.dep = Deputados()
self.relatorio = Relatorio()
self.helper = CamaraDeputadosHelper()
def buscar_por_parlamentar(self, cargo, parlamentar_id):
return json.loads(
Relatorio.objects(parlamentar__id__=parlamentar_id,
parlamentar__cargo=cargo).to_json())
def test_send_email(self, mock_MIMEText, mock_SMTP):
data_inicial = datetime(2019, 10, 12)
data_final = datetime(2019, 10, 19)
parlamentar1 = Parlamentar(id='1', cargo='BR1', nome='AMANDA')
parlamentar2 = Parlamentar(id='2', cargo='BR2', nome='SANTOS')
parlamentar3 = Parlamentar(id='3', cargo='BR1', nome='FULANO')
relatorio1 = Relatorio(parlamentar=parlamentar1,
data_final=data_final,
data_inicial=data_inicial)
relatorio2 = Relatorio(parlamentar=parlamentar2,
data_final=data_final,
data_inicial=data_inicial)
relatorio3 = Relatorio(parlamentar=parlamentar3,
data_final=data_final,
data_inicial=data_inicial)
#Não consegui nem encontrei como mockar Header e MIMEText...
def assert_in(member, container):
return self.assertIn(member, container)
class FakeMIMEText():
def __init__(self, html, *args, **kwargs):
assert_in("AMANDA", html)
assert_in("FULANO", html)
assert_in("SANTOS", html)
assert_in("12/10/2019", html)
assert_in("19/10/2019", html)
def __setitem__(self, name, value):
pass
def as_string(self):
return 'ok'
class FakeSMTP():
def __init__(self, *args, **kwargs):
pass
def starttls(self):
self.starttls_called = True
def ehlo(self):
pass
def login(self, *args):
self.login_args = args
def sendmail(self, *args):
self.sendmail_args = args
def quit(self):
self.quit_called = True
mock_SMTP.side_effect = FakeSMTP
mock_MIMEText.side_effect = FakeMIMEText
send_email(email="*****@*****.**",
reports=[relatorio1, relatorio2, relatorio3],
dates=(data_inicial, data_final))
self.assertEqual(1, mock_SMTP.call_count)
def obter_relatorio(self,
parlamentar_id,
data_final=datetime.now(),
periodo_dias=7):
try:
start_time = time()
self.relatorio = Relatorio()
self.relatorio.aviso_dados = u'Dados de sessões de comissões não disponível.'
self.set_period(periodo_dias)
data_final = datetime.strptime(data_final, '%Y-%m-%d')
data_inicial = self.obterDataInicial(data_final, **self.periodo)
logging.info('[SAO PAULO] Parlamentar: {}'.format(parlamentar_id))
logging.info('[SAO PAULO] Data final: {}'.format(data_final))
logging.info('[SAO PAULO] Intervalo: {}'.format(periodo_dias))
vereador = self.obter_parlamentar(parlamentar_id)
logging.info(
'[SAO PAULO] Vereador obtido em {0:.5f}s'.format(time() -
start_time))
self.relatorio.data_inicial = self.brasilia_tz.localize(
data_inicial)
self.relatorio.data_final = self.brasilia_tz.localize(data_final)
presenca = []
sessao_total = 0
presenca_total = 0
for dia in self.ver.obterPresenca(data_inicial, data_final):
if dia:
for v in dia['vereadores']:
if str(v['chave']) == vereador.id:
for s in v['sessoes']:
if s['presenca'] == 'Presente':
presenca.append(s['nome'])
sessao_total += int(dia['totalOrd']) + int(
dia['totalExtra'])
presenca_total += sum([
int(v['presenteOrd']),
int(v['presenteExtra'])
])
for key, value in dia['sessoes'].items():
evento = Evento()
orgao = Orgao()
orgao.nome = 'Plenário'
orgao.apelido = 'PLENÁRIO'
evento.orgaos.append(orgao)
evento.nome = key
evento.id = str(uuid4())
if value['data']:
try:
evento.data_inicial = self.brasilia_tz.localize(
datetime.strptime(value['data'],
"%d/%m/%Y"))
evento.data_final = self.brasilia_tz.localize(
datetime.strptime(value['data'],
"%d/%m/%Y"))
except ValueError:
pass
for prop in value['pautas']:
proposicao = Proposicao()
proposicao.pauta = prop['projeto']
proposicao.tipo = prop['pauta']
for v in prop['votos']:
if str(v['chave']) == parlamentar_id:
proposicao.voto = v['voto']
evento.pautas.append(proposicao)
if key in presenca:
evento.set_presente()
self.relatorio.eventos_presentes.append(evento)
else:
evento.set_ausencia_evento_esperado()
self.relatorio.eventos_ausentes.append(evento)
logging.info(
'[SAO PAULO] Eventos obtidos em {0:.5f}s'.format(time() -
start_time))
self.relatorio.eventos_ausentes_esperados_total = sessao_total - presenca_total
self.obter_proposicoes_parlamentar(vereador.id, data_inicial,
data_final)
logging.info('[SAO PAULO] Proposicoes obtidas em {0:.5f}s'.format(
time() - start_time))
logging.info(
'[SAO PAULO] Relatorio obtido em {0:.5f}s'.format(time() -
start_time))
return self.relatorio
except Exception as e:
logging.error(e)
raise ModelError(str(e))
def set_up_db(db):
parlamentar_test = set_up_parlamentar()
brasilia_tz = pytz.timezone('America/Sao_Paulo')
orgaos_evento = [
Orgao(nome="ÓrgãoTeste", sigla="OT", cargo="None", apelido="OhTe")
]
eventos_presentes = [
Evento(id="12345",
nome="Evento teste",
data_inicial=brasilia_tz.localize(datetime(2019, 1, 1)),
data_final=brasilia_tz.localize(datetime(2019, 1, 1)),
url="http://url.com",
situacao="Encerrada",
presenca=0,
orgaos=orgaos_evento)
]
eventos_ausentes = [
Evento(id="123",
nome="Evento teste",
data_inicial=brasilia_tz.localize(datetime(2019, 1, 1)),
data_final=brasilia_tz.localize(datetime(2019, 1, 1)),
url="http://url.com",
situacao="Cancelada",
presenca=1,
orgaos=orgaos_evento)
]
Relatorio(
pk=ObjectId("5c264b5e3a5efd576ecaf48e"),
parlamentar=parlamentar_test,
proposicoes=[],
data_inicial=brasilia_tz.localize(datetime(2018, 12, 31)),
data_final=brasilia_tz.localize(datetime(2019, 1, 7)),
orgaos=[],
eventos_presentes=eventos_presentes,
eventos_ausentes=eventos_ausentes,
eventos_previstos=[],
).save()
Avaliacoes(
pk=ObjectId("5c5116f5c3acc80004eada0a"),
email="*****@*****.**",
parlamentar=parlamentar_test,
avaliacao="1",
avaliado={
"url":
"url",
"situacao":
"Cancelada",
"dataFinal":
brasilia_tz.localize(datetime(2019, 1, 1)),
"orgaos": [{
"sigla": "OT",
"nome": "ÓrgãoTeste",
"apelido": "OhTe",
"cargo": None
}],
"dataInicial":
brasilia_tz.localize(datetime(2019, 1, 1)),
"presenca":
1,
"nome":
"Evento teste",
"id":
"123"
},
relatorioId=ObjectId("5c264b5e3a5efd576ecaf48e"),
).save()
inscricoes = Inscricoes(parlamentares=[parlamentar_test], intervalo=7)
User.drop_collection()
User(
username="******",
email="*****@*****.**",
password=
"******",
inscricoes=inscricoes,
devices=[
UserDevice(id="14",
name="dispositivo",
token="---token---",
active=True,
os="Android")
]).save()
def test_generate_reports_multiplos_intervalos(
self,
mock_send_email
):
brasilia_tz = pytz.timezone('America/Sao_Paulo')
agora = datetime(2019, 6, 29)
data_final = datetime(agora.year, agora.month, agora.day)
data_final = brasilia_tz.localize(data_final)
parlamentar1 = Parlamentar(id='1', cargo='BR1')
relatorio1 = Relatorio(
parlamentar=parlamentar1,
data_final=data_final,
data_inicial=data_final - timedelta(days=7)
).save().reload()
relatorio2 = Relatorio(
parlamentar=parlamentar1,
data_final=data_final,
data_inicial=data_final - timedelta(days=14)
).save().reload()
relatorio3 = Relatorio(
parlamentar=parlamentar1,
data_final=data_final,
data_inicial=data_final - timedelta(days=28)
).save().reload()
mock_send_email.return_value = True
users = [
User(
username='******',
password='******',
email='*****@*****.**',
inscricoes=Inscricoes(
parlamentares=[parlamentar1],
intervalo=7
)
),
User(
username='******',
password='******',
email='*****@*****.**',
inscricoes=Inscricoes(
parlamentares=[parlamentar1],
intervalo=14
)
),
User(
username='******',
password='******',
email='*****@*****.**',
inscricoes=Inscricoes(
parlamentares=[parlamentar1],
intervalo=28
)
)
]
generate_reports(users, data_final=agora)
self.assertEqual(mock_send_email.call_count, 3)
mock_send_email.assert_has_calls(
[
call("*****@*****.**", [relatorio1.to_dict()], dates=ANY),
call("*****@*****.**", [relatorio2.to_dict()], dates=ANY),
call("*****@*****.**", [relatorio3.to_dict()], dates=ANY)
]
)
def test_add_attended_events(self):
events_attended = [
Evento(id='3',
data_inicial=self.dep.helper.get_brt(datetime(2019, 12,
10)),
data_final=self.dep.helper.get_brt(datetime(2019, 12, 17))),
Evento(id='4',
data_inicial=self.dep.helper.get_brt(datetime(2019, 12,
10)),
data_final=self.dep.helper.get_brt(datetime(2019, 12, 17)))
]
mock_ev = Mocker(self.dep.helper.ev)
mock_prop = Mocker(self.dep.helper.prop)
mock_ev.add_response("obterPautaEvento", [
{
'codRegime': '123',
'proposicao_': {
'id': '11'
}
},
{
'codRegime': '123',
'proposicao_': {
'id': '12'
}
},
])
mock_ev.add_exception("obterPautaEvento", CamaraDeputadosError)
mock_prop.add_response(
"obterProposicao", {
'id': '11',
'nome': 'Proposição I',
'ementa': 'Proposição I',
'numero': '11',
'ano': 2019
})
mock_prop.add_exception("obterProposicao", CamaraDeputadosError)
mock_prop.add_response("obterVotacoesProposicao", [{
'data':
'15/12/2019',
'hora':
'12:00',
'resumo':
'Votação 1',
'votos': [
{
'id': '23456',
'voto': 'Não'
},
{
'id': '12345',
'voto': 'Sim'
},
{
'id': '34567',
'voto': 'Abstenção'
},
]
}])
mock_prop.add_response("obterVotacoesProposicao", [{
'data':
'16/12/2019',
'hora':
'12:00',
'resumo':
'Votação 2',
'votos': [
{
'id': '23456',
'voto': 'Sim'
},
{
'id': '12345',
'voto': 'Não'
},
{
'id': '34567',
'voto': 'Abstenção'
},
]
}])
self.dep.relatorio = Relatorio(parlamentar=Parlamentar(id='12345'))
self.dep._add_attended_events(events_attended)
self.assertEqual(self.dep.relatorio.eventos_presentes, [
Evento(id='3',
data_inicial=self.dep.helper.get_brt(datetime(2019, 12,
10)),
data_final=self.dep.helper.get_brt(datetime(2019, 12, 17)),
presenca=0,
pautas=[
Proposicao(id='11',
numero='11',
ementa='Proposição I',
pauta='Votação 1 de Proposição I',
voto='Sim')
]),
Evento(id='4',
data_inicial=self.dep.helper.get_brt(datetime(2019, 12,
10)),
data_final=self.dep.helper.get_brt(datetime(2019, 12, 17)),
presenca=0,
pautas=[])
])
def test_send_push_notification_success(self, mock_urllib3):
def assert_equal(actual, expected):
self.assertEqual(actual, expected)
data_inicial = datetime(2019, 10, 12)
data_final = datetime(2019, 10, 19)
parlamentar1 = Parlamentar(id='1', cargo='BR1', nome='AMANDA')
relatorio1 = Relatorio(
id="123",
parlamentar=parlamentar1,
data_final=data_final,
data_inicial=data_inicial,
proposicoes=[
Proposicao(id="1"),
Proposicao(id="2"),
Proposicao(id="3"),
Proposicao(id="4")
],
eventos_presentes=[Evento(id="1"), Evento(id="2")],
eventos_previstos=None,
eventos_ausentes=[Evento(id="4"),
Evento(id="5"),
Evento(id="6")])
expected_reports = [{
"_id": "123",
"parlamentar": parlamentar1.to_dict(),
"mensagem": None,
"dataInicial": str(data_inicial),
"dataFinal": str(data_final),
"orgaos": 0,
"proposicoes": 4,
"eventosPresentes": 2,
"eventosAusentes": 3,
"eventosPrevistos": 0,
"presencaRelativa": "100.00%",
"presencaTotal": "40.00%",
"eventosAusentesEsperadosTotal": 0
}]
class FakePoolManager:
def __init__(self, *args, **kwargs):
pass
def request(self, method, url, headers, body):
class response():
status = 200
data = json.dumps({
'results': [{
'id': '123'
}]
}).encode('utf-8')
assert_equal(method, "POST")
assert_equal(url, "https://fcm.googleapis.com/fcm/send")
assert_equal(
json.loads(body.decode('utf-8'))["data"]["reports"],
expected_reports)
return response()
mock_urllib3.side_effect = FakePoolManager
reports = [relatorio1.to_dict()]
result = send_push_notification("token", reports)
self.assertTrue(mock_urllib3.called)
self.assertTrue(result)
self.assertEqual([relatorio1.to_dict()], reports)
def __init__(self):
super().__init__()
self.ver = CamaraMunicipal()
self.relatorio = Relatorio()
self.brasilia_tz = pytz.timezone('America/Sao_Paulo')
def obter_por_id(self, relatorio_id):
try:
return Relatorio.objects(pk=relatorio_id).first()
except ValidationError:
return None
