Produits Entr'ouvert » Passerelle

import bz2

import json

import os

import urlparse

import unicodedata

from django.db import connection, models

from django.db.models import Q

from django.utils.http import urlencode

    category = _('Geographic information system')

        verbose_name=_('Postal codes to get streets, separated with commas'))

    class Meta:

                departments.add(zipcode[:2])

        for department in departments:

            if ban_file.status_code != 200:

                continue

                street_info = json.loads(line)

                if street_info['type'] == 'street' and street_info['postcode'].startswith(zipcodes):

                    if type(street_info['citycode']) is list:

                    if type(street_info['name']) is list:

                    street = StreetModel.objects.get_or_create(citycode=street_info['citycode'],

                                                               name=street_info['name'][:150])

                    street[0].city = street_info['city']

        ordering = ['unaccent_name', 'name']

    def __unicode__(self):

    def save(self, *args, **kwargs):

        self.unaccent_name = unicodedata.normalize('NFKD', self.name).encode('ascii', 'ignore')

from passerelle.apps.base_adresse.models import BaseAdresse, StreetModel

FAKE_DATA = ''

@pytest.fixture

def base_adresse(db):

    return utils.setup_access_rights(BaseAdresse.objects.create(slug='base-adresse', zipcode='73'))

@pytest.fixture

def base_adresse_97x(db):

    return utils.setup_access_rights(BaseAdresse.objects.create(slug='base-adresse',

                                                                zipcode='97425'))

@pytest.fixture

def base_adresse_corsica(db):

    return utils.setup_access_rights(BaseAdresse.objects.create(slug='base-adresse',

                                                                zipcode='20000, 20100 '))

@pytest.fixture

def base_adresse_multiple(db):

    return utils.setup_access_rights(BaseAdresse.objects.create(slug='base-adresse',

                                                                zipcode='73, 73100, 97425,20000 '))

@pytest.fixture

def street(db):

    return StreetModel.objects.create(city=u'Chambéry',

                                      type=u'street',

                                      citycode=u'73001')

@mock.patch('passerelle.utils.Request.get')

def test_base_adresse_search(mocked_get, app, base_adresse):

    endpoint = utils.generic_endpoint_url('base-adresse', 'search', slug=base_adresse.slug)

    assert data['lon'] == '-0.593775'

    assert data['display_name'] == 'Rue Roger Halope 49000 Angers'

@mock.patch('passerelle.utils.Request.get')

def test_base_adresse_search_path(mocked_get, app, base_adresse):

    base_adresse.service_url = 'http://example.net/path/'

    assert data['lon'] == '-0.593775'

    assert data['display_name'] == 'Rue Roger Halope 49000 Angers'

def test_base_adresse_search_qs(app, base_adresse, mock_api_adresse_data_gouv_fr_search):

    resp = app.get('/base-adresse/%s/search?q=plop' % base_adresse.slug)

    assert 'display_name' in resp.json[0]

    resp = app.get('/base-adresse/%s/search?q=plop&zipcode=49000' % base_adresse.slug)

    assert 'display_name' in resp.json[0]

def test_base_adresse_search_qs_empty(app, base_adresse, mock_api_adresse_data_gouv_fr_search):

    resp = app.get('/base-adresse/%s/search?q=' % base_adresse.slug)

    assert len(resp.json) == 0

def test_base_adresse_search_qs_parameters_error(app, base_adresse,

                                                 mock_api_adresse_data_gouv_fr_search):

    resp = app.get('/base-adresse/%s/search' % base_adresse.slug, status=400)

    assert data['address']['postcode'] == '49000'

    assert data['address']['citycode'] == '49007'

@mock.patch('passerelle.utils.Request.get')

def test_base_adresse_reverse_path(mocked_get, app, base_adresse):

    mocked_get.return_value = utils.FakedResponse(content=json.dumps({'features': []}), status_code=200)

    base_adresse.service_url = 'http://example.net/path/'

    base_adresse.save()

    assert mocked_get.call_args[0][0].startswith('http://example.net/path/reverse/?')

def test_base_adresse_streets_unaccent(app, base_adresse, street):

    resp = app.get('/base-adresse/%s/streets?q=une rue tres acc' % base_adresse.slug)

    data = json.loads(resp.body)

    assert result['zipcode'] == street.zipcode

    assert result['id'] == street.id

@mock.patch('passerelle.utils.Request.get')

def test_base_adresse_command_update(mocked_get, db, base_adresse):

    filepath = os.path.join(os.path.dirname(__file__), 'data', 'update_streets_test.bz2')

    call_command('cron', 'daily')

    mocked_get.call_count == 2

@mock.patch('passerelle.utils.Request.get')

def test_base_adresse_command_hourly_update(mocked_get, db, base_adresse):

    filepath = os.path.join(os.path.dirname(__file__), 'data', 'update_streets_test.bz2')

    call_command('cron', 'hourly')

    mocked_get.call_count == 1

@mock.patch('passerelle.utils.Request.get')

def test_base_adresse_command_update_97x(mocked_get, db, base_adresse_97x):

    filepath = os.path.join(os.path.dirname(__file__), 'data', 'update_streets_test.bz2')

    mocked_get.assert_called_once_with('http://bano.openstreetmap.fr/BAN_odbl/BAN_odbl_974-json.bz2')

    assert StreetModel.objects.count() == 2

@mock.patch('passerelle.utils.Request.get')

def test_base_adresse_command_update_corsica(mocked_get, db, base_adresse_corsica):

    filepath = os.path.join(os.path.dirname(__file__), 'data', 'update_streets_test.bz2')

    mocked_get.assert_any_call('http://bano.openstreetmap.fr/BAN_odbl/BAN_odbl_2B-json.bz2')

    assert StreetModel.objects.count() == 0

@mock.patch('passerelle.utils.Request.get')

def test_base_adresse_command_update_multiple(mocked_get, db, base_adresse_multiple):

    filepath = os.path.join(os.path.dirname(__file__), 'data', 'update_streets_test.bz2')