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()