def test_update_exploracao_create_licencia(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
lic_nro_first = expected.licencias[0].lic_nro
lic_nro_second = expected.exp_id + '-{:03d}'.format(len(expected.licencias) + 1)
expected_json['licencias'].append({
'lic_nro': None,
'lic_tipo': 'Subterrânea',
'cadastro': 'cadastro',
'estado': 'Irregular',
'd_emissao': '2020-2-2',
'd_validade': '2010-10-10',
'c_soli_tot': 4.3,
'c_soli_int': 2.1,
'c_soli_fon': 2.2,
'c_licencia': 10,
'c_real_tot': 4.3,
'c_real_int': 0,
'c_real_fon': 4.3,
})
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(2, len(actual.licencias))
for lic in actual.licencias:
self.assertIn(lic.lic_nro, [lic_nro_first, lic_nro_second])
def test_update_exploracao_update_licencia(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
lic_gid = expected.licencias[0].gid
lic_nro = expected.licencias[0].lic_nro
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['licencias'][0]['cadastro'] = 'cadastro'
expected_json['licencias'][0]['estado'] = 'Denegada'
expected_json['licencias'][0]['d_emissao'] = '1999-9-9'
expected_json['licencias'][0]['d_validade'] = '1999-8-7'
expected_json['licencias'][0]['c_soli_tot'] = 23.45
expected_json['licencias'][0]['c_soli_int'] = 0.45
expected_json['licencias'][0]['c_soli_fon'] = 23
expected_json['licencias'][0]['c_licencia'] = 999
expected_json['licencias'][0]['c_real_tot'] = 23.45
expected_json['licencias'][0]['c_real_int'] = 0.45
expected_json['licencias'][0]['c_real_fon'] = 23
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(1, len(actual.licencias))
self.assertEquals(lic_gid, actual.licencias[0].gid)
self.assertEquals(lic_nro, actual.licencias[0].lic_nro)
self.assertEquals('cadastro', actual.licencias[0].cadastro)
self.assertEquals('Denegada', actual.licencias[0].estado)
self.assertEquals('1999-09-09', actual.licencias[0].d_emissao.isoformat())
self.assertEquals('1999-08-07', actual.licencias[0].d_validade.isoformat())
self.assertEquals(23.45, float(actual.licencias[0].c_soli_tot))
self.assertEquals(0.45, float(actual.licencias[0].c_soli_int))
self.assertEquals(23, float(actual.licencias[0].c_soli_fon))
self.assertEquals(999, float(actual.licencias[0].c_licencia))
self.assertEquals(23.45, float(actual.licencias[0].c_real_tot))
self.assertEquals(0.45, float(actual.licencias[0].c_real_int))
self.assertEquals(23, float(actual.licencias[0].c_real_fon))
def test_update_exploracao_update_fonte_values(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
gid_fonte = expected.fontes[0].gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['fontes'][0]['tipo_fonte'] = 'Outros'
expected_json['fontes'][0]['lat_lon'] = '23,23 42,21'
expected_json['fontes'][0]['d_dado'] = '2001-01-01'
expected_json['fontes'][0]['c_soli'] = 23.42
expected_json['fontes'][0]['c_max'] = 42.23
expected_json['fontes'][0]['c_real'] = 4.3
expected_json['fontes'][0]['contador'] = False
expected_json['fontes'][0]['metodo_est'] = 'manual'
expected_json['fontes'][0]['observacio'] = 'nao'
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Fonte).filter(Fonte.gid == gid_fonte).first()
self.assertEquals('Outros', actual.tipo_fonte)
self.assertEquals('23,23 42,21', actual.lat_lon)
self.assertEquals('2001-01-01', actual.d_dado.isoformat())
self.assertEquals(23.42, float(actual.c_soli))
self.assertEquals(42.23, float(actual.c_max))
self.assertEquals(4.3, float(actual.c_real))
self.assertEquals(False, actual.contador)
self.assertEquals('manual', actual.metodo_est)
self.assertEquals('nao', actual.observacio)
self.assertEquals(gid, actual.exploracao)
def test_update_exploracao_update_utente_values(self):
exp = self.get_test_exploracao()
gid = exp.gid
self.request.matchdict.update(dict(id=gid))
expected = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
expected_json = build_json(self.request, expected)
expected_json['utente']['nuit'] = 'new nuit'
expected_json['utente']['entidade'] = 'new entidade'
expected_json['utente']['reg_comerc'] = 'new reg_comerc'
expected_json['utente']['reg_zona'] = 'new reg_zona'
expected_json['utente']['loc_provin'] = 'Niassa'
expected_json['utente']['loc_distri'] = 'Lago'
expected_json['utente']['loc_posto'] = 'Cobue'
expected_json['utente']['loc_nucleo'] = 'new loc_nucleo'
expected_json['utente']['observacio'] = 'new observacio'
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals('new nuit', actual.utente_rel.nuit)
self.assertEquals('new entidade', actual.utente_rel.entidade)
self.assertEquals('new reg_comerc', actual.utente_rel.reg_comerc)
self.assertEquals('new reg_zona', actual.utente_rel.reg_zona)
self.assertEquals('Niassa', actual.utente_rel.loc_provin)
self.assertEquals('Lago', actual.utente_rel.loc_distri)
self.assertEquals('Cobue', actual.utente_rel.loc_posto)
self.assertEquals('new loc_nucleo', actual.utente_rel.loc_nucleo)
self.assertEquals('new observacio', actual.utente_rel.observacio)
def test_update_exploracao_update_actividade_pecuaria_delete_res(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-029').first()
self.request.matchdict.update(dict(id=expected.gid))
expected_json = build_json(self.request, expected)
expected_json['actividade']['reses'] = [ res for res in expected_json['actividade']['reses'][0:-1] ]
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-029').first()
reses = actual.actividade.reses
self.assertEquals(2, len(reses))
def test_update_exploracao_delete_fonte(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['fontes'] = []
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(0, len(actual.fontes))
def test_update_exploracao_update_actividade_pecuaria_update_res(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-029').first()
self.request.matchdict.update( dict(id=expected.gid))
expected_json = build_json(self.request, expected)
expected_json['actividade']['reses'][0]['c_estimado'] = 9999.88
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-029').first()
reses = actual.actividade.reses
self.assertEquals(3, len(reses))
self.assertEquals(float(reses[0].c_estimado), 9999.88)
def test_update_exploracao_delete_the_geom(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['geometry_edited'] = True
expected_json['geometry'] = None
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertIsNone(actual.the_geom)
self.assertIsNone(actual.area)
def test_update_exploracao_update_actividade_values(self):
# SELECT a.tipo, e.exp_id FROM actividades AS a INNER JOIN exploracaos AS e ON (a.exploracao = e.gid) ORDER BY exp_id;
# 2010-002 industria
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['actividade']['c_estimado'] = 101.11
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(101.11, float(actual.actividade.c_estimado))
def test_update_exploracao_new_utente(self):
exp = self.get_test_exploracao()
gid = exp.gid
self.request.matchdict.update(dict(id=gid))
expected = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
expected_json = build_json(self.request, expected)
expected_json['utente']['id'] = None
expected_json['utente']['nome'] = 'test nome'
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals('test nome', actual.utente_rel.nome)
def test_update_exploracao_delete_licencia(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
lic_gid = expected.licencias[0].gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['licencias'] = [expected_json['licencias'][0]]
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
lic_count = self.request.db.query(Licencia).filter(Licencia.gid == lic_gid).count()
self.assertEquals(1, len(actual.licencias))
self.assertEquals(1, lic_count)
def test_update_exploracao_update_actividade_not_run_activity_validations(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['utente']['observacio'] = ' foo - bar '
expected_json['observacio'] = ' foo - bar '
expected_json['licencias'][0]['estado'] = u'Denegada'
expected_json['actividade']['c_estimado'] = None
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(' foo - bar ', actual.utente_rel.observacio)
self.assertEquals(u'Denegada', actual.licencias[0].estado)
self.assertIsNone(actual.actividade.c_estimado)
self.assertEquals(' foo - bar ', actual.observacio)
def test_update_exploracao_update_actividade_pecuaria_create_res_with_same_res_tipo(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-029').first()
old_len = len(expected.actividade.reses)
reses_tipo = expected.actividade.reses[0].reses_tipo
self.request.matchdict.update(dict(id=expected.gid))
expected_json = build_json(self.request, expected)
expected_json['actividade']['reses'].append({
'c_estimado': 40,
'reses_tipo': reses_tipo,
'reses_nro': 400,
'c_res': 4000,
'observacio': 'observacio'
})
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-029').first()
reses = actual.actividade.reses
self.assertEquals(old_len + 1, len(reses))
def test_update_exploracao_rename_utente(self):
'''
Tests that the related utente can be renamed from the exploracao,
and a new utente is not created
'''
exp = self.get_test_exploracao()
gid = exp.gid
self.request.matchdict.update(dict(id=gid))
expected = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
expected_utente_gid = expected.utente
expected_json = build_json(self.request, expected)
expected_json['utente']['nome'] = 'foo - bar'
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(expected_utente_gid, actual.utente)
self.assertEquals('foo - bar', actual.utente_rel.nome)
u = self.request.db.query(Utente).filter(Utente.gid == expected_utente_gid).first()
self.assertEquals('foo - bar', u.nome)
def test_update_exploracao_update_actividade_regadia_create_cultivo(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-022').first()
old_len = len(expected.actividade.cultivos)
self.request.matchdict.update(dict(id=expected.gid))
expected_json = build_json(self.request, expected)
expected_json['actividade']['cultivos'].append({
'cultivo': 'Verduras',
'c_estimado': 5,
'rega': 'Gravidade',
'eficiencia': 55,
'observacio': 'observacio'
})
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-022').first()
cultivos = actual.actividade.cultivos
self.assertEquals(old_len + 1, len(cultivos))
self.assertEquals(cultivos[old_len].c_estimado, 5)
self.assertEquals(cultivos[old_len].eficiencia, 55)
self.assertEquals(cultivos[old_len].cult_id, '2010-022-004')
def test_update_exploracao_update_actividade_pecuaria_create_update_delete_res(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-029').first()
self.request.matchdict.update(dict(id=expected.gid))
expected_json = build_json(self.request, expected)
expected_json['actividade']['reses'] = [res for res in expected_json['actividade']['reses'][0:-1]]
expected_json['actividade']['reses'].append({
'c_estimado': 50,
'reses_tipo': 'Vacuno (Vacas)',
'reses_nro': 500,
'c_res': 5000,
})
expected_json['actividade']['reses'][1]['c_estimado'] = 9999.77
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-029').first()
reses = actual.actividade.reses
self.assertEquals(3, len(reses))
self.assertEquals(float(reses[1].c_estimado), 9999.77)
self.assertEquals(reses[2].c_estimado, 50)
self.assertEquals(reses[2].c_res, 5000)
def test_update_exploracao_change_actividade(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
gid_actividade = expected.actividade.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
# change from industria to saneamento
expected_json['actividade'] = {
'id': None,
'tipo': u'Saneamento',
'c_estimado': 23,
'habitantes': 42
}
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
count_actividade = self.request.db.query(Actividade).filter(Actividade.gid == gid_actividade).count()
self.assertEquals(0, count_actividade) # was deleted
self.assertEquals('Saneamento', actual.actividade.tipo)
self.assertEquals(23, actual.actividade.c_estimado)
self.assertEquals(42, actual.actividade.habitantes)
def test_update_exploracao_create_fonte(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['fontes'].append({
'tipo_agua': 'Subterrânea',
'tipo_fonte': 'Outros',
'lat_lon': '23,23 42,21',
'd_dado': '2001-01-01',
'c_soli': 23.42,
'c_max': 42.23,
'c_real': 4.3,
'contador': False,
'metodo_est': 'manual',
'observacio': 'nao'
})
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(2, len(actual.fontes))
def test_update_exploracao_the_geom(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['geometry_edited'] = True
expected_json['geometry'] = {
"type": "MultiPolygon",
"coordinates": [[[
[40.3566078671374, -12.8577371684984],
[40.3773594643965, -12.8576290475983],
[40.3774400124151, -12.8723906015176],
[40.3566872025163, -12.8724988506617],
[40.3566078671374, -12.8577371684984]
]]]
}
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
# SELECT st_area(st_transform(ST_GeomFromText( 'MULTIPOLYGON(((40.3566078671374 -12.8577371684984, 40.3773594643965 -12.8576290475983, 40.3774400124151 -12.8723906015176, 40.3566872025163 -12.8724988506617, 40.3566078671374 -12.8577371684984)))', 4326 ), 32737));
self.assertAlmostEquals(367.77, float(actual.area))
def test_update_exploracao(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
expected_json['exp_name'] = 'new name'
expected_json['pagos'] = None
expected_json['d_soli'] = '2001-01-01'
expected_json['observacio'] = 'new observ'
expected_json['loc_provin'] = 'Niassa'
expected_json['loc_distri'] = 'Lago'
expected_json['loc_posto'] = 'Cobue'
expected_json['loc_nucleo'] = 'new loc_nucleo'
expected_json['loc_endere'] = 'new enderezo'
expected_json['loc_bacia'] = 'Megaruma'
expected_json['loc_subaci'] = 'Megaruma'
expected_json['loc_rio'] = 'Megaruma'
expected_json['c_soli'] = 19.02
expected_json['c_licencia'] = 29
expected_json['c_real'] = 92
expected_json['c_estimado'] = 42.23
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals('new name', actual.exp_name)
self.assertEquals(None, actual.pagos)
self.assertEquals('2001-01-01', actual.d_soli.isoformat())
self.assertEquals('new observ', actual.observacio)
self.assertEquals('Niassa', actual.loc_provin)
self.assertEquals('Lago', actual.loc_distri)
self.assertEquals('Cobue', actual.loc_posto)
self.assertEquals('new loc_nucleo', actual.loc_nucleo)
self.assertEquals('new enderezo', actual.loc_endere)
self.assertEquals('Megaruma', actual.loc_bacia)
self.assertEquals('Megaruma', actual.loc_subaci)
self.assertEquals('Megaruma', actual.loc_rio)
self.assertEquals(19.02, float(actual.c_soli))
self.assertEquals(29, float(actual.c_licencia))
self.assertEquals(92, float(actual.c_real))
self.assertEquals(42.23, float(actual.c_estimado))
def test_update_exploracao_change_utente(self):
exp = self.get_test_exploracao()
gid = exp.gid
utente = self.get_test_utente()
self.request.matchdict.update(dict(id=gid))
expected = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
expected_json = build_json(self.request, expected)
expected_json['utente']['id'] = utente.gid
expected_json['utente']['nome'] = utente.nome
expected_json['utente']['nuit'] = utente.nuit
expected_json['utente']['entidade'] = utente.entidade
expected_json['utente']['reg_comerc'] = utente.reg_comerc
expected_json['utente']['reg_zona'] = utente.reg_zona
expected_json['utente']['loc_provin'] = utente.loc_provin
expected_json['utente']['loc_distri'] = utente.loc_distri
expected_json['utente']['loc_posto'] = utente.loc_posto
expected_json['utente']['loc_nucleo'] = utente.loc_nucleo
expected_json['utente']['observacio'] = utente.observacio
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(utente.nome, actual.utente_rel.nome)
def test_update_exploracao_create_licencia_update_lic_nro(self):
expected = self.request.db.query(Exploracao).filter(Exploracao.exp_id == '2010-002').first()
gid = expected.gid
self.request.matchdict.update(dict(id=gid))
expected_json = build_json(self.request, expected)
# in test data, lic_nro_first is 'expid-001'
lic_nro_first = expected.licencias[0].lic_nro
lic_nro_second = expected.exp_id + '-002'
lic_nro_third = expected.exp_id + '-003'
expected_json['licencias'].append({
'lic_nro': None,
'lic_tipo': 'Subterrânea',
'cadastro': 'cadastro',
'estado': 'Irregular',
'c_soli_tot': 4.3,
'c_soli_int': 2.1,
'c_soli_fon': 2.2,
'c_licencia': 10,
'c_real_tot': 4.3,
'c_real_int': 0,
'c_real_fon': 4.3,
})
self.request.json_body = expected_json
exploracaos_update(self.request)
actual = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(2, len(actual.licencias))
for lic in actual.licencias:
self.assertIn(lic.lic_nro, [lic_nro_first, lic_nro_second])
# delete first license, with lic_nro expid-001
expected_json = build_json(self.request, actual)
for lic in expected_json['licencias']:
if lic['lic_nro'] == lic_nro_first:
expected_json['licencias'].remove(lic)
break
self.request.json_body = expected_json
exploracaos_update(self.request)
# add new one
expected_json['licencias'].append({
'lic_nro': None,
'lic_tipo': 'Superficial',
'estado': 'Irregular',
})
self.request.json_body = expected_json
exploracaos_update(self.request)
exploracao = self.request.db.query(Exploracao).filter(Exploracao.gid == gid).first()
self.assertEquals(2, len(exploracao.licencias))
for lic in exploracao.licencias:
self.assertIn(lic.lic_nro, [lic_nro_second, lic_nro_third])