diff --git a/acceptance_tests/pyproject.toml b/acceptance_tests/pyproject.toml
index 956567cf..30198ef0 100644
--- a/acceptance_tests/pyproject.toml
+++ b/acceptance_tests/pyproject.toml
@@ -10,7 +10,7 @@ packages = [{ include = "tests" }]
 python = "^3.10"
 pytest = "^8.3.3"
 psycopg2-binary = "^2.9.9"
-geoservercloud = "^0.2.5"
+geoservercloud = "^0.5.0"
 sqlalchemy = "^2.0.35"
 
 
diff --git a/acceptance_tests/tests/conftest.py b/acceptance_tests/tests/conftest.py
index 40624be4..8fce74e1 100644
--- a/acceptance_tests/tests/conftest.py
+++ b/acceptance_tests/tests/conftest.py
@@ -45,8 +45,8 @@ def geoserver():
     geoserver = GeoServerCloud(GEOSERVER_URL)
     geoserver.recreate_workspace(WORKSPACE, set_default_workspace=True)
     geoserver.create_pg_datastore(
-        workspace=WORKSPACE,
-        datastore=DATASTORE,
+        workspace_name=WORKSPACE,
+        datastore_name=DATASTORE,
         pg_host=PGHOST,
         pg_port=PGPORT,
         pg_db=PGDATABASE,
diff --git a/acceptance_tests/tests/test_cascaded_stores.py b/acceptance_tests/tests/test_cascaded_stores.py
index e355e397..635edfa3 100644
--- a/acceptance_tests/tests/test_cascaded_stores.py
+++ b/acceptance_tests/tests/test_cascaded_stores.py
@@ -13,24 +13,6 @@ WMTS_URL = "https://wmts.geo.admin.ch/EPSG/4326/1.0.0/WMTSCapabilities.xml"
 WMTS_LAYER = "ch.swisstopo.pixelkarte-grau"
 
 
-def create_cascaded_wms_store_payload():
-    return {
-        "wmsStore": {
-            "name": WMS_STORE,
-            "type": "WMS",
-            "enabled": "true",
-            "workspace": {"name": WORKSPACE},
-            "metadata": {"entry": {"@key": "useConnectionPooling", "$": "true"}},
-            "_default": "false",
-            "disableOnConnFailure": "false",
-            "capabilitiesURL": WMS_URL,
-            "maxConnections": 6,
-            "readTimeout": 60,
-            "connectTimeout": 30,
-        }
-    }
-
-
 @pytest.fixture(scope="module")
 def geoserver():
     geoserver = GeoServerCloud(url=GEOSERVER_URL)
@@ -44,23 +26,22 @@ def test_cascaded_wms(geoserver):
     format = "image/jpeg"
 
     # Create WMS store
-    payload = create_cascaded_wms_store_payload()
-    response = geoserver.post_request(
-        f"/rest/workspaces/{WORKSPACE}/wmsstores", json=payload
+    content, status = geoserver.create_wms_store(
+        workspace_name=WORKSPACE,
+        wms_store_name=WMS_STORE,
+        capabilities_url=WMS_URL,
     )
-    assert response.status_code == 201
+    assert content == WMS_STORE
+    assert status == 201
 
     # Publish layer
-    payload = {
-        "wmsLayer": {
-            "name": WMS_LAYER,
-        }
-    }
-    response = geoserver.post_request(
-        f"/rest/workspaces/{WORKSPACE}/wmsstores/{WMS_STORE}/wmslayers",
-        json=payload,
+    content, status = geoserver.create_wms_layer(
+        workspace_name=WORKSPACE,
+        wms_store_name=WMS_STORE,
+        native_layer_name=WMS_LAYER,
     )
-    assert response.status_code == 201
+    assert content == WMS_LAYER
+    assert status == 201
 
     # Perform GetMap request
     response = geoserver.get_map(
@@ -87,34 +68,41 @@ def test_cascaded_wms(geoserver):
     assert data.get("features") == []
 
     # Delete store
-    response = geoserver.delete_request(
-        f"/rest/workspaces/{WORKSPACE}/wmsstores/{WMS_STORE}?recurse=true"
+    content, status = geoserver.delete_wms_store(
+        workspace_name=WORKSPACE, wms_store_name=WMS_STORE
     )
-    assert response.status_code == 200
+    assert content == ""
+    assert status == 200
 
 
 def test_cascaded_wmts(geoserver):
     format = "image/jpeg"
 
     # Create WMTS store
-    response = geoserver.create_wmts_store(
-        WORKSPACE,
-        WMTS_STORE,
-        capabilities="https://wmts.geo.admin.ch/EPSG/4326/1.0.0/WMTSCapabilities.xml",
+    content, status = geoserver.create_wmts_store(
+        workspace_name=WORKSPACE,
+        name=WMTS_STORE,
+        capabilities=WMTS_URL,
     )
-    assert response.status_code == 201
+    assert content == WMTS_STORE
+    assert status == 201
 
     # Publish layer (GeoServer)
-    response = geoserver.create_wmts_layer(WORKSPACE, WMTS_STORE, WMTS_LAYER)
-    assert response.status_code == 201
-    response = geoserver.get_request(
-        f"/rest/workspaces/{WORKSPACE}/wmtsstores/{WMTS_STORE}/layers/{WMTS_LAYER}.json"
+    content, status = geoserver.create_wmts_layer(
+        workspace_name=WORKSPACE,
+        wmts_store=WMTS_STORE,
+        native_layer=WMTS_LAYER,
     )
-    assert response.status_code == 200
+    assert content == WMTS_LAYER
+    assert status == 201
 
     # Publish the layer in GWC
-    response = geoserver.publish_gwc_layer(WORKSPACE, WMTS_LAYER)
-    assert response.status_code == 200
+    content, status = geoserver.publish_gwc_layer(WORKSPACE, WMTS_LAYER)
+    assert content == "layer saved"
+    assert status == 200
+    content, status = geoserver.get_gwc_layer(WORKSPACE, WMTS_LAYER)
+    assert status == 200
+    assert content.get("GeoServerLayer", {}).get("name") == f"{WORKSPACE}:{WMTS_LAYER}"
 
     # Perform GetTile request (GWC)
     response = geoserver.get_tile(
@@ -128,9 +116,12 @@ def test_cascaded_wmts(geoserver):
     assert response.info().get("Content-Type") == format
 
     # Delete layer and store
-    response = geoserver.delete_request(f"/gwc/rest/layers/{WORKSPACE}:{WMTS_LAYER}")
-    assert response.status_code == 200
-    response = geoserver.delete_request(
-        f"/rest/workspaces/{WORKSPACE}/wmtsstores/{WMTS_STORE}?recurse=true"
+    content, code = geoserver.delete_gwc_layer(
+        workspace_name=WORKSPACE, layer=WMTS_LAYER
+    )
+    assert content == f"{WORKSPACE}:{WMTS_LAYER} deleted"
+    assert code == 200
+    response = geoserver.rest_service.rest_client.delete(
+        f"{geoserver.rest_service.rest_endpoints.wmtsstore(WORKSPACE,WMTS_STORE)}?recurse=true",
     )
     assert response.status_code == 200
diff --git a/acceptance_tests/tests/test_cog.py b/acceptance_tests/tests/test_cog.py
index f75c6fce..1ca5c367 100644
--- a/acceptance_tests/tests/test_cog.py
+++ b/acceptance_tests/tests/test_cog.py
@@ -2,25 +2,28 @@ import pytest
 from geoservercloud import GeoServerCloud
 from conftest import GEOSERVER_URL
 
+WORKSPACE = "cog"
 
-def test_create_cog_coverage():
+
+@pytest.fixture(scope="function")
+def geoserver():
+    geoserver = GeoServerCloud(url=GEOSERVER_URL)
+    geoserver.create_workspace(WORKSPACE, set_default_workspace=True)
+    yield geoserver
+    geoserver.delete_workspace(WORKSPACE)
+
+
+def test_create_cog_coverage(geoserver):
     """Test creating a COG coverage store and coverage"""
-    geoserver = GeoServerCloud(GEOSERVER_URL)
-    workspace = "cog"
     store_name = "land_shallow_topo_21600_NW_cog"
     coverage_name = "land_shallow_topo_NW"
 
-    # Delete and recreate workspace
-    geoserver.delete_workspace(workspace)
-    response = geoserver.create_workspace(workspace)
-    assert response.status_code == 201
-
     # Create COG coverage store
     store_xml = f"""<coverageStore>
     <name>{store_name}</name>
     <type>GeoTIFF</type>
     <enabled>true</enabled>
-    <workspace><name>{workspace}</name></workspace>
+    <workspace><name>{WORKSPACE}</name></workspace>
     <url>cog://https://test-data-cog-public.s3.amazonaws.com/public/land_shallow_topo_21600_NW_cog.tif</url>
     <metadata>
         <entry key="CogSettings.Key">
@@ -31,10 +34,13 @@ def test_create_cog_coverage():
     </metadata>
 </coverageStore>"""
 
-    response = geoserver.post_request(
-        f"/rest/workspaces/{workspace}/coveragestores",
+    rest_client = geoserver.rest_service.rest_client
+    endpoints = geoserver.rest_service.rest_endpoints
+
+    response = rest_client.post(
+        endpoints.coveragestores(WORKSPACE),
         data=store_xml,
-        headers={"Content-Type": "application/xml"}
+        headers={"Content-Type": "application/xml"},
     )
     assert response.status_code == 201
 
@@ -44,21 +50,21 @@ def test_create_cog_coverage():
         <nativeName>{store_name}</nativeName>
     </coverage>"""
 
-    response = geoserver.post_request(
-        f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages",
+    response = rest_client.post(
+        endpoints.coverages(WORKSPACE, store_name),
         data=coverage_xml,
-        headers={"Content-Type": "application/xml"}
+        headers={"Content-Type": "application/xml"},
     )
     assert response.status_code == 201
 
     # Verify the coverage was created - try listing coverages first
-    list_response = geoserver.get_request(f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages.json")
-    if list_response.status_code != 200:
-        print(f"Coverage listing failed: {list_response.status_code} - {list_response.text}")
-    assert list_response.status_code == 200
+    list_response = rest_client.get(endpoints.coverages(WORKSPACE, store_name))
+    assert (
+        list_response.status_code == 200
+    ), f"Failed to get coverages: {list_response.status_code} - {list_response.text}"
 
     # Check specific coverage
-    response = geoserver.get_request(f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages/{coverage_name}.json")
+    response = rest_client.get(endpoints.coverage(WORKSPACE, store_name, coverage_name))
     assert response.status_code == 200
 
     # Verify coverage properties
@@ -68,11 +74,8 @@ def test_create_cog_coverage():
     assert coverage_data["enabled"] == True
 
     # Test WMS GetMap request
-    wms_response = geoserver.get_request(
-        f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={workspace}:{coverage_name}&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/jpeg&SRS=EPSG:4326"
+    wms_response = rest_client.get(
+        f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={WORKSPACE}:{coverage_name}&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/jpeg&SRS=EPSG:4326"
     )
     assert wms_response.status_code == 200
     assert wms_response.headers.get("content-type").startswith("image/jpeg")
-
-    # Cleanup
-    geoserver.delete_workspace(workspace)
diff --git a/acceptance_tests/tests/test_datastore.py b/acceptance_tests/tests/test_datastore.py
index b44d8212..70336b27 100644
--- a/acceptance_tests/tests/test_datastore.py
+++ b/acceptance_tests/tests/test_datastore.py
@@ -1,12 +1,31 @@
-from conftest import PGHOST, PGPORT, PGDATABASE, PGUSER, PGPASSWORD, PGSCHEMA
+from geoservercloud import GeoServerCloud
+import pytest
+from conftest import (
+    GEOSERVER_URL,
+    PGHOST,
+    PGPORT,
+    PGDATABASE,
+    PGUSER,
+    PGPASSWORD,
+    PGSCHEMA,
+)
+
+WORKSPACE = "test_pg_datastore"
+
+
+@pytest.fixture(scope="function")
+def geoserver():
+    geoserver = GeoServerCloud(url=GEOSERVER_URL)
+    geoserver.create_workspace(WORKSPACE, set_default_workspace=True)
+    yield geoserver
+    geoserver.delete_workspace(WORKSPACE)
 
 
 def test_create_get_and_delete_datastore(geoserver):
-    workspace = datastore = "test_create_pg_datastore"
-    geoserver.create_workspace(workspace)
-    response = geoserver.create_pg_datastore(
-        workspace=workspace,
-        datastore=datastore,
+    datastore = "test_pg_datastore"
+    content, code = geoserver.create_pg_datastore(
+        workspace_name=WORKSPACE,
+        datastore_name=datastore,
         pg_host=PGHOST,
         pg_port=PGPORT,
         pg_db=PGDATABASE,
@@ -15,10 +34,8 @@ def test_create_get_and_delete_datastore(geoserver):
         pg_schema=PGSCHEMA,
         set_default_datastore=True,
     )
-    assert response.status_code == 201
-    response = geoserver.get_request(
-        f"/rest/workspaces/{workspace}/datastores/{datastore}.json"
-    )
-    assert response.status_code == 200
-    response = geoserver.delete_workspace(workspace)
-    assert response.status_code == 200
+    assert content == datastore
+    assert code == 201
+    content, code = geoserver.get_pg_datastore(WORKSPACE, datastore)
+    assert content.get("name") == datastore
+    assert code == 200
diff --git a/acceptance_tests/tests/test_gwc.py b/acceptance_tests/tests/test_gwc.py
index cfda180d..133c169b 100644
--- a/acceptance_tests/tests/test_gwc.py
+++ b/acceptance_tests/tests/test_gwc.py
@@ -14,12 +14,9 @@ def geoserver_with_gwc_layers(geoserver):
         capabilities="https://wmts.geo.admin.ch/EPSG/4326/1.0.0/WMTSCapabilities.xml",
     )
     geoserver.create_wmts_layer(WORKSPACE, WMTS_STORE, WMTS_LAYER)
-    geoserver.get_request(
-        f"/rest/workspaces/{WORKSPACE}/wmtsstores/{WMTS_STORE}/layers/{WMTS_LAYER}.json"
-    )
     geoserver.publish_gwc_layer(WORKSPACE, WMTS_LAYER)
     yield geoserver
-    geoserver.delete_request(f"/gwc/rest/layers/{WORKSPACE}:{WMTS_LAYER}")
+    geoserver.delete_gwc_layer(WORKSPACE, WMTS_LAYER)
     geoserver.delete_workspace(WORKSPACE)
 
 
diff --git a/acceptance_tests/tests/test_i18n.py b/acceptance_tests/tests/test_i18n.py
index 81640659..1007dc2b 100755
--- a/acceptance_tests/tests/test_i18n.py
+++ b/acceptance_tests/tests/test_i18n.py
@@ -28,7 +28,7 @@ def assert_legend(geoserver, style, language, expected_label):
         format="application/json",
         language=language,
         style=style,
-        workspace=WORKSPACE,
+        workspace_name=WORKSPACE,
     )
     try:
         label = response.json()["Legend"][0]["rules"][0]["title"]
@@ -71,14 +71,14 @@ def geoserver_i18n_legend_layer(geoserver):
     geoserver.create_workspace(WORKSPACE, set_default_workspace=True)
     geoserver.create_feature_type("i18n_legend", epsg=2056)
     geoserver.create_style_from_file(
-        "localized_with_default.sld",
+        "localized_with_default",
         f"{RESOURCE_DIR}/localized_with_default.sld",
-        workspace=WORKSPACE,
+        workspace_name=WORKSPACE,
     )
     geoserver.create_style_from_file(
-        "localized_no_default.sld",
+        "localized_no_default",
         f"{RESOURCE_DIR}/localized_no_default.sld",
-        workspace=WORKSPACE,
+        workspace_name=WORKSPACE,
     )
     yield geoserver
 
@@ -102,7 +102,7 @@ def geoserver_i18n_label_layer(geoserver, db_session):
         "label_fr": {"type": "string", "required": False},
     }
     geoserver.create_feature_type(feature_type, attributes=attributes, epsg=2056)
-    geoserver.create_style_from_file(style, file, workspace=WORKSPACE)
+    geoserver.create_style_from_file(style, file, workspace_name=WORKSPACE)
     # Feature with labels in German, French and a default value
     db_session.execute(
         text(
diff --git a/acceptance_tests/tests/test_imagemosaic.py b/acceptance_tests/tests/test_imagemosaic.py
index 9a65b469..e6dba830 100644
--- a/acceptance_tests/tests/test_imagemosaic.py
+++ b/acceptance_tests/tests/test_imagemosaic.py
@@ -27,22 +27,25 @@ def test_create_imagemosaic_local_files():
 
     # Delete and recreate workspace
     geoserver.delete_workspace(workspace)
-    response = geoserver.create_workspace(workspace)
-    assert response.status_code == 201
+    _, status = geoserver.create_workspace(workspace)
+    assert status == 201
 
     # Use direct directory approach (like web UI) instead of individual file URLs
     directory_path = "/opt/geoserver_data/sampledata/ne/pyramid/"
 
     # Create ImageMosaic store directly from directory
-    response = geoserver.put_request(
+    response = geoserver.rest_service.rest_client.put(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/external.imagemosaic",
         data=directory_path,
-        headers={"Content-Type": "text/plain"}
+        headers={"Content-Type": "text/plain"},
     )
-    assert response.status_code in [201, 202], f"Failed to create ImageMosaic from directory: {response.text}"
+    assert response.status_code in [
+        201,
+        202,
+    ], f"Failed to create ImageMosaic from directory: {response.text}"
 
     # List available coverages (should be auto-discovered)
-    response = geoserver.get_request(
+    response = geoserver.rest_service.rest_client.get(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages.xml?list=all"
     )
     assert response.status_code == 200, f"Failed to list coverages: {response.text}"
@@ -56,7 +59,7 @@ def test_create_imagemosaic_local_files():
     coverage_name = coverage_match.group(1)
 
     # Check if coverage was auto-created (likely scenario)
-    coverage_response = geoserver.get_request(
+    coverage_response = geoserver.rest_service.rest_client.get(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages/{coverage_name}.json"
     )
 
@@ -75,7 +78,7 @@ def test_create_imagemosaic_local_files():
     <enabled>true</enabled>
 </coverage>"""
 
-        response = geoserver.post_request(
+        response = geoserver.rest_service.rest_client.post(
             f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages",
             data=coverage_xml,
             headers={"Content-Type": "text/xml"}
@@ -83,7 +86,7 @@ def test_create_imagemosaic_local_files():
         assert response.status_code == 201, f"Failed to create coverage: {response.text}"
 
         # Verify the coverage was created
-        response = geoserver.get_request(f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages/{coverage_name}.json")
+        response = geoserver.rest_service.rest_client.get(f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages/{coverage_name}.json")
         assert response.status_code == 200
 
         coverage_data = response.json()["coverage"]
@@ -92,7 +95,7 @@ def test_create_imagemosaic_local_files():
         assert coverage_data["enabled"] == True
 
     # Test WMS GetMap request (verify local file mosaic works)
-    wms_response = geoserver.get_request(
+    wms_response = geoserver.rest_service.rest_client.get(
         f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={workspace}:{coverage_name}&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/png&SRS=EPSG:4326"
     )
     assert wms_response.status_code == 200, f"WMS GetMap failed: {wms_response.text}"
@@ -111,8 +114,8 @@ def test_create_imagemosaic_manual_granules():
 
     # Delete and recreate workspace
     geoserver.delete_workspace(workspace)
-    response = geoserver.create_workspace(workspace)
-    assert response.status_code == 201
+    _, status = geoserver.create_workspace(workspace)
+    assert status == 201
 
     # Create temporary directory for mosaic configuration
     with tempfile.TemporaryDirectory() as tmp_dir:
@@ -157,7 +160,7 @@ preparedStatements=false
         with open(zip_file, 'rb') as f:
             zip_data = f.read()
 
-        response = geoserver.put_request(
+        response = geoserver.rest_service.rest_client.put(
             f"/rest/workspaces/{workspace}/coveragestores/{store_name}/file.imagemosaic?configure=none",
             data=zip_data,
             headers={"Content-Type": "application/zip"}
@@ -174,7 +177,7 @@ preparedStatements=false
 
     for granule_path in granule_paths:
         # Use direct file paths (without file:// protocol) for external.imagemosaic
-        response = geoserver.post_request(
+        response = geoserver.rest_service.rest_client.post(
             f"/rest/workspaces/{workspace}/coveragestores/{store_name}/external.imagemosaic",
             data=granule_path,
             headers={"Content-Type": "text/plain"}
@@ -182,7 +185,7 @@ preparedStatements=false
         assert response.status_code in [201, 202], f"Failed to add granule {granule_path}: {response.text}"
 
     # Initialize the store (list available coverages)
-    response = geoserver.get_request(
+    response = geoserver.rest_service.rest_client.get(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages.xml?list=all"
     )
     assert response.status_code == 200, f"Failed to list coverages: {response.text}"
@@ -200,7 +203,7 @@ preparedStatements=false
     <enabled>true</enabled>
 </coverage>"""
 
-    response = geoserver.post_request(
+    response = geoserver.rest_service.rest_client.post(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages",
         data=coverage_xml,
         headers={"Content-Type": "text/xml"}
@@ -208,7 +211,7 @@ preparedStatements=false
     assert response.status_code == 201, f"Failed to create coverage: {response.text}"
 
     # Verify the coverage was created successfully
-    response = geoserver.get_request(
+    response = geoserver.rest_service.rest_client.get(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages/{coverage_name}.json"
     )
     assert response.status_code == 200, f"Failed to get coverage details: {response.text}"
@@ -219,7 +222,7 @@ preparedStatements=false
     assert coverage_data["enabled"] == True
 
     # Test WMS GetMap request (verify manual granule addition works)
-    wms_response = geoserver.get_request(
+    wms_response = geoserver.rest_service.rest_client.get(
         f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={workspace}:{coverage_name}&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/png&SRS=EPSG:4326"
     )
     assert wms_response.status_code == 200, f"WMS GetMap failed: {wms_response.text}"
@@ -243,8 +246,8 @@ def test_create_imagemosaic_empty_store_with_directory_harvest():
     geoserver.delete_workspace(workspace)
 
     # Step 1: Create workspace
-    response = geoserver.create_workspace(workspace)
-    assert response.status_code == 201, f"Failed to create workspace: {response.text}"
+    content, status = geoserver.create_workspace(workspace)
+    assert status == 201, f"Failed to create workspace: {content}"
 
     # Step 2: Create ImageMosaic store with configuration
     with tempfile.TemporaryDirectory() as tmp_dir:
@@ -289,7 +292,7 @@ preparedStatements=false
         with open(zip_file, 'rb') as f:
             zip_data = f.read()
 
-        response = geoserver.put_request(
+        response = geoserver.rest_service.rest_client.put(
             f"/rest/workspaces/{workspace}/coveragestores/{store_name}/file.imagemosaic?configure=none",
             data=zip_data,
             headers={"Content-Type": "application/zip"}
@@ -299,7 +302,7 @@ preparedStatements=false
     # Step 3: Harvest granules from directory
     harvest_path = "/opt/geoserver_data/sampledata/ne/pyramid/"
 
-    response = geoserver.post_request(
+    response = geoserver.rest_service.rest_client.post(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/external.imagemosaic",
         data=harvest_path,
         headers={"Content-Type": "text/plain"}
@@ -307,7 +310,7 @@ preparedStatements=false
     assert response.status_code in [201, 202], f"Failed to harvest directory {harvest_path}: {response.text}"
 
     # Step 4: List available coverages
-    response = geoserver.get_request(
+    response = geoserver.rest_service.rest_client.get(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages.xml?list=all"
     )
     assert response.status_code == 200, f"Failed to list coverages: {response.text}"
@@ -325,7 +328,7 @@ preparedStatements=false
     <enabled>true</enabled>
 </coverage>"""
 
-    response = geoserver.post_request(
+    response = geoserver.rest_service.rest_client.post(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages",
         data=coverage_xml,
         headers={"Content-Type": "text/xml"}
@@ -333,7 +336,7 @@ preparedStatements=false
     assert response.status_code == 201, f"Layer creation failed: {response.text}"
 
     # Step 6: Verify the coverage was created successfully
-    response = geoserver.get_request(
+    response = geoserver.rest_service.rest_client.get(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages/{coverage_name}.json"
     )
     assert response.status_code == 200, f"Failed to get coverage details: {response.text}"
@@ -344,7 +347,7 @@ preparedStatements=false
     assert coverage_data["enabled"] == True
 
     # Step 7: Test WMS GetMap request
-    wms_response = geoserver.get_request(
+    wms_response = geoserver.rest_service.rest_client.get(
         f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={workspace}:{coverage_name}"
         f"&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/png&SRS=EPSG:4326"
     )
@@ -369,8 +372,8 @@ def test_create_imagemosaic_empty_store_with_single_file_harvest():
     geoserver.delete_workspace(workspace)
 
     # Step 1: Create workspace
-    response = geoserver.create_workspace(workspace)
-    assert response.status_code == 201, f"Failed to create workspace: {response.text}"
+    content, status = geoserver.create_workspace(workspace)
+    assert status == 201, f"Failed to create workspace: {content}"
 
     # Step 2: Create ImageMosaic store
     with tempfile.TemporaryDirectory() as tmp_dir:
@@ -415,7 +418,7 @@ preparedStatements=false
         with open(zip_file, 'rb') as f:
             zip_data = f.read()
 
-        response = geoserver.put_request(
+        response = geoserver.rest_service.rest_client.put(
             f"/rest/workspaces/{workspace}/coveragestores/{store_name}/file.imagemosaic?configure=none",
             data=zip_data,
             headers={"Content-Type": "application/zip"}
@@ -425,7 +428,7 @@ preparedStatements=false
     # Step 3: Harvest single file
     single_file_path = "/opt/geoserver_data/sampledata/ne/NE1_LR_LC_SR_W_DR.tif"
 
-    response = geoserver.post_request(
+    response = geoserver.rest_service.rest_client.post(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/external.imagemosaic",
         data=single_file_path,
         headers={"Content-Type": "text/plain"}
@@ -433,7 +436,7 @@ preparedStatements=false
     assert response.status_code in [201, 202], f"Failed to harvest file {single_file_path}: {response.text}"
 
     # Step 4: List and create layer
-    response = geoserver.get_request(
+    response = geoserver.rest_service.rest_client.get(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages.xml?list=all"
     )
     assert response.status_code == 200, f"Failed to list coverages: {response.text}"
@@ -446,7 +449,7 @@ preparedStatements=false
     <enabled>true</enabled>
 </coverage>"""
 
-    response = geoserver.post_request(
+    response = geoserver.rest_service.rest_client.post(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages",
         data=coverage_xml,
         headers={"Content-Type": "text/xml"}
@@ -454,7 +457,7 @@ preparedStatements=false
     assert response.status_code == 201, f"Layer creation failed: {response.text}"
 
     # Verify WMS works
-    wms_response = geoserver.get_request(
+    wms_response = geoserver.rest_service.rest_client.get(
         f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={workspace}:{coverage_name}"
         f"&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/png&SRS=EPSG:4326"
     )
@@ -478,8 +481,8 @@ def test_create_imagemosaic_via_xml_store_creation():
     geoserver.delete_workspace(workspace)
 
     # Step 1: Create workspace
-    response = geoserver.create_workspace(workspace)
-    assert response.status_code == 201, f"Failed to create workspace: {response.text}"
+    content, code = geoserver.create_workspace(workspace)
+    assert code == 201, f"Failed to create workspace: {content}"
 
     # Step 2: Create ImageMosaic store via XML store creation
     store_xml = f"""<coverageStore>
@@ -492,7 +495,7 @@ def test_create_imagemosaic_via_xml_store_creation():
     <url>/opt/geoserver_data/sampledata/ne/pyramid/</url>
 </coverageStore>"""
 
-    response = geoserver.post_request(
+    response = geoserver.rest_service.rest_client.post(
         f"/rest/workspaces/{workspace}/coveragestores",
         data=store_xml,
         headers={"Content-Type": "text/xml"}
@@ -500,7 +503,7 @@ def test_create_imagemosaic_via_xml_store_creation():
     assert response.status_code == 201, f"Store creation via XML failed: {response.text}"
 
     # Step 3: List available coverages
-    response = geoserver.get_request(
+    response = geoserver.rest_service.rest_client.get(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages.xml?list=all"
     )
     assert response.status_code == 200, f"Failed to list coverages: {response.text}"
@@ -520,7 +523,7 @@ def test_create_imagemosaic_via_xml_store_creation():
     <enabled>true</enabled>
 </coverage>"""
 
-    response = geoserver.post_request(
+    response = geoserver.rest_service.rest_client.post(
         f"/rest/workspaces/{workspace}/coveragestores/{store_name}/coverages",
         data=coverage_xml,
         headers={"Content-Type": "text/xml"}
@@ -528,7 +531,7 @@ def test_create_imagemosaic_via_xml_store_creation():
     assert response.status_code == 201, f"Layer creation failed: {response.text}"
 
     # Verify WMS works
-    wms_response = geoserver.get_request(
+    wms_response = geoserver.rest_service.rest_client.get(
         f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={workspace}:{coverage_name}"
         f"&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/png&SRS=EPSG:4326"
     )
diff --git a/acceptance_tests/tests/test_imagemosaic_cog.py b/acceptance_tests/tests/test_imagemosaic_cog.py
index 184b593a..16e9f88f 100644
--- a/acceptance_tests/tests/test_imagemosaic_cog.py
+++ b/acceptance_tests/tests/test_imagemosaic_cog.py
@@ -11,8 +11,8 @@ def _create_imagemosaic(geoserver, workspace, coverage, granules, indexer_conten
     """Helper function to create an ImageMosaic with COG granules"""
     # Delete and recreate workspace
     geoserver.delete_workspace(workspace)
-    response = geoserver.create_workspace(workspace)
-    assert response.status_code == 201
+    _, status = geoserver.create_workspace(workspace)
+    assert status == 201
 
     # Create temporary directory for mosaic files
     with tempfile.TemporaryDirectory() as tmp_dir:
@@ -58,7 +58,7 @@ preparedStatements=false
         with open(zip_file, 'rb') as f:
             zip_data = f.read()
 
-        response = geoserver.put_request(
+        response = geoserver.rest_service.rest_client.put(
             f"/rest/workspaces/{workspace}/coveragestores/{coverage}/file.imagemosaic?configure=none",
             data=zip_data,
             headers={"Content-Type": "application/zip"}
@@ -67,7 +67,7 @@ preparedStatements=false
 
         # Add granules
         for uri in granules:
-            response = geoserver.post_request(
+            response = geoserver.rest_service.rest_client.post(
                 f"/rest/workspaces/{workspace}/coveragestores/{coverage}/remote.imagemosaic",
                 data=uri,
                 headers={"Content-Type": "text/plain"}
@@ -76,7 +76,7 @@ preparedStatements=false
             assert response.status_code in [201, 202]
 
         # Initialize the store (list available coverages)
-        response = geoserver.get_request(
+        response = geoserver.rest_service.rest_client.get(
             f"/rest/workspaces/{workspace}/coveragestores/{coverage}/coverages.xml?list=all"
         )
         assert response.status_code == 200
@@ -93,7 +93,7 @@ preparedStatements=false
     <enabled>true</enabled>
 </coverage>"""
 
-        response = geoserver.post_request(
+        response = geoserver.rest_service.rest_client.post(
             f"/rest/workspaces/{workspace}/coveragestores/{coverage}/coverages",
             data=coverage_xml,
             headers={"Content-Type": "text/xml"}
@@ -101,7 +101,7 @@ preparedStatements=false
         assert response.status_code == 201
 
         # Verify the coverage was created
-        response = geoserver.get_request(f"/rest/workspaces/{workspace}/coveragestores/{coverage}/coverages/{coverage}.json")
+        response = geoserver.rest_service.rest_client.get(f"/rest/workspaces/{workspace}/coveragestores/{coverage}/coverages/{coverage}.json")
         assert response.status_code == 200
 
         # Verify coverage properties
@@ -112,7 +112,7 @@ preparedStatements=false
         assert coverage_data["title"] == title
 
         # Test WMS GetMap request
-        wms_response = geoserver.get_request(
+        wms_response = geoserver.rest_service.rest_client.get(
             f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={workspace}:{coverage}&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/png&SRS=EPSG:4326"
         )
         assert wms_response.status_code == 200
@@ -172,7 +172,7 @@ Name={coverage}"""
     coverage_data = _create_imagemosaic(geoserver, workspace, coverage, modis_granules, indexer_content, "MODIS Vegetation Index")
 
     # Additional test for time-based query (since MODIS has time dimension)
-    time_wms_response = geoserver.get_request(
+    time_wms_response = geoserver.rest_service.rest_client.get(
         f"/wms?SERVICE=WMS&VERSION=1.1.0&REQUEST=GetMap&LAYERS={workspace}:{coverage}&STYLES=&BBOX=-180,-90,180,90&WIDTH=256&HEIGHT=256&FORMAT=image/png&SRS=EPSG:4326&TIME=2018-01-01"
     )
     assert time_wms_response.status_code == 200
diff --git a/acceptance_tests/tests/test_wfs.py b/acceptance_tests/tests/test_wfs.py
index fddc26e9..2daeb06b 100644
--- a/acceptance_tests/tests/test_wfs.py
+++ b/acceptance_tests/tests/test_wfs.py
@@ -29,11 +29,11 @@ def test_wfs(geoserver):
             "required": False,
         },
     }
-    response = geoserver.create_workspace(workspace, set_default_workspace=True)
-    assert response.status_code == 201
-    response = geoserver.create_pg_datastore(
-        workspace=workspace,
-        datastore=datastore,
+    _, code = geoserver.create_workspace(workspace, set_default_workspace=True)
+    assert code == 201
+    _, code = geoserver.create_pg_datastore(
+        workspace_name=workspace,
+        datastore_name=datastore,
         pg_host=PGHOST,
         pg_port=PGPORT,
         pg_db=PGDATABASE,
@@ -42,16 +42,19 @@ def test_wfs(geoserver):
         pg_schema=PGSCHEMA,
         set_default_datastore=True,
     )
-    assert response.status_code == 201
-    response = geoserver.create_feature_type(
+    assert code == 201
+    content, code = geoserver.create_feature_type(
         feature_type, attributes=attributes, epsg=2056
     )
-    assert response.status_code == 201
+    assert content == ""
+    assert code == 201
 
     # Post a feature through a WFS request
     with open(f"{RESOURCE_DIR}/wfs_payload.xml") as file:
         data = file.read()
-        response = geoserver.post_request(f"/{workspace}/wfs/", data=data)
+        response = geoserver.rest_service.rest_client.post(
+            f"/{workspace}/wfs/", data=data
+        )
         assert response.status_code == 200
 
     # GetFeature request
@@ -72,5 +75,5 @@ def test_wfs(geoserver):
         "properties": {"name": "urn:ogc:def:crs:EPSG::2056"},
     }
 
-    response = geoserver.delete_workspace(workspace)
-    assert response.status_code == 200
+    _, code = geoserver.delete_workspace(workspace)
+    assert code == 200
diff --git a/acceptance_tests/tests/test_wms.py b/acceptance_tests/tests/test_wms.py
index 73af7b43..5258f28e 100644
--- a/acceptance_tests/tests/test_wms.py
+++ b/acceptance_tests/tests/test_wms.py
@@ -17,8 +17,8 @@ def test_create_and_feature_type_and_get_map(db_session, geoserver):
     workspace = datastore = feature_type = "test_create_feature_type"
     geoserver.create_workspace(workspace, set_default_workspace=True)
     geoserver.create_pg_datastore(
-        workspace=workspace,
-        datastore=datastore,
+        workspace_name=workspace,
+        datastore_name=datastore,
         pg_host=PGHOST,
         pg_port=PGPORT,
         pg_db=PGDATABASE,
@@ -27,11 +27,11 @@ def test_create_and_feature_type_and_get_map(db_session, geoserver):
         pg_schema=PGSCHEMA,
         set_default_datastore=True,
     )
-    response = geoserver.create_feature_type(
+    _, status = geoserver.create_feature_type(
         feature_type,
         epsg=2056,
     )
-    assert response.status_code == 201
+    assert status == 201
 
     # Create feature
     db_session.execute(
@@ -69,11 +69,11 @@ def test_get_feature_info(db_session, geoserver):
             "required": False,
         },
     }
-    response = geoserver.create_workspace(workspace, set_default_workspace=True)
-    assert response.status_code == 201
-    response = geoserver.create_pg_datastore(
-        workspace=workspace,
-        datastore=datastore,
+    _, status = geoserver.create_workspace(workspace, set_default_workspace=True)
+    assert status == 201
+    _, status = geoserver.create_pg_datastore(
+        workspace_name=workspace,
+        datastore_name=datastore,
         pg_host=PGHOST,
         pg_port=PGPORT,
         pg_db=PGDATABASE,
@@ -82,11 +82,11 @@ def test_get_feature_info(db_session, geoserver):
         pg_schema=PGSCHEMA,
         set_default_datastore=True,
     )
-    assert response.status_code == 201
-    response = geoserver.create_feature_type(
+    assert status == 201
+    _, status = geoserver.create_feature_type(
         feature_type, attributes=attributes, epsg=2056
     )
-    assert response.status_code == 201
+    assert status == 201
 
     # Create feature
     db_session.execute(
@@ -98,8 +98,8 @@ def test_get_feature_info(db_session, geoserver):
     db_session.commit()
 
     # Test that layer is published
-    response = geoserver.get_request(f"/rest/layers/{workspace}:{feature_type}.json")
-    assert response.status_code == 200
+    _, status = geoserver.get_feature_type(workspace, datastore, feature_type)
+    assert status == 200
 
     # GetFeatureInfo request
     response = geoserver.get_feature_info(
@@ -124,5 +124,5 @@ def test_get_feature_info(db_session, geoserver):
         "properties": {"name": "urn:ogc:def:crs:EPSG::2056"},
     }
 
-    response = geoserver.delete_workspace(workspace)
-    assert response.status_code == 200
+    _, status = geoserver.delete_workspace(workspace)
+    assert status == 200
diff --git a/acceptance_tests/tests/test_workspace.py b/acceptance_tests/tests/test_workspace.py
index 23a8bc9b..f84b5d2f 100644
--- a/acceptance_tests/tests/test_workspace.py
+++ b/acceptance_tests/tests/test_workspace.py
@@ -1,23 +1,26 @@
 def test_create_get_and_delete_workspace(geoserver):
     workspace = "test_create_workspace"
-    response = geoserver.create_workspace(workspace)
-    assert response.status_code == 201
-    response = geoserver.get_request(f"/rest/workspaces/{workspace}.json")
-    assert response.status_code == 200
-    response = geoserver.publish_workspace(workspace)
-    assert response.status_code == 200
-    response = geoserver.delete_workspace(workspace)
-    assert response.status_code == 200
+    content, status = geoserver.create_workspace(workspace)
+    assert content == workspace
+    assert status == 201
+    content, status = geoserver.get_workspace(workspace)
+    assert content == {"name": workspace, "isolated": False}
+    assert status == 200
+    content, status = geoserver.publish_workspace(workspace)
+    assert status == 200
+    content, status = geoserver.delete_workspace(workspace)
+    assert status == 200
 
 
 def test_update_workspace(geoserver):
     workspace = "update_workspace"
-    response = geoserver.create_workspace(workspace, isolated=True)
-    assert response.status_code == 201
-    response = geoserver.get_request(f"/rest/workspaces/{workspace}.json")
-    assert response.json().get("workspace").get("isolated") == True
-    response = geoserver.create_workspace(workspace, isolated=False)
-    assert response.status_code == 200
-    response = geoserver.get_request(f"/rest/workspaces/{workspace}.json")
-    assert response.json().get("workspace").get("isolated") == False
+    content, status = geoserver.create_workspace(workspace, isolated=True)
+    content, status = geoserver.get_workspace(workspace)
+    assert content == {"name": workspace, "isolated": True}
+    assert status == 200
+    content, status = geoserver.create_workspace(workspace, isolated=False)
+    assert content == ""
+    assert status == 200
+    content, status = geoserver.get_workspace(workspace)
+    assert content == {"name": workspace, "isolated": False}
     geoserver.delete_workspace(workspace)