geoservercloud 0.8.10.dev6__tar.gz → 0.8.11.dev1__tar.gz

{geoservercloud-0.8.10.dev6 → geoservercloud-0.8.11.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: geoservercloud
-Version: 0.8.10.dev6
+Version: 0.8.11.dev1
 Summary: Lightweight Python client to interact with GeoServer Cloud REST API, GeoServer ACL and OGC services
 License: BSD-2-Clause
 Author: Camptocamp

geoservercloud-0.8.11.dev1/geoserver_acceptance_tests/tests/test_gwc.py

@@ -0,0 +1,295 @@
+import time
+
+import pytest
+
+from geoservercloud import GeoServerCloud
+
+
+def test_tile_cache(geoserver_factory):
+    workspace = "test_gwc"
+    wmts_store = "test_gwc_store"
+    wmts_layer = "ch.swisstopo.swissimage"
+    geoserver: GeoServerCloud = geoserver_factory(workspace)
+
+    content, status = geoserver.create_wmts_store(
+        workspace,
+        wmts_store,
+        capabilities="https://wmts.geo.admin.ch/EPSG/4326/1.0.0/WMTSCapabilities.xml",
+    )
+    assert status == 201
+    assert content == wmts_store
+
+    content, status = geoserver.create_wmts_layer(workspace, wmts_store, wmts_layer)
+    assert status == 201
+    assert content == wmts_layer
+
+    # with automatic tile caching enabled the tile layer is created with the
+    # WMTS layer; wait for it before publishing over it, GeoServer Cloud
+    # propagates the new layer between services asynchronously
+    assert wait_for_tile_layer_status(geoserver, workspace, wmts_layer, 200) == 200
+
+    content, status = geoserver.publish_gwc_layer(workspace, wmts_layer)
+    assert status == 200
+    assert content in ["", "layer saved"]
+
+    response = geoserver.get_tile(
+        format="image/png",
+        layer=f"{workspace}:{wmts_layer}",
+        tile_matrix_set="EPSG:4326",
+        tile_matrix="EPSG:4326:9",
+        row=122,
+        column=534,
+    )
+    assert response.info().get("Content-Type") == "image/png"
+    assert response.info().get("Geowebcache-Cache-Result") == "MISS"
+
+    response = geoserver.get_tile(
+        format="image/png",
+        layer=f"{workspace}:{wmts_layer}",
+        tile_matrix_set="EPSG:4326",
+        tile_matrix="EPSG:4326:9",
+        row=122,
+        column=534,
+    )
+    assert response.info().get("Geowebcache-Cache-Result") == "HIT"
+
+
+def wait_for_tile_layer_status(
+    geoserver, workspace, layer, expected_status, timeout=30
+):
+    """Poll the GWC REST API until the tile layer reaches the expected status.
+
+    GeoServer Cloud propagates catalog changes between services asynchronously;
+    against a monolithic GeoServer the first poll already settles.
+    """
+    deadline = time.monotonic() + timeout
+    status = None
+    while time.monotonic() < deadline:
+        _, status = geoserver.get_gwc_layer(workspace, layer)
+        if status == expected_status:
+            return status
+        time.sleep(0.5)
+    return status
+
+
+@pytest.mark.db
+def test_automatic_tile_layer_lifecycle(config, geoserver_factory):
+    """Tile layers must follow REST catalog changes when automatic caching is on.
+
+    Regression test for https://github.com/geoserver/geoserver-cloud/issues/519
+    """
+    workspace = datastore = "test_gwc_auto"
+    feature_type = "auto_cached_layer"
+    renamed = "auto_cached_layer_renamed"
+    geoserver: GeoServerCloud = geoserver_factory(workspace)
+
+    _, code = geoserver.create_pg_datastore(
+        workspace_name=workspace,
+        datastore_name=datastore,
+        pg_host=config["db"]["pg_host"]["docker"],
+        pg_port=config["db"]["pg_port"]["docker"],
+        pg_db=config["db"]["pg_db"],
+        pg_user=config["db"]["pg_user"],
+        pg_password=config["db"]["pg_password"],
+        pg_schema=config["db"]["pg_schema"],
+        set_default_datastore=True,
+    )
+    assert code == 201
+
+    attributes = {
+        "geom": {"type": "Point", "required": True},
+        "id": {"type": "integer", "required": True},
+    }
+    _, code = geoserver.create_feature_type(
+        feature_type, attributes=attributes, epsg=4326, workspace_name=workspace
+    )
+    assert code == 201
+
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 200) == 200
+
+    response = geoserver.rest_service.rest_client.put(
+        f"/rest/workspaces/{workspace}/datastores/{datastore}/featuretypes/{feature_type}.json",
+        json={"featureType": {"name": renamed}},
+    )
+    assert response.status_code == 200
+
+    assert wait_for_tile_layer_status(geoserver, workspace, renamed, 200) == 200
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 404) == 404
+
+    _, code = geoserver.delete_feature_type(workspace, datastore, renamed)
+    assert code == 200
+
+    assert wait_for_tile_layer_status(geoserver, workspace, renamed, 404) == 404
+
+
+@pytest.mark.db
+def test_tile_layer_follows_workspace_rename(config, geoserver_factory):
+    """Renaming a workspace must rename all its tile layers (prefixed names).
+
+    Regression test for https://github.com/geoserver/geoserver-cloud/issues/519
+    """
+    workspace = datastore = "test_gwc_wsrename"
+    renamed_workspace = "test_gwc_wsrenamed"
+    feature_type = "ws_rename_layer"
+    geoserver: GeoServerCloud = geoserver_factory(workspace)
+
+    _, code = geoserver.create_pg_datastore(
+        workspace_name=workspace,
+        datastore_name=datastore,
+        pg_host=config["db"]["pg_host"]["docker"],
+        pg_port=config["db"]["pg_port"]["docker"],
+        pg_db=config["db"]["pg_db"],
+        pg_user=config["db"]["pg_user"],
+        pg_password=config["db"]["pg_password"],
+        pg_schema=config["db"]["pg_schema"],
+        set_default_datastore=True,
+    )
+    assert code == 201
+
+    attributes = {"geom": {"type": "Point", "required": True}}
+    _, code = geoserver.create_feature_type(
+        feature_type, attributes=attributes, epsg=4326, workspace_name=workspace
+    )
+    assert code == 201
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 200) == 200
+
+    response = geoserver.rest_service.rest_client.put(
+        f"/rest/workspaces/{workspace}.json",
+        json={"workspace": {"name": renamed_workspace}},
+    )
+    assert response.status_code == 200
+
+    try:
+        assert (
+            wait_for_tile_layer_status(geoserver, renamed_workspace, feature_type, 200)
+            == 200
+        )
+        assert (
+            wait_for_tile_layer_status(geoserver, workspace, feature_type, 404) == 404
+        )
+    finally:
+        # rename back to the original name for the workspace cleanup finalizer
+        geoserver.rest_service.rest_client.put(
+            f"/rest/workspaces/{renamed_workspace}.json",
+            json={"workspace": {"name": workspace}},
+        )
+
+
+@pytest.mark.db
+def test_tile_layer_rename_after_tile_layer_recreated_through_gwc(
+    config, geoserver_factory
+):
+    """Layer renames must reach every service even when the service handling the
+    rename has not touched the tile layer since another service last changed it.
+
+    The tile layer is deleted and recreated through the GWC service, then the
+    feature type is renamed through the REST API. The tile layer must follow the
+    rename regardless of which service changed it last.
+    """
+    workspace = datastore = "test_gwc_coldrename"
+    feature_type = "cold_rename_layer"
+    renamed = "cold_rename_layer_renamed"
+    geoserver: GeoServerCloud = geoserver_factory(workspace)
+
+    _, code = geoserver.create_pg_datastore(
+        workspace_name=workspace,
+        datastore_name=datastore,
+        pg_host=config["db"]["pg_host"]["docker"],
+        pg_port=config["db"]["pg_port"]["docker"],
+        pg_db=config["db"]["pg_db"],
+        pg_user=config["db"]["pg_user"],
+        pg_password=config["db"]["pg_password"],
+        pg_schema=config["db"]["pg_schema"],
+        set_default_datastore=True,
+    )
+    assert code == 201
+
+    attributes = {"geom": {"type": "Point", "required": True}}
+    _, code = geoserver.create_feature_type(
+        feature_type, attributes=attributes, epsg=4326, workspace_name=workspace
+    )
+    assert code == 201
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 200) == 200
+
+    # recreate the tile layer through the GWC service
+    _, code = geoserver.delete_gwc_layer(workspace, feature_type)
+    assert code == 200
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 404) == 404
+    _, code = geoserver.publish_gwc_layer(workspace, feature_type)
+    assert code == 200
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 200) == 200
+
+    # rename the feature type through the REST API
+    response = geoserver.rest_service.rest_client.put(
+        f"/rest/workspaces/{workspace}/datastores/{datastore}/featuretypes/{feature_type}.json",
+        json={"featureType": {"name": renamed}},
+    )
+    assert response.status_code == 200
+
+    assert wait_for_tile_layer_status(geoserver, workspace, renamed, 200) == 200
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 404) == 404
+
+    _, code = geoserver.delete_feature_type(workspace, datastore, renamed)
+    assert code == 200
+
+
+@pytest.mark.db
+def test_workspace_rename_after_tile_layer_recreated_through_gwc(
+    config, geoserver_factory
+):
+    """Workspace renames must rename tile layers even when the service handling
+    the rename has not touched them since another service last changed them.
+    """
+    workspace = datastore = "test_gwc_coldws"
+    renamed_workspace = "test_gwc_coldws_renamed"
+    feature_type = "cold_ws_layer"
+    geoserver: GeoServerCloud = geoserver_factory(workspace)
+
+    _, code = geoserver.create_pg_datastore(
+        workspace_name=workspace,
+        datastore_name=datastore,
+        pg_host=config["db"]["pg_host"]["docker"],
+        pg_port=config["db"]["pg_port"]["docker"],
+        pg_db=config["db"]["pg_db"],
+        pg_user=config["db"]["pg_user"],
+        pg_password=config["db"]["pg_password"],
+        pg_schema=config["db"]["pg_schema"],
+        set_default_datastore=True,
+    )
+    assert code == 201
+
+    attributes = {"geom": {"type": "Point", "required": True}}
+    _, code = geoserver.create_feature_type(
+        feature_type, attributes=attributes, epsg=4326, workspace_name=workspace
+    )
+    assert code == 201
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 200) == 200
+
+    # recreate the tile layer through the GWC service
+    _, code = geoserver.delete_gwc_layer(workspace, feature_type)
+    assert code == 200
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 404) == 404
+    _, code = geoserver.publish_gwc_layer(workspace, feature_type)
+    assert code == 200
+    assert wait_for_tile_layer_status(geoserver, workspace, feature_type, 200) == 200
+
+    # rename the workspace through the REST API
+    response = geoserver.rest_service.rest_client.put(
+        f"/rest/workspaces/{workspace}.json",
+        json={"workspace": {"name": renamed_workspace}},
+    )
+    assert response.status_code == 200
+
+    try:
+        assert (
+            wait_for_tile_layer_status(geoserver, renamed_workspace, feature_type, 200)
+            == 200
+        )
+        assert (
+            wait_for_tile_layer_status(geoserver, workspace, feature_type, 404) == 404
+        )
+    finally:
+        geoserver.rest_service.rest_client.put(
+            f"/rest/workspaces/{renamed_workspace}.json",
+            json={"workspace": {"name": workspace}},
+        )

geoservercloud-0.8.11.dev1/geoserver_acceptance_tests/tests/test_rest_resource.py

@@ -0,0 +1,110 @@
+"""Acceptance tests for the REST resource API (/rest/resource/**).
+
+Regression coverage for https://github.com/geoserver/geoserver-cloud/issues/913:
+requests whose path contains "/gwc" anywhere, such as /rest/resource/gwc-gs.xml,
+used to fail with a 500 NPE ("Cannot invoke String.substring(int) because path
+is null") or a 404 for existing resources, because the servlet filters that
+rebuild getPathInfo() in GeoServer Cloud mistook them for GeoWebCache requests.
+"""
+
+import pytest
+
+from geoservercloud import GeoServerCloud
+
+RESOURCE_API = "/rest/resource"
+
+
+@pytest.fixture
+def rest_client(geoserver: GeoServerCloud):
+    return geoserver.rest_service.rest_client
+
+
+@pytest.fixture
+def resource_directory(rest_client, request):
+    """Factory for a resource directory deleted (recursively) on teardown."""
+
+    def _create(directory_name):
+        request.addfinalizer(
+            lambda: rest_client.delete(f"{RESOURCE_API}/{directory_name}")
+        )
+        return directory_name
+
+    return _create
+
+
+def test_get_gwc_config_file(rest_client):
+    """GET an existing file whose name contains "gwc": the exact request from issue #913."""
+    response = rest_client.get(f"{RESOURCE_API}/gwc-gs.xml")
+    assert response.status_code == 200
+    assert "<GeoServerGWCConfig>" in response.text
+
+
+def test_root_listing_contains_gwc_config_file(rest_client):
+    response = rest_client.get(RESOURCE_API, params={"format": "json"})
+    assert response.status_code == 200
+    assert "gwc-gs.xml" in response.text
+
+
+def test_nonexistent_gwc_prefixed_path_returns_404(rest_client):
+    """Missing resources must report 404, not a 500 NPE (issue #913)."""
+    response = rest_client.get(f"{RESOURCE_API}/gwcfoo")
+    assert response.status_code == 404
+
+
+def test_roundtrip_in_gwc_named_directory(rest_client, resource_directory):
+    """Create, list, read and delete inside a directory whose name starts with "gwc"."""
+    directory = resource_directory("gwc913dir")
+    file_path = f"{RESOURCE_API}/{directory}/child.txt"
+
+    put_text_resource(rest_client, file_path, "issue #913 directory probe")
+
+    listing = rest_client.get(f"{RESOURCE_API}/{directory}", params={"format": "json"})
+    assert listing.status_code == 200
+    assert "child.txt" in listing.text
+
+    assert_file_roundtrip(rest_client, file_path, "issue #913 directory probe")
+
+
+def test_roundtrip_on_gwc_prefixed_file_name(rest_client, resource_directory):
+    """Create, read and delete a file whose name starts with "gwc" (issue #913)."""
+    directory = resource_directory("resource_api_913")
+    file_path = f"{RESOURCE_API}/{directory}/gwc-913-probe.txt"
+
+    put_text_resource(rest_client, file_path, "issue #913 file name probe")
+    assert_file_roundtrip(rest_client, file_path, "issue #913 file name probe")
+
+
+def test_roundtrip_on_plain_file_name(rest_client, resource_directory):
+    """Baseline coverage of the resource API on a path without "gwc" in it."""
+    directory = resource_directory("resource_api_plain")
+    file_path = f"{RESOURCE_API}/{directory}/probe.txt"
+
+    put_text_resource(rest_client, file_path, "plain resource probe")
+
+    metadata = rest_client.get(
+        file_path, params={"operation": "metadata", "format": "json"}
+    )
+    assert metadata.status_code == 200
+    assert "probe.txt" in metadata.text
+
+    assert_file_roundtrip(rest_client, file_path, "plain resource probe")
+
+
+def put_text_resource(rest_client, file_path, contents):
+    response = rest_client.put(
+        file_path, data=contents, headers={"Content-Type": "text/plain"}
+    )
+    assert response.status_code in (200, 201)
+
+
+def assert_file_roundtrip(rest_client, file_path, contents):
+    """The file must be readable, deletable, and report 404 once deleted."""
+    response = rest_client.get(file_path)
+    assert response.status_code == 200
+    assert response.text == contents
+
+    response = rest_client.delete(file_path)
+    assert response.status_code == 200
+
+    response = rest_client.get(file_path)
+    assert response.status_code == 404

{geoservercloud-0.8.10.dev6 → geoservercloud-0.8.11.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geoservercloud"
-version = "0.8.10.dev6"
+version = "0.8.11.dev1"
 description = "Lightweight Python client to interact with GeoServer Cloud REST API, GeoServer ACL and OGC services"
 authors = ["Camptocamp <info@camptocamp.com>"]
 license = "BSD-2-Clause"

geoservercloud-0.8.10.dev6/geoserver_acceptance_tests/tests/test_gwc.py

@@ -1,45 +0,0 @@
-from geoservercloud import GeoServerCloud
-
-
-def test_tile_cache(geoserver_factory):
-    workspace = "test_gwc"
-    wmts_store = "test_gwc_store"
-    wmts_layer = "ch.swisstopo.swissimage"
-    geoserver: GeoServerCloud = geoserver_factory(workspace)
-
-    content, status = geoserver.create_wmts_store(
-        workspace,
-        wmts_store,
-        capabilities="https://wmts.geo.admin.ch/EPSG/4326/1.0.0/WMTSCapabilities.xml",
-    )
-    assert status == 201
-    assert content == wmts_store
-
-    content, status = geoserver.create_wmts_layer(workspace, wmts_store, wmts_layer)
-    assert status == 201
-    assert content == wmts_layer
-
-    content, status = geoserver.publish_gwc_layer(workspace, wmts_layer)
-    assert status == 200
-    assert content in ["", "layer saved"]
-
-    response = geoserver.get_tile(
-        format="image/png",
-        layer=f"{workspace}:{wmts_layer}",
-        tile_matrix_set="EPSG:4326",
-        tile_matrix="EPSG:4326:9",
-        row=122,
-        column=534,
-    )
-    assert response.info().get("Content-Type") == "image/png"
-    assert response.info().get("Geowebcache-Cache-Result") == "MISS"
-
-    response = geoserver.get_tile(
-        format="image/png",
-        layer=f"{workspace}:{wmts_layer}",
-        tile_matrix_set="EPSG:4326",
-        tile_matrix="EPSG:4326:9",
-        row=122,
-        column=534,
-    )
-    assert response.info().get("Geowebcache-Cache-Result") == "HIT"