def test_gerachaverecinto_and_sign(self):
recinto = '00001'
private_key_pem, assinado = UseCases.gera_chaves_recinto(
self.db_session, recinto)
public_key_pem = UseCases.get_public_key(self.db_session, recinto)
private_key = assinador.load_private_key(private_key_pem)
public_key = assinador.load_public_key(public_key_pem)
message = b'TESTE'
signed = assinador.sign(message, private_key)
assinador.verify(signed, message, public_key)
def getfile():
db_session = current_app.config['db_session']
try:
IDEvento = request.form.get('IDEvento')
tipoevento = request.form.get('tipoevento')
nomearquivo = request.form.get('nomearquivo')
if not tipoevento:
raise Exception('Parâmetro tipoevento é obrigatório.')
try:
aclass = getattr(orm, tipoevento)
except AttributeError:
raise AttributeError('tipoevento "%s" não existente' % tipoevento)
except TypeError:
raise AttributeError('tipoevento "%s": erro ao processar parâmetro' %
tipoevento)
evento = db_session.query(aclass).filter(
aclass.IDEvento == IDEvento
).one_or_none()
if evento is None:
return jsonify(_response('Evento não encontrado.', 404)), 404
oanexo = UseCases.get_anexo(evento, nomearquivo)
basepath = current_app.config.get('UPLOAD_FOLDER')
oanexo.load_file(basepath)
print(oanexo.content)
return Response(response=oanexo.content,
mimetype=oanexo.contentType
), 200
except Exception as err:
logging.error(err, exc_info=True)
return jsonify(_response(err, 400)), 400
def test_recinto1(self):
"""Cria chave para recinto, manda chave
"""
# login
# manda recinto, senha
# recebe chaveprivada, assina recinto
recinto = '00001'
private_key_pem, assinado = UseCases.gera_chaves_recinto(
self.db_session, recinto)
private_key = assinador.load_private_key(private_key_pem)
assinado = assinador.sign(recinto.encode('utf-8'), private_key)
assinado = b85encode(assinado).decode('utf-8')
# manda recinto encriptado com chave
# recebe OK com chave correta
payload = {'assinado': assinado, 'recinto': recinto}
token = authentication.generate_token(payload)
request = Request({'Authorization': 'Bearer %s' % token}, payload)
assert authentication.valida_assinatura(request,
self.db_session)[0] is True
# manda recinto sem encriptar, recebe erro
payload = {'assinado': recinto, 'recinto': recinto}
token = authentication.generate_token(payload)
request = Request({'Authorization': 'Bearer %s' % token}, payload)
assert authentication.valida_assinatura(request,
self.db_session)[0] is False
# manda assinado com outra chave, recebe erro
private_key2, _ = assinador.generate_keys()
assinado2 = assinador.sign(recinto.encode('utf-8'), private_key2)
payload2 = {'assinado': assinado2, 'recinto': recinto}
token2 = authentication.generate_token(payload2)
request2 = Request({'Authorization': 'Bearer %s' % token2}, payload2)
assert authentication.valida_assinatura(request2,
self.db_session)[0] is False
def uploadfile():
"""Função simplificada para upload de arquivo para um Evento."""
db_session = current_app.config['db_session']
usecase = create_usecases()
try:
file = request.files.get('file')
IDEvento = request.form.get('IDEvento')
tipoevento = request.form.get('tipoevento')
nomearquivo = request.form.get('nomearquivo')
tipoanexo = request.form.get('tipoanexo')
validfile, mensagem = usecase.valid_file(file)
if not validfile:
return jsonify(_response(mensagem, 400)), 400
aclass = getattr(orm, tipoevento)
evento = db_session.query(aclass).filter(
aclass.IDEvento == IDEvento).one_or_none()
if evento is None:
return jsonify(_response('Evento não encontrado.', 404)), 404
db_session.add(evento)
oanexo = UseCases.get_anexo(evento, nomearquivo)
if oanexo is None:
classeanexo = getattr(orm, tipoanexo)
oanexo = classeanexo.create(evento)
basepath = current_app.config.get('UPLOAD_FOLDER')
oanexo.save_file(basepath, file.read(), file.filename)
db_session.add(oanexo)
return jsonify(_commit(evento)), 201
except Exception as err:
logger.error(str(err), exc_info=True)
return jsonify(_response(err, 400)), 400
def get_private_key():
recinto = request.json.get('recinto')
try:
private_key_pem, assinado = UseCases.gera_chaves_recinto(
current_app.config['db_session'],
recinto
)
return jsonify({'pem': private_key_pem.decode('utf-8'),
'assinado': b85encode(assinado).decode('utf-8')}), 200
except Exception as err:
logging.error(err, exc_info=True)
return jsonify(_response(err, 400)), 400
class UseCaseTestCase(BaseTestCase):
def setUp(self):
super().setUp()
self.usecase = UseCases(self.db_session, '')
def _insert(self, classe_evento):
evento = self.open_json_test_case(classe_evento)
return self.usecase.insert_evento(classe_evento, evento)
def _load(self, classe_evento, IDEvento):
return self.usecase.load_evento(classe_evento, IDEvento)
def _insert_and_load(self, classe_evento):
evento = self.open_json_test_case(classe_evento)
evento_banco = self._insert(classe_evento)
evento_banco_load = self._load(classe_evento, evento['IDEvento'])
self.compara_eventos(evento, evento_banco.dump())
self.compara_eventos(evento, evento_banco_load.dump())
def test_InspecaonaoInvasiva(self):
evento = self.open_json_test_case(orm.InspecaonaoInvasiva)
evento_banco = self.usecase.insert_inspecaonaoinvasiva(evento)
evento_banco_load = self.usecase.load_inspecaonaoinvasiva(
evento['codRecinto'], evento['idEvento'])
print(sorted(evento.items(), key=lambda x: x[0]))
print(sorted(evento_banco_load.items(), key=lambda x: x[0]))
self.compara_eventos(evento, evento_banco_load)
# assert False
def test_PesagemVeiculoCarga(self):
evento = self.open_json_test_case(orm.PesagemVeiculoCarga)
evento_banco = self.usecase.insert_pesagemveiculocarga(evento)
evento_banco_load = self.usecase.load_pesagemveiculocarga(
evento['codRecinto'], evento['idEvento'])
print(sorted(evento.items(), key=lambda x: x[0]))
print(sorted(evento_banco_load.items(), key=lambda x: x[0]))
self.compara_eventos(evento, evento_banco_load)
def test_acessoveiculo(self):
evento = self.open_json_test_case(orm.AcessoVeiculo)
evento_banco = self.usecase.insert_acessoveiculo(evento)
evento_banco_load = self.usecase.load_acessoveiculo(
evento['codRecinto'], evento['idEvento'])
print(sorted(evento.items(), key=lambda x: x[0]))
print(sorted(evento_banco_load.items(), key=lambda x: x[0]))
self.compara_eventos(evento, evento_banco_load)
self.purge_datas(evento)
self.purge_datas(evento_banco_load)
self.assertDictContainsSubset(evento, evento_banco_load)
def getfile():
db_session = current_app.config['db_session']
try:
IDEvento = request.form.get('IDEvento')
tipoevento = request.form.get('tipoevento')
nomearquivo = request.form.get('nomearquivo')
aclass = getattr(orm, tipoevento)
evento = db_session.query(aclass).filter(
aclass.IDEvento == IDEvento).one_or_none()
if evento is None:
return jsonify(_response('Evento não encontrado.', 404)), 404
oanexo = UseCases.get_anexo(evento, nomearquivo)
basepath = current_app.config.get('UPLOAD_FOLDER')
oanexo.load_file(basepath)
print(oanexo.content)
return Response(response=oanexo.content,
mimetype=oanexo.contentType), 200
except Exception as err:
logging.error(err, exc_info=True)
return jsonify(_response(err, 400)), 400
def carrega(dir, arquivo, envio):
"""Script de linha de comando para validar ou enviar JSON de Eventos.
--arquivo Se somente arquivo for informado, valida o arquivo, gravando erros
detalhados caso ocorram no arquivo com final .erros.log,
no mesmo diretório e nome do arquivo passado
--envio Se parâmetro envio forem informados, tentará enviar arquivo para API.
--dir Por último, o parâmetro dir serve para indicar um diretório com imagens
que será utilizado para gerar um arquivo JSON do Evento (não implementado)
"""
with open(os.path.join(BASE_DIR, arquivo), 'r') as json_in:
testes = json.load(json_in)
filehandler = logging.FileHandler(
os.path.join(BASE_DIR, arquivo + '.erros.log'))
print(filehandler.baseFilename)
logger = logging.getLogger()
logger.addHandler(filehandler)
if envio: # Conecta ao Servidor e imprime resultado na tela
rv = requests.post(envio + '/set_eventos',
files={'file': (testes.read(), arquivo)})
else: # Valida arquivo json com BD na memória
print('Criando Banco na memória para testes')
session, engine = orm.init_db('sqlite:///:memory:')
orm.Base.metadata.create_all(bind=engine)
usecases = UseCases(session, 'TESTE', 'localhost', '.')
ind = 1
for classe, eventos in testes.items():
print('Evento numero %d Tipo %s' % (ind, classe))
aclass = getattr(orm, classe)
if isinstance(eventos, list):
for evento in eventos:
valida_evento(usecases, aclass, evento, logger, ind)
ind += 1
else:
valida_evento(usecases, aclass, eventos, logger, ind)
ind += 1
def setUp(self):
super().setUp()
self.usecase = UseCases(self.db_session, '')
def create_usecases():
db_session = current_app.config['db_session']
basepath = current_app.config['UPLOAD_FOLDER']
return UseCases(db_session, basepath)
def setUp(self):
super().setUp()
self.usecase = UseCases(self.db_session, RECINTO, REQUEST_IP, '')
class UseCaseTestCase(BaseTestCase):
def setUp(self):
super().setUp()
self.usecase = UseCases(self.db_session, RECINTO, REQUEST_IP, '')
def _insert(self, classe_evento):
evento = self.testes[classe_evento.__name__]
return self.usecase.insert_evento(classe_evento, evento)
def _load(self, classe_evento, IDEvento):
return self.usecase.load_evento(classe_evento, IDEvento)
def _insert_and_load(self, classe_evento):
evento = self.testes[classe_evento.__name__]
evento_banco = self._insert(classe_evento)
evento_banco_load = self._load(classe_evento, evento['IDEvento'])
self.compara_eventos(evento, evento_banco.dump())
self.compara_eventos(evento, evento_banco_load.dump())
def test_AcessoPessoa(self):
self._insert_and_load(orm.AcessoPessoa)
def test_PesagemMaritimo(self):
self._insert_and_load(orm.PesagemMaritimo)
def test_PosicaoConteiner(self):
self._insert_and_load(orm.PosicaoConteiner)
def test_AvariaLote(self):
self._insert_and_load(orm.AvariaLote)
def test_PosicaoLote(self):
self._insert_and_load(orm.PosicaoLote)
def test_Ocorrencia(self):
self._insert_and_load(orm.Ocorrencia)
def test_OperacaoNavio(self):
self._insert_and_load(orm.OperacaoNavio)
def test_InspecaonaoInvasiva(self):
evento = self.testes['InspecaonaoInvasiva']
evento_banco = self.usecase.insert_inspecaonaoinvasiva(evento)
self.compara_eventos(evento, evento_banco.dump())
evento_banco_load = self.usecase.load_inspecaonaoinvasiva(
evento['IDEvento'])
self.compara_eventos(evento, evento_banco_load)
def test_DTSC(self):
self._insert_and_load(orm.DTSC)
def test_ChavePublicaRecinto(self):
"""Adiciona dois recintos de numero diferente e checa chaves"""
chave_recinto1 = orm.ChavePublicaRecinto('00001',
b'MIIBIjANBgkqhkiG9w0B')
chave_recinto2 = orm.ChavePublicaRecinto('00002', b'TESTE123')
self.db_session.add(chave_recinto1)
self.db_session.add(chave_recinto2)
self.db_session.commit()
assert chave_recinto1.public_key == \
orm.ChavePublicaRecinto.get_public_key(self.db_session,
chave_recinto1.recinto)
assert chave_recinto2.public_key == \
orm.ChavePublicaRecinto.get_public_key(self.db_session,
chave_recinto2.recinto)
assert chave_recinto1.public_key != \
orm.ChavePublicaRecinto.get_public_key(self.db_session,
chave_recinto2.recinto)
def test_ChavePublicaRecinto_change(self):
"""Adiciona dois recintos de numero igual.
Usando classe, dará erro de integridade.
Usando set_public_key, chave deve ser editada."""
chave_recinto1 = orm.ChavePublicaRecinto('00001',
b'MIIBIjANBgkqhkiG9w0B')
chave_recinto2 = orm.ChavePublicaRecinto('00001', b'TESTE123')
self.db_session.add(chave_recinto1)
self.db_session.add(chave_recinto2)
try:
self.db_session.commit()
assert False # Deveria ter dado exceção
except IntegrityError:
self.db_session.rollback()
chave_recinto1 = orm.ChavePublicaRecinto.set_public_key(
self.db_session, '00001', b'MIIBIjANBgkqhkiG9w0B')
assert chave_recinto1.public_key == \
orm.ChavePublicaRecinto.get_public_key(self.db_session,
chave_recinto1.recinto)
chave_recinto2 = orm.ChavePublicaRecinto.set_public_key(
self.db_session, '00001', b'TESTE123')
assert chave_recinto2.public_key == \
orm.ChavePublicaRecinto.get_public_key(self.db_session,
chave_recinto2.recinto)
def test_gerachaverecinto_and_sign(self):
recinto = '00001'
private_key_pem, assinado = UseCases.gera_chaves_recinto(
self.db_session, recinto)
public_key_pem = UseCases.get_public_key(self.db_session, recinto)
private_key = assinador.load_private_key(private_key_pem)
public_key = assinador.load_public_key(public_key_pem)
message = b'TESTE'
signed = assinador.sign(message, private_key)
assinador.verify(signed, message, public_key)