def test_concept_should_have_exactly_one_preferred_name_per_locale_negative(
self):
user = create_user()
source_with_open_mrs = create_source(
user,
validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
kwargs = {
'org': self.org1.mnemonic,
'source': source_with_open_mrs.mnemonic
}
data = json.dumps(
open_mrs_concept_template({
"names": [{
"name": "grip",
"locale": 'en',
"name_type": "FULLY_SPECIFIED",
"locale_preferred": True
}, {
"name": "grip2",
"locale": 'en',
"name_type": "FULLY_SPECIFIED",
"locale_preferred": True
}]
}))
response = self.client.post(reverse('concept-create', kwargs=kwargs),
data,
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_update_concept_with_invalid_record(self):
(concept, _) = create_concept(mnemonic='1',
user=self.user1,
source=self.source1,
names=[self.name])
self.testfile = open(
'./integration_tests/fixtures/concept_without_fully_specified_name.json',
'rb')
stderr_stub = TestStream()
source = create_source(
self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source,
self.testfile,
'test',
TestStream(),
stderr_stub,
save_validation_errors=False)
importer.import_concepts(total=1)
self.assertTrue(OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME in
stderr_stub.getvalue())
self.assertEquals(
1,
Concept.objects.exclude(
concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
self.assertEquals(
1,
ConceptVersion.objects.exclude(
concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
def test_import_concepts_into_openmrs_validated_source_with_valid_records(
self):
test_file = open(
'./integration_tests/fixtures/concepts_for_openmrs_validation.json',
'rb')
stderr_stub = TestStream()
user = create_user()
source = create_source(
user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source, test_file, 'test', TestStream(),
stderr_stub)
importer.import_concepts(total=5)
self.assertTrue(
"Custom validation rules require a concept to have exactly one preferred name"
in stderr_stub.getvalue())
self.assertTrue(
"Custom validation rules require a preferred name to be different than a short name"
in stderr_stub.getvalue())
self.assertTrue(
"Custom validation rules require a preferred name not to be an index/search term"
in stderr_stub.getvalue())
self.assertTrue(
"Custom validation rules require all names except type=SHORT to be unique"
in stderr_stub.getvalue())
self.assertEquals(
2,
Concept.objects.exclude(concept_class='Concept Class').count())
self.assertEquals(
2,
ConceptVersion.objects.exclude(
concept_class='Concept Class').count())
def test_create_concept_without_description_negative(self):
user = create_user()
source_with_open_mrs = create_source(
user,
validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
kwargs = {
'org': self.org1.mnemonic,
'source': source_with_open_mrs.mnemonic
}
data = json.dumps({
"id":
"12399000",
"concept_class":
"conceptclass",
"names": [{
"name": "grip",
"locale": 'en',
"name_type": "FULLY_SPECIFIED"
}]
})
response = self.client.post(reverse('concept-create', kwargs=kwargs),
data,
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_name_should_be_unique_unless_short_term_positive(self):
user = create_user()
source_with_open_mrs = create_source(
user,
validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
kwargs = {
'org': self.org1.mnemonic,
'source': source_with_open_mrs.mnemonic
}
data = json.dumps(
open_mrs_concept_template({
"names": [{
"name": "grip",
"locale": 'en',
"name_type": "SHORT"
}, {
"name": "grip",
"locale": 'en',
"name_type": "SHORT"
}, {
"name": "grip",
"locale": 'en',
"name_type": "FULLY_SPECIFIED"
}]
}))
response = self.client.post(reverse('concept-create', kwargs=kwargs),
data,
content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test_name_should_be_unique_unless_short_term_positive(self):
user = create_user()
source_with_open_mrs = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
kwargs = {'org': self.org1.mnemonic, 'source': source_with_open_mrs.mnemonic}
data = json.dumps(open_mrs_concept_template(
{"names":
[{
"name": "grip",
"locale": 'en',
"name_type": "SHORT"
}, {
"name": "grip",
"locale": 'en',
"name_type": "SHORT"
}, {
"name": "grip",
"locale": 'en',
"name_type": "FULLY_SPECIFIED"
}]
}
))
response = self.client.post(reverse('concept-create', kwargs=kwargs), data, content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test_import_single_concept_without_fully_specified_name(self):
self.testfile = open('./integration_tests/fixtures/concept_without_fully_specified_name.json', 'rb')
stderr_stub = TestStream()
source = create_source(self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source, self.testfile, 'test', TestStream(), stderr_stub, save_validation_errors=False)
importer.import_concepts(total=1)
self.assertTrue(OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME in stderr_stub.getvalue())
def test_concept_should_have_exactly_one_preferred_name_per_locale_negative(self):
user = create_user()
source_with_open_mrs = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
kwargs = {'org': self.org1.mnemonic, 'source': source_with_open_mrs.mnemonic}
data = json.dumps(open_mrs_concept_template(
{"names":
[{
"name": "grip",
"locale": 'en',
"name_type": "FULLY_SPECIFIED",
"locale_preferred": True
}, {
"name": "grip2",
"locale": 'en',
"name_type": "FULLY_SPECIFIED",
"locale_preferred": True
}]
}
))
response = self.client.post(reverse('concept-create', kwargs=kwargs), data, content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_import_concepts_into_openmrs_validated_source_with_valid_records(
self):
test_file = open(
'./integration_tests/fixtures/concepts_for_openmrs_validation.json',
'rb')
stderr_stub = TestStream()
user = create_user()
source = create_source(
user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source,
test_file,
'test',
TestStream(),
stderr_stub,
save_validation_errors=False)
importer.import_concepts(total=5)
self.assertTrue(OPENMRS_MUST_HAVE_EXACTLY_ONE_PREFERRED_NAME in
stderr_stub.getvalue())
self.assertTrue(
OPENMRS_SHORT_NAME_CANNOT_BE_PREFERRED in stderr_stub.getvalue())
self.assertTrue(
OPENMRS_SHORT_NAME_CANNOT_BE_PREFERRED in stderr_stub.getvalue())
self.assertTrue(OPENMRS_NAMES_EXCEPT_SHORT_MUST_BE_UNIQUE in
stderr_stub.getvalue())
self.assertEquals(
2,
Concept.objects.exclude(
concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
self.assertEquals(
2,
ConceptVersion.objects.exclude(
concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
def test_create_mapping_duplicate_mapping_between_two_concepts(self):
source = create_source(
self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
(concept1, _) = create_concept(user=self.user1, source=source)
(concept2, _) = create_concept(user=self.user1, source=source)
self.client.login(username='******', password='******')
kwargs = {'source': source.mnemonic}
mapping1 = {
'from_concept_url': concept1.url,
'to_concept_url': concept2.url,
'map_type': 'Same As'
}
mapping2 = {
'from_concept_url': concept1.url,
'to_concept_url': concept2.url,
'map_type': 'Narrower Than'
}
self.client.post(reverse('mapping-list', kwargs=kwargs), mapping1)
response = self.client.post(reverse('mapping-list', kwargs=kwargs),
mapping2)
self.assertEquals(response.status_code, 400)
self.assertEquals(
response.data,
{"errors": OPENMRS_SINGLE_MAPPING_BETWEEN_TWO_CONCEPTS})
def test_import_concepts_with_invalid_records(self):
self.testfile = open(
'./integration_tests/fixtures/valid_invalid_concepts.json', 'rb')
stderr_stub = TestStream()
source = create_source(
self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source,
self.testfile,
'test',
TestStream(),
stderr_stub,
save_validation_errors=False)
importer.import_concepts(total=7)
self.assertTrue(OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME in
stderr_stub.getvalue())
self.assertTrue(OPENMRS_FULLY_SPECIFIED_NAME_UNIQUE_PER_SOURCE_LOCALE
in stderr_stub.getvalue())
self.assertEquals(
5,
Concept.objects.exclude(
concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
self.assertEquals(
5,
ConceptVersion.objects.exclude(
concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
def test_create_mapping_duplicate_mapping_between_two_concepts(self):
source = create_source(self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
(concept1, _) = create_concept(user=self.user1, source=source)
(concept2, _) = create_concept(user=self.user1, source=source)
self.client.login(username='******', password='******')
kwargs = {
'source': source.mnemonic
}
mapping1 = {
'from_concept_url': concept1.url,
'to_concept_url': concept2.url,
'map_type': 'Same As'
}
mapping2 = {
'from_concept_url': concept1.url,
'to_concept_url': concept2.url,
'map_type': 'Narrower Than'
}
self.client.post(reverse('mapping-list', kwargs=kwargs), mapping1)
response = self.client.post(reverse('mapping-list', kwargs=kwargs), mapping2)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.data, {"errors": OPENMRS_SINGLE_MAPPING_BETWEEN_TWO_CONCEPTS})
def create_source_and_user_fixture(self):
user = create_user()
source_with_open_mrs = create_source(
user,
validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
return source_with_open_mrs, user
def test_import_concepts_with_invalid_records(self):
self.testfile = open('./integration_tests/fixtures/valid_invalid_concepts.json', 'rb')
stderr_stub = TestStream()
source = create_source(self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source, self.testfile, 'test', TestStream(), stderr_stub, save_validation_errors=False)
importer.import_concepts(total=7)
self.assertTrue(OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME in stderr_stub.getvalue())
self.assertTrue(OPENMRS_FULLY_SPECIFIED_NAME_UNIQUE_PER_SOURCE_LOCALE in stderr_stub.getvalue())
self.assertEquals(5, Concept.objects.exclude(concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
self.assertEquals(5, ConceptVersion.objects.exclude(concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
def test_update_concept_with_invalid_record(self):
(concept, _) = create_concept(mnemonic='1', user=self.user1, source=self.source1, names=[self.name])
self.testfile = open('./integration_tests/fixtures/concept_without_fully_specified_name.json', 'rb')
stderr_stub = TestStream()
source = create_source(self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source, self.testfile, 'test', TestStream(), stderr_stub, save_validation_errors=False)
importer.import_concepts(total=1)
self.assertTrue(OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME in stderr_stub.getvalue())
self.assertEquals(1, Concept.objects.exclude(concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
self.assertEquals(1, ConceptVersion.objects.exclude(concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
def test_concepts_should_have_unique_fully_specified_name_per_locale_positive(self):
user = create_user()
source_with_open_mrs = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
kwargs = {'org': self.org1.mnemonic, 'source': source_with_open_mrs.mnemonic}
data = json.dumps(open_mrs_concept_template())
response = self.client.post(reverse('concept-create', kwargs=kwargs), data, content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test_concept_id_should_allow_underscore_positive(self):
user = create_user()
source_with_open_mrs = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
kwargs = {'org': self.org1.mnemonic, 'source': source_with_open_mrs.mnemonic}
data = json.dumps(underscore_concept_template())
response = self.client.post(reverse('concept-create', kwargs=kwargs), data, content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_201_CREATED)
def test_validation_error_file_output(self):
self.testfile = open("./integration_tests/fixtures/valid_invalid_concepts.json", "rb")
stderr_stub = TestStream()
logger = ValidationLogger(output=TestStream())
source = create_source(self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source, self.testfile, "test", TestStream(), stderr_stub, validation_logger=logger)
importer.import_concepts(total=7)
self.assertTrue("MNEMONIC;ERROR;JSON" in logger.output.getvalue())
self.assertTrue("4;%s" % OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME in logger.output.getvalue())
self.assertTrue("7;%s" % OPENMRS_FULLY_SPECIFIED_NAME_UNIQUE_PER_SOURCE_LOCALE in logger.output.getvalue())
def test_validation_error_file_exists(self):
self.testfile = open('./integration_tests/fixtures/valid_invalid_concepts.json', 'rb')
stderr_stub = TestStream()
output_file_name = 'test_file.csv'
logger = ValidationLogger(output_file_name=output_file_name)
importer = ConceptsImporter(create_source(user=self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS), self.testfile, 'test', TestStream(), stderr_stub,
validation_logger=logger)
importer.import_concepts(total=7)
from os import path, remove
self.assertTrue(path.exists(output_file_name))
remove(output_file_name)
def test_import_concepts_into_openmrs_validated_source_with_valid_records(self):
test_file = open("./integration_tests/fixtures/concepts_for_openmrs_validation.json", "rb")
stderr_stub = TestStream()
user = create_user()
source = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source, test_file, "test", TestStream(), stderr_stub, save_validation_errors=False)
importer.import_concepts(total=5)
self.assertTrue(OPENMRS_MUST_HAVE_EXACTLY_ONE_PREFERRED_NAME in stderr_stub.getvalue())
self.assertTrue(OPENMRS_SHORT_NAME_CANNOT_BE_PREFERRED in stderr_stub.getvalue())
self.assertTrue(OPENMRS_SHORT_NAME_CANNOT_BE_PREFERRED in stderr_stub.getvalue())
self.assertTrue(OPENMRS_NAMES_EXCEPT_SHORT_MUST_BE_UNIQUE in stderr_stub.getvalue())
self.assertEquals(2, Concept.objects.exclude(concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
self.assertEquals(2, ConceptVersion.objects.exclude(concept_class__in=LOOKUP_CONCEPT_CLASSES).count())
def test_import_concepts_into_openmrs_validated_source_with_valid_records(self):
test_file = open('./integration_tests/fixtures/concepts_for_openmrs_validation.json', 'rb')
stderr_stub = TestStream()
user = create_user()
source = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source, test_file, 'test', TestStream(), stderr_stub)
importer.import_concepts(total=5)
self.assertTrue("Custom validation rules require a concept to have exactly one preferred name" in stderr_stub.getvalue())
self.assertTrue("Custom validation rules require a preferred name to be different than a short name" in stderr_stub.getvalue())
self.assertTrue("Custom validation rules require a preferred name not to be an index/search term" in stderr_stub.getvalue())
self.assertTrue("Custom validation rules require all names except type=SHORT to be unique" in stderr_stub.getvalue())
self.assertEquals(2, Concept.objects.count())
self.assertEquals(2, ConceptVersion.objects.count())
def test_import_single_concept_without_fully_specified_name(self):
self.testfile = open(
'./integration_tests/fixtures/concept_without_fully_specified_name.json',
'rb')
stderr_stub = TestStream()
source = create_source(
self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source,
self.testfile,
'test',
TestStream(),
stderr_stub,
save_validation_errors=False)
importer.import_concepts(total=1)
self.assertTrue(OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME in
stderr_stub.getvalue())
def test_create_concept_without_description_negative(self):
user = create_user()
source_with_open_mrs = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
kwargs = {'org': self.org1.mnemonic, 'source': source_with_open_mrs.mnemonic}
data = json.dumps({
"id": "12399000",
"concept_class": "conceptclass",
"names": [{
"name": "grip",
"locale": 'en',
"name_type": "FULLY_SPECIFIED"
}]
})
response = self.client.post(reverse('concept-create', kwargs=kwargs), data, content_type='application/json')
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_validation_error_file_exists(self):
self.testfile = open(
'./integration_tests/fixtures/valid_invalid_concepts.json', 'rb')
stderr_stub = TestStream()
output_file_name = 'test_file.csv'
logger = ValidationLogger(output_file_name=output_file_name)
importer = ConceptsImporter(create_source(
user=self.user1,
validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS),
self.testfile,
'test',
TestStream(),
stderr_stub,
validation_logger=logger)
importer.import_concepts(total=7)
from os import path, remove
self.assertTrue(path.exists(output_file_name))
remove(output_file_name)
def test_create_mapping_maptype_without_found_lookup(self):
source = create_source(
self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
(concept1, _) = create_concept(user=self.user1, source=source)
(concept2, _) = create_concept(user=self.user1, source=source)
self.client.login(username='******', password='******')
kwargs = {'source': source.mnemonic}
mapping = {
'from_concept_url': concept1.url,
'to_concept_url': concept2.url,
'map_type': 'Wrong Map Type'
}
response = self.client.post(reverse('mapping-list', kwargs=kwargs),
mapping)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.data,
{'errors': 'map_type : ' + OPENMRS_INVALID_MAPTYPE})
def test_create_mapping_maptype_without_found_lookup(self):
source = create_source(self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
(concept1, _) = create_concept(user=self.user1, source=source)
(concept2, _) = create_concept(user=self.user1, source=source)
self.client.login(username='******', password='******')
kwargs = {
'source': source.mnemonic
}
mapping = {
'from_concept_url': concept1.url,
'to_concept_url': concept2.url,
'map_type': 'Wrong Map Type'
}
response = self.client.post(reverse('mapping-list', kwargs=kwargs), mapping)
self.assertEquals(response.status_code, 400)
self.assertEquals(response.data, {'errors': 'map_type : ' + OPENMRS_INVALID_MAPTYPE})
def test_validation_error_file_output(self):
self.testfile = open(
'./integration_tests/fixtures/valid_invalid_concepts.json', 'rb')
stderr_stub = TestStream()
logger = ValidationLogger(output=TestStream())
source = create_source(
self.user1, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
importer = ConceptsImporter(source,
self.testfile,
'test',
TestStream(),
stderr_stub,
validation_logger=logger)
importer.import_concepts(total=7)
self.assertTrue('MNEMONIC;ERROR;JSON' in logger.output.getvalue())
self.assertTrue('4;%s' % OPENMRS_AT_LEAST_ONE_FULLY_SPECIFIED_NAME in
logger.output.getvalue())
self.assertTrue('7;%s' %
OPENMRS_FULLY_SPECIFIED_NAME_UNIQUE_PER_SOURCE_LOCALE
in logger.output.getvalue())
def create_source_and_user_fixture(self):
user = create_user()
source_with_open_mrs = create_source(user, validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS,
organization=self.org1)
self.client.login(username=user.username, password=user.password)
return source_with_open_mrs, user
