def update(context, request): """Update the fields we received and store the updated version.""" annotation = context.model # Read the new fields for the annotation try: fields = request.json_body except ValueError: return _api_error(request, 'No JSON payload sent. Annotation not created.', status_code=400) # Client Error: Bad Request try: appstruct = schemas.AnnotationSchema().validate(fields) except schemas.ValidationError as err: return _api_error(request, err.message, status_code=400) # Update and store the annotation try: logic.update_annotation(annotation, appstruct, userid=request.authenticated_userid) except RuntimeError as err: return _api_error(request, err.args[0], status_code=err.args[1]) # Notify any subscribers _publish_annotation_event(request, annotation, 'update') # Return the updated version that was just stored. return search_lib.render(annotation)
def test_annotationschema_removes_protected_fields(field): data = {} data[field] = 'something forbidden' result = schemas.AnnotationSchema().validate(data) assert field not in result
def test_it_raises_if_document_is_not_a_dict(self): schema = schemas.AnnotationSchema() with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(document=False, )) assert str(err.value) == "document: False is not of type 'object'"
def test_it_raises_if_text_is_not_a_string(self): schema = schemas.AnnotationSchema() with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(text=False)) assert str(err.value) == "text: False is not of type 'string'"
def test_it_raises_if_document_link_is_not_a_list(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(document={'link': False})) assert str(err.value) == "document.link: False is not of type 'array'"
def test_it_raises_if_uri_is_not_a_string(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(uri=False)) assert str(err.value) == "uri: False is not of type 'string'"
def test_it_raises_if_document_dc_is_not_a_dict(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(document={'dc': False})) assert str(err.value) == "document.dc: False is not of type 'object'"
def test_it_raises_if_permissions_has_no_read(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(permissions={})) assert str(err.value) == "permissions: 'read' is a required property"
def test_it_does_not_pass_modified_dict_to_document_metas_from_data( self, parse_document_claims): """ If document_uris_from_data() modifies the document dict that it's given, the original dict (or one with the same values as it) should be passed t document_metas_from_data(), not the modified copy. """ document = { 'top_level_key': 'original_value', 'sub_dict': { 'key': 'original_value' } } def document_uris_from_data(document, claimant): document['new_key'] = 'new_value' document['top_level_key'] = 'new_value' document['sub_dict']['key'] = 'new_value' parse_document_claims.document_uris_from_data.side_effect = ( document_uris_from_data) schema = schemas.AnnotationSchema(testing.DummyRequest()) schema.validate(annotation_data(document=document)) assert (parse_document_claims.document_metas_from_data.call_args[0][0] == document)
def test_it_inserts_empty_string_if_data_has_no_uri(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) data = annotation_data() assert 'uri' not in data assert schema.validate(data)['target_uri'] == ''
def test_it_puts_document_metas_in_appstruct(self, parse_document_claims): schema = schemas.AnnotationSchema(testing.DummyRequest()) appstruct = schema.validate(annotation_data()) assert appstruct['document']['document_meta_dicts'] == ( parse_document_claims.document_metas_from_data.return_value)
def test_it_keeps_references(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) result = schema.validate( annotation_data(references=['parent id', 'parent id 2'])) assert result['references'] == ['parent id', 'parent id 2']
def test_it_does_not_crash_if_data_contains_no_target(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) data = annotation_data() assert 'target' not in data schema.validate(data)
def test_it_renames_group_to_groupid(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) result = schema.validate(annotation_data(group='foo')) assert result['groupid'] == 'foo' assert 'group' not in result
def test_it_inserts_empty_string_if_data_contains_no_text(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) data = annotation_data() assert 'text' not in data assert schema.validate(data)['text'] == ''
def test_it_inserts_empty_list_if_data_contains_no_tags(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) data = annotation_data() assert 'tags' not in data assert schema.validate(data)['tags'] == []
def test_it_raises_if_references_is_not_a_list(self): schema = schemas.AnnotationSchema() with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(references=False)) assert str(err.value) == "references: False is not of type 'array'"
def test_it_raises_if_permissions_is_not_a_dict(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(permissions=False)) assert str(err.value) == "permissions: False is not of type 'object'"
def test_it_moves_extra_data_into_extra_sub_dict(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) result = schema.validate({ # Throw in all the fields, just to make sure that none of them get # into extra. 'created': 'created', 'updated': 'updated', 'user': '******', 'id': 'id', 'uri': 'uri', 'text': 'text', 'tags': ['gar', 'har'], 'permissions': { 'read': ['group:__world__'] }, 'target': [], 'group': '__world__', 'references': ['parent'], # These should end up in extra. 'foo': 1, 'bar': 2, }) assert result['extra'] == {'foo': 1, 'bar': 2}
def test_it_raises_if_target_has_no_selector(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(target=[{}])) assert str(err.value) == "target.0: 'selector' is a required property"
def test_it_raises_if_target_item_is_not_a_dict(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(target=[False])) assert str(err.value) == "target.0: False is not of type 'object'"
def test_it_raises_if_target_is_not_a_list(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(target=False)) assert str(err.value) == "target: False is not of type 'array'"
def test_it_raises_if_references_item_is_not_a_string(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(references=[False])) assert str(err.value) == "references.0: False is not of type 'string'"
def test_it_sets_userid(self, authn_policy): authn_policy.authenticated_userid.return_value = ( 'acct:[email protected]') schema = schemas.AnnotationSchema(testing.DummyRequest()) result = schema.validate(annotation_data()) assert result['userid'] == 'acct:[email protected]'
def test_it_renames_uri_to_target_uri(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) result = schema.validate( annotation_data(uri='http://example.com/example'), ) assert result['target_uri'] == 'http://example.com/example' assert 'uri' not in result
def test_it_raises_if_permissions_read_is_not_a_list(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(permissions={'read': False})) assert str( err.value) == ("permissions.read: False is not of type 'array'")
def test_it_raises_if_document_link_item_is_not_a_dict(self): schema = schemas.AnnotationSchema() with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(document={'link': [False]})) assert str( err.value) == ("document.link.0: False is not of type 'object'")
def test_it_raises_if_document_link_item_has_no_href(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) with pytest.raises(schemas.ValidationError) as err: schema.validate(self.valid_input_data(document={'link': [{}]})) assert str( err.value) == ("document.link.0: 'href' is a required property")
def test_it_inserts_default_groupid_if_no_group(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) data = annotation_data() assert 'group' not in data result = schema.validate(data) assert result['groupid'] == '__world__'
def test_it_inserts_empty_list_if_no_references(self): schema = schemas.AnnotationSchema(testing.DummyRequest()) data = annotation_data() assert 'references' not in data result = schema.validate(data) assert result['references'] == []