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()
self.assertTrue(unicode(workspace))
def test_absolute_url(self): workspace = Workspace() workspace.save()
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)
# 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)
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)
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):
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)
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):
passself.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):
passdef 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):