Unit tests - upgrade all to pytest + fix paths logic

setup.py - use pkg_config to setup 'cairo' paths + bump min macOS to 13

Author: artemp

setup.py

@@ -7,6 +7,8 @@
 import subprocess
 import sys
 import glob
+import pkg_resources
+
 from distutils import sysconfig
 from ctypes.util import find_library
 
@@ -230,19 +232,21 @@ def run(self):
 if os.environ.get("PYCAIRO", "false") == "true":
     try:
         extra_comp_args.append('-DHAVE_PYCAIRO')
-        print("-I%s/include/pycairo".format(sys.exec_prefix))
-        extra_comp_args.append("-I{0}/include/pycairo".format(sys.exec_prefix))
+        dist = pkg_resources.get_distribution('pycairo')
+        print(dist.location)
+        print("-I%s/cairo/include".format(dist.location))
+        extra_comp_args.append("-I{0}/cairo/include".format(dist.location))
         #extra_comp_args.extend(check_output(["pkg-config", '--cflags', 'pycairo']).strip().split(' '))
         #linkflags.extend(check_output(["pkg-config", '--libs', 'pycairo']).strip().split(' '))
     except:
         raise Exception("Failed to find compiler options for pycairo")
 
 if sys.platform == 'darwin':
-    extra_comp_args.append('-mmacosx-version-min=10.11')
+    extra_comp_args.append('-mmacosx-version-min=13.0')
     # silence warning coming from boost python macros which
     # would is hard to silence via pragma
     extra_comp_args.append('-Wno-parentheses-equality')
-    linkflags.append('-mmacosx-version-min=10.11')
+    linkflags.append('-mmacosx-version-min=13.0')
 else:
     linkflags.append('-lrt')
     linkflags.append('-Wl,-z,origin')

test/python_tests/cairo_test.py

@@ -1,6 +1,16 @@
 import os
 import shutil
 import mapnik
+import pytest
+from .utilities import execution_path
+
+@pytest.fixture(scope="module")
+def setup():
+    # All of the paths used are relative, if we run the tests
+    # from another directory we need to chdir()
+    os.chdir(execution_path('.'))
+    yield
+
 
 def make_tmp_map():
     m = mapnik.Map(512, 512)
@@ -75,12 +85,12 @@ def cairo_color(c):
 if mapnik.has_pycairo():
     import cairo
 
-    def test_passing_pycairo_context_svg():
+    def test_passing_pycairo_context_svg(setup):
         m = make_tmp_map()
         m.zoom_to_box(mapnik.Box2d(-180, -90, 180, 90))
         test_cairo_file = '/tmp/mapnik-cairo-context-test.svg'
         surface = cairo.SVGSurface(test_cairo_file, m.width, m.height)
-        expected_cairo_file = './test/python_tests/images/pycairo/cairo-cairo-expected.svg'
+        expected_cairo_file = 'images/pycairo/cairo-cairo-expected.svg'
         context = cairo.Context(surface)
         mapnik.render(m, context)
         draw_title(m, context, "Hello Map", size=20)
@@ -102,7 +112,7 @@ def test_passing_pycairo_context_pdf():
         m.zoom_to_box(mapnik.Box2d(-180, -90, 180, 90))
         test_cairo_file = '/tmp/mapnik-cairo-context-test.pdf'
         surface = cairo.PDFSurface(test_cairo_file, m.width, m.height)
-        expected_cairo_file = './test/python_tests/images/pycairo/cairo-cairo-expected.pdf'
+        expected_cairo_file = 'images/pycairo/cairo-cairo-expected.pdf'
         context = cairo.Context(surface)
         mapnik.render(m, context)
         draw_title(m, context, "Hello Map", size=20)
@@ -124,8 +134,8 @@ def test_passing_pycairo_context_png():
         m.zoom_to_box(mapnik.Box2d(-180, -90, 180, 90))
         test_cairo_file = '/tmp/mapnik-cairo-context-test.png'
         surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, m.width, m.height)
-        expected_cairo_file = './test/python_tests/images/pycairo/cairo-cairo-expected.png'
-        expected_cairo_file2 = './test/python_tests/images/pycairo/cairo-cairo-expected-reduced.png'
+        expected_cairo_file = 'images/pycairo/cairo-cairo-expected.png'
+        expected_cairo_file2 = 'images/pycairo/cairo-cairo-expected-reduced.png'
         context = cairo.Context(surface)
         mapnik.render(m, context)
         draw_title(m, context, "Hello Map", size=20)
@@ -163,10 +173,10 @@ def test_passing_pycairo_context_png():
         def _pycairo_surface(type, sym):
             test_cairo_file = '/tmp/mapnik-cairo-surface-test.%s.%s' % (
                 sym, type)
-            expected_cairo_file = './test/python_tests/images/pycairo/cairo-surface-expected.%s.%s' % (
+            expected_cairo_file = 'images/pycairo/cairo-surface-expected.%s.%s' % (
                 sym, type)
             m = mapnik.Map(256, 256)
-            mapnik.load_map(m, './test/data/good_maps/%s_symbolizer.xml' % sym)
+            mapnik.load_map(m, '../data/good_maps/%s_symbolizer.xml' % sym)
             m.zoom_all()
             if hasattr(cairo, '%sSurface' % type.upper()):
                 surface = getattr(

test/python_tests/compositing_test.py

@@ -1,22 +1,14 @@
-# encoding: utf8
-
-from __future__ import print_function
-
 import os
-
-from nose.tools import eq_
-
 import mapnik
+import pytest
+from .utilities import (get_unique_colors, pixel2channels, side_by_side_image, execution_path)
 
-from .utilities import (execution_path, get_unique_colors, pixel2channels,
-                        run_all, side_by_side_image)
-
-
+@pytest.fixture(scope="module")
 def setup():
     # All of the paths used are relative, if we run the tests
     # from another directory we need to chdir()
     os.chdir(execution_path('.'))
-
+    yield
 
 def is_pre(color, alpha):
     return (color * 255.0 / alpha) <= 255
@@ -93,14 +85,14 @@ def validate_pixels_are_premultiplied(image):
     return (num_bad == 0, bad_pixels)
 
 
-def test_compare_images():
-    b = mapnik.Image.open('./images/support/b.png')
+def test_compare_images(setup):
+    b = mapnik.Image.open('images/support/b.png')
     b.premultiply()
     num_ops = len(mapnik.CompositeOp.names)
     successes = []
     fails = []
     for name in mapnik.CompositeOp.names:
-        a = mapnik.Image.open('./images/support/a.png')
+        a = mapnik.Image.open('images/support/a.png')
         a.premultiply()
         a.composite(b, getattr(mapnik.CompositeOp, name))
         actual = '/tmp/mapnik-comp-op-test-' + name + '.png'
@@ -132,53 +124,53 @@ def test_compare_images():
                 name +
                 '.fail.png',
                 'png32')
-    eq_(len(successes), num_ops, '\n' + '\n'.join(fails))
+    assert len(successes) == num_ops, '\n' + '\n'.join(fails)
     b.demultiply()
     # b will be slightly modified by pre and then de multiplication rounding errors
     # TODO - write test to ensure the image is 99% the same.
     #expected_b = mapnik.Image.open('./images/support/b.png')
     # b.save('/tmp/mapnik-comp-op-test-original-mask.png')
-    #eq_(b.tostring('png32'),expected_b.tostring('png32'), '/tmp/mapnik-comp-op-test-original-mask.png is no longer equivalent to original mask: ./images/support/b.png')
+    #assert b.tostring('png32') == expected_b.tostring('png32'), '/tmp/mapnik-comp-op-test-original-mask.png is no longer equivalent to original mask: ./images/support/b.png'
 
 
 def test_pre_multiply_status():
-    b = mapnik.Image.open('./images/support/b.png')
+    b = mapnik.Image.open('images/support/b.png')
     # not premultiplied yet, should appear that way
     result = validate_pixels_are_not_premultiplied(b)
-    eq_(result, True)
+    assert result
     # not yet premultiplied therefore should return false
     result = validate_pixels_are_premultiplied(b)
-    eq_(result[0], False)
+    assert not result[0]
     # now actually premultiply the pixels
     b.premultiply()
     # now checking if premultiplied should succeed
     result = validate_pixels_are_premultiplied(b)
-    eq_(result[0], True)
+    assert result[0]
     # should now not appear to look not premultiplied
     result = validate_pixels_are_not_premultiplied(b)
-    eq_(result, False)
+    assert not result
     # now actually demultiply the pixels
     b.demultiply()
     # should now appear demultiplied
     result = validate_pixels_are_not_premultiplied(b)
-    eq_(result, True)
+    assert result
 
 
 def test_pre_multiply_status_of_map1():
     m = mapnik.Map(256, 256)
     im = mapnik.Image(m.width, m.height)
-    eq_(validate_pixels_are_not_premultiplied(im), True)
+    assert validate_pixels_are_not_premultiplied(im)
     mapnik.render(m, im)
-    eq_(validate_pixels_are_not_premultiplied(im), True)
+    assert validate_pixels_are_not_premultiplied(im)
 
 
 def test_pre_multiply_status_of_map2():
     m = mapnik.Map(256, 256)
     m.background = mapnik.Color(1, 1, 1, 255)
     im = mapnik.Image(m.width, m.height)
-    eq_(validate_pixels_are_not_premultiplied(im), True)
+    assert validate_pixels_are_not_premultiplied(im)
     mapnik.render(m, im)
-    eq_(validate_pixels_are_not_premultiplied(im), True)
+    assert validate_pixels_are_not_premultiplied(im)
 
 if 'shape' in mapnik.DatasourceCache.plugin_names():
     def test_style_level_comp_op():
@@ -215,7 +207,7 @@ def test_style_level_comp_op():
                     name +
                     '.fail.png',
                     'png32')
-        eq_(len(fails), 0, '\n' + '\n'.join(fails))
+        assert len(fails) == 0, '\n' + '\n'.join(fails)
 
     def test_style_level_opacity():
         m = mapnik.Map(512, 512)
@@ -228,35 +220,33 @@ def test_style_level_opacity():
         expected = 'images/support/mapnik-style-level-opacity.png'
         im.save(actual, 'png32')
         expected_im = mapnik.Image.open(expected)
-        eq_(im.tostring('png32'),
-            expected_im.tostring('png32'),
-            'failed comparing actual (%s) and expected (%s)' % (actual,
-                                                                'tests/python_tests/' + expected))
+        assert im.tostring('png32') == expected_im.tostring('png32'), 'failed comparing actual (%s) and expected (%s)' % (actual,
+                                                                                                                          'tests/python_tests/' + expected)
 
 
 def test_rounding_and_color_expectations():
     m = mapnik.Map(1, 1)
     m.background = mapnik.Color('rgba(255,255,255,.4999999)')
     im = mapnik.Image(m.width, m.height)
     mapnik.render(m, im)
-    eq_(get_unique_colors(im), ['rgba(255,255,255,127)'])
+    assert get_unique_colors(im) == ['rgba(255,255,255,127)']
     m = mapnik.Map(1, 1)
     m.background = mapnik.Color('rgba(255,255,255,.5)')
     im = mapnik.Image(m.width, m.height)
     mapnik.render(m, im)
-    eq_(get_unique_colors(im), ['rgba(255,255,255,128)'])
+    assert get_unique_colors(im) == ['rgba(255,255,255,128)']
     im_file = mapnik.Image.open('../data/images/stripes_pattern.png')
-    eq_(get_unique_colors(im_file), ['rgba(0,0,0,0)', 'rgba(74,74,74,255)'])
+    assert get_unique_colors(im_file) == ['rgba(0,0,0,0)', 'rgba(74,74,74,255)']
     # should have no effect
     im_file.premultiply()
-    eq_(get_unique_colors(im_file), ['rgba(0,0,0,0)', 'rgba(74,74,74,255)'])
+    assert get_unique_colors(im_file) == ['rgba(0,0,0,0)', 'rgba(74,74,74,255)']
     im_file.apply_opacity(.5)
     # should have effect now that image has transparency
     im_file.premultiply()
-    eq_(get_unique_colors(im_file), ['rgba(0,0,0,0)', 'rgba(37,37,37,127)'])
+    assert get_unique_colors(im_file) == ['rgba(0,0,0,0)', 'rgba(37,37,37,127)']
     # should restore to original nonpremultiplied colors
     im_file.demultiply()
-    eq_(get_unique_colors(im_file), ['rgba(0,0,0,0)', 'rgba(74,74,74,127)'])
+    assert get_unique_colors(im_file) == ['rgba(0,0,0,0)', 'rgba(74,74,74,127)']
 
 
 def test_background_image_and_background_color():
@@ -265,7 +255,7 @@ def test_background_image_and_background_color():
     m.background_image = '../data/images/stripes_pattern.png'
     im = mapnik.Image(m.width, m.height)
     mapnik.render(m, im)
-    eq_(get_unique_colors(im), ['rgba(255,255,255,128)', 'rgba(74,74,74,255)'])
+    assert get_unique_colors(im) == ['rgba(255,255,255,128)', 'rgba(74,74,74,255)']
 
 
 def test_background_image_with_alpha_and_background_color():
@@ -274,7 +264,7 @@ def test_background_image_with_alpha_and_background_color():
     m.background_image = '../data/images/yellow_half_trans.png'
     im = mapnik.Image(m.width, m.height)
     mapnik.render(m, im)
-    eq_(get_unique_colors(im), ['rgba(255,255,85,191)'])
+    assert get_unique_colors(im) == ['rgba(255,255,85,191)']
 
 
 def test_background_image_with_alpha_and_background_color_against_composited_control():
@@ -295,8 +285,4 @@ def test_background_image_with_alpha_and_background_color_against_composited_con
     # compare image rendered (compositing in `agg_renderer<T>::setup`)
     # vs image composited via python bindings
     #raise Todo("looks like we need to investigate PNG color rounding when saving")
-    # eq_(get_unique_colors(im),get_unique_colors(im1))
-
-if __name__ == "__main__":
-    setup()
-    exit(run_all(eval(x) for x in dir() if x.startswith("test_")))
+    assert get_unique_colors(im) == get_unique_colors(im1)

test/python_tests/csv_test.py

@@ -2,19 +2,27 @@
 import os
 import mapnik
 import pytest
+from .utilities import execution_path
+
+@pytest.fixture(scope="module")
+def setup():
+    # All of the paths used are relative, if we run the tests
+    # from another directory we need to chdir()
+    os.chdir(execution_path('.'))
+    yield
 
 if 'csv' in mapnik.DatasourceCache.plugin_names():
 
     def get_csv_ds(filename):
         return mapnik.Datasource(
-            type='csv', file=os.path.join('./test/data/csv/', filename))
+            type='csv', file=os.path.join('../data/csv/', filename))
 
-    def test_broken_files(visual=False):
-        broken = glob.glob("./test/data/csv/fails/*.*")
-        broken.extend(glob.glob("./test/data/csv/warns/*.*"))
+    def test_broken_files(setup, visual=False):
+        broken = glob.glob("../data/csv/fails/*.*")
+        broken.extend(glob.glob("../data/csv/warns/*.*"))
 
         # Add a filename that doesn't exist
-        broken.append("./test/data/csv/fails/does_not_exist.csv")
+        broken.append("../data/csv/fails/does_not_exist.csv")
 
         for csv in broken:
             if visual:
@@ -24,10 +32,10 @@ def test_broken_files(visual=False):
                 except Exception:
                     print('\x1b[1;32m✓ \x1b[0m', csv)
 
-    def test_good_files(visual=False):
-        good_files = glob.glob("./test/data/csv/*.*")
-        good_files.extend(glob.glob("./test/data/csv/warns/*.*"))
-        ignorable = os.path.join('./test', 'data', 'csv', 'long_lat.vrt')
+    def test_good_files(setup, visual=False):
+        good_files = glob.glob("../data/csv/*.*")
+        good_files.extend(glob.glob("../data/csv/warns/*.*"))
+        ignorable = os.path.join('..', 'data', 'csv', 'long_lat.vrt')
         print("ignorable:", ignorable)
         good_files.remove(ignorable)
         for f in good_files:
@@ -469,7 +477,7 @@ def test_that_fewer_headers_than_rows_throws(**kwargs):
 
     def test_that_feature_id_only_incremented_for_valid_rows(**kwargs):
         ds = mapnik.Datasource(type='csv',
-                               file=os.path.join('./test/data/csv/warns', 'feature_id_counting.csv'))
+                               file=os.path.join('../data/csv/warns', 'feature_id_counting.csv'))
         assert len(ds.fields()) ==  3
         assert ds.fields(), ['x', 'y' ==  'id']
         assert ds.field_types(), ['int', 'int' ==  'int']
@@ -491,7 +499,7 @@ def test_that_feature_id_only_incremented_for_valid_rows(**kwargs):
     def test_dynamically_defining_headers1(**kwargs):
         ds = mapnik.Datasource(type='csv',
                                file=os.path.join(
-                                   './test/data/csv/fails', 'needs_headers_two_lines.csv'),
+                                   '../data/csv/fails', 'needs_headers_two_lines.csv'),
                                headers='x,y,name')
         assert len(ds.fields()) ==  3
         assert ds.fields(), ['x', 'y' ==  'name']
@@ -508,7 +516,7 @@ def test_dynamically_defining_headers1(**kwargs):
     def test_dynamically_defining_headers2(**kwargs):
         ds = mapnik.Datasource(type='csv',
                                file=os.path.join(
-                                   './test/data/csv/fails', 'needs_headers_one_line.csv'),
+                                   '../data/csv/fails', 'needs_headers_one_line.csv'),
                                headers='x,y,name')
         assert len(ds.fields()) ==  3
         assert ds.fields(), ['x', 'y' ==  'name']
@@ -525,7 +533,7 @@ def test_dynamically_defining_headers2(**kwargs):
     def test_dynamically_defining_headers3(**kwargs):
         ds = mapnik.Datasource(type='csv',
                                file=os.path.join(
-                                   './test/data/csv/fails', 'needs_headers_one_line_no_newline.csv'),
+                                   '../data/csv/fails', 'needs_headers_one_line_no_newline.csv'),
                                headers='x,y,name')
         assert len(ds.fields()) ==  3
         assert ds.fields(), ['x', 'y' ==  'name']