def test_delete_references(self):
collection = OrganizationCollectionFactory()
source = OrganizationSourceFactory()
concept1 = ConceptFactory(parent=source)
concept2 = ConceptFactory(parent=source)
mapping = MappingFactory(from_concept=concept1,
to_concept=concept2,
parent=source)
collection.add_references([concept1.uri, concept2.uri, mapping.uri])
self.assertEqual(collection.concepts.count(), 2)
self.assertEqual(collection.mappings.count(), 1)
self.assertEqual(collection.references.count(), 3)
collection.delete_references([
concept2.get_latest_version().uri,
mapping.get_latest_version().uri
])
self.assertEqual(collection.concepts.count(), 1)
self.assertEqual(collection.mappings.count(), 0)
self.assertEqual(collection.references.count(), 1)
self.assertEqual(collection.concepts.first().uri,
concept1.get_latest_version().uri)
self.assertEqual(collection.references.first().expression,
concept1.get_latest_version().uri)
def test_seed_children_task(self):
collection = OrganizationCollectionFactory()
concept = ConceptFactory()
mapping = MappingFactory()
concept_latest_version = concept.get_latest_version()
mapping_latest_version = mapping.get_latest_version()
collection.add_references([
concept_latest_version.version_url,
mapping_latest_version.version_url
])
self.assertEqual(collection.references.count(), 2)
self.assertEqual(collection.concepts.count(), 1)
self.assertEqual(collection.mappings.count(), 1)
collection_v1 = OrganizationCollectionFactory(
organization=collection.organization,
version='v1',
mnemonic=collection.mnemonic)
self.assertEqual(collection_v1.references.count(), 0)
self.assertEqual(collection_v1.concepts.count(), 0)
self.assertEqual(collection_v1.mappings.count(), 0)
seed_children('collection', collection_v1.id) # pylint: disable=no-value-for-parameter
self.assertEqual(collection_v1.references.count(), 2)
self.assertEqual(collection_v1.concepts.count(), 1)
self.assertEqual(collection_v1.mappings.count(), 1)
self.assertEqual(
list(collection_v1.references.values_list('expression',
flat=True)),
list(collection.references.values_list('expression', flat=True)),
)
def test_get_200_for_concept_version(self):
concept_latest_version = self.concept.get_latest_version()
mappings_url = concept_latest_version.uri + 'mappings/'
response = self.client.get(mappings_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
direct_mapping = MappingFactory(parent=self.concept.parent,
from_concept=concept_latest_version)
indirect_mapping = MappingFactory(parent=self.concept.parent,
to_concept=concept_latest_version)
response = self.client.get(mappings_url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['uuid'], str(direct_mapping.id))
response = self.client.get(mappings_url +
'?includeInverseMappings=true')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual(
sorted([mapping['uuid'] for mapping in response.data]),
sorted([str(direct_mapping.id),
str(indirect_mapping.id)]))
def test_single_mapping_between_concepts(self):
source = OrganizationSourceFactory(
version=HEAD,
custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
concept1 = ConceptFactory(parent=source,
names=[LocalizedTextFactory()])
concept2 = ConceptFactory(parent=source,
names=[LocalizedTextFactory()])
mapping1 = MappingFactory.build(parent=source,
to_concept=concept1,
from_concept=concept2)
mapping1.clean()
mapping1.save()
mapping2 = MappingFactory.build(parent=source,
to_concept=concept1,
from_concept=concept2)
with self.assertRaises(ValidationError) as ex:
mapping2.clean()
self.assertEqual(
ex.exception.messages,
['There can be only one mapping between two concepts'])
mapping3 = MappingFactory.build(parent=source,
to_concept=concept2,
from_concept=concept1)
mapping3.clean()
def test_invalid_map_type(self):
source = OrganizationSourceFactory(
version=HEAD,
custom_validation_schema=CUSTOM_VALIDATION_SCHEMA_OPENMRS)
concept1 = ConceptFactory(parent=source,
names=[LocalizedTextFactory()])
concept2 = ConceptFactory(parent=source,
names=[LocalizedTextFactory()])
mapping = MappingFactory.build(parent=source,
to_concept=concept1,
from_concept=concept2,
map_type='Foo bar')
mapping.populate_fields_from_relations({})
with self.assertRaises(ValidationError) as ex:
mapping.clean()
self.assertEqual(ex.exception.messages, ['Invalid mapping type'])
# 'Q-AND-A' is present in OpenMRS lookup values
mapping = MappingFactory.build(parent=source,
to_concept=concept1,
from_concept=concept2,
map_type='Q-AND-A')
mapping.populate_fields_from_relations({})
mapping.clean()
def test_export_collection(self, s3_mock): # pylint: disable=too-many-locals
s3_mock.url_for = Mock(return_value='https://s3-url')
s3_mock.upload_file = Mock()
source = OrganizationSourceFactory()
concept1 = ConceptFactory(parent=source)
concept2 = ConceptFactory(parent=source)
mapping = MappingFactory(from_concept=concept2,
to_concept=concept1,
parent=source)
collection = OrganizationCollectionFactory()
collection.add_references([concept1.uri, concept2.uri, mapping.uri])
collection.refresh_from_db()
export_collection(collection.id) # pylint: disable=no-value-for-parameter
latest_temp_dir = get_latest_dir_in_path('/tmp/')
zipped_file = zipfile.ZipFile(latest_temp_dir + '/export.zip')
exported_data = json.loads(
zipped_file.read('export.json').decode('utf-8'))
self.assertEqual(
exported_data, {
**CollectionDetailSerializer(collection).data, 'concepts': ANY,
'mappings': ANY
})
exported_concepts = exported_data['concepts']
expected_concepts = ConceptVersionDetailSerializer(
[concept2.get_latest_version(),
concept1.get_latest_version()],
many=True).data
self.assertEqual(len(exported_concepts), 2)
self.assertIn(expected_concepts[0], exported_concepts)
self.assertIn(expected_concepts[1], exported_concepts)
exported_mappings = exported_data['mappings']
expected_mappings = MappingDetailSerializer(
[mapping.get_latest_version()], many=True).data
self.assertEqual(len(exported_mappings), 1)
self.assertEqual(expected_mappings, exported_mappings)
s3_upload_key = collection.export_path
s3_mock.upload_file.assert_called_once_with(key=s3_upload_key,
file_path=latest_temp_dir +
'/export.zip',
binary=True)
s3_mock.url_for.assert_called_once_with(s3_upload_key)
import shutil
shutil.rmtree(latest_temp_dir)
def test_get_200(self):
response = self.client.get('/mappings/', format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
mapping = MappingFactory()
response = self.client.get('/mappings/', format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
response = self.client.get(mapping.parent.mappings_url, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
collection = OrganizationCollectionFactory()
response = self.client.get(collection.mappings_url, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 0)
collection.add_references(expressions=[mapping.uri])
response = self.client.get(collection.mappings_url, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
def test_delete_204_specific_expression(self):
response = self.client.delete(
'/collections/coll/references/',
dict(expressions=[self.concept.get_latest_version().uri]),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 204)
self.assertEqual(self.collection.references.count(), 0)
self.assertEqual(self.collection.concepts.count(), 0)
concept = ConceptFactory()
latest_version = concept.get_latest_version()
MappingFactory(from_concept=latest_version, parent=concept.parent)
response = self.client.put(
'/collections/coll/references/?cascade=sourcemappings',
dict(data=dict(mappings=[latest_version.uri])),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.collection.refresh_from_db()
self.assertEqual(self.collection.references.count(), 2)
self.assertEqual(self.collection.concepts.count(), 1)
self.assertEqual(self.collection.mappings.count(), 1)
response = self.client.delete(
'/collections/coll/references/?cascade=sourcemappings',
dict(expressions=[latest_version.uri]),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 204)
self.collection.refresh_from_db()
self.assertEqual(self.collection.references.count(), 0)
self.assertEqual(self.collection.concepts.count(), 0)
self.assertEqual(self.collection.mappings.count(), 0)
def test_get_200_with_mappings(self):
concept1 = ConceptFactory(parent=self.source, mnemonic='conceptA')
concept2 = ConceptFactory(parent=self.source, mnemonic='conceptB')
mapping = MappingFactory(parent=self.source,
from_concept=concept2.get_latest_version(),
to_concept=concept1.get_latest_version())
response = self.client.get("/concepts/",
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
self.assertEqual([response.data[0]['id'], response.data[1]['id']],
[concept2.mnemonic, concept1.mnemonic])
self.assertEqual(response['num_found'], '2')
self.assertEqual(response['num_returned'], '2')
self.assertFalse(response.has_header('previous'))
self.assertFalse(response.has_header('next'))
response = self.client.get(
"/concepts/?limit=1&verbose=true&includeMappings=true",
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], concept2.mnemonic)
self.assertEqual(len(response.data[0]['mappings']), 1)
self.assertEqual(response.data[0]['mappings'][0]['uuid'],
str(mapping.id))
self.assertEqual(response['num_found'], '2')
self.assertEqual(response['num_returned'], '1')
self.assertTrue(
'/concepts/?limit=1&verbose=true&includeMappings=true&page=2' in
response['next'])
self.assertFalse(response.has_header('previous'))
response = self.client.get(
"/concepts/?page=2&limit=1&verbose=true&includeInverseMappings=true",
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['id'], concept1.mnemonic)
self.assertEqual(response['num_found'], '2')
self.assertEqual(response['num_returned'], '1')
self.assertEqual(len(response.data[0]['mappings']), 1)
self.assertEqual(response.data[0]['mappings'][0]['uuid'],
str(mapping.id))
self.assertTrue(
'/concepts/?page=1&limit=1&verbose=true&includeInverseMappings=true'
in response['previous'])
self.assertFalse(response.has_header('next'))
def test_last_child_update(self):
collection = OrganizationCollectionFactory()
self.assertEqual(collection.last_child_update, collection.updated_at)
mapping = MappingFactory()
collection.mappings.add(mapping)
self.assertEqual(collection.last_child_update, mapping.updated_at)
concept = ConceptFactory()
collection.concepts.add(concept)
self.assertEqual(collection.last_child_update, concept.updated_at)
def test_add_references_task(self):
collection = OrganizationCollectionFactory()
concept1 = ConceptFactory()
concept2 = ConceptFactory()
mapping1 = MappingFactory(parent=concept2.parent,
from_concept=concept2.get_latest_version(),
to_concept=concept1.get_latest_version())
mapping2 = MappingFactory()
added_references, errors = add_references(
collection.created_by,
dict(expressions=[
obj.get_latest_version().version_url
for obj in [concept1, concept2, mapping2]
]), collection, None, True)
self.assertEqual(errors, {})
self.assertEqual(len(added_references), 4)
self.assertListEqual(
sorted([ref.expression for ref in added_references]),
sorted([
concept1.get_latest_version().version_url,
concept2.get_latest_version().version_url,
mapping1.get_latest_version().version_url,
mapping2.get_latest_version().version_url,
]))
def test_persist_clone(self):
source_head = OrganizationSourceFactory(version=HEAD)
source_version0 = OrganizationSourceFactory(
version='v0',
mnemonic=source_head.mnemonic,
organization=source_head.organization)
self.assertEqual(source_head.versions.count(), 2)
mapping = MappingFactory(parent=source_version0)
cloned_mapping = mapping.clone(mapping.created_by)
self.assertEqual(
Mapping.persist_clone(cloned_mapping),
dict(
version_created_by=
'Must specify which user is attempting to create a new mapping version.'
))
self.assertEqual(
Mapping.persist_clone(cloned_mapping, mapping.created_by), {})
persisted_mapping = Mapping.objects.filter(
id=cloned_mapping.id, version=cloned_mapping.version).first()
self.assertEqual(mapping.versions.count(), 2)
self.assertNotEqual(mapping.id, persisted_mapping.id)
self.assertEqual(persisted_mapping.from_concept_id,
mapping.from_concept_id)
self.assertEqual(persisted_mapping.to_concept_id,
mapping.to_concept_id)
self.assertEqual(persisted_mapping.parent, source_version0)
self.assertEqual(persisted_mapping.sources.count(), 2)
self.assertEqual(source_head.mappings.first().id, persisted_mapping.id)
self.assertEqual(
persisted_mapping.uri,
'/orgs/{}/sources/{}/{}/mappings/{}/{}/'.format(
source_version0.organization.mnemonic,
source_version0.mnemonic, source_version0.version,
persisted_mapping.mnemonic, persisted_mapping.version))
self.assertEqual(persisted_mapping.version_url, persisted_mapping.uri)
def test_get_mappings(self): # pylint: disable=too-many-locals
source1 = OrganizationSourceFactory()
source2 = OrganizationSourceFactory()
concept1 = ConceptFactory(parent=source1)
concept2 = ConceptFactory(parent=source1)
concept3 = ConceptFactory(parent=source2)
concept4 = ConceptFactory(parent=source2)
mapping1 = MappingFactory(from_concept=concept1,
to_concept=concept2,
parent=source1)
mapping2 = MappingFactory(from_concept=concept1,
to_concept=concept3,
parent=source1)
mapping3 = MappingFactory(from_concept=concept1,
to_concept=concept3,
parent=source2)
mapping4 = MappingFactory(from_concept=concept4,
to_concept=concept1,
parent=source1)
mapping5 = MappingFactory(from_concept=concept4,
to_concept=concept1,
parent=source2)
MappingFactory(from_concept=concept1,
to_concept=concept2,
parent=source2)
mappings = concept1.get_unidirectional_mappings()
self.assertEqual(mappings.count(), 2)
self.assertEqual(list(mappings), [mapping2, mapping1])
mappings = concept1.get_indirect_mappings()
self.assertEqual(mappings.count(), 1)
self.assertEqual(list(mappings), [mapping4])
mappings = concept1.get_bidirectional_mappings()
self.assertEqual(mappings.count(), 3)
self.assertEqual(list(mappings), [mapping4, mapping2, mapping1])
mappings = concept2.get_unidirectional_mappings()
self.assertEqual(mappings.count(), 0)
mappings = concept2.get_indirect_mappings()
self.assertEqual(mappings.count(), 1)
self.assertEqual(list(mappings), [mapping1])
mappings = concept3.get_unidirectional_mappings()
self.assertEqual(mappings.count(), 0)
mappings = concept3.get_indirect_mappings()
self.assertEqual(mappings.count(), 1)
self.assertEqual(list(mappings), [mapping3])
mappings = concept4.get_unidirectional_mappings()
self.assertEqual(mappings.count(), 1)
self.assertEqual(list(mappings), [mapping5])
mappings = concept4.get_indirect_mappings()
self.assertEqual(mappings.count(), 0)
def test_seed_children_task_with_export(self, export_source_task, index_children_mock):
source = OrganizationSourceFactory()
ConceptFactory(parent=source)
MappingFactory(parent=source)
source_v1 = OrganizationSourceFactory(organization=source.organization, version='v1', mnemonic=source.mnemonic)
self.assertEqual(source_v1.concepts.count(), 0)
self.assertEqual(source_v1.mappings.count(), 0)
seed_children('source', source_v1.id) # pylint: disable=no-value-for-parameter
self.assertEqual(source_v1.concepts.count(), 1)
self.assertEqual(source_v1.mappings.count(), 1)
export_source_task.delay.assert_called_once_with(source_v1.id)
index_children_mock.assert_called_once()
def test_seed_children_task(self):
source = OrganizationSourceFactory()
ConceptFactory(parent=source)
MappingFactory(parent=source)
source_v1 = OrganizationSourceFactory(organization=source.organization,
version='v1',
mnemonic=source.mnemonic)
self.assertEqual(source_v1.concepts.count(), 0)
self.assertEqual(source_v1.mappings.count(), 0)
seed_children('source', source_v1.id) # pylint: disable=no-value-for-parameter
self.assertEqual(source_v1.concepts.count(), 1)
self.assertEqual(source_v1.mappings.count(), 1)
class MappingVersionsViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.user = UserProfileFactory()
self.token = self.user.get_token()
self.source = UserSourceFactory(user=self.user)
self.mapping = MappingFactory(parent=self.source)
def test_get_200(self):
latest_version = self.mapping.get_latest_version()
response = self.client.get(self.mapping.url + 'versions/')
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 1)
self.assertTrue(response.data[0]['is_latest_version'])
self.assertEqual(response.data[0]['version_url'], latest_version.uri)
self.assertEqual(response.data[0]['versioned_object_id'], self.mapping.id)
class MappingVersionRetrieveViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.user = UserProfileFactory()
self.token = self.user.get_token()
self.source = UserSourceFactory(user=self.user)
self.mapping = MappingFactory(parent=self.source)
def test_get_200(self):
latest_version = self.mapping.get_latest_version()
response = self.client.get(self.mapping.url + '{}/'.format(latest_version.id))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['is_latest_version'], True)
self.assertEqual(response.data['version_url'], latest_version.uri)
self.assertEqual(response.data['versioned_object_id'], self.mapping.id)
def test_get_404(self):
response = self.client.get(self.mapping.url + '123/')
self.assertEqual(response.status_code, 404)
def test_put_200_specific_expression(self):
response = self.client.put(
'/collections/coll/references/',
dict(data=dict(concepts=[self.concept.uri])),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, [
dict(
added=False,
expression=self.concept.uri,
message=[
'Concept or Mapping reference name must be unique in a collection.'
])
])
concept2 = ConceptFactory()
response = self.client.put('/collections/coll/references/',
dict(data=dict(concepts=[concept2.uri])),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.collection.refresh_from_db()
self.assertEqual(self.collection.references.count(), 2)
self.assertEqual(self.collection.concepts.count(), 2)
self.assertEqual(self.collection.active_concepts, 2)
self.assertEqual(self.collection.active_mappings, 0)
self.assertTrue(
self.collection.references.filter(
expression=concept2.get_latest_version().uri).exists())
self.assertEqual(response.data, [
dict(
added=True,
expression=concept2.get_latest_version().uri,
message=
'Added the latest versions of concept to the collection. Future updates will not be added'
' automatically.')
])
mapping = MappingFactory(from_concept=concept2,
to_concept=self.concept,
parent=self.concept.parent)
response = self.client.put('/collections/coll/references/',
dict(data=dict(mappings=[mapping.uri])),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.collection.refresh_from_db()
self.assertEqual(self.collection.references.count(), 3)
self.assertEqual(self.collection.concepts.count(), 2)
self.assertEqual(self.collection.mappings.count(), 1)
self.assertEqual(self.collection.active_concepts, 2)
self.assertEqual(self.collection.active_mappings, 1)
self.assertTrue(
self.collection.references.filter(
expression=mapping.get_latest_version().uri).exists())
self.assertEqual(response.data, [
dict(
added=True,
expression=mapping.get_latest_version().uri,
message=
'Added the latest versions of mapping to the collection. Future updates will not be added'
' automatically.')
])
concept3 = ConceptFactory()
latest_version = concept3.get_latest_version()
mapping2 = MappingFactory(from_concept=latest_version,
parent=concept3.parent)
response = self.client.put(
'/collections/coll/references/?cascade=sourcemappings',
dict(data=dict(concepts=[latest_version.uri])),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json')
self.assertEqual(response.status_code, 200)
self.collection.refresh_from_db()
self.assertEqual(self.collection.references.count(), 5)
self.assertEqual(self.collection.concepts.count(), 3)
self.assertEqual(self.collection.mappings.count(), 2)
self.assertEqual(self.collection.active_concepts, 3)
self.assertEqual(self.collection.active_mappings, 2)
self.assertTrue(
self.collection.references.filter(
expression=mapping2.get_latest_version().uri).exists())
self.assertTrue(
self.collection.references.filter(
expression=latest_version.uri).exists())
class MappingRetrieveUpdateDestroyViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.user = UserProfileFactory()
self.token = self.user.get_token()
self.source = UserSourceFactory(user=self.user)
self.mapping = MappingFactory(parent=self.source)
def test_get_200(self):
response = self.client.get(self.mapping.uri, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['uuid'], str(self.mapping.get_latest_version().id))
def test_get_404(self):
response = self.client.get(
self.source.mappings_url + '123/', format='json'
)
self.assertEqual(response.status_code, 404)
def test_put_200(self):
self.assertEqual(self.mapping.versions.count(), 1)
self.assertEqual(self.mapping.get_latest_version().map_type, SAME_AS)
response = self.client.put(
self.mapping.uri,
dict(map_type='narrower than'),
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data['uuid'], str(self.mapping.get_latest_version().id))
self.assertEqual(response.data['map_type'], 'narrower than')
self.assertEqual(self.mapping.versions.count(), 2)
self.assertEqual(self.mapping.get_latest_version().map_type, 'narrower than')
self.mapping.refresh_from_db()
self.assertEqual(self.mapping.map_type, 'narrower than')
def test_put_400(self):
self.assertEqual(self.mapping.versions.count(), 1)
self.assertEqual(self.mapping.get_latest_version().map_type, SAME_AS)
response = self.client.put(
self.mapping.uri,
dict(map_type=''),
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.data, dict(map_type=[ErrorDetail(string='This field may not be blank.', code='blank')])
)
self.assertEqual(self.mapping.versions.count(), 1)
def test_delete_204(self):
self.assertEqual(self.mapping.versions.count(), 1)
self.assertFalse(self.mapping.get_latest_version().retired)
response = self.client.delete(
self.mapping.uri,
HTTP_AUTHORIZATION='Token ' + self.token,
)
self.assertEqual(response.status_code, 204)
self.assertEqual(self.mapping.versions.count(), 2)
self.assertFalse(self.mapping.versions.first().retired)
latest_version = self.mapping.get_latest_version()
self.assertTrue(latest_version.retired)
self.assertEqual(latest_version.comment, 'Mapping was retired')
self.mapping.refresh_from_db()
self.assertTrue(self.mapping.retired)
def setUp(self):
super().setUp()
self.user = UserProfileFactory()
self.token = self.user.get_token()
self.source = UserSourceFactory(user=self.user)
self.mapping = MappingFactory(parent=self.source)
class MappingExtraRetrieveUpdateDestroyViewTest(OCLAPITestCase):
def setUp(self):
super().setUp()
self.extras = dict(foo='bar', tao='ching')
self.mapping = MappingFactory(extras=self.extras)
self.user = UserProfileFactory(organizations=[self.mapping.parent.organization])
self.token = self.user.get_token()
def test_get_200(self):
response = self.client.get(self.mapping.uri + 'extras/foo/', format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict(foo='bar'))
def test_get_404(self):
response = self.client.get(self.mapping.uri + 'extras/bar/', format='json')
self.assertEqual(response.status_code, 404)
def test_put_200(self):
self.assertEqual(self.mapping.versions.count(), 1)
self.assertEqual(self.mapping.get_latest_version().extras, self.extras)
self.assertEqual(self.mapping.extras, self.extras)
response = self.client.put(
self.mapping.uri + 'extras/foo/',
dict(foo='foobar'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data, dict(foo='foobar'))
self.assertEqual(self.mapping.versions.count(), 2)
self.assertEqual(self.mapping.get_latest_version().extras, dict(foo='foobar', tao='ching'))
self.mapping.refresh_from_db()
self.assertEqual(self.mapping.extras, dict(foo='foobar', tao='ching'))
def test_put_400(self):
self.assertEqual(self.mapping.versions.count(), 1)
self.assertEqual(self.mapping.get_latest_version().extras, self.extras)
self.assertEqual(self.mapping.extras, self.extras)
response = self.client.put(
self.mapping.uri + 'extras/foo/',
dict(tao='foobar'),
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, ['Must specify foo param in body.'])
self.assertEqual(self.mapping.versions.count(), 1)
self.assertEqual(self.mapping.get_latest_version().extras, self.extras)
self.mapping.refresh_from_db()
self.assertEqual(self.mapping.extras, self.extras)
def test_delete_204(self):
self.assertEqual(self.mapping.versions.count(), 1)
self.assertEqual(self.mapping.get_latest_version().extras, self.extras)
self.assertEqual(self.mapping.extras, self.extras)
response = self.client.delete(
self.mapping.uri + 'extras/foo/',
HTTP_AUTHORIZATION='Token ' + self.token,
format='json'
)
self.assertEqual(response.status_code, 204)
self.assertEqual(self.mapping.versions.count(), 2)
self.assertEqual(self.mapping.get_latest_version().extras, dict(tao='ching'))
self.assertEqual(self.mapping.versions.first().extras, dict(foo='bar', tao='ching'))
self.mapping.refresh_from_db()
self.assertEqual(self.mapping.extras, dict(tao='ching'))
def test_last_mapping_update(self):
collection = OrganizationCollectionFactory()
self.assertIsNone(collection.last_mapping_update)
mapping = MappingFactory()
collection.mappings.add(mapping)
self.assertEqual(collection.last_mapping_update, mapping.updated_at)
def setUp(self):
super().setUp()
self.extras = dict(foo='bar', tao='ching')
self.mapping = MappingFactory(extras=self.extras)
self.user = UserProfileFactory(organizations=[self.mapping.parent.organization])
self.token = self.user.get_token()
