def test_idioma(self):
populate_catalog.main(['-c', 'idioma'])
self.assertEqual(Idioma.objects.count(), 3)
with open(os.path.join(os.path.join(DATA_DIR, 'Idioma.json')),
encoding="utf-8") as jsonf:
expected_idiomas = json.load(jsonf)
for expected_idioma_data in expected_idiomas:
idioma = Idioma.objects(_id=expected_idioma_data['iso_639_3'])
self.assertEqual(idioma.count(), 1)
idioma = idioma[0].to_mongo()
for k in expected_idioma_data:
self.assertEqual(expected_idioma_data[k], idioma[k])
def test_pais(self):
populate_catalog.main(['-c', 'pais'])
self.assertEqual(Pais.objects.count(), 3)
with open(os.path.join(os.path.join(DATA_DIR, 'Pais.json')),
encoding="utf-8") as jsonf:
expected_paises = json.load(jsonf)
for expected_pais_data in expected_paises:
pais = Pais.objects(_id=expected_pais_data['alpha2'])
self.assertEqual(pais.count(), 1)
pais = pais[0].to_mongo()
for k in expected_pais_data:
self.assertEqual(expected_pais_data[k], pais[k])
def test_sherpa_romeo(self):
populate_catalog.main(['-c', 'sherpa_romeo'])
self.assertEqual(SherpaRomeo.objects.count(), 4)
with open(os.path.join(os.path.join(DATA_DIR, 'SherpaRomeo.json')),
encoding="utf-8") as jsonf:
expected_sherpa_romeos = json.load(jsonf)
for expected_sherpa_romeo in expected_sherpa_romeos:
sherpa_romeo = SherpaRomeo.objects(
color__es=expected_sherpa_romeo['color']['es'])
self.assertEqual(sherpa_romeo.count(), 1)
sherpa_romeo = sherpa_romeo[0].to_mongo()
for k in expected_sherpa_romeo:
self.assertEqual(expected_sherpa_romeo[k], sherpa_romeo[k])
# Verificar que no ingresen registros repetidos
populate_catalog.main(['-c', 'sherpa_romeo'])
self.assertEqual(SherpaRomeo.objects.count(), 4)
def test_licencia_cc(self):
populate_catalog.main(['-c', 'licencia_cc'])
self.assertEqual(LicenciaCC.objects.count(), 3)
with open(os.path.join(os.path.join(DATA_DIR, 'LicenciaCC.json')),
encoding="utf-8") as jsonf:
expected_licencias_cc = json.load(jsonf)
for expected_licencia_cc in expected_licencias_cc:
licencia_cc = LicenciaCC.objects(
tipo=expected_licencia_cc['tipo'])
self.assertEqual(licencia_cc.count(), 1)
licencia_cc = licencia_cc[0].to_mongo()
for k in expected_licencia_cc:
self.assertEqual(expected_licencia_cc[k], licencia_cc[k])
# Verificar que no ingresen registros repetidos
populate_catalog.main(['-c', 'licencia_cc'])
self.assertEqual(LicenciaCC.objects.count(), 3)
def test_disciplina(self):
populate_catalog.main(['-c', 'disciplina'])
self.assertEqual(Disciplina.objects.count(), 3)
with open(os.path.join(os.path.join(DATA_DIR, 'Disciplina.json')),
encoding="utf-8") as jsonf:
expected_disciplinas = json.load(jsonf)
for expected_disciplina in expected_disciplinas:
disciplina = Disciplina.objects(
nombre__es=expected_disciplina['nombre']['es'])
self.assertEqual(disciplina.count(), 1)
disciplina = disciplina[0].to_mongo()
for k in expected_disciplina:
self.assertEqual(expected_disciplina[k], disciplina[k])
# Verificar que no ingresen registros repetidos
populate_catalog.main(['-c', 'disciplina'])
self.assertEqual(Disciplina.objects.count(), 3)
def test_tipo_documento(self):
populate_catalog.main(['-c', 'tipo_documento'])
self.assertEqual(TipoDocumento.objects.count(), 3)
with open(os.path.join(os.path.join(DATA_DIR, 'TipoDocumento.json')),
encoding="utf-8") as jsonf:
expected_tipos_documento = json.load(jsonf)
for expected_tipo_documento in expected_tipos_documento:
tipo_documento = TipoDocumento.objects(
nombre__es=expected_tipo_documento['nombre']['es'])
self.assertEqual(tipo_documento.count(), 1)
tipo_documento = tipo_documento[0].to_mongo()
for k in expected_tipo_documento:
self.assertDictEqual(expected_tipo_documento[k],
tipo_documento[k])
# Verificar que no ingresen registros repetidos
populate_catalog.main(['-c', 'tipo_documento'])
self.assertEqual(TipoDocumento.objects.count(), 3)
def test_nombre_geografico(self):
populate_catalog.main(['-c', 'nombre_geografico'])
self.assertEqual(NombreGeografico.objects.count(), 3)
with open(os.path.join(os.path.join(DATA_DIR,
'NombreGeografico.json')),
encoding="utf-8") as jsonf:
expected_nombres_geograficos = json.load(jsonf)
for expected_nombre_geografico in expected_nombres_geograficos:
nombre_geografico = NombreGeografico.objects(
nombre__es=expected_nombre_geografico['nombre']['es'])
self.assertEqual(nombre_geografico.count(), 1)
nombre_geografico = nombre_geografico[0].to_mongo()
for k in expected_nombre_geografico:
self.assertEqual(expected_nombre_geografico[k],
nombre_geografico[k])
# Verificar que no ingresen registros repetidos
populate_catalog.main(['-c', 'nombre_geografico'])
self.assertEqual(NombreGeografico.objects.count(), 3)
def test_tipo_documento_invalid_id(self):
populate_catalog.main(['-c', 'tipo_documento'])
self.assertEqual(TipoDocumento.objects.count(), 0)
def test_idioma_long_value(self):
populate_catalog.main(['-c', 'idioma'])
self.assertEqual(Idioma.objects.count(), 0)
def test_pais_long_value(self):
populate_catalog.main(['-c', 'pais'])
self.assertEqual(Pais.objects.count(), 0)
def test_sherpa_romeo_invalid_id(self):
populate_catalog.main(['-c', 'sherpa_romeo'])
self.assertEqual(SherpaRomeo.objects.count(), 0)
def test_licencia_cc_invalid_id(self):
populate_catalog.main(['-c', 'licencia_cc'])
self.assertEqual(LicenciaCC.objects.count(), 0)
def test_nombre_geografico_invalid_id(self):
populate_catalog.main(['-c', 'nombre_geografico'])
self.assertEqual(Disciplina.objects.count(), 0)
def test_subdisciplina_invalid_id(self):
populate_catalog.main(['-c', 'subdisciplina'])
self.assertEqual(SubDisciplina.objects.count(), 0)
def test_enfoque_documento_invalid_id(self):
populate_catalog.main(['-c', 'enfoque_documento'])
self.assertEqual(EnfoqueDocumento.objects.count(), 0)
