Produits Entr'ouvert » Passerelle

# -*- coding: utf-8 -*-

# Passerelle - uniform access to data and services

# Copyright (C) 2017  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import json

from django.utils.translation import ugettext_lazy as _

from passerelle.utils.api import endpoint

from passerelle.utils.jsonresponse import APIError

# Dict of mandatory keys and their expected values

MANDATORY_DATA = {

    'application_id': None,

    'application_time': None,

    'certificate_type': ('birth', 'mariage', 'death', 'other'),

    'document_type': ('full', 'multilingual', 'with-filiation', 'without-filiation'),

    'applicant_lastname': None,

    'applicant_firstnames': None,

    'concerned_lastname': None,

    'concerned_firstnames': None,

}

class CivilStatusMixin(object):

    category = _('Civil Status')

    def check_keys(self, formdata):

        for key in MANDATORY_DATA:

            if (key not in formdata):

                raise APIError('<%s> is required.' % key)

            expected_values = MANDATORY_DATA[key]

            if expected_values and formdata[key] not in expected_values:

                raise APIError('<%s> value must be one of %s' % (key, expected_values))

    def create_demand(self, formdata, *args, **kwargs):

        raise NotImplementedError

    def get_status(self, demand_id, **kwargs):

        raise NotImplementedError

    @endpoint(perm='can_access', methods=['post'])

    def create(self, request, *args, **kwargs):

        formdata = json.loads(request.body)

        self.check_keys(formdata)

        return self.create_demand(formdata, *args, **kwargs)

    @endpoint(perm='can_access', methods=['get'])

    def status(self, request, demand_id, **kwargs):

        return self.get_status(demand_id)

from passerelle.civilstatus import CivilStatusMixin

class MDEL(CivilStatusMixin, BaseResource):

# -*- coding: utf-8 -*-

import json

import mock

import pytest

from passerelle.civilstatus import CivilStatusMixin, MANDATORY_DATA

from passerelle.utils.jsonresponse import APIError

from django.test import RequestFactory

C_DEMAND = {'demand_id': '123-NAIS-0'}

S_DEMAND = {'closed': True, 'status': 'rejected'}

def build_post_request(data):

    request = RequestFactory()

    return request.post('/', content_type='application/json',

                        data=json.dumps(data))

@pytest.fixture

def base_payload():

    return {

        "application_id": "123",

        "application_time": "2017-06-11T10:30:25",

        "certificate_type_label": "Acte de Naissance",

        "certificate_type": "birth",

        "document_type_label": "Copie Intégrale",

        "document_type": "full",

        "applicant_firstnames": "Johhny Jumper",

        "applicant_lastname": "Doe",

        "concerned_firstnames": "Johnny Jumper",

        "concerned_lastname": "Dalton",

        "concerned_birthdate": "1980-07-07",

        "concerned_birthcity": "Nantes",

        "concerned_birthcountry": "France",

    }

@pytest.fixture(params=MANDATORY_DATA)

def case(request, base_payload):

    base_payload.pop(request.param)

    return request.param, base_payload

def test_civilstatus_mixin_missing_keys(app, case):

    missing_key, payload = case

    mixin = CivilStatusMixin()

    with pytest.raises(APIError) as exc:

        mixin.create(build_post_request(payload))

    assert exc.value.message == '<%s> is required.' % missing_key

@mock.patch('passerelle.civilstatus.CivilStatusMixin.create_demand',

            side_effect=lambda x: C_DEMAND)

@mock.patch('passerelle.civilstatus.CivilStatusMixin.get_status',

            side_effect=lambda x: S_DEMAND)

def test_civilstatus_mixin_expected_keys(mock_cvs_status, mock_cvs_create, app, base_payload):

    base_payload['certificate_type'] = 'whatever'

    mixin = CivilStatusMixin()

    with pytest.raises(APIError) as exc:

        mixin.create(build_post_request(base_payload))

    assert exc.value.message == "<certificate_type> value must be one of ('birth', 'mariage', 'death', 'other')"

    base_payload['certificate_type'] = 'birth'

    request = build_post_request(base_payload)

    resp_json = mixin.create(request)

    assert resp_json['demand_id'] == '123-NAIS-0'

    resp_json = mixin.status(request, '123-NAIS-0')

    assert resp_json['status'] == 'rejected'

    assert resp_json['closed'] is True