tests.py

#

We use the WorkspaceManager to find and create our workspaces

    def test_smoke(self):
#

self.assertTrue(self.workspace_manager) # It exists.

def test_load_or_create(self): workspace_groups = self.workspace_manager.load_or_create() self.assertTrue(workspace_groups)

def test_load(self): workspace_groups = self.workspace_manager.load_or_create() self.assertTrue(workspace_groups) self.workspace_manager.save_workspaces() errors = self.workspace_manager.load_workspaces() self.assertEqual(errors, 0)

def test_save(self): workspace_groups = self.workspace_manager.load_or_create() self.assertTrue(workspace_groups) self.workspace_manager.save_workspaces()

def test_empty(self): workspace_groups = self.workspace_manager.load_or_create() self.assertTrue(workspace_groups) self.workspace_manager.empty()

class ViewsTest(TestCase): fixtures = ('lizard_map', )

class MockRequest(object): session = {}

def setUp(self): self.client = Client() self.workspace = Workspace() self.workspace.save() self.collage = WorkspaceCollage(workspace=self.workspace) self.collage.save()

def test_homepage(self): url = reverse('lizard_map_workspace',

kwargs={'workspace_id': self.workspace.id})
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_wms(self): url = reverse('lizard_map_wms', kwargs={'workspace_id': self.workspace.id}) url += ('?LAYERS=basic&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap&' 'STYLES=&EXCEPTIONS=application%2Fvnd.ogc.se_inimage&' 'FORMAT=image%2Fjpeg&SRS=EPSG%3A900913&' 'BBOX=430987.5469813,6803449.8497827,' '669012.4530187,6896550.1502173&' 'WIDTH=1557&HEIGHT=609') response = self.client.get(url) self.assertEqual(response.status_code, 200)

def test_collage(self): url = reverse('lizard_map.collage', kwargs={'collage_id': self.collage.id}) response = self.client.get(url) self.assertEqual(response.status_code, 200)

def test_collage_popup(self): url = reverse('lizard_map.collage_popup', kwargs={'collage_id': self.collage.id}) response = self.client.get(url) self.assertEqual(response.status_code, 200)

def test_search_coordinates(self): url = reverse('lizard_map.search_coordinates') url += '?x=430987.5469813&y=6817896.448126&radius=100' response = self.client.get(url) self.assertEqual(response.status_code, 200)

def test_search_name(self): url = reverse('lizard_map.search_name') url += '?x=430987.5469813&y=6817896.448126&radius=100' response = self.client.get(url) self.assertEqual(response.status_code, 200)

def test_map_location_save(self): Save map location, see if it doesn't crash

client = Client() url = reverse('lizard_map.map_location_save') response = client.post(url, {'left': 100, 'top': 100,

'right': 150, 'bottom': 150,
'base_layer_name': 'Google standard'})
self.assertEqual(response.status_code, 200)
def test_map_location_load_default(self): Save map location, then load it back.

url_load = reverse('lizard_map.map_location_load_default') response_load = self.client.get(url_load) self.assertEqual(response_load.status_code, 200) result = json.loads(response_load.content) self.assertEqual( result['extent'], {'top': '6964942', 'right': '1254790', 'left': '-14675', 'bottom': '6668977'})

class WorkspaceTest(TestCase):

def test_workspace_contains_items(self): A workspace can contain workspace items

        workspace1 = Workspace()
        workspace1.save()
        self.assertTrue(workspace1)
        self.assertFalse(workspace1.workspace_items.all())  # Empty.
        workspace_item1 = workspace1.workspace_items.create()
        workspace_item2 = workspace1.workspace_items.create()
        self.assertEquals(len(workspace1.workspace_items.all()), 2)
        self.assertTrue(workspace_item1 in workspace1.workspace_items.all())
        self.assertTrue(workspace_item2 in workspace1.workspace_items.all())
#

A workspace always has a name. It is 'My Workspace' by

    def test_name(self):
#

default.""" workspace = Workspace() self.assertEquals(workspace.name, u'My Workspace')

def test_representation(self): workspace = Workspace() workspace.save()

No errors: fine. As long as we return something.

self.assertTrue(unicode(workspace))

def test_absolute_url(self): workspace = Workspace() workspace.save()

The initial version of this test asserted that the absolute URL ended

with '/workspace/1', apparantly assuming that the new workspace would

have id 1. However, that does not have to be the case.

expected_end = '/workspace/%d/' % workspace.id self.assertTrue(workspace.get_absolute_url().endswith(expected_end))

class WorkspaceClientTest(TestCase):

def setUp(self): self.client = Client()

def test_workspace_item_add(self): workspace = Workspace() workspace.save() url = reverse('lizard_map_workspace_item_add',

kwargs={'workspace_id': str(workspace.id)})
params = {'name': 'test workspace_item',
'adapter_class': 'test adapter_class',
'adapter_layer_json': '{"json"}'}
self.client.post(url, params)
self.assertTrue(workspace.workspace_items.filter())
def test_workspace_item_reorder(self): workspace = Workspace() workspace.save() workspace_item1 = workspace.workspace_items.create() workspace_item2 = workspace.workspace_items.create() url = reverse('lizard_map_workspace_item_reorder', kwargs={'workspace_id': str(workspace.id)}) order = {'workspace-items[]': [ str(workspace_item2.id), str(workspace_item1.id)]} self.client.post(url, order)

self.assertEqual(workspace.workspace_items.all()[0], workspace_item2) self.assertEqual(workspace.workspace_items.all()[1], workspace_item1)

def test_workspace_item_edit(self): workspace = Workspace() workspace.save() workspace_item1 = workspace.workspace_items.create( name='test workspaceitem')

url = reverse('lizard_map_workspace_item_edit') self.client.post( url, {'workspace_item_id': str(workspace_item1.id), 'visible': 'false'}) self.assertEqual( WorkspaceItem.objects.get(name='test workspaceitem').visible, False) self.client.post( url, {'workspace_item_id': str(workspace_item1.id), 'visible': 'true'}) self.assertEqual( WorkspaceItem.objects.get(name='test workspaceitem').visible, True)

def test_workspace_item_delete(self): workspace = Workspace() workspace.save() workspace_item1 = workspace.workspace_items.create( name='test workspaceitem')

url = reverse('lizard_map_workspace_item_delete') self.client.post( url, {'object_id': str(workspace_item1.id)}) self.assertFalse(workspace.workspace_items.all())

def test_workspace_extent_temp(self):

        Tests if the workspace extent does not crash (although the
        content will be meaningless).
#

url = reverse('lizard_map_session_workspace_extent_temp') result = self.client.get(url, {}) self.assertEqual(result.status_code, 200)

Not testable without adapter

def test_workspace_extent(self):

"""

Tests if the workspace extent does not crash (although the

content will be meaningless).

"""

workspace = Workspace()

workspace.save()

workspace_item1 = workspace.workspace_items.create(

#         name='test workspaceitem')

url = reverse('lizard_map_workspace_item_extent')

result = self.client.get(url, {

'workspace_item_id': workspace_item1.id})

self.assertEqual(result.status_code, 200)

self.assertTrue('north' in result.content)

Not testable without adapter

def test_workspace_item_image(self):

workspace = Workspace()

workspace.save()

workspace_item1 = workspace.workspace_items.create(

name='test workspaceitem')

url = reverse('lizard_map_workspace_item_image')

url += '?identifier={test_identifier}'

response = self.client.get(url)

self.assertEqual(response.status_code, 200)

TODO: snippet stuff

class WorkspaceItemTest(TestCase):

def test_has_adapter(self): A workspace item can point to a method that returns a layer.

        workspace_item = WorkspaceItem()
        self.assertFalse(workspace_item.has_adapter())
        workspace_item.adapter_class = 'todo'
        self.assertTrue(workspace_item.has_adapter())
#

There's at least one adapter entry point registered.

    def test_entry_points_exist(self):
#

self.assertTrue(list(pkg_resources.iter_entry_points(

group='lizard_map.adapter_class')))
def test_entry_point_lookup(self): The string that identifies a method is looked up as a so-called

        entry point."""
        workspace_item = WorkspaceItem()
        workspace_item.adapter_class = 'todo'
        self.assertRaises(lizard_map.models.AdapterClassNotFoundError,
                          lambda: workspace_item.adapter,

#DIVIDER
                          )
        workspace_item.adapter_class = 'adapter_dummy'
        workspace_item.adapter_layer_json = ("{}")
        self.assertTrue(isinstance(
                workspace_item.adapter,
                lizard_map.layers.AdapterDummy))


#DIVIDER
    def test_adapter_arguments(self):
#DIVIDER
        though."""
        workspace_item = WorkspaceItem()
        self.assertEquals(workspace_item.name, '')
        workspace_item2 = WorkspaceItem(name='bla')
        self.assertEquals(workspace_item2.name, 'bla')
#

^^^ lambda as adapter is a property and assertRaises expects a callable.

        self.assertTrue(unicode(workspace_item))
#

The layer method probably needs arguments. You can store them as a

class TestDateRange(TestCase):
#

json string.""" workspace_item = WorkspaceItem() self.assertTrue(isinstance(workspace_item.adapter_layer_arguments,

dict))
self.assertFalse(len(workspace_item.adapter_layer_arguments))
workspace_item.adapter_layer_json = '{"bla": "yes"}'
self.assertEquals(workspace_item.adapter_layer_arguments['bla'],
'yes')
def test_name(self): A workspace item always has a name. It is blank by default,

        period = current_period(self.request)
        self.assertEquals(period, PERIOD_DAY)
#

No errors: fine. As long as we return something.

    def test_set_date_range(self):
#

Test daterange.py

        timedelta_start = datetime.timedelta(days=-20)
        timedelta_end = datetime.timedelta(days=15)
#

def setUp(self):

class Mock(dict):
pass

self.request = Mock() self.request.session = Mock() self.today = datetime.datetime(2011, 4, 21) self.almost_one_day = datetime.timedelta( hours=23, minutes=59, seconds=59)

def _test_set_date_range(self, request):

set_date_range(self.request, now=self.today)

Get current period, dt_start, dt_end

period = current_period(self.request) dt_start, dt_end = current_start_end_dates( self.request, today=self.today)

return period, dt_start, dt_end

def test_current_start_end_dates(self): dt_start, dt_end = current_start_end_dates( self.request, today=self.today) dt_start_expected = self.today + PERIOD_DAYS[PERIOD_DAY][0] dt_end_expected = self.today + PERIOD_DAYS[PERIOD_DAY][1]

self.assertEquals(dt_start, dt_start_expected) self.assertEquals(dt_end, dt_end_expected)

def test_current_period(self): Test default period.

        self.request.method = 'POST'
        self.request.POST = {
            'period': str(PERIOD_OTHER),
            'dt_start': self.today + timedelta_start,
            'dt_end': self.today + timedelta_end}
        self.request.META = {}

        period, dt_start, dt_end = self._test_set_date_range(self.request)

        self.assertEquals(period, PERIOD_OTHER)
        self.assertEquals(dt_start, self.today + timedelta_start)
        self.assertEquals(
            dt_end, self.today + timedelta_end + self.almost_one_day)
#

Set date range to period_day, then retrieve it back

    def test_set_date_range3(self):
#

Fake Post

self.request.method = 'POST' self.request.POST = {

'period': str(PERIOD_DAY)}
self.request.META = {}
period, dt_start, dt_end = self._test_set_date_range(self.request)

self.assertEquals(period, PERIOD_DAY) self.assertEquals(dt_start, self.today + PERIOD_DAYS[PERIOD_DAY][0]) self.assertEquals(dt_end, self.today + PERIOD_DAYS[PERIOD_DAY][1])

def test_set_date_range2(self): Set custom date range, then retrieve it back

        daterange = {'dt_start': self.today + timedelta_start_expected,
                     'dt_end': self.today + timedelta_end_expected,
                     'period': period_expected}
        period, timedelta_start, timedelta_end = deltatime_range(
            daterange, now=self.today)
#

Fake Post

        self.assertEquals(period, period_expected)
        self.assertEquals(timedelta_start.days, timedelta_start_expected.days)
        self.assertEquals(timedelta_end.days, timedelta_end_expected.days)
#

Set start date after end date: result must have dt_start<dt_end

    def test_deltatime_range(self):
#

timedelta_start = datetime.timedelta(days=20) timedelta_end = datetime.timedelta(days=-15)

Fake Post

self.request.method = 'POST' self.request.POST = {

'period': str(PERIOD_OTHER),
'dt_start': self.today + timedelta_start,
'dt_end': self.today + timedelta_end}
self.request.META = {}
period, dt_start, dt_end = self._test_set_date_range(self.request)

self.assertEquals(period, PERIOD_OTHER) self.assertTrue(dt_start < dt_end)

def do_deltatime( self, period_expected, timedelta_start_expected, timedelta_end_expected): Easy testing deltatime_range.

        timedelta_start_expected = datetime.timedelta(-1)
        timedelta_end_expected = datetime.timedelta(0)
        period_expected = PERIOD_DAY
        self.do_deltatime(
            period_expected,
            timedelta_start_expected, timedelta_end_expected)
#

Test on day accuracy, because "almost_one_day" is added to end.

    def test_deltatime_range3(self):
#

Deltatime_range

#

timedelta_start_expected = datetime.timedelta(-1000) timedelta_end_expected = datetime.timedelta(20) period_expected = PERIOD_OTHER self.do_deltatime(

period_expected,
timedelta_start_expected, timedelta_end_expected)
def test_deltatime_range2(self): Deltatime_range

    def _fill_date_range(self, today):
#

Deltatime_range

        twothousand = datetime.datetime(year=2000, month=1, day=1)
        twothousandthree = datetime.datetime(year=2003, month=1, day=1)
        self.request.session[SESSION_DT_START] = twothousand - today
        self.request.session[SESSION_DT_END] = twothousandthree - today
        day_one = datetime.datetime(1979, 5, 25)
        self.date_start_days = (twothousand - day_one).days
        self.date_end_days = (twothousandthree - day_one).days
#

timedelta_start_expected = datetime.timedelta(-365) timedelta_end_expected = datetime.timedelta(0) period_expected = PERIOD_YEAR self.do_deltatime(

period_expected,
timedelta_start_expected, timedelta_end_expected)

class TestAnimationSettings(TestCase): Tests for animation.py.

    def _date_range_helper(self, today):
#

Helper method: fill session with date range info.

        animation_settings = AnimationSettings(
            self.request, today=self.today)
        animation_settings.slider_position = self.date_start_days + 100
        print current_start_end_dates(self.request)
        self.assertTrue(self.request.session.modified)
        self.assertEquals(
            animation_settings.slider_position, self.date_start_days + 100)
        self.assertEquals(
            self.request.session['animation_settings']['slider_position'],
            self.date_start_days + 100)
#

date_start is 730119 days from day_one date_end is 731215 days from day_one

    def test_initial_slider_position(self):
#

Make sure _fill_date_range() works.

        self._fill_date_range(self.today)
        animation_settings = AnimationSettings(
            self.request, today=self.today)
        result = animation_settings.info()
        self.assertEquals(result['min'], self.date_start_days)
        self.assertEquals(result['max'], self.date_end_days)
        self.assertEquals(result['step'], 1)
        self.assertEquals(result['value'], self.date_end_days)
        self.assertEquals(result['selected_date'].year, 2003)
#

self._fill_date_range(today=today) start, end = current_start_end_dates(self.request, today=today) self.assertEquals(start.year, 2000) self.assertEquals(end.year, 2003)

def setUp(self):

class Mock(dict):

pass
self.request = Mock() self.request.session = Mock() self.today = datetime.datetime(2011, 4, 21) self._date_range_helper(today=self.today) # Set the request datetimes

def test_smoke(self): animation_settings = AnimationSettings( request=self.request, today=self.today) self.assertTrue(animation_settings) # It exists.

def test_session_initialisation(self): self.assertFalse('animation_settings' in self.request.session) AnimationSettings(self.request, today=self.today) self.assertTrue('animation_settings' in self.request.session)

def test_slider_position(self): Are the getters/setters working?

    def test_info_gathering(self):
#

Slider position should be [max] if not initialised.

        self._fill_date_range(self.today)
        animation_settings = AnimationSettings(
            self.request, today=self.today)
        animation_settings.slider_position = -400
        result = animation_settings.info()
        self.assertEquals(result['value'], self.date_start_days)
#

In any case, it should not return a keyerror.""" animation_settings = AnimationSettings(

self.request, today=self.today)
self.assertEquals(animation_settings.slider_position,
self.date_end_days)
def test_initial_info_gathering(self): Do we return the correct date range and position?

    def test_impossible_beyond_max_corner_case(self):
#

Do we return the correct date range and position?

    Tests utility.py, adapter.py, mapnik_helper.py
#

self._fill_date_range(self.today) animation_settings = AnimationSettings(

self.request, today=self.today)
animation_settings.slider_position = self.date_start_days + 375
result = animation_settings.info()
self.assertEquals(result['min'], self.date_start_days)
self.assertEquals(result['max'], self.date_end_days)
self.assertEquals(result['step'], 1)
self.assertEquals(result['value'], self.date_start_days + 375)
self.assertEquals(result['selected_date'].year, 2001)
def test_impossible_negative_corner_case(self): Negative dates.

        st = float_to_string(1.2345678)
        self.assertTrue(len(st) <= 10)
        self.assertEquals(st[:4], '1.23')
#

Value beyond the max possible.

    def test_float_to_string2(self):
#

self._fill_date_range(self.today) animation_settings = AnimationSettings(

self.request, today=self.today)
animation_settings.slider_position = 1000000
result = animation_settings.info()

Max available.

self.assertEquals(result['value'], self.date_end_days)

class UtilityTest(TestCase):

        st = float_to_string(0.00000000012345)
        self.assertTrue(len(st) <= 10)
        self.assertEquals(st[:4], '1.23')
        self.assertTrue('e' in st)
#

class MockSettings(object):

pass
def test_short_string(self): input_names = [
'Loosdrechtse Plassen',
'wie niet waagt, wie niet wint',
'Reinout is een developer bij Nelen & Schuurmans',
'Dit is nog een langere zin, deze moet ook goed werken',
]
for name in input_names:
short = short_string(name, 17)
self.assertTrue(len(short) <= 17)
self.assertEquals(short[:5], name[:5])
def test_float_to_string(self): Let's input some nice floats.

    def test_float_to_string5(self):
#

Let's input some nice floats.

        st = float_to_string(999999999.99)
        self.assertTrue(len(st) <= 10)
        self.assertEquals(st[:4], '1000')
#

st = float_to_string(12345.678) self.assertTrue(len(st) <= 10) self.assertEquals(st[:4], '1234')

def test_float_to_string3(self): Let's input some nice floats.

    def test_float_to_string7(self):
#

Let's input some nice floats.

        st = float_to_string('1000')
        self.assertEquals(st, '1000.00')
#

st = float_to_string(123456789012345) self.assertTrue(len(st) <= 10) self.assertEquals(st[:4], '1.23') self.assertTrue('e' in st)

def test_float_to_string6(self): Let's input some nice floats.

    def test_database_settings(self):
#

Let's input a string.

    def test_database_settings2(self):
#

self.assertEquals(float_to_string('string'), 'string')

def test_float_to_string8(self): Let's input a string.

    def test_database_settings3(self):
#

See if correct database settings are fetched when using new style config.

#

See if correct database settings are fetched when using old style config.

#

Take new style config if both setting styles are present.

        start_date = datetime.datetime(2010, 5, 25)
        end_date = datetime.datetime(2010, 6, 25)
        self.adapter.values = (
            lambda
            identifier, start_date, end_date:
                [{'datetime': start_date, 'value': 5.0, 'unit': 'none'},
                 {'datetime': end_date, 'value': 6.0, 'unit': 'none'}])
        aggregated_values = self.adapter.value_aggregate_default(
            {},
            {'min': None, 'max': None, 'avg': None, 'count_lt': 6,
             'count_gte': 6, 'percentile': 50},
            start_date,
            end_date)
        self.assertEqual(aggregated_values['min'], 5.0)
        self.assertEqual(aggregated_values['max'], 6.0)
        self.assertEqual(aggregated_values['avg'], 5.5)
        self.assertEqual(aggregated_values['count_lt'], 1)
        self.assertEqual(aggregated_values['count_gte'], 1)
#

def test_create_layer_from_query(self): """Difficult to test, just see if it crashes or not. Currently crashes when db does not exist """ settings = self.MockSettings() settings.DATABASES = { 'default': { 'ENGINE': 'postgresql_psycopg2', 'HOST': 'database_host', 'USER': 'database_user', 'PASSWORD': 'database_password', 'NAME': 'database_name', }, }

        self.assertTrue(aggregated_values['percentile'] >= 5.0)
        self.assertTrue(aggregated_values['percentile'] <= 6.0)
#
q = "select * from dummy;"
projection = lizard_map.coordinates.RD
layer = create_layer_from_query(q, projection,
            user_settings=settings)
    def test_color(self):
#

First, implement values function

        anchestors = AnchestorRegistration()
        self.assertFalse(anchestors.anchestor_of('child', 'parent'))
        anchestors.register_parent('child', 'parent')
        self.assertTrue(anchestors.anchestor_of('child', 'parent'))
        anchestors.register_parent('grandchild', 'child')
        self.assertTrue(anchestors.anchestor_of('grandchild', 'parent'))
        self.assertFalse(anchestors.anchestor_of('parent', 'grandchild'))
#

Percentile value depends on definition...

    def test_anchestor_registration2(self):
#

Testing the color object

        Cycle detection 1
#

c = Color('ff8000') self.assertEquals(c.r, 255) self.assertEquals(c.g, 128) self.assertEquals(c.b, 0)

def test_color2(self): c = Color(None) self.assertEquals(c.r, None) self.assertEquals(c.g, None) self.assertEquals(c.b, None)

class TestOperations(TestCase):

def test_anchestor_registration(self): Check basic functionality

        Cycle detection 2
#

The anchestor registration doesn't mind cycles

        Test MapSettings class. Nothing in settings.py, so revert to
        default google projection and srid.
#

anchestors = AnchestorRegistration() anchestors.register_parent('child', 'parent') anchestors.register_parent('parent', 'child') self.assertTrue(anchestors.anchestor_of('child', 'parent')) self.assertTrue(anchestors.anchestor_of('parent', 'child'))

def test_tree_from_list1(self): rows = [] result_good = [] result_function = tree_from_list(rows) self.assertEqual(result_function, result_good)

def test_tree_from_list2(self): rows = [{'name': 'parent_name', 'parent': None},

{'name': 'child_name', 'parent': 'parent_name'}]
result_good = [
{'name': 'parent_name',
'parent': None,
'children': [
{'name': 'child_name',
'parent': 'parent_name',
'children': []}]}]
result_function = tree_from_list(
rows,
id_field='name',
parent_field='parent',
children_field='children',
root_parent=None)
self.assertEqual(result_function, result_good)
def test_tree_from_list3(self): rows = [{'name': 'parent_name', 'parent': None}, {'name': 'child_name', 'parent': 'parent_name'}, {'name': 'child_name2', 'parent': 'parent_name'}, {'name': 'child_name3', 'parent': 'parent_name'}, {'name': 'child_child', 'parent': 'child_name3'}] result_good = [ {'name': 'parent_name', 'parent': None, 'children': [ {'name': 'child_name', 'parent': 'parent_name', 'children': []}, {'name': 'child_name2', 'parent': 'parent_name', 'children': []}, {'name': 'child_name3', 'parent': 'parent_name', 'children': [
{'name': 'child_child',
'parent': 'child_name3',
'children': []}]},
]}]
result_function = tree_from_list(
rows,
id_field='name',
parent_field='parent',
children_field='children',
root_parent=None)
self.assertEqual(result_function, result_good)
def test_tree_from_list_cyclic(self):

        Test custom settings for MapSettings.

#

rows = [{'name': 'child_name', 'parent': 'parent_name'},

{'name': 'parent_name', 'parent': 'child_name'}]
self.assertRaises(
CycleError,
tree_from_list,
rows,
id_field='name',
parent_field='parent',
children_field='children',
root_parent='parent_name')
def test_tree_from_list_cyclic2(self):

#

rows = [{'name': 'parent_name', 'parent': 'parent_name'}, ] self.assertRaises(

CycleError,
tree_from_list,
rows,
id_field='name',
parent_field='parent',
children_field='children',
root_parent='child_name')
def test_named_list(self): rows = [ ['a', 'b', 'c', 'd'], ['f', 'g', 'h', 'i']] names = ['name1', 'name2', 'name3', 'name4'] result = named_list(rows, names) result_good = [ {'name1': 'a', 'name2': 'b', 'name3': 'c', 'name4': 'd'}, {'name1': 'f', 'name2': 'g', 'name3': 'h', 'name4': 'i'}] self.assertEqual(result, result_good)

def test_unique_list(self): rows = [1, 2, 2, 3, 4, 5, 5, 7, 2, 5] result = unique_list(rows) result_good = [1, 2, 3, 4, 5, 7] self.assertEqual(result, result_good)

def test_unique_list2(self): rows = [1, 2], [2, 2], [3, 4], [2, 2], 1, 2 result = unique_list(rows) result_good = [1, 2], [2, 2], 3, 4 self.assertEqual(result, result_good)

class CoordinatesTest(TestCase): fixtures = ('lizard_map', )

def test_detect_prj1(self): prj = None self.assertEquals( lizard_map.coordinates.detect_prj(prj), lizard_map.coordinates.RD)

def test_detect_prj2(self): prj = ('PROJCS["RD_New",GEOGCS["GCS_Amersfoort",' 'DATUM["D_Amersfoort",' 'SPHEROID["Bessel_1841",6377397.155,299.1528128]],' 'PRIMEM["Greenwich",0.0],' 'UNIT["Degree",0.0174532925199433]],' 'PROJECTION["Double_Stereographic"],' 'PARAMETER["False_Easting",155000.0],' 'PARAMETER["False_Northing",463000.0],' 'PARAMETER["Central_Meridian",5.38763888888889],' 'PARAMETER["Scale_Factor",0.9999079],' 'PARAMETER["Latitude_Of_Origin",52.15616055555555],' 'UNIT["Meter",1.0]]') self.assertEquals( lizard_map.coordinates.detect_prj(prj), lizard_map.coordinates.RD)

def test_detect_prj3(self): prj = ('GEOGCS["GCS_WGS_1984",' 'DATUM["D_WGS_1984",' 'SPHEROID["WGS_1984",6378137.0,298.257223563]],' 'PRIMEM["Greenwich",0.0],' 'UNIT["Degree",0.0174532925199433]]') self.assertEquals( lizard_map.coordinates.detect_prj(prj), lizard_map.coordinates.WGS84)

def test_map_settings(self):

#

map_settings = lizard_map.coordinates.MapSettings()

self.assertTrue(map_settings.mapnik_projection(),

lizard_map.coordinates.GOOGLE)
self.assertTrue(map_settings.srid, 900913)
def test_map_settings2(self):