MapProxy 1.16.1__py3-none-any.whl

mapproxy/test/unit/test_request_wmts.py

@@ -0,0 +1,178 @@
+# 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.exception import RequestError
+from mapproxy.request.wmts import wmts_request, WMTS100CapabilitiesRequest
+from mapproxy.request.wmts import (
+    URLTemplateConverter,
+    FeatureInfoURLTemplateConverter,
+    InvalidWMTSTemplate,
+    make_wmts_rest_request_parser,
+    WMTS100RestTileRequest,
+    WMTS100RestFeatureInfoRequest,
+)
+from mapproxy.request.base import url_decode
+
+import pytest
+
+
+def dummy_req(args):
+    return DummyRequest(url_decode(args.replace("\n", "")))
+
+
+def dummy_rest_req(path):
+    return DummyRequest(args="", path=path)
+
+
+class DummyRequest(object):
+
+    def __init__(self, args, path="", url=""):
+        self.args = args
+        self.path = path
+        self.base_url = url
+
+
+def test_tile_request():
+    args = """requeST=GetTile&service=wmts&tileMatrixset=EPSG900913&
+tilematrix=2&tileROW=4&TILECOL=2&FORMAT=image/png&Style=&layer=Foo&version=1.0.0"""
+    req = wmts_request(dummy_req(args))
+
+    assert req.params.coord == (2, 4, "2")
+    assert req.params.layer == "Foo"
+    assert req.params.format == "png"
+    assert req.params.tilematrixset == "EPSG900913"
+
+
+def test_featureinfo_request():
+    args = """requeST=GetFeatureInfo&service=wmts&tileMatrixset=EPSG900913&
+tilematrix=2&tileROW=4&TILECOL=2&FORMAT=image/png&Style=&layer=Foo&version=1.0.0&
+i=5&j=10&infoformat=application/json"""
+    req = wmts_request(dummy_req(args))
+
+    assert req.params.coord == (2, 4, "2")
+    assert req.params.layer == "Foo"
+    assert req.params.format == "png"
+    assert req.params.tilematrixset == "EPSG900913"
+    assert req.params.pos == (5, 10)
+    assert req.params.infoformat == "application/json"
+
+
+def test_capabilities_request():
+    args = """requeST=GetCapabilities&service=wmts"""
+    req = wmts_request(dummy_req(args))
+
+    assert isinstance(req, WMTS100CapabilitiesRequest)
+
+
+def test_template_converter():
+    regexp = URLTemplateConverter(
+        "/{Layer}/{Style}/{TileMatrixSet}-{TileMatrix}-{TileCol}-{TileRow}/tile"
+    ).regexp()
+    match = regexp.match("/wmts/test/bar/foo-EPSG4326-4-12-99/tile")
+    assert match
+    assert match.groupdict()["Layer"] == "test"
+    assert match.groupdict()["TileMatrixSet"] == "foo-EPSG4326"
+    assert match.groupdict()["TileMatrix"] == "4"
+    assert match.groupdict()["TileCol"] == "12"
+    assert match.groupdict()["TileRow"] == "99"
+    assert match.groupdict()["Style"] == "bar"
+
+
+def test_template_converter_deprecated_format():
+    # old format that doesn't match the WMTS spec, now deprecated
+    regexp = URLTemplateConverter(
+        "/{{Layer}}/{{Style}}/{{TileMatrixSet}}-{{TileMatrix}}-{{TileCol}}-{{TileRow}}/tile"
+    ).regexp()
+    match = regexp.match("/wmts/test/bar/foo-EPSG4326-4-12-99/tile")
+    assert match
+    assert match.groupdict()["Layer"] == "test"
+    assert match.groupdict()["TileMatrixSet"] == "foo-EPSG4326"
+    assert match.groupdict()["TileMatrix"] == "4"
+    assert match.groupdict()["TileCol"] == "12"
+    assert match.groupdict()["TileRow"] == "99"
+    assert match.groupdict()["Style"] == "bar"
+
+
+def test_template_converter_missing_vars():
+    with pytest.raises(InvalidWMTSTemplate):
+        URLTemplateConverter("/wmts/{Style}/{TileMatrixSet}/{TileCol}.png").regexp()
+
+
+def test_template_converter_dimensions():
+    converter = URLTemplateConverter(
+        "/{Layer}/{Dim1}/{Dim2}/{TileMatrixSet}-{TileMatrix}-{TileCol}-{TileRow}/tile"
+    )
+    assert converter.dimensions == ["Dim1", "Dim2"]
+
+
+class TestRestRequestParser(object):
+
+    @pytest.fixture
+    def parser(self):
+        return make_wmts_rest_request_parser(
+            URLTemplateConverter(
+                "/{Layer}/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}.{Format}"
+            ),
+            FeatureInfoURLTemplateConverter(
+                "/{Layer}/{TileMatrixSet}/{TileMatrix}/{TileCol}/{TileRow}/{I}/{J}.{InfoFormat}"
+            ),
+        )
+
+    @pytest.mark.parametrize(
+        "url,tile,pos",
+        [
+            ["/wmts/roads/webmercator/09/201/123/10/30.json", (201, 123, 9), (10, 30)],
+            ["/wmts/roads/webmercator/10/201/1/0/999.json", (201, 1, 10), (0, 999)],
+            ["/wmts/roads/webmercator/09/201/123/10/30json", None, None],
+            ["/wmts/roads/webmercator/09/201/123/10.json", None, None],
+            ["/wmts/roads-webmercator/09/201/123/10/30.json", None, None],
+            ["/roads/webmercator/09/201/123/10/30.json", None, None],
+        ],
+    )
+    def test_featureinfo(self, parser, url, tile, pos):
+        if tile is None:
+            with pytest.raises(RequestError):
+                parser(dummy_rest_req(url))
+        else:
+            req = parser(dummy_rest_req(url))
+            assert isinstance(req, WMTS100RestFeatureInfoRequest)
+            req.make_request()
+            assert req.pos == pos
+            assert req.tile == tile
+            assert req.infoformat == "json"
+            assert req.tilematrixset == "webmercator"
+
+    @pytest.mark.parametrize(
+        "url,tile",
+        [
+            ["/wmts/roads/webmercator/09/201/123.png", (201, 123, 9)],
+            ["/wmts/roads/webmercator/10/201/123.png", (201, 123, 10)],
+            ["/wmts/roads/webmercator/10/201/123a.png", None],
+            ["/wmts/roads/webmercator/10/201/123png", None],
+            ["/wmts/roads/webmercator/10/2013.png", None],
+            ["/wmts/roads-webmercator/10/201/123.png", None],
+        ],
+    )
+    def test_tile(self, parser, url, tile):
+        if tile is None:
+            with pytest.raises(RequestError):
+                parser(dummy_rest_req(url))
+        else:
+            req = parser(dummy_rest_req(url))
+            assert isinstance(req, WMTS100RestTileRequest)
+            req.make_request()
+            assert req.tile == tile
+            assert req.format == "png"
+            assert req.tilematrixset == "webmercator"

mapproxy/test/unit/test_response.py

@@ -0,0 +1,79 @@
+# 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 io import BytesIO
+
+from mapproxy.test.helper import Mocker
+from mapproxy.test.mocker import ANY
+from mapproxy.response import Response
+from mapproxy.compat import string_type
+
+
+class TestResponse(Mocker):
+
+    def test_str_response(self):
+        resp = Response("string content")
+        assert isinstance(resp.response, string_type)
+        start_response = self.mock()
+        self.expect(start_response("200 OK", ANY))
+        self.replay()
+        result = resp({"REQUEST_METHOD": "GET"}, start_response)
+        assert next(result) == b"string content"
+
+    def test_itr_response(self):
+        resp = Response(iter(["string content", "as iterable"]))
+        assert hasattr(resp.response, "next") or hasattr(resp.response, "__next__")
+        start_response = self.mock()
+        self.expect(start_response("200 OK", ANY))
+        self.replay()
+        result = resp({"REQUEST_METHOD": "GET"}, start_response)
+        assert next(result) == "string content"
+        assert next(result) == "as iterable"
+
+    def test_file_response(self):
+        data = BytesIO(b"foobar")
+        resp = Response(data)
+        assert resp.response == data
+        start_response = self.mock()
+        self.expect(start_response("200 OK", ANY))
+        self.replay()
+        result = resp({"REQUEST_METHOD": "GET"}, start_response)
+        assert next(result) == b"foobar"
+
+    def test_file_response_w_file_wrapper(self):
+        data = BytesIO(b"foobar")
+        resp = Response(data)
+        assert resp.response == data
+        start_response = self.mock()
+        self.expect(start_response("200 OK", ANY))
+
+        file_wrapper = self.mock()
+        self.expect(file_wrapper(data, resp.block_size)).result("DUMMY")
+        self.replay()
+
+        result = resp(
+            {"REQUEST_METHOD": "GET", "wsgi.file_wrapper": file_wrapper}, start_response
+        )
+        assert result == "DUMMY"
+
+    def test_file_response_content_length(self):
+        data = BytesIO(b"*" * 342)
+        resp = Response(data)
+        assert resp.response == data
+        start_response = self.mock()
+        self.expect(start_response("200 OK", ANY))
+        self.replay()
+        resp({"REQUEST_METHOD": "GET"}, start_response)
+        assert resp.content_length == 342

mapproxy/test/unit/test_seed.py

@@ -0,0 +1,365 @@
+# This file is part of the MapProxy project.
+# Copyright (C) 2010-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 __future__ import division
+
+import os
+import time
+from collections import defaultdict
+
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+import pytest
+
+from mapproxy.seed.seeder import TileWalker, SeedTask, SeedProgress
+from mapproxy.cache.dummy import DummyLocker
+from mapproxy.cache.tile import TileManager
+from mapproxy.source.tile import TiledSource
+from mapproxy.grid import tile_grid_for_epsg
+from mapproxy.grid import TileGrid
+from mapproxy.srs import SRS
+from mapproxy.util.coverage import BBOXCoverage, GeomCoverage
+from mapproxy.seed.config import before_timestamp_from_options, SeedConfigurationError
+from mapproxy.seed.config import (
+    LevelsList,
+    LevelsRange,
+    LevelsResolutionList,
+    LevelsResolutionRange,
+)
+from mapproxy.seed.util import ProgressStore
+from mapproxy.test.helper import TempFile
+
+
+try:
+    from shapely.wkt import loads as load_wkt
+
+    load_wkt  # prevent lint warning
+except ImportError:
+    load_wkt = None
+
+
+class MockSeedPool(object):
+
+    def __init__(self):
+        self.seeded_tiles = defaultdict(set)
+
+    def process(self, tiles, progess):
+        for x, y, level in tiles:
+            self.seeded_tiles[level].add((x, y))
+
+
+class MockCache(object):
+
+    def is_cached(self, tile,dimensions=None):
+        return False
+
+
+class TestSeeder(object):
+
+    def setup(self):
+        self.grid = TileGrid(SRS(4326), bbox=[-180, -90, 180, 90])
+        self.source = TiledSource(self.grid, None)
+        self.tile_mgr = TileManager(
+            self.grid, MockCache(), [self.source], "png", locker=DummyLocker()
+        )
+        self.seed_pool = MockSeedPool()
+
+    def make_bbox_task(self, bbox, srs, levels):
+        md = dict(name="", cache_name="", grid_name="")
+        coverage = BBOXCoverage(bbox, srs)
+        return SeedTask(
+            md, self.tile_mgr, levels, refresh_timestamp=None, coverage=coverage
+        )
+
+    def make_geom_task(self, geom, srs, levels):
+        md = dict(name="", cache_name="", grid_name="")
+        coverage = GeomCoverage(geom, srs)
+        return SeedTask(
+            md, self.tile_mgr, levels, refresh_timestamp=None, coverage=coverage
+        )
+
+    def test_seed_full_bbox(self):
+        task = self.make_bbox_task([-180, -90, 180, 90], SRS(4326), [0, 1, 2])
+        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
+        seeder.walk()
+
+        assert len(self.seed_pool.seeded_tiles) == 3
+        assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
+        assert self.seed_pool.seeded_tiles[1] == set([(0, 0), (1, 0)])
+        assert self.seed_pool.seeded_tiles[2] == set(
+            [(0, 0), (1, 0), (2, 0), (3, 0), (0, 1), (1, 1), (2, 1), (3, 1)]
+        )
+
+    def test_seed_small_bbox(self):
+        task = self.make_bbox_task([-45, 0, 180, 90], SRS(4326), [0, 1, 2])
+        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
+        seeder.walk()
+
+        assert len(self.seed_pool.seeded_tiles) == 3
+        assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
+        assert self.seed_pool.seeded_tiles[1] == set([(0, 0), (1, 0)])
+        assert self.seed_pool.seeded_tiles[2] == set([(1, 1), (2, 1), (3, 1)])
+
+    def test_seed_small_bbox_iregular_levels(self):
+        task = self.make_bbox_task([-45, 0, 180, 90], SRS(4326), [0, 2])
+        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
+        seeder.walk()
+
+        assert len(self.seed_pool.seeded_tiles) == 2
+        assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
+        assert self.seed_pool.seeded_tiles[2] == set([(1, 1), (2, 1), (3, 1)])
+
+    def test_seed_small_bbox_transformed(self):
+        bbox = SRS(4326).transform_bbox_to(SRS(900913), [-45, 0, 179, 80])
+        task = self.make_bbox_task(bbox, SRS(900913), [0, 1, 2])
+        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
+        seeder.walk()
+
+        assert len(self.seed_pool.seeded_tiles) == 3
+        assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
+        assert self.seed_pool.seeded_tiles[1] == set([(0, 0), (1, 0)])
+        assert self.seed_pool.seeded_tiles[2] == set([(1, 1), (2, 1), (3, 1)])
+
+    @pytest.mark.skipif(not load_wkt, reason="Shapely not installed")
+    def test_seed_with_geom(self):
+        # box from 10 10 to 80 80 with small spike/corner to -10 60 (upper left)
+        geom = load_wkt("POLYGON((10 10, 10 50, -10 60, 10 80, 80 80, 80 10, 10 10))")
+        task = self.make_geom_task(geom, SRS(4326), [0, 1, 2, 3, 4])
+        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
+        seeder.walk()
+
+        assert len(self.seed_pool.seeded_tiles) == 5
+        assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
+        assert self.seed_pool.seeded_tiles[1] == set([(0, 0), (1, 0)])
+        assert self.seed_pool.seeded_tiles[2] == set([(1, 1), (2, 1)])
+        assert self.seed_pool.seeded_tiles[3] == set(
+            [(4, 2), (5, 2), (4, 3), (5, 3), (3, 3)]
+        )
+        assert len(self.seed_pool.seeded_tiles[4]) == 4 * 4 + 2
+
+    @pytest.mark.skipif(not load_wkt, reason="Shapely not installed")
+    def test_seed_with_res_list(self):
+        # box from 10 10 to 80 80 with small spike/corner to -10 60 (upper left)
+        geom = load_wkt("POLYGON((10 10, 10 50, -10 60, 10 80, 80 80, 80 10, 10 10))")
+
+        self.grid = TileGrid(
+            SRS(4326),
+            bbox=[-180, -90, 180, 90],
+            res=[360 / 256, 360 / 720, 360 / 2000, 360 / 5000, 360 / 8000],
+        )
+        self.tile_mgr = TileManager(
+            self.grid, MockCache(), [self.source], "png", locker=DummyLocker()
+        )
+        task = self.make_geom_task(geom, SRS(4326), [0, 1, 2, 3, 4])
+        seeder = TileWalker(task, self.seed_pool, handle_uncached=True)
+        seeder.walk()
+
+        assert len(self.seed_pool.seeded_tiles) == 5
+        assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
+        assert self.grid.grid_sizes[1] == (3, 2)
+        assert self.seed_pool.seeded_tiles[1] == set([(1, 0), (1, 1), (2, 0), (2, 1)])
+        assert self.grid.grid_sizes[2] == (8, 4)
+        assert self.seed_pool.seeded_tiles[2] == set(
+            [(4, 2), (5, 2), (4, 3), (5, 3), (3, 3)]
+        )
+        assert self.grid.grid_sizes[3] == (20, 10)
+        assert len(self.seed_pool.seeded_tiles[3]) == 5 * 5 + 2
+
+    def test_seed_full_bbox_continue(self):
+        task = self.make_bbox_task([-180, -90, 180, 90], SRS(4326), [0, 1, 2])
+        seed_progress = SeedProgress([(0, 1), (1, 2)])
+        seeder = TileWalker(
+            task, self.seed_pool, handle_uncached=True, seed_progress=seed_progress
+        )
+        seeder.walk()
+
+        assert len(self.seed_pool.seeded_tiles) == 3
+        assert self.seed_pool.seeded_tiles[0] == set([(0, 0)])
+        assert self.seed_pool.seeded_tiles[1] == set([(0, 0), (1, 0)])
+        assert self.seed_pool.seeded_tiles[2] == set([(2, 0), (3, 0), (2, 1), (3, 1)])
+
+
+class TestLevels(object):
+
+    def test_level_list(self):
+        levels = LevelsList([-10, 3, 1, 3, 5, 7, 50])
+        assert levels.for_grid(tile_grid_for_epsg(4326)) == [1, 3, 5, 7]
+
+    def test_level_range(self):
+        levels = LevelsRange([1, 5])
+        assert levels.for_grid(tile_grid_for_epsg(4326)) == [1, 2, 3, 4, 5]
+
+    def test_level_range_open_from(self):
+        levels = LevelsRange([None, 5])
+        assert levels.for_grid(tile_grid_for_epsg(4326)) == [0, 1, 2, 3, 4, 5]
+
+    def test_level_range_open_to(self):
+        levels = LevelsRange([13, None])
+        assert levels.for_grid(tile_grid_for_epsg(4326)) == [13, 14, 15, 16, 17, 18, 19]
+
+    def test_level_range_open_tos_range(self):
+        levels = LevelsResolutionRange([1000, 100])
+        assert levels.for_grid(tile_grid_for_epsg(900913)) == [8, 9, 10, 11]
+
+    def test_res_range_open_from(self):
+        levels = LevelsResolutionRange([None, 100])
+        assert levels.for_grid(tile_grid_for_epsg(900913)) == [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10,
+            11,
+        ]
+
+    def test_res_range_open_to(self):
+        levels = LevelsResolutionRange([1000, None])
+        assert levels.for_grid(tile_grid_for_epsg(900913)) == [
+            8,
+            9,
+            10,
+            11,
+            12,
+            13,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+        ]
+
+    def test_resolution_list(self):
+        levels = LevelsResolutionList([1000, 100, 500])
+        assert levels.for_grid(tile_grid_for_epsg(900913)) == [8, 9, 11]
+
+
+class TestProgressStore(object):
+
+    def test_load_empty(self):
+        store = ProgressStore("doesnotexist.no_realy.txt")
+        store.load()
+        assert store.get(("foo", "bar", "baz")) == None
+
+    def test_load_store(self):
+        with TempFile(no_create=True) as tmp:
+            with open(tmp, "wb") as f:
+                f.write(pickle.dumps({("view", "cache", "grid"): [(0, 1), (2, 4)]}))
+            store = ProgressStore(tmp)
+            assert store.get(("view", "cache", "grid")) == [(0, 1), (2, 4)]
+            assert store.get(("view", "cache", "grid2")) == None
+            store.add(("view", "cache", "grid"), [])
+            store.add(("view", "cache", "grid2"), [(0, 1)])
+            store.write()
+
+            store = ProgressStore(tmp)
+            assert store.get(("view", "cache", "grid")) == []
+            assert store.get(("view", "cache", "grid2")) == [(0, 1)]
+
+    def test_load_broken(self):
+        with TempFile(no_create=True) as tmp:
+            with open(tmp, "wb") as f:
+                f.write(b"##invaliddata")
+                f.write(pickle.dumps({("view", "cache", "grid"): [(0, 1), (2, 4)]}))
+
+            store = ProgressStore(tmp)
+            assert store.status == {}
+
+
+class TestRemovebreforeTimetamp(object):
+
+    def test_from_time(self):
+        ts = before_timestamp_from_options({"time": "2010-12-01T20:12:00"})
+        # we don't know the timezone this test will run
+        assert (1291230720.0 - 14 * 3600) < ts < (1291230720.0 + 14 * 3600)
+
+    def test_from_mtime(self):
+        with TempFile() as tmp:
+            os.utime(tmp, (12376512, 12376512))
+            assert before_timestamp_from_options({"mtime": tmp}) == 12376512
+
+    def test_from_mtime_missing_file(self):
+        with pytest.raises(SeedConfigurationError):
+            before_timestamp_from_options(
+                {"mtime": "/tmp/does-not-exist-at-all,really"}
+            )
+
+    def test_from_empty(self):
+        assert before_timestamp_from_options({}) == pytest.approx(time.time(), 1)
+
+    def test_from_delta(self):
+        assert (
+            before_timestamp_from_options({"minutes": 15}) + 60 * 15
+        ) == pytest.approx(time.time(), 1)
+
+
+class TestSeedProgress(object):
+
+    def test_progress_identifier(self):
+        old = SeedProgress()
+        with old.step_down(0, 2):
+            with old.step_down(0, 4):
+                assert old.current_progress_identifier() == [(0, 2), (0, 4)]
+            # previous leafs are still present
+            assert old.current_progress_identifier() == [(0, 2), (0, 4)]
+            with old.step_down(1, 4):
+                assert old.current_progress_identifier() == [(0, 2), (1, 4)]
+            assert old.current_progress_identifier() == [(0, 2), (1, 4)]
+
+        assert old.current_progress_identifier() == []  # empty list after seed
+
+        with old.step_down(1, 2):
+            assert old.current_progress_identifier() == [(1, 2)]
+            with old.step_down(0, 4):
+                with old.step_down(1, 4):
+                    assert old.current_progress_identifier() == [(1, 2), (0, 4), (1, 4)]
+
+    def test_already_processed(self):
+        new = SeedProgress([(0, 2)])
+        with new.step_down(0, 2):
+            assert not new.already_processed()
+            with new.step_down(0, 2):
+                assert not new.already_processed()
+
+        new = SeedProgress([(1, 2)])
+        with new.step_down(0, 2):
+            assert new.already_processed()
+            with new.step_down(0, 2):
+                assert new.already_processed()
+
+        new = SeedProgress([(0, 2), (1, 4), (2, 4)])
+        with new.step_down(0, 2):
+            assert not new.already_processed()
+            with new.step_down(0, 4):
+                assert new.already_processed()
+            with new.step_down(1, 4):
+                assert not new.already_processed()
+                with new.step_down(1, 4):
+                    assert new.already_processed()
+                with new.step_down(2, 4):
+                    assert not new.already_processed()
+                with new.step_down(3, 4):
+                    assert not new.already_processed()
+            with new.step_down(2, 4):
+                assert not new.already_processed()