MapProxy 2.1.0__py3-none-any.whl

mapproxy/test/unit/test_image_mask.py

@@ -0,0 +1,181 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2012 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from mapproxy.compat.image import Image, ImageDraw
+from mapproxy.image import ImageSource
+from mapproxy.image.mask import mask_image_source_from_coverage
+from mapproxy.image.merge import LayerMerger
+from mapproxy.image.opts import ImageOptions
+from mapproxy.srs import SRS
+from mapproxy.test.image import assert_img_colors_eq, create_image
+from mapproxy.util.coverage import load_limited_to
+
+import pytest
+
+try:
+    from shapely.geometry import Polygon
+
+    geom_support = True
+except ImportError:
+    geom_support = False
+
+pytestmark = pytest.mark.skipif(not geom_support, reason="requires shapely")
+
+
+def coverage(geom, srs="EPSG:4326"):
+    return load_limited_to({"srs": srs, "geometry": geom})
+
+
+class TestMaskImage(object):
+
+    def test_mask_outside_of_image_transparent(self):
+        img = ImageSource(
+            Image.new("RGB", (100, 100), color=(100, 0, 200)),
+            image_opts=ImageOptions(transparent=True),
+        )
+        result = mask_image_source_from_coverage(
+            img, [0, 0, 10, 10], SRS(4326), coverage([20, 20, 30, 30])
+        )
+        assert_img_colors_eq(
+            result.as_image().getcolors(), [((100 * 100), (255, 255, 255, 0))]
+        )
+
+    def test_mask_outside_of_image_bgcolor(self):
+        img = ImageSource(
+            Image.new("RGB", (100, 100), color=(100, 0, 200)),
+            image_opts=ImageOptions(bgcolor=(200, 30, 120)),
+        )
+
+        result = mask_image_source_from_coverage(
+            img, [0, 0, 10, 10], SRS(4326), coverage([20, 20, 30, 30])
+        )
+        assert_img_colors_eq(
+            result.as_image().getcolors(), [((100 * 100), (200, 30, 120))]
+        )
+
+    def test_mask_partial_image_bgcolor(self):
+        img = ImageSource(
+            Image.new("RGB", (100, 100), color=(100, 0, 200)),
+            image_opts=ImageOptions(bgcolor=(200, 30, 120)),
+        )
+
+        result = mask_image_source_from_coverage(
+            img, [0, 0, 10, 10], SRS(4326), coverage([5, 5, 30, 30])
+        )
+        assert_img_colors_eq(
+            result.as_image().getcolors(),
+            [(7500, (200, 30, 120)), (2500, (100, 0, 200))],
+        )
+
+    def test_mask_partial_image_transparent(self):
+        img = ImageSource(
+            Image.new("RGB", (100, 100), color=(100, 0, 200)),
+            image_opts=ImageOptions(transparent=True),
+        )
+
+        result = mask_image_source_from_coverage(
+            img, [0, 0, 10, 10], SRS(4326), coverage([5, 5, 30, 30])
+        )
+        assert_img_colors_eq(
+            result.as_image().getcolors(),
+            [(7500, (255, 255, 255, 0)), (2500, (100, 0, 200, 255))],
+        )
+
+    def test_wkt_mask_partial_image_transparent(self):
+        img = ImageSource(
+            Image.new("RGB", (100, 100), color=(100, 0, 200)),
+            image_opts=ImageOptions(transparent=True),
+        )
+
+        # polygon with hole
+        geom = "POLYGON((2 2, 2 8, 8 8, 8 2, 2 2), (4 4, 4 6, 6 6, 6 4, 4 4))"
+
+        result = mask_image_source_from_coverage(
+            img, [0, 0, 10, 10], SRS(4326), coverage(geom)
+        )
+        # 60*60 - 20*20 = 3200
+        assert_img_colors_eq(
+            result.as_image().getcolors(),
+            [(10000 - 3200, (255, 255, 255, 0)), (3200, (100, 0, 200, 255))],
+        )
+
+    def test_shapely_mask_with_transform_partial_image_transparent(self):
+        img = ImageSource(
+            Image.new("RGB", (100, 100), color=(100, 0, 200)),
+            image_opts=ImageOptions(transparent=True),
+        )
+
+        p = Polygon(
+            [(0, 0), (222000, 0), (222000, 222000), (0, 222000)]
+        )  # ~ 2x2 degres
+
+        result = mask_image_source_from_coverage(
+            img, [0, 0, 10, 10], SRS(4326), coverage(p, "EPSG:3857")
+        )
+        # 20*20 = 400
+        assert_img_colors_eq(
+            result.as_image().getcolors(),
+            [(10000 - 400, (255, 255, 255, 0)), (400, (100, 0, 200, 255))],
+        )
+
+
+class TestLayerCoverageMerge(object):
+
+    def setup_method(self):
+        self.coverage1 = coverage(
+            Polygon([(0, 0), (0, 10), (10, 10), (10, 0)]), 3857
+        )
+        self.coverage2 = coverage([2, 2, 8, 8], 3857)
+
+    def test_merge_single_coverage(self):
+        merger = LayerMerger()
+        merger.add(
+            ImageSource(Image.new("RGB", (10, 10), (255, 255, 255))),
+            self.coverage1,
+        )
+        result = merger.merge(
+            image_opts=ImageOptions(transparent=True),
+            bbox=(5, 0, 15, 10),
+            bbox_srs=3857,
+        )
+        img = result.as_image()
+        assert img.mode == "RGBA"
+        assert img.getpixel((4, 0)) == (255, 255, 255, 255)
+        assert img.getpixel((6, 0)) == (255, 255, 255, 0)
+
+    def test_merge_overlapping_coverage(self):
+        color1 = (255, 255, 0)
+        color2 = (0, 255, 255)
+        merger = LayerMerger()
+        merger.add(
+            ImageSource(Image.new("RGB", (10, 10), color1)), self.coverage1
+        )
+        merger.add(
+            ImageSource(Image.new("RGB", (10, 10), color2)), self.coverage2
+        )
+
+        result = merger.merge(
+            image_opts=ImageOptions(), bbox=(0, 0, 10, 10), bbox_srs=3857
+        )
+        img = result.as_image()
+        assert img.mode == "RGB"
+
+        expected = create_image((10, 10), color1, "RGB")
+        draw = ImageDraw.Draw(expected)
+        draw.polygon([(2, 2), (7, 2), (7, 7), (2, 7)], fill=color2)
+
+        for x in range(0, 9):
+            for y in range(0, 9):
+                assert img.getpixel((x, y)) == expected.getpixel((x, y))

mapproxy/test/unit/test_image_messages.py

@@ -0,0 +1,209 @@
+# -:- encoding: utf8 -:-
+# This file is part of the MapProxy project.
+# Copyright (C) 2010 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+from mapproxy.compat.image import Image, ImageDraw, ImageColor, ImageFont
+from mapproxy.cache.tile import Tile
+from mapproxy.image import ImageSource
+from mapproxy.image.message import TextDraw, message_image
+from mapproxy.image.opts import ImageOptions
+from mapproxy.tilefilter import watermark_filter
+
+import pytest
+
+PNG_FORMAT = ImageOptions(format="image/png")
+
+requires_freetype = pytest.mark.skipif(
+    not isinstance(ImageFont.load_default(), ImageFont.FreeTypeFont),
+    reason="Test expects the default Pillow FreeTypeFont")
+
+
+class TestTextDraw(object):
+
+    def test_ul(self):
+        font = ImageFont.load_default()
+        td = TextDraw("Hello", font)
+        img = Image.new("RGB", (100, 100))
+        draw = ImageDraw.Draw(img)
+        total_box, boxes = td.text_boxes(draw, (100, 100))
+        assert total_box == boxes[0]
+        assert len(boxes) == 1
+
+    @requires_freetype
+    def test_multiline_ul(self):
+        font = ImageFont.load_default()
+        td = TextDraw("Hello\nWorld", font)
+        img = Image.new("RGB", (100, 100))
+        draw = ImageDraw.Draw(img)
+        total_box, boxes = td.text_boxes(draw, (100, 100))
+        assert total_box == (5, 7, 33, 28)
+        assert boxes == [(5, 7, 30, 15), (5, 20, 33, 28)]
+
+    @requires_freetype
+    def test_multiline_lr(self):
+        font = ImageFont.load_default()
+        td = TextDraw("Hello\nWorld", font, placement="lr")
+        img = Image.new("RGB", (100, 100))
+        draw = ImageDraw.Draw(img)
+        total_box, boxes = td.text_boxes(draw, (100, 100))
+        assert total_box == (67, 76, 95, 97)
+        assert boxes == [(67, 76, 92, 84), (67, 89, 95, 97)]
+
+    @requires_freetype
+    def test_multiline_center(self):
+        font = ImageFont.load_default()
+        td = TextDraw("Hello\nWorld", font, placement="cc")
+        img = Image.new("RGB", (100, 100))
+        draw = ImageDraw.Draw(img)
+        total_box, boxes = td.text_boxes(draw, (100, 100))
+        assert total_box == (36, 42, 64, 63)
+        assert boxes == [(36, 42, 61, 50), (36, 55, 64, 63)]
+
+    @requires_freetype
+    def test_unicode(self):
+        font = ImageFont.load_default()
+        td = TextDraw(u"Héllö\nWørld", font, placement="cc")
+        img = Image.new("RGB", (100, 100))
+        draw = ImageDraw.Draw(img)
+        total_box, boxes = td.text_boxes(draw, (100, 100))
+        assert total_box == (36, 42, 64, 63)
+        assert boxes == [(36, 42, 60, 50), (36, 55, 64, 63)]
+
+    def _test_all(self):
+        for x in "c":
+            for y in "LR":
+                yield self.check_placement, x, y
+
+    def check_placement(self, x, y):
+        font = ImageFont.load_default()
+        td = TextDraw(
+            "Hello\nWorld\n%s %s" % (x, y),
+            font,
+            placement=x + y,
+            padding=5,
+            linespacing=2,
+        )
+        img = Image.new("RGB", (100, 100))
+        draw = ImageDraw.Draw(img)
+        td.draw(draw, img.size)
+        img.show()
+
+    def test_transparent(self):
+        font = ImageFont.load_default()
+        td = TextDraw("Hello\nWorld", font, placement="cc")
+        img = Image.new("RGBA", (100, 100), (0, 0, 0, 0))
+        draw = ImageDraw.Draw(img)
+        td.draw(draw, img.size)
+        # override the alpha value as pillow >= 10.1.0 uses a new default font with transparency
+        img.putalpha(255)
+
+        assert len(img.getcolors()) == 2
+        # top color (bg) is transparent
+        assert sorted(img.getcolors())[1][1] == (0, 0, 0, 255)
+
+
+class TestMessageImage(object):
+
+    def test_blank(self):
+        image_opts = PNG_FORMAT.copy()
+        image_opts.bgcolor = "#113399"
+        img = message_image("", size=(100, 150), image_opts=image_opts)
+        assert isinstance(img, ImageSource)
+        assert img.size == (100, 150)
+        pil_img = img.as_image()
+        assert pil_img.getpixel((0, 0)) == ImageColor.getrgb("#113399")
+        # 3 values in histogram (RGB)
+        assert [x for x in pil_img.histogram() if x > 0] == [
+            15000,
+            15000,
+            15000,
+        ]
+
+    @requires_freetype
+    def test_message(self):
+        image_opts = PNG_FORMAT.copy()
+        image_opts.bgcolor = "#113399"
+        img = message_image("test", size=(100, 150), image_opts=image_opts)
+        text_pixels = 75
+        image_pixels = 100 * 150
+        assert isinstance(img, ImageSource)
+        assert img.size == (100, 150)
+        # expect the large histogram count values to be the amount of background pixels
+        assert [x for x in img.as_image().histogram() if x > 10] == [
+            image_pixels - text_pixels,
+            image_pixels - text_pixels,
+            image_pixels - text_pixels,
+        ]
+
+    def test_transparent(self):
+        image_opts = ImageOptions(transparent=True)
+        print(image_opts)
+        img = message_image("", size=(100, 150), image_opts=image_opts)
+        assert isinstance(img, ImageSource)
+        assert img.size == (100, 150)
+        pil_img = img.as_image()
+        assert pil_img.getpixel((0, 0)) == (255, 255, 255, 0)
+        # 6 values in histogram (3xRGB for background, 3xRGB for text message)
+        assert [x for x in pil_img.histogram() if x > 0] == [
+            15000,
+            15000,
+            15000,
+            15000,
+        ]
+
+
+class TestWatermarkTileFilter(object):
+
+    def setup_method(self):
+        self.tile = Tile((0, 0, 0))
+        self.filter = watermark_filter("Test")
+
+    def test_filter(self):
+        img = Image.new("RGB", (200, 200))
+        orig_source = ImageSource(img)
+        self.tile.source = orig_source
+        filtered_tile = self.filter(self.tile)
+
+        assert self.tile is filtered_tile
+        assert orig_source != filtered_tile.source
+
+        pil_img = filtered_tile.source.as_image()
+        assert pil_img.getpixel((0, 0)) == (0, 0, 0)
+
+        colors = pil_img.getcolors()
+        colors.sort()
+        # most but not all parts are bg color
+        assert 39950 > colors[-1][0] > 39000
+        assert colors[-1][1] == (0, 0, 0)
+
+    def test_filter_with_alpha(self):
+        img = Image.new("RGBA", (200, 200), (10, 15, 20, 0))
+        orig_source = ImageSource(img)
+        self.tile.source = orig_source
+        filtered_tile = self.filter(self.tile)
+
+        assert self.tile is filtered_tile
+        assert orig_source != filtered_tile.source
+
+        pil_img = filtered_tile.source.as_image()
+        assert pil_img.getpixel((0, 0)) == (10, 15, 20, 0)
+
+        colors = pil_img.getcolors()
+        colors.sort()
+        # most but not all parts are bg color
+        assert 39950 > colors[-1][0] > 39000
+        assert colors[-1][1] == (10, 15, 20, 0)

mapproxy/test/unit/test_image_options.py

@@ -0,0 +1,160 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2011 Omniscale <http://omniscale.de>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from mapproxy.image.opts import (
+    ImageOptions,
+    create_image,
+    compatible_image_options,
+)
+
+
+class TestCreateImage(object):
+
+    def test_default(self):
+        img = create_image((100, 100))
+        assert img.size == (100, 100)
+        assert img.mode == "RGB"
+        assert img.getcolors() == [(100 * 100, (255, 255, 255))]
+
+    def test_transparent(self):
+        img = create_image((100, 100), ImageOptions(transparent=True))
+        assert img.size == (100, 100)
+        assert img.mode == "RGBA"
+        assert img.getcolors() == [(100 * 100, (255, 255, 255, 0))]
+
+    def test_transparent_rgb(self):
+        img = create_image(
+            (100, 100), ImageOptions(mode="RGB", transparent=True)
+        )
+        assert img.size == (100, 100)
+        assert img.mode == "RGB"
+        assert img.getcolors() == [(100 * 100, (255, 255, 255))]
+
+    def test_bgcolor(self):
+        img = create_image((100, 100), ImageOptions(bgcolor=(200, 100, 0)))
+        assert img.size == (100, 100)
+        assert img.mode == "RGB"
+        assert img.getcolors() == [(100 * 100, (200, 100, 0))]
+
+    def test_rgba_bgcolor(self):
+        img = create_image((100, 100), ImageOptions(bgcolor=(200, 100, 0, 30)))
+        assert img.size == (100, 100)
+        assert img.mode == "RGB"
+        assert img.getcolors() == [(100 * 100, (200, 100, 0))]
+
+    def test_rgba_bgcolor_transparent(self):
+        img = create_image(
+            (100, 100),
+            ImageOptions(bgcolor=(200, 100, 0, 30), transparent=True),
+        )
+        assert img.size == (100, 100)
+        assert img.mode == "RGBA"
+        assert img.getcolors() == [(100 * 100, (200, 100, 0, 30))]
+
+    def test_rgba_bgcolor_rgba_mode(self):
+        img = create_image(
+            (100, 100), ImageOptions(bgcolor=(200, 100, 0, 30), mode="RGBA")
+        )
+        assert img.size == (100, 100)
+        assert img.mode == "RGBA"
+        assert img.getcolors() == [(100 * 100, (200, 100, 0, 30))]
+
+
+class TestCompatibleImageOptions(object):
+
+    def test_formats(self):
+        img_opts = compatible_image_options(
+            [
+                ImageOptions(format="image/png"),
+                ImageOptions(format="image/jpeg"),
+            ]
+        )
+        assert img_opts.format == "image/png"
+
+        img_opts = compatible_image_options(
+            [
+                ImageOptions(format="image/png"),
+                ImageOptions(format="image/jpeg"),
+            ],
+            ImageOptions(format="image/tiff"),
+        )
+        assert img_opts.format == "image/tiff"
+
+    def test_colors(self):
+        img_opts = compatible_image_options(
+            [ImageOptions(colors=None), ImageOptions(colors=16)]
+        )
+        assert img_opts.colors == 16
+
+        img_opts = compatible_image_options(
+            [ImageOptions(colors=256), ImageOptions(colors=16)]
+        )
+        assert img_opts.colors == 256
+
+        img_opts = compatible_image_options(
+            [ImageOptions(colors=256), ImageOptions(colors=16)],
+            ImageOptions(colors=4),
+        )
+        assert img_opts.colors == 4
+
+        img_opts = compatible_image_options(
+            [ImageOptions(colors=256), ImageOptions(colors=0)]
+        )
+        assert img_opts.colors == 0
+
+    def test_transparent(self):
+        img_opts = compatible_image_options(
+            [ImageOptions(transparent=False), ImageOptions(transparent=True)]
+        )
+        assert not img_opts.transparent
+
+        img_opts = compatible_image_options(
+            [ImageOptions(transparent=None), ImageOptions(transparent=True)]
+        )
+        assert img_opts.transparent
+
+        img_opts = compatible_image_options(
+            [ImageOptions(transparent=None), ImageOptions(transparent=True)],
+            ImageOptions(transparent=None),
+        )
+        assert img_opts.transparent
+
+        img_opts = compatible_image_options(
+            [ImageOptions(transparent=True), ImageOptions(transparent=True)]
+        )
+        assert img_opts.transparent
+
+    def test_mode(self):
+        img_opts = compatible_image_options(
+            [ImageOptions(mode="RGB"), ImageOptions(mode="P")]
+        )
+        assert img_opts.mode == "RGB"
+
+        img_opts = compatible_image_options(
+            [ImageOptions(mode="RGBA"), ImageOptions(mode="P")]
+        )
+        assert img_opts.mode == "RGBA"
+
+        img_opts = compatible_image_options(
+            [ImageOptions(mode="RGB"), ImageOptions(mode="P")]
+        )
+        assert img_opts.mode == "RGB"
+
+        img_opts = compatible_image_options(
+            [ImageOptions(mode="RGB"), ImageOptions(mode="P")],
+            ImageOptions(mode="P"),
+        )
+        assert img_opts.mode == "P"

mapproxy/test/unit/test_isodate.py

@@ -0,0 +1,118 @@
+# This file is part of the MapProxy project.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import division
+import pytest
+from mapproxy.util.ext.wmsparse.util import parse_datetime_range, parse_duration
+from mapproxy.util.ext.wmsparse.duration import parse_datetime
+
+expected_dim = {'time': {
+    'values': '2020-09-22T11:20:00Z,2020-09-22T13:20:00Z,2020-09-22T15:20:00Z',
+    'default': '2020-09-22T14:20:00Z'},
+    'dim_reference_time': {
+    'values': '2020-09-22T11:20:00Z,2020-09-22T13:20:00Z,2020-09-22T15:20:00Z',
+    'default': '2020-09-22T14:20:00Z'}}
+
+
+@pytest.fixture(scope="module")
+def config_file():
+    return "dimension.yaml"
+
+
+class TestIsoDate(object):
+
+    @pytest.mark.parametrize("test_input,expected_value", [
+
+        # test_input should be string
+        # expected array ==> [year,month,day,hour,mins,secs,tz]
+
+        ("2020-08-01T12:43:38Z", [2020, 8, 1, 12, 43, 38]),
+
+        ("1999-12-30T01:59:03Z", [1999, 12, 30, 1, 59, 3]),
+
+    ])
+    def test_parsing_datetime(self, test_input, expected_value):
+        # test = "2020-08-01T12:43:38Z"
+        expected_year = expected_value[0]
+        expected_month = expected_value[1]
+        expected_day = expected_value[2]
+        expected_hour = expected_value[3]
+        expected_mins = expected_value[4]
+        expected_secs = expected_value[5]
+
+        result = parse_datetime(test_input)
+        test_tz = result.tzinfo
+        test_tz = test_tz.tzname(test_tz)
+
+        assert result.year == expected_year
+        assert result.month == expected_month
+        assert result.day == expected_day
+        assert result.hour == expected_hour
+        assert result.minute == expected_mins
+        assert result.second == expected_secs
+        assert test_tz == "UTC"
+
+    @pytest.mark.parametrize("test_input,only_time,expected_values", [
+
+        # test_input should be string
+        # only_time flag to indicate only time parsing
+        # expected array ==> [year,month,day,secs]
+
+        ("PT1H", True, [0, 0, 0, 3600]),
+        ("PT1H30M45S", True, [0, 0, 0, 5445]),
+        ("P6MT", False, [0, 6, 0, 0]),
+        ("P1MT", False, [0, 1, 0, 0]),
+        ("P1Y2M1W3DT", False, [1, 2, 10, 0]),
+    ])
+    def test_parse_duration(self, test_input, only_time, expected_values):
+        if only_time:
+            expect = expected_values[-1]
+            result = parse_duration(test_input).seconds
+            assert expect == result
+
+        else:
+            expected_years = expected_values[0]
+            expected_months = expected_values[1]
+            expected_days = expected_values[2]
+            expected_seconds = expected_values[3]
+
+            result = parse_duration(test_input)
+
+            result_years = int(result.years)
+            result_months = int(result.months)
+            result_days = int(result.days)
+            result_seconds = int(result.seconds)
+
+            assert expected_years == result_years
+            assert expected_months == result_months
+            assert expected_days == result_days
+            assert expected_seconds == result_seconds
+
+    @pytest.mark.parametrize("test_input,exp_values", [
+
+        # test_input should be string
+        # only_time flag to indicate only time parsing
+        # exp_values array ==> [time range values]
+        ("2020-09-22T00:00:00Z/2020-09-23T00:00:00Z/PT12H", ['2020-09-22T00:00:00Z',
+                                                             '2020-09-22T12:00:00Z', '2020-09-23T00:00:00Z']),
+        ("2020-08-01T00:00:00Z/P1DT2H30M", ['2020-08-01T00:00:00Z',
+                                            '2020-08-02T02:30:00Z']),
+        ("P1DT2H30M/2020-08-30T00:00:00Z", ['2020-08-28T21:30:00Z',
+                                            '2020-08-30T00:00:00Z'])
+    ])
+    def test_parse_datetime_range(self, test_input, exp_values):
+
+        exp_values = set(exp_values)
+        result = set(parse_datetime_range(test_input))
+
+        assert exp_values == result