4859215502

Build Type

push

github

Committed by Gagaro

Commit Message

Add support for Django 4.2

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

409 of 491 relevant lines covered (83.3%)

13.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.49

/leaflet/tests/tests.py

import django
from django.contrib.admin import ModelAdmin, StackedInline
from django.contrib.admin.options import BaseModelAdmin, InlineModelAdmin
from django.contrib.gis.db import models as gismodels
from django.contrib.staticfiles.storage import StaticFilesStorage
from django.test import SimpleTestCase

from .. import PLUGINS, PLUGIN_FORMS, _normalize_plugins_config

from ..templatetags import leaflet_tags
from ..admin import LeafletGeoAdmin, LeafletGeoAdminMixin
from ..forms.widgets import LeafletWidget
from ..forms import fields


class DummyStaticFilesStorage(StaticFilesStorage):

    def url(self, name):
        raise ValueError


class PluginListingTest(SimpleTestCase):

    def test_default_resources(self):
        PLUGINS.update({
            'a': {'css': 'a'},
            'b': {'css': 'b', 'auto-include': True},
            'c': {'css': 'c'},
        })
        PLUGINS.pop('__is_normalized__')
        _normalize_plugins_config()

        names = leaflet_tags._get_plugin_names(None)
        resources = leaflet_tags._get_all_resources_for_plugins(names, 'css')
        self.assertEqual(['/static/b'], resources)

    def test_all_resources(self):
        PLUGINS.update({
            'a': {'css': 'a'},
            'b': {'css': 'b'},
            'c': {'css': 'c'},
        })
        PLUGINS.pop('ALL')
        PLUGINS.pop(PLUGIN_FORMS)
        PLUGINS.pop('__is_normalized__')
        _normalize_plugins_config()

        names = leaflet_tags._get_plugin_names('ALL')
        resources = leaflet_tags._get_all_resources_for_plugins(names, 'css')
        self.assertEqual(['/static/a', '/static/b', '/static/c'],
                         sorted(resources))

    def test_explicit_resources(self):
        PLUGINS.update({
            'a': {'css': 'a'},
            'b': {'css': 'b'},
            'c': {'css': 'c'},
        })
        PLUGINS.pop('__is_normalized__')
        _normalize_plugins_config()

        names = leaflet_tags._get_plugin_names('a,c')
        resources = leaflet_tags._get_all_resources_for_plugins(names, 'css')
        self.assertEqual(['/static/a', '/static/c'], sorted(resources))


class TemplateTagTest(SimpleTestCase):

    def test_default_layer_in_leaflet_map(self):
        context = leaflet_tags.leaflet_map('map')
        self.assertEqual('map', context['name'])
        self.assertTrue('"OSM", "//{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"' in
                        context['djoptions'])


class LeafletWidgetRenderingTest(SimpleTestCase):
    def test_default_media(self):
        widget = LeafletWidget()
        media = widget.media
        self.assertEqual([], media.render_js())
        self.assertEqual([], list(media.render_css()))

    def test_included_media(self):
        class LeafletWidgetMedia(LeafletWidget):
            include_media = True

        widget = LeafletWidgetMedia()
        media = widget.media
        media_js = "".join(media.render_js())
        media_css = "".join(media.render_css())
        self.assertIn('leaflet/leaflet.js', media_js)
        self.assertIn('leaflet/leaflet.extras.js', media_js)
        self.assertIn('leaflet/leaflet.forms.js', media_js)
        self.assertIn('leaflet/draw/leaflet.draw.js', media_js)

        self.assertIn('leaflet/leaflet.css', media_css)
        self.assertIn('leaflet/draw/leaflet.draw.css', media_css)

    def test_widget_geometry_is_empty_string(self):
        widget = LeafletWidget()
        widget.render('geom', '', {'id': 'geom'})
        self.assertTrue(True, 'We should\'t accept blank geometry in value.')

    def test_widget_get_attrs_deprecation(self):
        widget = LeafletWidget()
        with self.assertWarns(DeprecationWarning):
            priv_result = widget._get_attrs("foo")
        pub_result = widget.get_attrs("foo")
        self.assertEqual(
            priv_result, pub_result,
            msg=(
                'Deprecated \'LeafletWidget._get_attrs\' does not have the the same '
                'output as public method \'LeafletWidget.get_attrs\'.'
            )
        )


class LeafletFieldsWidgetsTest(SimpleTestCase):
    def test_default_widget(self):
        for typ in ['Geometry', 'Point', 'MultiPoint', 'LineString', 'Polygon',
                    'MultiLineString', 'MultiPolygon', 'GeometryCollection']:
            f = getattr(fields, typ + 'Field')()
            self.assertTrue(isinstance(f.widget, LeafletWidget))
            self.assertEqual(f.widget.geom_type, typ.upper())


class DummyAdminSite:
    """
    Mock adminsite, which is required by InlineModelAdmin.__init__
    """

    def is_registered(self, model):
        return True


class DummyModel(gismodels.Model):
    geom = gismodels.PointField()

    class Meta:
        app_label = "leaflet"


class DummyInlineModel(gismodels.Model):
    geom = gismodels.PointField()

    class Meta:
        app_label = "leaflet"


class BaseLeafletGeoAdminTest:
    modeladmin_class = None  # type: BaseModelAdmin
    leafletgeoadmin_class = None  # type: LeafletGeoAdmin

    def setUp(self):
        self.modeladmin = self.leafletgeoadmin_class(DummyModel, DummyAdminSite())
        self.geomfield = DummyModel._meta.get_field('geom')
        self.formfield = self.modeladmin.formfield_for_dbfield(self.geomfield, None)

    def test_widget_for_field(self):
        widget = self.formfield.widget
        self.assertTrue(issubclass(widget.__class__, LeafletWidget))

    def test_widget_parameters(self):
        widget = self.formfield.widget
        self.assertEqual(widget.geom_type, 'POINT')
        self.assertEqual(widget.settings_overrides, {'DEFAULT_CENTER': (8.0, 3.15), })
        self.assertTrue(widget.modifiable)

    def test_widget_media(self):
        widget = self.formfield.widget
        media = widget.media
        media_js = "".join(media.render_js())
        media_css = "".join(media.render_css())
        self.assertIn('leaflet/leaflet.js', media_js)
        self.assertIn('leaflet/leaflet.extras.js', media_js)
        self.assertIn('leaflet/leaflet.forms.js', media_js)
        self.assertIn('leaflet/draw/leaflet.draw.js', media_js)

        self.assertIn('leaflet/leaflet.css', media_css)
        self.assertIn('leaflet/draw/leaflet.draw.css', media_css)

    def test_is_subclass_of_modeladmin(self):
        self.assertTrue(issubclass(self.leafletgeoadmin_class, self.modeladmin_class))


class DummyAdminSettingsOverridesMixin:
    settings_overrides = {
        'DEFAULT_CENTER': (8.0, 3.15),
    }


class DummyMixinModelAdmin(DummyAdminSettingsOverridesMixin, LeafletGeoAdminMixin, ModelAdmin):
    pass


class LeafletGeoAdminMixinTest(BaseLeafletGeoAdminTest, SimpleTestCase):
    modeladmin_class = ModelAdmin
    leafletgeoadmin_class = DummyMixinModelAdmin

    def test_is_not_subclass_of_modeladmin(self):
        self.assertFalse(issubclass(LeafletGeoAdminMixin, BaseModelAdmin))


class DummyModelAdmin(DummyAdminSettingsOverridesMixin, LeafletGeoAdmin):
    pass


class LeafletGeoAdminTest(BaseLeafletGeoAdminTest, SimpleTestCase):
    modeladmin_class = ModelAdmin
    leafletgeoadmin_class = DummyModelAdmin


class DummyMixinStackedInline(DummyAdminSettingsOverridesMixin, LeafletGeoAdminMixin, StackedInline):
    model = DummyInlineModel


class LeafletGeoAdminStackedInlineTest(BaseLeafletGeoAdminTest, SimpleTestCase):
    modeladmin_class = InlineModelAdmin
    leafletgeoadmin_class = DummyMixinStackedInline


class LeafletWidgetMapTest(SimpleTestCase):

    def test_default_parameters(self):
        widget = LeafletWidget()
        output = widget.render('geom', '', {'id': 'geom'})
        self.assertIn(".fieldid = 'geom'", output)
        self.assertIn(".srid = 4326", output)
        self.assertIn(".geom_type = 'Geometry'", output)
        self.assertIn('#geom { display: none; }', output)
        self.assertIn('function geom_map_callback(map, options)', output)

    def test_overriden_parameters(self):
        class PolygonWidget(LeafletWidget):
            geom_type = 'POLYGON'
        widget = PolygonWidget()
        output = widget.render('geometry', '', {'id': 'geometry'})
        self.assertIn(".fieldid = 'geometry'", output)
        self.assertIn(".geom_type = 'Polygon'", output)
        self.assertIn('#geometry { display: none; }', output)
        self.assertIn('function geometry_map_callback(map, options)', output)

    def test_javascript_safe_callback_name(self):
        widget = LeafletWidget()
        output = widget.render('prefix-geom', '')
        self.assertIn('function prefix_geom_map_callback(map, options)', output)
        output = widget.render('geom', '', {'id': 'prefix-geom'})
        self.assertIn('function prefix_geom_map_callback(map, options)', output)


class SettingsOverridesTest(SimpleTestCase):

    def test_settings_overrides(self):
        widget = LeafletWidget(attrs={
            'settings_overrides': {
                'DEFAULT_CENTER': (8.0, 3.14),
            }
        })
        output = widget.render('geom', '', {'id': 'geom'})
        self.assertIn('"center": [8.0, 3.14]', output)

    def test_spatial_extent_settings_overrides(self):
        widget = LeafletWidget(attrs={
            'settings_overrides': {
                'SPATIAL_EXTENT': (
                    3.812255859375,
                    50.387507803003146,
                    4.0869140625,
                    50.523904629228625,
                ),
                'DEFAULT_ZOOM': None,
                'DEFAULT_CENTER': None,
            }
        })
        output = widget.render('geom', '', {'id': 'geom'})
        self.assertIn('"extent": [[50.387507803003146, 3.812255859375], [50.523904629228625, 4.0869140625]]', output)
        self.assertIn('"center": null', output)
        self.assertIn('"zoom": null', output)


class LeafletModelFormTest(SimpleTestCase):

    def test_modelform_field_conformity(self):
        class DummyForm(django.forms.ModelForm):
            geom = fields.PointField()

            class Meta:
                model = DummyModel
                fields = ['geom']

        form = DummyForm()
        output = form.as_p()
        self.assertIn(".geom_type = 'Point'", output)

    def test_modelform_widget_conformity(self):
        class DummyForm(django.forms.ModelForm):
            class Meta:
                model = DummyModel
                fields = ['geom']
                widgets = {'geom': LeafletWidget()}
        form = DummyForm()
        output = form.as_p()
        self.assertIn(".geom_type = 'Point'", output)


class LeafletGeoAdminMapTest(LeafletGeoAdminTest):

    def test_widget_template_overriden(self):
        widget = self.formfield.widget
        output = widget.render('geom', '', {'id': 'geom'})
        self.assertIn('<div id="geom-div-map">', output)
        link_type = 'type="text/css" ' if django.get_version() < '4.1' else ''
        self.assertEqual(
            list(widget.media.render_css()),
            [
                f'<link href="/static/leaflet/leaflet.css" {link_type}media="screen" rel="stylesheet">',
                f'<link href="/static/leaflet/leaflet_django.css" {link_type}media="screen" rel="stylesheet">',
                f'<link href="/static/leaflet/draw/leaflet.draw.css" {link_type}media="screen" rel="stylesheet">',
            ]
        )

1	import django	16✔
2	from django.contrib.admin import ModelAdmin, StackedInline	16✔
3	from django.contrib.admin.options import BaseModelAdmin, InlineModelAdmin	16✔
4	from django.contrib.gis.db import models as gismodels	16✔
5	from django.contrib.staticfiles.storage import StaticFilesStorage	16✔
6	from django.test import SimpleTestCase	16✔
7
8	from .. import PLUGINS, PLUGIN_FORMS, _normalize_plugins_config	16✔
9
10	from ..templatetags import leaflet_tags	16✔
11	from ..admin import LeafletGeoAdmin, LeafletGeoAdminMixin	16✔
12	from ..forms.widgets import LeafletWidget	16✔
13	from ..forms import fields	16✔
14
15
16	class DummyStaticFilesStorage(StaticFilesStorage):	16✔
17
18	def url(self, name):	16✔
19	raise ValueError	×
20
21
22	class PluginListingTest(SimpleTestCase):	16✔
23
24	def test_default_resources(self):	16✔
25	PLUGINS.update({	16✔
26	'a': {'css': 'a'},
27	'b': {'css': 'b', 'auto-include': True},
28	'c': {'css': 'c'},
29	})
30	PLUGINS.pop('__is_normalized__')	16✔
31	_normalize_plugins_config()	16✔
32
33	names = leaflet_tags._get_plugin_names(None)	16✔
34	resources = leaflet_tags._get_all_resources_for_plugins(names, 'css')	16✔
35	self.assertEqual(['/static/b'], resources)	16✔
36
37	def test_all_resources(self):	16✔
38	PLUGINS.update({	16✔
39	'a': {'css': 'a'},
40	'b': {'css': 'b'},
41	'c': {'css': 'c'},
42	})
43	PLUGINS.pop('ALL')	16✔
44	PLUGINS.pop(PLUGIN_FORMS)	16✔
45	PLUGINS.pop('__is_normalized__')	16✔
46	_normalize_plugins_config()	16✔
47
48	names = leaflet_tags._get_plugin_names('ALL')	16✔
49	resources = leaflet_tags._get_all_resources_for_plugins(names, 'css')	16✔
50	self.assertEqual(['/static/a', '/static/b', '/static/c'],	16✔
51	sorted(resources))
52
53	def test_explicit_resources(self):	16✔
54	PLUGINS.update({	16✔
55	'a': {'css': 'a'},
56	'b': {'css': 'b'},
57	'c': {'css': 'c'},
58	})
59	PLUGINS.pop('__is_normalized__')	16✔
60	_normalize_plugins_config()	16✔
61
62	names = leaflet_tags._get_plugin_names('a,c')	16✔
63	resources = leaflet_tags._get_all_resources_for_plugins(names, 'css')	16✔
64	self.assertEqual(['/static/a', '/static/c'], sorted(resources))	16✔
65
66
67	class TemplateTagTest(SimpleTestCase):	16✔
68
69	def test_default_layer_in_leaflet_map(self):	16✔
70	context = leaflet_tags.leaflet_map('map')	16✔
71	self.assertEqual('map', context['name'])	16✔
72	self.assertTrue('"OSM", "//{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"' in	16✔
73	context['djoptions'])
74
75
76	class LeafletWidgetRenderingTest(SimpleTestCase):	16✔
77	def test_default_media(self):	16✔
78	widget = LeafletWidget()	16✔
79	media = widget.media	16✔
80	self.assertEqual([], media.render_js())	16✔
81	self.assertEqual([], list(media.render_css()))	16✔
82
83	def test_included_media(self):	16✔
84	class LeafletWidgetMedia(LeafletWidget):	16✔
85	include_media = True	16✔
86
87	widget = LeafletWidgetMedia()	16✔
88	media = widget.media	16✔
89	media_js = "".join(media.render_js())	16✔
90	media_css = "".join(media.render_css())	16✔
91	self.assertIn('leaflet/leaflet.js', media_js)	16✔
92	self.assertIn('leaflet/leaflet.extras.js', media_js)	16✔
93	self.assertIn('leaflet/leaflet.forms.js', media_js)	16✔
94	self.assertIn('leaflet/draw/leaflet.draw.js', media_js)	16✔
95
96	self.assertIn('leaflet/leaflet.css', media_css)	16✔
97	self.assertIn('leaflet/draw/leaflet.draw.css', media_css)	16✔
98
99	def test_widget_geometry_is_empty_string(self):	16✔
100	widget = LeafletWidget()	16✔
101	widget.render('geom', '', {'id': 'geom'})	16✔
102	self.assertTrue(True, 'We should\'t accept blank geometry in value.')	16✔
103
104	def test_widget_get_attrs_deprecation(self):	16✔
105	widget = LeafletWidget()	16✔
106	with self.assertWarns(DeprecationWarning):	16✔
107	priv_result = widget._get_attrs("foo")	16✔
108	pub_result = widget.get_attrs("foo")	16✔
109	self.assertEqual(	16✔
110	priv_result, pub_result,
111	msg=(
112	'Deprecated \'LeafletWidget._get_attrs\' does not have the the same '
113	'output as public method \'LeafletWidget.get_attrs\'.'
114	)
115	)
116
117
118	class LeafletFieldsWidgetsTest(SimpleTestCase):	16✔
119	def test_default_widget(self):	16✔
120	for typ in ['Geometry', 'Point', 'MultiPoint', 'LineString', 'Polygon',	16✔
121	'MultiLineString', 'MultiPolygon', 'GeometryCollection']:
122	f = getattr(fields, typ + 'Field')()	16✔
123	self.assertTrue(isinstance(f.widget, LeafletWidget))	16✔
124	self.assertEqual(f.widget.geom_type, typ.upper())	16✔
125
126
127	class DummyAdminSite:	16✔
128	"""
129	Mock adminsite, which is required by InlineModelAdmin.__init__
130	"""
131
132	def is_registered(self, model):	16✔
133	return True	16✔
134
135
136	class DummyModel(gismodels.Model):	16✔
137	geom = gismodels.PointField()	16✔
138
139	class Meta:	16✔
140	app_label = "leaflet"	16✔
141
142
143	class DummyInlineModel(gismodels.Model):	16✔
144	geom = gismodels.PointField()	16✔
145
146	class Meta:	16✔
147	app_label = "leaflet"	16✔
148
149
150	class BaseLeafletGeoAdminTest:	16✔
151	modeladmin_class = None # type: BaseModelAdmin	16✔
152	leafletgeoadmin_class = None # type: LeafletGeoAdmin	16✔
153
154	def setUp(self):	16✔
155	self.modeladmin = self.leafletgeoadmin_class(DummyModel, DummyAdminSite())	16✔
156	self.geomfield = DummyModel._meta.get_field('geom')	16✔
157	self.formfield = self.modeladmin.formfield_for_dbfield(self.geomfield, None)	16✔
158
159	def test_widget_for_field(self):	16✔
160	widget = self.formfield.widget	16✔
161	self.assertTrue(issubclass(widget.__class__, LeafletWidget))	16✔
162
163	def test_widget_parameters(self):	16✔
164	widget = self.formfield.widget	16✔
165	self.assertEqual(widget.geom_type, 'POINT')	16✔
166	self.assertEqual(widget.settings_overrides, {'DEFAULT_CENTER': (8.0, 3.15), })	16✔
167	self.assertTrue(widget.modifiable)	16✔
168
169	def test_widget_media(self):	16✔
170	widget = self.formfield.widget	16✔
171	media = widget.media	16✔
172	media_js = "".join(media.render_js())	16✔
173	media_css = "".join(media.render_css())	16✔
174	self.assertIn('leaflet/leaflet.js', media_js)	16✔
175	self.assertIn('leaflet/leaflet.extras.js', media_js)	16✔
176	self.assertIn('leaflet/leaflet.forms.js', media_js)	16✔
177	self.assertIn('leaflet/draw/leaflet.draw.js', media_js)	16✔
178
179	self.assertIn('leaflet/leaflet.css', media_css)	16✔
180	self.assertIn('leaflet/draw/leaflet.draw.css', media_css)	16✔
181
182	def test_is_subclass_of_modeladmin(self):	16✔
183	self.assertTrue(issubclass(self.leafletgeoadmin_class, self.modeladmin_class))	16✔
184
185
186	class DummyAdminSettingsOverridesMixin:	16✔
187	settings_overrides = {	16✔
188	'DEFAULT_CENTER': (8.0, 3.15),
189	}
190
191
192	class DummyMixinModelAdmin(DummyAdminSettingsOverridesMixin, LeafletGeoAdminMixin, ModelAdmin):	16✔
193	pass	16✔
194
195
196	class LeafletGeoAdminMixinTest(BaseLeafletGeoAdminTest, SimpleTestCase):	16✔
197	modeladmin_class = ModelAdmin	16✔
198	leafletgeoadmin_class = DummyMixinModelAdmin	16✔
199
200	def test_is_not_subclass_of_modeladmin(self):	16✔
201	self.assertFalse(issubclass(LeafletGeoAdminMixin, BaseModelAdmin))	16✔
202
203
204	class DummyModelAdmin(DummyAdminSettingsOverridesMixin, LeafletGeoAdmin):	16✔
205	pass	16✔
206
207
208	class LeafletGeoAdminTest(BaseLeafletGeoAdminTest, SimpleTestCase):	16✔
209	modeladmin_class = ModelAdmin	16✔
210	leafletgeoadmin_class = DummyModelAdmin	16✔
211
212
213	class DummyMixinStackedInline(DummyAdminSettingsOverridesMixin, LeafletGeoAdminMixin, StackedInline):	16✔
214	model = DummyInlineModel	16✔
215
216
217	class LeafletGeoAdminStackedInlineTest(BaseLeafletGeoAdminTest, SimpleTestCase):	16✔
218	modeladmin_class = InlineModelAdmin	16✔
219	leafletgeoadmin_class = DummyMixinStackedInline	16✔
220
221
222	class LeafletWidgetMapTest(SimpleTestCase):	16✔
223
224	def test_default_parameters(self):	16✔
225	widget = LeafletWidget()	16✔
226	output = widget.render('geom', '', {'id': 'geom'})	16✔
227	self.assertIn(".fieldid = 'geom'", output)	16✔
228	self.assertIn(".srid = 4326", output)	16✔
229	self.assertIn(".geom_type = 'Geometry'", output)	16✔
230	self.assertIn('#geom { display: none; }', output)	16✔
231	self.assertIn('function geom_map_callback(map, options)', output)	16✔
232
233	def test_overriden_parameters(self):	16✔
234	class PolygonWidget(LeafletWidget):	16✔
235	geom_type = 'POLYGON'	16✔
236	widget = PolygonWidget()	16✔
237	output = widget.render('geometry', '', {'id': 'geometry'})	16✔
238	self.assertIn(".fieldid = 'geometry'", output)	16✔
239	self.assertIn(".geom_type = 'Polygon'", output)	16✔
240	self.assertIn('#geometry { display: none; }', output)	16✔
241	self.assertIn('function geometry_map_callback(map, options)', output)	16✔
242
243	def test_javascript_safe_callback_name(self):	16✔
244	widget = LeafletWidget()	16✔
245	output = widget.render('prefix-geom', '')	16✔
246	self.assertIn('function prefix_geom_map_callback(map, options)', output)	16✔
247	output = widget.render('geom', '', {'id': 'prefix-geom'})	16✔
248	self.assertIn('function prefix_geom_map_callback(map, options)', output)	16✔
249
250
251	class SettingsOverridesTest(SimpleTestCase):	16✔
252
253	def test_settings_overrides(self):	16✔
254	widget = LeafletWidget(attrs={	16✔
255	'settings_overrides': {
256	'DEFAULT_CENTER': (8.0, 3.14),
257	}
258	})
259	output = widget.render('geom', '', {'id': 'geom'})	16✔
260	self.assertIn('"center": [8.0, 3.14]', output)	16✔
261
262	def test_spatial_extent_settings_overrides(self):	16✔
263	widget = LeafletWidget(attrs={	16✔
264	'settings_overrides': {
265	'SPATIAL_EXTENT': (
266	3.812255859375,
267	50.387507803003146,
268	4.0869140625,
269	50.523904629228625,
270	),
271	'DEFAULT_ZOOM': None,
272	'DEFAULT_CENTER': None,
273	}
274	})
275	output = widget.render('geom', '', {'id': 'geom'})	16✔
276	self.assertIn('"extent": [[50.387507803003146, 3.812255859375], [50.523904629228625, 4.0869140625]]', output)	16✔
277	self.assertIn('"center": null', output)	16✔
278	self.assertIn('"zoom": null', output)	16✔
279
280
281	class LeafletModelFormTest(SimpleTestCase):	16✔
282
283	def test_modelform_field_conformity(self):	16✔
284	class DummyForm(django.forms.ModelForm):	16✔
285	geom = fields.PointField()	16✔
286
287	class Meta:	16✔
288	model = DummyModel	16✔
289	fields = ['geom']	16✔
290
291	form = DummyForm()	16✔
292	output = form.as_p()	16✔
293	self.assertIn(".geom_type = 'Point'", output)	16✔
294
295	def test_modelform_widget_conformity(self):	16✔
296	class DummyForm(django.forms.ModelForm):	16✔
297	class Meta:	16✔
298	model = DummyModel	16✔
299	fields = ['geom']	16✔
300	widgets = {'geom': LeafletWidget()}	16✔
301	form = DummyForm()	16✔
302	output = form.as_p()	16✔
303	self.assertIn(".geom_type = 'Point'", output)	16✔
304
305
306	class LeafletGeoAdminMapTest(LeafletGeoAdminTest):	16✔
307
308	def test_widget_template_overriden(self):	16✔
309	widget = self.formfield.widget	16✔
310	output = widget.render('geom', '', {'id': 'geom'})	16✔
311	self.assertIn('<div id="geom-div-map">', output)	16✔
312	link_type = 'type="text/css" ' if django.get_version() < '4.1' else ''	16✔
313	self.assertEqual(	16✔
314	list(widget.media.render_css()),
315	[
316	f'<link href="/static/leaflet/leaflet.css" {link_type}media="screen" rel="stylesheet">',
317	f'<link href="/static/leaflet/leaflet_django.css" {link_type}media="screen" rel="stylesheet">',
318	f'<link href="/static/leaflet/draw/leaflet.draw.css" {link_type}media="screen" rel="stylesheet">',
319	]
320	)

makinacorpus / django-leaflet / 4859215502

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous