0001-iparapheur-add-handling-of-invalid-response-content.patch

Josué Kouka, 27 septembre 2016 11:08

Voir les différences: en ligne côte à côte

Subject: [PATCH] iparapheur: add handling of invalid response content

 passerelle/contrib/iparapheur/models.py | 49 +++++++++++++++++++++++----------
 passerelle/contrib/iparapheur/soap.py   | 19 ++++++++++---
 tests/test_iparapheur.py                | 21 ++++++++++++++
 3 files changed, 71 insertions(+), 18 deletions(-)

     from passerelle.utils.api import endpoint
     from .soap import get_client
     from suds import WebFault
     def format_type(t):
         return {'id': unicode(t), 'text': unicode(t)}
-...
         http_status = 404
     class InvalidResponseContent(Exception):
         http_status = 200
         log_error = False
     class ServiceError(Exception):
         http_status = 200
         log_error = False
     class IParapheur(BaseResource):
         wsdl_url = models.CharField(max_length=128, blank=False,
                 verbose_name=_('WSDL URL'),
-...
         def get_verbose_name(cls):
             return cls._meta.verbose_name
         def call(self, service, *args, **kwargs):
             client = get_client(self)
             try:
                 result = getattr(client.service, service)(*args, **kwargs)
             except(WebFault,) as e:
                 # Remote Service Error: <SOAP-ENV:Fault> in response
                 raise ServiceError(e.args[0])
             except(Exception,) as e:
                 # Exception different from suds.tranport.TransportError
                 if not(e.args) or not isinstance(e.args[0], tuple):
                     raise e
                 # TransportError Exception
                 raise InvalidResponseContent(e.args[0])
             return result
         @endpoint(serializer_type='json-api')
         def types(self, request):
             c = get_client(self)
             return [format_type(t) for t in c.service.GetListeTypes()]
             return [format_type(t) for t in self.call('GetListeTypes')]
         @endpoint(serializer_type='json-api')
         def ping(self, request):
             c = get_client(self)
             return c.service.echo('ping')
             return self.call('echo', 'ping')
         @endpoint(serializer_type='json-api')
         def subtypes(self, request, type=None):
             c = get_client(self)
             if type:
                 return [format_type(t) for t in c.service.GetListeSousTypes(type)]
             return [format_type(t) for t in c.service.GetListeSousTypes()]
                 return [format_type(t) for t in self.call('GetListeSousTypes', type)]
             return [format_type(t) for t in self.call('GetListeSousTypes')]
         @endpoint(serializer_type='json-api')
         def files(self, status=None):
             c = get_client(self)
             if status:
                 return [format_status(f) for f in c.service.RechercherDossiers(Status=status)]
             return [format_status(f) for f in c.service.RechercherDossiers()]
                 return [format_status(f) for f in self.call('RechercherDossiers', Status=status)]
             return [format_status(f) for f in self.call('RechercherDossiers')]
         @endpoint(serializer_type='json-api', name='create-file', methods=['post'])
         def create_file(self, request, email=None):
-...
         @endpoint(serializer_type='json-api', name='get-file', pattern='(?P<file_id>[\w-]+)')
         def get_file(self, request, file_id):
             client = get_client(self)
             resp = client.service.GetDossier(file_id)
             resp = self.call('GetDossier', file_id)
             if resp.MessageRetour.codeRetour == 'KO':
                 if 'inconnu' in resp.MessageRetour.message:
                     raise Http404(resp.MessageRetour.message)
-...
         @endpoint(serializer_type='json-api', name='get-file-status', pattern='(?P<file_id>[\w-]+)')
         def get_file_status(self, request, file_id):
             c = get_client(self)
             resp = c.service.GetHistoDossier(file_id)
             resp = self.call('GetHistoDossier', file_id)
             if resp.MessageRetour.codeRetour == 'KO':
                 if 'inconnu' in resp.MessageRetour.message:
                     raise Http404(resp.MessageRetour.message)

     from suds.client import Client
     from suds.transport.http import HttpAuthenticated
     from suds.transport import Reply
     from suds.transport import Reply, TransportError
     from suds.plugin import MessagePlugin, DocumentPlugin
     from suds.sudsobject import asdict
     from requests.execptions import RequestException
     class Filter(MessagePlugin):
-...
         def send(self, request):
             request.message = request.message.replace("contentType", "xm:contentType")
             self.addcredentials(request)
             resp = self.model.requests.post(request.url, data=request.message,
             try:
                 resp = self.model.requests.post(request.url, data=request.message,
                     headers=request.headers, **self.get_requests_kwargs())
             return Reply(resp.status_code, resp.headers, resp.content)
             except(RequestException,) as e:
                 raise TransportError(e.message.message, None)
             if resp.status_code in (202, 204):
                 return None
             elif not resp.ok:
                 raise TransportError(
                     resp.reason,
                     resp.status_code, fp=StringIO.StringIO(resp.content))
             else:
                 return Reply(resp.status_code, resp.headers, resp.content)
     def get_client(instance):
         transport = Transport(instance)

         file_sent = os.path.join(os.path.dirname(__file__), 'data/iparapheur_test.pdf')
         assert resp.headers['Content-Type'] == 'application/pdf'
         assert hashlib.md5(resp.body[:8192]).hexdigest() == hashlib.md5(file(file_sent).read()[:8192]).hexdigest()
     @mock.patch('passerelle.utils.LoggedRequest.get')
     @mock.patch('passerelle.utils.LoggedRequest.post')
     @mock.patch('passerelle.contrib.iparapheur.soap.HttpAuthenticated.open')
     def test_invalid_response(http_open, mocked_post, mocked_get, setup, xmlmime, wsdl_file):
         app, conn = setup
         file_id = str(uuid.uuid4())
         http_open.return_value = file(xmlmime)
         mocked_get.return_value = mock.Mock(content = file(wsdl_file).read(),
                                                 status_code=200)
         mocked_post.return_value = mock.Mock(status_code=502,
                 content='<p>Bad Gateway</p>', reason='Bad Gateway', ok=False)
         url = reverse('generic-endpoint', kwargs={'slug': conn.slug,
                     'connector': 'iparapheur', 'endpoint': 'get-file-status',
                     'rest': file_id})
         resp = app.get(url)
         assert 'x-error-code' in dict(resp.headers)
         assert resp.json['err_desc'] == 'Invalid Response Content, XML expected'
+    -

Projet

Général

Profil

Produits Entr'ouvert » Passerelle

0001-iparapheur-add-handling-of-invalid-response-content.patch