Repository: gophercloud/gophercloud

Issue:
Cinder "manage existing volume" feature
I want to use the "manage existing volume" feature of Cinder, but there seems to be no implementation.
Are there any plans to implement it?

ref. https://docs.openstack.org/api-ref/block-storage/v3/#volume-manage-extension-manageable-volumes

Discussion:
@github-actions: Thank you for reporting your first issue! Be sure that we will be looking at it, but keep in mind
this sometimes takes a while.
Please let the maintainers know if your issue has not got enough attention after a few days.
If any doubt, please consult our issue [tutorial](https://github.com/gophercloud/gophercloud/blob/main/docs/contributor-tutorial/step-02-issues.md).@TOMOFUMI-KONDO: I worked on it!
- https://github.com/gophercloud/gophercloud/pull/3332

Solution patch:
diff --git a/.github/workflows/functional-baremetal.yaml b/.github/workflows/functional-baremetal.yaml
index 008f7a3d3..14d6636fb 100644
--- a/.github/workflows/functional-baremetal.yaml
+++ b/.github/workflows/functional-baremetal.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**baremetal**'
+      - '.github/workflows/functional-baremetal.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,44 +14,29 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
-            use_system_scope: true
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
             openstack_version: "stable/2024.2"
             ubuntu_version: "22.04"
-            # NOTE(dtantsur): this forces running tests with a system scope
-            # token, which is required for certain actions. Use it on versions
-            # starting with 2024.1.
-            use_system_scope: true
             additional_services: "openstack-cli-server"
           - name: "caracal"
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
-            use_system_scope: true
-            additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            use_system_scope: false
             additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Ironic and run baremetal acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
-      - name: Workaround for grub-efi-amd64-signed
-        run: sudo rm /var/cache/debconf/config.dat
-        shell: bash
-        if: matrix.ubuntu_version == '20.04'
-      - name: Ensure update and upgrade
-        run: sudo apt update && sudo apt -y upgrade
-        shell: bash
-        if: matrix.ubuntu_version == '20.04'
       - name: Work around broken dnsmasq
         run: sudo apt-get purge -y dnsmasq-base
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -93,13 +79,13 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-baremetal
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/baremetal/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
-          # TODO(dtantsur): default to true when no longer supporting versions before 2024.1
-          USE_SYSTEM_SCOPE: ${{ matrix.use_system_scope }}
+          USE_SYSTEM_SCOPE: true
       - name: Generate logs on failure
         run: ./script/collectlogs
         if: failure()
diff --git a/.github/workflows/functional-basic.yaml b/.github/workflows/functional-basic.yaml
index 0fc650a1f..64eeec76d 100644
--- a/.github/workflows/functional-basic.yaml
+++ b/.github/workflows/functional-basic.yaml
@@ -16,6 +16,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -26,17 +30,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with defaults and run basic acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           enabled_services: 's-account,s-container,s-object,s-proxy,${{ matrix.additional_services }}'
@@ -45,10 +45,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-basic
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: './internal/acceptance/openstack'
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-blockstorage.yaml b/.github/workflows/functional-blockstorage.yaml
index 26e81321e..2d941c02a 100644
--- a/.github/workflows/functional-blockstorage.yaml
+++ b/.github/workflows/functional-blockstorage.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**blockstorage**'
+      - '.github/workflows/functional-blockstorage.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +28,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Cinder and run blockstorage acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -44,10 +45,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-blockstorage
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/blockstorage/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-compute.yaml b/.github/workflows/functional-compute.yaml
index a01dbdfc9..6068ed557 100644
--- a/.github/workflows/functional-compute.yaml
+++ b/.github/workflows/functional-compute.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**compute**'
+      - '.github/workflows/functional-compute.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +28,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Nova and run compute acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -44,10 +45,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-compute
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/compute/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-containerinfra.yaml b/.github/workflows/functional-containerinfra.yaml
index 634685f60..97cf2a588 100644
--- a/.github/workflows/functional-containerinfra.yaml
+++ b/.github/workflows/functional-containerinfra.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**containerinfra**'
+      - '.github/workflows/functional-containerinfra.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,11 +14,30 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
-            ubuntu_version: "22.04"
+            ubuntu_version: "24.04"
             devstack_conf_overrides: |
+              # ensure we're using a working version of setuptools
+              if [ -n "\$TOP_DIR" ]; then
+                sed -i 's/setuptools\[core\]$/setuptools[core]==79.0.1/g' \$TOP_DIR/lib/infra \$TOP_DIR/inc/python
+                sed -i 's/pip_install "-U" "pbr"/pip_install "-U" "pbr" "setuptools[core]==79.0.1"/g' \$TOP_DIR/lib/infra
+              fi
+
               enable_plugin magnum https://github.com/openstack/magnum master
               MAGNUMCLIENT_BRANCH=master
             additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
+            ubuntu_version: "22.04"
+            devstack_conf_overrides: |
+              # ensure we're using a working version of setuptools
+              if [ -n "\$TOP_DIR" ]; then
+                sed -i 's/setuptools\[core\]$/setuptools[core]==79.0.1/g' \$TOP_DIR/lib/infra \$TOP_DIR/inc/python
+                sed -i 's/pip_install "-U" "pbr"/pip_install "-U" "pbr" "setuptools[core]==79.0.1"/g' \$TOP_DIR/lib/infra
+              fi
+
+              enable_plugin magnum https://github.com/openstack/magnum stable/2025.1
+              MAGNUMCLIENT_BRANCH=stable/2025.1
+            additional_services: "openstack-cli-server"
           - name: "dalmatian"
             openstack_version: "stable/2024.2"
             ubuntu_version: "22.04"
@@ -32,20 +52,13 @@ jobs:
               enable_plugin magnum https://github.com/openstack/magnum stable/2024.1
               MAGNUMCLIENT_BRANCH=stable/2024.1
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            devstack_conf_overrides: |
-              enable_plugin magnum https://github.com/openstack/magnum stable/2023.2
-              MAGNUMCLIENT_BRANCH=stable/2023.2
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Magnum and run containerinfra acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -54,6 +67,7 @@ jobs:
             GLANCE_LIMIT_IMAGE_SIZE_TOTAL=5000
             SWIFT_MAX_FILE_SIZE=5368709122
             KEYSTONE_ADMIN_ENDPOINT=true
+
             ${{ matrix.devstack_conf_overrides }}
           enabled_services: "h-eng,h-api,h-api-cfn,h-api-cw,${{ matrix.additional_services }}"
       - name: Checkout go
@@ -61,10 +75,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-containerinfra
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/containerinfra/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-dns.yaml b/.github/workflows/functional-dns.yaml
index f829002ba..643778a72 100644
--- a/.github/workflows/functional-dns.yaml
+++ b/.github/workflows/functional-dns.yaml
@@ -2,8 +2,8 @@ name: functional-dns
 on:
   pull_request:
     paths:
-      - '**openstack/dns**'
-      - '**functional-dns.yaml'
+      - '**dns**'
+      - '.github/workflows/functional-dns.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -14,6 +14,16 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            devstack_conf_overrides: |
+              # ensure we're using a working version of setuptools
+              if [ -n "\$TOP_DIR" ]; then
+                sed -i 's/setuptools\[core\]$/setuptools[core]==79.0.1/g' \$TOP_DIR/lib/infra \$TOP_DIR/inc/python
+                sed -i 's/pip_install "-U" "pbr"/pip_install "-U" "pbr" "setuptools[core]==79.0.1"/g' \$TOP_DIR/lib/infra
+              fi
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -24,31 +34,30 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Designate and run dns acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
             enable_plugin designate https://github.com/openstack/designate ${{ matrix.openstack_version }}
+
+            ${{ matrix.devstack_conf_overrides }}
           enabled_services: "designate,designate-central,designate-api,designate-worker,designate-producer,designate-mdns,${{ matrix.additional_services }}"
       - name: Checkout go
         uses: actions/setup-go@v5
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-dns
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/dns/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-fwaas_v2.yaml b/.github/workflows/functional-fwaas_v2.yaml
index 297da6ff2..b6770476c 100644
--- a/.github/workflows/functional-fwaas_v2.yaml
+++ b/.github/workflows/functional-fwaas_v2.yaml
@@ -1,8 +1,13 @@
+# TODO(stephenfin): neutron-fwaas may support OVN now. If so, we can combine
+# this job with the functional-networking job. See [1]
+#
+# [1] https://bugs.launchpad.net/neutron/+bug/1971958
 name: functional-fwaas_v2
 on:
   pull_request:
     paths:
       - '**networking/v2/extensions/fwaas_v2**'
+      - '.github/workflows/functional-fwaas_v2.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +18,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +32,21 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with enabled FWaaS_v2 and run networking acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
+      - name: Create additional neutron policies
+        run: |
+          mkdir /tmp/neutron-policies
+          cat << EOF >> /tmp/neutron-policies/port_binding.yaml
+          ---
+          "create_port:binding:profile": "rule:admin_only or rule:service_api"
+          "update_port:binding:profile": "rule:admin_only or rule:service_api"
+          EOF
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -43,16 +56,21 @@ jobs:
             Q_ML2_PLUGIN_TYPE_DRIVERS=flat,gre,vlan,vxlan
             Q_ML2_TENANT_NETWORK_TYPE=vxlan
             Q_TUNNEL_TYPES=vxlan,gre
+
+            [[post-config|\$NEUTRON_CONF]]
+            [oslo_policy]
+            policy_dirs = /tmp/neutron-policies
           enabled_services: 'q-svc,q-agt,q-dhcp,q-l3,q-meta,q-fwaas-v2,-cinder,-horizon,-tempest,-swift,-c-sch,-c-api,-c-vol,-c-bak,-ovn,-ovn-controller,-ovn-northd,-q-ovn-metadata-agent,${{ matrix.additional_services }}'
       - name: Checkout go
         uses: actions/setup-go@v5
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-networking
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/networking/v2/extensions/fwaas_v2/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-identity.yaml b/.github/workflows/functional-identity.yaml
index 6db4b9d11..e2de054dd 100644
--- a/.github/workflows/functional-identity.yaml
+++ b/.github/workflows/functional-identity.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**identity**'
+      - '.github/workflows/functional-identity.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +28,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Keystone and run identity acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           enabled_services: "${{ matrix.additional_services }}"
@@ -42,10 +43,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-identity
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/identity/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-image.yaml b/.github/workflows/functional-image.yaml
index 3b66c8598..39f009d73 100644
--- a/.github/workflows/functional-image.yaml
+++ b/.github/workflows/functional-image.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**image**'
+      - '.github/workflows/functional-image.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +28,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Glance and run image acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           enabled_services: "${{ matrix.additional_services }}"
@@ -42,10 +43,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-image
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/image/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-keymanager.yaml b/.github/workflows/functional-keymanager.yaml
index 08ee8546e..e39d3803d 100644
--- a/.github/workflows/functional-keymanager.yaml
+++ b/.github/workflows/functional-keymanager.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**keymanager**'
+      - '.github/workflows/functional-keymanager.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,7 +14,23 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            devstack_conf_overrides: |
+              # ensure we're using a working version of setuptools
+              if [ -n "\$TOP_DIR" ]; then
+                sed -i 's/setuptools\[core\]$/setuptools[core]==79.0.1/g' \$TOP_DIR/lib/infra \$TOP_DIR/inc/python
+                sed -i 's/pip_install "-U" "pbr"/pip_install "-U" "pbr" "setuptools[core]==79.0.1"/g' \$TOP_DIR/lib/infra
+              fi
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
+            devstack_conf_overrides: |
+              # ensure we're using a working version of setuptools
+              if [ -n "\$TOP_DIR" ]; then
+                sed -i 's/setuptools\[core\]$/setuptools[core]==79.0.1/g' \$TOP_DIR/lib/infra \$TOP_DIR/inc/python
+                sed -i 's/pip_install "-U" "pbr"/pip_install "-U" "pbr" "setuptools[core]==79.0.1"/g' \$TOP_DIR/lib/infra
+              fi
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
             openstack_version: "stable/2024.2"
@@ -23,31 +40,30 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Barbican and run keymanager acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
             enable_plugin barbican https://github.com/openstack/barbican ${{ matrix.openstack_version }}
+
+            ${{ matrix.devstack_conf_overrides }}
           enabled_services: "barbican-svc,barbican-retry,barbican-keystone-listener,${{ matrix.additional_services }}"
       - name: Checkout go
         uses: actions/setup-go@v5
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-keymanager
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/keymanager/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-loadbalancer.yaml b/.github/workflows/functional-loadbalancer.yaml
index ec7b076ee..4271bb383 100644
--- a/.github/workflows/functional-loadbalancer.yaml
+++ b/.github/workflows/functional-loadbalancer.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**loadbalancer**'
+      - '.github/workflows/functional-loadbalancer.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,16 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            devstack_conf_overrides: |
+              # ensure we're using a working version of setuptools
+              if [ -n "\$TOP_DIR" ]; then
+                sed -i 's/setuptools\[core\]$/setuptools[core]==79.0.1/g' \$TOP_DIR/lib/infra \$TOP_DIR/inc/python
+                sed -i 's/pip_install "-U" "pbr"/pip_install "-U" "pbr" "setuptools[core]==79.0.1"/g' \$TOP_DIR/lib/infra
+              fi
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,32 +34,31 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Octavia and run loadbalancer acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
             enable_plugin octavia https://github.com/openstack/octavia ${{ matrix.openstack_version }}
             enable_plugin neutron https://github.com/openstack/neutron ${{ matrix.openstack_version }}
+
+            ${{ matrix.devstack_conf_overrides }}
           enabled_services: "octavia,o-api,o-cw,o-hk,o-hm,o-da,neutron-qos,${{ matrix.additional_services }}"
       - name: Checkout go
         uses: actions/setup-go@v5
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-loadbalancer
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/loadbalancer/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-messaging.yaml b/.github/workflows/functional-messaging.yaml
index d3e3169f6..658abc8a9 100644
--- a/.github/workflows/functional-messaging.yaml
+++ b/.github/workflows/functional-messaging.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**messaging**'
+      - '.github/workflows/functional-messaging.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +28,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Zaqar and run messaging acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -45,10 +46,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-messaging
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/messaging/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-networking.yaml b/.github/workflows/functional-networking.yaml
index 8722b6789..a8814d571 100644
--- a/.github/workflows/functional-networking.yaml
+++ b/.github/workflows/functional-networking.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**networking**'
+      - '.github/workflows/functional-networking.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,10 +28,6 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Neutron and run networking acceptance tests
     steps:
@@ -41,7 +42,7 @@ jobs:
           "update_port:binding:profile": "rule:admin_only or rule:service_api"
           EOF
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -49,6 +50,7 @@ jobs:
             enable_plugin neutron-vpnaas https://github.com/openstack/neutron-vpnaas ${{ matrix.openstack_version }}
             enable_plugin networking-bgpvpn https://github.com/openstack/networking-bgpvpn.git ${{ matrix.openstack_version }}
             Q_ML2_PLUGIN_EXT_DRIVERS=qos,port_security,dns_domain_keywords
+            BGP_SCHEDULER_DRIVER=neutron_dynamic_routing.services.bgp.scheduler.bgp_dragent_scheduler.StaticScheduler
 
             [[post-config|\$NEUTRON_CONF]]
             [oslo_policy]
@@ -59,10 +61,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-networking
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/networking/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-objectstorage.yaml b/.github/workflows/functional-objectstorage.yaml
index ff88efbc1..4e6075818 100644
--- a/.github/workflows/functional-objectstorage.yaml
+++ b/.github/workflows/functional-objectstorage.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**objectstorage**'
+      - '.github/workflows/functional-objectstorage.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +28,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Swift and run objectstorage acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -48,10 +49,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-objectstorage
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/objectstorage/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-orchestration.yaml b/.github/workflows/functional-orchestration.yaml
index 9928aba17..38b6c7b7a 100644
--- a/.github/workflows/functional-orchestration.yaml
+++ b/.github/workflows/functional-orchestration.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**orchestration**'
+      - '.github/workflows/functional-orchestration.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +28,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Heat and run orchestration acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -44,10 +45,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-orchestration
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/orchestration/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-placement.yaml b/.github/workflows/functional-placement.yaml
index 2f182285f..9df95058c 100644
--- a/.github/workflows/functional-placement.yaml
+++ b/.github/workflows/functional-placement.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**placement**'
+      - '.github/workflows/functional-placement.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,10 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +28,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Placement and run placement acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           enabled_services: "${{ matrix.additional_services }}"
@@ -42,10 +43,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-placement
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/placement/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-sharedfilesystems.yaml b/.github/workflows/functional-sharedfilesystems.yaml
index 56480d7d5..eb7b258be 100644
--- a/.github/workflows/functional-sharedfilesystems.yaml
+++ b/.github/workflows/functional-sharedfilesystems.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**sharedfilesystems**'
+      - '.github/workflows/functional-sharedfilesystems.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,6 +14,16 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
+            ubuntu_version: "24.04"
+            devstack_conf_overrides: |
+              # ensure we're using a working version of setuptools
+              if [ -n "\$TOP_DIR" ]; then
+                sed -i 's/setuptools\[core\]$/setuptools[core]==79.0.1/g' \$TOP_DIR/lib/infra \$TOP_DIR/inc/python
+                sed -i 's/pip_install "-U" "pbr"/pip_install "-U" "pbr" "setuptools[core]==79.0.1"/g' \$TOP_DIR/lib/infra
+              fi
+            additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
             ubuntu_version: "22.04"
             additional_services: "openstack-cli-server"
           - name: "dalmatian"
@@ -23,17 +34,13 @@ jobs:
             openstack_version: "stable/2024.1"
             ubuntu_version: "22.04"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Manila and run sharedfilesystems acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -52,16 +59,19 @@ jobs:
             MANILA_DEFAULT_SHARE_TYPE_EXTRA_SPECS='snapshot_support=True create_share_from_snapshot_support=True revert_to_snapshot_support=True mount_snapshot_support=True'
             MANILA_CONFIGURE_DEFAULT_TYPES=True
             MANILA_INSTALL_TEMPEST_PLUGIN_SYSTEMWIDE=false
+
+            ${{ matrix.devstack_conf_overrides }}
           enabled_services: "${{ matrix.additional_services }}"
       - name: Checkout go
         uses: actions/setup-go@v5
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-sharedfilesystems
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/sharedfilesystems/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/functional-workflow.yaml b/.github/workflows/functional-workflow.yaml
index 3ac1cdeb1..871ec1aa7 100644
--- a/.github/workflows/functional-workflow.yaml
+++ b/.github/workflows/functional-workflow.yaml
@@ -3,6 +3,7 @@ on:
   pull_request:
     paths:
       - '**workflow**'
+      - '.github/workflows/functional-workflow.yaml'
   schedule:
     - cron: '0 0 */3 * *'
 jobs:
@@ -13,9 +14,14 @@ jobs:
         include:
           - name: "master"
             openstack_version: "master"
-            ubuntu_version: "22.04"
+            ubuntu_version: "24.04"
             mistral_plugin_version: "master"
             additional_services: "openstack-cli-server"
+          - name: "epoxy"
+            openstack_version: "stable/2025.1"
+            ubuntu_version: "22.04"
+            mistral_plugin_version: "stable/2025.1"
+            additional_services: "openstack-cli-server"
           - name: "dalmatian"
             openstack_version: "stable/2024.2"
             ubuntu_version: "22.04"
@@ -26,21 +32,13 @@ jobs:
             ubuntu_version: "22.04"
             mistral_plugin_version: "stable/2024.1"
             additional_services: ""
-          - name: "bobcat"
-            openstack_version: "stable/2023.2"
-            ubuntu_version: "22.04"
-            # Devstack support is broken with Mistral v2023.2, and requires 2 patches:
-            # * https://github.com/openstack/mistral/commit/e343ccb078d8ba261ac70afca93f4358589730d3
-            # * https://github.com/openstack/mistral/commit/ecdeadeb7a1aa87cba2cdb0c1a2bb1ffc4aabf25
-            mistral_plugin_version: "ecdeadeb7a1aa87cba2cdb0c1a2bb1ffc4aabf25"
-            additional_services: ""
     runs-on: ubuntu-${{ matrix.ubuntu_version }}
     name: Deploy OpenStack ${{ matrix.name }} with Mistral and run workflow acceptance tests
     steps:
       - name: Checkout Gophercloud
         uses: actions/checkout@v4
       - name: Deploy devstack
-        uses: EmilienM/devstack-action@e82a9cbead099cba72f99537e82a360c3e319c69
+        uses: gophercloud/devstack-action@v0.17
         with:
           branch: ${{ matrix.openstack_version }}
           conf_overrides: |
@@ -51,10 +49,11 @@ jobs:
         with:
           go-version: '^1.23'
       - name: Run Gophercloud acceptance tests
-        run: ./script/acceptancetest
+        run: |
+          source ${{ github.workspace }}/script/stackenv
+          make acceptance-workflow
         env:
           DEVSTACK_PATH: ${{ github.workspace }}/devstack
-          PACKAGE: "./internal/acceptance/openstack/workflow/..."
           OS_BRANCH: ${{ matrix.openstack_version }}
       - name: Generate logs on failure
         run: ./script/collectlogs
diff --git a/.github/workflows/lint.yaml b/.github/workflows/lint.yaml
index 665b88718..ed7399819 100644
--- a/.github/workflows/lint.yaml
+++ b/.github/workflows/lint.yaml
@@ -1,27 +1,23 @@
-on: [push, pull_request]
 name: Linters
+on:
+  - push
+  - pull_request
 permissions:
   contents: read
-
 jobs:
   test:
     runs-on: ubuntu-latest
-
     steps:
+      - name: Checkout Gophercloud
+        uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
           go-version: '1'
-
-      - uses: actions/checkout@v4
-
-      - name: Run go fmt
+      - name: Run linters
         run: |
-          ./script/format
-
-      - name: Run go vet
-        run: |
-          ./script/vet
-
+          make lint
+      # TODO: Use 'go mod tidy -diff' instead once go 1.23 is out
+      # https://github.com/golang/go/issues/27005
       - name: Ensure go.mod is up-to-date
         run: |
           if [ $(go mod tidy && git diff | wc -l) -gt 0 ]; then git diff && exit 1; fi
diff --git a/.github/workflows/unit.yaml b/.github/workflows/unit.yaml
index 1489ec0e3..ab11e2656 100644
--- a/.github/workflows/unit.yaml
+++ b/.github/workflows/unit.yaml
@@ -1,8 +1,9 @@
-on: [push, pull_request]
 name: Unit Testing
+on:
+  - push
+  - pull_request
 permissions:
   contents: read
-
 jobs:
   test:
     permissions:
@@ -15,35 +16,29 @@ jobs:
         go-version:
           - "1.23.0"
           - "1"
-
     steps:
+      - name: Checkout Gophercloud
+        uses: actions/checkout@v4
       - name: Setup Go ${{ matrix.go-version }}
         uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go-version }}
-
-      - uses: actions/checkout@v4
-
       - name: Setup environment
         run: |
           # Changing into a different directory to avoid polluting go.sum with "go get"
           cd "$(mktemp -d)"
           go mod init unit_tests
-
           go install github.com/wadey/gocovmerge@master
-
       - name: Run unit tests
         run: |
-          ./script/coverage
-          ./script/unittest
-
+          make unit
+          make coverage
       - name: Check coverage
         uses: coverallsapp/github-action@v2
         with:
           file: cover.out
           flag-name: Go-${{ matrix.go-version }}
           parallel: true
-
   finish:
     permissions:
       checks: write  # for coverallsapp/github-action to create a new check based on the results
diff --git a/Makefile b/Makefile
index 2a0618a6b..5dfd8ad2f 100644
--- a/Makefile
+++ b/Makefile
@@ -2,6 +2,7 @@ undefine GOFLAGS
 
 GOLANGCI_LINT_VERSION?=v1.62.2
 GO_TEST?=go run gotest.tools/gotestsum@latest --format testname --
+TIMEOUT := "60m"
 
 ifeq ($(shell command -v podman 2> /dev/null),)
 	RUNNER=docker
@@ -9,15 +10,18 @@ else
 	RUNNER=podman
 endif
 
-# if the golangci-lint steps fails with the following error message:
+# if the golangci-lint steps fails with one of the following error messages:
 #
 #   directory prefix . does not contain main module or its selected dependencies
 #
+#   failed to initialize build cache at /root/.cache/golangci-lint: mkdir /root/.cache/golangci-lint: permission denied
+#
 # you probably have to fix the SELinux security context for root directory plus your cache
 #
 #   chcon -Rt svirt_sandbox_file_t .
 #   chcon -Rt svirt_sandbox_file_t ~/.cache/golangci-lint
 lint:
+	mkdir -p ~/.cache/golangci-lint/$(GOLANGCI_LINT_VERSION)
 	$(RUNNER) run -t --rm \
 		-v $(shell pwd):/app \
 		-v ~/.cache/golangci-lint/$(GOLANGCI_LINT_VERSION):/root/.cache \
@@ -31,84 +35,88 @@ format:
 .PHONY: format
 
 unit:
-	$(GO_TEST) ./...
+	$(GO_TEST) -shuffle on ./...
 .PHONY: unit
 
 coverage:
-	$(GO_TEST) -covermode count -coverprofile cover.out -coverpkg=./... ./...
+	$(GO_TEST) -shuffle on -covermode count -coverprofile cover.out -coverpkg=./... ./...
 .PHONY: coverage
 
-acceptance: acceptance-baremetal acceptance-blockstorage acceptance-compute acceptance-container acceptance-containerinfra acceptance-db acceptance-dns acceptance-identity acceptance-imageservice acceptance-keymanager acceptance-loadbalancer acceptance-messaging acceptance-networking acceptance-objectstorage acceptance-orchestration acceptance-placement acceptance-sharedfilesystems acceptance-workflow
+acceptance: acceptance-basic acceptance-baremetal acceptance-blockstorage acceptance-compute acceptance-container acceptance-containerinfra acceptance-db acceptance-dns acceptance-identity acceptance-image acceptance-keymanager acceptance-loadbalancer acceptance-messaging acceptance-networking acceptance-objectstorage acceptance-orchestration acceptance-placement acceptance-sharedfilesystems acceptance-workflow
 .PHONY: acceptance
 
+acceptance-basic:
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack
+.PHONY: acceptance-basic
+
 acceptance-baremetal:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/baremetal/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/baremetal/...
 .PHONY: acceptance-baremetal
 
 acceptance-blockstorage:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/blockstorage/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/blockstorage/...
 .PHONY: acceptance-blockstorage
 
 acceptance-compute:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/compute/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/compute/...
 .PHONY: acceptance-compute
 
 acceptance-container:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/container/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/container/...
 .PHONY: acceptance-container
 
 acceptance-containerinfra:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/containerinfra/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/containerinfra/...
 .PHONY: acceptance-containerinfra
 
 acceptance-db:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/db/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/db/...
 .PHONY: acceptance-db
 
 acceptance-dns:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/dns/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/dns/...
 .PHONY: acceptance-dns
 
 acceptance-identity:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/identity/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/identity/...
 .PHONY: acceptance-identity
 
 acceptance-image:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/imageservice/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/image/...
 .PHONY: acceptance-image
 
 acceptance-keymanager:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/keymanager/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/keymanager/...
 .PHONY: acceptance-keymanager
 
 acceptance-loadbalancer:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/loadbalancer/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/loadbalancer/...
 .PHONY: acceptance-loadbalancer
 
 acceptance-messaging:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/messaging/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/messaging/...
 .PHONY: acceptance-messaging
 
 acceptance-networking:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/networking/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/networking/...
 .PHONY: acceptance-networking
 
 acceptance-objectstorage:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/objectstorage/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/objectstorage/...
 .PHONY: acceptance-objectstorage
 
 acceptance-orchestration:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/orchestration/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/orchestration/...
 .PHONY: acceptance-orchestration
 
 acceptance-placement:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/placement/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/placement/...
 .PHONY: acceptance-placement
 
 acceptance-sharedfilesystems:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/sharedfilesystems/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/sharedfilesystems/...
 .PHONY: acceptance-sharefilesystems
 
 acceptance-workflow:
-	$(GO_TEST) -tags "fixtures acceptance" ./internal/acceptance/openstack/workflow/...
+	$(GO_TEST) -timeout $(TIMEOUT) -tags "fixtures acceptance" ./internal/acceptance/openstack/workflow/...
 .PHONY: acceptance-workflow
diff --git a/go.mod b/go.mod
index 16b9039f4..e1ad7471b 100644
--- a/go.mod
+++ b/go.mod
@@ -5,8 +5,8 @@ go 1.23.0
 toolchain go1.23.6
 
 require (
-	golang.org/x/crypto v0.36.0
+	golang.org/x/crypto v0.38.0
 	gopkg.in/yaml.v2 v2.4.0
 )
 
-require golang.org/x/sys v0.31.0 // indirect
+require golang.org/x/sys v0.33.0 // indirect
diff --git a/go.sum b/go.sum
index d886e772d..ff29c0704 100644
--- a/go.sum
+++ b/go.sum
@@ -1,9 +1,9 @@
-golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34=
-golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc=
-golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
-golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
-golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
diff --git a/internal/acceptance/README.md b/internal/acceptance/README.md
index cbbbac7f3..febf394f1 100644
--- a/internal/acceptance/README.md
+++ b/internal/acceptance/README.md
@@ -91,7 +91,13 @@ to set them manually.
 From the root directory, run:
 
 ```
-./script/acceptancetest
+make acceptance
+```
+
+You can also run tests for a specific service:
+
+```
+make acceptance-compute
 ```
 
 Alternatively, add the following to your `.bashrc`:
diff --git a/internal/acceptance/clients/conditions.go b/internal/acceptance/clients/conditions.go
index c48ac208a..6077f4bde 100644
--- a/internal/acceptance/clients/conditions.go
+++ b/internal/acceptance/clients/conditions.go
@@ -14,14 +14,6 @@ func RequiredSystemScope(t *testing.T) {
 	}
 }
 
-// RequireManilaReplicas will restrict a test to only be run with enabled
-// manila replicas.
-func RequireManilaReplicas(t *testing.T) {
-	if os.Getenv("OS_MANILA_REPLICAS") != "true" {
-		t.Skip("manila replicas must be enabled to run this test")
-	}
-}
-
 // RequireAdmin will restrict a test to only be run by admin users.
 func RequireAdmin(t *testing.T) {
 	if os.Getenv("OS_USERNAME") != "admin" {
@@ -36,38 +28,6 @@ func RequireNonAdmin(t *testing.T) {
 	}
 }
 
-// RequirePortForwarding will restrict a test to only be run in environments
-// that support port forwarding
-func RequirePortForwarding(t *testing.T) {
-	if os.Getenv("OS_PORTFORWARDING_ENVIRONMENT") == "" {
-		t.Skip("this test requires support for port forwarding")
-	}
-}
-
-// RequireGuestAgent will restrict a test to only be run in
-// environments that support the QEMU guest agent.
-func RequireGuestAgent(t *testing.T) {
-	if os.Getenv("OS_GUEST_AGENT") == "" {
-		t.Skip("this test requires support for qemu guest agent and to set OS_GUEST_AGENT to 1")
-	}
-}
-
-// RequireIdentityV2 will restrict a test to only be run in
-// environments that support the Identity V2 API.
-func RequireIdentityV2(t *testing.T) {
-	if os.Getenv("OS_IDENTITY_API_VERSION") != "2.0" {
-		t.Skip("this test requires support for the identity v2 API")
-	}
-}
-
-// RequireLiveMigration will restrict a test to only be run in
-// environments that support live migration.
-func RequireLiveMigration(t *testing.T) {
-	if os.Getenv("OS_LIVE_MIGRATE") == "" {
-		t.Skip("this test requires support for live migration and to set OS_LIVE_MIGRATE to 1")
-	}
-}
-
 // RequireLong will ensure long-running tests can run.
 func RequireLong(t *testing.T) {
 	if testing.Short() {
@@ -75,38 +35,6 @@ func RequireLong(t *testing.T) {
 	}
 }
 
-// RequireNovaNetwork will restrict a test to only be run in
-// environments that support nova-network.
-func RequireNovaNetwork(t *testing.T) {
-	if os.Getenv("OS_NOVANET") == "" {
-		t.Skip("this test requires nova-network and to set OS_NOVANET to 1")
-	}
-}
-
-// RequireCinderNoAuth will restrict a test to be only run in environments that
-// have Cinder using noauth.
-func RequireCinderNoAuth(t *testing.T) {
-	if os.Getenv("CINDER_ENDPOINT") == "" || os.Getenv("OS_USERNAME") == "" {
-		t.Skip("this test requires Cinder using noauth, set OS_USERNAME and CINDER_ENDPOINT")
-	}
-}
-
-// RequireIronicNoAuth will restrict a test to be only run in environments that
-// have Ironic using noauth.
-func RequireIronicNoAuth(t *testing.T) {
-	if os.Getenv("IRONIC_ENDPOINT") == "" || os.Getenv("OS_USERNAME") == "" {
-		t.Skip("this test requires IRONIC using noauth, set OS_USERNAME and IRONIC_ENDPOINT")
-	}
-}
-
-// RequireIronicHTTPBasic will restrict a test to be only run in environments
-// that have Ironic using http_basic.
-func RequireIronicHTTPBasic(t *testing.T) {
-	if os.Getenv("IRONIC_ENDPOINT") == "" || os.Getenv("OS_USERNAME") == "" || os.Getenv("OS_PASSWORD") == "" {
-		t.Skip("this test requires Ironic using http_basic, set OS_USERNAME, OS_PASSWORD and IRONIC_ENDPOINT")
-	}
-}
-
 func getReleaseFromEnv(t *testing.T) string {
 	current := strings.TrimPrefix(os.Getenv("OS_BRANCH"), "stable/")
 	if current == "" {
@@ -115,8 +43,8 @@ func getReleaseFromEnv(t *testing.T) string {
 	return current
 }
 
-// SkipRelease will have the test be skipped on a certain
-// release. Releases are named such as 'stable/mitaka', master, etc.
+// SkipRelease will have the test be skipped on a certain release.
+// Releases are named such as 'stable/dalmatian', master, etc.
 func SkipRelease(t *testing.T, release string) {
 	current := getReleaseFromEnv(t)
 	if current == strings.TrimPrefix(release, "stable/") {
@@ -124,8 +52,8 @@ func SkipRelease(t *testing.T, release string) {
 	}
 }
 
-// SkipReleasesBelow will have the test be skipped on releases below a certain
-// one. Releases are named such as 'stable/mitaka', master, etc.
+// SkipReleasesBelow will have the test be skipped on releases below a certain one.
+// Releases are named such as 'stable/dalmatian', master, etc.
 func SkipReleasesBelow(t *testing.T, release string) {
 	current := getReleaseFromEnv(t)
 
@@ -134,9 +62,9 @@ func SkipReleasesBelow(t *testing.T, release string) {
 	}
 }
 
-// SkipReleasesAbove will have the test be skipped on releases above a certain
-// one. The test is always skipped on master release. Releases are named such
-// as 'stable/mitaka', master, etc.
+// SkipReleasesAbove will have the test be skipped on releases above a certain one.
+// The test is always skipped on master release.
+// Releases are named such as 'stable/dalmatian', master, etc.
 func SkipReleasesAbove(t *testing.T, release string) {
 	current := getReleaseFromEnv(t)
 
@@ -150,9 +78,9 @@ func isReleaseNumeral(release string) bool {
 	return err == nil
 }
 
-// IsCurrentAbove will return true on releases above a certain
-// one. The result is always true on master release. Releases are named such
-// as 'stable/mitaka', master, etc.
+// IsCurrentAbove will return true on releases above a certain one.
+// The result is always true on master release.
+// Releases are named such as 'stable/dalmatian', master, etc.
 func IsCurrentAbove(t *testing.T, release string) bool {
 	current := getReleaseFromEnv(t)
 	release = strings.TrimPrefix(release, "stable/")
@@ -174,8 +102,9 @@ func IsCurrentAbove(t *testing.T, release string) bool {
 	return false
 }
 
-// IsCurrentBelow will return true on releases below a certain
-// one. Releases are named such as 'stable/mitaka', master, etc.
+// IsCurrentBelow will return true on releases below a certain one.
+// The result is always false on master release.
+// Releases are named such as 'stable/dalmatian', master, etc.
 func IsCurrentBelow(t *testing.T, release string) bool {
 	current := getReleaseFromEnv(t)
 	release = strings.TrimPrefix(release, "stable/")
diff --git a/internal/acceptance/openstack/baremetal/httpbasic/conditions.go b/internal/acceptance/openstack/baremetal/httpbasic/conditions.go
new file mode 100644
index 000000000..15d1c9f72
--- /dev/null
+++ b/internal/acceptance/openstack/baremetal/httpbasic/conditions.go
@@ -0,0 +1,14 @@
+package httpbasic
+
+import (
+	"os"
+	"testing"
+)
+
+// RequireIronicHTTPBasic will restrict a test to be only run in environments
+// that have Ironic using http_basic.
+func RequireIronicHTTPBasic(t *testing.T) {
+	if os.Getenv("IRONIC_ENDPOINT") == "" || os.Getenv("OS_USERNAME") == "" || os.Getenv("OS_PASSWORD") == "" {
+		t.Skip("this test requires Ironic using http_basic, set OS_USERNAME, OS_PASSWORD and IRONIC_ENDPOINT")
+	}
+}
diff --git a/internal/acceptance/openstack/baremetal/noauth/conditions.go b/internal/acceptance/openstack/baremetal/noauth/conditions.go
new file mode 100644
index 000000000..762f141f5
--- /dev/null
+++ b/internal/acceptance/openstack/baremetal/noauth/conditions.go
@@ -0,0 +1,15 @@
+package noauth
+
+import (
+	"os"
+	"testing"
+)
+
+// RequireIronicNoAuth will restrict a test to be only run in environments that
+
+// have Ironic using noauth.
+func RequireIronicNoAuth(t *testing.T) {
+	if os.Getenv("IRONIC_ENDPOINT") == "" || os.Getenv("OS_USERNAME") == "" {
+		t.Skip("this test requires IRONIC using noauth, set OS_USERNAME and IRONIC_ENDPOINT")
+	}
+}
diff --git a/internal/acceptance/openstack/blockstorage/noauth/conditions.go b/internal/acceptance/openstack/blockstorage/noauth/conditions.go
new file mode 100644
index 000000000..b1fd42e3b
--- /dev/null
+++ b/internal/acceptance/openstack/blockstorage/noauth/conditions.go
@@ -0,0 +1,14 @@
+package noauth
+
+import (
+	"os"
+	"testing"
+)
+
+// RequireCinderNoAuth will restrict a test to be only run in environments that
+// have Cinder using noauth.
+func RequireCinderNoAuth(t *testing.T) {
+	if os.Getenv("CINDER_ENDPOINT") == "" || os.Getenv("OS_USERNAME") == "" {
+		t.Skip("this test requires Cinder using noauth, set OS_USERNAME and CINDER_ENDPOINT")
+	}
+}
diff --git a/internal/acceptance/openstack/blockstorage/v3/blockstorage.go b/internal/acceptance/openstack/blockstorage/v3/blockstorage.go
index 56cf612ab..d28ac05c4 100644
--- a/internal/acceptance/openstack/blockstorage/v3/blockstorage.go
+++ b/internal/acceptance/openstack/blockstorage/v3/blockstorage.go
@@ -14,6 +14,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/tools"
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/backups"
+	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/manageablevolumes"
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/qos"
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/snapshots"
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/volumes"
@@ -779,3 +780,73 @@ func ReImage(t *testing.T, client *gophercloud.ServiceClient, volume *volumes.Vo
 
 	return nil
 }
+
+func Unmanage(t *testing.T, client *gophercloud.ServiceClient, volume *volumes.Volume) error {
+	t.Logf("Attempting to unmanage volume %s", volume.ID)
+
+	err := volumes.Unmanage(context.TODO(), client, volume.ID).ExtractErr()
+	if err != nil {
+		return err
+	}
+
+	gophercloud.WaitFor(context.TODO(), func(ctx context.Context) (bool, error) {
+		if _, err := volumes.Get(ctx, client, volume.ID).Extract(); err != nil {
+			if _, ok := err.(gophercloud.ErrResourceNotFound); ok {
+				return true, nil
+			}
+			return false, err
+		}
+		return false, nil
+	})
+
+	t.Logf("Successfully unmanaged volume %s", volume.ID)
+
+	return nil
+}
+
+func ManageExisting(t *testing.T, client *gophercloud.ServiceClient, volume *volumes.Volume) (*volumes.Volume, error) {
+	t.Logf("Attempting to manage existing volume %s", volume.Name)
+
+	manageOpts := manageablevolumes.ManageExistingOpts{
+		Host: volume.Host,
+		Ref: map[string]string{
+			"source-name": fmt.Sprintf("volume-%s", volume.ID),
+		},
+		Name:             volume.Name,
+		AvailabilityZone: volume.AvailabilityZone,
+		Description:      volume.Description,
+		VolumeType:       volume.VolumeType,
+		Bootable:         volume.Bootable == "true",
+		Metadata:         volume.Metadata,
+	}
+
+	managed, err := manageablevolumes.ManageExisting(context.TODO(), client, manageOpts).Extract()
+	if err != nil {
+		return managed, err
+	}
+
+	ctx, cancel := context.WithTimeout(context.TODO(), 60*time.Second)
+	defer cancel()
+
+	if err := volumes.WaitForStatus(ctx, client, managed.ID, "available"); err != nil {
+		return managed, err
+	}
+
+	managed, err = volumes.Get(context.TODO(), client, managed.ID).Extract()
+	if err != nil {
+		return managed, err
+	}
+
+	tools.PrintResource(t, managed)
+	th.AssertEquals(t, managed.Host, volume.Host)
+	th.AssertEquals(t, managed.Name, volume.Name)
+	th.AssertEquals(t, managed.AvailabilityZone, volume.AvailabilityZone)
+	th.AssertEquals(t, managed.Description, volume.Description)
+	th.AssertEquals(t, managed.VolumeType, volume.VolumeType)
+	th.AssertEquals(t, managed.Bootable, volume.Bootable)
+	th.AssertDeepEquals(t, managed.Metadata, volume.Metadata)
+
+	t.Logf("Successfully managed existing volume %s", managed.ID)
+
+	return managed, nil
+}
diff --git a/internal/acceptance/openstack/compute/v2/conditions.go b/internal/acceptance/openstack/compute/v2/conditions.go
new file mode 100644
index 000000000..565a3e1cf
--- /dev/null
+++ b/internal/acceptance/openstack/compute/v2/conditions.go
@@ -0,0 +1,22 @@
+package v2
+
+import (
+	"os"
+	"testing"
+)
+
+// RequireGuestAgent will restrict a test to only be run in
+// environments that support the QEMU guest agent.
+func RequireGuestAgent(t *testing.T) {
+	if os.Getenv("OS_GUEST_AGENT") == "" {
+		t.Skip("this test requires support for qemu guest agent and to set OS_GUEST_AGENT to 1")
+	}
+}
+
+// RequireLiveMigration will restrict a test to only be run in
+// environments that support live migration.
+func RequireLiveMigration(t *testing.T) {
+	if os.Getenv("OS_LIVE_MIGRATE") == "" {
+		t.Skip("this test requires support for live migration and to set OS_LIVE_MIGRATE to 1")
+	}
+}
diff --git a/internal/acceptance/openstack/containerinfra/v1/containerinfra.go b/internal/acceptance/openstack/containerinfra/v1/containerinfra.go
index 9b26c0ad2..84ee98e87 100644
--- a/internal/acceptance/openstack/containerinfra/v1/containerinfra.go
+++ b/internal/acceptance/openstack/containerinfra/v1/containerinfra.go
@@ -31,6 +31,9 @@ func CreateClusterTemplateCOE(t *testing.T, client *gophercloud.ServiceClient, c
 	t.Logf("Attempting to create %s cluster template: %s", coe, name)
 
 	boolFalse := false
+	labels := map[string]string{
+		"test": "test",
+	}
 	createOpts := clustertemplates.CreateOpts{
 		COE:                 coe,
 		DNSNameServer:       "8.8.8.8",
@@ -45,6 +48,8 @@ func CreateClusterTemplateCOE(t *testing.T, client *gophercloud.ServiceClient, c
 		Public:              &boolFalse,
 		RegistryEnabled:     &boolFalse,
 		ServerType:          "vm",
+		// workaround for https://bugs.launchpad.net/magnum/+bug/2109685
+		Labels: labels,
 	}
 
 	res := clustertemplates.Create(context.TODO(), client, createOpts)
@@ -68,6 +73,7 @@ func CreateClusterTemplateCOE(t *testing.T, client *gophercloud.ServiceClient, c
 	tools.PrintResource(t, clusterTemplate.CreatedAt)
 
 	th.AssertEquals(t, name, clusterTemplate.Name)
+	th.AssertDeepEquals(t, labels, clusterTemplate.Labels)
 	th.AssertEquals(t, choices.ExternalNetworkID, clusterTemplate.ExternalNetworkID)
 	th.AssertEquals(t, choices.MagnumImageID, clusterTemplate.ImageID)
 
diff --git a/internal/acceptance/openstack/dns/v2/dns.go b/internal/acceptance/openstack/dns/v2/dns.go
index c31f238a6..9adb61882 100644
--- a/internal/acceptance/openstack/dns/v2/dns.go
+++ b/internal/acceptance/openstack/dns/v2/dns.go
@@ -186,6 +186,41 @@ func DeleteTransferRequest(t *testing.T, client *gophercloud.ServiceClient, tr *
 	t.Logf("Deleted zone transfer request: %s", tr.ID)
 }
 
+// CreateShare will create a zone share. An error will be returned if the
+// zone share was unable to be created.
+func CreateShare(t *testing.T, client *gophercloud.ServiceClient, zone *zones.Zone, targetProjectID string) (*zones.ZoneShare, error) {
+	t.Logf("Attempting to share zone %s with project %s", zone.ID, targetProjectID)
+
+	createOpts := zones.ShareZoneOpts{
+		TargetProjectID: targetProjectID,
+	}
+
+	share, err := zones.Share(context.TODO(), client, zone.ID, createOpts).Extract()
+	if err != nil {
+		return share, err
+	}
+
+	t.Logf("Created share for zone: %s", zone.ID)
+
+	th.AssertEquals(t, share.ZoneID, zone.ID)
+	th.AssertEquals(t, share.TargetProjectID, targetProjectID)
+
+	return share, nil
+}
+
+// UnshareZone will unshare a zone. An error will be returned if the
+// zone unshare was unable to be created.
+func UnshareZone(t *testing.T, client *gophercloud.ServiceClient, share *zones.ZoneShare) {
+	t.Logf("Attempting to unshare zone %s with project %s", share.ZoneID, share.TargetProjectID)
+
+	err := zones.Unshare(context.TODO(), client, share.ZoneID, share.ID).ExtractErr()
+	if err != nil {
+		t.Fatalf("Unable to unshare zone %s: %v", share.ZoneID, err)
+	}
+
+	t.Logf("Unshared zone: %s", share.ZoneID)
+}
+
 // DeleteRecordSet will delete a specified record set. A fatal error will occur if
 // the record set failed to be deleted. This works best when used as a deferred
 // function.
diff --git a/internal/acceptance/openstack/identity/v2/conditions.go b/internal/acceptance/openstack/identity/v2/conditions.go
new file mode 100644
index 000000000..9871afaf3
--- /dev/null
+++ b/internal/acceptance/openstack/identity/v2/conditions.go
@@ -0,0 +1,14 @@
+package v2
+
+import (
+	"os"
+	"testing"
+)
+
+// RequireIdentityV2 will restrict a test to only be run in
+// environments that support the Identity V2 API.
+func RequireIdentityV2(t *testing.T) {
+	if os.Getenv("OS_IDENTITY_API_VERSION") != "2.0" {
+		t.Skip("this test requires support for the identity v2 API")
+	}
+}
diff --git a/internal/acceptance/openstack/loadbalancer/v2/loadbalancer.go b/internal/acceptance/openstack/loadbalancer/v2/loadbalancer.go
index 907e9d565..6a36a49d2 100644
--- a/internal/acceptance/openstack/loadbalancer/v2/loadbalancer.go
+++ b/internal/acceptance/openstack/loadbalancer/v2/loadbalancer.go
@@ -214,6 +214,7 @@ func CreateLoadBalancerFullyPopulated(t *testing.T, client *gophercloud.ServiceC
 					MaxRetries:     5,
 					MaxRetriesDown: 4,
 					Type:           monitors.TypeHTTP,
+					HTTPVersion:    "1.0",
 				},
 			},
 			L7Policies: []l7policies.CreateOpts{{
@@ -272,6 +273,13 @@ func CreateLoadBalancerFullyPopulated(t *testing.T, client *gophercloud.ServiceC
 	th.AssertEquals(t, lb.Pools[0].Members[0].ProtocolPort, memberPort)
 	th.AssertEquals(t, lb.Pools[0].Members[0].Weight, memberWeight)
 
+	th.AssertEquals(t, lb.Pools[0].Monitor.Delay, 10)
+	th.AssertEquals(t, lb.Pools[0].Monitor.Timeout, 5)
+	th.AssertEquals(t, lb.Pools[0].Monitor.MaxRetries, 5)
+	th.AssertEquals(t, lb.Pools[0].Monitor.MaxRetriesDown, 4)
+	th.AssertEquals(t, lb.Pools[0].Monitor.Type, string(monitors.TypeHTTP))
+	th.AssertEquals(t, lb.Pools[0].Monitor.HTTPVersion, "1.0")
+
 	if len(tags) > 0 {
 		th.AssertDeepEquals(t, lb.Tags, tags)
 	}
@@ -333,6 +341,7 @@ func CreateMonitor(t *testing.T, client *gophercloud.ServiceClient, lb *loadbala
 		MaxRetries:     5,
 		MaxRetriesDown: 4,
 		Type:           monitors.TypePING,
+		HTTPVersion:    "1.1",
 	}
 
 	monitor, err := monitors.Create(context.TODO(), client, createOpts).Extract()
@@ -352,6 +361,7 @@ func CreateMonitor(t *testing.T, client *gophercloud.ServiceClient, lb *loadbala
 	th.AssertEquals(t, monitor.Timeout, 5)
 	th.AssertEquals(t, monitor.MaxRetries, 5)
 	th.AssertEquals(t, monitor.MaxRetriesDown, 4)
+	th.AssertEquals(t, monitor.HTTPVersion, "1.1")
 
 	return monitor, nil
 }
diff --git a/internal/acceptance/openstack/networking/v2/extensions/extensions.go b/internal/acceptance/openstack/networking/v2/extensions/extensions.go
index f50878abe..9565d1e30 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/extensions.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/extensions.go
@@ -140,20 +140,18 @@ func CreateSecurityGroupRule(t *testing.T, client *gophercloud.ServiceClient, se
 	return rule, nil
 }
 
-// CreateSecurityGroupRulesBulk will create security group rules with a random name
-// and random port between 80 and 99.
+// CreateSecurityGroupRulesBulk will create 3 security group rules with ports between 1080 and 1099.
 // An error will be returned if one was failed to be created.
 func CreateSecurityGroupRulesBulk(t *testing.T, client *gophercloud.ServiceClient, secGroupID string) ([]rules.SecGroupRule, error) {
 	t.Logf("Attempting to bulk create security group rules in group: %s", secGroupID)
 
 	sgRulesCreateOpts := make([]rules.CreateOpts, 3)
-	for i := range 3 {
-		description := "Rule description"
-		fromPort := tools.RandomInt(1080, 1089)
-		toPort := tools.RandomInt(1090, 1099)
+	for i := range sgRulesCreateOpts {
+		fromPort := 1080 + i
+		toPort := tools.RandomInt(fromPort, 1099)
 
 		sgRulesCreateOpts[i] = rules.CreateOpts{
-			Description:  description,
+			Description:  "Rule description",
 			Direction:    "ingress",
 			EtherType:    "IPv4",
 			SecGroupID:   secGroupID,
diff --git a/internal/acceptance/openstack/sharedfilesystems/v2/conditions.go b/internal/acceptance/openstack/sharedfilesystems/v2/conditions.go
new file mode 100644
index 000000000..de48b6939
--- /dev/null
+++ b/internal/acceptance/openstack/sharedfilesystems/v2/conditions.go
@@ -0,0 +1,14 @@
+package v2
+
+import (
+	"os"
+	"testing"
+)
+
+// RequireManilaReplicas will restrict a test to only be run with enabled
+// manila replicas.
+func RequireManilaReplicas(t *testing.T) {
+	if os.Getenv("OS_MANILA_REPLICAS") != "true" {
+		t.Skip("manila replicas must be enabled to run this test")
+	}
+}
diff --git a/openstack/auth_env.go b/openstack/auth_env.go
index 893787b78..9ecc5b4ef 100644
--- a/openstack/auth_env.go
+++ b/openstack/auth_env.go
@@ -24,8 +24,8 @@ OS_PROJECT_NAME and the latter are expected against a v3 auth api.
 If OS_PROJECT_ID and OS_PROJECT_NAME are set, they will still be referred
 as "tenant" in Gophercloud.
 
-If OS_PROJECT_NAME is set, it requires OS_PROJECT_ID to be set as well to
-handle projects not on the default domain.
+If OS_PROJECT_NAME is set, it requires OS_DOMAIN_ID or OS_DOMAIN_NAME to be
+set as well to handle projects not on the default domain.
 
 To use this function, first set the OS_* environment variables (for example,
 by sourcing an `openrc` file), then:
diff --git a/openstack/blockstorage/v2/backups/requests.go b/openstack/blockstorage/v2/backups/requests.go
index 573946ab2..a791191d9 100644
--- a/openstack/blockstorage/v2/backups/requests.go
+++ b/openstack/blockstorage/v2/backups/requests.go
@@ -238,6 +238,12 @@ func Update(ctx context.Context, client *gophercloud.ServiceClient, id string, o
 	return
 }
 
+// RestoreOptsBuilder allows extensions to add additional parameters to the
+// Restore request.
+type RestoreOptsBuilder interface {
+	ToRestoreMap() (map[string]any, error)
+}
+
 // RestoreOpts contains options for restoring a Backup. This object is passed to
 // the backups.RestoreFromBackup function.
 type RestoreOpts struct {
@@ -257,7 +263,7 @@ func (opts RestoreOpts) ToRestoreMap() (map[string]any, error) {
 // RestoreFromBackup will restore a Backup to a volume based on the values in
 // RestoreOpts. To extract the Restore object from the response, call the
 // Extract method on the RestoreResult.
-func RestoreFromBackup(ctx context.Context, client *gophercloud.ServiceClient, id string, opts RestoreOpts) (r RestoreResult) {
+func RestoreFromBackup(ctx context.Context, client *gophercloud.ServiceClient, id string, opts RestoreOptsBuilder) (r RestoreResult) {
 	b, err := opts.ToRestoreMap()
 	if err != nil {
 		r.Err = err
@@ -278,6 +284,12 @@ func Export(ctx context.Context, client *gophercloud.ServiceClient, id string) (
 	return
 }
 
+// ImportOptsBuilder allows extensions to add additional parameters to the
+// Import request.
+type ImportOptsBuilder interface {
+	ToBackupImportMap() (map[string]any, error)
+}
+
 // ImportOpts contains options for importing a Backup. This object is passed to
 // the backups.ImportBackup function.
 type ImportOpts BackupRecord
@@ -291,7 +303,7 @@ func (opts ImportOpts) ToBackupImportMap() (map[string]any, error) {
 // Import will import a Backup data to a backup based on the values in
 // ImportOpts. To extract the Backup object from the response, call the
 // Extract method on the ImportResult.
-func Import(ctx context.Context, client *gophercloud.ServiceClient, opts ImportOpts) (r ImportResult) {
+func Import(ctx context.Context, client *gophercloud.ServiceClient, opts ImportOptsBuilder) (r ImportResult) {
 	b, err := opts.ToBackupImportMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/blockstorage/v2/transfers/requests.go b/openstack/blockstorage/v2/transfers/requests.go
index 9c762cfe1..4d146ff23 100644
--- a/openstack/blockstorage/v2/transfers/requests.go
+++ b/openstack/blockstorage/v2/transfers/requests.go
@@ -7,6 +7,12 @@ import (
 	"github.com/gophercloud/gophercloud/v2/pagination"
 )
 
+// CreateOptsBuilder allows extensions to add additional parameters to the
+// Create request.
+type CreateOptsBuilder interface {
+	ToCreateMap() (map[string]any, error)
+}
+
 // CreateOpts contains options for a Volume transfer.
 type CreateOpts struct {
 	// The ID of the volume to transfer.
@@ -23,7 +29,7 @@ func (opts CreateOpts) ToCreateMap() (map[string]any, error) {
 }
 
 // Create will create a volume tranfer request based on the values in CreateOpts.
-func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateOpts) (r CreateResult) {
+func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
 	b, err := opts.ToCreateMap()
 	if err != nil {
 		r.Err = err
@@ -36,6 +42,12 @@ func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateO
 	return
 }
 
+// AcceptOptsBuilder allows extensions to add additional parameters to the
+// Accept request.
+type AcceptOptsBuilder interface {
+	ToAcceptMap() (map[string]any, error)
+}
+
 // AcceptOpts contains options for a Volume transfer accept reqeust.
 type AcceptOpts struct {
 	// The auth key of the volume transfer to accept.
@@ -49,7 +61,7 @@ func (opts AcceptOpts) ToAcceptMap() (map[string]any, error) {
 }
 
 // Accept will accept a volume tranfer request based on the values in AcceptOpts.
-func Accept(ctx context.Context, client *gophercloud.ServiceClient, id string, opts AcceptOpts) (r CreateResult) {
+func Accept(ctx context.Context, client *gophercloud.ServiceClient, id string, opts AcceptOptsBuilder) (r CreateResult) {
 	b, err := opts.ToAcceptMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/blockstorage/v2/volumes/requests.go b/openstack/blockstorage/v2/volumes/requests.go
index 9d1e797fc..62b36d214 100644
--- a/openstack/blockstorage/v2/volumes/requests.go
+++ b/openstack/blockstorage/v2/volumes/requests.go
@@ -617,6 +617,12 @@ func SetImageMetadata(ctx context.Context, client *gophercloud.ServiceClient, id
 	return
 }
 
+// BootableOptsBuilder allows extensions to add additional parameters to the
+// SetBootable request.
+type BootableOptsBuilder interface {
+	ToBootableMap() (map[string]any, error)
+}
+
 // BootableOpts contains options for setting bootable status to a volume.
 type BootableOpts struct {
 	// Enables or disables the bootable attribute. You can boot an instance from a bootable volume.
@@ -630,7 +636,7 @@ func (opts BootableOpts) ToBootableMap() (map[string]any, error) {
 }
 
 // SetBootable will set bootable status on a volume based on the values in BootableOpts
-func SetBootable(ctx context.Context, client *gophercloud.ServiceClient, id string, opts BootableOpts) (r SetBootableResult) {
+func SetBootable(ctx context.Context, client *gophercloud.ServiceClient, id string, opts BootableOptsBuilder) (r SetBootableResult) {
 	b, err := opts.ToBootableMap()
 	if err != nil {
 		r.Err = err
@@ -691,6 +697,12 @@ func ChangeType(ctx context.Context, client *gophercloud.ServiceClient, id strin
 	return
 }
 
+// ReImageOptsBuilder allows extensions to add additional parameters to the
+// ReImage request.
+type ReImageOptsBuilder interface {
+	ToReImageMap() (map[string]any, error)
+}
+
 // ReImageOpts contains options for Re-image a volume.
 type ReImageOpts struct {
 	// New image id
@@ -705,7 +717,7 @@ func (opts ReImageOpts) ToReImageMap() (map[string]any, error) {
 }
 
 // ReImage will re-image a volume based on the values in ReImageOpts
-func ReImage(ctx context.Context, client *gophercloud.ServiceClient, id string, opts ReImageOpts) (r ReImageResult) {
+func ReImage(ctx context.Context, client *gophercloud.ServiceClient, id string, opts ReImageOptsBuilder) (r ReImageResult) {
 	b, err := opts.ToReImageMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/blockstorage/v3/backups/requests.go b/openstack/blockstorage/v3/backups/requests.go
index a1f3cc8ee..d75da4c25 100644
--- a/openstack/blockstorage/v3/backups/requests.go
+++ b/openstack/blockstorage/v3/backups/requests.go
@@ -238,6 +238,12 @@ func Update(ctx context.Context, client *gophercloud.ServiceClient, id string, o
 	return
 }
 
+// RestoreOptsBuilder allows extensions to add additional parameters to the
+// Restore request.
+type RestoreOptsBuilder interface {
+	ToRestoreMap() (map[string]any, error)
+}
+
 // RestoreOpts contains options for restoring a Backup. This object is passed to
 // the backups.RestoreFromBackup function.
 type RestoreOpts struct {
@@ -257,7 +263,7 @@ func (opts RestoreOpts) ToRestoreMap() (map[string]any, error) {
 // RestoreFromBackup will restore a Backup to a volume based on the values in
 // RestoreOpts. To extract the Restore object from the response, call the
 // Extract method on the RestoreResult.
-func RestoreFromBackup(ctx context.Context, client *gophercloud.ServiceClient, id string, opts RestoreOpts) (r RestoreResult) {
+func RestoreFromBackup(ctx context.Context, client *gophercloud.ServiceClient, id string, opts RestoreOptsBuilder) (r RestoreResult) {
 	b, err := opts.ToRestoreMap()
 	if err != nil {
 		r.Err = err
@@ -278,6 +284,12 @@ func Export(ctx context.Context, client *gophercloud.ServiceClient, id string) (
 	return
 }
 
+// ImportOptsBuilder allows extensions to add additional parameters to the
+// Import request.
+type ImportOptsBuilder interface {
+	ToBackupImportMap() (map[string]any, error)
+}
+
 // ImportOpts contains options for importing a Backup. This object is passed to
 // the backups.ImportBackup function.
 type ImportOpts BackupRecord
@@ -291,7 +303,7 @@ func (opts ImportOpts) ToBackupImportMap() (map[string]any, error) {
 // Import will import a Backup data to a backup based on the values in
 // ImportOpts. To extract the Backup object from the response, call the
 // Extract method on the ImportResult.
-func Import(ctx context.Context, client *gophercloud.ServiceClient, opts ImportOpts) (r ImportResult) {
+func Import(ctx context.Context, client *gophercloud.ServiceClient, opts ImportOptsBuilder) (r ImportResult) {
 	b, err := opts.ToBackupImportMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/blockstorage/v3/manageablevolumes/doc.go b/openstack/blockstorage/v3/manageablevolumes/doc.go
new file mode 100644
index 000000000..a2217fc0f
--- /dev/null
+++ b/openstack/blockstorage/v3/manageablevolumes/doc.go
@@ -0,0 +1,32 @@
+/*
+Package manageablevolumes information and interaction with manageable volumes
+for the OpenStack Block Storage service.
+
+NOTE: Requires at least microversion 3.8
+
+Example to manage an existing volume
+
+	manageOpts := manageablevolumes.ManageExistingOpts{
+		Host:             "host@lvm#LVM",
+		Ref:              map[string]string{
+			"source-name": "volume-73796b96-169f-4675-a5bc-73fc0f8f9a17",
+		},
+		Name:             "New Volume",
+		AvailabilityZone: "nova",
+		Description:      "Volume imported from existingLV",
+		VolumeType:       "lvm",
+		Bootable:         true,
+		Metadata:         map[string]string{
+			"key1": "value1",
+			"key2": "value2"
+		},
+	}
+
+	managedVolume, err := manageablevolumes.ManageExisting(context.TODO(), client, manageOpts).Extract()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fmt.Printf("Managed volume: %+v\n", managedVolume)
+*/
+package manageablevolumes
diff --git a/openstack/blockstorage/v3/manageablevolumes/requests.go b/openstack/blockstorage/v3/manageablevolumes/requests.go
new file mode 100644
index 000000000..42c5593cd
--- /dev/null
+++ b/openstack/blockstorage/v3/manageablevolumes/requests.go
@@ -0,0 +1,61 @@
+package manageablevolumes
+
+import (
+	"context"
+
+	"github.com/gophercloud/gophercloud/v2"
+)
+
+// ManageExistingOptsBuilder allows extentions to add additional parameters to the ManageExisting request.
+type ManageExistingOptsBuilder interface {
+	ToManageExistingMap() (map[string]any, error)
+}
+
+// ManageExistingOpts contains options for managing a existing volume.
+// This object is passed to the volumes.ManageExisting function.
+// For more information about the parameters, see the Volume object and OpenStack BlockStorage API Guide.
+type ManageExistingOpts struct {
+	// The OpenStack Block Storage host where the existing resource resides.
+	// Optional only if cluster field is provided.
+	Host string `json:"host,omitempty"`
+	// The OpenStack Block Storage cluster where the resource resides.
+	// Optional only if host field is provided.
+	Cluster string `json:"cluster,omitempty"`
+	// A reference to the existing volume.
+	// The internal structure of this reference depends on the volume driver implementation.
+	// For details about the required elements in the structure, see the documentation for the volume driver.
+	Ref map[string]string `json:"ref,omitempty"`
+	// Human-readable display name for the volume.
+	Name string `json:"name,omitempty"`
+	// The availability zone.
+	AvailabilityZone string `json:"availability_zone,omitempty"`
+	// Human-readable description for the volume.
+	Description string `json:"description,omitempty"`
+	// The associated volume type
+	VolumeType string `json:"volume_type,omitempty"`
+	// Indicates whether this is a bootable volume.
+	Bootable bool `json:"bootable,omitempty"`
+	// One or more metadata key and value pairs to associate with the volume.
+	Metadata map[string]string `json:"metadata,omitempty"`
+}
+
+// ToManageExistingMap assembles a request body based on the contents of a ManageExistingOpts.
+func (opts ManageExistingOpts) ToManageExistingMap() (map[string]any, error) {
+	return gophercloud.BuildRequestBody(opts, "volume")
+}
+
+// ManageExisting will manage an existing volume based on the values in ManageExistingOpts.
+// To extract the Volume object from response, call the Extract method on the ManageExistingResult.
+func ManageExisting(ctx context.Context, client *gophercloud.ServiceClient, opts ManageExistingOptsBuilder) (r ManageExistingResult) {
+	b, err := opts.ToManageExistingMap()
+	if err != nil {
+		r.Err = err
+		return
+	}
+
+	resp, err := client.Post(ctx, createURL(client), b, &r.Body, &gophercloud.RequestOpts{
+		OkCodes: []int{202},
+	})
+	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
+	return
+}
diff --git a/openstack/blockstorage/v3/manageablevolumes/results.go b/openstack/blockstorage/v3/manageablevolumes/results.go
new file mode 100644
index 000000000..317ed21fb
--- /dev/null
+++ b/openstack/blockstorage/v3/manageablevolumes/results.go
@@ -0,0 +1,22 @@
+package manageablevolumes
+
+import (
+	"github.com/gophercloud/gophercloud/v2"
+	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/volumes"
+)
+
+type ManageExistingResult struct {
+	gophercloud.Result
+}
+
+// Extract will get the Volume object out of the ManageExistingResult object.
+func (r ManageExistingResult) Extract() (*volumes.Volume, error) {
+	var s volumes.Volume
+	err := r.ExtractInto(&s)
+	return &s, err
+}
+
+// ExtractInto converts our response data into a volume struct
+func (r ManageExistingResult) ExtractInto(v any) error {
+	return r.Result.ExtractIntoStructPtr(v, "volume")
+}
diff --git a/openstack/blockstorage/v3/manageablevolumes/urls.go b/openstack/blockstorage/v3/manageablevolumes/urls.go
new file mode 100644
index 000000000..c58c94a39
--- /dev/null
+++ b/openstack/blockstorage/v3/manageablevolumes/urls.go
@@ -0,0 +1,7 @@
+package manageablevolumes
+
+import "github.com/gophercloud/gophercloud/v2"
+
+func createURL(c *gophercloud.ServiceClient) string {
+	return c.ServiceURL("manageable_volumes")
+}
diff --git a/openstack/blockstorage/v3/transfers/requests.go b/openstack/blockstorage/v3/transfers/requests.go
index 9c762cfe1..4d146ff23 100644
--- a/openstack/blockstorage/v3/transfers/requests.go
+++ b/openstack/blockstorage/v3/transfers/requests.go
@@ -7,6 +7,12 @@ import (
 	"github.com/gophercloud/gophercloud/v2/pagination"
 )
 
+// CreateOptsBuilder allows extensions to add additional parameters to the
+// Create request.
+type CreateOptsBuilder interface {
+	ToCreateMap() (map[string]any, error)
+}
+
 // CreateOpts contains options for a Volume transfer.
 type CreateOpts struct {
 	// The ID of the volume to transfer.
@@ -23,7 +29,7 @@ func (opts CreateOpts) ToCreateMap() (map[string]any, error) {
 }
 
 // Create will create a volume tranfer request based on the values in CreateOpts.
-func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateOpts) (r CreateResult) {
+func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
 	b, err := opts.ToCreateMap()
 	if err != nil {
 		r.Err = err
@@ -36,6 +42,12 @@ func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateO
 	return
 }
 
+// AcceptOptsBuilder allows extensions to add additional parameters to the
+// Accept request.
+type AcceptOptsBuilder interface {
+	ToAcceptMap() (map[string]any, error)
+}
+
 // AcceptOpts contains options for a Volume transfer accept reqeust.
 type AcceptOpts struct {
 	// The auth key of the volume transfer to accept.
@@ -49,7 +61,7 @@ func (opts AcceptOpts) ToAcceptMap() (map[string]any, error) {
 }
 
 // Accept will accept a volume tranfer request based on the values in AcceptOpts.
-func Accept(ctx context.Context, client *gophercloud.ServiceClient, id string, opts AcceptOpts) (r CreateResult) {
+func Accept(ctx context.Context, client *gophercloud.ServiceClient, id string, opts AcceptOptsBuilder) (r CreateResult) {
 	b, err := opts.ToAcceptMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/blockstorage/v3/volumes/doc.go b/openstack/blockstorage/v3/volumes/doc.go
index 2ab4af93e..e018b57a8 100644
--- a/openstack/blockstorage/v3/volumes/doc.go
+++ b/openstack/blockstorage/v3/volumes/doc.go
@@ -157,5 +157,12 @@ Example of Attaching a Volume to an Instance
 	if err != nil {
 		panic(err)
 	}
+
+Example of Unmanaging a Volume
+
+	err := volumes.Unmanage(context.TODO(), client, volume.ID).ExtractErr()
+	if err != nil {
+		panic(err)
+	}
 */
 package volumes
diff --git a/openstack/blockstorage/v3/volumes/requests.go b/openstack/blockstorage/v3/volumes/requests.go
index 77210943b..1026d1eca 100644
--- a/openstack/blockstorage/v3/volumes/requests.go
+++ b/openstack/blockstorage/v3/volumes/requests.go
@@ -623,6 +623,12 @@ func SetImageMetadata(ctx context.Context, client *gophercloud.ServiceClient, id
 	return
 }
 
+// BootableOptsBuilder allows extensions to add additional parameters to the
+// SetBootable request.
+type BootableOptsBuilder interface {
+	ToBootableMap() (map[string]any, error)
+}
+
 // BootableOpts contains options for setting bootable status to a volume.
 type BootableOpts struct {
 	// Enables or disables the bootable attribute. You can boot an instance from a bootable volume.
@@ -636,7 +642,7 @@ func (opts BootableOpts) ToBootableMap() (map[string]any, error) {
 }
 
 // SetBootable will set bootable status on a volume based on the values in BootableOpts
-func SetBootable(ctx context.Context, client *gophercloud.ServiceClient, id string, opts BootableOpts) (r SetBootableResult) {
+func SetBootable(ctx context.Context, client *gophercloud.ServiceClient, id string, opts BootableOptsBuilder) (r SetBootableResult) {
 	b, err := opts.ToBootableMap()
 	if err != nil {
 		r.Err = err
@@ -697,6 +703,12 @@ func ChangeType(ctx context.Context, client *gophercloud.ServiceClient, id strin
 	return
 }
 
+// ReImageOptsBuilder allows extensions to add additional parameters to the
+// ReImage request.
+type ReImageOptsBuilder interface {
+	ToReImageMap() (map[string]any, error)
+}
+
 // ReImageOpts contains options for Re-image a volume.
 type ReImageOpts struct {
 	// New image id
@@ -711,7 +723,7 @@ func (opts ReImageOpts) ToReImageMap() (map[string]any, error) {
 }
 
 // ReImage will re-image a volume based on the values in ReImageOpts
-func ReImage(ctx context.Context, client *gophercloud.ServiceClient, id string, opts ReImageOpts) (r ReImageResult) {
+func ReImage(ctx context.Context, client *gophercloud.ServiceClient, id string, opts ReImageOptsBuilder) (r ReImageResult) {
 	b, err := opts.ToReImageMap()
 	if err != nil {
 		r.Err = err
@@ -763,3 +775,14 @@ func ResetStatus(ctx context.Context, client *gophercloud.ServiceClient, id stri
 	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
 	return
 }
+
+// Unmanage removes a volume from Block Storage management without
+// removing the back-end storage object that is associated with it.
+func Unmanage(ctx context.Context, client *gophercloud.ServiceClient, id string) (r UnmanageResult) {
+	body := map[string]any{"os-unmanage": make(map[string]any)}
+	resp, err := client.Post(ctx, actionURL(client, id), body, nil, &gophercloud.RequestOpts{
+		OkCodes: []int{202},
+	})
+	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
+	return
+}
diff --git a/openstack/blockstorage/v3/volumes/results.go b/openstack/blockstorage/v3/volumes/results.go
index 3f184b398..e99ef5e19 100644
--- a/openstack/blockstorage/v3/volumes/results.go
+++ b/openstack/blockstorage/v3/volumes/results.go
@@ -399,3 +399,8 @@ type ReImageResult struct {
 type ResetStatusResult struct {
 	gophercloud.ErrResult
 }
+
+// UnmanageResult contains the response error from a Unmanage request.
+type UnmanageResult struct {
+	gophercloud.ErrResult
+}
diff --git a/openstack/compute/v2/aggregates/requests.go b/openstack/compute/v2/aggregates/requests.go
index be20cbffe..bdf9ccb3d 100644
--- a/openstack/compute/v2/aggregates/requests.go
+++ b/openstack/compute/v2/aggregates/requests.go
@@ -15,6 +15,12 @@ func List(client *gophercloud.ServiceClient) pagination.Pager {
 	})
 }
 
+// CreateOptsBuilder allows extensions to add additional parameters to the
+// Create request.
+type CreateOptsBuilder interface {
+	ToAggregatesCreateMap() (map[string]any, error)
+}
+
 type CreateOpts struct {
 	// The name of the host aggregate.
 	Name string `json:"name" required:"true"`
@@ -31,7 +37,7 @@ func (opts CreateOpts) ToAggregatesCreateMap() (map[string]any, error) {
 }
 
 // Create makes a request against the API to create an aggregate.
-func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateOpts) (r CreateResult) {
+func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
 	b, err := opts.ToAggregatesCreateMap()
 	if err != nil {
 		r.Err = err
@@ -64,6 +70,12 @@ func Get(ctx context.Context, client *gophercloud.ServiceClient, aggregateID int
 	return
 }
 
+// UpdateOptsBuilder allows extensions to add additional parameters to the
+// Update request.
+type UpdateOptsBuilder interface {
+	ToAggregatesUpdateMap() (map[string]any, error)
+}
+
 type UpdateOpts struct {
 	// The name of the host aggregate.
 	Name *string `json:"name,omitempty"`
@@ -80,7 +92,7 @@ func (opts UpdateOpts) ToAggregatesUpdateMap() (map[string]any, error) {
 }
 
 // Update makes a request against the API to update a specific aggregate.
-func Update(ctx context.Context, client *gophercloud.ServiceClient, aggregateID int, opts UpdateOpts) (r UpdateResult) {
+func Update(ctx context.Context, client *gophercloud.ServiceClient, aggregateID int, opts UpdateOptsBuilder) (r UpdateResult) {
 	v := strconv.Itoa(aggregateID)
 
 	b, err := opts.ToAggregatesUpdateMap()
diff --git a/openstack/compute/v2/services/requests.go b/openstack/compute/v2/services/requests.go
index 7f6ac1d6d..32be17cb7 100644
--- a/openstack/compute/v2/services/requests.go
+++ b/openstack/compute/v2/services/requests.go
@@ -51,6 +51,12 @@ const (
 	ServiceDisabled ServiceStatus = "disabled"
 )
 
+// UpdateOptsBuilder allows extensions to add additional parameters to the
+// Update request.
+type UpdateOptsBuilder interface {
+	ToServiceUpdateMap() (map[string]any, error)
+}
+
 // UpdateOpts specifies the base attributes that may be updated on a service.
 type UpdateOpts struct {
 	// Status represents the new service status. One of enabled or disabled.
@@ -70,7 +76,7 @@ func (opts UpdateOpts) ToServiceUpdateMap() (map[string]any, error) {
 }
 
 // Update requests that various attributes of the indicated service be changed.
-func Update(ctx context.Context, client *gophercloud.ServiceClient, id string, opts UpdateOpts) (r UpdateResult) {
+func Update(ctx context.Context, client *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
 	b, err := opts.ToServiceUpdateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/config/clouds/clouds.go b/openstack/config/clouds/clouds.go
index e2310fbc1..146605809 100644
--- a/openstack/config/clouds/clouds.go
+++ b/openstack/config/clouds/clouds.go
@@ -40,7 +40,7 @@ import (
 //     clouds.yaml, use that location as the only search location for `clouds.yaml` and `secure.yaml`;
 //   - otherwise, the search locations for `clouds.yaml` and `secure.yaml` are:
 //     1. the current working directory (on Linux: `./`)
-//     2. the directory `openstack` under the standatd user config location for
+//     2. the directory `openstack` under the standard user config location for
 //     the operating system (on Linux: `${XDG_CONFIG_HOME:-$HOME/.config}/openstack/`)
 //     3. on Linux, `/etc/openstack/`
 //
diff --git a/openstack/dns/v2/zones/requests.go b/openstack/dns/v2/zones/requests.go
index b8ac4cf8a..b0049a914 100644
--- a/openstack/dns/v2/zones/requests.go
+++ b/openstack/dns/v2/zones/requests.go
@@ -179,6 +179,48 @@ func Delete(ctx context.Context, client *gophercloud.ServiceClient, zoneID strin
 	return
 }
 
+// ListSharesOptsBuilder allows extensions to add additional parameters to the List
+// request.
+type ListSharesOptsBuilder interface {
+	ToZoneListSharesHeadersMap() (map[string]string, error)
+}
+
+// ListSharesOpts is a structure that holds parameters for listing zone shares.
+type ListSharesOpts struct {
+	AllProjects bool `h:"X-Auth-All-Projects"`
+}
+
+// ToZoneListSharesHeadersMap formats a ListSharesOpts into header parameters.
+func (opts ListSharesOpts) ToZoneListSharesHeadersMap() (map[string]string, error) {
+	return gophercloud.BuildHeaders(opts)
+}
+
+// ListShares implements a zone list shares request.
+func ListShares(client *gophercloud.ServiceClient, zoneID string, opts ListSharesOptsBuilder) pagination.Pager {
+	var h map[string]string
+	var err error
+
+	if opts != nil {
+		h, err = opts.ToZoneListSharesHeadersMap()
+		if err != nil {
+			return pagination.Pager{Err: err}
+		}
+	}
+
+	pager := pagination.NewPager(client, sharesBaseURL(client, zoneID), func(r pagination.PageResult) pagination.Page {
+		return ZoneSharePage{pagination.LinkedPageBase{PageResult: r}}
+	})
+	pager.Headers = h
+	return pager
+}
+
+// GetShare returns information about a shared zone, given its ID.
+func GetShare(ctx context.Context, client *gophercloud.ServiceClient, zoneID, shareID string) (r ZoneShareResult) {
+	resp, err := client.Get(ctx, shareURL(client, zoneID, shareID), &r.Body, nil)
+	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
+	return
+}
+
 // request body for sharing a zone.
 type ShareOptsBuilder interface {
 	ToShareMap() (map[string]interface{}, error)
@@ -198,14 +240,14 @@ func (opts ShareZoneOpts) ToShareMap() (map[string]interface{}, error) {
 }
 
 // Share shares a zone with another project.
-func Share(ctx context.Context, client *gophercloud.ServiceClient, zoneID string, opts ShareOptsBuilder) (r gophercloud.ErrResult) {
+func Share(ctx context.Context, client *gophercloud.ServiceClient, zoneID string, opts ShareOptsBuilder) (r ZoneShareResult) {
 	body, err := gophercloud.BuildRequestBody(opts, "")
 	if err != nil {
 		r.Err = err
 		return
 	}
 
-	resp, err := client.Post(ctx, zoneShareURL(client, zoneID), body, nil, &gophercloud.RequestOpts{
+	resp, err := client.Post(ctx, sharesBaseURL(client, zoneID), body, &r.Body, &gophercloud.RequestOpts{
 		OkCodes: []int{201},
 	})
 	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
@@ -214,7 +256,7 @@ func Share(ctx context.Context, client *gophercloud.ServiceClient, zoneID string
 
 // Unshare removes a share for a zone.
 func Unshare(ctx context.Context, client *gophercloud.ServiceClient, zoneID, shareID string) (r gophercloud.ErrResult) {
-	resp, err := client.Delete(ctx, zoneUnshareURL(client, zoneID, shareID), &gophercloud.RequestOpts{
+	resp, err := client.Delete(ctx, shareURL(client, zoneID, shareID), &gophercloud.RequestOpts{
 		OkCodes: []int{204},
 	})
 	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
diff --git a/openstack/dns/v2/zones/results.go b/openstack/dns/v2/zones/results.go
index 7ccf5ace9..9b93e4f4b 100644
--- a/openstack/dns/v2/zones/results.go
+++ b/openstack/dns/v2/zones/results.go
@@ -173,3 +173,81 @@ func (r *Zone) UnmarshalJSON(b []byte) error {
 
 	return err
 }
+
+// ZoneShare represents a shared zone.
+type ZoneShare struct {
+	// ID uniquely identifies this zone share.
+	ID string `json:"id"`
+
+	// ZoneID is the ID of the zone being shared.
+	ZoneID string `json:"zone_id"`
+
+	// ProjectID is the ID of the project with which the zone is shared.
+	ProjectID string `json:"project_id"`
+
+	// TargetProjectID is the ID of the project with which the zone is shared.
+	TargetProjectID string `json:"target_project_id"`
+
+	// CreatedAt is the date when the zone share was created.
+	CreatedAt time.Time `json:"-"`
+
+	// UpdatedAt is the date when the zone share was last updated.
+	UpdatedAt time.Time `json:"-"`
+}
+
+func (r *ZoneShare) UnmarshalJSON(b []byte) error {
+	type tmp ZoneShare
+	var s struct {
+		tmp
+		CreatedAt gophercloud.JSONRFC3339MilliNoZ `json:"created_at"`
+		UpdatedAt gophercloud.JSONRFC3339MilliNoZ `json:"updated_at"`
+	}
+
+	err := json.Unmarshal(b, &s)
+	if err != nil {
+		return err
+	}
+	*r = ZoneShare(s.tmp)
+
+	r.CreatedAt = time.Time(s.CreatedAt)
+	r.UpdatedAt = time.Time(s.UpdatedAt)
+
+	return nil
+}
+
+// ZoneShareResult is the result of a GetZoneShare request.
+type ZoneShareResult struct {
+	gophercloud.Result
+}
+
+// Extract interprets a GetResult, CreateResult or UpdateResult as a Zone.
+// An error is returned if the original call or the extraction failed.
+func (r ZoneShareResult) Extract() (*ZoneShare, error) {
+	var s *ZoneShare
+	err := r.ExtractInto(&s)
+	return s, err
+}
+
+// ZoneSharePage is a single page of ZoneShare results.
+type ZoneSharePage struct {
+	pagination.LinkedPageBase
+}
+
+// IsEmpty returns true if the page contains no results.
+func (r ZoneSharePage) IsEmpty() (bool, error) {
+	if r.StatusCode == 204 {
+		return true, nil
+	}
+
+	s, err := ExtractZoneShares(r)
+	return len(s) == 0, err
+}
+
+// ExtractZoneShares extracts a slice of ZoneShares from a List result.
+func ExtractZoneShares(r pagination.Page) ([]ZoneShare, error) {
+	var s struct {
+		ZoneShares []ZoneShare `json:"shared_zones"`
+	}
+	err := (r.(ZoneSharePage)).ExtractInto(&s)
+	return s.ZoneShares, err
+}
diff --git a/openstack/dns/v2/zones/urls.go b/openstack/dns/v2/zones/urls.go
index ba156882f..99416a3e1 100644
--- a/openstack/dns/v2/zones/urls.go
+++ b/openstack/dns/v2/zones/urls.go
@@ -12,12 +12,12 @@ func zoneURL(c *gophercloud.ServiceClient, zoneID string) string {
 	return c.ServiceURL("zones", zoneID)
 }
 
-// zoneShareURL returns the URL for sharing a zone.
-func zoneShareURL(c *gophercloud.ServiceClient, zoneID string) string {
+// sharesBaseURL returns the URL for shared zones.
+func sharesBaseURL(c *gophercloud.ServiceClient, zoneID string) string {
 	return c.ServiceURL("zones", zoneID, "shares")
 }
 
-// zoneUnshareURL returns the URL for unsharing a zone.
-func zoneUnshareURL(c *gophercloud.ServiceClient, zoneID, shareID string) string {
-	return c.ServiceURL("zones", zoneID, "shares", shareID)
+// shareURL returns the URL for a shared zone.
+func shareURL(c *gophercloud.ServiceClient, zoneID, sharedZoneID string) string {
+	return c.ServiceURL("zones", zoneID, "shares", sharedZoneID)
 }
diff --git a/openstack/identity/v2/tenants/requests.go b/openstack/identity/v2/tenants/requests.go
index a08980df2..84a8b9df1 100644
--- a/openstack/identity/v2/tenants/requests.go
+++ b/openstack/identity/v2/tenants/requests.go
@@ -7,6 +7,12 @@ import (
 	"github.com/gophercloud/gophercloud/v2/pagination"
 )
 
+// ListOptsBuilder allows extensions to add additional parameters to the
+// List request.
+type ListOptsBuilder interface {
+	ToTenantListQuery() (string, error)
+}
+
 // ListOpts filters the Tenants that are returned by the List call.
 type ListOpts struct {
 	// Marker is the ID of the last Tenant on the previous page.
@@ -16,15 +22,21 @@ type ListOpts struct {
 	Limit int `q:"limit"`
 }
 
+// ToTenantListQuery formats a ListOpts into a query string.
+func (opts ListOpts) ToTenantListQuery() (string, error) {
+	q, err := gophercloud.BuildQueryString(opts)
+	return q.String(), err
+}
+
 // List enumerates the Tenants to which the current token has access.
-func List(client *gophercloud.ServiceClient, opts *ListOpts) pagination.Pager {
+func List(client *gophercloud.ServiceClient, opts ListOptsBuilder) pagination.Pager {
 	url := listURL(client)
 	if opts != nil {
-		q, err := gophercloud.BuildQueryString(opts)
+		query, err := opts.ToTenantListQuery()
 		if err != nil {
 			return pagination.Pager{Err: err}
 		}
-		url += q.String()
+		url += query
 	}
 	return pagination.NewPager(client, url, func(r pagination.PageResult) pagination.Page {
 		return TenantPage{pagination.LinkedPageBase{PageResult: r}}
diff --git a/openstack/identity/v3/ec2credentials/requests.go b/openstack/identity/v3/ec2credentials/requests.go
index aefb2b14b..df3c59aff 100644
--- a/openstack/identity/v3/ec2credentials/requests.go
+++ b/openstack/identity/v3/ec2credentials/requests.go
@@ -22,6 +22,12 @@ func Get(ctx context.Context, client *gophercloud.ServiceClient, userID string,
 	return
 }
 
+// CreateOptsBuilder allows extensions to add additional parameters to the
+// Create request.
+type CreateOptsBuilder interface {
+	ToCredentialCreateMap() (map[string]any, error)
+}
+
 // CreateOpts provides options used to create an EC2 credential.
 type CreateOpts struct {
 	// TenantID is the project ID scope of the EC2 credential.
@@ -34,7 +40,7 @@ func (opts CreateOpts) ToCredentialCreateMap() (map[string]any, error) {
 }
 
 // Create creates a new EC2 Credential.
-func Create(ctx context.Context, client *gophercloud.ServiceClient, userID string, opts CreateOpts) (r CreateResult) {
+func Create(ctx context.Context, client *gophercloud.ServiceClient, userID string, opts CreateOptsBuilder) (r CreateResult) {
 	b, err := opts.ToCredentialCreateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/identity/v3/oauth1/requests.go b/openstack/identity/v3/oauth1/requests.go
index 8c66b36e2..0b23269ff 100644
--- a/openstack/identity/v3/oauth1/requests.go
+++ b/openstack/identity/v3/oauth1/requests.go
@@ -214,6 +214,12 @@ func GetConsumer(ctx context.Context, client *gophercloud.ServiceClient, id stri
 	return
 }
 
+// UpdateConsumerOptsBuilder allows extensions to add additional parameters to the
+// UpdateConsumer request.
+type UpdateConsumerOptsBuilder interface {
+	ToOAuth1UpdateConsumerMap() (map[string]any, error)
+}
+
 // UpdateConsumerOpts provides options used to update a consumer.
 type UpdateConsumerOpts struct {
 	// Description is the consumer description.
@@ -227,7 +233,7 @@ func (opts UpdateConsumerOpts) ToOAuth1UpdateConsumerMap() (map[string]any, erro
 }
 
 // UpdateConsumer updates an existing Consumer.
-func UpdateConsumer(ctx context.Context, client *gophercloud.ServiceClient, id string, opts UpdateConsumerOpts) (r UpdateConsumerResult) {
+func UpdateConsumer(ctx context.Context, client *gophercloud.ServiceClient, id string, opts UpdateConsumerOptsBuilder) (r UpdateConsumerResult) {
 	b, err := opts.ToOAuth1UpdateConsumerMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/identity/v3/projects/requests.go b/openstack/identity/v3/projects/requests.go
index 30338fc51..6fb8448a9 100644
--- a/openstack/identity/v3/projects/requests.go
+++ b/openstack/identity/v3/projects/requests.go
@@ -276,8 +276,7 @@ func (opts ModifyTagsOpts) ToModifyTagsCreateMap() (map[string]any, error) {
 }
 
 // ModifyTags deletes all tags of a project and adds new ones.
-func ModifyTags(ctx context.Context, client *gophercloud.ServiceClient, projectID string, opts ModifyTagsOpts) (r ModifyTagsResult) {
-
+func ModifyTags(ctx context.Context, client *gophercloud.ServiceClient, projectID string, opts ModifyTagsOptsBuilder) (r ModifyTagsResult) {
 	b, err := opts.ToModifyTagsCreateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/identity/v3/users/results.go b/openstack/identity/v3/users/results.go
index dc48da2a2..d9e7aaab6 100644
--- a/openstack/identity/v3/users/results.go
+++ b/openstack/identity/v3/users/results.go
@@ -2,6 +2,8 @@ package users
 
 import (
 	"encoding/json"
+	"fmt"
+	"strconv"
 	"time"
 
 	"github.com/gophercloud/gophercloud/v2"
@@ -20,7 +22,7 @@ type User struct {
 	DomainID string `json:"domain_id"`
 
 	// Enabled is whether or not the user is enabled.
-	Enabled bool `json:"enabled"`
+	Enabled bool `json:"-"`
 
 	// Extra is a collection of miscellaneous key/values.
 	Extra map[string]any `json:"-"`
@@ -45,6 +47,7 @@ func (r *User) UnmarshalJSON(b []byte) error {
 	type tmp User
 	var s struct {
 		tmp
+		Enabled           any                             `json:"enabled"`
 		Extra             map[string]any                  `json:"extra"`
 		PasswordExpiresAt gophercloud.JSONRFC3339MilliNoZ `json:"password_expires_at"`
 	}
@@ -56,6 +59,20 @@ func (r *User) UnmarshalJSON(b []byte) error {
 
 	r.PasswordExpiresAt = time.Time(s.PasswordExpiresAt)
 
+	switch t := s.Enabled.(type) {
+	case nil:
+		r.Enabled = false
+	case bool:
+		r.Enabled = t
+	case string:
+		r.Enabled, err = strconv.ParseBool(t)
+		if err != nil {
+			return fmt.Errorf("Failed to parse Enabled %q: %v", t, err)
+		}
+	default:
+		return fmt.Errorf("Unknown type for Enabled: %T (value: %v)", t, t)
+	}
+
 	// Collect other fields and bundle them into Extra
 	// but only if a field titled "extra" wasn't sent.
 	if s.Extra != nil {
diff --git a/openstack/loadbalancer/v2/flavorprofiles/requests.go b/openstack/loadbalancer/v2/flavorprofiles/requests.go
index 3c764592c..a541c6c77 100644
--- a/openstack/loadbalancer/v2/flavorprofiles/requests.go
+++ b/openstack/loadbalancer/v2/flavorprofiles/requests.go
@@ -121,7 +121,7 @@ func (opts UpdateOpts) ToFlavorProfileUpdateMap() (map[string]any, error) {
 
 // Update is an operation which modifies the attributes of the specified
 // FlavorProfile.
-func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOpts) (r UpdateResult) {
+func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
 	b, err := opts.ToFlavorProfileUpdateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/loadbalancer/v2/flavors/requests.go b/openstack/loadbalancer/v2/flavors/requests.go
index 499bb3bd0..52c936269 100644
--- a/openstack/loadbalancer/v2/flavors/requests.go
+++ b/openstack/loadbalancer/v2/flavors/requests.go
@@ -127,7 +127,7 @@ func (opts UpdateOpts) ToFlavorUpdateMap() (map[string]any, error) {
 
 // Update is an operation which modifies the attributes of the specified
 // Flavor.
-func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOpts) (r UpdateResult) {
+func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
 	b, err := opts.ToFlavorUpdateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/loadbalancer/v2/l7policies/requests.go b/openstack/loadbalancer/v2/l7policies/requests.go
index 62a4f179e..ab0b22c6b 100644
--- a/openstack/loadbalancer/v2/l7policies/requests.go
+++ b/openstack/loadbalancer/v2/l7policies/requests.go
@@ -263,6 +263,12 @@ func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts U
 	return
 }
 
+// CreateRuleOptsBuilder allows extensions to add additional parameters to the
+// CreateRule request.
+type CreateRuleOptsBuilder interface {
+	ToRuleCreateMap() (map[string]any, error)
+}
+
 // CreateRuleOpts is the common options struct used in this package's CreateRule
 // operation.
 type CreateRuleOpts struct {
@@ -300,7 +306,7 @@ func (opts CreateRuleOpts) ToRuleCreateMap() (map[string]any, error) {
 }
 
 // CreateRule will create and associate a Rule with a particular L7Policy.
-func CreateRule(ctx context.Context, c *gophercloud.ServiceClient, policyID string, opts CreateRuleOpts) (r CreateRuleResult) {
+func CreateRule(ctx context.Context, c *gophercloud.ServiceClient, policyID string, opts CreateRuleOptsBuilder) (r CreateRuleResult) {
 	b, err := opts.ToRuleCreateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/loadbalancer/v2/listeners/requests.go b/openstack/loadbalancer/v2/listeners/requests.go
index 3216fbddd..abd5d0897 100644
--- a/openstack/loadbalancer/v2/listeners/requests.go
+++ b/openstack/loadbalancer/v2/listeners/requests.go
@@ -380,7 +380,7 @@ func (opts UpdateOpts) ToListenerUpdateMap() (map[string]any, error) {
 
 // Update is an operation which modifies the attributes of the specified
 // Listener.
-func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOpts) (r UpdateResult) {
+func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
 	b, err := opts.ToListenerUpdateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/loadbalancer/v2/loadbalancers/requests.go b/openstack/loadbalancer/v2/loadbalancers/requests.go
index f815806f3..095170edd 100644
--- a/openstack/loadbalancer/v2/loadbalancers/requests.go
+++ b/openstack/loadbalancer/v2/loadbalancers/requests.go
@@ -208,7 +208,7 @@ func (opts UpdateOpts) ToLoadBalancerUpdateMap() (map[string]any, error) {
 
 // Update is an operation which modifies the attributes of the specified
 // LoadBalancer.
-func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOpts) (r UpdateResult) {
+func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
 	b, err := opts.ToLoadBalancerUpdateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/loadbalancer/v2/monitors/requests.go b/openstack/loadbalancer/v2/monitors/requests.go
index be5701c5f..15a503bad 100644
--- a/openstack/loadbalancer/v2/monitors/requests.go
+++ b/openstack/loadbalancer/v2/monitors/requests.go
@@ -2,6 +2,7 @@ package monitors
 
 import (
 	"context"
+	"strconv"
 
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/pagination"
@@ -153,7 +154,25 @@ type CreateOpts struct {
 
 // ToMonitorCreateMap builds a request body from CreateOpts.
 func (opts CreateOpts) ToMonitorCreateMap() (map[string]any, error) {
-	return gophercloud.BuildRequestBody(opts, "healthmonitor")
+	b, err := gophercloud.BuildRequestBody(opts, "healthmonitor")
+	if err != nil {
+		return nil, err
+	}
+
+	if v, ok := b["healthmonitor"]; ok {
+		if m, ok := v.(map[string]any); ok {
+			if v, ok := m["http_version"]; ok {
+				if v, ok := v.(string); ok {
+					m["http_version"], err = strconv.ParseFloat(v, 64)
+					if err != nil {
+						return nil, err
+					}
+				}
+			}
+		}
+	}
+
+	return b, nil
 }
 
 /*
@@ -247,7 +266,25 @@ type UpdateOpts struct {
 
 // ToMonitorUpdateMap builds a request body from UpdateOpts.
 func (opts UpdateOpts) ToMonitorUpdateMap() (map[string]any, error) {
-	return gophercloud.BuildRequestBody(opts, "healthmonitor")
+	b, err := gophercloud.BuildRequestBody(opts, "healthmonitor")
+	if err != nil {
+		return nil, err
+	}
+
+	if v, ok := b["healthmonitor"]; ok {
+		if m, ok := v.(map[string]any); ok {
+			if v, ok := m["http_version"]; ok {
+				if v, ok := v.(string); ok {
+					m["http_version"], err = strconv.ParseFloat(v, 64)
+					if err != nil {
+						return nil, err
+					}
+				}
+			}
+		}
+	}
+
+	return b, nil
 }
 
 // Update is an operation which modifies the attributes of the specified
diff --git a/openstack/loadbalancer/v2/monitors/results.go b/openstack/loadbalancer/v2/monitors/results.go
index 644ef1870..6e8563faa 100644
--- a/openstack/loadbalancer/v2/monitors/results.go
+++ b/openstack/loadbalancer/v2/monitors/results.go
@@ -1,6 +1,9 @@
 package monitors
 
 import (
+	"encoding/json"
+	"strconv"
+
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 )
@@ -61,7 +64,7 @@ type Monitor struct {
 	HTTPMethod string `json:"http_method"`
 
 	// The HTTP version that the monitor uses for requests.
-	HTTPVersion string `json:"http_version"`
+	HTTPVersion string `json:"-"`
 
 	// The HTTP path of the request sent by the monitor to test the health of a
 	// member. Must be a string beginning with a forward slash (/).
@@ -96,6 +99,26 @@ type Monitor struct {
 	Tags []string `json:"tags"`
 }
 
+func (r *Monitor) UnmarshalJSON(b []byte) error {
+	type tmp Monitor
+	var s struct {
+		tmp
+		HTTPVersion float64 `json:"http_version"`
+	}
+
+	err := json.Unmarshal(b, &s)
+	if err != nil {
+		return err
+	}
+
+	*r = Monitor(s.tmp)
+	if s.HTTPVersion != 0 {
+		r.HTTPVersion = strconv.FormatFloat(s.HTTPVersion, 'f', 1, 64)
+	}
+
+	return nil
+}
+
 // MonitorPage is the page returned by a pager when traversing over a
 // collection of health monitors.
 type MonitorPage struct {
diff --git a/openstack/networking/v2/apiversions/constants.go b/openstack/networking/v2/apiversions/constants.go
new file mode 100644
index 000000000..2ffd32aa0
--- /dev/null
+++ b/openstack/networking/v2/apiversions/constants.go
@@ -0,0 +1,7 @@
+package apiversions
+
+const (
+	StatusCurrent    = "CURRENT"
+	StatusDeprecated = "DEPRECATED"
+	StatusStable     = "STABLE"
+)
diff --git a/openstack/networking/v2/extensions/bgp/peers/requests.go b/openstack/networking/v2/extensions/bgp/peers/requests.go
index eef38c0b7..589c4f7ad 100644
--- a/openstack/networking/v2/extensions/bgp/peers/requests.go
+++ b/openstack/networking/v2/extensions/bgp/peers/requests.go
@@ -43,7 +43,7 @@ func (opts CreateOpts) ToPeerCreateMap() (map[string]any, error) {
 }
 
 // Create a BGP Peer
-func Create(ctx context.Context, c *gophercloud.ServiceClient, opts CreateOpts) (r CreateResult) {
+func Create(ctx context.Context, c *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
 	b, err := opts.ToPeerCreateMap()
 	if err != nil {
 		r.Err = err
@@ -79,7 +79,7 @@ func (opts UpdateOpts) ToPeerUpdateMap() (map[string]any, error) {
 }
 
 // Update accept a BGP Peer ID and an UpdateOpts and update the BGP Peer
-func Update(ctx context.Context, c *gophercloud.ServiceClient, bgpPeerID string, opts UpdateOpts) (r UpdateResult) {
+func Update(ctx context.Context, c *gophercloud.ServiceClient, bgpPeerID string, opts UpdateOptsBuilder) (r UpdateResult) {
 	b, err := opts.ToPeerUpdateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/networking/v2/extensions/bgp/speakers/requests.go b/openstack/networking/v2/extensions/bgp/speakers/requests.go
index b6dd26d90..8597602a7 100644
--- a/openstack/networking/v2/extensions/bgp/speakers/requests.go
+++ b/openstack/networking/v2/extensions/bgp/speakers/requests.go
@@ -43,7 +43,7 @@ func (opts CreateOpts) ToSpeakerCreateMap() (map[string]any, error) {
 }
 
 // Create accepts a CreateOpts and create a BGP Speaker.
-func Create(ctx context.Context, c *gophercloud.ServiceClient, opts CreateOpts) (r CreateResult) {
+func Create(ctx context.Context, c *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
 	b, err := opts.ToSpeakerCreateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/networking/v2/extensions/bgpvpns/requests.go b/openstack/networking/v2/extensions/bgpvpns/requests.go
index 587961ede..374b4daf5 100644
--- a/openstack/networking/v2/extensions/bgpvpns/requests.go
+++ b/openstack/networking/v2/extensions/bgpvpns/requests.go
@@ -81,7 +81,7 @@ func (opts CreateOpts) ToBGPVPNCreateMap() (map[string]any, error) {
 }
 
 // Create a BGP VPN
-func Create(ctx context.Context, c *gophercloud.ServiceClient, opts CreateOpts) (r CreateResult) {
+func Create(ctx context.Context, c *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
 	b, err := opts.ToBGPVPNCreateMap()
 	if err != nil {
 		r.Err = err
@@ -121,7 +121,7 @@ func (opts UpdateOpts) ToBGPVPNUpdateMap() (map[string]any, error) {
 }
 
 // Update accept a BGP VPN ID and an UpdateOpts and update the BGP VPN
-func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOpts) (r UpdateResult) {
+func Update(ctx context.Context, c *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
 	b, err := opts.ToBGPVPNUpdateMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/networking/v2/extensions/layer3/floatingips/constants.go b/openstack/networking/v2/extensions/layer3/floatingips/constants.go
new file mode 100644
index 000000000..85dff7818
--- /dev/null
+++ b/openstack/networking/v2/extensions/layer3/floatingips/constants.go
@@ -0,0 +1,7 @@
+package floatingips
+
+const (
+	StatusActive = "ACTIVE"
+	StatusDown   = "DOWN"
+	StatusError  = "ERROR"
+)
diff --git a/openstack/networking/v2/extensions/layer3/routers/requests.go b/openstack/networking/v2/extensions/layer3/routers/requests.go
index f6ca65484..def4699db 100644
--- a/openstack/networking/v2/extensions/layer3/routers/requests.go
+++ b/openstack/networking/v2/extensions/layer3/routers/requests.go
@@ -8,6 +8,12 @@ import (
 	"github.com/gophercloud/gophercloud/v2/pagination"
 )
 
+// ListOptsBuilder allows extensions to add additional parameters to the List
+// request.
+type ListOptsBuilder interface {
+	ToRouterListQuery() (string, error)
+}
+
 // ListOpts allows the filtering and sorting of paginated collections through
 // the API. Filtering is achieved by passing in struct field values that map to
 // the floating IP attributes you want to see returned. SortKey allows you to
@@ -33,19 +39,31 @@ type ListOpts struct {
 	RevisionNumber *int   `q:"revision_number"`
 }
 
+// ToRouterListQuery formats a ListOpts into a query string.
+func (opts ListOpts) ToRouterListQuery() (string, error) {
+	q, err := gophercloud.BuildQueryString(&opts)
+	if err != nil {
+		return "", err
+	}
+	return q.String(), nil
+}
+
 // List returns a Pager which allows you to iterate over a collection of
 // routers. It accepts a ListOpts struct, which allows you to filter and sort
 // the returned collection for greater efficiency.
 //
 // Default policy settings return only those routers that are owned by the
 // tenant who submits the request, unless an admin user submits the request.
-func List(c *gophercloud.ServiceClient, opts ListOpts) pagination.Pager {
-	q, err := gophercloud.BuildQueryString(&opts)
-	if err != nil {
-		return pagination.Pager{Err: err}
+func List(c *gophercloud.ServiceClient, opts ListOptsBuilder) pagination.Pager {
+	url := rootURL(c)
+	if opts != nil {
+		query, err := opts.ToRouterListQuery()
+		if err != nil {
+			return pagination.Pager{Err: err}
+		}
+		url += query
 	}
-	u := rootURL(c) + q.String()
-	return pagination.NewPager(c, u, func(r pagination.PageResult) pagination.Page {
+	return pagination.NewPager(c, url, func(r pagination.PageResult) pagination.Page {
 		return RouterPage{pagination.LinkedPageBase{PageResult: r}}
 	})
 }
diff --git a/openstack/networking/v2/extensions/layer3/routers/results.go b/openstack/networking/v2/extensions/layer3/routers/results.go
index d75615b77..14845524c 100644
--- a/openstack/networking/v2/extensions/layer3/routers/results.go
+++ b/openstack/networking/v2/extensions/layer3/routers/results.go
@@ -122,11 +122,14 @@ func (r RouterPage) IsEmpty() (bool, error) {
 // and extracts the elements into a slice of Router structs. In other words,
 // a generic collection is mapped into a relevant slice.
 func ExtractRouters(r pagination.Page) ([]Router, error) {
-	var s struct {
-		Routers []Router `json:"routers"`
-	}
-	err := (r.(RouterPage)).ExtractInto(&s)
-	return s.Routers, err
+	var s []Router
+	err := ExtractRoutersInto(r, &s)
+	return s, err
+}
+
+// ExtractRoutersInto extracts the elements into a slice of Router structs.
+func ExtractRoutersInto(r pagination.Page, v any) error {
+	return r.(RouterPage).Result.ExtractIntoSlicePtr(v, "routers")
 }
 
 type commonResult struct {
diff --git a/openstack/networking/v2/extensions/qos/rules/doc.go b/openstack/networking/v2/extensions/qos/rules/doc.go
index f1c2d2672..f7d3b744a 100644
--- a/openstack/networking/v2/extensions/qos/rules/doc.go
+++ b/openstack/networking/v2/extensions/qos/rules/doc.go
@@ -76,7 +76,7 @@ Example of Deleting a single BandwidthLimitRule
 	policyID := "501005fa-3b56-4061-aaca-3f24995112e1"
 	ruleID   := "30a57f4a-336b-4382-8275-d708babd2241"
 
-	err := rules.DeleteBandwidthLimitRule(fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractErr()
+	err := rules.DeleteBandwidthLimitRule(fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractErr()
 	if err != nil {
 	    panic(err)
 	}
@@ -151,7 +151,7 @@ Example of Deleting a single DSCPMarkingRule
 	policyID := "501005fa-3b56-4061-aaca-3f24995112e1"
 	ruleID   := "30a57f4a-336b-4382-8275-d708babd2241"
 
-	err := rules.DeleteDSCPMarkingRule(fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractErr()
+	err := rules.DeleteDSCPMarkingRule(fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractErr()
 	if err != nil {
 	    panic(err)
 	}
@@ -228,7 +228,7 @@ Example of Deleting a single MinimumBandwidthRule
 	policyID := "501005fa-3b56-4061-aaca-3f24995112e1"
 	ruleID   := "30a57f4a-336b-4382-8275-d708babd2241"
 
-	err := rules.DeleteMinimumBandwidthRule(fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractErr()
+	err := rules.DeleteMinimumBandwidthRule(fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractErr()
 	if err != nil {
 	    panic(err)
 	}
diff --git a/openstack/networking/v2/extensions/security/rules/requests.go b/openstack/networking/v2/extensions/security/rules/requests.go
index f70456d18..a3c6a8a2e 100644
--- a/openstack/networking/v2/extensions/security/rules/requests.go
+++ b/openstack/networking/v2/extensions/security/rules/requests.go
@@ -7,6 +7,12 @@ import (
 	"github.com/gophercloud/gophercloud/v2/pagination"
 )
 
+// ListOptsBuilder allows extensions to add additional parameters to the List
+// request.
+type ListOptsBuilder interface {
+	ToSecGroupListQuery() (string, error)
+}
+
 // ListOpts allows the filtering and sorting of paginated collections through
 // the API. Filtering is achieved by passing in struct field values that map to
 // the security group rule attributes you want to see returned. SortKey allows
@@ -32,16 +38,28 @@ type ListOpts struct {
 	RevisionNumber *int   `q:"revision_number"`
 }
 
+// ToSecGroupListQuery formats a ListOpts into a query string.
+func (opts ListOpts) ToSecGroupListQuery() (string, error) {
+	q, err := gophercloud.BuildQueryString(&opts)
+	if err != nil {
+		return "", err
+	}
+	return q.String(), nil
+}
+
 // List returns a Pager which allows you to iterate over a collection of
 // security group rules. It accepts a ListOpts struct, which allows you to filter
 // and sort the returned collection for greater efficiency.
-func List(c *gophercloud.ServiceClient, opts ListOpts) pagination.Pager {
-	q, err := gophercloud.BuildQueryString(&opts)
-	if err != nil {
-		return pagination.Pager{Err: err}
+func List(c *gophercloud.ServiceClient, opts ListOptsBuilder) pagination.Pager {
+	url := rootURL(c)
+	if opts != nil {
+		query, err := opts.ToSecGroupListQuery()
+		if err != nil {
+			return pagination.Pager{Err: err}
+		}
+		url += query
 	}
-	u := rootURL(c) + q.String()
-	return pagination.NewPager(c, u, func(r pagination.PageResult) pagination.Page {
+	return pagination.NewPager(c, url, func(r pagination.PageResult) pagination.Page {
 		return SecGroupRulePage{pagination.LinkedPageBase{PageResult: r}}
 	})
 }
diff --git a/openstack/networking/v2/extensions/trunks/constants.go b/openstack/networking/v2/extensions/trunks/constants.go
new file mode 100644
index 000000000..6bec77fa7
--- /dev/null
+++ b/openstack/networking/v2/extensions/trunks/constants.go
@@ -0,0 +1,9 @@
+package trunks
+
+const (
+	StatusActive   = "ACTIVE"
+	StatusBuild    = "BUILD"
+	StatusDegraded = "DEGRADED"
+	StatusDown     = "DOWN"
+	StatusError    = "ERROR"
+)
diff --git a/openstack/networking/v2/extensions/vpnaas/services/constants.go b/openstack/networking/v2/extensions/vpnaas/services/constants.go
new file mode 100644
index 000000000..491708392
--- /dev/null
+++ b/openstack/networking/v2/extensions/vpnaas/services/constants.go
@@ -0,0 +1,11 @@
+package services
+
+const (
+	StatusActive        = "ACTIVE"
+	StatusBuild         = "BUILD"
+	StatusDown          = "DOWN"
+	StatusError         = "ERROR"
+	StatusPendingCreate = "PENDING_CREATE"
+	StatusPendingDelete = "PENDING_DELETE"
+	StatusPendingUpdate = "PENDING_UPDATE"
+)
diff --git a/openstack/networking/v2/extensions/vpnaas/siteconnections/constants.go b/openstack/networking/v2/extensions/vpnaas/siteconnections/constants.go
new file mode 100644
index 000000000..d4f4e0f44
--- /dev/null
+++ b/openstack/networking/v2/extensions/vpnaas/siteconnections/constants.go
@@ -0,0 +1,11 @@
+package siteconnections
+
+const (
+	StatusActive        = "ACTIVE"
+	StatusBuild         = "BUILD"
+	StatusDown          = "DOWN"
+	StatusError         = "ERROR"
+	StatusPendingCreate = "PENDING_CREATE"
+	StatusPendingDelete = "PENDING_DELETE"
+	StatusPendingUpdate = "PENDING_UPDATE"
+)
diff --git a/openstack/networking/v2/networks/constants.go b/openstack/networking/v2/networks/constants.go
new file mode 100644
index 000000000..1214ce9de
--- /dev/null
+++ b/openstack/networking/v2/networks/constants.go
@@ -0,0 +1,8 @@
+package networks
+
+const (
+	StatusActive = "ACTIVE"
+	StatusBuild  = "BUILD"
+	StatusDown   = "DOWN"
+	StatusError  = "ERROR"
+)
diff --git a/openstack/networking/v2/ports/constants.go b/openstack/networking/v2/ports/constants.go
new file mode 100644
index 000000000..6275839bf
--- /dev/null
+++ b/openstack/networking/v2/ports/constants.go
@@ -0,0 +1,8 @@
+package ports
+
+const (
+	StatusActive = "ACTIVE"
+	StatusBuild  = "BUILD"
+	StatusDown   = "DOWN"
+	StatusError  = "ERROR"
+)
diff --git a/openstack/sharedfilesystems/v2/sharetransfers/requests.go b/openstack/sharedfilesystems/v2/sharetransfers/requests.go
index 642d2a36d..88b1950eb 100644
--- a/openstack/sharedfilesystems/v2/sharetransfers/requests.go
+++ b/openstack/sharedfilesystems/v2/sharetransfers/requests.go
@@ -42,6 +42,12 @@ func Create(ctx context.Context, client *gophercloud.ServiceClient, opts CreateO
 	return
 }
 
+// AcceptOptsBuilder allows extensions to add additional parameters to the
+// Accept request.
+type AcceptOptsBuilder interface {
+	ToAcceptMap() (map[string]any, error)
+}
+
 // AcceptOpts contains options for a Share transfer accept reqeust.
 type AcceptOpts struct {
 	// The auth key of the share transfer to accept.
@@ -58,7 +64,7 @@ func (opts AcceptOpts) ToAcceptMap() (map[string]any, error) {
 }
 
 // Accept will accept a share tranfer request based on the values in AcceptOpts.
-func Accept(ctx context.Context, client *gophercloud.ServiceClient, id string, opts AcceptOpts) (r AcceptResult) {
+func Accept(ctx context.Context, client *gophercloud.ServiceClient, id string, opts AcceptOptsBuilder) (r AcceptResult) {
 	b, err := opts.ToAcceptMap()
 	if err != nil {
 		r.Err = err
diff --git a/openstack/workflow/v2/workflows/doc.go b/openstack/workflow/v2/workflows/doc.go
index 52638a346..bc82714a6 100644
--- a/openstack/workflow/v2/workflows/doc.go
+++ b/openstack/workflow/v2/workflows/doc.go
@@ -65,7 +65,7 @@ Create a workflow
 
 Delete a workflow
 
-	res := workflows.Delete(fake.ServiceClient(), "604a3a1e-94e3-4066-a34a-aa56873ef236")
+	res := workflows.Delete(fake.ServiceClient(fakeServer), "604a3a1e-94e3-4066-a34a-aa56873ef236")
 	if res.Err != nil {
 		panic(res.Err)
 	}
diff --git a/script/acceptancetest b/script/acceptancetest
deleted file mode 100755
index 7e223bae5..000000000
--- a/script/acceptancetest
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-#
-# Run acceptance tests.
-
-# We intentionally don't set '-u' (error on unbound variables) or '-e' (exit on
-# first failure) initially since DevStack is not designed to run with these
-# flags and things crash and burn *spectacularly* 🔥🔥🔥
-set -xo pipefail
-
-# shellcheck disable=SC1091
-source "$(dirname "$0")/stackenv"
-
-# ...but we can do it after the fact
-set -eu
-
-timeout="60m"
-
-LOG_DIR=${LOG_DIR:-}
-if [[ -z "${LOG_DIR}" ]]; then
-    echo "LOG_DIR not set, will set a temp directory"
-    LOG_DIR=/tmp/devstack-logs
-fi
-mkdir -p "${LOG_DIR}"
-
-# shellcheck disable=SC2068
-go test -v -timeout $timeout -tags "fixtures acceptance" "${PACKAGE:-./internal/acceptance/openstack/...}" $@ |& tee -a "${LOG_DIR}/acceptance_tests.log"
diff --git a/script/coverage b/script/coverage
deleted file mode 100755
index ec5b2776b..000000000
--- a/script/coverage
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-#
-# Run unit tests with coverage enabled.
-
-set -euxo pipefail
-
-n=1
-for testpkg in $(go list ./testing ./.../testing); do
-  covpkg="${testpkg/"/testing"/}"
-  go test -covermode count -coverprofile "testing_"$n.coverprofile -coverpkg "$covpkg" "$testpkg" 2>/dev/null
-  n=$((n+1))
-done
-
-base_pkg=$(go list)
-# Look for additional test files
-for path in $(find . -path '*/testing' -prune -o -path '*/internal' -prune -o -name '*_test.go' -exec dirname {} \; | uniq); do
-  pkg="${base_pkg}${path:1}"
-  go test -covermode count -coverprofile "testing_"$n.coverprofile -coverpkg "$pkg" "$pkg" 2>/dev/null
-  n=$((n+1))
-done
-
-# shellcheck disable=SC2046
-gocovmerge $(ls -- *.coverprofile) > cover.out
-rm ./*.coverprofile
diff --git a/script/format b/script/format
deleted file mode 100755
index 1bbf74ce3..000000000
--- a/script/format
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-#
-# Run 'go fmt' to warn about unformatted code
-
-set -euxo pipefail
-
-go fmt ./...
diff --git a/script/test b/script/test
deleted file mode 100755
index e71e7514b..000000000
--- a/script/test
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash
-#
-# Run all the tests.
-
-set -euxo pipefail
-
-# shellcheck disable=SC2068
-go test -v -tags 'acceptance fixtures' ./... $@
diff --git a/script/unittest b/script/unittest
deleted file mode 100755
index 1f1b1864f..000000000
--- a/script/unittest
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash
-#
-# Run the unit tests.
-
-set -euxo pipefail
-
-# Do extra rounds of testing to help identify reauth concurrency issues.
-# All other packages are tested in the `coverage` tests.
-# shellcheck disable=SC2068
-go test -v -race -count=5 ./testing $@
diff --git a/script/vet b/script/vet
deleted file mode 100755
index ecb74ef37..000000000
--- a/script/vet
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash
-#
-# Run go vet.
-
-set -euxo pipefail
-
-export GOFLAGS="-tags=acceptance"
-go vet ./...



Test patch:
diff --git a/docs/contributor-tutorial/.template/testing/requests_test.go b/docs/contributor-tutorial/.template/testing/requests_test.go
index c1766d862..f325d204d 100644
--- a/docs/contributor-tutorial/.template/testing/requests_test.go
+++ b/docs/contributor-tutorial/.template/testing/requests_test.go
@@ -16,7 +16,7 @@ func TestListResources(t *testing.T) {
 	HandleListResourcesSuccessfully(t)
 
 	count := 0
-	err := resources.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := resources.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := resources.ExtractResources(page)
@@ -35,7 +35,7 @@ func TestListResourcesAllPages(t *testing.T) {
 	defer th.TeardownHTTP()
 	HandleListResourcesSuccessfully(t)
 
-	allPages, err := resources.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := resources.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := resources.ExtractResources(allPages)
 	th.AssertNoErr(t, err)
@@ -47,7 +47,7 @@ func TestGetResource(t *testing.T) {
 	defer th.TeardownHTTP()
 	HandleGetResourceSuccessfully(t)
 
-	actual, err := resources.Get(context.TODO(), client.ServiceClient(), "9fe1d3").Extract()
+	actual, err := resources.Get(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, SecondResource, *actual)
 }
@@ -61,7 +61,7 @@ func TestCreateResource(t *testing.T) {
 		Name: "resource two",
 	}
 
-	actual, err := resources.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := resources.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, SecondResource, *actual)
 }
@@ -71,7 +71,7 @@ func TestDeleteResource(t *testing.T) {
 	defer th.TeardownHTTP()
 	HandleDeleteResourceSuccessfully(t)
 
-	res := resources.Delete(context.TODO(), client.ServiceClient(), "9fe1d3")
+	res := resources.Delete(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3")
 	th.AssertNoErr(t, res.Err)
 }
 
@@ -84,7 +84,7 @@ func TestUpdateResource(t *testing.T) {
 		Description: "Staging Resource",
 	}
 
-	actual, err := resources.Update(context.TODO(), client.ServiceClient(), "9fe1d3", updateOpts).Extract()
+	actual, err := resources.Update(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, SecondResourceUpdated, *actual)
 }
diff --git a/internal/acceptance/openstack/baremetal/httpbasic/allocations_test.go b/internal/acceptance/openstack/baremetal/httpbasic/allocations_test.go
index 932c067ad..faa667d05 100644
--- a/internal/acceptance/openstack/baremetal/httpbasic/allocations_test.go
+++ b/internal/acceptance/openstack/baremetal/httpbasic/allocations_test.go
@@ -15,7 +15,7 @@ import (
 
 func TestAllocationsCreateDestroy(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicHTTPBasic(t)
+	RequireIronicHTTPBasic(t)
 
 	client, err := clients.NewBareMetalV1HTTPBasic()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/baremetal/httpbasic/nodes_test.go b/internal/acceptance/openstack/baremetal/httpbasic/nodes_test.go
index e35ae1e25..a0c656d7f 100644
--- a/internal/acceptance/openstack/baremetal/httpbasic/nodes_test.go
+++ b/internal/acceptance/openstack/baremetal/httpbasic/nodes_test.go
@@ -16,7 +16,7 @@ import (
 
 func TestNodesCreateDestroy(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicHTTPBasic(t)
+	RequireIronicHTTPBasic(t)
 
 	client, err := clients.NewBareMetalV1HTTPBasic()
 	th.AssertNoErr(t, err)
@@ -49,7 +49,7 @@ func TestNodesCreateDestroy(t *testing.T) {
 
 func TestNodesUpdate(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicHTTPBasic(t)
+	RequireIronicHTTPBasic(t)
 
 	client, err := clients.NewBareMetalV1HTTPBasic()
 	th.AssertNoErr(t, err)
@@ -74,7 +74,7 @@ func TestNodesUpdate(t *testing.T) {
 func TestNodesRAIDConfig(t *testing.T) {
 	clients.SkipReleasesBelow(t, "stable/ussuri")
 	clients.RequireLong(t)
-	clients.RequireIronicHTTPBasic(t)
+	RequireIronicHTTPBasic(t)
 
 	client, err := clients.NewBareMetalV1HTTPBasic()
 	th.AssertNoErr(t, err)
@@ -104,7 +104,7 @@ func TestNodesRAIDConfig(t *testing.T) {
 func TestNodesFirmwareInterface(t *testing.T) {
 	clients.SkipReleasesBelow(t, "stable/2023.2")
 	clients.RequireLong(t)
-	clients.RequireIronicHTTPBasic(t)
+	RequireIronicHTTPBasic(t)
 
 	client, err := clients.NewBareMetalV1HTTPBasic()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/baremetal/httpbasic/portgroups_test.go b/internal/acceptance/openstack/baremetal/httpbasic/portgroups_test.go
index b3ed1948e..8db6da007 100644
--- a/internal/acceptance/openstack/baremetal/httpbasic/portgroups_test.go
+++ b/internal/acceptance/openstack/baremetal/httpbasic/portgroups_test.go
@@ -1,3 +1,5 @@
+//go:build acceptance || baremetal || portgroups
+
 package httpbasic
 
 import (
@@ -13,7 +15,7 @@ import (
 
 func TestPortGroupsCreateDestroy(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicHTTPBasic(t)
+	RequireIronicHTTPBasic(t)
 
 	client, err := clients.NewBareMetalV1HTTPBasic()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/baremetal/httpbasic/ports_test.go b/internal/acceptance/openstack/baremetal/httpbasic/ports_test.go
index 9912c4932..7773f8b23 100644
--- a/internal/acceptance/openstack/baremetal/httpbasic/ports_test.go
+++ b/internal/acceptance/openstack/baremetal/httpbasic/ports_test.go
@@ -16,7 +16,7 @@ import (
 
 func TestPortsCreateDestroy(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicHTTPBasic(t)
+	RequireIronicHTTPBasic(t)
 
 	client, err := clients.NewBareMetalV1HTTPBasic()
 	th.AssertNoErr(t, err)
@@ -52,7 +52,7 @@ func TestPortsCreateDestroy(t *testing.T) {
 
 func TestPortsUpdate(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicHTTPBasic(t)
+	RequireIronicHTTPBasic(t)
 
 	client, err := clients.NewBareMetalV1HTTPBasic()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/baremetal/noauth/allocations_test.go b/internal/acceptance/openstack/baremetal/noauth/allocations_test.go
index e6cb33ac3..d0b34737c 100644
--- a/internal/acceptance/openstack/baremetal/noauth/allocations_test.go
+++ b/internal/acceptance/openstack/baremetal/noauth/allocations_test.go
@@ -15,7 +15,7 @@ import (
 
 func TestAllocationsCreateDestroy(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicNoAuth(t)
+	RequireIronicNoAuth(t)
 
 	client, err := clients.NewBareMetalV1NoAuthClient()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/baremetal/noauth/nodes_test.go b/internal/acceptance/openstack/baremetal/noauth/nodes_test.go
index bd05203b2..64b9826a0 100644
--- a/internal/acceptance/openstack/baremetal/noauth/nodes_test.go
+++ b/internal/acceptance/openstack/baremetal/noauth/nodes_test.go
@@ -16,7 +16,7 @@ import (
 
 func TestNodesCreateDestroy(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicNoAuth(t)
+	RequireIronicNoAuth(t)
 
 	client, err := clients.NewBareMetalV1NoAuthClient()
 	th.AssertNoErr(t, err)
@@ -49,7 +49,7 @@ func TestNodesCreateDestroy(t *testing.T) {
 
 func TestNodesUpdate(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicNoAuth(t)
+	RequireIronicNoAuth(t)
 
 	client, err := clients.NewBareMetalV1NoAuthClient()
 	th.AssertNoErr(t, err)
@@ -74,7 +74,7 @@ func TestNodesUpdate(t *testing.T) {
 func TestNodesRAIDConfig(t *testing.T) {
 	clients.SkipReleasesBelow(t, "stable/ussuri")
 	clients.RequireLong(t)
-	clients.RequireIronicNoAuth(t)
+	RequireIronicNoAuth(t)
 
 	client, err := clients.NewBareMetalV1NoAuthClient()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/baremetal/noauth/portgroups_test.go b/internal/acceptance/openstack/baremetal/noauth/portgroups_test.go
index c4b95bba6..c3ed33cd6 100644
--- a/internal/acceptance/openstack/baremetal/noauth/portgroups_test.go
+++ b/internal/acceptance/openstack/baremetal/noauth/portgroups_test.go
@@ -1,3 +1,5 @@
+//go:build acceptance || baremetal || ports
+
 package noauth
 
 import (
diff --git a/internal/acceptance/openstack/baremetal/noauth/ports_test.go b/internal/acceptance/openstack/baremetal/noauth/ports_test.go
index 980b2dec3..3f10b3b85 100644
--- a/internal/acceptance/openstack/baremetal/noauth/ports_test.go
+++ b/internal/acceptance/openstack/baremetal/noauth/ports_test.go
@@ -16,7 +16,7 @@ import (
 
 func TestPortsCreateDestroy(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicNoAuth(t)
+	RequireIronicNoAuth(t)
 
 	client, err := clients.NewBareMetalV1NoAuthClient()
 	th.AssertNoErr(t, err)
@@ -52,7 +52,7 @@ func TestPortsCreateDestroy(t *testing.T) {
 
 func TestPortsUpdate(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireIronicNoAuth(t)
+	RequireIronicNoAuth(t)
 
 	client, err := clients.NewBareMetalV1NoAuthClient()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/baremetal/v1/portgroups_test.go b/internal/acceptance/openstack/baremetal/v1/portgroups_test.go
index 6f04223a0..968244c45 100644
--- a/internal/acceptance/openstack/baremetal/v1/portgroups_test.go
+++ b/internal/acceptance/openstack/baremetal/v1/portgroups_test.go
@@ -1,3 +1,5 @@
+//go:build acceptance || baremetal || portgroups
+
 package v1
 
 import (
diff --git a/internal/acceptance/openstack/blockstorage/noauth/snapshots_test.go b/internal/acceptance/openstack/blockstorage/noauth/snapshots_test.go
index 5b8bb2a98..f1daa352e 100644
--- a/internal/acceptance/openstack/blockstorage/noauth/snapshots_test.go
+++ b/internal/acceptance/openstack/blockstorage/noauth/snapshots_test.go
@@ -12,7 +12,7 @@ import (
 )
 
 func TestSnapshotsList(t *testing.T) {
-	clients.RequireCinderNoAuth(t)
+	RequireCinderNoAuth(t)
 
 	client, err := clients.NewBlockStorageV3NoAuthClient()
 	if err != nil {
@@ -35,7 +35,7 @@ func TestSnapshotsList(t *testing.T) {
 }
 
 func TestSnapshotsCreateDelete(t *testing.T) {
-	clients.RequireCinderNoAuth(t)
+	RequireCinderNoAuth(t)
 
 	client, err := clients.NewBlockStorageV3NoAuthClient()
 	if err != nil {
diff --git a/internal/acceptance/openstack/blockstorage/noauth/volumes_test.go b/internal/acceptance/openstack/blockstorage/noauth/volumes_test.go
index 0c993adda..15d481542 100644
--- a/internal/acceptance/openstack/blockstorage/noauth/volumes_test.go
+++ b/internal/acceptance/openstack/blockstorage/noauth/volumes_test.go
@@ -12,7 +12,7 @@ import (
 )
 
 func TestVolumesList(t *testing.T) {
-	clients.RequireCinderNoAuth(t)
+	RequireCinderNoAuth(t)
 
 	client, err := clients.NewBlockStorageV3NoAuthClient()
 	if err != nil {
@@ -35,7 +35,7 @@ func TestVolumesList(t *testing.T) {
 }
 
 func TestVolumesCreateDestroy(t *testing.T) {
-	clients.RequireCinderNoAuth(t)
+	RequireCinderNoAuth(t)
 
 	client, err := clients.NewBlockStorageV3NoAuthClient()
 	if err != nil {
diff --git a/internal/acceptance/openstack/blockstorage/v3/manageablevolumes_test.go b/internal/acceptance/openstack/blockstorage/v3/manageablevolumes_test.go
new file mode 100644
index 000000000..a555e706c
--- /dev/null
+++ b/internal/acceptance/openstack/blockstorage/v3/manageablevolumes_test.go
@@ -0,0 +1,57 @@
+//go:build acceptance || blockstorage || volumes
+
+package v3
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gophercloud/gophercloud/v2/internal/acceptance/clients"
+	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/volumes"
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
+)
+
+func TestManageableVolumes(t *testing.T) {
+	clients.RequireLong(t)
+
+	client, err := clients.NewBlockStorageV3Client()
+	th.AssertNoErr(t, err)
+
+	client.Microversion = "3.8"
+
+	volume1, err := CreateVolume(t, client)
+	th.AssertNoErr(t, err)
+
+	err = Unmanage(t, client, volume1)
+	if err != nil {
+		DeleteVolume(t, client, volume1)
+	}
+	th.AssertNoErr(t, err)
+
+	managed1, err := ManageExisting(t, client, volume1)
+	th.AssertNoErr(t, err)
+	defer DeleteVolume(t, client, managed1)
+
+	th.CheckEquals(t, volume1.Host, managed1.Host)
+	th.AssertEquals(t, volume1.Name, managed1.Name)
+	th.AssertEquals(t, volume1.AvailabilityZone, managed1.AvailabilityZone)
+	th.AssertEquals(t, volume1.Description, managed1.Description)
+	th.AssertEquals(t, volume1.VolumeType, managed1.VolumeType)
+	th.AssertEquals(t, volume1.Bootable, managed1.Bootable)
+	th.AssertDeepEquals(t, volume1.Metadata, managed1.Metadata)
+	th.AssertEquals(t, volume1.Size, managed1.Size)
+
+	allPages, err := volumes.List(client, volumes.ListOpts{}).AllPages(context.TODO())
+	th.AssertNoErr(t, err)
+	allVolumes, err := volumes.ExtractVolumes(allPages)
+	th.AssertNoErr(t, err)
+
+	var found bool
+	for _, v := range allVolumes {
+		if v.ID == managed1.ID {
+			found = true
+			break
+		}
+	}
+	th.AssertEquals(t, true, found)
+}
diff --git a/internal/acceptance/openstack/client_test.go b/internal/acceptance/openstack/client_test.go
index 69e9a0936..3b252a285 100644
--- a/internal/acceptance/openstack/client_test.go
+++ b/internal/acceptance/openstack/client_test.go
@@ -36,14 +36,14 @@ func TestAuthenticatedClient(t *testing.T) {
 
 	t.Logf("Client successfully acquired a token: %v", client.TokenID)
 
-	// Find the storage service in the service catalog.
-	storage, err := openstack.NewObjectStorageV1(client, gophercloud.EndpointOpts{
+	// Find the compute service in the service catalog.
+	compute, err := openstack.NewComputeV2(client, gophercloud.EndpointOpts{
 		Region: os.Getenv("OS_REGION_NAME"),
 	})
 	if err != nil {
-		t.Errorf("Unable to locate a storage service: %v", err)
+		t.Errorf("Unable to locate a compute service: %v", err)
 	} else {
-		t.Logf("Located a storage service at endpoint: [%s]", storage.Endpoint)
+		t.Logf("Located a compute service at endpoint: [%s]", compute.Endpoint)
 	}
 }
 
diff --git a/internal/acceptance/openstack/compute/v2/migrate_test.go b/internal/acceptance/openstack/compute/v2/migrate_test.go
index f22d6e67c..6db845c0b 100644
--- a/internal/acceptance/openstack/compute/v2/migrate_test.go
+++ b/internal/acceptance/openstack/compute/v2/migrate_test.go
@@ -31,7 +31,7 @@ func TestMigrate(t *testing.T) {
 func TestLiveMigrate(t *testing.T) {
 	clients.RequireLong(t)
 	clients.RequireAdmin(t)
-	clients.RequireLiveMigration(t)
+	RequireLiveMigration(t)
 
 	client, err := clients.NewComputeV2Client()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/compute/v2/servers_test.go b/internal/acceptance/openstack/compute/v2/servers_test.go
index 67ef63028..7f769e6e9 100644
--- a/internal/acceptance/openstack/compute/v2/servers_test.go
+++ b/internal/acceptance/openstack/compute/v2/servers_test.go
@@ -234,7 +234,7 @@ func TestServersMetadata(t *testing.T) {
 
 func TestServersActionChangeAdminPassword(t *testing.T) {
 	clients.RequireLong(t)
-	clients.RequireGuestAgent(t)
+	RequireGuestAgent(t)
 
 	client, err := clients.NewComputeV2Client()
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/dns/v2/shares_test.go b/internal/acceptance/openstack/dns/v2/shares_test.go
new file mode 100644
index 000000000..496ee8f1b
--- /dev/null
+++ b/internal/acceptance/openstack/dns/v2/shares_test.go
@@ -0,0 +1,66 @@
+//go:build acceptance || dns || zone_shares
+
+package v2
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gophercloud/gophercloud/v2/internal/acceptance/clients"
+	identity "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/identity/v3"
+	"github.com/gophercloud/gophercloud/v2/internal/acceptance/tools"
+	"github.com/gophercloud/gophercloud/v2/openstack/dns/v2/zones"
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
+)
+
+func TestShareCRD(t *testing.T) {
+	// Create new project
+	identityClient, err := clients.NewIdentityV3Client()
+	th.AssertNoErr(t, err)
+
+	project, err := identity.CreateProject(t, identityClient, nil)
+	th.AssertNoErr(t, err)
+	defer identity.DeleteProject(t, identityClient, project.ID)
+
+	// Create new Zone
+	client, err := clients.NewDNSV2Client()
+	th.AssertNoErr(t, err)
+
+	zone, err := CreateZone(t, client)
+	th.AssertNoErr(t, err)
+	defer DeleteZone(t, client, zone)
+
+	// Create a zone share to new tenant
+	share, err := CreateShare(t, client, zone, project.ID)
+	th.AssertNoErr(t, err)
+	tools.PrintResource(t, share)
+	defer UnshareZone(t, client, share)
+
+	// Get the share
+	getShare, err := zones.GetShare(context.TODO(), client, share.ZoneID, share.ID).Extract()
+	th.AssertNoErr(t, err)
+	tools.PrintResource(t, getShare)
+	th.AssertDeepEquals(t, *share, *getShare)
+
+	// List shares
+	allPages, err := zones.ListShares(client, share.ZoneID, nil).AllPages(context.TODO())
+	th.AssertNoErr(t, err)
+
+	allShares, err := zones.ExtractZoneShares(allPages)
+	th.AssertNoErr(t, err)
+	tools.PrintResource(t, allShares)
+
+	foundShare := -1
+	for i, s := range allShares {
+		tools.PrintResource(t, &s)
+		if share.ID == s.ID {
+			foundShare = i
+			break
+		}
+	}
+	if foundShare == -1 {
+		t.Fatalf("Share %s not found in list", share.ID)
+	}
+
+	th.AssertDeepEquals(t, *share, allShares[foundShare])
+}
diff --git a/internal/acceptance/openstack/identity/v2/extension_test.go b/internal/acceptance/openstack/identity/v2/extension_test.go
index ada4ddef4..f43523340 100644
--- a/internal/acceptance/openstack/identity/v2/extension_test.go
+++ b/internal/acceptance/openstack/identity/v2/extension_test.go
@@ -13,7 +13,7 @@ import (
 )
 
 func TestExtensionsList(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2Client()
@@ -37,7 +37,7 @@ func TestExtensionsList(t *testing.T) {
 }
 
 func TestExtensionsGet(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2Client()
diff --git a/internal/acceptance/openstack/identity/v2/role_test.go b/internal/acceptance/openstack/identity/v2/role_test.go
index 2eed42a3c..49635f7f9 100644
--- a/internal/acceptance/openstack/identity/v2/role_test.go
+++ b/internal/acceptance/openstack/identity/v2/role_test.go
@@ -14,7 +14,7 @@ import (
 )
 
 func TestRolesAddToUser(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2AdminClient()
@@ -53,7 +53,7 @@ func TestRolesAddToUser(t *testing.T) {
 }
 
 func TestRolesList(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2AdminClient()
diff --git a/internal/acceptance/openstack/identity/v2/tenant_test.go b/internal/acceptance/openstack/identity/v2/tenant_test.go
index d390f14d3..2c7092e91 100644
--- a/internal/acceptance/openstack/identity/v2/tenant_test.go
+++ b/internal/acceptance/openstack/identity/v2/tenant_test.go
@@ -13,7 +13,7 @@ import (
 )
 
 func TestTenantsList(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2Client()
@@ -38,7 +38,7 @@ func TestTenantsList(t *testing.T) {
 }
 
 func TestTenantsCRUD(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2AdminClient()
diff --git a/internal/acceptance/openstack/identity/v2/token_test.go b/internal/acceptance/openstack/identity/v2/token_test.go
index fba2dbc0a..61d93f218 100644
--- a/internal/acceptance/openstack/identity/v2/token_test.go
+++ b/internal/acceptance/openstack/identity/v2/token_test.go
@@ -14,7 +14,7 @@ import (
 )
 
 func TestTokenAuthenticate(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2UnauthenticatedClient()
@@ -38,7 +38,7 @@ func TestTokenAuthenticate(t *testing.T) {
 }
 
 func TestTokenValidate(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2Client()
diff --git a/internal/acceptance/openstack/identity/v2/user_test.go b/internal/acceptance/openstack/identity/v2/user_test.go
index f54e218d3..e0f614e51 100644
--- a/internal/acceptance/openstack/identity/v2/user_test.go
+++ b/internal/acceptance/openstack/identity/v2/user_test.go
@@ -13,7 +13,7 @@ import (
 )
 
 func TestUsersList(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2AdminClient()
@@ -38,7 +38,7 @@ func TestUsersList(t *testing.T) {
 }
 
 func TestUsersCreateUpdateDelete(t *testing.T) {
-	clients.RequireIdentityV2(t)
+	RequireIdentityV2(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewIdentityV2AdminClient()
diff --git a/internal/acceptance/openstack/networking/v2/extensions/agents/agents_test.go b/internal/acceptance/openstack/networking/v2/extensions/agents/agents_test.go
index 37b5e39c3..fd1cf3f54 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/agents/agents_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/agents/agents_test.go
@@ -16,8 +16,8 @@ import (
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
 )
 
-func TestAgentsRUD(t *testing.T) {
-	t.Skip("TestAgentsRUD needs to be re-worked to work with both ML2/OVS and OVN")
+func TestAgentsCRUD(t *testing.T) {
+	t.Skip("TestAgentsCRUD needs to be re-worked to work with both ML2/OVS and OVN")
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewNetworkV2Client()
@@ -96,13 +96,16 @@ func TestAgentsRUD(t *testing.T) {
 	th.AssertNoErr(t, err)
 }
 
-func TestBGPAgentRUD(t *testing.T) {
-	timeout := 15 * time.Minute
+func TestBGPAgentCRUD(t *testing.T) {
+	timeout := 120 * time.Second
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "bgp")
+
 	// List BGP Agents
 	listOpts := &agents.ListOpts{
 		AgentType: "BGP Dynamic Routing Agent",
@@ -119,86 +122,73 @@ func TestBGPAgentRUD(t *testing.T) {
 	// Create a BGP Speaker
 	bgpSpeaker, err := spk.CreateBGPSpeaker(t, client)
 	th.AssertNoErr(t, err)
+
+	// List BGP Speaker-Agent associations
 	pages, err := agents.ListDRAgentHostingBGPSpeakers(client, bgpSpeaker.ID).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
-	bgpAgents, err := agents.ExtractAgents(pages)
-	th.AssertNoErr(t, err)
-	th.AssertIntGreaterOrEqual(t, len(bgpAgents), 1)
-
-	// List the BGP Agents that accommodate the BGP Speaker
-	err = tools.WaitForTimeout(
-		func(ctx context.Context) (bool, error) {
-			flag := true
-			for _, agt := range bgpAgents {
-				t.Logf("BGP Speaker %s has been scheduled to agent %s", bgpSpeaker.ID, agt.ID)
-				bgpAgent, err := agents.Get(ctx, client, agt.ID).Extract()
-				th.AssertNoErr(t, err)
-				numOfSpeakers := int(bgpAgent.Configurations["bgp_speakers"].(float64))
-				flag = flag && (numOfSpeakers == 1)
-			}
-			return flag, nil
-		}, timeout)
+	bgpAgentsForSpeaker, err := agents.ExtractAgents(pages)
 	th.AssertNoErr(t, err)
 
-	// List the BGP speakers on the first agent
-	bgpAgent, err := agents.Get(context.TODO(), client, bgpAgents[0].ID).Extract()
-	th.AssertNoErr(t, err)
-	agentConf := bgpAgent.Configurations
-	numOfSpeakers := int(agentConf["bgp_speakers"].(float64))
-	t.Logf("Agent %s has %d speaker(s)", bgpAgents[0].ID, numOfSpeakers)
+	// If there are no associations, we can assume the static scheduler is in
+	// effect and we must manually associate/disassociate the speaker from the
+	// agent.
+	//
+	// https://docs.openstack.org/neutron-dynamic-routing/latest/admin/agent-scheduler.html
+	doManualAssignment := len(bgpAgentsForSpeaker) == 0
+	var agentID string
 
-	pages, err = agents.ListBGPSpeakers(client, bgpAgents[0].ID).AllPages(context.TODO())
-	th.AssertNoErr(t, err)
-	allSpeakers, err := agents.ExtractBGPSpeakers(pages)
-	th.AssertNoErr(t, err)
-	out := "Speakers:"
-	for _, speaker := range allSpeakers {
-		out += " " + speaker.ID
+	if doManualAssignment {
+		// If using manual assignment, schedule a BGP Speaker to an agent
+		agentID = allAgents[0].ID
+		opts := agents.ScheduleBGPSpeakerOpts{
+			SpeakerID: bgpSpeaker.ID,
+		}
+		err = agents.ScheduleBGPSpeaker(context.TODO(), client, agentID, opts).ExtractErr()
+		th.AssertNoErr(t, err)
+		t.Logf("Successfully scheduled speaker %s to agent %s", bgpSpeaker.ID, agentID)
+	} else {
+		// If using automatic assignment, pick the first agent that the speaker
+		// was assigned to (it may be assigned to many, depending on how many
+		// nodes there are)
+		agentID = bgpAgentsForSpeaker[0].ID
 	}
-	t.Log(out)
 
-	// Remove the BGP Speaker from the first agent
-	err = agents.RemoveBGPSpeaker(context.TODO(), client, bgpAgents[0].ID, bgpSpeaker.ID).ExtractErr()
+	// Wait for the association to complete.
+	pages, err = agents.ListDRAgentHostingBGPSpeakers(client, bgpSpeaker.ID).AllPages(context.TODO())
+	th.AssertNoErr(t, err)
+	bgpAgentsForSpeaker, err = agents.ExtractAgents(pages)
 	th.AssertNoErr(t, err)
-	t.Logf("BGP Speaker %s has been removed from agent %s", bgpSpeaker.ID, bgpAgents[0].ID)
 	err = tools.WaitForTimeout(
 		func(ctx context.Context) (bool, error) {
-			bgpAgent, err := agents.Get(ctx, client, bgpAgents[0].ID).Extract()
+			bgpAgent, err := agents.Get(ctx, client, agentID).Extract()
 			th.AssertNoErr(t, err)
 			agentConf := bgpAgent.Configurations
 			numOfSpeakers := int(agentConf["bgp_speakers"].(float64))
-			t.Logf("Agent %s has %d speaker(s)", bgpAgent.ID, numOfSpeakers)
-			return numOfSpeakers == 0, nil
+			t.Logf("Agent %s has %d speaker(s)", agentID, numOfSpeakers)
+			return 1 == numOfSpeakers, nil
 		}, timeout)
 	th.AssertNoErr(t, err)
 
-	// Remove all BGP Speakers from the agent
-	pages, err = agents.ListBGPSpeakers(client, bgpAgents[0].ID).AllPages(context.TODO())
+	// Disassociate the BGP Speaker from the agent.
+	err = agents.RemoveBGPSpeaker(context.TODO(), client, bgpAgentsForSpeaker[0].ID, bgpSpeaker.ID).ExtractErr()
 	th.AssertNoErr(t, err)
-	allSpeakers, err = agents.ExtractBGPSpeakers(pages)
-	th.AssertNoErr(t, err)
-	for _, speaker := range allSpeakers {
-		th.AssertNoErr(t, agents.RemoveBGPSpeaker(context.TODO(), client, bgpAgents[0].ID, speaker.ID).ExtractErr())
-	}
+	t.Logf("BGP Speaker %s has been removed from agent %s", bgpSpeaker.ID, bgpAgentsForSpeaker[0].ID)
 
-	// Schedule a BGP Speaker to an agent
-	opts := agents.ScheduleBGPSpeakerOpts{
-		SpeakerID: bgpSpeaker.ID,
+	// Only validate the disassociation if we know the static scheduler is in
+	// effect as it'll simply be recreated if we're using the chance scheduler
+	// and running in a single node deployment.
+	if doManualAssignment {
+		err = tools.WaitForTimeout(
+			func(ctx context.Context) (bool, error) {
+				bgpAgent, err := agents.Get(ctx, client, bgpAgentsForSpeaker[0].ID).Extract()
+				th.AssertNoErr(t, err)
+				agentConf := bgpAgent.Configurations
+				numOfSpeakers := int(agentConf["bgp_speakers"].(float64))
+				t.Logf("Agent %s has %d speaker(s)", bgpAgent.ID, numOfSpeakers)
+				return numOfSpeakers == 0, nil
+			}, timeout)
+		th.AssertNoErr(t, err)
 	}
-	err = agents.ScheduleBGPSpeaker(context.TODO(), client, bgpAgents[0].ID, opts).ExtractErr()
-	th.AssertNoErr(t, err)
-	t.Logf("Successfully scheduled speaker %s to agent %s", bgpSpeaker.ID, bgpAgents[0].ID)
-
-	err = tools.WaitForTimeout(
-		func(ctx context.Context) (bool, error) {
-			bgpAgent, err := agents.Get(ctx, client, bgpAgents[0].ID).Extract()
-			th.AssertNoErr(t, err)
-			agentConf := bgpAgent.Configurations
-			numOfSpeakers := int(agentConf["bgp_speakers"].(float64))
-			t.Logf("Agent %s has %d speaker(s)", bgpAgent.ID, numOfSpeakers)
-			return 1 == numOfSpeakers, nil
-		}, timeout)
-	th.AssertNoErr(t, err)
 
 	// Delete the BGP Speaker
 	err = speakers.Delete(context.TODO(), client, bgpSpeaker.ID).ExtractErr()
@@ -206,7 +196,7 @@ func TestBGPAgentRUD(t *testing.T) {
 	t.Logf("Successfully deleted the BGP Speaker, %s", bgpSpeaker.ID)
 	err = tools.WaitForTimeout(
 		func(ctx context.Context) (bool, error) {
-			bgpAgent, err := agents.Get(ctx, client, bgpAgents[0].ID).Extract()
+			bgpAgent, err := agents.Get(ctx, client, agentID).Extract()
 			th.AssertNoErr(t, err)
 			agentConf := bgpAgent.Configurations
 			numOfSpeakers := int(agentConf["bgp_speakers"].(float64))
diff --git a/internal/acceptance/openstack/networking/v2/extensions/bgp/peers/bgppeers_test.go b/internal/acceptance/openstack/networking/v2/extensions/bgp/peers/bgppeers_test.go
index 8fdee3c03..baad9a8a5 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/bgp/peers/bgppeers_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/bgp/peers/bgppeers_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/clients"
+	networking "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2"
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/tools"
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/extensions/bgp/peers"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
@@ -18,6 +19,9 @@ func TestBGPPeerCRUD(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "bgp")
+
 	// Create a BGP Peer
 	bgpPeerCreated, err := CreateBGPPeer(t, client)
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/networking/v2/extensions/bgp/speakers/bgpspeakers_test.go b/internal/acceptance/openstack/networking/v2/extensions/bgp/speakers/bgpspeakers_test.go
index 5b50d6df5..2ab5584d5 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/bgp/speakers/bgpspeakers_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/bgp/speakers/bgpspeakers_test.go
@@ -17,9 +17,13 @@ import (
 
 func TestBGPSpeakerCRUD(t *testing.T) {
 	clients.RequireAdmin(t)
+
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "bgp")
+
 	// Create a BGP Speaker
 	bgpSpeaker, err := CreateBGPSpeaker(t, client)
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/networking/v2/extensions/bgpvpns/bgpvpns_test.go b/internal/acceptance/openstack/networking/v2/extensions/bgpvpns/bgpvpns_test.go
index 01542d6ec..3c915901e 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/bgpvpns/bgpvpns_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/bgpvpns/bgpvpns_test.go
@@ -20,6 +20,9 @@ func TestBGPVPNCRUD(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "bgpvpn")
+
 	// Create a BGP VPN
 	bgpVpnCreated, err := CreateBGPVPN(t, client)
 	th.AssertNoErr(t, err)
@@ -60,12 +63,15 @@ func TestBGPVPNCRUD(t *testing.T) {
 	t.Logf("BGP VPN %s deleted", bgpVpnUpdated.Name)
 }
 
-func TestBGPVPNNetworkAssociationCRD(t *testing.T) {
+func TestBGPVPNNetworkAssociationCRUD(t *testing.T) {
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "bgpvpn")
+
 	// Create a BGP VPN
 	bgpVpnCreated, err := CreateBGPVPN(t, client)
 	th.AssertNoErr(t, err)
@@ -117,6 +123,9 @@ func TestBGPVPNRouterAssociationCRUD(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "bgpvpn")
+
 	// Create a BGP VPN
 	bgpVpnCreated, err := CreateBGPVPN(t, client)
 	th.AssertNoErr(t, err)
@@ -182,6 +191,9 @@ func TestBGPVPNPortAssociationCRUD(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "bgpvpn")
+
 	// Create a BGP VPN
 	bgpVpnCreated, err := CreateBGPVPN(t, client)
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/networking/v2/extensions/dns/dns_test.go b/internal/acceptance/openstack/networking/v2/extensions/dns/dns_test.go
index d709a4252..fd239f8a4 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/dns/dns_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/dns/dns_test.go
@@ -141,8 +141,8 @@ func TestDNSPortCRUDL(t *testing.T) {
 	th.AssertDeepEquals(t, newPort, getNewPort)
 }
 
-func TestDNSFloatingIPCRDL(t *testing.T) {
-	t.Skip("Skipping TestDNSFloatingIPCRDL for now, as it doesn't work with ML2/OVN.")
+func TestDNSFloatingIPCRUD(t *testing.T) {
+	t.Skip("Skipping TestDNSFloatingIPCRUD for now, as it doesn't work with ML2/OVN.")
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewNetworkV2Client()
diff --git a/internal/acceptance/openstack/networking/v2/extensions/layer3/portforwardings_test.go b/internal/acceptance/openstack/networking/v2/extensions/layer3/portforwardings_test.go
index 3d3f20852..6811d472f 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/layer3/portforwardings_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/layer3/portforwardings_test.go
@@ -15,11 +15,11 @@ import (
 )
 
 func TestLayer3PortForwardingsCreateDelete(t *testing.T) {
-	clients.RequirePortForwarding(t)
-
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	networking.RequireNeutronExtension(t, client, "floating-ip-port-forwarding")
+
 	choices, err := clients.AcceptanceTestChoicesFromEnv()
 	th.AssertNoErr(t, err)
 
diff --git a/internal/acceptance/openstack/networking/v2/extensions/mtu/mtu_test.go b/internal/acceptance/openstack/networking/v2/extensions/mtu/mtu_test.go
index a71c96cc4..63e4f7790 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/mtu/mtu_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/mtu/mtu_test.go
@@ -16,7 +16,7 @@ import (
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
 )
 
-func TestMTUNetworkCRUDL(t *testing.T) {
+func TestMTUNetworkCRUD(t *testing.T) {
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewNetworkV2Client()
diff --git a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/group_test.go b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/group_test.go
index 8fe5e0638..862324736 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/group_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/group_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/clients"
+	networking "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2"
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/tools"
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/extensions/vpnaas/endpointgroups"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
@@ -16,6 +17,9 @@ func TestGroupList(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	allPages, err := endpointgroups.List(client, nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
@@ -31,6 +35,9 @@ func TestGroupCRUD(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	group, err := CreateEndpointGroup(t, client)
 	th.AssertNoErr(t, err)
 	defer DeleteEndpointGroup(t, client, group.ID)
diff --git a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/ikepolicy_test.go b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/ikepolicy_test.go
index c0407c99a..eeb573edf 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/ikepolicy_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/ikepolicy_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/clients"
+	networking "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2"
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/tools"
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/extensions/vpnaas/ikepolicies"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
@@ -16,6 +17,9 @@ func TestIKEPolicyList(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	allPages, err := ikepolicies.List(client, nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
@@ -31,6 +35,9 @@ func TestIKEPolicyCRUD(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	policy, err := CreateIKEPolicy(t, client)
 	th.AssertNoErr(t, err)
 	defer DeleteIKEPolicy(t, client, policy.ID)
diff --git a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/ipsecpolicy_test.go b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/ipsecpolicy_test.go
index f9aed9b2a..74dc5a375 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/ipsecpolicy_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/ipsecpolicy_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/clients"
+	networking "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2"
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/tools"
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/extensions/vpnaas/ipsecpolicies"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
@@ -16,6 +17,9 @@ func TestIPSecPolicyList(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	allPages, err := ipsecpolicies.List(client, nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
@@ -31,6 +35,9 @@ func TestIPSecPolicyCRUD(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	policy, err := CreateIPSecPolicy(t, client)
 	th.AssertNoErr(t, err)
 	defer DeleteIPSecPolicy(t, client, policy.ID)
diff --git a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/service_test.go b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/service_test.go
index 2ac1c7734..b932dbdeb 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/service_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/service_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/clients"
+	networking "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2"
 	layer3 "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2/extensions/layer3"
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/tools"
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/extensions/vpnaas/services"
@@ -17,6 +18,9 @@ func TestServiceList(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	allPages, err := services.List(client, nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
@@ -29,10 +33,15 @@ func TestServiceList(t *testing.T) {
 }
 
 func TestServiceCRUD(t *testing.T) {
+	// TODO(stephenfin): Why are we skipping this? Can we unskip? If not, we should remove.
 	clients.SkipReleasesAbove(t, "stable/wallaby")
+
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	router, err := layer3.CreateExternalRouter(t, client)
 	th.AssertNoErr(t, err)
 	defer layer3.DeleteRouter(t, client, router.ID)
diff --git a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/siteconnection_test.go b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/siteconnection_test.go
index 8aa8e49f5..68a7f4519 100644
--- a/internal/acceptance/openstack/networking/v2/extensions/vpnaas/siteconnection_test.go
+++ b/internal/acceptance/openstack/networking/v2/extensions/vpnaas/siteconnection_test.go
@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/clients"
-	networks "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2"
+	networking "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2"
 	layer3 "github.com/gophercloud/gophercloud/v2/internal/acceptance/openstack/networking/v2/extensions/layer3"
 	"github.com/gophercloud/gophercloud/v2/internal/acceptance/tools"
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/extensions/layer3/routers"
@@ -19,6 +19,9 @@ func TestConnectionList(t *testing.T) {
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	allPages, err := siteconnections.List(client, nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
@@ -31,19 +34,24 @@ func TestConnectionList(t *testing.T) {
 }
 
 func TestConnectionCRUD(t *testing.T) {
+	// TODO(stephenfin): Why are we skipping this? Can we unskip? If not, we should remove.
 	clients.SkipReleasesAbove(t, "stable/wallaby")
+
 	client, err := clients.NewNetworkV2Client()
 	th.AssertNoErr(t, err)
 
+	// Skip these tests if we don't have the required extension
+	networking.RequireNeutronExtension(t, client, "vpnaas")
+
 	// Create Network
-	network, err := networks.CreateNetwork(t, client)
+	network, err := networking.CreateNetwork(t, client)
 	th.AssertNoErr(t, err)
-	defer networks.DeleteNetwork(t, client, network.ID)
+	defer networking.DeleteNetwork(t, client, network.ID)
 
 	// Create Subnet
-	subnet, err := networks.CreateSubnet(t, client, network.ID)
+	subnet, err := networking.CreateSubnet(t, client, network.ID)
 	th.AssertNoErr(t, err)
-	defer networks.DeleteSubnet(t, client, subnet.ID)
+	defer networking.DeleteSubnet(t, client, subnet.ID)
 
 	router, err := layer3.CreateExternalRouter(t, client)
 	th.AssertNoErr(t, err)
diff --git a/internal/acceptance/openstack/sharedfilesystems/v2/replicas_test.go b/internal/acceptance/openstack/sharedfilesystems/v2/replicas_test.go
index 41913ac26..8432afeb7 100644
--- a/internal/acceptance/openstack/sharedfilesystems/v2/replicas_test.go
+++ b/internal/acceptance/openstack/sharedfilesystems/v2/replicas_test.go
@@ -18,7 +18,7 @@ import (
 const replicasPathMicroversion = "2.56"
 
 func TestReplicaCreate(t *testing.T) {
-	clients.RequireManilaReplicas(t)
+	RequireManilaReplicas(t)
 
 	client, err := clients.NewSharedFileSystemV2Client()
 	if err != nil {
@@ -55,7 +55,7 @@ func TestReplicaCreate(t *testing.T) {
 }
 
 func TestReplicaPromote(t *testing.T) {
-	clients.RequireManilaReplicas(t)
+	RequireManilaReplicas(t)
 
 	client, err := clients.NewSharedFileSystemV2Client()
 	if err != nil {
@@ -131,7 +131,7 @@ func TestReplicaPromote(t *testing.T) {
 }
 
 func TestReplicaExportLocations(t *testing.T) {
-	clients.RequireManilaReplicas(t)
+	RequireManilaReplicas(t)
 
 	client, err := clients.NewSharedFileSystemV2Client()
 	if err != nil {
@@ -198,7 +198,7 @@ func TestReplicaExportLocations(t *testing.T) {
 }
 
 func TestReplicaListDetail(t *testing.T) {
-	clients.RequireManilaReplicas(t)
+	RequireManilaReplicas(t)
 
 	client, err := clients.NewSharedFileSystemV2Client()
 	if err != nil {
@@ -231,7 +231,7 @@ func TestReplicaListDetail(t *testing.T) {
 }
 
 func TestReplicaResetStatus(t *testing.T) {
-	clients.RequireManilaReplicas(t)
+	RequireManilaReplicas(t)
 
 	client, err := clients.NewSharedFileSystemV2Client()
 	if err != nil {
@@ -272,7 +272,7 @@ func TestReplicaResetStatus(t *testing.T) {
 
 // This test available only for cloud admins
 func TestReplicaForceDelete(t *testing.T) {
-	clients.RequireManilaReplicas(t)
+	RequireManilaReplicas(t)
 	clients.RequireAdmin(t)
 
 	client, err := clients.NewSharedFileSystemV2Client()
diff --git a/openstack/baremetal/apiversions/testing/fixtures_test.go b/openstack/baremetal/apiversions/testing/fixtures_test.go
index d0e11553c..2d799a07c 100644
--- a/openstack/baremetal/apiversions/testing/fixtures_test.go
+++ b/openstack/baremetal/apiversions/testing/fixtures_test.go
@@ -81,8 +81,8 @@ var IronicAllAPIVersionResults = apiversions.APIVersions{
 	},
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -93,8 +93,8 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/v1/", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/baremetal/apiversions/testing/requests_test.go b/openstack/baremetal/apiversions/testing/requests_test.go
index 27d9fa5e2..2a9de065c 100644
--- a/openstack/baremetal/apiversions/testing/requests_test.go
+++ b/openstack/baremetal/apiversions/testing/requests_test.go
@@ -10,24 +10,24 @@ import (
 )
 
 func TestListAPIVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	actual, err := apiversions.List(context.TODO(), client.ServiceClient()).Extract()
+	actual, err := apiversions.List(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, IronicAllAPIVersionResults, *actual)
 }
 
 func TestGetAPIVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	actual, err := apiversions.Get(context.TODO(), client.ServiceClient(), "v1").Extract()
+	actual, err := apiversions.Get(context.TODO(), client.ServiceClient(fakeServer), "v1").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, IronicAPIVersion1Result, *actual)
diff --git a/openstack/baremetal/v1/allocations/testing/fixtures_test.go b/openstack/baremetal/v1/allocations/testing/fixtures_test.go
index 7ee9fa483..935043759 100644
--- a/openstack/baremetal/v1/allocations/testing/fixtures_test.go
+++ b/openstack/baremetal/v1/allocations/testing/fixtures_test.go
@@ -108,8 +108,8 @@ var (
 )
 
 // HandleAllocationListSuccessfully sets up the test server to respond to a allocation List request.
-func HandleAllocationListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/allocations", func(w http.ResponseWriter, r *http.Request) {
+func HandleAllocationListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/allocations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -132,8 +132,8 @@ func HandleAllocationListSuccessfully(t *testing.T) {
 
 // HandleAllocationCreationSuccessfully sets up the test server to respond to a allocation creation request
 // with a given response.
-func HandleAllocationCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/allocations", func(w http.ResponseWriter, r *http.Request) {
+func HandleAllocationCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/allocations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -150,8 +150,8 @@ func HandleAllocationCreationSuccessfully(t *testing.T, response string) {
 }
 
 // HandleAllocationDeletionSuccessfully sets up the test server to respond to a allocation deletion request.
-func HandleAllocationDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/allocations/344a3e2-978a-444e-990a-cbf47c62ef88", func(w http.ResponseWriter, r *http.Request) {
+func HandleAllocationDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/allocations/344a3e2-978a-444e-990a-cbf47c62ef88", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -159,8 +159,8 @@ func HandleAllocationDeletionSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleAllocationGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/allocations/344a3e2-978a-444e-990a-cbf47c62ef88", func(w http.ResponseWriter, r *http.Request) {
+func HandleAllocationGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/allocations/344a3e2-978a-444e-990a-cbf47c62ef88", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/baremetal/v1/allocations/testing/requests_test.go b/openstack/baremetal/v1/allocations/testing/requests_test.go
index 2eec2aa51..c30334eaf 100644
--- a/openstack/baremetal/v1/allocations/testing/requests_test.go
+++ b/openstack/baremetal/v1/allocations/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListAllocations(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAllocationListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAllocationListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := allocations.List(client.ServiceClient(), allocations.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := allocations.List(client.ServiceClient(fakeServer), allocations.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := allocations.ExtractAllocations(page)
@@ -41,11 +41,11 @@ func TestListAllocations(t *testing.T) {
 }
 
 func TestCreateAllocation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAllocationCreationSuccessfully(t, SingleAllocationBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAllocationCreationSuccessfully(t, fakeServer, SingleAllocationBody)
 
-	actual, err := allocations.Create(context.TODO(), client.ServiceClient(), allocations.CreateOpts{
+	actual, err := allocations.Create(context.TODO(), client.ServiceClient(fakeServer), allocations.CreateOpts{
 		Name:           "allocation-1",
 		ResourceClass:  "baremetal",
 		CandidateNodes: []string{"344a3e2-978a-444e-990a-cbf47c62ef88"},
@@ -57,20 +57,20 @@ func TestCreateAllocation(t *testing.T) {
 }
 
 func TestDeleteAllocation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAllocationDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAllocationDeletionSuccessfully(t, fakeServer)
 
-	res := allocations.Delete(context.TODO(), client.ServiceClient(), "344a3e2-978a-444e-990a-cbf47c62ef88")
+	res := allocations.Delete(context.TODO(), client.ServiceClient(fakeServer), "344a3e2-978a-444e-990a-cbf47c62ef88")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetAllocation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAllocationGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAllocationGetSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := allocations.Get(context.TODO(), c, "344a3e2-978a-444e-990a-cbf47c62ef88").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
diff --git a/openstack/baremetal/v1/conductors/testing/fixtures_test.go b/openstack/baremetal/v1/conductors/testing/fixtures_test.go
index fd66a34d4..4b264fd7e 100644
--- a/openstack/baremetal/v1/conductors/testing/fixtures_test.go
+++ b/openstack/baremetal/v1/conductors/testing/fixtures_test.go
@@ -138,8 +138,8 @@ var (
 )
 
 // HandleConductorListSuccessfully sets up the test server to respond to a server List request.
-func HandleConductorListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/conductors", func(w http.ResponseWriter, r *http.Request) {
+func HandleConductorListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/conductors", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -161,8 +161,8 @@ func HandleConductorListSuccessfully(t *testing.T) {
 }
 
 // HandleConductorListDetailSuccessfully sets up the test server to respond to a server List request.
-func HandleConductorListDetailSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/conductors", func(w http.ResponseWriter, r *http.Request) {
+func HandleConductorListDetailSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/conductors", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -174,8 +174,8 @@ func HandleConductorListDetailSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleConductorGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/conductors/1234asdf", func(w http.ResponseWriter, r *http.Request) {
+func HandleConductorGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/conductors/1234asdf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/baremetal/v1/conductors/testing/requests_test.go b/openstack/baremetal/v1/conductors/testing/requests_test.go
index 6f6aa518a..103faf579 100644
--- a/openstack/baremetal/v1/conductors/testing/requests_test.go
+++ b/openstack/baremetal/v1/conductors/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListConductors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleConductorListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleConductorListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := conductors.List(client.ServiceClient(), conductors.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := conductors.List(client.ServiceClient(fakeServer), conductors.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := conductors.ExtractConductors(page)
@@ -41,12 +41,12 @@ func TestListConductors(t *testing.T) {
 }
 
 func TestListDetailConductors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleConductorListDetailSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleConductorListDetailSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := conductors.List(client.ServiceClient(), conductors.ListOpts{Detail: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := conductors.List(client.ServiceClient(fakeServer), conductors.ListOpts{Detail: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := conductors.ExtractConductors(page)
@@ -93,11 +93,11 @@ func TestListOpts(t *testing.T) {
 }
 
 func TestGetConductor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleConductorGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleConductorGetSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := conductors.Get(context.TODO(), c, "1234asdf").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
diff --git a/openstack/baremetal/v1/drivers/testing/fixtures_test.go b/openstack/baremetal/v1/drivers/testing/fixtures_test.go
index 6c6d0fcc7..7fb607fd1 100644
--- a/openstack/baremetal/v1/drivers/testing/fixtures_test.go
+++ b/openstack/baremetal/v1/drivers/testing/fixtures_test.go
@@ -368,8 +368,8 @@ var (
 )
 
 // HandleListDriversSuccessfully sets up the test server to respond to a drivers ListDrivers request.
-func HandleListDriversSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/drivers", func(w http.ResponseWriter, r *http.Request) {
+func HandleListDriversSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/drivers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -382,8 +382,8 @@ func HandleListDriversSuccessfully(t *testing.T) {
 }
 
 // HandleGetDriverDetailsSuccessfully sets up the test server to respond to a drivers GetDriverDetails request.
-func HandleGetDriverDetailsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/drivers/ipmi", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetDriverDetailsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/drivers/ipmi", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -393,8 +393,8 @@ func HandleGetDriverDetailsSuccessfully(t *testing.T) {
 }
 
 // HandleGetDriverPropertiesSuccessfully sets up the test server to respond to a drivers GetDriverProperties request.
-func HandleGetDriverPropertiesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/drivers/agent_ipmitool/properties", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetDriverPropertiesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/drivers/agent_ipmitool/properties", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -404,8 +404,8 @@ func HandleGetDriverPropertiesSuccessfully(t *testing.T) {
 }
 
 // HandleGetDriverDiskPropertiesSuccessfully sets up the test server to respond to a drivers GetDriverDiskProperties request.
-func HandleGetDriverDiskPropertiesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/drivers/agent_ipmitool/raid/logical_disk_properties", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetDriverDiskPropertiesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/drivers/agent_ipmitool/raid/logical_disk_properties", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/baremetal/v1/drivers/testing/requests_test.go b/openstack/baremetal/v1/drivers/testing/requests_test.go
index f99e3198c..58d83f27a 100644
--- a/openstack/baremetal/v1/drivers/testing/requests_test.go
+++ b/openstack/baremetal/v1/drivers/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListDrivers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListDriversSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListDriversSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := drivers.ListDrivers(client.ServiceClient(), drivers.ListDriversOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := drivers.ListDrivers(client.ServiceClient(fakeServer), drivers.ListDriversOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := drivers.ExtractDrivers(page)
@@ -43,11 +43,11 @@ func TestListDrivers(t *testing.T) {
 }
 
 func TestGetDriverDetails(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetDriverDetailsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetDriverDetailsSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := drivers.GetDriverDetails(context.TODO(), c, "ipmi").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -57,11 +57,11 @@ func TestGetDriverDetails(t *testing.T) {
 }
 
 func TestGetDriverProperties(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetDriverPropertiesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetDriverPropertiesSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := drivers.GetDriverProperties(context.TODO(), c, "agent_ipmitool").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -71,11 +71,11 @@ func TestGetDriverProperties(t *testing.T) {
 }
 
 func TestGetDriverDiskProperties(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetDriverDiskPropertiesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetDriverDiskPropertiesSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := drivers.GetDriverDiskProperties(context.TODO(), c, "agent_ipmitool").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
diff --git a/openstack/baremetal/v1/nodes/testing/fixtures_test.go b/openstack/baremetal/v1/nodes/testing/fixtures_test.go
index 371a4f00a..064351ea8 100644
--- a/openstack/baremetal/v1/nodes/testing/fixtures_test.go
+++ b/openstack/baremetal/v1/nodes/testing/fixtures_test.go
@@ -1419,8 +1419,8 @@ var (
 )
 
 // HandleNodeListSuccessfully sets up the test server to respond to a server List request.
-func HandleNodeListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -1442,8 +1442,8 @@ func HandleNodeListSuccessfully(t *testing.T) {
 }
 
 // HandleNodeListSuccessfully sets up the test server to respond to a server List request.
-func HandleNodeListDetailSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeListDetailSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -1457,8 +1457,8 @@ func HandleNodeListDetailSuccessfully(t *testing.T) {
 
 // HandleServerCreationSuccessfully sets up the test server to respond to a server creation request
 // with a given response.
-func HandleNodeCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/nodes", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/nodes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -1483,8 +1483,8 @@ func HandleNodeCreationSuccessfully(t *testing.T, response string) {
 }
 
 // HandleNodeDeletionSuccessfully sets up the test server to respond to a server deletion request.
-func HandleNodeDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/asdfasdfasdf", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/asdfasdfasdf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -1492,8 +1492,8 @@ func HandleNodeDeletionSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleNodeGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1502,8 +1502,8 @@ func HandleNodeGetSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleNodeUpdateSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/nodes/1234asdf", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1514,8 +1514,8 @@ func HandleNodeUpdateSuccessfully(t *testing.T, response string) {
 	})
 }
 
-func HandleNodeValidateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/validate", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeValidateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/validate", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1525,8 +1525,8 @@ func HandleNodeValidateSuccessfully(t *testing.T) {
 }
 
 // HandleInjectNMISuccessfully sets up the test server to respond to a node InjectNMI request
-func HandleInjectNMISuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/management/inject_nmi", func(w http.ResponseWriter, r *http.Request) {
+func HandleInjectNMISuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/management/inject_nmi", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, "{}")
@@ -1536,8 +1536,8 @@ func HandleInjectNMISuccessfully(t *testing.T) {
 }
 
 // HandleSetBootDeviceSuccessfully sets up the test server to respond to a set boot device request for a node
-func HandleSetBootDeviceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/management/boot_device", func(w http.ResponseWriter, r *http.Request) {
+func HandleSetBootDeviceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/management/boot_device", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, NodeBootDeviceBody)
@@ -1547,8 +1547,8 @@ func HandleSetBootDeviceSuccessfully(t *testing.T) {
 }
 
 // HandleGetBootDeviceSuccessfully sets up the test server to respond to a get boot device request for a node
-func HandleGetBootDeviceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/management/boot_device", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetBootDeviceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/management/boot_device", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
@@ -1557,8 +1557,8 @@ func HandleGetBootDeviceSuccessfully(t *testing.T) {
 }
 
 // HandleGetBootDeviceSuccessfully sets up the test server to respond to a get boot device request for a node
-func HandleGetSupportedBootDeviceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/management/boot_device/supported", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSupportedBootDeviceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/management/boot_device/supported", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
@@ -1566,8 +1566,8 @@ func HandleGetSupportedBootDeviceSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleNodeChangeProvisionStateActive(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeChangeProvisionStateActive(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, NodeProvisionStateActiveBody)
@@ -1575,8 +1575,8 @@ func HandleNodeChangeProvisionStateActive(t *testing.T) {
 	})
 }
 
-func HandleNodeChangeProvisionStateActiveWithSteps(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeChangeProvisionStateActiveWithSteps(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, NodeProvisionStateActiveBodyWithSteps)
@@ -1584,8 +1584,8 @@ func HandleNodeChangeProvisionStateActiveWithSteps(t *testing.T) {
 	})
 }
 
-func HandleNodeChangeProvisionStateClean(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeChangeProvisionStateClean(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, NodeProvisionStateCleanBody)
@@ -1593,8 +1593,8 @@ func HandleNodeChangeProvisionStateClean(t *testing.T) {
 	})
 }
 
-func HandleNodeChangeProvisionStateCleanWithConflict(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeChangeProvisionStateCleanWithConflict(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, NodeProvisionStateCleanBody)
@@ -1602,8 +1602,8 @@ func HandleNodeChangeProvisionStateCleanWithConflict(t *testing.T) {
 	})
 }
 
-func HandleNodeChangeProvisionStateConfigDrive(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeChangeProvisionStateConfigDrive(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, NodeProvisionStateConfigDriveBody)
@@ -1611,8 +1611,8 @@ func HandleNodeChangeProvisionStateConfigDrive(t *testing.T) {
 	})
 }
 
-func HandleNodeChangeProvisionStateService(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
+func HandleNodeChangeProvisionStateService(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/provision", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, NodeProvisionStateServiceBody)
@@ -1621,8 +1621,8 @@ func HandleNodeChangeProvisionStateService(t *testing.T) {
 }
 
 // HandleChangePowerStateSuccessfully sets up the test server to respond to a change power state request for a node
-func HandleChangePowerStateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/power", func(w http.ResponseWriter, r *http.Request) {
+func HandleChangePowerStateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/power", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -1635,8 +1635,8 @@ func HandleChangePowerStateSuccessfully(t *testing.T) {
 }
 
 // HandleChangePowerStateWithConflict sets up the test server to respond to a change power state request for a node with a 409 error
-func HandleChangePowerStateWithConflict(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/power", func(w http.ResponseWriter, r *http.Request) {
+func HandleChangePowerStateWithConflict(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/power", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -1648,8 +1648,8 @@ func HandleChangePowerStateWithConflict(t *testing.T) {
 	})
 }
 
-func HandleSetRAIDConfig(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/raid", func(w http.ResponseWriter, r *http.Request) {
+func HandleSetRAIDConfig(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/raid", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `
@@ -1668,8 +1668,8 @@ func HandleSetRAIDConfig(t *testing.T) {
 	})
 }
 
-func HandleSetRAIDConfigMaxSize(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/states/raid", func(w http.ResponseWriter, r *http.Request) {
+func HandleSetRAIDConfigMaxSize(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/states/raid", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `
@@ -1688,8 +1688,8 @@ func HandleSetRAIDConfigMaxSize(t *testing.T) {
 	})
 }
 
-func HandleListBIOSSettingsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/bios", func(w http.ResponseWriter, r *http.Request) {
+func HandleListBIOSSettingsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/bios", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1698,8 +1698,8 @@ func HandleListBIOSSettingsSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleListDetailBIOSSettingsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/bios", func(w http.ResponseWriter, r *http.Request) {
+func HandleListDetailBIOSSettingsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/bios", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1708,8 +1708,8 @@ func HandleListDetailBIOSSettingsSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetBIOSSettingSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/bios/ProcVirtualization", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetBIOSSettingSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/bios/ProcVirtualization", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1718,8 +1718,8 @@ func HandleGetBIOSSettingSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetVendorPassthruMethodsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru/methods", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetVendorPassthruMethodsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru/methods", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1728,8 +1728,8 @@ func HandleGetVendorPassthruMethodsSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetAllSubscriptionsVendorPassthruSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetAllSubscriptionsVendorPassthruSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1739,8 +1739,8 @@ func HandleGetAllSubscriptionsVendorPassthruSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetSubscriptionVendorPassthruSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSubscriptionVendorPassthruSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1755,8 +1755,8 @@ func HandleGetSubscriptionVendorPassthruSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleCreateSubscriptionVendorPassthruAllParametersSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSubscriptionVendorPassthruAllParametersSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1775,8 +1775,8 @@ func HandleCreateSubscriptionVendorPassthruAllParametersSuccessfully(t *testing.
 	})
 }
 
-func HandleCreateSubscriptionVendorPassthruRequiredParametersSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSubscriptionVendorPassthruRequiredParametersSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1791,8 +1791,8 @@ func HandleCreateSubscriptionVendorPassthruRequiredParametersSuccessfully(t *tes
 	})
 }
 
-func HandleDeleteSubscriptionVendorPassthruSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSubscriptionVendorPassthruSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vendor_passthru", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1807,8 +1807,8 @@ func HandleDeleteSubscriptionVendorPassthruSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleSetNodeMaintenanceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/maintenance", func(w http.ResponseWriter, r *http.Request) {
+func HandleSetNodeMaintenanceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/maintenance", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, NodeSetMaintenanceBody)
@@ -1817,8 +1817,8 @@ func HandleSetNodeMaintenanceSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleUnsetNodeMaintenanceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/maintenance", func(w http.ResponseWriter, r *http.Request) {
+func HandleUnsetNodeMaintenanceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/maintenance", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -1827,8 +1827,8 @@ func HandleUnsetNodeMaintenanceSuccessfully(t *testing.T) {
 }
 
 // HandleGetInventorySuccessfully sets up the test server to respond to a get inventory request for a node
-func HandleGetInventorySuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/inventory", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetInventorySuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/inventory", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
@@ -1837,8 +1837,8 @@ func HandleGetInventorySuccessfully(t *testing.T) {
 }
 
 // HandleListFirmware
-func HandleListFirmwareSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/firmware", func(w http.ResponseWriter, r *http.Request) {
+func HandleListFirmwareSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/firmware", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
@@ -1846,8 +1846,8 @@ func HandleListFirmwareSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleAttachVirtualMediaSuccessfully(t *testing.T, withSource bool) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vmedia", func(w http.ResponseWriter, r *http.Request) {
+func HandleAttachVirtualMediaSuccessfully(t *testing.T, fakeServer th.FakeServer, withSource bool) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vmedia", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		if withSource {
@@ -1859,8 +1859,8 @@ func HandleAttachVirtualMediaSuccessfully(t *testing.T, withSource bool) {
 	})
 }
 
-func HandleDetachVirtualMediaSuccessfully(t *testing.T, withType bool) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vmedia", func(w http.ResponseWriter, r *http.Request) {
+func HandleDetachVirtualMediaSuccessfully(t *testing.T, fakeServer th.FakeServer, withType bool) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vmedia", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		if withType {
@@ -1872,8 +1872,8 @@ func HandleDetachVirtualMediaSuccessfully(t *testing.T, withType bool) {
 	})
 }
 
-func HandleGetVirtualMediaSuccessfully(t *testing.T, attached bool) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vmedia", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetVirtualMediaSuccessfully(t *testing.T, fakeServer th.FakeServer, attached bool) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vmedia", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
@@ -1886,8 +1886,8 @@ func HandleGetVirtualMediaSuccessfully(t *testing.T, attached bool) {
 }
 
 // HandleListVirtualInterfacesSuccessfully sets up the test server to respond to a ListVirtualInterfaces request
-func HandleListVirtualInterfacesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vifs",
+func HandleListVirtualInterfacesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vifs",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -1907,8 +1907,8 @@ func HandleListVirtualInterfacesSuccessfully(t *testing.T) {
 }
 
 // HandleAttachVirtualInterfaceSuccessfully sets up the test server to respond to an AttachVirtualInterface request
-func HandleAttachVirtualInterfaceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vifs",
+func HandleAttachVirtualInterfaceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vifs",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -1921,8 +1921,8 @@ func HandleAttachVirtualInterfaceSuccessfully(t *testing.T) {
 }
 
 // HandleAttachVirtualInterfaceWithPortSuccessfully sets up the test server to respond to an AttachVirtualInterface request with port
-func HandleAttachVirtualInterfaceWithPortSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vifs",
+func HandleAttachVirtualInterfaceWithPortSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vifs",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -1935,8 +1935,8 @@ func HandleAttachVirtualInterfaceWithPortSuccessfully(t *testing.T) {
 }
 
 // HandleAttachVirtualInterfaceWithPortgroupSuccessfully sets up the test server to respond to an AttachVirtualInterface request with portgroup
-func HandleAttachVirtualInterfaceWithPortgroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vifs",
+func HandleAttachVirtualInterfaceWithPortgroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vifs",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -1949,8 +1949,8 @@ func HandleAttachVirtualInterfaceWithPortgroupSuccessfully(t *testing.T) {
 }
 
 // HandleDetachVirtualInterfaceSuccessfully sets up the test server to respond to a DetachVirtualInterface request
-func HandleDetachVirtualInterfaceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/nodes/1234asdf/vifs/1974dcfa-836f-41b2-b541-686c100900e5",
+func HandleDetachVirtualInterfaceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/nodes/1234asdf/vifs/1974dcfa-836f-41b2-b541-686c100900e5",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
diff --git a/openstack/baremetal/v1/nodes/testing/requests_test.go b/openstack/baremetal/v1/nodes/testing/requests_test.go
index 24452be0c..c881cfba8 100644
--- a/openstack/baremetal/v1/nodes/testing/requests_test.go
+++ b/openstack/baremetal/v1/nodes/testing/requests_test.go
@@ -13,12 +13,12 @@ import (
 )
 
 func TestListDetailNodes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeListDetailSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeListDetailSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := nodes.ListDetail(client.ServiceClient(), nodes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := nodes.ListDetail(client.ServiceClient(fakeServer), nodes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := nodes.ExtractNodes(page)
@@ -44,12 +44,12 @@ func TestListDetailNodes(t *testing.T) {
 }
 
 func TestListNodes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := nodes.List(client.ServiceClient(), nodes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := nodes.List(client.ServiceClient(fakeServer), nodes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := nodes.ExtractNodes(page)
@@ -90,11 +90,11 @@ func TestListOpts(t *testing.T) {
 }
 
 func TestCreateNode(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeCreationSuccessfully(t, SingleNodeBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeCreationSuccessfully(t, fakeServer, SingleNodeBody)
 
-	actual, err := nodes.Create(context.TODO(), client.ServiceClient(), nodes.CreateOpts{
+	actual, err := nodes.Create(context.TODO(), client.ServiceClient(fakeServer), nodes.CreateOpts{
 		Name:          "foo",
 		Driver:        "ipmi",
 		BootInterface: "pxe",
@@ -114,20 +114,20 @@ func TestCreateNode(t *testing.T) {
 }
 
 func TestDeleteNode(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeDeletionSuccessfully(t, fakeServer)
 
-	res := nodes.Delete(context.TODO(), client.ServiceClient(), "asdfasdfasdf")
+	res := nodes.Delete(context.TODO(), client.ServiceClient(fakeServer), "asdfasdfasdf")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetNode(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeGetSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.Get(context.TODO(), c, "1234asdf").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -137,11 +137,11 @@ func TestGetNode(t *testing.T) {
 }
 
 func TestUpdateNode(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeUpdateSuccessfully(t, SingleNodeBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeUpdateSuccessfully(t, fakeServer, SingleNodeBody)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.Update(context.TODO(), c, "1234asdf", nodes.UpdateOpts{
 		nodes.UpdateOperation{
 			Op:   nodes.ReplaceOp,
@@ -159,7 +159,10 @@ func TestUpdateNode(t *testing.T) {
 }
 
 func TestUpdateRequiredOp(t *testing.T) {
-	c := client.ServiceClient()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	c := client.ServiceClient(fakeServer)
 	_, err := nodes.Update(context.TODO(), c, "1234asdf", nodes.UpdateOpts{
 		nodes.UpdateOperation{
 			Path:  "/driver",
@@ -174,7 +177,10 @@ func TestUpdateRequiredOp(t *testing.T) {
 }
 
 func TestUpdateRequiredPath(t *testing.T) {
-	c := client.ServiceClient()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	c := client.ServiceClient(fakeServer)
 	_, err := nodes.Update(context.TODO(), c, "1234asdf", nodes.UpdateOpts{
 		nodes.UpdateOperation{
 			Op:    nodes.ReplaceOp,
@@ -188,32 +194,32 @@ func TestUpdateRequiredPath(t *testing.T) {
 }
 
 func TestValidateNode(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeValidateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeValidateSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.Validate(context.TODO(), c, "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeFooValidation, *actual)
 }
 
 func TestInjectNMI(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleInjectNMISuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleInjectNMISuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.InjectNMI(context.TODO(), c, "1234asdf").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestSetBootDevice(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSetBootDeviceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSetBootDeviceSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.SetBootDevice(context.TODO(), c, "1234asdf", nodes.BootDeviceOpts{
 		BootDevice: "pxe",
 		Persistent: false,
@@ -222,33 +228,33 @@ func TestSetBootDevice(t *testing.T) {
 }
 
 func TestGetBootDevice(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetBootDeviceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetBootDeviceSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	bootDevice, err := nodes.GetBootDevice(context.TODO(), c, "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeBootDevice, *bootDevice)
 }
 
 func TestGetSupportedBootDevices(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSupportedBootDeviceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSupportedBootDeviceSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	bootDevices, err := nodes.GetSupportedBootDevices(context.TODO(), c, "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeSupportedBootDevice, bootDevices)
 }
 
 func TestNodeChangeProvisionStateActive(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeChangeProvisionStateActive(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeChangeProvisionStateActive(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangeProvisionState(context.TODO(), c, "1234asdf", nodes.ProvisionStateOpts{
 		Target:      nodes.TargetActive,
 		ConfigDrive: "http://127.0.0.1/images/test-node-config-drive.iso.gz",
@@ -258,11 +264,11 @@ func TestNodeChangeProvisionStateActive(t *testing.T) {
 }
 
 func TestNodeChangeProvisionStateActiveWithSteps(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeChangeProvisionStateActiveWithSteps(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeChangeProvisionStateActiveWithSteps(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangeProvisionState(context.TODO(), c, "1234asdf", nodes.ProvisionStateOpts{
 		Target: nodes.TargetActive,
 		DeploySteps: []nodes.DeployStep{
@@ -281,12 +287,11 @@ func TestNodeChangeProvisionStateActiveWithSteps(t *testing.T) {
 }
 
 func TestHandleNodeChangeProvisionStateConfigDrive(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-
-	HandleNodeChangeProvisionStateConfigDrive(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeChangeProvisionStateConfigDrive(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 
 	err := nodes.ChangeProvisionState(context.TODO(), c, "1234asdf", nodes.ProvisionStateOpts{
 		Target:      nodes.TargetActive,
@@ -297,11 +302,11 @@ func TestHandleNodeChangeProvisionStateConfigDrive(t *testing.T) {
 }
 
 func TestNodeChangeProvisionStateClean(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeChangeProvisionStateClean(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeChangeProvisionStateClean(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangeProvisionState(context.TODO(), c, "1234asdf", nodes.ProvisionStateOpts{
 		Target: nodes.TargetClean,
 		CleanSteps: []nodes.CleanStep{
@@ -319,11 +324,11 @@ func TestNodeChangeProvisionStateClean(t *testing.T) {
 }
 
 func TestNodeChangeProvisionStateCleanWithConflict(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeChangeProvisionStateCleanWithConflict(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeChangeProvisionStateCleanWithConflict(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangeProvisionState(context.TODO(), c, "1234asdf", nodes.ProvisionStateOpts{
 		Target: nodes.TargetClean,
 		CleanSteps: []nodes.CleanStep{
@@ -343,7 +348,10 @@ func TestNodeChangeProvisionStateCleanWithConflict(t *testing.T) {
 }
 
 func TestCleanStepRequiresInterface(t *testing.T) {
-	c := client.ServiceClient()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangeProvisionState(context.TODO(), c, "1234asdf", nodes.ProvisionStateOpts{
 		Target: nodes.TargetClean,
 		CleanSteps: []nodes.CleanStep{
@@ -362,7 +370,10 @@ func TestCleanStepRequiresInterface(t *testing.T) {
 }
 
 func TestCleanStepRequiresStep(t *testing.T) {
-	c := client.ServiceClient()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangeProvisionState(context.TODO(), c, "1234asdf", nodes.ProvisionStateOpts{
 		Target: nodes.TargetClean,
 		CleanSteps: []nodes.CleanStep{
@@ -381,11 +392,11 @@ func TestCleanStepRequiresStep(t *testing.T) {
 }
 
 func TestNodeChangeProvisionStateService(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNodeChangeProvisionStateService(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNodeChangeProvisionStateService(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangeProvisionState(context.TODO(), c, "1234asdf", nodes.ProvisionStateOpts{
 		Target: nodes.TargetService,
 		ServiceSteps: []nodes.ServiceStep{
@@ -403,31 +414,31 @@ func TestNodeChangeProvisionStateService(t *testing.T) {
 }
 
 func TestChangePowerState(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleChangePowerStateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleChangePowerStateSuccessfully(t, fakeServer)
 
 	opts := nodes.PowerStateOpts{
 		Target:  nodes.PowerOn,
 		Timeout: 100,
 	}
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangePowerState(context.TODO(), c, "1234asdf", opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestChangePowerStateWithConflict(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleChangePowerStateWithConflict(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleChangePowerStateWithConflict(t, fakeServer)
 
 	opts := nodes.PowerStateOpts{
 		Target:  nodes.PowerOn,
 		Timeout: 100,
 	}
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.ChangePowerState(context.TODO(), c, "1234asdf", opts).ExtractErr()
 	if !gophercloud.ResponseCodeIs(err, http.StatusConflict) {
 		t.Fatalf("expected 409 response, but got %s", err.Error())
@@ -435,9 +446,9 @@ func TestChangePowerStateWithConflict(t *testing.T) {
 }
 
 func TestSetRAIDConfig(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSetRAIDConfig(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSetRAIDConfig(t, fakeServer)
 
 	sizeGB := 100
 	isRootVolume := true
@@ -452,16 +463,16 @@ func TestSetRAIDConfig(t *testing.T) {
 		},
 	}
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.SetRAIDConfig(context.TODO(), c, "1234asdf", config).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 // Without specifying a size, we need to send a string: "MAX"
 func TestSetRAIDConfigMaxSize(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSetRAIDConfigMaxSize(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSetRAIDConfigMaxSize(t, fakeServer)
 
 	isRootVolume := true
 
@@ -474,7 +485,7 @@ func TestSetRAIDConfigMaxSize(t *testing.T) {
 		},
 	}
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.SetRAIDConfig(context.TODO(), c, "1234asdf", config).ExtractErr()
 	th.AssertNoErr(t, err)
 }
@@ -572,37 +583,37 @@ func TestToRAIDConfigMap(t *testing.T) {
 }
 
 func TestListBIOSSettings(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListBIOSSettingsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListBIOSSettingsSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.ListBIOSSettings(context.TODO(), c, "1234asdf", nil).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeBIOSSettings, actual)
 }
 
 func TestListDetailBIOSSettings(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListDetailBIOSSettingsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListDetailBIOSSettingsSuccessfully(t, fakeServer)
 
 	opts := nodes.ListBIOSSettingsOpts{
 		Detail: true,
 	}
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.ListBIOSSettings(context.TODO(), c, "1234asdf", opts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeDetailBIOSSettings, actual)
 }
 
 func TestGetBIOSSetting(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetBIOSSettingSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetBIOSSettingSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.GetBIOSSetting(context.TODO(), c, "1234asdf", "ProcVirtualization").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeSingleBIOSSetting, *actual)
@@ -620,22 +631,22 @@ func TestListBIOSSettingsOpts(t *testing.T) {
 }
 
 func TestGetVendorPassthruMethods(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetVendorPassthruMethodsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetVendorPassthruMethodsSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.GetVendorPassthruMethods(context.TODO(), c, "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeVendorPassthruMethods, *actual)
 }
 
 func TestGetAllSubscriptions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetAllSubscriptionsVendorPassthruSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetAllSubscriptionsVendorPassthruSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	method := nodes.CallVendorPassthruOpts{
 		Method: "get_all_subscriptions",
 	}
@@ -645,11 +656,11 @@ func TestGetAllSubscriptions(t *testing.T) {
 }
 
 func TestGetSubscription(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSubscriptionVendorPassthruSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSubscriptionVendorPassthruSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	method := nodes.CallVendorPassthruOpts{
 		Method: "get_subscription",
 	}
@@ -662,11 +673,11 @@ func TestGetSubscription(t *testing.T) {
 }
 
 func TestCreateSubscriptionAllParameters(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSubscriptionVendorPassthruAllParametersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSubscriptionVendorPassthruAllParametersSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	method := nodes.CallVendorPassthruOpts{
 		Method: "create_subscription",
 	}
@@ -683,11 +694,11 @@ func TestCreateSubscriptionAllParameters(t *testing.T) {
 }
 
 func TestCreateSubscriptionWithRequiredParameters(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSubscriptionVendorPassthruRequiredParametersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSubscriptionVendorPassthruRequiredParametersSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	method := nodes.CallVendorPassthruOpts{
 		Method: "create_subscription",
 	}
@@ -700,11 +711,11 @@ func TestCreateSubscriptionWithRequiredParameters(t *testing.T) {
 }
 
 func TestDeleteSubscription(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSubscriptionVendorPassthruSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSubscriptionVendorPassthruSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	method := nodes.CallVendorPassthruOpts{
 		Method: "delete_subscription",
 	}
@@ -716,11 +727,11 @@ func TestDeleteSubscription(t *testing.T) {
 }
 
 func TestSetMaintenance(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSetNodeMaintenanceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSetNodeMaintenanceSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.SetMaintenance(context.TODO(), c, "1234asdf", nodes.MaintenanceOpts{
 		Reason: "I'm tired",
 	}).ExtractErr()
@@ -728,21 +739,21 @@ func TestSetMaintenance(t *testing.T) {
 }
 
 func TestUnsetMaintenance(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUnsetNodeMaintenanceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUnsetNodeMaintenanceSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.UnsetMaintenance(context.TODO(), c, "1234asdf").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetInventory(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetInventorySuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetInventorySuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.GetInventory(context.TODO(), c, "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeInventoryData.Inventory, actual.Inventory)
@@ -757,11 +768,11 @@ func TestGetInventory(t *testing.T) {
 }
 
 func TestListFirmware(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListFirmwareSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListFirmwareSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.ListFirmware(context.TODO(), c, "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, NodeFirmwareList, actual)
@@ -779,11 +790,11 @@ func TestVirtualMediaOpts(t *testing.T) {
 }
 
 func TestVirtualMediaAttach(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAttachVirtualMediaSuccessfully(t, false)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAttachVirtualMediaSuccessfully(t, fakeServer, false)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	opts := nodes.AttachVirtualMediaOpts{
 		ImageURL:   "https://example.com/image",
 		DeviceType: nodes.VirtualMediaCD,
@@ -793,11 +804,11 @@ func TestVirtualMediaAttach(t *testing.T) {
 }
 
 func TestVirtualMediaAttachWithSource(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAttachVirtualMediaSuccessfully(t, true)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAttachVirtualMediaSuccessfully(t, fakeServer, true)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	opts := nodes.AttachVirtualMediaOpts{
 		ImageURL:            "https://example.com/image",
 		DeviceType:          nodes.VirtualMediaCD,
@@ -808,21 +819,21 @@ func TestVirtualMediaAttachWithSource(t *testing.T) {
 }
 
 func TestVirtualMediaDetach(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDetachVirtualMediaSuccessfully(t, false)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDetachVirtualMediaSuccessfully(t, fakeServer, false)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.DetachVirtualMedia(context.TODO(), c, "1234asdf", nodes.DetachVirtualMediaOpts{}).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestVirtualMediaDetachWithTypes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDetachVirtualMediaSuccessfully(t, true)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDetachVirtualMediaSuccessfully(t, fakeServer, true)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	opts := nodes.DetachVirtualMediaOpts{
 		DeviceTypes: []nodes.VirtualMediaDeviceType{nodes.VirtualMediaCD},
 	}
@@ -831,31 +842,31 @@ func TestVirtualMediaDetachWithTypes(t *testing.T) {
 }
 
 func TestVirtualMediaGetAttached(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetVirtualMediaSuccessfully(t, true)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetVirtualMediaSuccessfully(t, fakeServer, true)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.GetVirtualMedia(context.TODO(), c, "1234asdf").Err
 	th.AssertNoErr(t, err)
 }
 
 func TestVirtualMediaGetNotAttached(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetVirtualMediaSuccessfully(t, false)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetVirtualMediaSuccessfully(t, fakeServer, false)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.GetVirtualMedia(context.TODO(), c, "1234asdf").Err
 	th.AssertNoErr(t, err)
 }
 
 func TestListVirtualInterfaces(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListVirtualInterfacesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListVirtualInterfacesSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := nodes.ListVirtualInterfaces(context.TODO(), c, "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 
@@ -869,11 +880,11 @@ func TestListVirtualInterfaces(t *testing.T) {
 }
 
 func TestAttachVirtualInterface(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAttachVirtualInterfaceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAttachVirtualInterfaceSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	opts := nodes.VirtualInterfaceOpts{
 		ID: "1974dcfa-836f-41b2-b541-686c100900e5",
 	}
@@ -882,11 +893,11 @@ func TestAttachVirtualInterface(t *testing.T) {
 }
 
 func TestAttachVirtualInterfaceWithPort(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAttachVirtualInterfaceWithPortSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAttachVirtualInterfaceWithPortSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	opts := nodes.VirtualInterfaceOpts{
 		ID:       "1974dcfa-836f-41b2-b541-686c100900e5",
 		PortUUID: "b2f96298-5172-45e9-b174-8d1ba936ab47",
@@ -896,11 +907,11 @@ func TestAttachVirtualInterfaceWithPort(t *testing.T) {
 }
 
 func TestAttachVirtualInterfaceWithPortgroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAttachVirtualInterfaceWithPortgroupSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAttachVirtualInterfaceWithPortgroupSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	opts := nodes.VirtualInterfaceOpts{
 		ID:            "1974dcfa-836f-41b2-b541-686c100900e5",
 		PortgroupUUID: "c24944b5-a52e-4c5c-9c0a-52a0235a08a2",
@@ -910,11 +921,11 @@ func TestAttachVirtualInterfaceWithPortgroup(t *testing.T) {
 }
 
 func TestDetachVirtualInterface(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDetachVirtualInterfaceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDetachVirtualInterfaceSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := nodes.DetachVirtualInterface(context.TODO(), c, "1234asdf", "1974dcfa-836f-41b2-b541-686c100900e5").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/baremetal/v1/portgroups/testing/fixtures.go b/openstack/baremetal/v1/portgroups/testing/fixtures.go
index 9a8773fd8..52039ca7d 100644
--- a/openstack/baremetal/v1/portgroups/testing/fixtures.go
+++ b/openstack/baremetal/v1/portgroups/testing/fixtures.go
@@ -192,8 +192,8 @@ var (
 
 // HandlePortGroupListSuccessfully sets up the test server to respond to a
 // portgroup List request.
-func HandlePortGroupListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/portgroups", func(w http.ResponseWriter, r *http.Request) {
+func HandlePortGroupListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/portgroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -205,7 +205,7 @@ func HandlePortGroupListSuccessfully(t *testing.T) {
 		switch marker {
 		case "":
 			// Return both portgroups.
-			fmt.Fprintf(w, PortGroupsListBody)
+			fmt.Fprint(w, PortGroupsListBody)
 		case "d2b42f0d-c7e6-4f08-b9bc-e8b23a6ee796":
 			// No portgroups remain.
 			fmt.Fprintf(w, `{ "portgroups": [] }`)
@@ -217,8 +217,8 @@ func HandlePortGroupListSuccessfully(t *testing.T) {
 
 // HandlePortGroupCreationSuccessfully sets up the test server to respond to a PortGroup creation request
 // with a given response.
-func HandlePortGroupCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/portgroups", func(w http.ResponseWriter, r *http.Request) {
+func HandlePortGroupCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/portgroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -241,14 +241,14 @@ func HandlePortGroupCreationSuccessfully(t *testing.T, response string) {
 
 		w.WriteHeader(http.StatusAccepted)
 		w.Header().Add("Content-Type", "application/json")
-		fmt.Fprintf(w, response)
+		fmt.Fprint(w, response)
 	})
 }
 
 // HandlePortGroupDeletionSuccessfully sets up the test server to respond to a
 // portgroup Deletion (DELETE) request for PortGroup2.
-func HandlePortGroupDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/portgroups/d2b42f0d-c7e6-4f08-b9bc-e8b23a6ee796",
+func HandlePortGroupDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/portgroups/d2b42f0d-c7e6-4f08-b9bc-e8b23a6ee796",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -258,14 +258,14 @@ func HandlePortGroupDeletionSuccessfully(t *testing.T) {
 
 // HandlePortGroupGetSuccessfully sets up the test server to respond to a
 // portgroup Get request for PortGroup1.
-func HandlePortGroupGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/portgroups/d2b42f0d-c7e6-4f08-b9bc-e8b23a6ee796",
+func HandlePortGroupGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/portgroups/d2b42f0d-c7e6-4f08-b9bc-e8b23a6ee796",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Accept", "application/json")
 
 			w.Header().Add("Content-Type", "application/json")
-			fmt.Fprintf(w, SinglePortGroupBody)
+			fmt.Fprint(w, SinglePortGroupBody)
 		})
 }
diff --git a/openstack/baremetal/v1/portgroups/testing/requests_test.go b/openstack/baremetal/v1/portgroups/testing/requests_test.go
index 7a818060d..b8dc0b479 100644
--- a/openstack/baremetal/v1/portgroups/testing/requests_test.go
+++ b/openstack/baremetal/v1/portgroups/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestListPortGroups(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortGroupListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortGroupListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := portgroups.List(client.ServiceClient(), portgroups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := portgroups.List(client.ServiceClient(fakeServer), portgroups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := portgroups.ExtractPortGroups(page)
@@ -44,11 +44,11 @@ func TestListPortGroups(t *testing.T) {
 }
 
 func TestCreatePortGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortGroupCreationSuccessfully(t, SinglePortGroupBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortGroupCreationSuccessfully(t, fakeServer, SinglePortGroupBody)
 
-	actual, err := portgroups.Create(context.TODO(), client.ServiceClient(), portgroups.CreateOpts{
+	actual, err := portgroups.Create(context.TODO(), client.ServiceClient(fakeServer), portgroups.CreateOpts{
 		Name:                     "bond0",
 		NodeUUID:                 "f9c9a846-c53f-4b17-9f0c-dd9f459d35c8",
 		Address:                  "00:1a:2b:3c:4d:5e",
@@ -71,20 +71,20 @@ func TestCreatePortGroup(t *testing.T) {
 }
 
 func TestDeletePortGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortGroupDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortGroupDeletionSuccessfully(t, fakeServer)
 
-	res := portgroups.Delete(context.TODO(), client.ServiceClient(), "d2b42f0d-c7e6-4f08-b9bc-e8b23a6ee796")
+	res := portgroups.Delete(context.TODO(), client.ServiceClient(fakeServer), "d2b42f0d-c7e6-4f08-b9bc-e8b23a6ee796")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetPortGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortGroupGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortGroupGetSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := portgroups.Get(context.TODO(), c, "d2b42f0d-c7e6-4f08-b9bc-e8b23a6ee796").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
diff --git a/openstack/baremetal/v1/ports/testing/fixtures_test.go b/openstack/baremetal/v1/ports/testing/fixtures_test.go
index a6221ecd4..0d1ec9cdf 100644
--- a/openstack/baremetal/v1/ports/testing/fixtures_test.go
+++ b/openstack/baremetal/v1/ports/testing/fixtures_test.go
@@ -169,8 +169,8 @@ var (
 )
 
 // HandlePortListSuccessfully sets up the test server to respond to a port List request.
-func HandlePortListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/ports", func(w http.ResponseWriter, r *http.Request) {
+func HandlePortListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -192,8 +192,8 @@ func HandlePortListSuccessfully(t *testing.T) {
 }
 
 // HandlePortListSuccessfully sets up the test server to respond to a port List request.
-func HandlePortListDetailSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/ports/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandlePortListDetailSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/ports/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -207,8 +207,8 @@ func HandlePortListDetailSuccessfully(t *testing.T) {
 
 // HandleSPortCreationSuccessfully sets up the test server to respond to a port creation request
 // with a given response.
-func HandlePortCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/ports", func(w http.ResponseWriter, r *http.Request) {
+func HandlePortCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -224,8 +224,8 @@ func HandlePortCreationSuccessfully(t *testing.T, response string) {
 }
 
 // HandlePortDeletionSuccessfully sets up the test server to respond to a port deletion request.
-func HandlePortDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/ports/3abe3f36-9708-4e9f-b07e-0f898061d3a7", func(w http.ResponseWriter, r *http.Request) {
+func HandlePortDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/ports/3abe3f36-9708-4e9f-b07e-0f898061d3a7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -233,8 +233,8 @@ func HandlePortDeletionSuccessfully(t *testing.T) {
 	})
 }
 
-func HandlePortGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/ports/f2845e11-dbd4-4728-a8c0-30d19f48924a", func(w http.ResponseWriter, r *http.Request) {
+func HandlePortGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/ports/f2845e11-dbd4-4728-a8c0-30d19f48924a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -243,8 +243,8 @@ func HandlePortGetSuccessfully(t *testing.T) {
 	})
 }
 
-func HandlePortUpdateSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/ports/f2845e11-dbd4-4728-a8c0-30d19f48924a", func(w http.ResponseWriter, r *http.Request) {
+func HandlePortUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/ports/f2845e11-dbd4-4728-a8c0-30d19f48924a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/baremetal/v1/ports/testing/requests_test.go b/openstack/baremetal/v1/ports/testing/requests_test.go
index b52d3c521..1d335c24d 100644
--- a/openstack/baremetal/v1/ports/testing/requests_test.go
+++ b/openstack/baremetal/v1/ports/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListDetailPorts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortListDetailSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortListDetailSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := ports.ListDetail(client.ServiceClient(), ports.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := ports.ListDetail(client.ServiceClient(fakeServer), ports.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := ports.ExtractPorts(page)
@@ -41,12 +41,12 @@ func TestListDetailPorts(t *testing.T) {
 }
 
 func TestListPorts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := ports.List(client.ServiceClient(), ports.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := ports.List(client.ServiceClient(fakeServer), ports.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := ports.ExtractPorts(page)
@@ -86,12 +86,12 @@ func TestListOpts(t *testing.T) {
 }
 
 func TestCreatePort(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortCreationSuccessfully(t, SinglePortBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortCreationSuccessfully(t, fakeServer, SinglePortBody)
 
 	iTrue := true
-	actual, err := ports.Create(context.TODO(), client.ServiceClient(), ports.CreateOpts{
+	actual, err := ports.Create(context.TODO(), client.ServiceClient(fakeServer), ports.CreateOpts{
 		NodeUUID:   "ddd06a60-b91e-4ab4-a6e7-56c0b25b6086",
 		Address:    "52:54:00:4d:87:e6",
 		PXEEnabled: &iTrue,
@@ -102,20 +102,20 @@ func TestCreatePort(t *testing.T) {
 }
 
 func TestDeletePort(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortDeletionSuccessfully(t, fakeServer)
 
-	res := ports.Delete(context.TODO(), client.ServiceClient(), "3abe3f36-9708-4e9f-b07e-0f898061d3a7")
+	res := ports.Delete(context.TODO(), client.ServiceClient(fakeServer), "3abe3f36-9708-4e9f-b07e-0f898061d3a7")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetPort(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortGetSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := ports.Get(context.TODO(), c, "f2845e11-dbd4-4728-a8c0-30d19f48924a").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -125,11 +125,11 @@ func TestGetPort(t *testing.T) {
 }
 
 func TestUpdatePort(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePortUpdateSuccessfully(t, SinglePortBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePortUpdateSuccessfully(t, fakeServer, SinglePortBody)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := ports.Update(context.TODO(), c, "f2845e11-dbd4-4728-a8c0-30d19f48924a", ports.UpdateOpts{
 		ports.UpdateOperation{
 			Op:    ports.ReplaceOp,
diff --git a/openstack/baremetalintrospection/v1/introspection/testing/fixtures.go b/openstack/baremetalintrospection/v1/introspection/testing/fixtures.go
index 56a4299ae..6170e5303 100644
--- a/openstack/baremetalintrospection/v1/introspection/testing/fixtures.go
+++ b/openstack/baremetalintrospection/v1/introspection/testing/fixtures.go
@@ -454,8 +454,8 @@ var (
 )
 
 // HandleListIntrospectionsSuccessfully sets up the test server to respond to a server ListIntrospections request.
-func HandleListIntrospectionsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/introspection", func(w http.ResponseWriter, r *http.Request) {
+func HandleListIntrospectionsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/introspection", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -479,8 +479,8 @@ func HandleListIntrospectionsSuccessfully(t *testing.T) {
 }
 
 // HandleGetIntrospectionStatusSuccessfully sets up the test server to respond to a GetIntrospectionStatus request.
-func HandleGetIntrospectionStatusSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetIntrospectionStatusSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -489,8 +489,8 @@ func HandleGetIntrospectionStatusSuccessfully(t *testing.T) {
 }
 
 // HandleStartIntrospectionSuccessfully sets up the test server to respond to a StartIntrospection request.
-func HandleStartIntrospectionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b", func(w http.ResponseWriter, r *http.Request) {
+func HandleStartIntrospectionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
@@ -498,8 +498,8 @@ func HandleStartIntrospectionSuccessfully(t *testing.T) {
 }
 
 // HandleAbortIntrospectionSuccessfully sets up the test server to respond to an AbortIntrospection request.
-func HandleAbortIntrospectionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b/abort", func(w http.ResponseWriter, r *http.Request) {
+func HandleAbortIntrospectionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b/abort", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
@@ -507,8 +507,8 @@ func HandleAbortIntrospectionSuccessfully(t *testing.T) {
 }
 
 // HandleGetIntrospectionDataSuccessfully sets up the test server to respond to a GetIntrospectionData request.
-func HandleGetIntrospectionDataSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b/data", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetIntrospectionDataSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b/data", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -518,8 +518,8 @@ func HandleGetIntrospectionDataSuccessfully(t *testing.T) {
 }
 
 // HandleReApplyIntrospectionSuccessfully sets up the test server to respond to a ReApplyIntrospection request.
-func HandleReApplyIntrospectionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b/data/unprocessed", func(w http.ResponseWriter, r *http.Request) {
+func HandleReApplyIntrospectionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/introspection/c244557e-899f-46fa-a1ff-5b2c6718616b/data/unprocessed", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
diff --git a/openstack/baremetalintrospection/v1/introspection/testing/requests_test.go b/openstack/baremetalintrospection/v1/introspection/testing/requests_test.go
index b36318ce7..97d788c56 100644
--- a/openstack/baremetalintrospection/v1/introspection/testing/requests_test.go
+++ b/openstack/baremetalintrospection/v1/introspection/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListIntrospections(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListIntrospectionsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListIntrospectionsSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := introspection.ListIntrospections(client.ServiceClient(), introspection.ListIntrospectionsOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := introspection.ListIntrospections(client.ServiceClient(fakeServer), introspection.ListIntrospectionsOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := introspection.ExtractIntrospections(page)
@@ -41,11 +41,11 @@ func TestListIntrospections(t *testing.T) {
 }
 
 func TestGetIntrospectionStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetIntrospectionStatusSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetIntrospectionStatusSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := introspection.GetIntrospectionStatus(context.TODO(), c, "c244557e-899f-46fa-a1ff-5b2c6718616b").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -55,31 +55,31 @@ func TestGetIntrospectionStatus(t *testing.T) {
 }
 
 func TestStartIntrospection(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleStartIntrospectionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleStartIntrospectionSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := introspection.StartIntrospection(context.TODO(), c, "c244557e-899f-46fa-a1ff-5b2c6718616b", introspection.StartOpts{}).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestAbortIntrospection(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAbortIntrospectionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAbortIntrospectionSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := introspection.AbortIntrospection(context.TODO(), c, "c244557e-899f-46fa-a1ff-5b2c6718616b").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetIntrospectionData(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetIntrospectionDataSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetIntrospectionDataSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	actual, err := introspection.GetIntrospectionData(context.TODO(), c, "c244557e-899f-46fa-a1ff-5b2c6718616b").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -89,11 +89,11 @@ func TestGetIntrospectionData(t *testing.T) {
 }
 
 func TestReApplyIntrospection(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleReApplyIntrospectionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleReApplyIntrospectionSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	err := introspection.ReApplyIntrospection(context.TODO(), c, "c244557e-899f-46fa-a1ff-5b2c6718616b").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/blockstorage/apiversions/testing/fixtures_test.go b/openstack/blockstorage/apiversions/testing/fixtures_test.go
index ed78b1e47..d4a34b9bf 100644
--- a/openstack/blockstorage/apiversions/testing/fixtures_test.go
+++ b/openstack/blockstorage/apiversions/testing/fixtures_test.go
@@ -116,8 +116,8 @@ const APIListOldResponse = `
   ]
 }`
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -128,8 +128,8 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockListOldResponse(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func MockListOldResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/apiversions/testing/requests_test.go b/openstack/blockstorage/apiversions/testing/requests_test.go
index 1cfcb72e2..ea48e3581 100644
--- a/openstack/blockstorage/apiversions/testing/requests_test.go
+++ b/openstack/blockstorage/apiversions/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allVersions, err := apiversions.List(client.ServiceClient()).AllPages(context.TODO())
+	allVersions, err := apiversions.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := apiversions.ExtractAPIVersions(allVersions)
 	th.AssertNoErr(t, err)
@@ -45,12 +45,12 @@ func TestListVersions(t *testing.T) {
 }
 
 func TestListOldVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListOldResponse(t)
+	MockListOldResponse(t, fakeServer)
 
-	allVersions, err := apiversions.List(client.ServiceClient()).AllPages(context.TODO())
+	allVersions, err := apiversions.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := apiversions.ExtractAPIVersions(allVersions)
 	th.AssertNoErr(t, err)
@@ -72,12 +72,12 @@ func TestListOldVersions(t *testing.T) {
 }
 
 func TestGetVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allVersions, err := apiversions.List(client.ServiceClient()).AllPages(context.TODO())
+	allVersions, err := apiversions.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := apiversions.ExtractAPIVersion(allVersions, "v3.0")
 	th.AssertNoErr(t, err)
@@ -96,12 +96,12 @@ func TestGetVersion(t *testing.T) {
 }
 
 func TestGetOldVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListOldResponse(t)
+	MockListOldResponse(t, fakeServer)
 
-	allVersions, err := apiversions.List(client.ServiceClient()).AllPages(context.TODO())
+	allVersions, err := apiversions.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := apiversions.ExtractAPIVersion(allVersions, "v2.0")
 	th.AssertNoErr(t, err)
diff --git a/openstack/blockstorage/v2/availabilityzones/testing/fixtures_test.go b/openstack/blockstorage/v2/availabilityzones/testing/fixtures_test.go
index 5c48bdce2..9c29adac9 100644
--- a/openstack/blockstorage/v2/availabilityzones/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/availabilityzones/testing/fixtures_test.go
@@ -41,8 +41,8 @@ var AZResult = []az.AvailabilityZone{
 
 // HandleGetSuccessfully configures the test server to respond to a Get request
 // for availability zone information.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-availability-zone", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-availability-zone", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v2/availabilityzones/testing/requests_test.go b/openstack/blockstorage/v2/availabilityzones/testing/requests_test.go
index 4e8e751f4..0873ab6d2 100644
--- a/openstack/blockstorage/v2/availabilityzones/testing/requests_test.go
+++ b/openstack/blockstorage/v2/availabilityzones/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 
 // Verifies that availability zones can be listed correctly
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetSuccessfully(t)
+	HandleGetSuccessfully(t, fakeServer)
 
-	allPages, err := az.List(client.ServiceClient()).AllPages(context.TODO())
+	allPages, err := az.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := az.ExtractAvailabilityZones(allPages)
diff --git a/openstack/blockstorage/v2/backups/testing/fixtures_test.go b/openstack/blockstorage/v2/backups/testing/fixtures_test.go
index 4f1f45c12..f09e16c95 100644
--- a/openstack/blockstorage/v2/backups/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/backups/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v2/backups"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const ListResponse = `
@@ -194,10 +194,10 @@ var (
 	backupURL, _ = json.Marshal(backupImport)
 )
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -208,7 +208,7 @@ func MockListResponse(t *testing.T) {
 		marker := r.Form.Get("marker")
 		switch marker {
 		case "":
-			fmt.Fprintf(w, ListResponse, th.Server.URL)
+			fmt.Fprintf(w, ListResponse, fakeServer.Server.URL)
 		case "1":
 			fmt.Fprint(w, `{"backups": []}`)
 		default:
@@ -217,10 +217,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockListDetailResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListDetailResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -231,7 +231,7 @@ func MockListDetailResponse(t *testing.T) {
 		marker := r.Form.Get("marker")
 		switch marker {
 		case "":
-			fmt.Fprintf(w, ListDetailResponse, th.Server.URL)
+			fmt.Fprintf(w, ListDetailResponse, fakeServer.Server.URL)
 		case "1":
 			fmt.Fprint(w, `{"backups": []}`)
 		default:
@@ -240,10 +240,10 @@ func MockListDetailResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -251,10 +251,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -266,10 +266,10 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockRestoreResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/restore", func(w http.ResponseWriter, r *http.Request) {
+func MockRestoreResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/restore", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, RestoreRequest)
@@ -281,18 +281,18 @@ func MockRestoreResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func MockExportResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/export_record", func(w http.ResponseWriter, r *http.Request) {
+func MockExportResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/export_record", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Add("Content-Type", "application/json")
@@ -302,10 +302,10 @@ func MockExportResponse(t *testing.T) {
 	})
 }
 
-func MockImportResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/import_record", func(w http.ResponseWriter, r *http.Request) {
+func MockImportResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/import_record", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, ImportRequest)
@@ -318,10 +318,10 @@ func MockImportResponse(t *testing.T) {
 }
 
 // MockResetStatusResponse provides mock response for reset backup status API call
-func MockResetStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockResetStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, ResetRequest)
 
@@ -330,10 +330,10 @@ func MockResetStatusResponse(t *testing.T) {
 }
 
 // MockForceDeleteResponse provides mock response for force delete backup API call
-func MockForceDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockForceDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, ForceDeleteRequest)
 
diff --git a/openstack/blockstorage/v2/backups/testing/requests_test.go b/openstack/blockstorage/v2/backups/testing/requests_test.go
index f34bb5f77..4298c6258 100644
--- a/openstack/blockstorage/v2/backups/testing/requests_test.go
+++ b/openstack/blockstorage/v2/backups/testing/requests_test.go
@@ -13,14 +13,14 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
 	count := 0
 
-	err := backups.List(client.ServiceClient(), &backups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := backups.List(client.ServiceClient(fakeServer), &backups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := backups.ExtractBackups(page)
 		if err != nil {
@@ -53,14 +53,14 @@ func TestList(t *testing.T) {
 }
 
 func TestListDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListDetailResponse(t)
+	MockListDetailResponse(t, fakeServer)
 
 	count := 0
 
-	err := backups.ListDetail(client.ServiceClient(), &backups.ListDetailOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := backups.ListDetail(client.ServiceClient(fakeServer), &backups.ListDetailOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := backups.ExtractBackups(page)
 		if err != nil {
@@ -103,12 +103,12 @@ func TestListDetail(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	v, err := backups.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	v, err := backups.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, v.Name, "backup-001")
@@ -116,13 +116,13 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := backups.CreateOpts{VolumeID: "1234", Name: "backup-001"}
-	n, err := backups.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := backups.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.VolumeID, "1234")
@@ -131,13 +131,13 @@ func TestCreate(t *testing.T) {
 }
 
 func TestRestore(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockRestoreResponse(t)
+	MockRestoreResponse(t, fakeServer)
 
 	options := backups.RestoreOpts{VolumeID: "1234", Name: "vol-001"}
-	n, err := backups.RestoreFromBackup(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
+	n, err := backups.RestoreFromBackup(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.VolumeID, "1234")
@@ -146,22 +146,22 @@ func TestRestore(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := backups.Delete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := backups.Delete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestExport(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockExportResponse(t)
+	MockExportResponse(t, fakeServer)
 
-	n, err := backups.Export(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	n, err := backups.Export(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.BackupService, "cinder.backup.drivers.swift.SwiftBackupDriver")
@@ -174,40 +174,40 @@ func TestExport(t *testing.T) {
 }
 
 func TestImport(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockImportResponse(t)
+	MockImportResponse(t, fakeServer)
 
 	options := backups.ImportOpts{
 		BackupService: "cinder.backup.drivers.swift.SwiftBackupDriver",
 		BackupURL:     backupURL,
 	}
-	n, err := backups.Import(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := backups.Import(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.ID, "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 }
 
 func TestResetStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStatusResponse(t)
+	MockResetStatusResponse(t, fakeServer)
 
 	opts := &backups.ResetStatusOpts{
 		Status: "error",
 	}
-	res := backups.ResetStatus(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", opts)
+	res := backups.ResetStatus(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", opts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestForceDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockForceDeleteResponse(t)
+	MockForceDeleteResponse(t, fakeServer)
 
-	res := backups.ForceDelete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := backups.ForceDelete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/blockstorage/v2/limits/testing/fixtures_test.go b/openstack/blockstorage/v2/limits/testing/fixtures_test.go
index bdd1308a1..44d9166d7 100644
--- a/openstack/blockstorage/v2/limits/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/limits/testing/fixtures_test.go
@@ -118,8 +118,8 @@ var LimitsResult = limits.Limits{
 
 // HandleGetSuccessfully configures the test server to respond to a Get request
 // for a limit.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v2/limits/testing/requests_test.go b/openstack/blockstorage/v2/limits/testing/requests_test.go
index a7b6c0a50..660c84a02 100644
--- a/openstack/blockstorage/v2/limits/testing/requests_test.go
+++ b/openstack/blockstorage/v2/limits/testing/requests_test.go
@@ -10,11 +10,11 @@ import (
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := limits.Get(context.TODO(), client.ServiceClient()).Extract()
+	actual, err := limits.Get(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &LimitsResult, actual)
 }
diff --git a/openstack/blockstorage/v2/quotasets/testing/fixtures_test.go b/openstack/blockstorage/v2/quotasets/testing/fixtures_test.go
index 1e26bec78..ad5914798 100644
--- a/openstack/blockstorage/v2/quotasets/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/quotasets/testing/fixtures_test.go
@@ -173,9 +173,9 @@ var partialUpdateExpectedQuotaSet = quotasets.QuotaSet{
 }
 
 // HandleSuccessfulRequest configures the test server to respond to an HTTP request.
-func HandleSuccessfulRequest(t *testing.T, httpMethod, uriPath, jsonOutput string, uriQueryParams map[string]string) {
+func HandleSuccessfulRequest(t *testing.T, fakeServer th.FakeServer, httpMethod, uriPath, jsonOutput string, uriQueryParams map[string]string) {
 
-	th.Mux.HandleFunc(uriPath, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(uriPath, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, httpMethod)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -189,8 +189,8 @@ func HandleSuccessfulRequest(t *testing.T, httpMethod, uriPath, jsonOutput strin
 }
 
 // HandleDeleteSuccessfully tests quotaset deletion.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v2/quotasets/testing/requests_test.go b/openstack/blockstorage/v2/quotasets/testing/requests_test.go
index 025d824f2..7a5bc8fe0 100644
--- a/openstack/blockstorage/v2/quotasets/testing/requests_test.go
+++ b/openstack/blockstorage/v2/quotasets/testing/requests_test.go
@@ -11,45 +11,45 @@ import (
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	uriQueryParms := map[string]string{}
-	HandleSuccessfulRequest(t, "GET", "/os-quota-sets/"+FirstTenantID, getExpectedJSONBody, uriQueryParms)
-	actual, err := quotasets.Get(context.TODO(), client.ServiceClient(), FirstTenantID).Extract()
+	HandleSuccessfulRequest(t, fakeServer, "GET", "/os-quota-sets/"+FirstTenantID, getExpectedJSONBody, uriQueryParms)
+	actual, err := quotasets.Get(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &getExpectedQuotaSet, actual)
 }
 
 func TestGetUsage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	uriQueryParms := map[string]string{"usage": "true"}
-	HandleSuccessfulRequest(t, "GET", "/os-quota-sets/"+FirstTenantID, getUsageExpectedJSONBody, uriQueryParms)
-	actual, err := quotasets.GetUsage(context.TODO(), client.ServiceClient(), FirstTenantID).Extract()
+	HandleSuccessfulRequest(t, fakeServer, "GET", "/os-quota-sets/"+FirstTenantID, getUsageExpectedJSONBody, uriQueryParms)
+	actual, err := quotasets.GetUsage(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, getUsageExpectedQuotaSet, actual)
 }
 
 func TestFullUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	uriQueryParms := map[string]string{}
-	HandleSuccessfulRequest(t, "PUT", "/os-quota-sets/"+FirstTenantID, fullUpdateExpectedJSONBody, uriQueryParms)
-	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, fullUpdateOpts).Extract()
+	HandleSuccessfulRequest(t, fakeServer, "PUT", "/os-quota-sets/"+FirstTenantID, fullUpdateExpectedJSONBody, uriQueryParms)
+	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, fullUpdateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &fullUpdateExpectedQuotaSet, actual)
 }
 
 func TestPartialUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	uriQueryParms := map[string]string{}
-	HandleSuccessfulRequest(t, "PUT", "/os-quota-sets/"+FirstTenantID, partialUpdateExpectedJSONBody, uriQueryParms)
-	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, partialUpdateOpts).Extract()
+	HandleSuccessfulRequest(t, fakeServer, "PUT", "/os-quota-sets/"+FirstTenantID, partialUpdateExpectedJSONBody, uriQueryParms)
+	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, partialUpdateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &partialUpdateExpectedQuotaSet, actual)
 }
@@ -62,20 +62,20 @@ func (opts ErrorUpdateOpts) ToBlockStorageQuotaUpdateMap() (map[string]any, erro
 
 func TestErrorInToBlockStorageQuotaUpdateMap(t *testing.T) {
 	opts := &ErrorUpdateOpts{}
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSuccessfulRequest(t, "PUT", "/os-quota-sets/"+FirstTenantID, "", nil)
-	_, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, opts).Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSuccessfulRequest(t, fakeServer, "PUT", "/os-quota-sets/"+FirstTenantID, "", nil)
+	_, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, opts).Extract()
 	if err == nil {
 		t.Fatal("Error handling failed")
 	}
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	err := quotasets.Delete(context.TODO(), client.ServiceClient(), FirstTenantID).ExtractErr()
+	err := quotasets.Delete(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/blockstorage/v2/schedulerstats/testing/fixtures_test.go b/openstack/blockstorage/v2/schedulerstats/testing/fixtures_test.go
index 05512dbf6..b37281131 100644
--- a/openstack/blockstorage/v2/schedulerstats/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/schedulerstats/testing/fixtures_test.go
@@ -93,8 +93,8 @@ var (
 	}
 )
 
-func HandleStoragePoolsListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/scheduler-stats/get_pools", func(w http.ResponseWriter, r *http.Request) {
+func HandleStoragePoolsListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/scheduler-stats/get_pools", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v2/schedulerstats/testing/requests_test.go b/openstack/blockstorage/v2/schedulerstats/testing/requests_test.go
index 7a6cb8b45..35bdb7ea6 100644
--- a/openstack/blockstorage/v2/schedulerstats/testing/requests_test.go
+++ b/openstack/blockstorage/v2/schedulerstats/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListStoragePoolsDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleStoragePoolsListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleStoragePoolsListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := schedulerstats.List(client.ServiceClient(), schedulerstats.ListOpts{Detail: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := schedulerstats.List(client.ServiceClient(fakeServer), schedulerstats.ListOpts{Detail: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := schedulerstats.ExtractStoragePools(page)
diff --git a/openstack/blockstorage/v2/services/testing/fixtures_test.go b/openstack/blockstorage/v2/services/testing/fixtures_test.go
index 41fb5bc61..398ad96c4 100644
--- a/openstack/blockstorage/v2/services/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/services/testing/fixtures_test.go
@@ -86,8 +86,8 @@ var ThirdFakeService = services.Service{
 }
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-services", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-services", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v2/services/testing/requests_test.go b/openstack/blockstorage/v2/services/testing/requests_test.go
index d1277a99b..9fbbe6120 100644
--- a/openstack/blockstorage/v2/services/testing/requests_test.go
+++ b/openstack/blockstorage/v2/services/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListServices(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := services.List(client.ServiceClient(), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := services.List(client.ServiceClient(fakeServer), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := services.ExtractServices(page)
diff --git a/openstack/blockstorage/v2/snapshots/testing/fixtures_test.go b/openstack/blockstorage/v2/snapshots/testing/fixtures_test.go
index b2e5cf4c0..964dfff2e 100644
--- a/openstack/blockstorage/v2/snapshots/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/snapshots/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -44,10 +44,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -67,10 +67,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -102,10 +102,10 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockUpdateMetadataResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/123/metadata", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateMetadataResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/123/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, `
     {
@@ -125,10 +125,10 @@ func MockUpdateMetadataResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
diff --git a/openstack/blockstorage/v2/snapshots/testing/requests_test.go b/openstack/blockstorage/v2/snapshots/testing/requests_test.go
index 07d74a14a..e3b140ce3 100644
--- a/openstack/blockstorage/v2/snapshots/testing/requests_test.go
+++ b/openstack/blockstorage/v2/snapshots/testing/requests_test.go
@@ -12,14 +12,14 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
 	count := 0
 
-	err := snapshots.List(client.ServiceClient(), &snapshots.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := snapshots.List(client.ServiceClient(fakeServer), &snapshots.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := snapshots.ExtractSnapshots(page)
 		if err != nil {
@@ -60,12 +60,12 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	v, err := snapshots.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	v, err := snapshots.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, v.Name, "snapshot-001")
@@ -73,13 +73,13 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := snapshots.CreateOpts{VolumeID: "1234", Name: "snapshot-001"}
-	n, err := snapshots.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := snapshots.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.VolumeID, "1234")
@@ -88,10 +88,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdateMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateMetadataResponse(t)
+	MockUpdateMetadataResponse(t, fakeServer)
 
 	expected := map[string]any{"key": "v1"}
 
@@ -101,18 +101,18 @@ func TestUpdateMetadata(t *testing.T) {
 		},
 	}
 
-	actual, err := snapshots.UpdateMetadata(context.TODO(), client.ServiceClient(), "123", options).ExtractMetadata()
+	actual, err := snapshots.UpdateMetadata(context.TODO(), client.ServiceClient(fakeServer), "123", options).ExtractMetadata()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, actual, expected)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := snapshots.Delete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := snapshots.Delete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/blockstorage/v2/transfers/testing/fixtures_test.go b/openstack/blockstorage/v2/transfers/testing/fixtures_test.go
index 866d5068f..f24b7fa82 100644
--- a/openstack/blockstorage/v2/transfers/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/transfers/testing/fixtures_test.go
@@ -159,8 +159,8 @@ var AcceptResponse = transfers.Transfer{
 	},
 }
 
-func HandleCreateTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -171,8 +171,8 @@ func HandleCreateTransfer(t *testing.T) {
 	})
 }
 
-func HandleAcceptTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f/accept", func(w http.ResponseWriter, r *http.Request) {
+func HandleAcceptTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f/accept", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -183,8 +183,8 @@ func HandleAcceptTransfer(t *testing.T) {
 	})
 }
 
-func HandleDeleteTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -192,8 +192,8 @@ func HandleDeleteTransfer(t *testing.T) {
 	})
 }
 
-func HandleListTransfers(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleListTransfers(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -204,8 +204,8 @@ func HandleListTransfers(t *testing.T) {
 	})
 }
 
-func HandleGetTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
diff --git a/openstack/blockstorage/v2/transfers/testing/requests_test.go b/openstack/blockstorage/v2/transfers/testing/requests_test.go
index 32501eb09..f6404fb2a 100644
--- a/openstack/blockstorage/v2/transfers/testing/requests_test.go
+++ b/openstack/blockstorage/v2/transfers/testing/requests_test.go
@@ -11,44 +11,44 @@ import (
 )
 
 func TestCreateTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateTransfer(t, fakeServer)
 
-	actual, err := transfers.Create(context.TODO(), client.ServiceClient(), TransferRequest).Extract()
+	actual, err := transfers.Create(context.TODO(), client.ServiceClient(fakeServer), TransferRequest).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, TransferResponse, *actual)
 }
 
 func TestAcceptTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAcceptTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAcceptTransfer(t, fakeServer)
 
-	actual, err := transfers.Accept(context.TODO(), client.ServiceClient(), TransferResponse.ID, AcceptRequest).Extract()
+	actual, err := transfers.Accept(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID, AcceptRequest).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, AcceptResponse, *actual)
 }
 
 func TestDeleteTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteTransfer(t, fakeServer)
 
-	err := transfers.Delete(context.TODO(), client.ServiceClient(), TransferResponse.ID).ExtractErr()
+	err := transfers.Delete(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListTransfers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTransfers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTransfers(t, fakeServer)
 
 	expectedResponse := TransferListResponse
 	expectedResponse[0].AuthKey = ""
 
 	count := 0
-	err := transfers.List(client.ServiceClient(), &transfers.ListOpts{AllTenants: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := transfers.List(client.ServiceClient(fakeServer), &transfers.ListOpts{AllTenants: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := transfers.ExtractTransfers(page)
@@ -63,14 +63,14 @@ func TestListTransfers(t *testing.T) {
 }
 
 func TestListTransfersAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTransfers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTransfers(t, fakeServer)
 
 	expectedResponse := TransferListResponse
 	expectedResponse[0].AuthKey = ""
 
-	allPages, err := transfers.List(client.ServiceClient(), &transfers.ListOpts{AllTenants: true}).AllPages(context.TODO())
+	allPages, err := transfers.List(client.ServiceClient(fakeServer), &transfers.ListOpts{AllTenants: true}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := transfers.ExtractTransfers(allPages)
 	th.AssertNoErr(t, err)
@@ -78,14 +78,14 @@ func TestListTransfersAllPages(t *testing.T) {
 }
 
 func TestGetTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetTransfer(t, fakeServer)
 
 	expectedResponse := TransferResponse
 	expectedResponse.AuthKey = ""
 
-	actual, err := transfers.Get(context.TODO(), client.ServiceClient(), TransferResponse.ID).Extract()
+	actual, err := transfers.Get(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expectedResponse, *actual)
 }
diff --git a/openstack/blockstorage/v2/volumes/testing/fixtures_test.go b/openstack/blockstorage/v2/volumes/testing/fixtures_test.go
index d6688f785..5b7331028 100644
--- a/openstack/blockstorage/v2/volumes/testing/fixtures_test.go
+++ b/openstack/blockstorage/v2/volumes/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -86,10 +86,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -134,10 +134,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -179,18 +179,18 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `
 {
@@ -202,11 +202,11 @@ func MockUpdateResponse(t *testing.T) {
 	})
 }
 
-func MockAttachResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockAttachResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -227,11 +227,11 @@ func MockAttachResponse(t *testing.T) {
 		})
 }
 
-func MockBeginDetachingResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockBeginDetachingResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -247,11 +247,11 @@ func MockBeginDetachingResponse(t *testing.T) {
 		})
 }
 
-func MockDetachResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockDetachResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -267,11 +267,11 @@ func MockDetachResponse(t *testing.T) {
 		})
 }
 
-func MockUploadImageResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockUploadImageResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -319,11 +319,11 @@ func MockUploadImageResponse(t *testing.T) {
 		})
 }
 
-func MockReserveResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockReserveResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -339,11 +339,11 @@ func MockReserveResponse(t *testing.T) {
 		})
 }
 
-func MockUnreserveResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockUnreserveResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -359,11 +359,11 @@ func MockUnreserveResponse(t *testing.T) {
 		})
 }
 
-func MockInitializeConnectionResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockInitializeConnectionResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -416,11 +416,11 @@ func MockInitializeConnectionResponse(t *testing.T) {
 		})
 }
 
-func MockTerminateConnectionResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockTerminateConnectionResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -447,11 +447,11 @@ func MockTerminateConnectionResponse(t *testing.T) {
 		})
 }
 
-func MockExtendSizeResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockExtendSizeResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -470,19 +470,19 @@ func MockExtendSizeResponse(t *testing.T) {
 		})
 }
 
-func MockForceDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockForceDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestBody(t, r, `{"os-force_delete":""}`)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockSetImageMetadataResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
+func MockSetImageMetadataResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -501,10 +501,10 @@ func MockSetImageMetadataResponse(t *testing.T) {
 	})
 }
 
-func MockSetBootableResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
+func MockSetBootableResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -520,10 +520,10 @@ func MockSetBootableResponse(t *testing.T) {
 	})
 }
 
-func MockReImageResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
+func MockReImageResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -540,11 +540,11 @@ func MockReImageResponse(t *testing.T) {
 	})
 }
 
-func MockChangeTypeResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockChangeTypeResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -564,11 +564,11 @@ func MockChangeTypeResponse(t *testing.T) {
 		})
 }
 
-func MockResetStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockResetStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestJSONRequest(t, r, `
 {
diff --git a/openstack/blockstorage/v2/volumes/testing/requests_test.go b/openstack/blockstorage/v2/volumes/testing/requests_test.go
index 3d829a56a..3a1819b3c 100644
--- a/openstack/blockstorage/v2/volumes/testing/requests_test.go
+++ b/openstack/blockstorage/v2/volumes/testing/requests_test.go
@@ -13,14 +13,14 @@ import (
 )
 
 func TestListWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
 	count := 0
 
-	err := volumes.List(client.ServiceClient(), &volumes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := volumes.List(client.ServiceClient(fakeServer), &volumes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := volumes.ExtractVolumes(page)
 		if err != nil {
@@ -97,12 +97,12 @@ func TestListWithExtensions(t *testing.T) {
 }
 
 func TestListAllWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := volumes.List(client.ServiceClient(), &volumes.ListOpts{}).AllPages(context.TODO())
+	allPages, err := volumes.List(client.ServiceClient(fakeServer), &volumes.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	var actual []volumes.Volume
@@ -113,12 +113,12 @@ func TestListAllWithExtensions(t *testing.T) {
 }
 
 func TestListAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := volumes.List(client.ServiceClient(), &volumes.ListOpts{}).AllPages(context.TODO())
+	allPages, err := volumes.List(client.ServiceClient(fakeServer), &volumes.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := volumes.ExtractVolumes(allPages)
 	th.AssertNoErr(t, err)
@@ -185,12 +185,12 @@ func TestListAll(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	v, err := volumes.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	v, err := volumes.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, v.Name, "vol-001")
@@ -198,13 +198,13 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &volumes.CreateOpts{Size: 75, Name: "vol-001"}
-	n, err := volumes.Create(context.TODO(), client.ServiceClient(), options, nil).Extract()
+	n, err := volumes.Create(context.TODO(), client.ServiceClient(fakeServer), options, nil).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Size, 75)
@@ -246,84 +246,84 @@ func TestCreateSchedulerHints(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := volumes.Delete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", volumes.DeleteOpts{})
+	res := volumes.Delete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", volumes.DeleteOpts{})
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateResponse(t)
+	MockUpdateResponse(t, fakeServer)
 
 	var name = "vol-002"
 	options := volumes.UpdateOpts{Name: &name}
-	v, err := volumes.Update(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
+	v, err := volumes.Update(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckEquals(t, "vol-002", v.Name)
 }
 
 func TestGetWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
 	var v volumes.Volume
-	err := volumes.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&v)
+	err := volumes.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&v)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, "304dc00909ac4d0da6c62d816bcb3459", v.TenantID)
 
-	err = volumes.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(v)
+	err = volumes.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(v)
 	if err == nil {
 		t.Errorf("Expected error when providing non-pointer struct")
 	}
 }
 
 func TestAttach(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockAttachResponse(t)
+	MockAttachResponse(t, fakeServer)
 
 	options := &volumes.AttachOpts{
 		MountPoint:   "/mnt",
 		Mode:         "rw",
 		InstanceUUID: "50902f4f-a974-46a0-85e9-7efc5e22dfdd",
 	}
-	err := volumes.Attach(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.Attach(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestBeginDetaching(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockBeginDetachingResponse(t)
+	MockBeginDetachingResponse(t, fakeServer)
 
-	err := volumes.BeginDetaching(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
+	err := volumes.BeginDetaching(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDetach(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDetachResponse(t)
+	MockDetachResponse(t, fakeServer)
 
-	err := volumes.Detach(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", &volumes.DetachOpts{}).ExtractErr()
+	err := volumes.Detach(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", &volumes.DetachOpts{}).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUploadImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	MockUploadImageResponse(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	MockUploadImageResponse(t, fakeServer)
 	options := &volumes.UploadImageOpts{
 		ContainerFormat: "bare",
 		DiskFormat:      "raw",
@@ -331,7 +331,7 @@ func TestUploadImage(t *testing.T) {
 		Force:           true,
 	}
 
-	actual, err := volumes.UploadImage(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).Extract()
+	actual, err := volumes.UploadImage(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := volumes.VolumeImage{
@@ -361,30 +361,30 @@ func TestUploadImage(t *testing.T) {
 }
 
 func TestReserve(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockReserveResponse(t)
+	MockReserveResponse(t, fakeServer)
 
-	err := volumes.Reserve(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
+	err := volumes.Reserve(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUnreserve(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUnreserveResponse(t)
+	MockUnreserveResponse(t, fakeServer)
 
-	err := volumes.Unreserve(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
+	err := volumes.Unreserve(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestInitializeConnection(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockInitializeConnectionResponse(t)
+	MockInitializeConnectionResponse(t, fakeServer)
 
 	options := &volumes.InitializeConnectionOpts{
 		IP:        "127.0.0.1",
@@ -394,15 +394,15 @@ func TestInitializeConnection(t *testing.T) {
 		Platform:  "x86_64",
 		OSType:    "linux2",
 	}
-	_, err := volumes.InitializeConnection(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).Extract()
+	_, err := volumes.InitializeConnection(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestTerminateConnection(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockTerminateConnectionResponse(t)
+	MockTerminateConnectionResponse(t, fakeServer)
 
 	options := &volumes.TerminateConnectionOpts{
 		IP:        "127.0.0.1",
@@ -412,39 +412,39 @@ func TestTerminateConnection(t *testing.T) {
 		Platform:  "x86_64",
 		OSType:    "linux2",
 	}
-	err := volumes.TerminateConnection(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.TerminateConnection(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestExtendSize(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockExtendSizeResponse(t)
+	MockExtendSizeResponse(t, fakeServer)
 
 	options := &volumes.ExtendSizeOpts{
 		NewSize: 3,
 	}
 
-	err := volumes.ExtendSize(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.ExtendSize(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestForceDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockForceDeleteResponse(t)
+	MockForceDeleteResponse(t, fakeServer)
 
-	res := volumes.ForceDelete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := volumes.ForceDelete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestSetImageMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockSetImageMetadataResponse(t)
+	MockSetImageMetadataResponse(t, fakeServer)
 
 	options := &volumes.ImageMetadataOpts{
 		Metadata: map[string]string{
@@ -452,59 +452,59 @@ func TestSetImageMetadata(t *testing.T) {
 		},
 	}
 
-	err := volumes.SetImageMetadata(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.SetImageMetadata(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestSetBootable(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockSetBootableResponse(t)
+	MockSetBootableResponse(t, fakeServer)
 
 	options := volumes.BootableOpts{
 		Bootable: true,
 	}
 
-	err := volumes.SetBootable(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.SetBootable(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestReImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockReImageResponse(t)
+	MockReImageResponse(t, fakeServer)
 
 	options := volumes.ReImageOpts{
 		ImageID:         "71543ced-a8af-45b6-a5c4-a46282108a90",
 		ReImageReserved: false,
 	}
 
-	err := volumes.ReImage(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.ReImage(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestChangeType(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockChangeTypeResponse(t)
+	MockChangeTypeResponse(t, fakeServer)
 
 	options := &volumes.ChangeTypeOpts{
 		NewType:         "ssd",
 		MigrationPolicy: "on-demand",
 	}
 
-	err := volumes.ChangeType(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.ChangeType(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestResetStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStatusResponse(t)
+	MockResetStatusResponse(t, fakeServer)
 
 	options := &volumes.ResetStatusOpts{
 		Status:          "error",
@@ -512,6 +512,6 @@ func TestResetStatus(t *testing.T) {
 		MigrationStatus: "migrating",
 	}
 
-	err := volumes.ResetStatus(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.ResetStatus(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/blockstorage/v3/attachments/testing/fixtures_test.go b/openstack/blockstorage/v3/attachments/testing/fixtures_test.go
index 18471c3b3..6d35b5f30 100644
--- a/openstack/blockstorage/v3/attachments/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/attachments/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/attachments"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 var (
@@ -27,10 +27,10 @@ var (
 	}
 )
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/attachments/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/attachments/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -62,7 +62,7 @@ func MockListResponse(t *testing.T) {
 	}
     ]
 }
-  `, th.Server.URL)
+  `, fakeServer.Server.URL)
 		case "1":
 			fmt.Fprint(w, `{"volumes": []}`)
 		default:
@@ -71,10 +71,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -95,10 +95,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/attachments", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/attachments", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -140,18 +140,18 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 	})
 }
 
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -188,10 +188,10 @@ func MockUpdateResponse(t *testing.T) {
 	})
 }
 
-func MockUpdateEmptyResponse(t *testing.T) {
-	th.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateEmptyResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -225,10 +225,10 @@ var completeRequest = `
 }
 `
 
-func MockCompleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a/action", func(w http.ResponseWriter, r *http.Request) {
+func MockCompleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/attachments/05551600-a936-4d4a-ba42-79a037c1-c91a/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, completeRequest)
 		w.WriteHeader(http.StatusNoContent)
 	})
diff --git a/openstack/blockstorage/v3/attachments/testing/requests_test.go b/openstack/blockstorage/v3/attachments/testing/requests_test.go
index 4f9f91dcb..5f1591950 100644
--- a/openstack/blockstorage/v3/attachments/testing/requests_test.go
+++ b/openstack/blockstorage/v3/attachments/testing/requests_test.go
@@ -10,12 +10,12 @@ import (
 )
 
 func TestListAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := attachments.List(client.ServiceClient(), &attachments.ListOpts{}).AllPages(context.TODO())
+	allPages, err := attachments.List(client.ServiceClient(fakeServer), &attachments.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := attachments.ExtractAttachments(allPages)
 	th.AssertNoErr(t, err)
@@ -27,22 +27,22 @@ func TestListAll(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	attachment, err := attachments.Get(context.TODO(), client.ServiceClient(), "05551600-a936-4d4a-ba42-79a037c1-c91a").Extract()
+	attachment, err := attachments.Get(context.TODO(), client.ServiceClient(fakeServer), "05551600-a936-4d4a-ba42-79a037c1-c91a").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, expectedAttachment, attachment)
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &attachments.CreateOpts{
 		InstanceUUID: "83ec2e3b-4321-422b-8706-a84185f52a0a",
@@ -58,27 +58,27 @@ func TestCreate(t *testing.T) {
 		},
 		VolumeUUID: "289da7f8-6440-407c-9fb4-7db01ec49164",
 	}
-	attachment, err := attachments.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	attachment, err := attachments.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, expectedAttachment, attachment)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := attachments.Delete(context.TODO(), client.ServiceClient(), "05551600-a936-4d4a-ba42-79a037c1-c91a")
+	res := attachments.Delete(context.TODO(), client.ServiceClient(fakeServer), "05551600-a936-4d4a-ba42-79a037c1-c91a")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateResponse(t)
+	MockUpdateResponse(t, fakeServer)
 
 	options := &attachments.UpdateOpts{
 		Connector: map[string]any{
@@ -92,29 +92,29 @@ func TestUpdate(t *testing.T) {
 			"mode":       "rw",
 		},
 	}
-	attachment, err := attachments.Update(context.TODO(), client.ServiceClient(), "05551600-a936-4d4a-ba42-79a037c1-c91a", options).Extract()
+	attachment, err := attachments.Update(context.TODO(), client.ServiceClient(fakeServer), "05551600-a936-4d4a-ba42-79a037c1-c91a", options).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expectedAttachment, attachment)
 }
 
 func TestUpdateEmpty(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateEmptyResponse(t)
+	MockUpdateEmptyResponse(t, fakeServer)
 
 	options := attachments.UpdateOpts{}
-	attachment, err := attachments.Update(context.TODO(), client.ServiceClient(), "05551600-a936-4d4a-ba42-79a037c1-c91a", options).Extract()
+	attachment, err := attachments.Update(context.TODO(), client.ServiceClient(fakeServer), "05551600-a936-4d4a-ba42-79a037c1-c91a", options).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expectedAttachment, attachment)
 }
 
 func TestComplete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCompleteResponse(t)
+	MockCompleteResponse(t, fakeServer)
 
-	err := attachments.Complete(context.TODO(), client.ServiceClient(), "05551600-a936-4d4a-ba42-79a037c1-c91a").ExtractErr()
+	err := attachments.Complete(context.TODO(), client.ServiceClient(fakeServer), "05551600-a936-4d4a-ba42-79a037c1-c91a").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/blockstorage/v3/availabilityzones/testing/fixtures_test.go b/openstack/blockstorage/v3/availabilityzones/testing/fixtures_test.go
index 780c7dec2..067ba9fa1 100644
--- a/openstack/blockstorage/v3/availabilityzones/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/availabilityzones/testing/fixtures_test.go
@@ -41,8 +41,8 @@ var AZResult = []az.AvailabilityZone{
 
 // HandleGetSuccessfully configures the test server to respond to a Get request
 // for availability zone information.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-availability-zone", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-availability-zone", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v3/availabilityzones/testing/requests_test.go b/openstack/blockstorage/v3/availabilityzones/testing/requests_test.go
index 3d1ed1bd0..fce05f2c0 100644
--- a/openstack/blockstorage/v3/availabilityzones/testing/requests_test.go
+++ b/openstack/blockstorage/v3/availabilityzones/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 
 // Verifies that availability zones can be listed correctly
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetSuccessfully(t)
+	HandleGetSuccessfully(t, fakeServer)
 
-	allPages, err := az.List(client.ServiceClient()).AllPages(context.TODO())
+	allPages, err := az.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := az.ExtractAvailabilityZones(allPages)
diff --git a/openstack/blockstorage/v3/backups/testing/fixtures_test.go b/openstack/blockstorage/v3/backups/testing/fixtures_test.go
index 9bbaec87d..51b0f953a 100644
--- a/openstack/blockstorage/v3/backups/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/backups/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/backups"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const ListResponse = `
@@ -194,10 +194,10 @@ var (
 	backupURL, _ = json.Marshal(backupImport)
 )
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -208,7 +208,7 @@ func MockListResponse(t *testing.T) {
 		marker := r.Form.Get("marker")
 		switch marker {
 		case "":
-			fmt.Fprintf(w, ListResponse, th.Server.URL)
+			fmt.Fprintf(w, ListResponse, fakeServer.Server.URL)
 		case "1":
 			fmt.Fprint(w, `{"backups": []}`)
 		default:
@@ -217,10 +217,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockListDetailResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListDetailResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -231,7 +231,7 @@ func MockListDetailResponse(t *testing.T) {
 		marker := r.Form.Get("marker")
 		switch marker {
 		case "":
-			fmt.Fprintf(w, ListDetailResponse, th.Server.URL)
+			fmt.Fprintf(w, ListDetailResponse, fakeServer.Server.URL)
 		case "1":
 			fmt.Fprint(w, `{"backups": []}`)
 		default:
@@ -240,10 +240,10 @@ func MockListDetailResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -251,10 +251,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -266,10 +266,10 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockRestoreResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/restore", func(w http.ResponseWriter, r *http.Request) {
+func MockRestoreResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/restore", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, RestoreRequest)
@@ -281,18 +281,18 @@ func MockRestoreResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func MockExportResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/export_record", func(w http.ResponseWriter, r *http.Request) {
+func MockExportResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/export_record", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Add("Content-Type", "application/json")
@@ -302,10 +302,10 @@ func MockExportResponse(t *testing.T) {
 	})
 }
 
-func MockImportResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/import_record", func(w http.ResponseWriter, r *http.Request) {
+func MockImportResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/import_record", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, ImportRequest)
@@ -318,10 +318,10 @@ func MockImportResponse(t *testing.T) {
 }
 
 // MockResetStatusResponse provides mock response for reset backup status API call
-func MockResetStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockResetStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, ResetRequest)
 
@@ -330,10 +330,10 @@ func MockResetStatusResponse(t *testing.T) {
 }
 
 // MockForceDeleteResponse provides mock response for force delete backup API call
-func MockForceDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockForceDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/backups/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, ForceDeleteRequest)
 
diff --git a/openstack/blockstorage/v3/backups/testing/requests_test.go b/openstack/blockstorage/v3/backups/testing/requests_test.go
index b9c302896..76b39cb09 100644
--- a/openstack/blockstorage/v3/backups/testing/requests_test.go
+++ b/openstack/blockstorage/v3/backups/testing/requests_test.go
@@ -13,14 +13,14 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
 	count := 0
 
-	err := backups.List(client.ServiceClient(), &backups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := backups.List(client.ServiceClient(fakeServer), &backups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := backups.ExtractBackups(page)
 		if err != nil {
@@ -53,14 +53,14 @@ func TestList(t *testing.T) {
 }
 
 func TestListDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListDetailResponse(t)
+	MockListDetailResponse(t, fakeServer)
 
 	count := 0
 
-	err := backups.ListDetail(client.ServiceClient(), &backups.ListDetailOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := backups.ListDetail(client.ServiceClient(fakeServer), &backups.ListDetailOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := backups.ExtractBackups(page)
 		if err != nil {
@@ -103,12 +103,12 @@ func TestListDetail(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	v, err := backups.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	v, err := backups.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, v.Name, "backup-001")
@@ -116,13 +116,13 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := backups.CreateOpts{VolumeID: "1234", Name: "backup-001"}
-	n, err := backups.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := backups.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.VolumeID, "1234")
@@ -131,13 +131,13 @@ func TestCreate(t *testing.T) {
 }
 
 func TestRestore(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockRestoreResponse(t)
+	MockRestoreResponse(t, fakeServer)
 
 	options := backups.RestoreOpts{VolumeID: "1234", Name: "vol-001"}
-	n, err := backups.RestoreFromBackup(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
+	n, err := backups.RestoreFromBackup(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.VolumeID, "1234")
@@ -146,22 +146,22 @@ func TestRestore(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := backups.Delete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := backups.Delete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestExport(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockExportResponse(t)
+	MockExportResponse(t, fakeServer)
 
-	n, err := backups.Export(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	n, err := backups.Export(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.BackupService, "cinder.backup.drivers.swift.SwiftBackupDriver")
@@ -174,40 +174,40 @@ func TestExport(t *testing.T) {
 }
 
 func TestImport(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockImportResponse(t)
+	MockImportResponse(t, fakeServer)
 
 	options := backups.ImportOpts{
 		BackupService: "cinder.backup.drivers.swift.SwiftBackupDriver",
 		BackupURL:     backupURL,
 	}
-	n, err := backups.Import(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := backups.Import(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.ID, "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 }
 
 func TestResetStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStatusResponse(t)
+	MockResetStatusResponse(t, fakeServer)
 
 	opts := &backups.ResetStatusOpts{
 		Status: "error",
 	}
-	res := backups.ResetStatus(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", opts)
+	res := backups.ResetStatus(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", opts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestForceDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockForceDeleteResponse(t)
+	MockForceDeleteResponse(t, fakeServer)
 
-	res := backups.ForceDelete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := backups.ForceDelete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/blockstorage/v3/limits/testing/fixtures_test.go b/openstack/blockstorage/v3/limits/testing/fixtures_test.go
index 68fe8ae83..318ef7779 100644
--- a/openstack/blockstorage/v3/limits/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/limits/testing/fixtures_test.go
@@ -118,8 +118,8 @@ var LimitsResult = limits.Limits{
 
 // HandleGetSuccessfully configures the test server to respond to a Get request
 // for a limit.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v3/limits/testing/requests_test.go b/openstack/blockstorage/v3/limits/testing/requests_test.go
index bd2a2cbfd..8296ef751 100644
--- a/openstack/blockstorage/v3/limits/testing/requests_test.go
+++ b/openstack/blockstorage/v3/limits/testing/requests_test.go
@@ -10,11 +10,11 @@ import (
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := limits.Get(context.TODO(), client.ServiceClient()).Extract()
+	actual, err := limits.Get(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &LimitsResult, actual)
 }
diff --git a/openstack/blockstorage/v3/manageablevolumes/testing/doc.go b/openstack/blockstorage/v3/manageablevolumes/testing/doc.go
new file mode 100644
index 000000000..4acd66588
--- /dev/null
+++ b/openstack/blockstorage/v3/manageablevolumes/testing/doc.go
@@ -0,0 +1,2 @@
+// manageablevolumes unit tests
+package testing
diff --git a/openstack/blockstorage/v3/manageablevolumes/testing/fixtures_test.go b/openstack/blockstorage/v3/manageablevolumes/testing/fixtures_test.go
new file mode 100644
index 000000000..5fdc8fb99
--- /dev/null
+++ b/openstack/blockstorage/v3/manageablevolumes/testing/fixtures_test.go
@@ -0,0 +1,93 @@
+package testing
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
+	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+)
+
+func MockManageExistingResponse(t *testing.T) {
+	th.Mux.HandleFunc("/manageable_volumes", func(w http.ResponseWriter, r *http.Request) {
+		th.TestMethod(t, r, "POST")
+		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "Content-Type", "application/json")
+		th.TestHeader(t, r, "Accept", "application/json")
+		th.TestJSONRequest(t, r, `
+{
+    "volume": {
+        "host": "host@lvm#LVM",
+        "ref": {
+            "source-name": "volume-73796b96-169f-4675-a5bc-73fc0f8f9a17"
+        },
+        "name": "New Volume",
+        "availability_zone": "nova",
+        "description": "Volume imported from existingLV",
+        "volume_type": "lvm",
+        "bootable": true,
+        "metadata": {
+            "key1": "value1",
+            "key2": "value2"
+        }
+    }
+}
+		`)
+
+		w.Header().Add("Content-Type", "application/json")
+		w.WriteHeader(http.StatusAccepted)
+
+		fmt.Fprint(w, `
+{
+    "volume": {
+        "id": "23cf872b-c781-4cd4-847d-5f2ec8cbd91c",
+        "status": "creating",
+        "size": 0,
+        "availability_zone": "nova",
+		"created_at": "2025-03-20T11:58:05.000000",
+        "updated_at": "2025-03-20T11:58:05.000000",
+        "name": "New Volume",
+        "description": "Volume imported from existingLV",
+        "volume_type": "lvm",
+        "snapshot_id": null,
+        "source_volid": null,
+        "metadata": {
+            "key1": "value1",
+            "key2": "value2"
+        },
+        "links": [
+            {
+                "href": "http://10.0.2.15:8776/v3/87c8522052ca4eed98bc672b4c1a3ddb/volumes/23cf872b-c781-4cd4-847d-5f2ec8cbd91c",
+                "rel": "self"
+            },
+            {
+                "href": "http://10.0.2.15:8776/87c8522052ca4eed98bc672b4c1a3ddb/volumes/23cf872b-c781-4cd4-847d-5f2ec8cbd91c",
+                "rel": "bookmark"
+            }
+        ],
+        "user_id": "eae1472b5fc5496998a3d06550929e7e",
+        "bootable": "true",
+        "encrypted": false,
+		"replication_status": null,
+		"consistencygroup_id": null,
+		"multiattach": false,
+        "attachments": [],
+        "created_at": "2014-07-18T00:12:54.000000",
+		"migration_status": null,
+		"group_id": null,
+		"provider_id": null,
+		"shared_targets": true,
+		"service_uuid": null,
+		"cluster_name": null,
+		"volume_type_id": "a218796e-605b-4b6f-9dfc-8be95a0d7d03",
+		"consumes_quota": true,
+		"os-vol-mig-status-attr:migstat": null,
+		"os-vol-mig-status-attr:name_id": null,
+        "os-vol-tenant-attr:tenant_id": "87c8522052ca4eed98bc672b4c1a3ddb",
+		"os-vol-host-attr:host": "host@lvm#LVM"
+	}
+}
+		`)
+	})
+}
diff --git a/openstack/blockstorage/v3/manageablevolumes/testing/requests_test.go b/openstack/blockstorage/v3/manageablevolumes/testing/requests_test.go
new file mode 100644
index 000000000..cabbfde4e
--- /dev/null
+++ b/openstack/blockstorage/v3/manageablevolumes/testing/requests_test.go
@@ -0,0 +1,44 @@
+package testing
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/manageablevolumes"
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
+)
+
+func TestManageExisting(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+
+	MockManageExistingResponse(t)
+
+	options := &manageablevolumes.ManageExistingOpts{
+		Host:             "host@lvm#LVM",
+		Ref:              map[string]string{"source-name": "volume-73796b96-169f-4675-a5bc-73fc0f8f9a17"},
+		Name:             "New Volume",
+		AvailabilityZone: "nova",
+		Description:      "Volume imported from existingLV",
+		VolumeType:       "lvm",
+		Bootable:         true,
+		Metadata: map[string]string{
+			"key1": "value1",
+			"key2": "value2",
+		},
+	}
+	n, err := manageablevolumes.ManageExisting(context.TODO(), client.ServiceClient(), options).Extract()
+	th.AssertNoErr(t, err)
+
+	th.AssertEquals(t, n.Host, "host@lvm#LVM")
+	th.AssertEquals(t, n.Name, "New Volume")
+	th.AssertEquals(t, n.AvailabilityZone, "nova")
+	th.AssertEquals(t, n.Description, "Volume imported from existingLV")
+	th.AssertEquals(t, n.Bootable, "true")
+	th.AssertDeepEquals(t, n.Metadata, map[string]string{
+		"key1": "value1",
+		"key2": "value2",
+	})
+	th.AssertEquals(t, n.ID, "23cf872b-c781-4cd4-847d-5f2ec8cbd91c")
+}
diff --git a/openstack/blockstorage/v3/qos/testing/fixtures_test.go b/openstack/blockstorage/v3/qos/testing/fixtures_test.go
index e6cd002ce..0e52ba204 100644
--- a/openstack/blockstorage/v3/qos/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/qos/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/blockstorage/v3/qos"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 var createQoSExpected = qos.QoS{
@@ -28,10 +28,10 @@ var getQoSExpected = qos.QoS{
 	},
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -62,18 +62,18 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		if err := r.ParseForm(); err != nil {
@@ -108,7 +108,7 @@ func MockListResponse(t *testing.T) {
 							}
 						]
 					}
-				`, th.Server.URL)
+				`, fakeServer.Server.URL)
 		case "2":
 			fmt.Fprint(w, `{ "qos_specs": [] }`)
 		default:
@@ -117,10 +117,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 
@@ -157,10 +157,10 @@ var UpdateQos = map[string]string{
 	"write_iops_sec": "40000",
 }
 
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `{
 				"qos_specs": {
@@ -176,10 +176,10 @@ func MockUpdateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteKeysResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/delete_keys", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteKeysResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/delete_keys", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
 			"keys": [
 				"read_iops_sec"
@@ -190,34 +190,34 @@ func MockDeleteKeysResponse(t *testing.T) {
 	})
 }
 
-func MockAssociateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/associate", func(w http.ResponseWriter, r *http.Request) {
+func MockAssociateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/associate", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockDisassociateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/disassociate", func(w http.ResponseWriter, r *http.Request) {
+func MockDisassociateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/disassociate", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockDisassociateAllResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/disassociate_all", func(w http.ResponseWriter, r *http.Request) {
+func MockDisassociateAllResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/disassociate_all", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockListAssociationsResponse(t *testing.T) {
-	th.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/associations", func(w http.ResponseWriter, r *http.Request) {
+func MockListAssociationsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/qos-specs/d32019d3-bc6e-4319-9c1d-6722fc136a22/associations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `
 			{
diff --git a/openstack/blockstorage/v3/qos/testing/requests_test.go b/openstack/blockstorage/v3/qos/testing/requests_test.go
index be88fbd30..7ccfa4a42 100644
--- a/openstack/blockstorage/v3/qos/testing/requests_test.go
+++ b/openstack/blockstorage/v3/qos/testing/requests_test.go
@@ -12,10 +12,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := qos.CreateOpts{
 		Name:     "qos-001",
@@ -24,29 +24,29 @@ func TestCreate(t *testing.T) {
 			"read_iops_sec": "20000",
 		},
 	}
-	actual, err := qos.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	actual, err := qos.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &createQoSExpected, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := qos.Delete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", qos.DeleteOpts{})
+	res := qos.Delete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", qos.DeleteOpts{})
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
 	pages := 0
-	err := qos.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := qos.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 		actual, err := qos.ExtractQoS(page)
 		if err != nil {
@@ -76,20 +76,20 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	actual, err := qos.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	actual, err := qos.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &getQoSExpected, actual)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	MockUpdateResponse(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	MockUpdateResponse(t, fakeServer)
 
 	updateOpts := qos.UpdateOpts{
 		Consumer: qos.ConsumerBack,
@@ -100,64 +100,64 @@ func TestUpdate(t *testing.T) {
 	}
 
 	expected := UpdateQos
-	actual, err := qos.Update(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", updateOpts).Extract()
+	actual, err := qos.Update(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestDeleteKeys(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteKeysResponse(t)
+	MockDeleteKeysResponse(t, fakeServer)
 
-	res := qos.DeleteKeys(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", qos.DeleteKeysOpts{"read_iops_sec"})
+	res := qos.DeleteKeys(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", qos.DeleteKeysOpts{"read_iops_sec"})
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestAssociate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockAssociateResponse(t)
+	MockAssociateResponse(t, fakeServer)
 
 	associateOpts := qos.AssociateOpts{
 		VolumeTypeID: "b596be6a-0ce9-43fa-804a-5c5e181ede76",
 	}
 
-	res := qos.Associate(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", associateOpts)
+	res := qos.Associate(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", associateOpts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestDisssociate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDisassociateResponse(t)
+	MockDisassociateResponse(t, fakeServer)
 
 	disassociateOpts := qos.DisassociateOpts{
 		VolumeTypeID: "b596be6a-0ce9-43fa-804a-5c5e181ede76",
 	}
 
-	res := qos.Disassociate(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", disassociateOpts)
+	res := qos.Disassociate(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", disassociateOpts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestDissasociateAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDisassociateAllResponse(t)
+	MockDisassociateAllResponse(t, fakeServer)
 
-	res := qos.DisassociateAll(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := qos.DisassociateAll(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestQosAssociationsList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListAssociationsResponse(t)
+	MockListAssociationsResponse(t, fakeServer)
 
 	expected := []qos.QosAssociation{
 		{
@@ -167,7 +167,7 @@ func TestQosAssociationsList(t *testing.T) {
 		},
 	}
 
-	allPages, err := qos.ListAssociations(client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").AllPages(context.TODO())
+	allPages, err := qos.ListAssociations(client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := qos.ExtractAssociations(allPages)
diff --git a/openstack/blockstorage/v3/quotasets/testing/fixtures_test.go b/openstack/blockstorage/v3/quotasets/testing/fixtures_test.go
index d78b7d012..a64b68ec0 100644
--- a/openstack/blockstorage/v3/quotasets/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/quotasets/testing/fixtures_test.go
@@ -173,9 +173,9 @@ var partialUpdateExpectedQuotaSet = quotasets.QuotaSet{
 }
 
 // HandleSuccessfulRequest configures the test server to respond to an HTTP request.
-func HandleSuccessfulRequest(t *testing.T, httpMethod, uriPath, jsonOutput string, uriQueryParams map[string]string) {
+func HandleSuccessfulRequest(t *testing.T, fakeServer th.FakeServer, httpMethod, uriPath, jsonOutput string, uriQueryParams map[string]string) {
 
-	th.Mux.HandleFunc(uriPath, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(uriPath, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, httpMethod)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -189,8 +189,8 @@ func HandleSuccessfulRequest(t *testing.T, httpMethod, uriPath, jsonOutput strin
 }
 
 // HandleDeleteSuccessfully tests quotaset deletion.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v3/quotasets/testing/requests_test.go b/openstack/blockstorage/v3/quotasets/testing/requests_test.go
index ba2019fa5..0b8b74e51 100644
--- a/openstack/blockstorage/v3/quotasets/testing/requests_test.go
+++ b/openstack/blockstorage/v3/quotasets/testing/requests_test.go
@@ -11,45 +11,45 @@ import (
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	uriQueryParms := map[string]string{}
-	HandleSuccessfulRequest(t, "GET", "/os-quota-sets/"+FirstTenantID, getExpectedJSONBody, uriQueryParms)
-	actual, err := quotasets.Get(context.TODO(), client.ServiceClient(), FirstTenantID).Extract()
+	HandleSuccessfulRequest(t, fakeServer, "GET", "/os-quota-sets/"+FirstTenantID, getExpectedJSONBody, uriQueryParms)
+	actual, err := quotasets.Get(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &getExpectedQuotaSet, actual)
 }
 
 func TestGetUsage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	uriQueryParms := map[string]string{"usage": "true"}
-	HandleSuccessfulRequest(t, "GET", "/os-quota-sets/"+FirstTenantID, getUsageExpectedJSONBody, uriQueryParms)
-	actual, err := quotasets.GetUsage(context.TODO(), client.ServiceClient(), FirstTenantID).Extract()
+	HandleSuccessfulRequest(t, fakeServer, "GET", "/os-quota-sets/"+FirstTenantID, getUsageExpectedJSONBody, uriQueryParms)
+	actual, err := quotasets.GetUsage(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, getUsageExpectedQuotaSet, actual)
 }
 
 func TestFullUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	uriQueryParms := map[string]string{}
-	HandleSuccessfulRequest(t, "PUT", "/os-quota-sets/"+FirstTenantID, fullUpdateExpectedJSONBody, uriQueryParms)
-	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, fullUpdateOpts).Extract()
+	HandleSuccessfulRequest(t, fakeServer, "PUT", "/os-quota-sets/"+FirstTenantID, fullUpdateExpectedJSONBody, uriQueryParms)
+	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, fullUpdateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &fullUpdateExpectedQuotaSet, actual)
 }
 
 func TestPartialUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	uriQueryParms := map[string]string{}
-	HandleSuccessfulRequest(t, "PUT", "/os-quota-sets/"+FirstTenantID, partialUpdateExpectedJSONBody, uriQueryParms)
-	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, partialUpdateOpts).Extract()
+	HandleSuccessfulRequest(t, fakeServer, "PUT", "/os-quota-sets/"+FirstTenantID, partialUpdateExpectedJSONBody, uriQueryParms)
+	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, partialUpdateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &partialUpdateExpectedQuotaSet, actual)
 }
@@ -62,20 +62,20 @@ func (opts ErrorUpdateOpts) ToBlockStorageQuotaUpdateMap() (map[string]any, erro
 
 func TestErrorInToBlockStorageQuotaUpdateMap(t *testing.T) {
 	opts := &ErrorUpdateOpts{}
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSuccessfulRequest(t, "PUT", "/os-quota-sets/"+FirstTenantID, "", nil)
-	_, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, opts).Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSuccessfulRequest(t, fakeServer, "PUT", "/os-quota-sets/"+FirstTenantID, "", nil)
+	_, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, opts).Extract()
 	if err == nil {
 		t.Fatal("Error handling failed")
 	}
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	err := quotasets.Delete(context.TODO(), client.ServiceClient(), FirstTenantID).ExtractErr()
+	err := quotasets.Delete(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/blockstorage/v3/schedulerstats/testing/fixtures_test.go b/openstack/blockstorage/v3/schedulerstats/testing/fixtures_test.go
index 18462bfb2..d84f647cb 100644
--- a/openstack/blockstorage/v3/schedulerstats/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/schedulerstats/testing/fixtures_test.go
@@ -93,8 +93,8 @@ var (
 	}
 )
 
-func HandleStoragePoolsListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/scheduler-stats/get_pools", func(w http.ResponseWriter, r *http.Request) {
+func HandleStoragePoolsListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/scheduler-stats/get_pools", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v3/schedulerstats/testing/requests_test.go b/openstack/blockstorage/v3/schedulerstats/testing/requests_test.go
index c12576327..d42cf69b6 100644
--- a/openstack/blockstorage/v3/schedulerstats/testing/requests_test.go
+++ b/openstack/blockstorage/v3/schedulerstats/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListStoragePoolsDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleStoragePoolsListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleStoragePoolsListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := schedulerstats.List(client.ServiceClient(), schedulerstats.ListOpts{Detail: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := schedulerstats.List(client.ServiceClient(fakeServer), schedulerstats.ListOpts{Detail: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := schedulerstats.ExtractStoragePools(page)
diff --git a/openstack/blockstorage/v3/services/testing/fixtures_test.go b/openstack/blockstorage/v3/services/testing/fixtures_test.go
index 63771ff03..f1acd556d 100644
--- a/openstack/blockstorage/v3/services/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/services/testing/fixtures_test.go
@@ -86,8 +86,8 @@ var ThirdFakeService = services.Service{
 }
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-services", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-services", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/blockstorage/v3/services/testing/requests_test.go b/openstack/blockstorage/v3/services/testing/requests_test.go
index 4e291da96..12fa3bc33 100644
--- a/openstack/blockstorage/v3/services/testing/requests_test.go
+++ b/openstack/blockstorage/v3/services/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListServices(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := services.List(client.ServiceClient(), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := services.List(client.ServiceClient(fakeServer), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := services.ExtractServices(page)
diff --git a/openstack/blockstorage/v3/snapshots/testing/fixtures_test.go b/openstack/blockstorage/v3/snapshots/testing/fixtures_test.go
index e1bfd3758..a5ce93c38 100644
--- a/openstack/blockstorage/v3/snapshots/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/snapshots/testing/fixtures_test.go
@@ -6,14 +6,14 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // MockListResponse provides mock response for list snapshot API call
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -52,7 +52,7 @@ func MockListResponse(t *testing.T) {
             "rel": "next"
         }]
     }
-    `, th.Server.URL)
+    `, fakeServer.Server.URL)
 		case "1":
 			fmt.Fprint(w, `{"snapshots": []}`)
 		default:
@@ -61,10 +61,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockListDetailsResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListDetailsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -118,10 +118,10 @@ func MockListDetailsResponse(t *testing.T) {
 }
 
 // MockGetResponse provides mock response for get snapshot API call
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -142,10 +142,10 @@ func MockGetResponse(t *testing.T) {
 }
 
 // MockCreateResponse provides mock response for create snapshot API call
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -178,10 +178,10 @@ func MockCreateResponse(t *testing.T) {
 }
 
 // MockUpdateMetadataResponse provides mock response for update metadata snapshot API call
-func MockUpdateMetadataResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/123/metadata", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateMetadataResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/123/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, `
     {
@@ -202,19 +202,19 @@ func MockUpdateMetadataResponse(t *testing.T) {
 }
 
 // MockDeleteResponse provides mock response for delete snapshot API call
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
 // MockUpdateResponse provides mock response for update snapshot API call
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -236,10 +236,10 @@ func MockUpdateResponse(t *testing.T) {
 }
 
 // MockResetStatusResponse provides mock response for reset snapshot status API call
-func MockResetStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockResetStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, `
 {
@@ -253,10 +253,10 @@ func MockResetStatusResponse(t *testing.T) {
 }
 
 // MockUpdateStatusResponse provides mock response for update snapshot status API call
-func MockUpdateStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, `
 {
@@ -271,10 +271,10 @@ func MockUpdateStatusResponse(t *testing.T) {
 }
 
 // MockForceDeleteResponse provides mock response for force delete snapshot API call
-func MockForceDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockForceDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/snapshots/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestJSONRequest(t, r, `
 {
diff --git a/openstack/blockstorage/v3/snapshots/testing/requests_test.go b/openstack/blockstorage/v3/snapshots/testing/requests_test.go
index aca65ba7a..fb7a6d319 100644
--- a/openstack/blockstorage/v3/snapshots/testing/requests_test.go
+++ b/openstack/blockstorage/v3/snapshots/testing/requests_test.go
@@ -12,14 +12,14 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
 	count := 0
 
-	err := snapshots.List(client.ServiceClient(), &snapshots.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := snapshots.List(client.ServiceClient(fakeServer), &snapshots.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := snapshots.ExtractSnapshots(page)
 		if err != nil {
@@ -60,14 +60,14 @@ func TestList(t *testing.T) {
 }
 
 func TestDetailList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListDetailsResponse(t)
+	MockListDetailsResponse(t, fakeServer)
 
 	count := 0
 
-	err := snapshots.ListDetail(client.ServiceClient(), &snapshots.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := snapshots.ListDetail(client.ServiceClient(fakeServer), &snapshots.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := snapshots.ExtractSnapshots(page)
 		if err != nil {
@@ -116,12 +116,12 @@ func TestDetailList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	v, err := snapshots.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	v, err := snapshots.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, v.Name, "snapshot-001")
@@ -129,13 +129,13 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := snapshots.CreateOpts{VolumeID: "1234", Name: "snapshot-001"}
-	n, err := snapshots.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := snapshots.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.VolumeID, "1234")
@@ -144,10 +144,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdateMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateMetadataResponse(t)
+	MockUpdateMetadataResponse(t, fakeServer)
 
 	expected := map[string]any{"key": "v1"}
 
@@ -157,70 +157,70 @@ func TestUpdateMetadata(t *testing.T) {
 		},
 	}
 
-	actual, err := snapshots.UpdateMetadata(context.TODO(), client.ServiceClient(), "123", options).ExtractMetadata()
+	actual, err := snapshots.UpdateMetadata(context.TODO(), client.ServiceClient(fakeServer), "123", options).ExtractMetadata()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, actual, expected)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := snapshots.Delete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := snapshots.Delete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateResponse(t)
+	MockUpdateResponse(t, fakeServer)
 
 	var name = "snapshot-002"
 	var description = "Daily backup 002"
 	options := snapshots.UpdateOpts{Name: &name, Description: &description}
-	v, err := snapshots.Update(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
+	v, err := snapshots.Update(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckEquals(t, "snapshot-002", v.Name)
 	th.CheckEquals(t, "Daily backup 002", v.Description)
 }
 
 func TestResetStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStatusResponse(t)
+	MockResetStatusResponse(t, fakeServer)
 
 	opts := &snapshots.ResetStatusOpts{
 		Status: "error",
 	}
-	res := snapshots.ResetStatus(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", opts)
+	res := snapshots.ResetStatus(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", opts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateStatusResponse(t)
+	MockUpdateStatusResponse(t, fakeServer)
 
 	opts := &snapshots.UpdateStatusOpts{
 		Status:   "error",
 		Progress: "80%",
 	}
-	res := snapshots.UpdateStatus(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", opts)
+	res := snapshots.UpdateStatus(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", opts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestForceDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockForceDeleteResponse(t)
+	MockForceDeleteResponse(t, fakeServer)
 
-	res := snapshots.ForceDelete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := snapshots.ForceDelete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/blockstorage/v3/transfers/testing/fixtures_test.go b/openstack/blockstorage/v3/transfers/testing/fixtures_test.go
index 859e454ec..2e1d50b66 100644
--- a/openstack/blockstorage/v3/transfers/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/transfers/testing/fixtures_test.go
@@ -159,8 +159,8 @@ var AcceptResponse = transfers.Transfer{
 	},
 }
 
-func HandleCreateTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -171,8 +171,8 @@ func HandleCreateTransfer(t *testing.T) {
 	})
 }
 
-func HandleAcceptTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f/accept", func(w http.ResponseWriter, r *http.Request) {
+func HandleAcceptTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f/accept", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -183,8 +183,8 @@ func HandleAcceptTransfer(t *testing.T) {
 	})
 }
 
-func HandleDeleteTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -192,8 +192,8 @@ func HandleDeleteTransfer(t *testing.T) {
 	})
 }
 
-func HandleListTransfers(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleListTransfers(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -204,8 +204,8 @@ func HandleListTransfers(t *testing.T) {
 	})
 }
 
-func HandleGetTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-volume-transfer/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
diff --git a/openstack/blockstorage/v3/transfers/testing/requests_test.go b/openstack/blockstorage/v3/transfers/testing/requests_test.go
index 43013a71e..5b5428e1f 100644
--- a/openstack/blockstorage/v3/transfers/testing/requests_test.go
+++ b/openstack/blockstorage/v3/transfers/testing/requests_test.go
@@ -11,44 +11,44 @@ import (
 )
 
 func TestCreateTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateTransfer(t, fakeServer)
 
-	actual, err := transfers.Create(context.TODO(), client.ServiceClient(), TransferRequest).Extract()
+	actual, err := transfers.Create(context.TODO(), client.ServiceClient(fakeServer), TransferRequest).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, TransferResponse, *actual)
 }
 
 func TestAcceptTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAcceptTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAcceptTransfer(t, fakeServer)
 
-	actual, err := transfers.Accept(context.TODO(), client.ServiceClient(), TransferResponse.ID, AcceptRequest).Extract()
+	actual, err := transfers.Accept(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID, AcceptRequest).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, AcceptResponse, *actual)
 }
 
 func TestDeleteTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteTransfer(t, fakeServer)
 
-	err := transfers.Delete(context.TODO(), client.ServiceClient(), TransferResponse.ID).ExtractErr()
+	err := transfers.Delete(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListTransfers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTransfers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTransfers(t, fakeServer)
 
 	expectedResponse := TransferListResponse
 	expectedResponse[0].AuthKey = ""
 
 	count := 0
-	err := transfers.List(client.ServiceClient(), &transfers.ListOpts{AllTenants: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := transfers.List(client.ServiceClient(fakeServer), &transfers.ListOpts{AllTenants: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := transfers.ExtractTransfers(page)
@@ -63,14 +63,14 @@ func TestListTransfers(t *testing.T) {
 }
 
 func TestListTransfersAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTransfers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTransfers(t, fakeServer)
 
 	expectedResponse := TransferListResponse
 	expectedResponse[0].AuthKey = ""
 
-	allPages, err := transfers.List(client.ServiceClient(), &transfers.ListOpts{AllTenants: true}).AllPages(context.TODO())
+	allPages, err := transfers.List(client.ServiceClient(fakeServer), &transfers.ListOpts{AllTenants: true}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := transfers.ExtractTransfers(allPages)
 	th.AssertNoErr(t, err)
@@ -78,14 +78,14 @@ func TestListTransfersAllPages(t *testing.T) {
 }
 
 func TestGetTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetTransfer(t, fakeServer)
 
 	expectedResponse := TransferResponse
 	expectedResponse.AuthKey = ""
 
-	actual, err := transfers.Get(context.TODO(), client.ServiceClient(), TransferResponse.ID).Extract()
+	actual, err := transfers.Get(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expectedResponse, *actual)
 }
diff --git a/openstack/blockstorage/v3/volumes/testing/fixtures_test.go b/openstack/blockstorage/v3/volumes/testing/fixtures_test.go
index 9b4630a97..bcd403be7 100644
--- a/openstack/blockstorage/v3/volumes/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/volumes/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -93,7 +93,7 @@ func MockListResponse(t *testing.T) {
 		"rel": "next"
 	}]
 }
-  `, th.Server.URL)
+  `, fakeServer.Server.URL)
 		case "1":
 			fmt.Fprint(w, `{"volumes": []}`)
 		default:
@@ -102,10 +102,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -153,10 +153,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -198,18 +198,18 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `
 {
@@ -221,10 +221,10 @@ func MockUpdateResponse(t *testing.T) {
 	})
 }
 
-func MockCreateVolumeFromBackupResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateVolumeFromBackupResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -266,11 +266,11 @@ func MockCreateVolumeFromBackupResponse(t *testing.T) {
 	})
 }
 
-func MockAttachResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockAttachResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -291,11 +291,11 @@ func MockAttachResponse(t *testing.T) {
 		})
 }
 
-func MockBeginDetachingResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockBeginDetachingResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -311,11 +311,11 @@ func MockBeginDetachingResponse(t *testing.T) {
 		})
 }
 
-func MockDetachResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockDetachResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -331,11 +331,11 @@ func MockDetachResponse(t *testing.T) {
 		})
 }
 
-func MockUploadImageResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockUploadImageResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -383,11 +383,11 @@ func MockUploadImageResponse(t *testing.T) {
 		})
 }
 
-func MockReserveResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockReserveResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -403,11 +403,11 @@ func MockReserveResponse(t *testing.T) {
 		})
 }
 
-func MockUnreserveResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockUnreserveResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -423,11 +423,11 @@ func MockUnreserveResponse(t *testing.T) {
 		})
 }
 
-func MockInitializeConnectionResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockInitializeConnectionResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -480,11 +480,11 @@ func MockInitializeConnectionResponse(t *testing.T) {
 		})
 }
 
-func MockTerminateConnectionResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockTerminateConnectionResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -511,11 +511,11 @@ func MockTerminateConnectionResponse(t *testing.T) {
 		})
 }
 
-func MockExtendSizeResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockExtendSizeResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -534,19 +534,19 @@ func MockExtendSizeResponse(t *testing.T) {
 		})
 }
 
-func MockForceDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
+func MockForceDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/d32019d3-bc6e-4319-9c1d-6722fc136a22/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestBody(t, r, `{"os-force_delete":""}`)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockSetImageMetadataResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
+func MockSetImageMetadataResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -565,10 +565,10 @@ func MockSetImageMetadataResponse(t *testing.T) {
 	})
 }
 
-func MockSetBootableResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
+func MockSetBootableResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -584,10 +584,10 @@ func MockSetBootableResponse(t *testing.T) {
 	})
 }
 
-func MockReImageResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
+func MockReImageResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -604,11 +604,11 @@ func MockReImageResponse(t *testing.T) {
 	})
 }
 
-func MockChangeTypeResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockChangeTypeResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestHeader(t, r, "Accept", "application/json")
 			th.TestJSONRequest(t, r, `
@@ -628,11 +628,11 @@ func MockChangeTypeResponse(t *testing.T) {
 		})
 }
 
-func MockResetStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+func MockResetStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Content-Type", "application/json")
 			th.TestJSONRequest(t, r, `
 {
@@ -648,3 +648,19 @@ func MockResetStatusResponse(t *testing.T) {
 			w.WriteHeader(http.StatusAccepted)
 		})
 }
+
+func MockUnmanageResponse(t *testing.T) {
+	th.Mux.HandleFunc("/volumes/cd281d77-8217-4830-be95-9528227c105c/action",
+		func(w http.ResponseWriter, r *http.Request) {
+			th.TestMethod(t, r, "POST")
+			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "Content-Type", "application/json")
+			th.TestJSONRequest(t, r, `
+{
+	"os-unmanage": {}
+}
+			`)
+
+			w.WriteHeader(http.StatusAccepted)
+		})
+}
diff --git a/openstack/blockstorage/v3/volumes/testing/requests_test.go b/openstack/blockstorage/v3/volumes/testing/requests_test.go
index 5e3234674..f72274d4d 100644
--- a/openstack/blockstorage/v3/volumes/testing/requests_test.go
+++ b/openstack/blockstorage/v3/volumes/testing/requests_test.go
@@ -13,14 +13,14 @@ import (
 )
 
 func TestListWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
 	count := 0
 
-	err := volumes.List(client.ServiceClient(), &volumes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := volumes.List(client.ServiceClient(fakeServer), &volumes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := volumes.ExtractVolumes(page)
 		if err != nil {
@@ -98,12 +98,12 @@ func TestListWithExtensions(t *testing.T) {
 }
 
 func TestListAllWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := volumes.List(client.ServiceClient(), &volumes.ListOpts{}).AllPages(context.TODO())
+	allPages, err := volumes.List(client.ServiceClient(fakeServer), &volumes.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	var actual []volumes.Volume
@@ -116,12 +116,12 @@ func TestListAllWithExtensions(t *testing.T) {
 }
 
 func TestListAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := volumes.List(client.ServiceClient(), &volumes.ListOpts{}).AllPages(context.TODO())
+	allPages, err := volumes.List(client.ServiceClient(fakeServer), &volumes.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := volumes.ExtractVolumes(allPages)
 	th.AssertNoErr(t, err)
@@ -189,12 +189,12 @@ func TestListAll(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	v, err := volumes.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	v, err := volumes.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, v.Name, "vol-001")
@@ -202,13 +202,13 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &volumes.CreateOpts{Size: 75, Name: "vol-001"}
-	n, err := volumes.Create(context.TODO(), client.ServiceClient(), options, nil).Extract()
+	n, err := volumes.Create(context.TODO(), client.ServiceClient(fakeServer), options, nil).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Size, 75)
@@ -250,57 +250,57 @@ func TestCreateSchedulerHints(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := volumes.Delete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", volumes.DeleteOpts{})
+	res := volumes.Delete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", volumes.DeleteOpts{})
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateResponse(t)
+	MockUpdateResponse(t, fakeServer)
 
 	var name = "vol-002"
 	options := volumes.UpdateOpts{Name: &name}
-	v, err := volumes.Update(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
+	v, err := volumes.Update(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckEquals(t, "vol-002", v.Name)
 }
 
 func TestGetWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
 	var v volumes.Volume
-	err := volumes.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&v)
+	err := volumes.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&v)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, "304dc00909ac4d0da6c62d816bcb3459", v.TenantID)
 	th.AssertEquals(t, "centos", v.VolumeImageMetadata["image_name"])
 
-	err = volumes.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(v)
+	err = volumes.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(v)
 	if err == nil {
 		t.Errorf("Expected error when providing non-pointer struct")
 	}
 }
 
 func TestCreateFromBackup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateVolumeFromBackupResponse(t)
+	MockCreateVolumeFromBackupResponse(t, fakeServer)
 
 	options := volumes.CreateOpts{
 		Name:     "vol-001",
 		BackupID: "20c792f0-bb03-434f-b653-06ef238e337e",
 	}
-	v, err := volumes.Create(context.TODO(), client.ServiceClient(), options, nil).Extract()
+	v, err := volumes.Create(context.TODO(), client.ServiceClient(fakeServer), options, nil).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, v.Size, 30)
@@ -309,44 +309,44 @@ func TestCreateFromBackup(t *testing.T) {
 }
 
 func TestAttach(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockAttachResponse(t)
+	MockAttachResponse(t, fakeServer)
 
 	options := &volumes.AttachOpts{
 		MountPoint:   "/mnt",
 		Mode:         "rw",
 		InstanceUUID: "50902f4f-a974-46a0-85e9-7efc5e22dfdd",
 	}
-	err := volumes.Attach(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.Attach(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestBeginDetaching(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockBeginDetachingResponse(t)
+	MockBeginDetachingResponse(t, fakeServer)
 
-	err := volumes.BeginDetaching(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
+	err := volumes.BeginDetaching(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDetach(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDetachResponse(t)
+	MockDetachResponse(t, fakeServer)
 
-	err := volumes.Detach(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", &volumes.DetachOpts{}).ExtractErr()
+	err := volumes.Detach(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", &volumes.DetachOpts{}).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUploadImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	MockUploadImageResponse(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	MockUploadImageResponse(t, fakeServer)
 	options := &volumes.UploadImageOpts{
 		ContainerFormat: "bare",
 		DiskFormat:      "raw",
@@ -354,7 +354,7 @@ func TestUploadImage(t *testing.T) {
 		Force:           true,
 	}
 
-	actual, err := volumes.UploadImage(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).Extract()
+	actual, err := volumes.UploadImage(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := volumes.VolumeImage{
@@ -384,30 +384,30 @@ func TestUploadImage(t *testing.T) {
 }
 
 func TestReserve(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockReserveResponse(t)
+	MockReserveResponse(t, fakeServer)
 
-	err := volumes.Reserve(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
+	err := volumes.Reserve(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUnreserve(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUnreserveResponse(t)
+	MockUnreserveResponse(t, fakeServer)
 
-	err := volumes.Unreserve(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
+	err := volumes.Unreserve(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestInitializeConnection(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockInitializeConnectionResponse(t)
+	MockInitializeConnectionResponse(t, fakeServer)
 
 	options := &volumes.InitializeConnectionOpts{
 		IP:        "127.0.0.1",
@@ -417,15 +417,15 @@ func TestInitializeConnection(t *testing.T) {
 		Platform:  "x86_64",
 		OSType:    "linux2",
 	}
-	_, err := volumes.InitializeConnection(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).Extract()
+	_, err := volumes.InitializeConnection(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestTerminateConnection(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockTerminateConnectionResponse(t)
+	MockTerminateConnectionResponse(t, fakeServer)
 
 	options := &volumes.TerminateConnectionOpts{
 		IP:        "127.0.0.1",
@@ -435,39 +435,39 @@ func TestTerminateConnection(t *testing.T) {
 		Platform:  "x86_64",
 		OSType:    "linux2",
 	}
-	err := volumes.TerminateConnection(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.TerminateConnection(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestExtendSize(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockExtendSizeResponse(t)
+	MockExtendSizeResponse(t, fakeServer)
 
 	options := &volumes.ExtendSizeOpts{
 		NewSize: 3,
 	}
 
-	err := volumes.ExtendSize(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.ExtendSize(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestForceDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockForceDeleteResponse(t)
+	MockForceDeleteResponse(t, fakeServer)
 
-	res := volumes.ForceDelete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := volumes.ForceDelete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestSetImageMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockSetImageMetadataResponse(t)
+	MockSetImageMetadataResponse(t, fakeServer)
 
 	options := &volumes.ImageMetadataOpts{
 		Metadata: map[string]string{
@@ -475,59 +475,59 @@ func TestSetImageMetadata(t *testing.T) {
 		},
 	}
 
-	err := volumes.SetImageMetadata(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.SetImageMetadata(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestSetBootable(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockSetBootableResponse(t)
+	MockSetBootableResponse(t, fakeServer)
 
 	options := volumes.BootableOpts{
 		Bootable: true,
 	}
 
-	err := volumes.SetBootable(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.SetBootable(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestReImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockReImageResponse(t)
+	MockReImageResponse(t, fakeServer)
 
 	options := volumes.ReImageOpts{
 		ImageID:         "71543ced-a8af-45b6-a5c4-a46282108a90",
 		ReImageReserved: false,
 	}
 
-	err := volumes.ReImage(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.ReImage(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestChangeType(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockChangeTypeResponse(t)
+	MockChangeTypeResponse(t, fakeServer)
 
 	options := &volumes.ChangeTypeOpts{
 		NewType:         "ssd",
 		MigrationPolicy: "on-demand",
 	}
 
-	err := volumes.ChangeType(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.ChangeType(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestResetStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStatusResponse(t)
+	MockResetStatusResponse(t, fakeServer)
 
 	options := &volumes.ResetStatusOpts{
 		Status:          "error",
@@ -535,6 +535,16 @@ func TestResetStatus(t *testing.T) {
 		MigrationStatus: "migrating",
 	}
 
-	err := volumes.ResetStatus(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	err := volumes.ResetStatus(context.TODO(), client.ServiceClient(fakeServer), "cd281d77-8217-4830-be95-9528227c105c", options).ExtractErr()
+	th.AssertNoErr(t, err)
+}
+
+func TestUnmanage(t *testing.T) {
+	th.SetupHTTP()
+	defer th.TeardownHTTP()
+
+	MockUnmanageResponse(t)
+
+	err := volumes.Unmanage(context.TODO(), client.ServiceClient(), "cd281d77-8217-4830-be95-9528227c105c").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/blockstorage/v3/volumetypes/testing/fixtures_test.go b/openstack/blockstorage/v3/volumetypes/testing/fixtures_test.go
index c7eb37893..d8f5786bb 100644
--- a/openstack/blockstorage/v3/volumetypes/testing/fixtures_test.go
+++ b/openstack/blockstorage/v3/volumetypes/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -56,7 +56,7 @@ func MockListResponse(t *testing.T) {
         }
     ]
 }
-  `, th.Server.URL)
+  `, fakeServer.Server.URL)
 		case "1":
 			fmt.Fprint(w, `{"volume_types": []}`)
 		default:
@@ -65,10 +65,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -90,10 +90,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -130,18 +130,18 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `
 {
@@ -195,10 +195,10 @@ var UpdatedExtraSpec = map[string]string{
 	"capabilities": "gpu-2",
 }
 
-func HandleExtraSpecsListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/types/1/extra_specs", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecsListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/1/extra_specs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -207,10 +207,10 @@ func HandleExtraSpecsListSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleExtraSpecGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/types/1/extra_specs/capabilities", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/1/extra_specs/capabilities", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -219,10 +219,10 @@ func HandleExtraSpecGetSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleExtraSpecsCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/types/1/extra_specs", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecsCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/1/extra_specs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `{
 				"extra_specs": {
@@ -237,10 +237,10 @@ func HandleExtraSpecsCreateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleExtraSpecUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/types/1/extra_specs/capabilities", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/1/extra_specs/capabilities", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `{
 				"capabilities":        "gpu-2"
@@ -252,19 +252,19 @@ func HandleExtraSpecUpdateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleExtraSpecDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/types/1/extra_specs/capabilities", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/1/extra_specs/capabilities", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockEncryptionCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption", func(w http.ResponseWriter, r *http.Request) {
+func MockEncryptionCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -296,18 +296,18 @@ func MockEncryptionCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteEncryptionResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption/81e069c6-7394-4856-8df7-3b237ca61f74", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteEncryptionResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption/81e069c6-7394-4856-8df7-3b237ca61f74", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockEncryptionUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption/81e069c6-7394-4856-8df7-3b237ca61f74", func(w http.ResponseWriter, r *http.Request) {
+func MockEncryptionUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption/81e069c6-7394-4856-8df7-3b237ca61f74", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -337,10 +337,10 @@ func MockEncryptionUpdateResponse(t *testing.T) {
 	})
 }
 
-func MockEncryptionGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption", func(w http.ResponseWriter, r *http.Request) {
+func MockEncryptionGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -362,10 +362,10 @@ func MockEncryptionGetResponse(t *testing.T) {
 	})
 }
 
-func MockEncryptionGetSpecResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption/cipher", func(w http.ResponseWriter, r *http.Request) {
+func MockEncryptionGetSpecResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/encryption/cipher", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
diff --git a/openstack/blockstorage/v3/volumetypes/testing/requests_test.go b/openstack/blockstorage/v3/volumetypes/testing/requests_test.go
index f222be239..920714d72 100644
--- a/openstack/blockstorage/v3/volumetypes/testing/requests_test.go
+++ b/openstack/blockstorage/v3/volumetypes/testing/requests_test.go
@@ -14,12 +14,12 @@ import (
 )
 
 func TestListAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 	pages := 0
-	err := volumetypes.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := volumetypes.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 		actual, err := volumetypes.ExtractVolumeTypes(page)
 		if err != nil {
@@ -52,12 +52,12 @@ func TestListAll(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	v, err := volumetypes.Get(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	v, err := volumetypes.Get(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, v.Name, "vol-type-001")
@@ -68,10 +68,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	var isPublic = true
 
@@ -82,7 +82,7 @@ func TestCreate(t *testing.T) {
 		ExtraSpecs:  map[string]string{"capabilities": "gpu"},
 	}
 
-	n, err := volumetypes.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := volumetypes.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Name, "test_type")
@@ -94,20 +94,20 @@ func TestCreate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := volumetypes.Delete(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
+	res := volumetypes.Delete(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateResponse(t)
+	MockUpdateResponse(t, fakeServer)
 
 	var isPublic = true
 	var name = "vol-type-002"
@@ -116,77 +116,77 @@ func TestUpdate(t *testing.T) {
 		IsPublic: &isPublic,
 	}
 
-	v, err := volumetypes.Update(context.TODO(), client.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
+	v, err := volumetypes.Update(context.TODO(), client.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22", options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckEquals(t, "vol-type-002", v.Name)
 	th.CheckEquals(t, true, v.IsPublic)
 }
 
 func TestVolumeTypeExtraSpecsList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecsListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecsListSuccessfully(t, fakeServer)
 
 	expected := ExtraSpecs
-	actual, err := volumetypes.ListExtraSpecs(context.TODO(), client.ServiceClient(), "1").Extract()
+	actual, err := volumetypes.ListExtraSpecs(context.TODO(), client.ServiceClient(fakeServer), "1").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestVolumeTypeExtraSpecGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecGetSuccessfully(t, fakeServer)
 
 	expected := ExtraSpec
-	actual, err := volumetypes.GetExtraSpec(context.TODO(), client.ServiceClient(), "1", "capabilities").Extract()
+	actual, err := volumetypes.GetExtraSpec(context.TODO(), client.ServiceClient(fakeServer), "1", "capabilities").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestVolumeTypeExtraSpecsCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecsCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecsCreateSuccessfully(t, fakeServer)
 
 	createOpts := volumetypes.ExtraSpecsOpts{
 		"capabilities":        "gpu",
 		"volume_backend_name": "ssd",
 	}
 	expected := ExtraSpecs
-	actual, err := volumetypes.CreateExtraSpecs(context.TODO(), client.ServiceClient(), "1", createOpts).Extract()
+	actual, err := volumetypes.CreateExtraSpecs(context.TODO(), client.ServiceClient(fakeServer), "1", createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestVolumeTypeExtraSpecUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecUpdateSuccessfully(t, fakeServer)
 
 	updateOpts := volumetypes.ExtraSpecsOpts{
 		"capabilities": "gpu-2",
 	}
 	expected := UpdatedExtraSpec
-	actual, err := volumetypes.UpdateExtraSpec(context.TODO(), client.ServiceClient(), "1", updateOpts).Extract()
+	actual, err := volumetypes.UpdateExtraSpec(context.TODO(), client.ServiceClient(fakeServer), "1", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestVolumeTypeExtraSpecDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecDeleteSuccessfully(t, fakeServer)
 
-	res := volumetypes.DeleteExtraSpec(context.TODO(), client.ServiceClient(), "1", "capabilities")
+	res := volumetypes.DeleteExtraSpec(context.TODO(), client.ServiceClient(fakeServer), "1", "capabilities")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestVolumeTypeListAccesses(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/os-volume-type-access", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/os-volume-type-access", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -209,7 +209,7 @@ func TestVolumeTypeListAccesses(t *testing.T) {
 		},
 	}
 
-	allPages, err := volumetypes.ListAccesses(client.ServiceClient(), "a5082c24-2a27-43a4-b48e-fcec1240e36b").AllPages(context.TODO())
+	allPages, err := volumetypes.ListAccesses(client.ServiceClient(fakeServer), "a5082c24-2a27-43a4-b48e-fcec1240e36b").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := volumetypes.ExtractAccesses(allPages)
@@ -221,10 +221,10 @@ func TestVolumeTypeListAccesses(t *testing.T) {
 }
 
 func TestVolumeTypeAddAccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "accept", "application/json")
@@ -244,16 +244,16 @@ func TestVolumeTypeAddAccess(t *testing.T) {
 		Project: "6f70656e737461636b20342065766572",
 	}
 
-	err := volumetypes.AddAccess(context.TODO(), client.ServiceClient(), "a5082c24-2a27-43a4-b48e-fcec1240e36b", addAccessOpts).ExtractErr()
+	err := volumetypes.AddAccess(context.TODO(), client.ServiceClient(fakeServer), "a5082c24-2a27-43a4-b48e-fcec1240e36b", addAccessOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 
 }
 
 func TestVolumeTypeRemoveAccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/types/a5082c24-2a27-43a4-b48e-fcec1240e36b/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "accept", "application/json")
@@ -273,16 +273,16 @@ func TestVolumeTypeRemoveAccess(t *testing.T) {
 		Project: "6f70656e737461636b20342065766572",
 	}
 
-	err := volumetypes.RemoveAccess(context.TODO(), client.ServiceClient(), "a5082c24-2a27-43a4-b48e-fcec1240e36b", removeAccessOpts).ExtractErr()
+	err := volumetypes.RemoveAccess(context.TODO(), client.ServiceClient(fakeServer), "a5082c24-2a27-43a4-b48e-fcec1240e36b", removeAccessOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 
 }
 
 func TestCreateEncryption(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockEncryptionCreateResponse(t)
+	MockEncryptionCreateResponse(t, fakeServer)
 
 	options := &volumetypes.CreateEncryptionOpts{
 		KeySize:         256,
@@ -291,7 +291,7 @@ func TestCreateEncryption(t *testing.T) {
 		Cipher:          "aes-xts-plain64",
 	}
 	id := "a5082c24-2a27-43a4-b48e-fcec1240e36b"
-	n, err := volumetypes.CreateEncryption(context.TODO(), client.ServiceClient(), id, options).Extract()
+	n, err := volumetypes.CreateEncryption(context.TODO(), client.ServiceClient(fakeServer), id, options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "a5082c24-2a27-43a4-b48e-fcec1240e36b", n.VolumeTypeID)
@@ -303,20 +303,20 @@ func TestCreateEncryption(t *testing.T) {
 }
 
 func TestDeleteEncryption(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteEncryptionResponse(t)
+	MockDeleteEncryptionResponse(t, fakeServer)
 
-	res := volumetypes.DeleteEncryption(context.TODO(), client.ServiceClient(), "a5082c24-2a27-43a4-b48e-fcec1240e36b", "81e069c6-7394-4856-8df7-3b237ca61f74")
+	res := volumetypes.DeleteEncryption(context.TODO(), client.ServiceClient(fakeServer), "a5082c24-2a27-43a4-b48e-fcec1240e36b", "81e069c6-7394-4856-8df7-3b237ca61f74")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateEncryption(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockEncryptionUpdateResponse(t)
+	MockEncryptionUpdateResponse(t, fakeServer)
 
 	options := &volumetypes.UpdateEncryptionOpts{
 		KeySize:         256,
@@ -326,7 +326,7 @@ func TestUpdateEncryption(t *testing.T) {
 	}
 	id := "a5082c24-2a27-43a4-b48e-fcec1240e36b"
 	encryptionID := "81e069c6-7394-4856-8df7-3b237ca61f74"
-	n, err := volumetypes.UpdateEncryption(context.TODO(), client.ServiceClient(), id, encryptionID, options).Extract()
+	n, err := volumetypes.UpdateEncryption(context.TODO(), client.ServiceClient(fakeServer), id, encryptionID, options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "front-end", n.ControlLocation)
@@ -336,12 +336,12 @@ func TestUpdateEncryption(t *testing.T) {
 }
 
 func TestGetEncryption(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockEncryptionGetResponse(t)
+	MockEncryptionGetResponse(t, fakeServer)
 	id := "a5082c24-2a27-43a4-b48e-fcec1240e36b"
-	n, err := volumetypes.GetEncryption(context.TODO(), client.ServiceClient(), id).Extract()
+	n, err := volumetypes.GetEncryption(context.TODO(), client.ServiceClient(fakeServer), id).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "a5082c24-2a27-43a4-b48e-fcec1240e36b", n.VolumeTypeID)
@@ -357,12 +357,12 @@ func TestGetEncryption(t *testing.T) {
 }
 
 func TestGetEncryptionSpec(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockEncryptionGetSpecResponse(t)
+	MockEncryptionGetSpecResponse(t, fakeServer)
 	id := "a5082c24-2a27-43a4-b48e-fcec1240e36b"
-	n, err := volumetypes.GetEncryptionSpec(context.TODO(), client.ServiceClient(), id, "cipher").Extract()
+	n, err := volumetypes.GetEncryptionSpec(context.TODO(), client.ServiceClient(fakeServer), id, "cipher").Extract()
 	th.AssertNoErr(t, err)
 
 	key := "cipher"
diff --git a/openstack/common/extensions/testing/fixtures.go b/openstack/common/extensions/testing/fixtures.go
index 91f6a041b..092763818 100644
--- a/openstack/common/extensions/testing/fixtures.go
+++ b/openstack/common/extensions/testing/fixtures.go
@@ -64,8 +64,8 @@ var SingleExtension = &extensions.Extension{
 
 // HandleListExtensionsSuccessfully creates an HTTP handler at `/extensions` on the test handler
 // mux that response with a list containing a single tenant.
-func HandleListExtensionsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/extensions", func(w http.ResponseWriter, r *http.Request) {
+func HandleListExtensionsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/extensions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -77,8 +77,8 @@ func HandleListExtensionsSuccessfully(t *testing.T) {
 
 // HandleGetExtensionSuccessfully creates an HTTP handler at `/extensions/agent` that responds with
 // a JSON payload corresponding to SingleExtension.
-func HandleGetExtensionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/extensions/agent", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetExtensionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/extensions/agent", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/common/extensions/testing/requests_test.go b/openstack/common/extensions/testing/requests_test.go
index 37a7a5092..5713bf2d9 100644
--- a/openstack/common/extensions/testing/requests_test.go
+++ b/openstack/common/extensions/testing/requests_test.go
@@ -11,13 +11,13 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListExtensionsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListExtensionsSuccessfully(t, fakeServer)
 
 	count := 0
 
-	err := extensions.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := extensions.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := extensions.ExtractExtensions(page)
 		th.AssertNoErr(t, err)
@@ -31,11 +31,11 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetExtensionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetExtensionSuccessfully(t, fakeServer)
 
-	actual, err := extensions.Get(context.TODO(), client.ServiceClient(), "agent").Extract()
+	actual, err := extensions.Get(context.TODO(), client.ServiceClient(fakeServer), "agent").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SingleExtension, actual)
 }
diff --git a/openstack/compute/apiversions/testing/fixtures_test.go b/openstack/compute/apiversions/testing/fixtures_test.go
index 49162c77c..ac122e2d2 100644
--- a/openstack/compute/apiversions/testing/fixtures_test.go
+++ b/openstack/compute/apiversions/testing/fixtures_test.go
@@ -161,8 +161,8 @@ var NovaAllAPIVersionResults = []apiversions.APIVersion{
 	NovaAPIVersion21Result,
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -173,8 +173,8 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/v2.1/", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.1/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -185,8 +185,8 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockGetMultipleResponses(t *testing.T) {
-	th.Mux.HandleFunc("/v3/", func(w http.ResponseWriter, r *http.Request) {
+func MockGetMultipleResponses(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v3/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/apiversions/testing/requests_test.go b/openstack/compute/apiversions/testing/requests_test.go
index 737976b75..59d05b9eb 100644
--- a/openstack/compute/apiversions/testing/requests_test.go
+++ b/openstack/compute/apiversions/testing/requests_test.go
@@ -10,12 +10,12 @@ import (
 )
 
 func TestListAPIVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allVersions, err := apiversions.List(client.ServiceClient()).AllPages(context.TODO())
+	allVersions, err := apiversions.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := apiversions.ExtractAPIVersions(allVersions)
@@ -25,23 +25,23 @@ func TestListAPIVersions(t *testing.T) {
 }
 
 func TestGetAPIVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	actual, err := apiversions.Get(context.TODO(), client.ServiceClient(), "v2.1").Extract()
+	actual, err := apiversions.Get(context.TODO(), client.ServiceClient(fakeServer), "v2.1").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, NovaAPIVersion21Result, *actual)
 }
 
 func TestGetMultipleAPIVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetMultipleResponses(t)
+	MockGetMultipleResponses(t, fakeServer)
 
-	_, err := apiversions.Get(context.TODO(), client.ServiceClient(), "v3").Extract()
+	_, err := apiversions.Get(context.TODO(), client.ServiceClient(fakeServer), "v3").Extract()
 	th.AssertEquals(t, err.Error(), "Unable to find requested API version")
 }
diff --git a/openstack/compute/v2/aggregates/testing/fixtures_test.go b/openstack/compute/v2/aggregates/testing/fixtures_test.go
index 11cebc891..751ca766e 100644
--- a/openstack/compute/v2/aggregates/testing/fixtures_test.go
+++ b/openstack/compute/v2/aggregates/testing/fixtures_test.go
@@ -258,8 +258,8 @@ var (
 )
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-aggregates", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-aggregates", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -268,8 +268,8 @@ func HandleListSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-aggregates", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-aggregates", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -278,9 +278,9 @@ func HandleCreateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleDeleteSuccessfully(t *testing.T) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	v := strconv.Itoa(AggregateIDtoDelete)
-	th.Mux.HandleFunc("/os-aggregates/"+v, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/os-aggregates/"+v, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -288,9 +288,9 @@ func HandleDeleteSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetSuccessfully(t *testing.T) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	v := strconv.Itoa(AggregateIDtoGet)
-	th.Mux.HandleFunc("/os-aggregates/"+v, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/os-aggregates/"+v, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -299,9 +299,9 @@ func HandleGetSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleUpdateSuccessfully(t *testing.T) {
+func HandleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	v := strconv.Itoa(AggregateIDtoUpdate)
-	th.Mux.HandleFunc("/os-aggregates/"+v, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/os-aggregates/"+v, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -310,9 +310,9 @@ func HandleUpdateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleAddHostSuccessfully(t *testing.T) {
+func HandleAddHostSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	v := strconv.Itoa(AggregateWithAddedHost.ID)
-	th.Mux.HandleFunc("/os-aggregates/"+v+"/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/os-aggregates/"+v+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -321,9 +321,9 @@ func HandleAddHostSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleRemoveHostSuccessfully(t *testing.T) {
+func HandleRemoveHostSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	v := strconv.Itoa(AggregateWithRemovedHost.ID)
-	th.Mux.HandleFunc("/os-aggregates/"+v+"/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/os-aggregates/"+v+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -332,9 +332,9 @@ func HandleRemoveHostSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleSetMetadataSuccessfully(t *testing.T) {
+func HandleSetMetadataSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	v := strconv.Itoa(AggregateWithUpdatedMetadata.ID)
-	th.Mux.HandleFunc("/os-aggregates/"+v+"/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/os-aggregates/"+v+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/aggregates/testing/requests_test.go b/openstack/compute/v2/aggregates/testing/requests_test.go
index 601150a58..b6a8912a7 100644
--- a/openstack/compute/v2/aggregates/testing/requests_test.go
+++ b/openstack/compute/v2/aggregates/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestListAggregates(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := aggregates.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := aggregates.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := aggregates.ExtractAggregates(page)
@@ -42,9 +42,9 @@ func TestListAggregates(t *testing.T) {
 }
 
 func TestCreateAggregates(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
 	expected := CreatedAggregate
 
@@ -53,38 +53,38 @@ func TestCreateAggregates(t *testing.T) {
 		AvailabilityZone: "london",
 	}
 
-	actual, err := aggregates.Create(context.TODO(), client.ServiceClient(), opts).Extract()
+	actual, err := aggregates.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &expected, actual)
 }
 
 func TestDeleteAggregates(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	err := aggregates.Delete(context.TODO(), client.ServiceClient(), AggregateIDtoDelete).ExtractErr()
+	err := aggregates.Delete(context.TODO(), client.ServiceClient(fakeServer), AggregateIDtoDelete).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetAggregates(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
 	expected := SecondFakeAggregate
 
-	actual, err := aggregates.Get(context.TODO(), client.ServiceClient(), AggregateIDtoGet).Extract()
+	actual, err := aggregates.Get(context.TODO(), client.ServiceClient(fakeServer), AggregateIDtoGet).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &expected, actual)
 }
 
 func TestUpdateAggregate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
 	expected := UpdatedAggregate
 	opts := aggregates.UpdateOpts{
@@ -92,16 +92,16 @@ func TestUpdateAggregate(t *testing.T) {
 		AvailabilityZone: ptr.To("nova2"),
 	}
 
-	actual, err := aggregates.Update(context.TODO(), client.ServiceClient(), expected.ID, opts).Extract()
+	actual, err := aggregates.Update(context.TODO(), client.ServiceClient(fakeServer), expected.ID, opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &expected, actual)
 }
 
 func TestAddHostAggregate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAddHostSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAddHostSuccessfully(t, fakeServer)
 
 	expected := AggregateWithAddedHost
 
@@ -109,16 +109,16 @@ func TestAddHostAggregate(t *testing.T) {
 		Host: "cmp1",
 	}
 
-	actual, err := aggregates.AddHost(context.TODO(), client.ServiceClient(), expected.ID, opts).Extract()
+	actual, err := aggregates.AddHost(context.TODO(), client.ServiceClient(fakeServer), expected.ID, opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &expected, actual)
 }
 
 func TestRemoveHostAggregate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRemoveHostSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRemoveHostSuccessfully(t, fakeServer)
 
 	expected := AggregateWithRemovedHost
 
@@ -126,16 +126,16 @@ func TestRemoveHostAggregate(t *testing.T) {
 		Host: "cmp1",
 	}
 
-	actual, err := aggregates.RemoveHost(context.TODO(), client.ServiceClient(), expected.ID, opts).Extract()
+	actual, err := aggregates.RemoveHost(context.TODO(), client.ServiceClient(fakeServer), expected.ID, opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &expected, actual)
 }
 
 func TestSetMetadataAggregate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSetMetadataSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSetMetadataSuccessfully(t, fakeServer)
 
 	expected := AggregateWithUpdatedMetadata
 
@@ -143,7 +143,7 @@ func TestSetMetadataAggregate(t *testing.T) {
 		Metadata: map[string]any{"key": "value"},
 	}
 
-	actual, err := aggregates.SetMetadata(context.TODO(), client.ServiceClient(), expected.ID, opts).Extract()
+	actual, err := aggregates.SetMetadata(context.TODO(), client.ServiceClient(fakeServer), expected.ID, opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &expected, actual)
diff --git a/openstack/compute/v2/attachinterfaces/testing/fixtures_test.go b/openstack/compute/v2/attachinterfaces/testing/fixtures_test.go
index 59a03d57d..16effc651 100644
--- a/openstack/compute/v2/attachinterfaces/testing/fixtures_test.go
+++ b/openstack/compute/v2/attachinterfaces/testing/fixtures_test.go
@@ -63,8 +63,8 @@ var CreateInterfacesExpected = attachinterfaces.Interface{
 }
 
 // HandleInterfaceListSuccessfully sets up the test server to respond to a ListInterfaces request.
-func HandleInterfaceListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/b07e7a3b-d951-4efc-a4f9-ac9f001afb7f/os-interface", func(w http.ResponseWriter, r *http.Request) {
+func HandleInterfaceListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/b07e7a3b-d951-4efc-a4f9-ac9f001afb7f/os-interface", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -93,8 +93,8 @@ func HandleInterfaceListSuccessfully(t *testing.T) {
 }
 
 // HandleInterfaceGetSuccessfully sets up the test server to respond to a GetInterface request.
-func HandleInterfaceGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/b07e7a3b-d951-4efc-a4f9-ac9f001afb7f/os-interface/0dde1598-b374-474e-986f-5b8dd1df1d4e", func(w http.ResponseWriter, r *http.Request) {
+func HandleInterfaceGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/b07e7a3b-d951-4efc-a4f9-ac9f001afb7f/os-interface/0dde1598-b374-474e-986f-5b8dd1df1d4e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -122,8 +122,8 @@ func HandleInterfaceGetSuccessfully(t *testing.T) {
 }
 
 // HandleInterfaceCreateSuccessfully sets up the test server to respond to a CreateInterface request.
-func HandleInterfaceCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/b07e7a3b-d951-4efc-a4f9-ac9f001afb7f/os-interface", func(w http.ResponseWriter, r *http.Request) {
+func HandleInterfaceCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/b07e7a3b-d951-4efc-a4f9-ac9f001afb7f/os-interface", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -152,8 +152,8 @@ func HandleInterfaceCreateSuccessfully(t *testing.T) {
 }
 
 // HandleInterfaceDeleteSuccessfully sets up the test server to respond to a DeleteInterface request.
-func HandleInterfaceDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/b07e7a3b-d951-4efc-a4f9-ac9f001afb7f/os-interface/0dde1598-b374-474e-986f-5b8dd1df1d4e", func(w http.ResponseWriter, r *http.Request) {
+func HandleInterfaceDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/b07e7a3b-d951-4efc-a4f9-ac9f001afb7f/os-interface/0dde1598-b374-474e-986f-5b8dd1df1d4e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/attachinterfaces/testing/requests_test.go b/openstack/compute/v2/attachinterfaces/testing/requests_test.go
index d436bc081..a8fe23946 100644
--- a/openstack/compute/v2/attachinterfaces/testing/requests_test.go
+++ b/openstack/compute/v2/attachinterfaces/testing/requests_test.go
@@ -11,13 +11,13 @@ import (
 )
 
 func TestListInterface(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleInterfaceListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleInterfaceListSuccessfully(t, fakeServer)
 
 	expected := ListInterfacesExpected
 	pages := 0
-	err := attachinterfaces.List(client.ServiceClient(), "b07e7a3b-d951-4efc-a4f9-ac9f001afb7f").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := attachinterfaces.List(client.ServiceClient(fakeServer), "b07e7a3b-d951-4efc-a4f9-ac9f001afb7f").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := attachinterfaces.ExtractInterfaces(page)
@@ -35,42 +35,42 @@ func TestListInterface(t *testing.T) {
 }
 
 func TestListInterfacesAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleInterfaceListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleInterfaceListSuccessfully(t, fakeServer)
 
-	allPages, err := attachinterfaces.List(client.ServiceClient(), "b07e7a3b-d951-4efc-a4f9-ac9f001afb7f").AllPages(context.TODO())
+	allPages, err := attachinterfaces.List(client.ServiceClient(fakeServer), "b07e7a3b-d951-4efc-a4f9-ac9f001afb7f").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	_, err = attachinterfaces.ExtractInterfaces(allPages)
 	th.AssertNoErr(t, err)
 }
 
 func TestGetInterface(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleInterfaceGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleInterfaceGetSuccessfully(t, fakeServer)
 
 	expected := GetInterfaceExpected
 
 	serverID := "b07e7a3b-d951-4efc-a4f9-ac9f001afb7f"
 	interfaceID := "0dde1598-b374-474e-986f-5b8dd1df1d4e"
 
-	actual, err := attachinterfaces.Get(context.TODO(), client.ServiceClient(), serverID, interfaceID).Extract()
+	actual, err := attachinterfaces.Get(context.TODO(), client.ServiceClient(fakeServer), serverID, interfaceID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, actual)
 }
 
 func TestCreateInterface(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleInterfaceCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleInterfaceCreateSuccessfully(t, fakeServer)
 
 	expected := CreateInterfacesExpected
 
 	serverID := "b07e7a3b-d951-4efc-a4f9-ac9f001afb7f"
 	networkID := "8a5fe506-7e9f-4091-899b-96336909d93c"
 
-	actual, err := attachinterfaces.Create(context.TODO(), client.ServiceClient(), serverID, attachinterfaces.CreateOpts{
+	actual, err := attachinterfaces.Create(context.TODO(), client.ServiceClient(fakeServer), serverID, attachinterfaces.CreateOpts{
 		NetworkID: networkID,
 	}).Extract()
 	th.AssertNoErr(t, err)
@@ -78,13 +78,13 @@ func TestCreateInterface(t *testing.T) {
 }
 
 func TestDeleteInterface(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleInterfaceDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleInterfaceDeleteSuccessfully(t, fakeServer)
 
 	serverID := "b07e7a3b-d951-4efc-a4f9-ac9f001afb7f"
 	portID := "0dde1598-b374-474e-986f-5b8dd1df1d4e"
 
-	err := attachinterfaces.Delete(context.TODO(), client.ServiceClient(), serverID, portID).ExtractErr()
+	err := attachinterfaces.Delete(context.TODO(), client.ServiceClient(fakeServer), serverID, portID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/compute/v2/availabilityzones/testing/fixtures_test.go b/openstack/compute/v2/availabilityzones/testing/fixtures_test.go
index a36c64649..53899fbf7 100644
--- a/openstack/compute/v2/availabilityzones/testing/fixtures_test.go
+++ b/openstack/compute/v2/availabilityzones/testing/fixtures_test.go
@@ -174,8 +174,8 @@ var AZDetailResult = []az.AvailabilityZone{
 
 // HandleGetSuccessfully configures the test server to respond to a Get request
 // for availability zone information.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-availability-zone", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-availability-zone", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -186,8 +186,8 @@ func HandleGetSuccessfully(t *testing.T) {
 
 // HandleGetDetailSuccessfully configures the test server to respond to a Get request
 // for detailed availability zone information.
-func HandleGetDetailSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-availability-zone/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetDetailSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-availability-zone/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/availabilityzones/testing/requests_test.go b/openstack/compute/v2/availabilityzones/testing/requests_test.go
index f537d9d18..fb6a20ee2 100644
--- a/openstack/compute/v2/availabilityzones/testing/requests_test.go
+++ b/openstack/compute/v2/availabilityzones/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 
 // Verifies that availability zones can be listed correctly
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetSuccessfully(t)
+	HandleGetSuccessfully(t, fakeServer)
 
-	allPages, err := az.List(client.ServiceClient()).AllPages(context.TODO())
+	allPages, err := az.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := az.ExtractAvailabilityZones(allPages)
@@ -27,12 +27,12 @@ func TestList(t *testing.T) {
 
 // Verifies that detailed availability zones can be listed correctly
 func TestListDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetDetailSuccessfully(t)
+	HandleGetDetailSuccessfully(t, fakeServer)
 
-	allPages, err := az.ListDetail(client.ServiceClient()).AllPages(context.TODO())
+	allPages, err := az.ListDetail(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := az.ExtractAvailabilityZones(allPages)
diff --git a/openstack/compute/v2/diagnostics/testing/fixtures_test.go b/openstack/compute/v2/diagnostics/testing/fixtures_test.go
index 35cfd134b..41e5dcf0f 100644
--- a/openstack/compute/v2/diagnostics/testing/fixtures_test.go
+++ b/openstack/compute/v2/diagnostics/testing/fixtures_test.go
@@ -9,8 +9,8 @@ import (
 )
 
 // HandleDiagnosticGetSuccessfully sets up the test server to respond to a diagnostic Get request.
-func HandleDiagnosticGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/diagnostics", func(w http.ResponseWriter, r *http.Request) {
+func HandleDiagnosticGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/diagnostics", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/compute/v2/diagnostics/testing/requests_test.go b/openstack/compute/v2/diagnostics/testing/requests_test.go
index 983c4d18e..6f3feceea 100644
--- a/openstack/compute/v2/diagnostics/testing/requests_test.go
+++ b/openstack/compute/v2/diagnostics/testing/requests_test.go
@@ -10,14 +10,14 @@ import (
 )
 
 func TestGetDiagnostics(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleDiagnosticGetSuccessfully(t)
+	HandleDiagnosticGetSuccessfully(t, fakeServer)
 
 	expected := map[string]any{"cpu0_time": float64(173), "memory": float64(524288)}
 
-	res, err := diagnostics.Get(context.TODO(), client.ServiceClient(), "1234asdf").Extract()
+	res, err := diagnostics.Get(context.TODO(), client.ServiceClient(fakeServer), "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, expected, res)
diff --git a/openstack/compute/v2/extensions/testing/delegate_test.go b/openstack/compute/v2/extensions/testing/delegate_test.go
index a2b8774c8..4461b7464 100644
--- a/openstack/compute/v2/extensions/testing/delegate_test.go
+++ b/openstack/compute/v2/extensions/testing/delegate_test.go
@@ -12,13 +12,13 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleListExtensionsSuccessfully(t)
+	HandleListExtensionsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := extensions.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := extensions.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := extensions.ExtractExtensions(page)
 		th.AssertNoErr(t, err)
@@ -42,12 +42,12 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetExtensionsSuccessfully(t)
+	HandleGetExtensionsSuccessfully(t, fakeServer)
 
-	ext, err := extensions.Get(context.TODO(), client.ServiceClient(), "agent").Extract()
+	ext, err := extensions.Get(context.TODO(), client.ServiceClient(fakeServer), "agent").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, ext.Updated, "2013-02-03T10:00:00-00:00")
diff --git a/openstack/compute/v2/extensions/testing/fixtures_test.go b/openstack/compute/v2/extensions/testing/fixtures_test.go
index b1622af76..c330c9c86 100644
--- a/openstack/compute/v2/extensions/testing/fixtures_test.go
+++ b/openstack/compute/v2/extensions/testing/fixtures_test.go
@@ -9,8 +9,8 @@ import (
 	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func HandleListExtensionsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/extensions", func(w http.ResponseWriter, r *http.Request) {
+func HandleListExtensionsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/extensions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -33,8 +33,8 @@ func HandleListExtensionsSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetExtensionsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/extensions/agent", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetExtensionsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/extensions/agent", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/flavors/testing/fixtures_test.go b/openstack/compute/v2/flavors/testing/fixtures_test.go
index a92cdcd1d..1dfdbf695 100644
--- a/openstack/compute/v2/flavors/testing/fixtures_test.go
+++ b/openstack/compute/v2/flavors/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // ExtraSpecsGetBody provides a GET result of the extra_specs for a flavor
@@ -49,10 +49,10 @@ var UpdatedExtraSpec = map[string]string{
 	"hw:cpu_policy": "CPU-POLICY-2",
 }
 
-func HandleExtraSpecsListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/flavors/1/os-extra_specs", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecsListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/flavors/1/os-extra_specs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -61,10 +61,10 @@ func HandleExtraSpecsListSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleExtraSpecGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/flavors/1/os-extra_specs/hw:cpu_policy", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/flavors/1/os-extra_specs/hw:cpu_policy", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -73,10 +73,10 @@ func HandleExtraSpecGetSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleExtraSpecsCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/flavors/1/os-extra_specs", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecsCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/flavors/1/os-extra_specs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `{
 				"extra_specs": {
@@ -91,10 +91,10 @@ func HandleExtraSpecsCreateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleExtraSpecUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/flavors/1/os-extra_specs/hw:cpu_policy", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/flavors/1/os-extra_specs/hw:cpu_policy", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `{
 				"hw:cpu_policy":        "CPU-POLICY-2"
@@ -106,10 +106,10 @@ func HandleExtraSpecUpdateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleExtraSpecDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/flavors/1/os-extra_specs/hw:cpu_policy", func(w http.ResponseWriter, r *http.Request) {
+func HandleExtraSpecDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/flavors/1/os-extra_specs/hw:cpu_policy", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusOK)
 	})
diff --git a/openstack/compute/v2/flavors/testing/requests_test.go b/openstack/compute/v2/flavors/testing/requests_test.go
index 315fcd340..8940fec65 100644
--- a/openstack/compute/v2/flavors/testing/requests_test.go
+++ b/openstack/compute/v2/flavors/testing/requests_test.go
@@ -11,16 +11,16 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/compute/v2/flavors"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestListFlavors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/flavors/detail", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		if err := r.ParseForm(); err != nil {
@@ -75,7 +75,7 @@ func TestListFlavors(t *testing.T) {
 							}
 						]
 					}
-				`, th.Server.URL)
+				`, fakeServer.Server.URL)
 		case "2":
 			fmt.Fprint(w, `{ "flavors": [] }`)
 		default:
@@ -85,7 +85,7 @@ func TestListFlavors(t *testing.T) {
 
 	pages := 0
 	// Get public and private flavors
-	err := flavors.ListDetail(fake.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := flavors.ListDetail(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := flavors.ExtractFlavors(page)
@@ -114,12 +114,12 @@ func TestListFlavors(t *testing.T) {
 }
 
 func TestGetFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/flavors/12345", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors/12345", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `
@@ -141,7 +141,7 @@ func TestGetFlavor(t *testing.T) {
 		`)
 	})
 
-	actual, err := flavors.Get(context.TODO(), fake.ServiceClient(), "12345").Extract()
+	actual, err := flavors.Get(context.TODO(), client.ServiceClient(fakeServer), "12345").Extract()
 	if err != nil {
 		t.Fatalf("Unable to get flavor: %v", err)
 	}
@@ -163,12 +163,12 @@ func TestGetFlavor(t *testing.T) {
 }
 
 func TestCreateFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/flavors", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `
@@ -197,7 +197,7 @@ func TestCreateFlavor(t *testing.T) {
 		RxTxFactor:  1.0,
 		Description: "foo",
 	}
-	actual, err := flavors.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	actual, err := flavors.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	if err != nil {
 		t.Fatalf("Unable to create flavor: %v", err)
 	}
@@ -218,12 +218,12 @@ func TestCreateFlavor(t *testing.T) {
 }
 
 func TestUpdateFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/flavors/12345678", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors/12345678", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `
@@ -245,7 +245,7 @@ func TestUpdateFlavor(t *testing.T) {
 	opts := &flavors.UpdateOpts{
 		Description: ptr.To("foo"),
 	}
-	actual, err := flavors.Update(context.TODO(), fake.ServiceClient(), "12345678", opts).Extract()
+	actual, err := flavors.Update(context.TODO(), client.ServiceClient(fakeServer), "12345678", opts).Extract()
 	if err != nil {
 		t.Fatalf("Unable to update flavor: %v", err)
 	}
@@ -267,27 +267,27 @@ func TestUpdateFlavor(t *testing.T) {
 }
 
 func TestDeleteFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/flavors/12345678", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors/12345678", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusAccepted)
 	})
 
-	res := flavors.Delete(context.TODO(), fake.ServiceClient(), "12345678")
+	res := flavors.Delete(context.TODO(), client.ServiceClient(fakeServer), "12345678")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestFlavorAccessesList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/flavors/12345678/os-flavor-access", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors/12345678/os-flavor-access", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `
 			{
@@ -308,7 +308,7 @@ func TestFlavorAccessesList(t *testing.T) {
 		},
 	}
 
-	allPages, err := flavors.ListAccesses(fake.ServiceClient(), "12345678").AllPages(context.TODO())
+	allPages, err := flavors.ListAccesses(client.ServiceClient(fakeServer), "12345678").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := flavors.ExtractAccesses(allPages)
@@ -320,12 +320,12 @@ func TestFlavorAccessesList(t *testing.T) {
 }
 
 func TestFlavorAccessAdd(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/flavors/12345678/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors/12345678/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "accept", "application/json")
 		th.TestJSONRequest(t, r, `
 			{
@@ -360,7 +360,7 @@ func TestFlavorAccessAdd(t *testing.T) {
 		Tenant: "2f954bcf047c4ee9b09a37d49ae6db54",
 	}
 
-	actual, err := flavors.AddAccess(context.TODO(), fake.ServiceClient(), "12345678", addAccessOpts).Extract()
+	actual, err := flavors.AddAccess(context.TODO(), client.ServiceClient(fakeServer), "12345678", addAccessOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	if !reflect.DeepEqual(expected, actual) {
@@ -369,12 +369,12 @@ func TestFlavorAccessAdd(t *testing.T) {
 }
 
 func TestFlavorAccessRemove(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/flavors/12345678/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors/12345678/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "accept", "application/json")
 		th.TestJSONRequest(t, r, `
 			{
@@ -398,7 +398,7 @@ func TestFlavorAccessRemove(t *testing.T) {
 		Tenant: "2f954bcf047c4ee9b09a37d49ae6db54",
 	}
 
-	actual, err := flavors.RemoveAccess(context.TODO(), fake.ServiceClient(), "12345678", removeAccessOpts).Extract()
+	actual, err := flavors.RemoveAccess(context.TODO(), client.ServiceClient(fakeServer), "12345678", removeAccessOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	if !reflect.DeepEqual(expected, actual) {
@@ -407,61 +407,61 @@ func TestFlavorAccessRemove(t *testing.T) {
 }
 
 func TestFlavorExtraSpecsList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecsListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecsListSuccessfully(t, fakeServer)
 
 	expected := ExtraSpecs
-	actual, err := flavors.ListExtraSpecs(context.TODO(), fake.ServiceClient(), "1").Extract()
+	actual, err := flavors.ListExtraSpecs(context.TODO(), client.ServiceClient(fakeServer), "1").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestFlavorExtraSpecGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecGetSuccessfully(t, fakeServer)
 
 	expected := ExtraSpec
-	actual, err := flavors.GetExtraSpec(context.TODO(), fake.ServiceClient(), "1", "hw:cpu_policy").Extract()
+	actual, err := flavors.GetExtraSpec(context.TODO(), client.ServiceClient(fakeServer), "1", "hw:cpu_policy").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestFlavorExtraSpecsCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecsCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecsCreateSuccessfully(t, fakeServer)
 
 	createOpts := flavors.ExtraSpecsOpts{
 		"hw:cpu_policy":        "CPU-POLICY",
 		"hw:cpu_thread_policy": "CPU-THREAD-POLICY",
 	}
 	expected := ExtraSpecs
-	actual, err := flavors.CreateExtraSpecs(context.TODO(), fake.ServiceClient(), "1", createOpts).Extract()
+	actual, err := flavors.CreateExtraSpecs(context.TODO(), client.ServiceClient(fakeServer), "1", createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestFlavorExtraSpecUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecUpdateSuccessfully(t, fakeServer)
 
 	updateOpts := flavors.ExtraSpecsOpts{
 		"hw:cpu_policy": "CPU-POLICY-2",
 	}
 	expected := UpdatedExtraSpec
-	actual, err := flavors.UpdateExtraSpec(context.TODO(), fake.ServiceClient(), "1", updateOpts).Extract()
+	actual, err := flavors.UpdateExtraSpec(context.TODO(), client.ServiceClient(fakeServer), "1", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestFlavorExtraSpecDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleExtraSpecDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleExtraSpecDeleteSuccessfully(t, fakeServer)
 
-	res := flavors.DeleteExtraSpec(context.TODO(), fake.ServiceClient(), "1", "hw:cpu_policy")
+	res := flavors.DeleteExtraSpec(context.TODO(), client.ServiceClient(fakeServer), "1", "hw:cpu_policy")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/compute/v2/hypervisors/testing/fixtures_test.go b/openstack/compute/v2/hypervisors/testing/fixtures_test.go
index 4bdb2c061..ebfd816c0 100644
--- a/openstack/compute/v2/hypervisors/testing/fixtures_test.go
+++ b/openstack/compute/v2/hypervisors/testing/fixtures_test.go
@@ -6,7 +6,6 @@ import (
 	"testing"
 
 	"github.com/gophercloud/gophercloud/v2/openstack/compute/v2/hypervisors"
-	"github.com/gophercloud/gophercloud/v2/testhelper"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
@@ -616,8 +615,8 @@ var (
 	}
 )
 
-func HandleHypervisorsStatisticsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-hypervisors/statistics", func(w http.ResponseWriter, r *http.Request) {
+func HandleHypervisorsStatisticsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-hypervisors/statistics", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -626,8 +625,8 @@ func HandleHypervisorsStatisticsSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleHypervisorListPre253Successfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-hypervisors/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleHypervisorListPre253Successfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-hypervisors/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -636,15 +635,15 @@ func HandleHypervisorListPre253Successfully(t *testing.T) {
 	})
 }
 
-func HandleHypervisorListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-hypervisors/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleHypervisorListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-hypervisors/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		switch r.URL.Query().Get("marker") {
 		case "":
 			w.Header().Add("Content-Type", "application/json")
-			fmt.Fprintf(w, HypervisorListBodyPage1, testhelper.Server.URL)
+			fmt.Fprintf(w, HypervisorListBodyPage1, fakeServer.Server.URL)
 		case "c48f6247-abe4-4a24-824e-ea39e108874f":
 			w.Header().Add("Content-Type", "application/json")
 			fmt.Fprint(w, HypervisorListBodyPage2)
@@ -654,8 +653,8 @@ func HandleHypervisorListSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleHypervisorListWithParametersSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-hypervisors/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleHypervisorListWithParametersSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-hypervisors/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestFormValues(t, r, map[string]string{
@@ -667,8 +666,8 @@ func HandleHypervisorListWithParametersSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleHypervisorGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-hypervisors/"+HypervisorFake.ID, func(w http.ResponseWriter, r *http.Request) {
+func HandleHypervisorGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-hypervisors/"+HypervisorFake.ID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -677,8 +676,8 @@ func HandleHypervisorGetSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleHypervisorGetEmptyCPUInfoSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-hypervisors/"+HypervisorFake.ID, func(w http.ResponseWriter, r *http.Request) {
+func HandleHypervisorGetEmptyCPUInfoSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-hypervisors/"+HypervisorFake.ID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -687,8 +686,8 @@ func HandleHypervisorGetEmptyCPUInfoSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleHypervisorAfterV287ResponseSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-hypervisors/"+HypervisorFake.ID, func(w http.ResponseWriter, r *http.Request) {
+func HandleHypervisorAfterV287ResponseSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-hypervisors/"+HypervisorFake.ID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -697,8 +696,8 @@ func HandleHypervisorAfterV287ResponseSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleHypervisorUptimeSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-hypervisors/"+HypervisorFake.ID+"/uptime", func(w http.ResponseWriter, r *http.Request) {
+func HandleHypervisorUptimeSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-hypervisors/"+HypervisorFake.ID+"/uptime", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/hypervisors/testing/requests_test.go b/openstack/compute/v2/hypervisors/testing/requests_test.go
index 5acf7d0d1..a2b2183e4 100644
--- a/openstack/compute/v2/hypervisors/testing/requests_test.go
+++ b/openstack/compute/v2/hypervisors/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListHypervisorsPre253(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorListPre253Successfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorListPre253Successfully(t, fakeServer)
 
 	pages := 0
-	err := hypervisors.List(client.ServiceClient(),
+	err := hypervisors.List(client.ServiceClient(fakeServer),
 		hypervisors.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
@@ -42,11 +42,11 @@ func TestListHypervisorsPre253(t *testing.T) {
 }
 
 func TestListAllHypervisorsPre253(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorListPre253Successfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorListPre253Successfully(t, fakeServer)
 
-	allPages, err := hypervisors.List(client.ServiceClient(), hypervisors.ListOpts{}).AllPages(context.TODO())
+	allPages, err := hypervisors.List(client.ServiceClient(fakeServer), hypervisors.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := hypervisors.ExtractHypervisors(allPages)
 	th.AssertNoErr(t, err)
@@ -55,12 +55,12 @@ func TestListAllHypervisorsPre253(t *testing.T) {
 }
 
 func TestListHypervisors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := hypervisors.List(client.ServiceClient(),
+	err := hypervisors.List(client.ServiceClient(fakeServer),
 		hypervisors.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
@@ -85,11 +85,11 @@ func TestListHypervisors(t *testing.T) {
 }
 
 func TestListAllHypervisors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorListSuccessfully(t, fakeServer)
 
-	allPages, err := hypervisors.List(client.ServiceClient(), hypervisors.ListOpts{}).AllPages(context.TODO())
+	allPages, err := hypervisors.List(client.ServiceClient(fakeServer), hypervisors.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := hypervisors.ExtractHypervisors(allPages)
 	th.AssertNoErr(t, err)
@@ -98,12 +98,12 @@ func TestListAllHypervisors(t *testing.T) {
 }
 
 func TestListAllHypervisorsWithParameters(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorListWithParametersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorListWithParametersSuccessfully(t, fakeServer)
 
 	with_servers := true
-	allPages, err := hypervisors.List(client.ServiceClient(), hypervisors.ListOpts{WithServers: &with_servers}).AllPages(context.TODO())
+	allPages, err := hypervisors.List(client.ServiceClient(fakeServer), hypervisors.ListOpts{WithServers: &with_servers}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := hypervisors.ExtractHypervisors(allPages)
 	th.AssertNoErr(t, err)
@@ -112,61 +112,61 @@ func TestListAllHypervisorsWithParameters(t *testing.T) {
 }
 
 func TestHypervisorsStatistics(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorsStatisticsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorsStatisticsSuccessfully(t, fakeServer)
 
 	expected := HypervisorsStatisticsExpected
 
-	actual, err := hypervisors.GetStatistics(context.TODO(), client.ServiceClient()).Extract()
+	actual, err := hypervisors.GetStatistics(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, actual)
 }
 
 func TestGetHypervisor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorGetSuccessfully(t, fakeServer)
 
 	expected := HypervisorFake
 
-	actual, err := hypervisors.Get(context.TODO(), client.ServiceClient(), expected.ID).Extract()
+	actual, err := hypervisors.Get(context.TODO(), client.ServiceClient(fakeServer), expected.ID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, actual)
 }
 
 func TestGetHypervisorEmptyCPUInfo(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorGetEmptyCPUInfoSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorGetEmptyCPUInfoSuccessfully(t, fakeServer)
 
 	expected := HypervisorEmptyCPUInfo
 
-	actual, err := hypervisors.Get(context.TODO(), client.ServiceClient(), expected.ID).Extract()
+	actual, err := hypervisors.Get(context.TODO(), client.ServiceClient(fakeServer), expected.ID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, actual)
 }
 
 func TestGetHypervisorAfterV287Response(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorAfterV287ResponseSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorAfterV287ResponseSuccessfully(t, fakeServer)
 
 	expected := HypervisorAfterV287Response
 
-	actual, err := hypervisors.Get(context.TODO(), client.ServiceClient(), expected.ID).Extract()
+	actual, err := hypervisors.Get(context.TODO(), client.ServiceClient(fakeServer), expected.ID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, actual)
 }
 
 func TestHypervisorsUptime(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHypervisorUptimeSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHypervisorUptimeSuccessfully(t, fakeServer)
 
 	expected := HypervisorUptimeExpected
 
-	actual, err := hypervisors.GetUptime(context.TODO(), client.ServiceClient(), HypervisorFake.ID).Extract()
+	actual, err := hypervisors.GetUptime(context.TODO(), client.ServiceClient(fakeServer), HypervisorFake.ID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, actual)
 }
diff --git a/openstack/compute/v2/instanceactions/testing/fixtures_test.go b/openstack/compute/v2/instanceactions/testing/fixtures_test.go
index cbbf6def2..1a53cbc7c 100644
--- a/openstack/compute/v2/instanceactions/testing/fixtures_test.go
+++ b/openstack/compute/v2/instanceactions/testing/fixtures_test.go
@@ -34,8 +34,8 @@ var ListExpected = []instanceactions.InstanceAction{
 }
 
 // HandleInstanceActionListSuccessfully sets up the test server to respond to a ListAddresses request.
-func HandleInstanceActionListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/asdfasdfasdf/os-instance-actions", func(w http.ResponseWriter, r *http.Request) {
+func HandleInstanceActionListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/asdfasdfasdf/os-instance-actions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -94,8 +94,8 @@ var GetExpected = instanceactions.InstanceActionDetail{
 }
 
 // HandleInstanceActionGetSuccessfully sets up the test server to respond to a Get request.
-func HandleInstanceActionGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/asdfasdfasdf/os-instance-actions/okzeorkmkfs", func(w http.ResponseWriter, r *http.Request) {
+func HandleInstanceActionGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/asdfasdfasdf/os-instance-actions/okzeorkmkfs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/instanceactions/testing/request_test.go b/openstack/compute/v2/instanceactions/testing/request_test.go
index 459c77694..1b36152d7 100644
--- a/openstack/compute/v2/instanceactions/testing/request_test.go
+++ b/openstack/compute/v2/instanceactions/testing/request_test.go
@@ -11,13 +11,13 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleInstanceActionListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleInstanceActionListSuccessfully(t, fakeServer)
 
 	expected := ListExpected
 	pages := 0
-	err := instanceactions.List(client.ServiceClient(), "asdfasdfasdf", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := instanceactions.List(client.ServiceClient(fakeServer), "asdfasdfasdf", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := instanceactions.ExtractInstanceActions(page)
@@ -35,11 +35,11 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleInstanceActionGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleInstanceActionGetSuccessfully(t, fakeServer)
 
-	client := client.ServiceClient()
+	client := client.ServiceClient(fakeServer)
 	actual, err := instanceactions.Get(context.TODO(), client, "asdfasdfasdf", "okzeorkmkfs").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
diff --git a/openstack/compute/v2/keypairs/testing/fixtures_test.go b/openstack/compute/v2/keypairs/testing/fixtures_test.go
index 92460e925..27dc93399 100644
--- a/openstack/compute/v2/keypairs/testing/fixtures_test.go
+++ b/openstack/compute/v2/keypairs/testing/fixtures_test.go
@@ -151,8 +151,8 @@ var ImportedKeyPair = keypairs.KeyPair{
 }
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -162,8 +162,8 @@ func HandleListSuccessfully(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a Get request for "firstkey".
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-keypairs/firstkey", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-keypairs/firstkey", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -181,8 +181,8 @@ func HandleGetSuccessfully(t *testing.T) {
 
 // HandleCreateSuccessfully configures the test server to respond to a Create request for a new
 // keypair called "createdkey".
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "keypair": { "name": "createdkey" } }`)
@@ -194,8 +194,8 @@ func HandleCreateSuccessfully(t *testing.T) {
 
 // HandleCreateSuccessfullyOtherUser configures the test server to respond to a Create request for a new
 // keypair called "createdkey" for another user, different than the current one.
-func HandleCreateSuccessfullyOtherUser(t *testing.T) {
-	th.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSuccessfullyOtherUser(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "keypair": { "name": "createdkey", "user_id": "fake2" } }`)
@@ -207,8 +207,8 @@ func HandleCreateSuccessfullyOtherUser(t *testing.T) {
 
 // HandleImportSuccessfully configures the test server to respond to an Import request for an
 // existing keypair called "importedkey".
-func HandleImportSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) {
+func HandleImportSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-keypairs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `
@@ -227,8 +227,8 @@ func HandleImportSuccessfully(t *testing.T) {
 
 // HandleDeleteSuccessfully configures the test server to respond to a Delete request for a
 // keypair called "deletedkey".
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-keypairs/deletedkey", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-keypairs/deletedkey", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.AssertEquals(t, r.Form.Get("user_id"), "")
@@ -239,8 +239,8 @@ func HandleDeleteSuccessfully(t *testing.T) {
 
 // HandleDeleteSuccessfully configures the test server to respond to a Delete request for a
 // keypair called "deletedkey" for another user.
-func HandleDeleteSuccessfullyOtherUser(t *testing.T) {
-	th.Mux.HandleFunc("/os-keypairs/deletedkey", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfullyOtherUser(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-keypairs/deletedkey", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestFormValues(t, r, map[string]string{"user_id": "fake2"})
diff --git a/openstack/compute/v2/keypairs/testing/requests_test.go b/openstack/compute/v2/keypairs/testing/requests_test.go
index 35e9f7653..43961a3b1 100644
--- a/openstack/compute/v2/keypairs/testing/requests_test.go
+++ b/openstack/compute/v2/keypairs/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	count := 0
-	err := keypairs.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := keypairs.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := keypairs.ExtractKeyPairs(page)
 		th.AssertNoErr(t, err)
@@ -29,11 +29,11 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
-	actual, err := keypairs.Create(context.TODO(), client.ServiceClient(), keypairs.CreateOpts{
+	actual, err := keypairs.Create(context.TODO(), client.ServiceClient(fakeServer), keypairs.CreateOpts{
 		Name: "createdkey",
 	}).Extract()
 	th.AssertNoErr(t, err)
@@ -41,11 +41,11 @@ func TestCreate(t *testing.T) {
 }
 
 func TestCreateOtherUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfullyOtherUser(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfullyOtherUser(t, fakeServer)
 
-	actual, err := keypairs.Create(context.TODO(), client.ServiceClient(), keypairs.CreateOpts{
+	actual, err := keypairs.Create(context.TODO(), client.ServiceClient(fakeServer), keypairs.CreateOpts{
 		Name:   "createdkey",
 		UserID: "fake2",
 	}).Extract()
@@ -54,11 +54,11 @@ func TestCreateOtherUser(t *testing.T) {
 }
 
 func TestImport(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleImportSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleImportSuccessfully(t, fakeServer)
 
-	actual, err := keypairs.Create(context.TODO(), client.ServiceClient(), keypairs.CreateOpts{
+	actual, err := keypairs.Create(context.TODO(), client.ServiceClient(fakeServer), keypairs.CreateOpts{
 		Name:      "importedkey",
 		PublicKey: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAgQDx8nkQv/zgGgB4rMYmIf+6A4l6Rr+o/6lHBQdW5aYd44bd8JttDCE/F/pNRr0lRE+PiqSPO8nDPHw0010JeMH9gYgnnFlyY3/OcJ02RhIPyyxYpv9FhY+2YiUkpwFOcLImyrxEsYXpD/0d3ac30bNH6Sw9JD9UZHYcpSxsIbECHw== Generated by Nova",
 	}).Extract()
@@ -67,47 +67,47 @@ func TestImport(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := keypairs.Get(context.TODO(), client.ServiceClient(), "firstkey", nil).Extract()
+	actual, err := keypairs.Get(context.TODO(), client.ServiceClient(fakeServer), "firstkey", nil).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstKeyPair, actual)
 }
 
 func TestGetOtherUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
 	getOpts := keypairs.GetOpts{
 		UserID: "fake2",
 	}
 
-	actual, err := keypairs.Get(context.TODO(), client.ServiceClient(), "firstkey", getOpts).Extract()
+	actual, err := keypairs.Get(context.TODO(), client.ServiceClient(fakeServer), "firstkey", getOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstKeyPairOtherUser, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	err := keypairs.Delete(context.TODO(), client.ServiceClient(), "deletedkey", nil).ExtractErr()
+	err := keypairs.Delete(context.TODO(), client.ServiceClient(fakeServer), "deletedkey", nil).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDeleteOtherUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfullyOtherUser(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfullyOtherUser(t, fakeServer)
 
 	deleteOpts := keypairs.DeleteOpts{
 		UserID: "fake2",
 	}
 
-	err := keypairs.Delete(context.TODO(), client.ServiceClient(), "deletedkey", deleteOpts).ExtractErr()
+	err := keypairs.Delete(context.TODO(), client.ServiceClient(fakeServer), "deletedkey", deleteOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/compute/v2/limits/testing/fixtures_test.go b/openstack/compute/v2/limits/testing/fixtures_test.go
index ee04c7244..365b9d68b 100644
--- a/openstack/compute/v2/limits/testing/fixtures_test.go
+++ b/openstack/compute/v2/limits/testing/fixtures_test.go
@@ -69,8 +69,8 @@ const TenantID = "555544443333222211110000ffffeeee"
 
 // HandleGetSuccessfully configures the test server to respond to a Get request
 // for a limit.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/limits/testing/requests_test.go b/openstack/compute/v2/limits/testing/requests_test.go
index ae9650097..d795ec958 100644
--- a/openstack/compute/v2/limits/testing/requests_test.go
+++ b/openstack/compute/v2/limits/testing/requests_test.go
@@ -10,15 +10,15 @@ import (
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
 	getOpts := limits.GetOpts{
 		TenantID: TenantID,
 	}
 
-	actual, err := limits.Get(context.TODO(), client.ServiceClient(), getOpts).Extract()
+	actual, err := limits.Get(context.TODO(), client.ServiceClient(fakeServer), getOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &LimitsResult, actual)
 }
diff --git a/openstack/compute/v2/quotasets/testing/fixtures_test.go b/openstack/compute/v2/quotasets/testing/fixtures_test.go
index 5d0ef2493..a9bac9f36 100644
--- a/openstack/compute/v2/quotasets/testing/fixtures_test.go
+++ b/openstack/compute/v2/quotasets/testing/fixtures_test.go
@@ -161,8 +161,8 @@ var UpdatedQuotaSet = quotasets.UpdateOpts{
 }
 
 // HandleGetSuccessfully configures the test server to respond to a Get request for sample tenant
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -172,8 +172,8 @@ func HandleGetSuccessfully(t *testing.T) {
 }
 
 // HandleGetDetailSuccessfully configures the test server to respond to a Get Details request for sample tenant
-func HandleGetDetailSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID+"/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetDetailSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID+"/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -182,8 +182,8 @@ func HandleGetDetailSuccessfully(t *testing.T) {
 }
 
 // HandlePutSuccessfully configures the test server to respond to a Put request for sample tenant
-func HandlePutSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
+func HandlePutSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateOutput)
@@ -193,8 +193,8 @@ func HandlePutSuccessfully(t *testing.T) {
 }
 
 // HandlePartialPutSuccessfully configures the test server to respond to a Put request for sample tenant that only containes specific values
-func HandlePartialPutSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
+func HandlePartialPutSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, PartialUpdateBody)
@@ -204,8 +204,8 @@ func HandlePartialPutSuccessfully(t *testing.T) {
 }
 
 // HandleDeleteSuccessfully configures the test server to respond to a Delete request for sample tenant
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-quota-sets/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestBody(t, r, "")
diff --git a/openstack/compute/v2/quotasets/testing/requests_test.go b/openstack/compute/v2/quotasets/testing/requests_test.go
index eac6e99d0..c46afd343 100644
--- a/openstack/compute/v2/quotasets/testing/requests_test.go
+++ b/openstack/compute/v2/quotasets/testing/requests_test.go
@@ -12,47 +12,47 @@ import (
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
-	actual, err := quotasets.Get(context.TODO(), client.ServiceClient(), FirstTenantID).Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
+	actual, err := quotasets.Get(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstQuotaSet, actual)
 }
 
 func TestGetDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetDetailSuccessfully(t)
-	actual, err := quotasets.GetDetail(context.TODO(), client.ServiceClient(), FirstTenantID).Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetDetailSuccessfully(t, fakeServer)
+	actual, err := quotasets.GetDetail(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).Extract()
 	th.CheckDeepEquals(t, FirstQuotaDetailsSet, actual)
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePutSuccessfully(t)
-	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, UpdatedQuotaSet).Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePutSuccessfully(t, fakeServer)
+	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, UpdatedQuotaSet).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstQuotaSet, actual)
 }
 
 func TestPartialUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePartialPutSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePartialPutSuccessfully(t, fakeServer)
 	opts := quotasets.UpdateOpts{Cores: gophercloud.IntToPointer(200), Force: true}
-	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, opts).Extract()
+	actual, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstQuotaSet, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
-	_, err := quotasets.Delete(context.TODO(), client.ServiceClient(), FirstTenantID).Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
+	_, err := quotasets.Delete(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID).Extract()
 	th.AssertNoErr(t, err)
 }
 
@@ -64,10 +64,10 @@ func (opts ErrorUpdateOpts) ToComputeQuotaUpdateMap() (map[string]any, error) {
 
 func TestErrorInToComputeQuotaUpdateMap(t *testing.T) {
 	opts := &ErrorUpdateOpts{}
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePutSuccessfully(t)
-	_, err := quotasets.Update(context.TODO(), client.ServiceClient(), FirstTenantID, opts).Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePutSuccessfully(t, fakeServer)
+	_, err := quotasets.Update(context.TODO(), client.ServiceClient(fakeServer), FirstTenantID, opts).Extract()
 	if err == nil {
 		t.Fatal("Error handling failed")
 	}
diff --git a/openstack/compute/v2/remoteconsoles/testing/requests_test.go b/openstack/compute/v2/remoteconsoles/testing/requests_test.go
index 3a49e4d46..0ae0f480d 100644
--- a/openstack/compute/v2/remoteconsoles/testing/requests_test.go
+++ b/openstack/compute/v2/remoteconsoles/testing/requests_test.go
@@ -8,16 +8,16 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/compute/v2/remoteconsoles"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/b16ba811-199d-4ffd-8839-ba96c1185a67/remote-consoles", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/b16ba811-199d-4ffd-8839-ba96c1185a67/remote-consoles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, RemoteConsoleCreateRequest)
@@ -32,7 +32,7 @@ func TestCreate(t *testing.T) {
 		Protocol: remoteconsoles.ConsoleProtocolVNC,
 		Type:     remoteconsoles.ConsoleTypeNoVNC,
 	}
-	s, err := remoteconsoles.Create(context.TODO(), fake.ServiceClient(), "b16ba811-199d-4ffd-8839-ba96c1185a67", opts).Extract()
+	s, err := remoteconsoles.Create(context.TODO(), client.ServiceClient(fakeServer), "b16ba811-199d-4ffd-8839-ba96c1185a67", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Protocol, string(remoteconsoles.ConsoleProtocolVNC))
diff --git a/openstack/compute/v2/secgroups/testing/fixtures_test.go b/openstack/compute/v2/secgroups/testing/fixtures_test.go
index df3614b66..cee5eb6d5 100644
--- a/openstack/compute/v2/secgroups/testing/fixtures_test.go
+++ b/openstack/compute/v2/secgroups/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const rootPath = "/os-security-groups"
@@ -25,10 +25,10 @@ const listGroupsJSON = `
 }
 `
 
-func mockListGroupsResponse(t *testing.T) {
-	th.Mux.HandleFunc(rootPath, func(w http.ResponseWriter, r *http.Request) {
+func mockListGroupsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(rootPath, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -37,11 +37,11 @@ func mockListGroupsResponse(t *testing.T) {
 	})
 }
 
-func mockListGroupsByServerResponse(t *testing.T, serverID string) {
+func mockListGroupsByServerResponse(t *testing.T, fakeServer th.FakeServer, serverID string) {
 	url := fmt.Sprintf("/servers/%s%s", serverID, rootPath)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -50,10 +50,10 @@ func mockListGroupsByServerResponse(t *testing.T, serverID string) {
 	})
 }
 
-func mockCreateGroupResponse(t *testing.T) {
-	th.Mux.HandleFunc(rootPath, func(w http.ResponseWriter, r *http.Request) {
+func mockCreateGroupResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(rootPath, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -81,11 +81,11 @@ func mockCreateGroupResponse(t *testing.T) {
 	})
 }
 
-func mockUpdateGroupResponse(t *testing.T, groupID string) {
+func mockUpdateGroupResponse(t *testing.T, fakeServer th.FakeServer, groupID string) {
 	url := fmt.Sprintf("%s/%s", rootPath, groupID)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -113,11 +113,11 @@ func mockUpdateGroupResponse(t *testing.T, groupID string) {
 	})
 }
 
-func mockGetGroupsResponse(t *testing.T, groupID string) {
+func mockGetGroupsResponse(t *testing.T, fakeServer th.FakeServer, groupID string) {
 	url := fmt.Sprintf("%s/%s", rootPath, groupID)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -151,11 +151,11 @@ func mockGetGroupsResponse(t *testing.T, groupID string) {
 	})
 }
 
-func mockGetNumericIDGroupResponse(t *testing.T, groupID int) {
+func mockGetNumericIDGroupResponse(t *testing.T, fakeServer th.FakeServer, groupID int) {
 	url := fmt.Sprintf("%s/%d", rootPath, groupID)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -170,11 +170,11 @@ func mockGetNumericIDGroupResponse(t *testing.T, groupID int) {
 	})
 }
 
-func mockGetNumericIDGroupRuleResponse(t *testing.T, groupID int) {
+func mockGetNumericIDGroupRuleResponse(t *testing.T, fakeServer th.FakeServer, groupID int) {
 	url := fmt.Sprintf("%s/%d", rootPath, groupID)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -195,20 +195,20 @@ func mockGetNumericIDGroupRuleResponse(t *testing.T, groupID int) {
 	})
 }
 
-func mockDeleteGroupResponse(t *testing.T, groupID string) {
+func mockDeleteGroupResponse(t *testing.T, fakeServer th.FakeServer, groupID string) {
 	url := fmt.Sprintf("%s/%s", rootPath, groupID)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func mockAddRuleResponse(t *testing.T) {
-	th.Mux.HandleFunc("/os-security-group-rules", func(w http.ResponseWriter, r *http.Request) {
+func mockAddRuleResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-security-group-rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -241,10 +241,10 @@ func mockAddRuleResponse(t *testing.T) {
 	})
 }
 
-func mockAddRuleResponseICMPZero(t *testing.T) {
-	th.Mux.HandleFunc("/os-security-group-rules", func(w http.ResponseWriter, r *http.Request) {
+func mockAddRuleResponseICMPZero(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-security-group-rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -277,21 +277,21 @@ func mockAddRuleResponseICMPZero(t *testing.T) {
 	})
 }
 
-func mockDeleteRuleResponse(t *testing.T, ruleID string) {
+func mockDeleteRuleResponse(t *testing.T, fakeServer th.FakeServer, ruleID string) {
 	url := fmt.Sprintf("/os-security-group-rules/%s", ruleID)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func mockAddServerToGroupResponse(t *testing.T, serverID string) {
+func mockAddServerToGroupResponse(t *testing.T, fakeServer th.FakeServer, serverID string) {
 	url := fmt.Sprintf("/servers/%s/action", serverID)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -306,11 +306,11 @@ func mockAddServerToGroupResponse(t *testing.T, serverID string) {
 	})
 }
 
-func mockRemoveServerFromGroupResponse(t *testing.T, serverID string) {
+func mockRemoveServerFromGroupResponse(t *testing.T, fakeServer th.FakeServer, serverID string) {
 	url := fmt.Sprintf("/servers/%s/action", serverID)
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
diff --git a/openstack/compute/v2/secgroups/testing/requests_test.go b/openstack/compute/v2/secgroups/testing/requests_test.go
index 53c473ce0..38d819d06 100644
--- a/openstack/compute/v2/secgroups/testing/requests_test.go
+++ b/openstack/compute/v2/secgroups/testing/requests_test.go
@@ -18,14 +18,14 @@ const (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockListGroupsResponse(t)
+	mockListGroupsResponse(t, fakeServer)
 
 	count := 0
 
-	err := secgroups.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := secgroups.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := secgroups.ExtractSecurityGroups(page)
 		if err != nil {
@@ -53,14 +53,14 @@ func TestList(t *testing.T) {
 }
 
 func TestListByServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockListGroupsByServerResponse(t, serverID)
+	mockListGroupsByServerResponse(t, fakeServer, serverID)
 
 	count := 0
 
-	err := secgroups.ListByServer(client.ServiceClient(), serverID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := secgroups.ListByServer(client.ServiceClient(fakeServer), serverID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := secgroups.ExtractSecurityGroups(page)
 		if err != nil {
@@ -88,17 +88,17 @@ func TestListByServer(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockCreateGroupResponse(t)
+	mockCreateGroupResponse(t, fakeServer)
 
 	opts := secgroups.CreateOpts{
 		Name:        "test",
 		Description: "something",
 	}
 
-	group, err := secgroups.Create(context.TODO(), client.ServiceClient(), opts).Extract()
+	group, err := secgroups.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &secgroups.SecurityGroup{
@@ -112,17 +112,17 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockUpdateGroupResponse(t, groupID)
+	mockUpdateGroupResponse(t, fakeServer, groupID)
 
 	opts := secgroups.UpdateOpts{
 		Name:        ptr.To("new_name"),
 		Description: ptr.To("new_desc"),
 	}
 
-	group, err := secgroups.Update(context.TODO(), client.ServiceClient(), groupID, opts).Extract()
+	group, err := secgroups.Update(context.TODO(), client.ServiceClient(fakeServer), groupID, opts).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &secgroups.SecurityGroup{
@@ -136,12 +136,12 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockGetGroupsResponse(t, groupID)
+	mockGetGroupsResponse(t, fakeServer, groupID)
 
-	group, err := secgroups.Get(context.TODO(), client.ServiceClient(), groupID).Extract()
+	group, err := secgroups.Get(context.TODO(), client.ServiceClient(fakeServer), groupID).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &secgroups.SecurityGroup{
@@ -166,14 +166,14 @@ func TestGet(t *testing.T) {
 }
 
 func TestGetNumericID(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	numericGroupID := 12345
 
-	mockGetNumericIDGroupResponse(t, numericGroupID)
+	mockGetNumericIDGroupResponse(t, fakeServer, numericGroupID)
 
-	group, err := secgroups.Get(context.TODO(), client.ServiceClient(), "12345").Extract()
+	group, err := secgroups.Get(context.TODO(), client.ServiceClient(fakeServer), "12345").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &secgroups.SecurityGroup{ID: "12345"}
@@ -181,14 +181,14 @@ func TestGetNumericID(t *testing.T) {
 }
 
 func TestGetNumericRuleID(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	numericGroupID := 12345
 
-	mockGetNumericIDGroupRuleResponse(t, numericGroupID)
+	mockGetNumericIDGroupRuleResponse(t, fakeServer, numericGroupID)
 
-	group, err := secgroups.Get(context.TODO(), client.ServiceClient(), "12345").Extract()
+	group, err := secgroups.Get(context.TODO(), client.ServiceClient(fakeServer), "12345").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &secgroups.SecurityGroup{
@@ -204,20 +204,20 @@ func TestGetNumericRuleID(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockDeleteGroupResponse(t, groupID)
+	mockDeleteGroupResponse(t, fakeServer, groupID)
 
-	err := secgroups.Delete(context.TODO(), client.ServiceClient(), groupID).ExtractErr()
+	err := secgroups.Delete(context.TODO(), client.ServiceClient(fakeServer), groupID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestAddRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockAddRuleResponse(t)
+	mockAddRuleResponse(t, fakeServer)
 
 	opts := secgroups.CreateRuleOpts{
 		ParentGroupID: groupID,
@@ -227,7 +227,7 @@ func TestAddRule(t *testing.T) {
 		CIDR:          "0.0.0.0/0",
 	}
 
-	rule, err := secgroups.CreateRule(context.TODO(), client.ServiceClient(), opts).Extract()
+	rule, err := secgroups.CreateRule(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &secgroups.Rule{
@@ -244,10 +244,10 @@ func TestAddRule(t *testing.T) {
 }
 
 func TestAddRuleICMPZero(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockAddRuleResponseICMPZero(t)
+	mockAddRuleResponseICMPZero(t, fakeServer)
 
 	opts := secgroups.CreateRuleOpts{
 		ParentGroupID: groupID,
@@ -257,7 +257,7 @@ func TestAddRuleICMPZero(t *testing.T) {
 		CIDR:          "0.0.0.0/0",
 	}
 
-	rule, err := secgroups.CreateRule(context.TODO(), client.ServiceClient(), opts).Extract()
+	rule, err := secgroups.CreateRule(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &secgroups.Rule{
@@ -274,31 +274,31 @@ func TestAddRuleICMPZero(t *testing.T) {
 }
 
 func TestDeleteRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockDeleteRuleResponse(t, ruleID)
+	mockDeleteRuleResponse(t, fakeServer, ruleID)
 
-	err := secgroups.DeleteRule(context.TODO(), client.ServiceClient(), ruleID).ExtractErr()
+	err := secgroups.DeleteRule(context.TODO(), client.ServiceClient(fakeServer), ruleID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestAddServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockAddServerToGroupResponse(t, serverID)
+	mockAddServerToGroupResponse(t, fakeServer, serverID)
 
-	err := secgroups.AddServer(context.TODO(), client.ServiceClient(), serverID, "test").ExtractErr()
+	err := secgroups.AddServer(context.TODO(), client.ServiceClient(fakeServer), serverID, "test").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestRemoveServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockRemoveServerFromGroupResponse(t, serverID)
+	mockRemoveServerFromGroupResponse(t, fakeServer, serverID)
 
-	err := secgroups.RemoveServer(context.TODO(), client.ServiceClient(), serverID, "test").ExtractErr()
+	err := secgroups.RemoveServer(context.TODO(), client.ServiceClient(fakeServer), serverID, "test").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/compute/v2/servergroups/testing/fixtures_test.go b/openstack/compute/v2/servergroups/testing/fixtures_test.go
index 2ad519023..f9ce09be2 100644
--- a/openstack/compute/v2/servergroups/testing/fixtures_test.go
+++ b/openstack/compute/v2/servergroups/testing/fixtures_test.go
@@ -57,9 +57,6 @@ const GetOutputMicroversion = `
     "server_group": {
         "id": "616fb98f-46ca-475e-917e-2563e5a8cd19",
         "name": "test",
-        "policies": [
-            "anti-affinity"
-        ],
         "policy": "anti-affinity",
         "rules": {
           "max_server_per_host": 3
@@ -91,9 +88,6 @@ const CreateOutputMicroversion = `
     "server_group": {
         "id": "616fb98f-46ca-475e-917e-2563e5a8cd19",
         "name": "test",
-        "policies": [
-            "anti-affinity"
-        ],
         "policy": "anti-affinity",
         "rules": {
           "max_server_per_host": 3
@@ -104,8 +98,10 @@ const CreateOutputMicroversion = `
 }
 `
 
-// FirstServerGroup is the first result in ListOutput.
-var FirstServerGroup = servergroups.ServerGroup{
+var policy = "anti-affinity"
+
+// ExpectedServerGroupGet is parsed result from GetOutput.
+var ExpectedServerGroupGet = servergroups.ServerGroup{
 	ID:   "616fb98f-46ca-475e-917e-2563e5a8cd19",
 	Name: "test",
 	Policies: []string{
@@ -115,23 +111,43 @@ var FirstServerGroup = servergroups.ServerGroup{
 	Metadata: map[string]any{},
 }
 
-// SecondServerGroup is the second result in ListOutput.
-var SecondServerGroup = servergroups.ServerGroup{
-	ID:   "4d8c3732-a248-40ed-bebc-539a6ffd25c0",
-	Name: "test2",
-	Policies: []string{
-		"affinity",
+// ExpectedServerGroupGet is parsed result from GetOutputMicroversion.
+var ExpectedServerGroupGetMicroversion = servergroups.ServerGroup{
+	ID:     "616fb98f-46ca-475e-917e-2563e5a8cd19",
+	Name:   "test",
+	Policy: &policy,
+	Rules: &servergroups.Rules{
+		MaxServerPerHost: 3,
 	},
 	Members:  []string{},
 	Metadata: map[string]any{},
 }
 
-// ExpectedServerGroupSlice is the slice of results that should be parsed
+// ExpectedServerGroupList is the slice of results that should be parsed
 // from ListOutput, in the expected order.
-var ExpectedServerGroupSlice = []servergroups.ServerGroup{FirstServerGroup, SecondServerGroup}
+var ExpectedServerGroupList = []servergroups.ServerGroup{
+	{
+		ID:   "616fb98f-46ca-475e-917e-2563e5a8cd19",
+		Name: "test",
+		Policies: []string{
+			"anti-affinity",
+		},
+		Members:  []string{},
+		Metadata: map[string]any{},
+	},
+	{
+		ID:   "4d8c3732-a248-40ed-bebc-539a6ffd25c0",
+		Name: "test2",
+		Policies: []string{
+			"affinity",
+		},
+		Members:  []string{},
+		Metadata: map[string]any{},
+	},
+}
 
-// CreatedServerGroup is the parsed result from CreateOutput.
-var CreatedServerGroup = servergroups.ServerGroup{
+// ExpectedServerGroupCreate is the parsed result from CreateOutput.
+var ExpectedServerGroupCreate = servergroups.ServerGroup{
 	ID:   "616fb98f-46ca-475e-917e-2563e5a8cd19",
 	Name: "test",
 	Policies: []string{
@@ -141,9 +157,21 @@ var CreatedServerGroup = servergroups.ServerGroup{
 	Metadata: map[string]any{},
 }
 
+// CreatedServerGroup is the parsed result from CreateOutputMicroversion.
+var ExpectedServerGroupCreateMicroversion = servergroups.ServerGroup{
+	ID:     "616fb98f-46ca-475e-917e-2563e5a8cd19",
+	Name:   "test",
+	Policy: &policy,
+	Rules: &servergroups.Rules{
+		MaxServerPerHost: 3,
+	},
+	Members:  []string{},
+	Metadata: map[string]any{},
+}
+
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-server-groups", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-server-groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -154,8 +182,8 @@ func HandleListSuccessfully(t *testing.T) {
 
 // HandleGetSuccessfully configures the test server to respond to a Get request
 // for an existing server group
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-server-groups/4d8c3732-a248-40ed-bebc-539a6ffd25c0", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-server-groups/4d8c3732-a248-40ed-bebc-539a6ffd25c0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -166,8 +194,8 @@ func HandleGetSuccessfully(t *testing.T) {
 
 // HandleGetMicroversionSuccessfully configures the test server to respond to a Get request
 // for an existing server group with microversion set to 2.64
-func HandleGetMicroversionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-server-groups/4d8c3732-a248-40ed-bebc-539a6ffd25c0", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetMicroversionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-server-groups/4d8c3732-a248-40ed-bebc-539a6ffd25c0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -178,8 +206,8 @@ func HandleGetMicroversionSuccessfully(t *testing.T) {
 
 // HandleCreateSuccessfully configures the test server to respond to a Create request
 // for a new server group
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-server-groups", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-server-groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `
@@ -200,17 +228,14 @@ func HandleCreateSuccessfully(t *testing.T) {
 
 // HandleCreateMicroversionSuccessfully configures the test server to respond to a Create request
 // for a new server group with microversion set to 2.64
-func HandleCreateMicroversionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-server-groups", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateMicroversionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-server-groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `
 {
     "server_group": {
         "name": "test",
-        "policies": [
-            "anti-affinity"
-        ],
         "policy": "anti-affinity",
         "rules": {
             "max_server_per_host": 3
@@ -226,8 +251,8 @@ func HandleCreateMicroversionSuccessfully(t *testing.T) {
 
 // HandleDeleteSuccessfully configures the test server to respond to a Delete request for a
 // an existing server group
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-server-groups/616fb98f-46ca-475e-917e-2563e5a8cd19", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-server-groups/616fb98f-46ca-475e-917e-2563e5a8cd19", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/servergroups/testing/requests_test.go b/openstack/compute/v2/servergroups/testing/requests_test.go
index 91a9b7516..770d3f726 100644
--- a/openstack/compute/v2/servergroups/testing/requests_test.go
+++ b/openstack/compute/v2/servergroups/testing/requests_test.go
@@ -11,16 +11,16 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	count := 0
-	err := servergroups.List(client.ServiceClient(), &servergroups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := servergroups.List(client.ServiceClient(fakeServer), &servergroups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := servergroups.ExtractServerGroups(page)
 		th.AssertNoErr(t, err)
-		th.CheckDeepEquals(t, ExpectedServerGroupSlice, actual)
+		th.CheckDeepEquals(t, ExpectedServerGroupList, actual)
 
 		return true, nil
 	})
@@ -29,77 +29,59 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
-	actual, err := servergroups.Create(context.TODO(), client.ServiceClient(), servergroups.CreateOpts{
+	actual, err := servergroups.Create(context.TODO(), client.ServiceClient(fakeServer), servergroups.CreateOpts{
 		Name:     "test",
 		Policies: []string{"anti-affinity"},
 	}).Extract()
 	th.AssertNoErr(t, err)
-	th.CheckDeepEquals(t, &CreatedServerGroup, actual)
+	th.CheckDeepEquals(t, &ExpectedServerGroupCreate, actual)
 }
 
 func TestCreateMicroversion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateMicroversionSuccessfully(t)
-
-	policy := "anti-affinity"
-	rules := servergroups.Rules{
-		MaxServerPerHost: 3,
-	}
-	CreatedServerGroup.Policy = &policy
-	CreatedServerGroup.Rules = &rules
-
-	result := servergroups.Create(context.TODO(), client.ServiceClient(), servergroups.CreateOpts{
-		Name:     "test",
-		Policies: []string{"anti-affinity"},
-		Policy:   policy,
-		Rules:    &rules,
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateMicroversionSuccessfully(t, fakeServer)
+
+	result := servergroups.Create(context.TODO(), client.ServiceClient(fakeServer), servergroups.CreateOpts{
+		Name:   "test",
+		Policy: policy,
+		Rules:  ExpectedServerGroupCreateMicroversion.Rules,
 	})
 
 	actual, err := result.Extract()
 	th.AssertNoErr(t, err)
-	th.CheckDeepEquals(t, &CreatedServerGroup, actual)
+	th.CheckDeepEquals(t, &ExpectedServerGroupCreateMicroversion, actual)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := servergroups.Get(context.TODO(), client.ServiceClient(), "4d8c3732-a248-40ed-bebc-539a6ffd25c0").Extract()
+	actual, err := servergroups.Get(context.TODO(), client.ServiceClient(fakeServer), "4d8c3732-a248-40ed-bebc-539a6ffd25c0").Extract()
 	th.AssertNoErr(t, err)
-	th.CheckDeepEquals(t, &FirstServerGroup, actual)
+	th.CheckDeepEquals(t, &ExpectedServerGroupGet, actual)
 }
 
 func TestGetMicroversion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetMicroversionSuccessfully(t)
-
-	policy := "anti-affinity"
-	rules := servergroups.Rules{
-		MaxServerPerHost: 3,
-	}
-	FirstServerGroup.Policy = &policy
-	FirstServerGroup.Rules = &rules
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetMicroversionSuccessfully(t, fakeServer)
 
-	result := servergroups.Get(context.TODO(), client.ServiceClient(), "4d8c3732-a248-40ed-bebc-539a6ffd25c0")
-
-	// Extract basic fields.
-	actual, err := result.Extract()
+	actual, err := servergroups.Get(context.TODO(), client.ServiceClient(fakeServer), "4d8c3732-a248-40ed-bebc-539a6ffd25c0").Extract()
 	th.AssertNoErr(t, err)
-	th.CheckDeepEquals(t, &FirstServerGroup, actual)
+	th.CheckDeepEquals(t, &ExpectedServerGroupGetMicroversion, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	err := servergroups.Delete(context.TODO(), client.ServiceClient(), "616fb98f-46ca-475e-917e-2563e5a8cd19").ExtractErr()
+	err := servergroups.Delete(context.TODO(), client.ServiceClient(fakeServer), "616fb98f-46ca-475e-917e-2563e5a8cd19").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/compute/v2/servers/testing/fixtures_test.go b/openstack/compute/v2/servers/testing/fixtures_test.go
index a9c3980d8..7d7239d2f 100644
--- a/openstack/compute/v2/servers/testing/fixtures_test.go
+++ b/openstack/compute/v2/servers/testing/fixtures_test.go
@@ -729,8 +729,8 @@ func (opts CreateOptsWithCustomField) ToServerCreateMap() (map[string]any, error
 
 // HandleServerNoNetworkCreationSuccessfully sets up the test server with no
 // network to respond to a server creation request with a given response.
-func HandleServerNoNetworkCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerNoNetworkCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -750,8 +750,8 @@ func HandleServerNoNetworkCreationSuccessfully(t *testing.T, response string) {
 
 // HandleServerCreationSuccessfully sets up the test server to respond to a server creation request
 // with a given response.
-func HandleServerCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -767,7 +767,7 @@ func HandleServerCreationSuccessfully(t *testing.T, response string) {
 		fmt.Fprint(w, response)
 	})
 
-	th.Mux.HandleFunc("/images/detail", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/images/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -813,7 +813,7 @@ func HandleServerCreationSuccessfully(t *testing.T, response string) {
 		}
 	})
 
-	th.Mux.HandleFunc("/flavors/detail", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/flavors/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -851,7 +851,7 @@ func HandleServerCreationSuccessfully(t *testing.T, response string) {
 								}
 							]
 						}
-					`, th.Server.URL)
+					`, fakeServer.Server.URL)
 		case "2":
 			fmt.Fprint(w, `{ "flavors": [] }`)
 		default:
@@ -862,8 +862,8 @@ func HandleServerCreationSuccessfully(t *testing.T, response string) {
 
 // HandleServerCreationWithCustomFieldSuccessfully sets up the test server to respond to a server creation request
 // with a given response.
-func HandleServersCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServersCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -884,8 +884,8 @@ func HandleServersCreationSuccessfully(t *testing.T, response string) {
 
 // HandleServerCreationWithCustomFieldSuccessfully sets up the test server to respond to a server creation request
 // with a given response.
-func HandleServerCreationWithCustomFieldSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerCreationWithCustomFieldSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -903,8 +903,8 @@ func HandleServerCreationWithCustomFieldSuccessfully(t *testing.T, response stri
 	})
 }
 
-func HandleServerCreationWithHostname(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerCreationWithHostname(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -924,8 +924,8 @@ func HandleServerCreationWithHostname(t *testing.T, response string) {
 
 // HandleServerCreationWithUserdata sets up the test server to respond to a server creation request
 // with a given response.
-func HandleServerCreationWithUserdata(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerCreationWithUserdata(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -945,8 +945,8 @@ func HandleServerCreationWithUserdata(t *testing.T, response string) {
 
 // HandleServerCreationWithMetadata sets up the test server to respond to a server creation request
 // with a given response.
-func HandleServerCreationWithMetadata(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerCreationWithMetadata(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -967,8 +967,8 @@ func HandleServerCreationWithMetadata(t *testing.T, response string) {
 }
 
 // HandleServerListSimpleSuccessfully sets up the test server to respond to a server List request.
-func HandleServerListSimpleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerListSimpleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -989,8 +989,8 @@ func HandleServerListSimpleSuccessfully(t *testing.T) {
 }
 
 // HandleServerListSuccessfully sets up the test server to respond to a server detail List request.
-func HandleServerListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -1011,8 +1011,8 @@ func HandleServerListSuccessfully(t *testing.T) {
 }
 
 // HandleServerDeletionSuccessfully sets up the test server to respond to a server deletion request.
-func HandleServerDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/asdfasdfasdf", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/asdfasdfasdf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -1022,8 +1022,8 @@ func HandleServerDeletionSuccessfully(t *testing.T) {
 
 // HandleServerForceDeletionSuccessfully sets up the test server to respond to a server force deletion
 // request.
-func HandleServerForceDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/asdfasdfasdf/action", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerForceDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/asdfasdfasdf/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "forceDelete": "" }`)
@@ -1033,8 +1033,8 @@ func HandleServerForceDeletionSuccessfully(t *testing.T) {
 }
 
 // HandleServerGetSuccessfully sets up the test server to respond to a server Get request.
-func HandleServerGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1045,8 +1045,8 @@ func HandleServerGetSuccessfully(t *testing.T) {
 
 // HandleServerGetFaultSuccessfully sets up the test server to respond to a server Get
 // request which contains a fault.
-func HandleServerGetFaultSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerGetFaultSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1056,8 +1056,8 @@ func HandleServerGetFaultSuccessfully(t *testing.T) {
 }
 
 // HandleServerUpdateSuccessfully sets up the test server to respond to a server Update request.
-func HandleServerUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1070,8 +1070,8 @@ func HandleServerUpdateSuccessfully(t *testing.T) {
 
 // HandleAdminPasswordChangeSuccessfully sets up the test server to respond to a server password
 // change request.
-func HandleAdminPasswordChangeSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
+func HandleAdminPasswordChangeSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "changePassword": { "adminPass": "new-password" } }`)
@@ -1081,8 +1081,8 @@ func HandleAdminPasswordChangeSuccessfully(t *testing.T) {
 }
 
 // HandleRebootSuccessfully sets up the test server to respond to a reboot request with success.
-func HandleRebootSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
+func HandleRebootSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "reboot": { "type": "SOFT" } }`)
@@ -1092,8 +1092,8 @@ func HandleRebootSuccessfully(t *testing.T) {
 }
 
 // HandleShowConsoleOutputSuccessfully sets up the test server to respond to a os-getConsoleOutput request with success.
-func HandleShowConsoleOutputSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
+func HandleShowConsoleOutputSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "os-getConsoleOutput": { "length": 50 } }`)
@@ -1105,8 +1105,8 @@ func HandleShowConsoleOutputSuccessfully(t *testing.T, response string) {
 }
 
 // HandleRebuildSuccessfully sets up the test server to respond to a rebuild request with success.
-func HandleRebuildSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
+func HandleRebuildSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `
@@ -1127,8 +1127,8 @@ func HandleRebuildSuccessfully(t *testing.T, response string) {
 }
 
 // HandleMetadatumGetSuccessfully sets up the test server to respond to a metadatum Get request.
-func HandleMetadatumGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
+func HandleMetadatumGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1141,8 +1141,8 @@ func HandleMetadatumGetSuccessfully(t *testing.T) {
 }
 
 // HandleMetadatumCreateSuccessfully sets up the test server to respond to a metadatum Create request.
-func HandleMetadatumCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
+func HandleMetadatumCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -1159,8 +1159,8 @@ func HandleMetadatumCreateSuccessfully(t *testing.T) {
 }
 
 // HandleMetadatumDeleteSuccessfully sets up the test server to respond to a metadatum Delete request.
-func HandleMetadatumDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
+func HandleMetadatumDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -1169,8 +1169,8 @@ func HandleMetadatumDeleteSuccessfully(t *testing.T) {
 }
 
 // HandleMetadataGetSuccessfully sets up the test server to respond to a metadata Get request.
-func HandleMetadataGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/metadata", func(w http.ResponseWriter, r *http.Request) {
+func HandleMetadataGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1182,8 +1182,8 @@ func HandleMetadataGetSuccessfully(t *testing.T) {
 }
 
 // HandleMetadataResetSuccessfully sets up the test server to respond to a metadata Create request.
-func HandleMetadataResetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/metadata", func(w http.ResponseWriter, r *http.Request) {
+func HandleMetadataResetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -1201,8 +1201,8 @@ func HandleMetadataResetSuccessfully(t *testing.T) {
 }
 
 // HandleMetadataUpdateSuccessfully sets up the test server to respond to a metadata Update request.
-func HandleMetadataUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/metadata", func(w http.ResponseWriter, r *http.Request) {
+func HandleMetadataUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -1240,8 +1240,8 @@ var ListAddressesExpected = map[string][]servers.Address{
 }
 
 // HandleAddressListSuccessfully sets up the test server to respond to a ListAddresses request.
-func HandleAddressListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/asdfasdfasdf/ips", func(w http.ResponseWriter, r *http.Request) {
+func HandleAddressListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/asdfasdfasdf/ips", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -1282,8 +1282,8 @@ var ListNetworkAddressesExpected = []servers.Address{
 }
 
 // HandleNetworkAddressListSuccessfully sets up the test server to respond to a ListAddressesByNetwork request.
-func HandleNetworkAddressListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/asdfasdfasdf/ips/public", func(w http.ResponseWriter, r *http.Request) {
+func HandleNetworkAddressListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/asdfasdfasdf/ips/public", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -1304,8 +1304,8 @@ func HandleNetworkAddressListSuccessfully(t *testing.T) {
 }
 
 // HandleCreateServerImageSuccessfully sets up the test server to respond to a TestCreateServerImage request.
-func HandleCreateServerImageSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/serverimage/action", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateServerImageSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/serverimage/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Location", "https://0.0.0.0/images/xxxx-xxxxx-xxxxx-xxxx")
@@ -1314,8 +1314,8 @@ func HandleCreateServerImageSuccessfully(t *testing.T) {
 }
 
 // HandlePasswordGetSuccessfully sets up the test server to respond to a password Get request.
-func HandlePasswordGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/1234asdf/os-server-password", func(w http.ResponseWriter, r *http.Request) {
+func HandlePasswordGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/os-server-password", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -1326,8 +1326,8 @@ func HandlePasswordGetSuccessfully(t *testing.T) {
 
 // HandleServerWithTagsCreationSuccessfully sets up the test server to respond
 // to a server creation request with a given response.
-func HandleServerWithTagsCreationSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
+func HandleServerWithTagsCreationSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, ServerWithTagsCreateRequest)
diff --git a/openstack/compute/v2/servers/testing/requests_test.go b/openstack/compute/v2/servers/testing/requests_test.go
index 831ddb2ec..16a16530f 100644
--- a/openstack/compute/v2/servers/testing/requests_test.go
+++ b/openstack/compute/v2/servers/testing/requests_test.go
@@ -15,12 +15,12 @@ import (
 )
 
 func TestListServers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := servers.List(client.ServiceClient(), servers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := servers.List(client.ServiceClient(fakeServer), servers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := servers.ExtractServers(page)
@@ -46,11 +46,11 @@ func TestListServers(t *testing.T) {
 }
 
 func TestListAllServers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerListSimpleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerListSimpleSuccessfully(t, fakeServer)
 
-	allPages, err := servers.ListSimple(client.ServiceClient(), servers.ListOpts{}).AllPages(context.TODO())
+	allPages, err := servers.ListSimple(client.ServiceClient(fakeServer), servers.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := servers.ExtractServers(allPages)
 	th.AssertNoErr(t, err)
@@ -59,11 +59,11 @@ func TestListAllServers(t *testing.T) {
 }
 
 func TestListAllServersWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerListSuccessfully(t, fakeServer)
 
-	allPages, err := servers.List(client.ServiceClient(), servers.ListOpts{}).AllPages(context.TODO())
+	allPages, err := servers.List(client.ServiceClient(fakeServer), servers.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	var actual []servers.Server
@@ -78,11 +78,11 @@ func TestListAllServersWithExtensions(t *testing.T) {
 }
 
 func TestCreateServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerCreationSuccessfully(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerCreationSuccessfully(t, fakeServer, SingleServerBody)
 
-	actual, err := servers.Create(context.TODO(), client.ServiceClient(), servers.CreateOpts{
+	actual, err := servers.Create(context.TODO(), client.ServiceClient(fakeServer), servers.CreateOpts{
 		Name:      "derp",
 		ImageRef:  "f90f6034-2570-4974-8351-6b49732ef2eb",
 		FlavorRef: "1",
@@ -93,11 +93,11 @@ func TestCreateServer(t *testing.T) {
 }
 
 func TestCreateServerNoNetwork(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerNoNetworkCreationSuccessfully(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerNoNetworkCreationSuccessfully(t, fakeServer, SingleServerBody)
 
-	actual, err := servers.Create(context.TODO(), client.ServiceClient(), servers.CreateOpts{
+	actual, err := servers.Create(context.TODO(), client.ServiceClient(fakeServer), servers.CreateOpts{
 		Name:      "derp",
 		ImageRef:  "f90f6034-2570-4974-8351-6b49732ef2eb",
 		FlavorRef: "1",
@@ -109,11 +109,11 @@ func TestCreateServerNoNetwork(t *testing.T) {
 }
 
 func TestCreateServers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServersCreationSuccessfully(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServersCreationSuccessfully(t, fakeServer, SingleServerBody)
 
-	actual, err := servers.Create(context.TODO(), client.ServiceClient(), servers.CreateOpts{
+	actual, err := servers.Create(context.TODO(), client.ServiceClient(fakeServer), servers.CreateOpts{
 		Name:      "derp",
 		ImageRef:  "f90f6034-2570-4974-8351-6b49732ef2eb",
 		FlavorRef: "1",
@@ -126,11 +126,11 @@ func TestCreateServers(t *testing.T) {
 }
 
 func TestCreateServerWithCustomField(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerCreationWithCustomFieldSuccessfully(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerCreationWithCustomFieldSuccessfully(t, fakeServer, SingleServerBody)
 
-	actual, err := servers.Create(context.TODO(), client.ServiceClient(), CreateOptsWithCustomField{
+	actual, err := servers.Create(context.TODO(), client.ServiceClient(fakeServer), CreateOptsWithCustomField{
 		CreateOpts: servers.CreateOpts{
 			Name:      "derp",
 			ImageRef:  "f90f6034-2570-4974-8351-6b49732ef2eb",
@@ -144,11 +144,11 @@ func TestCreateServerWithCustomField(t *testing.T) {
 }
 
 func TestCreateServerWithMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerCreationWithMetadata(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerCreationWithMetadata(t, fakeServer, SingleServerBody)
 
-	actual, err := servers.Create(context.TODO(), client.ServiceClient(), servers.CreateOpts{
+	actual, err := servers.Create(context.TODO(), client.ServiceClient(fakeServer), servers.CreateOpts{
 		Name:      "derp",
 		ImageRef:  "f90f6034-2570-4974-8351-6b49732ef2eb",
 		FlavorRef: "1",
@@ -162,11 +162,11 @@ func TestCreateServerWithMetadata(t *testing.T) {
 }
 
 func TestCreateServerWithUserdataString(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerCreationWithUserdata(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerCreationWithUserdata(t, fakeServer, SingleServerBody)
 
-	actual, err := servers.Create(context.TODO(), client.ServiceClient(), servers.CreateOpts{
+	actual, err := servers.Create(context.TODO(), client.ServiceClient(fakeServer), servers.CreateOpts{
 		Name:      "derp",
 		ImageRef:  "f90f6034-2570-4974-8351-6b49732ef2eb",
 		FlavorRef: "1",
@@ -178,13 +178,13 @@ func TestCreateServerWithUserdataString(t *testing.T) {
 }
 
 func TestCreateServerWithUserdataEncoded(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerCreationWithUserdata(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerCreationWithUserdata(t, fakeServer, SingleServerBody)
 
 	encoded := base64.StdEncoding.EncodeToString([]byte("userdata string"))
 
-	actual, err := servers.Create(context.TODO(), client.ServiceClient(), servers.CreateOpts{
+	actual, err := servers.Create(context.TODO(), client.ServiceClient(fakeServer), servers.CreateOpts{
 		Name:      "derp",
 		ImageRef:  "f90f6034-2570-4974-8351-6b49732ef2eb",
 		FlavorRef: "1",
@@ -196,11 +196,11 @@ func TestCreateServerWithUserdataEncoded(t *testing.T) {
 }
 
 func TestCreateServerWithHostname(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerCreationWithHostname(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerCreationWithHostname(t, fakeServer, SingleServerBody)
 
-	actual, err := servers.Create(context.TODO(), client.ServiceClient(), servers.CreateOpts{
+	actual, err := servers.Create(context.TODO(), client.ServiceClient(fakeServer), servers.CreateOpts{
 		Name:      "derp",
 		ImageRef:  "f90f6034-2570-4974-8351-6b49732ef2eb",
 		FlavorRef: "1",
@@ -731,29 +731,29 @@ func TestCreateComplexSchedulerHints(t *testing.T) {
 }
 
 func TestDeleteServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerDeletionSuccessfully(t, fakeServer)
 
-	res := servers.Delete(context.TODO(), client.ServiceClient(), "asdfasdfasdf")
+	res := servers.Delete(context.TODO(), client.ServiceClient(fakeServer), "asdfasdfasdf")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestForceDeleteServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerForceDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerForceDeletionSuccessfully(t, fakeServer)
 
-	res := servers.ForceDelete(context.TODO(), client.ServiceClient(), "asdfasdfasdf")
+	res := servers.ForceDelete(context.TODO(), client.ServiceClient(fakeServer), "asdfasdfasdf")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerGetSuccessfully(t, fakeServer)
 
-	client := client.ServiceClient()
+	client := client.ServiceClient(fakeServer)
 	actual, err := servers.Get(context.TODO(), client, "1234asdf").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -763,11 +763,11 @@ func TestGetServer(t *testing.T) {
 }
 
 func TestGetFaultyServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerGetFaultSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerGetFaultSuccessfully(t, fakeServer)
 
-	client := client.ServiceClient()
+	client := client.ServiceClient(fakeServer)
 	actual, err := servers.Get(context.TODO(), client, "1234asdf").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -780,15 +780,15 @@ func TestGetFaultyServer(t *testing.T) {
 }
 
 func TestGetServerWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerGetSuccessfully(t, fakeServer)
 
 	var s struct {
 		servers.Server
 	}
 
-	client := client.ServiceClient()
+	client := client.ServiceClient(fakeServer)
 	err := servers.Get(context.TODO(), client, "1234asdf").ExtractInto(&s)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, "nova", s.AvailabilityZone)
@@ -804,11 +804,11 @@ func TestGetServerWithExtensions(t *testing.T) {
 }
 
 func TestUpdateServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerUpdateSuccessfully(t, fakeServer)
 
-	client := client.ServiceClient()
+	client := client.ServiceClient(fakeServer)
 	actual, err := servers.Update(context.TODO(), client, "1234asdf", servers.UpdateOpts{Name: ptr.To("new-name")}).Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Update error: %v", err)
@@ -818,52 +818,52 @@ func TestUpdateServer(t *testing.T) {
 }
 
 func TestChangeServerAdminPassword(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAdminPasswordChangeSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAdminPasswordChangeSuccessfully(t, fakeServer)
 
-	res := servers.ChangeAdminPassword(context.TODO(), client.ServiceClient(), "1234asdf", "new-password")
+	res := servers.ChangeAdminPassword(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", "new-password")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestShowConsoleOutput(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleShowConsoleOutputSuccessfully(t, ConsoleOutputBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleShowConsoleOutputSuccessfully(t, fakeServer, ConsoleOutputBody)
 
 	outputOpts := &servers.ShowConsoleOutputOpts{
 		Length: 50,
 	}
-	actual, err := servers.ShowConsoleOutput(context.TODO(), client.ServiceClient(), "1234asdf", outputOpts).Extract()
+	actual, err := servers.ShowConsoleOutput(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", outputOpts).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertByteArrayEquals(t, []byte(ConsoleOutput), []byte(actual))
 }
 
 func TestGetPassword(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePasswordGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePasswordGetSuccessfully(t, fakeServer)
 
-	res := servers.GetPassword(context.TODO(), client.ServiceClient(), "1234asdf")
+	res := servers.GetPassword(context.TODO(), client.ServiceClient(fakeServer), "1234asdf")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestRebootServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRebootSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRebootSuccessfully(t, fakeServer)
 
-	res := servers.Reboot(context.TODO(), client.ServiceClient(), "1234asdf", servers.RebootOpts{
+	res := servers.Reboot(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", servers.RebootOpts{
 		Type: servers.SoftReboot,
 	})
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestRebuildServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRebuildSuccessfully(t, SingleServerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRebuildSuccessfully(t, fakeServer, SingleServerBody)
 
 	opts := servers.RebuildOpts{
 		Name:       "new-name",
@@ -872,7 +872,7 @@ func TestRebuildServer(t *testing.T) {
 		AccessIPv4: "1.2.3.4",
 	}
 
-	actual, err := servers.Rebuild(context.TODO(), client.ServiceClient(), "1234asdf", opts).Extract()
+	actual, err := servers.Rebuild(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.CheckDeepEquals(t, ServerDerp, *actual)
@@ -902,10 +902,10 @@ func TestRebuildServerWithDiskConfig(t *testing.T) {
 }
 
 func TestResizeServer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "resize": { "flavorRef": "2" } }`)
@@ -913,7 +913,7 @@ func TestResizeServer(t *testing.T) {
 		w.WriteHeader(http.StatusAccepted)
 	})
 
-	res := servers.Resize(context.TODO(), client.ServiceClient(), "1234asdf", servers.ResizeOpts{FlavorRef: "2"})
+	res := servers.Resize(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", servers.ResizeOpts{FlavorRef: "2"})
 	th.AssertNoErr(t, res.Err)
 }
 
@@ -937,10 +937,10 @@ func TestResizeServerWithDiskConfig(t *testing.T) {
 }
 
 func TestConfirmResize(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "confirmResize": null }`)
@@ -948,15 +948,15 @@ func TestConfirmResize(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := servers.ConfirmResize(context.TODO(), client.ServiceClient(), "1234asdf")
+	res := servers.ConfirmResize(context.TODO(), client.ServiceClient(fakeServer), "1234asdf")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestRevertResize(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/1234asdf/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{ "revertResize": null }`)
@@ -964,64 +964,64 @@ func TestRevertResize(t *testing.T) {
 		w.WriteHeader(http.StatusAccepted)
 	})
 
-	res := servers.RevertResize(context.TODO(), client.ServiceClient(), "1234asdf")
+	res := servers.RevertResize(context.TODO(), client.ServiceClient(fakeServer), "1234asdf")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetMetadatum(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleMetadatumGetSuccessfully(t)
+	HandleMetadatumGetSuccessfully(t, fakeServer)
 
 	expected := map[string]string{"foo": "bar"}
-	actual, err := servers.Metadatum(context.TODO(), client.ServiceClient(), "1234asdf", "foo").Extract()
+	actual, err := servers.Metadatum(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", "foo").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expected, actual)
 }
 
 func TestCreateMetadatum(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleMetadatumCreateSuccessfully(t)
+	HandleMetadatumCreateSuccessfully(t, fakeServer)
 
 	expected := map[string]string{"foo": "bar"}
-	actual, err := servers.CreateMetadatum(context.TODO(), client.ServiceClient(), "1234asdf", servers.MetadatumOpts{"foo": "bar"}).Extract()
+	actual, err := servers.CreateMetadatum(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", servers.MetadatumOpts{"foo": "bar"}).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expected, actual)
 }
 
 func TestDeleteMetadatum(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleMetadatumDeleteSuccessfully(t)
+	HandleMetadatumDeleteSuccessfully(t, fakeServer)
 
-	err := servers.DeleteMetadatum(context.TODO(), client.ServiceClient(), "1234asdf", "foo").ExtractErr()
+	err := servers.DeleteMetadatum(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", "foo").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleMetadataGetSuccessfully(t)
+	HandleMetadataGetSuccessfully(t, fakeServer)
 
 	expected := map[string]string{"foo": "bar", "this": "that"}
-	actual, err := servers.Metadata(context.TODO(), client.ServiceClient(), "1234asdf").Extract()
+	actual, err := servers.Metadata(context.TODO(), client.ServiceClient(fakeServer), "1234asdf").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expected, actual)
 }
 
 func TestResetMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleMetadataResetSuccessfully(t)
+	HandleMetadataResetSuccessfully(t, fakeServer)
 
 	expected := map[string]string{"foo": "bar", "this": "that"}
-	actual, err := servers.ResetMetadata(context.TODO(), client.ServiceClient(), "1234asdf", servers.MetadataOpts{
+	actual, err := servers.ResetMetadata(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", servers.MetadataOpts{
 		"foo":  "bar",
 		"this": "that",
 	}).Extract()
@@ -1030,13 +1030,13 @@ func TestResetMetadata(t *testing.T) {
 }
 
 func TestUpdateMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleMetadataUpdateSuccessfully(t)
+	HandleMetadataUpdateSuccessfully(t, fakeServer)
 
 	expected := map[string]string{"foo": "baz", "this": "those"}
-	actual, err := servers.UpdateMetadata(context.TODO(), client.ServiceClient(), "1234asdf", servers.MetadataOpts{
+	actual, err := servers.UpdateMetadata(context.TODO(), client.ServiceClient(fakeServer), "1234asdf", servers.MetadataOpts{
 		"foo":  "baz",
 		"this": "those",
 	}).Extract()
@@ -1045,13 +1045,13 @@ func TestUpdateMetadata(t *testing.T) {
 }
 
 func TestListAddresses(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAddressListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAddressListSuccessfully(t, fakeServer)
 
 	expected := ListAddressesExpected
 	pages := 0
-	err := servers.ListAddresses(client.ServiceClient(), "asdfasdfasdf").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := servers.ListAddresses(client.ServiceClient(fakeServer), "asdfasdfasdf").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := servers.ExtractAddresses(page)
@@ -1069,13 +1069,13 @@ func TestListAddresses(t *testing.T) {
 }
 
 func TestListAddressesByNetwork(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleNetworkAddressListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleNetworkAddressListSuccessfully(t, fakeServer)
 
 	expected := ListNetworkAddressesExpected
 	pages := 0
-	err := servers.ListAddressesByNetwork(client.ServiceClient(), "asdfasdfasdf", "public").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := servers.ListAddressesByNetwork(client.ServiceClient(fakeServer), "asdfasdfasdf", "public").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := servers.ExtractNetworkAddresses(page)
@@ -1093,11 +1093,11 @@ func TestListAddressesByNetwork(t *testing.T) {
 }
 
 func TestCreateServerImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateServerImageSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateServerImageSuccessfully(t, fakeServer)
 
-	_, err := servers.CreateImage(context.TODO(), client.ServiceClient(), "serverimage", servers.CreateImageOpts{Name: "test"}).ExtractImageID()
+	_, err := servers.CreateImage(context.TODO(), client.ServiceClient(fakeServer), "serverimage", servers.CreateImageOpts{Name: "test"}).ExtractImageID()
 	th.AssertNoErr(t, err)
 }
 
@@ -1137,11 +1137,11 @@ func TestMarshalPersonality(t *testing.T) {
 }
 
 func TestCreateServerWithTags(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleServerWithTagsCreationSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleServerWithTagsCreationSuccessfully(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	c.Microversion = "2.52"
 
 	tags := []string{"foo", "bar"}
diff --git a/openstack/compute/v2/servers/testing/results_test.go b/openstack/compute/v2/servers/testing/results_test.go
index eb751341f..ba58d63e0 100644
--- a/openstack/compute/v2/servers/testing/results_test.go
+++ b/openstack/compute/v2/servers/testing/results_test.go
@@ -102,11 +102,11 @@ KSde3I0ybDz7iS2EtceKB7m4C0slYd+oBkm4efuF00rCOKDwpFq45m0=
 }
 
 func TestListAddressesAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAddressListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAddressListSuccessfully(t, fakeServer)
 
-	allPages, err := servers.ListAddresses(client.ServiceClient(), "asdfasdfasdf").AllPages(context.TODO())
+	allPages, err := servers.ListAddresses(client.ServiceClient(fakeServer), "asdfasdfasdf").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	_, err = servers.ExtractAddresses(allPages)
 	th.AssertNoErr(t, err)
diff --git a/openstack/compute/v2/services/testing/fixtures_test.go b/openstack/compute/v2/services/testing/fixtures_test.go
index 93b124df9..47e549e1b 100644
--- a/openstack/compute/v2/services/testing/fixtures_test.go
+++ b/openstack/compute/v2/services/testing/fixtures_test.go
@@ -253,8 +253,8 @@ var FakeServiceUpdateBody = services.Service{
 
 // HandleListPre253Successfully configures the test server to respond to a List
 // request to a Compute server API pre 2.53 microversion release.
-func HandleListPre253Successfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-services", func(w http.ResponseWriter, r *http.Request) {
+func HandleListPre253Successfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-services", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -265,8 +265,8 @@ func HandleListPre253Successfully(t *testing.T) {
 
 // HandleListSuccessfully configures the test server to respond to a List
 // request to a Compute server with Pike+ release.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-services", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-services", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -277,8 +277,8 @@ func HandleListSuccessfully(t *testing.T) {
 
 // HandleUpdateSuccessfully configures the test server to respond to a Update
 // request to a Compute server with Pike+ release.
-func HandleUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-services/fake-service-id", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-services/fake-service-id", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -291,8 +291,8 @@ func HandleUpdateSuccessfully(t *testing.T) {
 
 // HandleDeleteSuccessfully configures the test server to respond to a Delete
 // request to a Compute server with Pike+ release.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-services/fake-service-id", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-services/fake-service-id", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
diff --git a/openstack/compute/v2/services/testing/requests_test.go b/openstack/compute/v2/services/testing/requests_test.go
index df7a9e9a1..3fac76abf 100644
--- a/openstack/compute/v2/services/testing/requests_test.go
+++ b/openstack/compute/v2/services/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListServicesPre253(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListPre253Successfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListPre253Successfully(t, fakeServer)
 
 	pages := 0
-	err := services.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := services.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := services.ExtractServices(page)
@@ -43,16 +43,16 @@ func TestListServicesPre253(t *testing.T) {
 }
 
 func TestListServices(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	pages := 0
 	opts := services.ListOpts{
 		Binary: "fake-binary",
 		Host:   "host123",
 	}
-	err := services.List(client.ServiceClient(), opts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := services.List(client.ServiceClient(fakeServer), opts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := services.ExtractServices(page)
@@ -79,11 +79,11 @@ func TestListServices(t *testing.T) {
 }
 
 func TestUpdateService(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
-	client := client.ServiceClient()
+	client := client.ServiceClient(fakeServer)
 	actual, err := services.Update(context.TODO(), client, "fake-service-id", services.UpdateOpts{Status: services.ServiceDisabled}).Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Update error: %v", err)
@@ -93,11 +93,11 @@ func TestUpdateService(t *testing.T) {
 }
 
 func TestDeleteService(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	client := client.ServiceClient()
+	client := client.ServiceClient(fakeServer)
 	res := services.Delete(context.TODO(), client, "fake-service-id")
 
 	th.AssertNoErr(t, res.Err)
diff --git a/openstack/compute/v2/tags/testing/requests_test.go b/openstack/compute/v2/tags/testing/requests_test.go
index dc524a230..fa93b4948 100644
--- a/openstack/compute/v2/tags/testing/requests_test.go
+++ b/openstack/compute/v2/tags/testing/requests_test.go
@@ -12,10 +12,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/uuid1/tags", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/uuid1/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -27,17 +27,17 @@ func TestList(t *testing.T) {
 	})
 
 	expected := []string{"foo", "bar", "baz"}
-	actual, err := tags.List(context.TODO(), client.ServiceClient(), "uuid1").Extract()
+	actual, err := tags.List(context.TODO(), client.ServiceClient(fakeServer), "uuid1").Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expected, actual)
 }
 
 func TestCheckOk(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/uuid1/tags/foo", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/uuid1/tags/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -45,16 +45,16 @@ func TestCheckOk(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	exists, err := tags.Check(context.TODO(), client.ServiceClient(), "uuid1", "foo").Extract()
+	exists, err := tags.Check(context.TODO(), client.ServiceClient(fakeServer), "uuid1", "foo").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, true, exists)
 }
 
 func TestCheckFail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/uuid1/tags/bar", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/uuid1/tags/bar", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -62,16 +62,16 @@ func TestCheckFail(t *testing.T) {
 		w.WriteHeader(http.StatusNotFound)
 	})
 
-	exists, err := tags.Check(context.TODO(), client.ServiceClient(), "uuid1", "bar").Extract()
+	exists, err := tags.Check(context.TODO(), client.ServiceClient(fakeServer), "uuid1", "bar").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, false, exists)
 }
 
 func TestReplaceAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/uuid1/tags", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/uuid1/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPut)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -83,17 +83,17 @@ func TestReplaceAll(t *testing.T) {
 	})
 
 	expected := []string{"tag1", "tag2", "tag3"}
-	actual, err := tags.ReplaceAll(context.TODO(), client.ServiceClient(), "uuid1", tags.ReplaceAllOpts{Tags: []string{"tag1", "tag2", "tag3"}}).Extract()
+	actual, err := tags.ReplaceAll(context.TODO(), client.ServiceClient(fakeServer), "uuid1", tags.ReplaceAllOpts{Tags: []string{"tag1", "tag2", "tag3"}}).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expected, actual)
 }
 
 func TestAddCreated(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/uuid1/tags/foo", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/uuid1/tags/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPut)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -101,15 +101,15 @@ func TestAddCreated(t *testing.T) {
 		w.WriteHeader(http.StatusCreated)
 	})
 
-	err := tags.Add(context.TODO(), client.ServiceClient(), "uuid1", "foo").ExtractErr()
+	err := tags.Add(context.TODO(), client.ServiceClient(fakeServer), "uuid1", "foo").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestAddExists(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/uuid1/tags/foo", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/uuid1/tags/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPut)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -117,15 +117,15 @@ func TestAddExists(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := tags.Add(context.TODO(), client.ServiceClient(), "uuid1", "foo").ExtractErr()
+	err := tags.Add(context.TODO(), client.ServiceClient(fakeServer), "uuid1", "foo").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/uuid1/tags/foo", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/uuid1/tags/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodDelete)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -133,15 +133,15 @@ func TestDelete(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := tags.Delete(context.TODO(), client.ServiceClient(), "uuid1", "foo").ExtractErr()
+	err := tags.Delete(context.TODO(), client.ServiceClient(fakeServer), "uuid1", "foo").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDeleteAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/servers/uuid1/tags", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/servers/uuid1/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodDelete)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -149,6 +149,6 @@ func TestDeleteAll(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := tags.DeleteAll(context.TODO(), client.ServiceClient(), "uuid1").ExtractErr()
+	err := tags.DeleteAll(context.TODO(), client.ServiceClient(fakeServer), "uuid1").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/compute/v2/usage/testing/fixtures_test.go b/openstack/compute/v2/usage/testing/fixtures_test.go
index f5b92ca09..1922a0dda 100644
--- a/openstack/compute/v2/usage/testing/fixtures_test.go
+++ b/openstack/compute/v2/usage/testing/fixtures_test.go
@@ -74,8 +74,8 @@ const GetSingleTenant = `{
 
 // HandleGetSingleTenantSuccessfully configures the test server to respond to a
 // Get request for a single tenant
-func HandleGetSingleTenantSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-simple-tenant-usage/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSingleTenantSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-simple-tenant-usage/"+FirstTenantID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -224,8 +224,8 @@ const GetAllTenants = `{
 
 // HandleGetAllTenantsSuccessfully configures the test server to respond to a
 // Get request for all tenants.
-func HandleGetAllTenantsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/os-simple-tenant-usage", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetAllTenantsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-simple-tenant-usage", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
diff --git a/openstack/compute/v2/usage/testing/requests_test.go b/openstack/compute/v2/usage/testing/requests_test.go
index 163ab1082..eb1692266 100644
--- a/openstack/compute/v2/usage/testing/requests_test.go
+++ b/openstack/compute/v2/usage/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestGetTenant(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSingleTenantSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSingleTenantSuccessfully(t, fakeServer)
 
 	count := 0
-	err := usage.SingleTenant(client.ServiceClient(), FirstTenantID, nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := usage.SingleTenant(client.ServiceClient(fakeServer), FirstTenantID, nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := usage.ExtractSingleTenant(page)
@@ -30,16 +30,16 @@ func TestGetTenant(t *testing.T) {
 }
 
 func TestAllTenants(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetAllTenantsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetAllTenantsSuccessfully(t, fakeServer)
 
 	getOpts := usage.AllTenantsOpts{
 		Detailed: true,
 	}
 
 	count := 0
-	err := usage.AllTenants(client.ServiceClient(), getOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := usage.AllTenants(client.ServiceClient(fakeServer), getOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := usage.ExtractAllTenants(page)
diff --git a/openstack/compute/v2/volumeattach/testing/fixtures_test.go b/openstack/compute/v2/volumeattach/testing/fixtures_test.go
index d9ada1e8c..f1450719b 100644
--- a/openstack/compute/v2/volumeattach/testing/fixtures_test.go
+++ b/openstack/compute/v2/volumeattach/testing/fixtures_test.go
@@ -56,8 +56,8 @@ const CreateOutput = `
 `
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/4d8c3732-a248-40ed-bebc-539a6ffd25c0/os-volume_attachments", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/4d8c3732-a248-40ed-bebc-539a6ffd25c0/os-volume_attachments", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -68,8 +68,8 @@ func HandleListSuccessfully(t *testing.T) {
 
 // HandleGetSuccessfully configures the test server to respond to a Get request
 // for an existing attachment
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/4d8c3732-a248-40ed-bebc-539a6ffd25c0/os-volume_attachments/a26887c6-c47b-4654-abb5-dfadf7d3f804", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/4d8c3732-a248-40ed-bebc-539a6ffd25c0/os-volume_attachments/a26887c6-c47b-4654-abb5-dfadf7d3f804", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -80,8 +80,8 @@ func HandleGetSuccessfully(t *testing.T) {
 
 // HandleCreateSuccessfully configures the test server to respond to a Create request
 // for a new attachment
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/4d8c3732-a248-40ed-bebc-539a6ffd25c0/os-volume_attachments", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/4d8c3732-a248-40ed-bebc-539a6ffd25c0/os-volume_attachments", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `
@@ -102,8 +102,8 @@ func HandleCreateSuccessfully(t *testing.T) {
 
 // HandleDeleteSuccessfully configures the test server to respond to a Delete request for a
 // an existing attachment
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/servers/4d8c3732-a248-40ed-bebc-539a6ffd25c0/os-volume_attachments/a26887c6-c47b-4654-abb5-dfadf7d3f804", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/servers/4d8c3732-a248-40ed-bebc-539a6ffd25c0/os-volume_attachments/a26887c6-c47b-4654-abb5-dfadf7d3f804", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/compute/v2/volumeattach/testing/requests_test.go b/openstack/compute/v2/volumeattach/testing/requests_test.go
index 92da356cb..21f323a35 100644
--- a/openstack/compute/v2/volumeattach/testing/requests_test.go
+++ b/openstack/compute/v2/volumeattach/testing/requests_test.go
@@ -44,15 +44,15 @@ var CreatedVolumeAttachment = volumeattach.VolumeAttachment{
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleListSuccessfully(t)
+	HandleListSuccessfully(t, fakeServer)
 
 	serverID := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
 
 	count := 0
-	err := volumeattach.List(client.ServiceClient(), serverID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := volumeattach.List(client.ServiceClient(fakeServer), serverID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := volumeattach.ExtractVolumeAttachments(page)
 		th.AssertNoErr(t, err)
@@ -65,14 +65,14 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCreateSuccessfully(t)
+	HandleCreateSuccessfully(t, fakeServer)
 
 	serverID := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
 
-	actual, err := volumeattach.Create(context.TODO(), client.ServiceClient(), serverID, volumeattach.CreateOpts{
+	actual, err := volumeattach.Create(context.TODO(), client.ServiceClient(fakeServer), serverID, volumeattach.CreateOpts{
 		Device:              "/dev/vdc",
 		VolumeID:            "a26887c6-c47b-4654-abb5-dfadf7d3f804",
 		Tag:                 iTag,
@@ -83,28 +83,28 @@ func TestCreate(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetSuccessfully(t)
+	HandleGetSuccessfully(t, fakeServer)
 
 	aID := "a26887c6-c47b-4654-abb5-dfadf7d3f804"
 	serverID := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
 
-	actual, err := volumeattach.Get(context.TODO(), client.ServiceClient(), serverID, aID).Extract()
+	actual, err := volumeattach.Get(context.TODO(), client.ServiceClient(fakeServer), serverID, aID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &SecondVolumeAttachment, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleDeleteSuccessfully(t)
+	HandleDeleteSuccessfully(t, fakeServer)
 
 	aID := "a26887c6-c47b-4654-abb5-dfadf7d3f804"
 	serverID := "4d8c3732-a248-40ed-bebc-539a6ffd25c0"
 
-	err := volumeattach.Delete(context.TODO(), client.ServiceClient(), serverID, aID).ExtractErr()
+	err := volumeattach.Delete(context.TODO(), client.ServiceClient(fakeServer), serverID, aID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/container/v1/capsules/testing/fixtures_test.go b/openstack/container/v1/capsules/testing/fixtures_test.go
index 779a41a0d..e21b85256 100644
--- a/openstack/container/v1/capsules/testing/fixtures_test.go
+++ b/openstack/container/v1/capsules/testing/fixtures_test.go
@@ -4,10 +4,12 @@ import (
 	"fmt"
 	"net/http"
 	"testing"
+	"time"
 
+	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/container/v1/capsules"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // ValidJSONTemplate is a valid OpenStack Capsule template in JSON format
@@ -455,157 +457,175 @@ const CapsuleV132ListBody = `
   ]
 }`
 
-var ExpectedContainer1 = capsules.Container{
-	Name:      "test-demo-omicron-13",
-	UUID:      "1739e28a-d391-4fd9-93a5-3ba3f29a4c9b",
-	UserID:    "d33b18c384574fd2a3299447aac285f0",
-	ProjectID: "6b8ffef2a0ac42ee87887b9cc98bdf68",
-	CPU:       float64(1),
-	Memory:    "1024M",
-	Host:      "test-host",
-	Status:    "Running",
-	Image:     "test",
-	Labels: map[string]string{
-		"foo": "bar",
-	},
-	WorkDir: "/root",
-	Disk:    0,
-	Command: []string{
-		"testcmd",
-	},
-	Ports: []int{
-		80,
-	},
-	SecurityGroups: []string{
-		"default",
-	},
-	ImagePullPolicy: "ifnotpresent",
-	Runtime:         "runc",
-	TaskState:       "Creating",
-	HostName:        "test-hostname",
-	Environment: map[string]string{
-		"USER1": "test",
-	},
-	StatusReason: "No reason",
-	StatusDetail: "Just created",
-	ImageDriver:  "docker",
-	Interactive:  true,
-	AutoRemove:   false,
-	AutoHeal:     false,
-	RestartPolicy: map[string]string{
-		"MaximumRetryCount": "0",
-		"Name":              "always",
-	},
-	Addresses: map[string][]capsules.Address{
-		"b1295212-64e1-471d-aa01-25ff46f9818d": {
-			{
-				PreserveOnDelete: false,
-				Addr:             "172.24.4.11",
-				Port:             "8439060f-381a-4386-a518-33d5a4058636",
-				Version:          float64(4),
-				SubnetID:         "4a2bcd64-93ad-4436-9f48-3a7f9b267e0a",
+func GetFakeContainer() capsules.Container {
+	createdAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:25")
+	updatedAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:26")
+	startedAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:26")
+
+	return capsules.Container{
+		Name:      "test-demo-omicron-13",
+		UUID:      "1739e28a-d391-4fd9-93a5-3ba3f29a4c9b",
+		UserID:    "d33b18c384574fd2a3299447aac285f0",
+		ProjectID: "6b8ffef2a0ac42ee87887b9cc98bdf68",
+		CreatedAt: createdAt,
+		UpdatedAt: updatedAt,
+		StartedAt: startedAt,
+		CPU:       float64(1),
+		Memory:    "1024M",
+		Host:      "test-host",
+		Status:    "Running",
+		Image:     "test",
+		Labels: map[string]string{
+			"foo": "bar",
+		},
+		WorkDir: "/root",
+		Disk:    0,
+		Command: []string{
+			"testcmd",
+		},
+		Ports: []int{
+			80,
+		},
+		SecurityGroups: []string{
+			"default",
+		},
+		ImagePullPolicy: "ifnotpresent",
+		Runtime:         "runc",
+		TaskState:       "Creating",
+		HostName:        "test-hostname",
+		Environment: map[string]string{
+			"USER1": "test",
+		},
+		StatusReason: "No reason",
+		StatusDetail: "Just created",
+		ImageDriver:  "docker",
+		Interactive:  true,
+		AutoRemove:   false,
+		AutoHeal:     false,
+		RestartPolicy: map[string]string{
+			"MaximumRetryCount": "0",
+			"Name":              "always",
+		},
+		Addresses: map[string][]capsules.Address{
+			"b1295212-64e1-471d-aa01-25ff46f9818d": {
+				{
+					PreserveOnDelete: false,
+					Addr:             "172.24.4.11",
+					Port:             "8439060f-381a-4386-a518-33d5a4058636",
+					Version:          float64(4),
+					SubnetID:         "4a2bcd64-93ad-4436-9f48-3a7f9b267e0a",
+				},
 			},
 		},
-	},
+	}
 }
 
-var ExpectedCapsule = capsules.Capsule{
-	UUID:      "cc654059-1a77-47a3-bfcf-715bde5aad9e",
-	Status:    "Running",
-	UserID:    "d33b18c384574fd2a3299447aac285f0",
-	ProjectID: "6b8ffef2a0ac42ee87887b9cc98bdf68",
-	CPU:       float64(1),
-	Memory:    "1024M",
-	MetaName:  "test",
-	Links: []any{
-		map[string]any{
-			"href": "http://10.10.10.10/v1/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e",
-			"rel":  "self",
+func GetFakeCapsule() capsules.Capsule {
+	createdAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:25")
+	updatedAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:26")
+
+	return capsules.Capsule{
+		UUID:      "cc654059-1a77-47a3-bfcf-715bde5aad9e",
+		Status:    "Running",
+		UserID:    "d33b18c384574fd2a3299447aac285f0",
+		ProjectID: "6b8ffef2a0ac42ee87887b9cc98bdf68",
+		CreatedAt: createdAt,
+		UpdatedAt: updatedAt,
+		CPU:       float64(1),
+		Memory:    "1024M",
+		MetaName:  "test",
+		Links: []any{
+			map[string]any{
+				"href": "http://10.10.10.10/v1/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e",
+				"rel":  "self",
+			},
+			map[string]any{
+				"href": "http://10.10.10.10/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e",
+				"rel":  "bookmark",
+			},
 		},
-		map[string]any{
-			"href": "http://10.10.10.10/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e",
-			"rel":  "bookmark",
+		CapsuleVersion: "beta",
+		RestartPolicy:  "always",
+		MetaLabels: map[string]string{
+			"web": "app",
 		},
-	},
-	CapsuleVersion: "beta",
-	RestartPolicy:  "always",
-	MetaLabels: map[string]string{
-		"web": "app",
-	},
-	ContainersUUIDs: []string{
-		"1739e28a-d391-4fd9-93a5-3ba3f29a4c9b",
-	},
-	Addresses: map[string][]capsules.Address{
-		"b1295212-64e1-471d-aa01-25ff46f9818d": {
-			{
-				PreserveOnDelete: false,
-				Addr:             "172.24.4.11",
-				Port:             "8439060f-381a-4386-a518-33d5a4058636",
-				Version:          float64(4),
-				SubnetID:         "4a2bcd64-93ad-4436-9f48-3a7f9b267e0a",
+		ContainersUUIDs: []string{
+			"1739e28a-d391-4fd9-93a5-3ba3f29a4c9b",
+		},
+		Addresses: map[string][]capsules.Address{
+			"b1295212-64e1-471d-aa01-25ff46f9818d": {
+				{
+					PreserveOnDelete: false,
+					Addr:             "172.24.4.11",
+					Port:             "8439060f-381a-4386-a518-33d5a4058636",
+					Version:          float64(4),
+					SubnetID:         "4a2bcd64-93ad-4436-9f48-3a7f9b267e0a",
+				},
 			},
 		},
-	},
-	VolumesInfo: map[string][]string{
-		"67618d54-dd55-4f7e-91b3-39ffb3ba7f5f": {
-			"1739e28a-d391-4fd9-93a5-3ba3f29a4c9b",
+		VolumesInfo: map[string][]string{
+			"67618d54-dd55-4f7e-91b3-39ffb3ba7f5f": {
+				"1739e28a-d391-4fd9-93a5-3ba3f29a4c9b",
+			},
 		},
-	},
-	Host:         "test-host",
-	StatusReason: "No reason",
-	Containers: []capsules.Container{
-		ExpectedContainer1,
-	},
+		Host:         "test-host",
+		StatusReason: "No reason",
+		Containers: []capsules.Container{
+			GetFakeContainer(),
+		},
+	}
 }
 
-var ExpectedCapsuleV132 = capsules.CapsuleV132{
-	UUID:      "cc654059-1a77-47a3-bfcf-715bde5aad9e",
-	Status:    "Running",
-	UserID:    "d33b18c384574fd2a3299447aac285f0",
-	ProjectID: "6b8ffef2a0ac42ee87887b9cc98bdf68",
-	CPU:       float64(1),
-	Memory:    "1024M",
-	MetaName:  "test",
-	Links: []any{
-		map[string]any{
-			"href": "http://10.10.10.10/v1/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e",
-			"rel":  "self",
+func GetFakeCapsuleV132() capsules.CapsuleV132 {
+	return capsules.CapsuleV132{
+		UUID:      "cc654059-1a77-47a3-bfcf-715bde5aad9e",
+		Status:    "Running",
+		UserID:    "d33b18c384574fd2a3299447aac285f0",
+		ProjectID: "6b8ffef2a0ac42ee87887b9cc98bdf68",
+		CPU:       float64(1),
+		Memory:    "1024M",
+		MetaName:  "test",
+		Links: []any{
+			map[string]any{
+				"href": "http://10.10.10.10/v1/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e",
+				"rel":  "self",
+			},
+			map[string]any{
+				"href": "http://10.10.10.10/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e",
+				"rel":  "bookmark",
+			},
 		},
-		map[string]any{
-			"href": "http://10.10.10.10/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e",
-			"rel":  "bookmark",
+		RestartPolicy: map[string]string{
+			"MaximumRetryCount": "0",
+			"Name":              "always",
 		},
-	},
-	RestartPolicy: map[string]string{
-		"MaximumRetryCount": "0",
-		"Name":              "always",
-	},
-	MetaLabels: map[string]string{
-		"web": "app",
-	},
-	Addresses: map[string][]capsules.Address{
-		"b1295212-64e1-471d-aa01-25ff46f9818d": {
-			{
-				PreserveOnDelete: false,
-				Addr:             "172.24.4.11",
-				Port:             "8439060f-381a-4386-a518-33d5a4058636",
-				Version:          float64(4),
-				SubnetID:         "4a2bcd64-93ad-4436-9f48-3a7f9b267e0a",
+		MetaLabels: map[string]string{
+			"web": "app",
+		},
+		Addresses: map[string][]capsules.Address{
+			"b1295212-64e1-471d-aa01-25ff46f9818d": {
+				{
+					PreserveOnDelete: false,
+					Addr:             "172.24.4.11",
+					Port:             "8439060f-381a-4386-a518-33d5a4058636",
+					Version:          float64(4),
+					SubnetID:         "4a2bcd64-93ad-4436-9f48-3a7f9b267e0a",
+				},
 			},
 		},
-	},
-	Host:         "test-host",
-	StatusReason: "No reason",
-	Containers: []capsules.Container{
-		ExpectedContainer1,
-	},
+		Host:         "test-host",
+		StatusReason: "No reason",
+		Containers: []capsules.Container{
+			GetFakeContainer(),
+		},
+	}
 }
 
 // HandleCapsuleGetOldTimeSuccessfully test setup
-func HandleCapsuleGetOldTimeSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e", func(w http.ResponseWriter, r *http.Request) {
+func HandleCapsuleGetOldTimeSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusOK)
 		w.Header().Add("Content-Type", "application/json")
@@ -614,10 +634,10 @@ func HandleCapsuleGetOldTimeSuccessfully(t *testing.T) {
 }
 
 // HandleCapsuleGetNewTimeSuccessfully test setup
-func HandleCapsuleGetNewTimeSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e", func(w http.ResponseWriter, r *http.Request) {
+func HandleCapsuleGetNewTimeSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/capsules/cc654059-1a77-47a3-bfcf-715bde5aad9e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusOK)
 		w.Header().Add("Content-Type", "application/json")
@@ -627,10 +647,10 @@ func HandleCapsuleGetNewTimeSuccessfully(t *testing.T) {
 
 // HandleCapsuleCreateSuccessfully creates an HTTP handler at `/capsules` on the test handler mux
 // that responds with a `Create` response.
-func HandleCapsuleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/capsules", func(w http.ResponseWriter, r *http.Request) {
+func HandleCapsuleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/capsules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.WriteHeader(http.StatusAccepted)
 		fmt.Fprint(w, CapsuleGetBody_NewTime)
@@ -638,10 +658,10 @@ func HandleCapsuleCreateSuccessfully(t *testing.T) {
 }
 
 // HandleCapsuleListSuccessfully test setup
-func HandleCapsuleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/capsules/", func(w http.ResponseWriter, r *http.Request) {
+func HandleCapsuleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/capsules/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -650,10 +670,10 @@ func HandleCapsuleListSuccessfully(t *testing.T) {
 }
 
 // HandleCapsuleV132ListSuccessfully test setup
-func HandleCapsuleV132ListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/capsules/", func(w http.ResponseWriter, r *http.Request) {
+func HandleCapsuleV132ListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/capsules/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -661,10 +681,10 @@ func HandleCapsuleV132ListSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleCapsuleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/capsules/963a239d-3946-452b-be5a-055eab65a421", func(w http.ResponseWriter, r *http.Request) {
+func HandleCapsuleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/capsules/963a239d-3946-452b-be5a-055eab65a421", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
diff --git a/openstack/container/v1/capsules/testing/requests_test.go b/openstack/container/v1/capsules/testing/requests_test.go
index 2925f93ec..20d085088 100644
--- a/openstack/container/v1/capsules/testing/requests_test.go
+++ b/openstack/container/v1/capsules/testing/requests_test.go
@@ -9,81 +9,74 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/container/v1/capsules"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestGetCapsule_OldTime(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCapsuleGetOldTimeSuccessfully(t)
+	HandleCapsuleGetOldTimeSuccessfully(t, fakeServer)
 
 	createdAt, _ := time.Parse(gophercloud.RFC3339ZNoT, "2018-01-12 09:37:25+00:00")
 	updatedAt, _ := time.Parse(gophercloud.RFC3339ZNoT, "2018-01-12 09:37:26+00:00")
 	startedAt, _ := time.Parse(gophercloud.RFC3339ZNoT, "2018-01-12 09:37:26+00:00")
 
-	ExpectedCapsule.CreatedAt = createdAt
-	ExpectedCapsule.UpdatedAt = updatedAt
-	ExpectedCapsule.Containers[0].CreatedAt = createdAt
-	ExpectedCapsule.Containers[0].UpdatedAt = updatedAt
-	ExpectedCapsule.Containers[0].StartedAt = startedAt
+	ec := GetFakeCapsule()
+	ec.CreatedAt = createdAt
+	ec.UpdatedAt = updatedAt
+	ec.Containers[0].CreatedAt = createdAt
+	ec.Containers[0].UpdatedAt = updatedAt
+	ec.Containers[0].StartedAt = startedAt
 
-	actualCapsule, err := capsules.Get(context.TODO(), fakeclient.ServiceClient(), ExpectedCapsule.UUID).Extract()
+	actualCapsule, err := capsules.Get(context.TODO(), client.ServiceClient(fakeServer), ec.UUID).Extract()
 	th.AssertNoErr(t, err)
 
-	th.AssertDeepEquals(t, &ExpectedCapsule, actualCapsule)
+	th.AssertDeepEquals(t, &ec, actualCapsule)
 }
 
 func TestGetCapsule_NewTime(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCapsuleGetNewTimeSuccessfully(t)
-
-	createdAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:25")
-	updatedAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:26")
-	startedAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:26")
+	HandleCapsuleGetNewTimeSuccessfully(t, fakeServer)
 
-	ExpectedCapsule.CreatedAt = createdAt
-	ExpectedCapsule.UpdatedAt = updatedAt
-	ExpectedCapsule.Containers[0].CreatedAt = createdAt
-	ExpectedCapsule.Containers[0].UpdatedAt = updatedAt
-	ExpectedCapsule.Containers[0].StartedAt = startedAt
+	ec := GetFakeCapsule()
 
-	actualCapsule, err := capsules.Get(context.TODO(), fakeclient.ServiceClient(), ExpectedCapsule.UUID).Extract()
+	actualCapsule, err := capsules.Get(context.TODO(), client.ServiceClient(fakeServer), ec.UUID).Extract()
 	th.AssertNoErr(t, err)
 
-	th.AssertDeepEquals(t, &ExpectedCapsule, actualCapsule)
+	th.AssertDeepEquals(t, &ec, actualCapsule)
 }
 
 func TestCreateCapsule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCapsuleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCapsuleCreateSuccessfully(t, fakeServer)
+
+	ec := GetFakeCapsule()
 
 	template := new(capsules.Template)
 	template.Bin = []byte(ValidJSONTemplate)
-
 	createOpts := capsules.CreateOpts{
 		TemplateOpts: template,
 	}
-	actualCapsule, err := capsules.Create(context.TODO(), fakeclient.ServiceClient(), createOpts).Extract()
+	actualCapsule, err := capsules.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 
-	th.AssertDeepEquals(t, &ExpectedCapsule, actualCapsule)
+	th.AssertDeepEquals(t, &ec, actualCapsule)
 }
 
 func TestListCapsule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCapsuleListSuccessfully(t)
+	HandleCapsuleListSuccessfully(t, fakeServer)
 
 	createdAt, _ := time.Parse(gophercloud.RFC3339ZNoT, "2018-01-12 09:37:25+00:00")
 	updatedAt, _ := time.Parse(gophercloud.RFC3339ZNoT, "2018-01-12 09:37:25+01:00")
 
-	ec := ExpectedCapsule
-
+	ec := GetFakeCapsule()
 	ec.CreatedAt = createdAt
 	ec.UpdatedAt = updatedAt
 	ec.Containers = nil
@@ -91,7 +84,7 @@ func TestListCapsule(t *testing.T) {
 	expected := []capsules.Capsule{ec}
 
 	count := 0
-	results := capsules.List(fakeclient.ServiceClient(), nil)
+	results := capsules.List(client.ServiceClient(fakeServer), nil)
 	err := results.EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := capsules.ExtractCapsules(page)
@@ -112,16 +105,15 @@ func TestListCapsule(t *testing.T) {
 }
 
 func TestListCapsuleV132(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCapsuleV132ListSuccessfully(t)
+	HandleCapsuleV132ListSuccessfully(t, fakeServer)
 
 	createdAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:25")
 	updatedAt, _ := time.Parse(gophercloud.RFC3339ZNoTNoZ, "2018-01-12 09:37:25")
 
-	ec := ExpectedCapsuleV132
-
+	ec := GetFakeCapsuleV132()
 	ec.CreatedAt = createdAt
 	ec.UpdatedAt = updatedAt
 	ec.Containers = nil
@@ -129,7 +121,7 @@ func TestListCapsuleV132(t *testing.T) {
 	expected := []capsules.CapsuleV132{ec}
 
 	count := 0
-	results := capsules.List(fakeclient.ServiceClient(), nil)
+	results := capsules.List(client.ServiceClient(fakeServer), nil)
 	err := results.EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := capsules.ExtractCapsules(page)
@@ -150,11 +142,11 @@ func TestListCapsuleV132(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCapsuleDeleteSuccessfully(t)
+	HandleCapsuleDeleteSuccessfully(t, fakeServer)
 
-	res := capsules.Delete(context.TODO(), fakeclient.ServiceClient(), "963a239d-3946-452b-be5a-055eab65a421")
+	res := capsules.Delete(context.TODO(), client.ServiceClient(fakeServer), "963a239d-3946-452b-be5a-055eab65a421")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/containerinfra/apiversions/testing/fixtures_test.go b/openstack/containerinfra/apiversions/testing/fixtures_test.go
index f42844214..dd9711a6c 100644
--- a/openstack/containerinfra/apiversions/testing/fixtures_test.go
+++ b/openstack/containerinfra/apiversions/testing/fixtures_test.go
@@ -63,8 +63,8 @@ var MagnumAllAPIVersionResults = []apiversions.APIVersion{
 	MagnumAPIVersion1Result,
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -75,8 +75,8 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/v1/", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/containerinfra/apiversions/testing/requests_test.go b/openstack/containerinfra/apiversions/testing/requests_test.go
index 175be19c7..a2a478243 100644
--- a/openstack/containerinfra/apiversions/testing/requests_test.go
+++ b/openstack/containerinfra/apiversions/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListAPIVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allVersions, err := apiversions.List(client.ServiceClient()).AllPages(context.TODO())
+	allVersions, err := apiversions.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := apiversions.ExtractAPIVersions(allVersions)
@@ -26,12 +26,12 @@ func TestListAPIVersions(t *testing.T) {
 }
 
 func TestGetAPIVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	actual, err := apiversions.Get(context.TODO(), client.ServiceClient(), "v1").Extract()
+	actual, err := apiversions.Get(context.TODO(), client.ServiceClient(fakeServer), "v1").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, MagnumAPIVersion1Result, *actual)
diff --git a/openstack/containerinfra/v1/certificates/testing/fixtures_test.go b/openstack/containerinfra/v1/certificates/testing/fixtures_test.go
index b51d77cbd..67381f578 100644
--- a/openstack/containerinfra/v1/certificates/testing/fixtures_test.go
+++ b/openstack/containerinfra/v1/certificates/testing/fixtures_test.go
@@ -8,7 +8,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/certificates"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const CertificateResponse = `
@@ -67,10 +67,10 @@ var ExpectedCreateCertificateResponse = certificates.Certificate{
 	},
 }
 
-func HandleGetCertificateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/certificates/d564b18a-2890-4152-be3d-e05d784ff72", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetCertificateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/certificates/d564b18a-2890-4152-be3d-e05d784ff72", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("OpenStack-API-Minimum-Version", "container-infra 1.1")
@@ -83,10 +83,10 @@ func HandleGetCertificateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleCreateCertificateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/certificates/", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateCertificateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/certificates/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("OpenStack-API-Minimum-Version", "container-infra 1.1")
@@ -99,11 +99,11 @@ func HandleCreateCertificateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleUpdateCertificateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/certificates/d564b18a-2890-4152-be3d-e05d784ff72",
+func HandleUpdateCertificateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/certificates/d564b18a-2890-4152-be3d-e05d784ff72",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PATCH")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.WriteHeader(http.StatusAccepted)
 			fmt.Fprint(w, `{}`)
diff --git a/openstack/containerinfra/v1/certificates/testing/requests_test.go b/openstack/containerinfra/v1/certificates/testing/requests_test.go
index 25a287e40..3725c8636 100644
--- a/openstack/containerinfra/v1/certificates/testing/requests_test.go
+++ b/openstack/containerinfra/v1/certificates/testing/requests_test.go
@@ -6,16 +6,16 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/certificates"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestGetCertificates(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetCertificateSuccessfully(t)
+	HandleGetCertificateSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	actual, err := certificates.Get(context.TODO(), sc, "d564b18a-2890-4152-be3d-e05d784ff72").Extract()
@@ -24,12 +24,12 @@ func TestGetCertificates(t *testing.T) {
 }
 
 func TestCreateCertificates(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCreateCertificateSuccessfully(t)
+	HandleCreateCertificateSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	opts := certificates.CreateOpts{
@@ -43,12 +43,12 @@ func TestCreateCertificates(t *testing.T) {
 }
 
 func TestUpdateCertificates(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleUpdateCertificateSuccessfully(t)
+	HandleUpdateCertificateSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	err := certificates.Update(context.TODO(), sc, "d564b18a-2890-4152-be3d-e05d784ff72").ExtractErr()
diff --git a/openstack/containerinfra/v1/clusters/testing/fixtures_test.go b/openstack/containerinfra/v1/clusters/testing/fixtures_test.go
index ccbfddfc6..bf0a77c91 100644
--- a/openstack/containerinfra/v1/clusters/testing/fixtures_test.go
+++ b/openstack/containerinfra/v1/clusters/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/clusters"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const clusterUUID = "746e779a-751a-456b-a3e9-c883d734946f"
@@ -95,10 +95,10 @@ var ExpectedCluster2 = clusters.Cluster{
 
 var ExpectedClusterUUID = clusterUUID
 
-func HandleCreateClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("X-OpenStack-Request-Id", requestUUID)
@@ -108,10 +108,10 @@ func HandleCreateClusterSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID, func(w http.ResponseWriter, r *http.Request) {
+func HandleGetClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -247,10 +247,10 @@ var ClusterListResponse = fmt.Sprintf(`
 
 var ExpectedClusters = []clusters.Cluster{ExpectedCluster}
 
-func HandleListClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters", func(w http.ResponseWriter, r *http.Request) {
+func HandleListClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("X-OpenStack-Request-Id", requestUUID)
@@ -260,10 +260,10 @@ func HandleListClusterSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleListDetailClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleListDetailClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("X-OpenStack-Request-Id", requestUUID)
@@ -278,10 +278,10 @@ var UpdateResponse = fmt.Sprintf(`
 	"uuid":"%s"
 }`, clusterUUID)
 
-func HandleUpdateClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID, func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("X-OpenStack-Request-Id", requestUUID)
@@ -296,10 +296,10 @@ var UpgradeResponse = fmt.Sprintf(`
 	"uuid":"%s"
 }`, clusterUUID)
 
-func HandleUpgradeClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/actions/upgrade", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpgradeClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/actions/upgrade", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("X-OpenStack-Request-Id", requestUUID)
@@ -309,10 +309,10 @@ func HandleUpgradeClusterSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleDeleteClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID, func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("X-OpenStack-Request-Id", requestUUID)
@@ -325,10 +325,10 @@ var ResizeResponse = fmt.Sprintf(`
 	"uuid": "%s"
 }`, clusterUUID)
 
-func HandleResizeClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/actions/resize", func(w http.ResponseWriter, r *http.Request) {
+func HandleResizeClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/actions/resize", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("X-OpenStack-Request-Id", requestUUID)
diff --git a/openstack/containerinfra/v1/clusters/testing/requests_test.go b/openstack/containerinfra/v1/clusters/testing/requests_test.go
index c7cd21efc..44a8a353d 100644
--- a/openstack/containerinfra/v1/clusters/testing/requests_test.go
+++ b/openstack/containerinfra/v1/clusters/testing/requests_test.go
@@ -8,14 +8,14 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/clusters"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreateCluster(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCreateClusterSuccessfully(t)
+	HandleCreateClusterSuccessfully(t, fakeServer)
 
 	masterCount := 1
 	nodeCount := 1
@@ -39,7 +39,7 @@ func TestCreateCluster(t *testing.T) {
 		MergeLabels:       gophercloud.Enabled,
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	res := clusters.Create(context.TODO(), sc, opts)
 	th.AssertNoErr(t, res.Err)
@@ -54,12 +54,12 @@ func TestCreateCluster(t *testing.T) {
 }
 
 func TestGetCluster(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetClusterSuccessfully(t)
+	HandleGetClusterSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	actual, err := clusters.Get(context.TODO(), sc, "746e779a-751a-456b-a3e9-c883d734946f").Extract()
 	th.AssertNoErr(t, err)
@@ -69,13 +69,13 @@ func TestGetCluster(t *testing.T) {
 }
 
 func TestListClusters(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleListClusterSuccessfully(t)
+	HandleListClusterSuccessfully(t, fakeServer)
 
 	count := 0
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	err := clusters.List(sc, clusters.ListOpts{Limit: 2}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
@@ -97,13 +97,13 @@ func TestListClusters(t *testing.T) {
 }
 
 func TestListDetailClusters(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleListDetailClusterSuccessfully(t)
+	HandleListDetailClusterSuccessfully(t, fakeServer)
 
 	count := 0
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	err := clusters.ListDetail(sc, clusters.ListOpts{Limit: 2}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
@@ -125,10 +125,10 @@ func TestListDetailClusters(t *testing.T) {
 }
 
 func TestUpdateCluster(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleUpdateClusterSuccessfully(t)
+	HandleUpdateClusterSuccessfully(t, fakeServer)
 
 	updateOpts := []clusters.UpdateOptsBuilder{
 		clusters.UpdateOpts{
@@ -143,7 +143,7 @@ func TestUpdateCluster(t *testing.T) {
 		},
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	res := clusters.Update(context.TODO(), sc, clusterUUID, updateOpts)
 	th.AssertNoErr(t, res.Err)
@@ -158,16 +158,16 @@ func TestUpdateCluster(t *testing.T) {
 }
 
 func TestUpgradeCluster(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleUpgradeClusterSuccessfully(t)
+	HandleUpgradeClusterSuccessfully(t, fakeServer)
 
 	opts := clusters.UpgradeOpts{
 		ClusterTemplate: "0562d357-8641-4759-8fed-8173f02c9633",
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	res := clusters.Upgrade(context.TODO(), sc, clusterUUID, opts)
 	th.AssertNoErr(t, res.Err)
@@ -182,12 +182,12 @@ func TestUpgradeCluster(t *testing.T) {
 }
 
 func TestDeleteCluster(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleDeleteClusterSuccessfully(t)
+	HandleDeleteClusterSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	r := clusters.Delete(context.TODO(), sc, clusterUUID)
 	err := r.ExtractErr()
@@ -208,10 +208,10 @@ func TestDeleteCluster(t *testing.T) {
 }
 
 func TestResizeCluster(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResizeClusterSuccessfully(t)
+	HandleResizeClusterSuccessfully(t, fakeServer)
 
 	nodeCount := 2
 
@@ -219,7 +219,7 @@ func TestResizeCluster(t *testing.T) {
 		NodeCount: &nodeCount,
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	res := clusters.Resize(context.TODO(), sc, clusterUUID, opts)
 	th.AssertNoErr(t, res.Err)
diff --git a/openstack/containerinfra/v1/clustertemplates/testing/fixtures_test.go b/openstack/containerinfra/v1/clustertemplates/testing/fixtures_test.go
index f269d99cb..5d47da598 100644
--- a/openstack/containerinfra/v1/clustertemplates/testing/fixtures_test.go
+++ b/openstack/containerinfra/v1/clustertemplates/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/clustertemplates"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const ClusterTemplateResponse = `
@@ -274,10 +274,32 @@ var ExpectedClusterTemplate_EmptyTime = clustertemplates.ClusterTemplate{
 
 var ExpectedClusterTemplates = []clustertemplates.ClusterTemplate{ExpectedClusterTemplate, ExpectedClusterTemplate_EmptyTime}
 
-func HandleCreateClusterTemplateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clustertemplates", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateClusterTemplateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clustertemplates", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
+		th.TestJSONRequest(t, r, `{
+                  "coe": "kubernetes",
+                  "dns_nameserver": "8.8.8.8",
+                  "docker_storage_driver": "devicemapper",
+                  "docker_volume_size": 3,
+                  "external_network_id": "public",
+                  "flavor_id": "m1.small",
+                  "hidden": true,
+                  "http_proxy": "http://10.164.177.169:8080",
+                  "https_proxy": "http://10.164.177.169:8080",
+                  "image_id": "Fedora-Atomic-27-20180212.2.x86_64",
+                  "keypair_id": "kp",
+                  "master_lb_enabled": true,
+                  "name": "kubernetes-dev",
+                  "network_driver": "flannel",
+                  "no_proxy": "10.0.0.0/8,172.0.0.0/8,192.0.0.0/8,localhost",
+                  "public": false,
+                  "registry_enabled": false,
+                  "server_type": "vm",
+                  "tls_disabled": false,
+                  "volume_driver": "cinder"
+                }`)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("OpenStack-API-Minimum-Version", "container-infra 1.1")
@@ -290,10 +312,10 @@ func HandleCreateClusterTemplateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleDeleteClusterSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clustertemplates/6dc6d336e3fc4c0a951b5698cd1236ee", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteClusterSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clustertemplates/6dc6d336e3fc4c0a951b5698cd1236ee", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("OpenStack-API-Minimum-Version", "container-infra 1.1")
@@ -304,10 +326,10 @@ func HandleDeleteClusterSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleListClusterTemplateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clustertemplates", func(w http.ResponseWriter, r *http.Request) {
+func HandleListClusterTemplateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clustertemplates", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -316,10 +338,10 @@ func HandleListClusterTemplateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetClusterTemplateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetClusterTemplateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -328,10 +350,10 @@ func HandleGetClusterTemplateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGetClusterTemplateEmptyTimeSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetClusterTemplateEmptyTimeSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -505,10 +527,10 @@ var ExpectedUpdateClusterTemplate_EmptyTime = clustertemplates.ClusterTemplate{
 	Hidden:          false,
 }
 
-func HandleUpdateClusterTemplateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateClusterTemplateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -517,10 +539,10 @@ func HandleUpdateClusterTemplateSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleUpdateClusterTemplateEmptyTimeSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateClusterTemplateEmptyTimeSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -529,10 +551,10 @@ func HandleUpdateClusterTemplateEmptyTimeSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleUpdateClusterTemplateInvalidUpdate(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateClusterTemplateInvalidUpdate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clustertemplates/7d85f602-a948-4a30-afd4-e84f47471c15", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusBadRequest)
diff --git a/openstack/containerinfra/v1/clustertemplates/testing/requests_test.go b/openstack/containerinfra/v1/clustertemplates/testing/requests_test.go
index 8bab4017f..4e7058dc1 100644
--- a/openstack/containerinfra/v1/clustertemplates/testing/requests_test.go
+++ b/openstack/containerinfra/v1/clustertemplates/testing/requests_test.go
@@ -7,14 +7,14 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/clustertemplates"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreateClusterTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCreateClusterTemplateSuccessfully(t)
+	HandleCreateClusterTemplateSuccessfully(t, fakeServer)
 
 	boolFalse := false
 	boolTrue := true
@@ -46,7 +46,7 @@ func TestCreateClusterTemplate(t *testing.T) {
 		Hidden:              &boolTrue,
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	res := clustertemplates.Create(context.TODO(), sc, opts)
 	th.AssertNoErr(t, res.Err)
@@ -62,12 +62,12 @@ func TestCreateClusterTemplate(t *testing.T) {
 }
 
 func TestDeleteClusterTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleDeleteClusterSuccessfully(t)
+	HandleDeleteClusterSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	res := clustertemplates.Delete(context.TODO(), sc, "6dc6d336e3fc4c0a951b5698cd1236ee")
 	th.AssertNoErr(t, res.Err)
@@ -76,14 +76,14 @@ func TestDeleteClusterTemplate(t *testing.T) {
 }
 
 func TestListClusterTemplates(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleListClusterTemplateSuccessfully(t)
+	HandleListClusterTemplateSuccessfully(t, fakeServer)
 
 	count := 0
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	err := clustertemplates.List(sc, clustertemplates.ListOpts{Limit: 2}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
@@ -104,12 +104,12 @@ func TestListClusterTemplates(t *testing.T) {
 }
 
 func TestGetClusterTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetClusterTemplateSuccessfully(t)
+	HandleGetClusterTemplateSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	actual, err := clustertemplates.Get(context.TODO(), sc, "7d85f602-a948-4a30-afd4-e84f47471c15").Extract()
 	th.AssertNoErr(t, err)
@@ -118,12 +118,12 @@ func TestGetClusterTemplate(t *testing.T) {
 }
 
 func TestGetClusterTemplateEmptyTime(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetClusterTemplateEmptyTimeSuccessfully(t)
+	HandleGetClusterTemplateEmptyTimeSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	actual, err := clustertemplates.Get(context.TODO(), sc, "7d85f602-a948-4a30-afd4-e84f47471c15").Extract()
 	th.AssertNoErr(t, err)
@@ -132,10 +132,10 @@ func TestGetClusterTemplateEmptyTime(t *testing.T) {
 }
 
 func TestUpdateClusterTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleUpdateClusterTemplateSuccessfully(t)
+	HandleUpdateClusterTemplateSuccessfully(t, fakeServer)
 
 	updateOpts := []clustertemplates.UpdateOptsBuilder{
 		clustertemplates.UpdateOpts{
@@ -150,7 +150,7 @@ func TestUpdateClusterTemplate(t *testing.T) {
 		},
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	res := clustertemplates.Update(context.TODO(), sc, "7d85f602-a948-4a30-afd4-e84f47471c15", updateOpts)
 	th.AssertNoErr(t, res.Err)
@@ -162,10 +162,10 @@ func TestUpdateClusterTemplate(t *testing.T) {
 }
 
 func TestUpdateClusterTemplateEmptyTime(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleUpdateClusterTemplateEmptyTimeSuccessfully(t)
+	HandleUpdateClusterTemplateEmptyTimeSuccessfully(t, fakeServer)
 
 	updateOpts := []clustertemplates.UpdateOptsBuilder{
 		clustertemplates.UpdateOpts{
@@ -180,7 +180,7 @@ func TestUpdateClusterTemplateEmptyTime(t *testing.T) {
 		},
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	actual, err := clustertemplates.Update(context.TODO(), sc, "7d85f602-a948-4a30-afd4-e84f47471c15", updateOpts).Extract()
 	th.AssertNoErr(t, err)
@@ -188,10 +188,10 @@ func TestUpdateClusterTemplateEmptyTime(t *testing.T) {
 }
 
 func TestUpdateClusterTemplateInvalidUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleUpdateClusterTemplateInvalidUpdate(t)
+	HandleUpdateClusterTemplateInvalidUpdate(t, fakeServer)
 
 	updateOpts := []clustertemplates.UpdateOptsBuilder{
 		clustertemplates.UpdateOpts{
@@ -208,7 +208,7 @@ func TestUpdateClusterTemplateInvalidUpdate(t *testing.T) {
 		},
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 	_, err := clustertemplates.Update(context.TODO(), sc, "7d85f602-a948-4a30-afd4-e84f47471c15", updateOpts).Extract()
 	th.AssertEquals(t, true, err != nil)
diff --git a/openstack/containerinfra/v1/nodegroups/testing/fixtures_test.go b/openstack/containerinfra/v1/nodegroups/testing/fixtures_test.go
index 90de8b6fe..95b9505c4 100644
--- a/openstack/containerinfra/v1/nodegroups/testing/fixtures_test.go
+++ b/openstack/containerinfra/v1/nodegroups/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/nodegroups"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const (
@@ -125,10 +125,10 @@ var expectedUpdatedNodeGroup = nodegroups.NodeGroup{
 	UpdatedAt:     nodeGroup2Updated,
 }
 
-func handleGetNodeGroupSuccess(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup1UUID, func(w http.ResponseWriter, r *http.Request) {
+func handleGetNodeGroupSuccess(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup1UUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -137,10 +137,10 @@ func handleGetNodeGroupSuccess(t *testing.T) {
 	})
 }
 
-func handleGetNodeGroupNotFound(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+badNodeGroupUUID, func(w http.ResponseWriter, r *http.Request) {
+func handleGetNodeGroupNotFound(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+badNodeGroupUUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusNotFound)
@@ -149,10 +149,10 @@ func handleGetNodeGroupNotFound(t *testing.T) {
 	})
 }
 
-func handleGetNodeGroupClusterNotFound(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+badClusterUUID+"/nodegroups/"+badNodeGroupUUID, func(w http.ResponseWriter, r *http.Request) {
+func handleGetNodeGroupClusterNotFound(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+badClusterUUID+"/nodegroups/"+badNodeGroupUUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusNotFound)
@@ -161,10 +161,10 @@ func handleGetNodeGroupClusterNotFound(t *testing.T) {
 	})
 }
 
-func handleListNodeGroupsSuccess(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
+func handleListNodeGroupsSuccess(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -173,10 +173,10 @@ func handleListNodeGroupsSuccess(t *testing.T) {
 	})
 }
 
-func handleListNodeGroupsLimitSuccess(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
+func handleListNodeGroupsLimitSuccess(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -187,12 +187,12 @@ func handleListNodeGroupsLimitSuccess(t *testing.T) {
 		if marker, ok := r.Form["marker"]; !ok {
 			// No marker, this is the first request.
 			th.TestFormValues(t, r, map[string]string{"limit": "1"})
-			fmt.Fprintf(w, nodeGroupListLimitResponse1, th.Endpoint())
+			fmt.Fprintf(w, nodeGroupListLimitResponse1, fakeServer.Endpoint())
 		} else {
 			switch marker[0] {
 			case nodeGroup1UUID:
 				// Marker is the UUID of the first node group, return the second.
-				fmt.Fprintf(w, nodeGroupListLimitResponse2, th.Endpoint())
+				fmt.Fprintf(w, nodeGroupListLimitResponse2, fakeServer.Endpoint())
 			case nodeGroup2UUID:
 				// Marker is the UUID of the second node group, there are no more to return.
 				fmt.Fprint(w, nodeGroupListLimitResponse3)
@@ -201,10 +201,10 @@ func handleListNodeGroupsLimitSuccess(t *testing.T) {
 	})
 }
 
-func handleListNodeGroupsClusterNotFound(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+badClusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
+func handleListNodeGroupsClusterNotFound(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+badClusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodGet)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusNotFound)
@@ -213,10 +213,10 @@ func handleListNodeGroupsClusterNotFound(t *testing.T) {
 	})
 }
 
-func handleCreateNodeGroupSuccess(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
+func handleCreateNodeGroupSuccess(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPost)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusAccepted)
@@ -225,10 +225,10 @@ func handleCreateNodeGroupSuccess(t *testing.T) {
 	})
 }
 
-func handleCreateNodeGroupDuplicate(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
+func handleCreateNodeGroupDuplicate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPost)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusConflict)
@@ -237,10 +237,10 @@ func handleCreateNodeGroupDuplicate(t *testing.T) {
 	})
 }
 
-func handleCreateNodeGroupMaster(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
+func handleCreateNodeGroupMaster(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPost)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusBadRequest)
@@ -249,10 +249,10 @@ func handleCreateNodeGroupMaster(t *testing.T) {
 	})
 }
 
-func handleCreateNodeGroupBadSizes(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
+func handleCreateNodeGroupBadSizes(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPost)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusConflict)
@@ -261,10 +261,10 @@ func handleCreateNodeGroupBadSizes(t *testing.T) {
 	})
 }
 
-func handleUpdateNodeGroupSuccess(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
+func handleUpdateNodeGroupSuccess(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPatch)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusAccepted)
@@ -273,10 +273,10 @@ func handleUpdateNodeGroupSuccess(t *testing.T) {
 	})
 }
 
-func handleUpdateNodeGroupInternal(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
+func handleUpdateNodeGroupInternal(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPatch)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusBadRequest)
@@ -285,10 +285,10 @@ func handleUpdateNodeGroupInternal(t *testing.T) {
 	})
 }
 
-func handleUpdateNodeGroupBadField(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
+func handleUpdateNodeGroupBadField(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPatch)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusBadRequest)
@@ -297,10 +297,10 @@ func handleUpdateNodeGroupBadField(t *testing.T) {
 	})
 }
 
-func handleUpdateNodeGroupBadMin(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
+func handleUpdateNodeGroupBadMin(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodPatch)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusConflict)
@@ -309,19 +309,19 @@ func handleUpdateNodeGroupBadMin(t *testing.T) {
 	})
 }
 
-func handleDeleteNodeGroupSuccess(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
+func handleDeleteNodeGroupSuccess(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodDelete)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func handleDeleteNodeGroupNotFound(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+badNodeGroupUUID, func(w http.ResponseWriter, r *http.Request) {
+func handleDeleteNodeGroupNotFound(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+badNodeGroupUUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodDelete)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusNotFound)
@@ -330,10 +330,10 @@ func handleDeleteNodeGroupNotFound(t *testing.T) {
 	})
 }
 
-func handleDeleteNodeGroupClusterNotFound(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+badClusterUUID+"/nodegroups/"+badNodeGroupUUID, func(w http.ResponseWriter, r *http.Request) {
+func handleDeleteNodeGroupClusterNotFound(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+badClusterUUID+"/nodegroups/"+badNodeGroupUUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodDelete)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusNotFound)
@@ -342,10 +342,10 @@ func handleDeleteNodeGroupClusterNotFound(t *testing.T) {
 	})
 }
 
-func handleDeleteNodeGroupDefault(t *testing.T) {
-	th.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
+func handleDeleteNodeGroupDefault(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/clusters/"+clusterUUID+"/nodegroups/"+nodeGroup2UUID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, http.MethodDelete)
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusBadRequest)
diff --git a/openstack/containerinfra/v1/nodegroups/testing/requests_test.go b/openstack/containerinfra/v1/nodegroups/testing/requests_test.go
index 6e929a2e1..0964e23b3 100644
--- a/openstack/containerinfra/v1/nodegroups/testing/requests_test.go
+++ b/openstack/containerinfra/v1/nodegroups/testing/requests_test.go
@@ -8,17 +8,17 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/nodegroups"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // TestGetNodeGroupSuccess gets a node group successfully.
 func TestGetNodeGroupSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleGetNodeGroupSuccess(t)
+	handleGetNodeGroupSuccess(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	ng, err := nodegroups.Get(context.TODO(), sc, clusterUUID, nodeGroup1UUID).Extract()
@@ -29,12 +29,12 @@ func TestGetNodeGroupSuccess(t *testing.T) {
 
 // TestGetNodeGroupNotFound tries to get a node group which does not exist.
 func TestGetNodeGroupNotFound(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleGetNodeGroupNotFound(t)
+	handleGetNodeGroupNotFound(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	_, err := nodegroups.Get(context.TODO(), sc, clusterUUID, badNodeGroupUUID).Extract()
@@ -44,12 +44,12 @@ func TestGetNodeGroupNotFound(t *testing.T) {
 // TestGetNodeGroupClusterNotFound tries to get a node group in
 // a cluster which does not exist.
 func TestGetNodeGroupClusterNotFound(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleGetNodeGroupClusterNotFound(t)
+	handleGetNodeGroupClusterNotFound(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	_, err := nodegroups.Get(context.TODO(), sc, badClusterUUID, badNodeGroupUUID).Extract()
@@ -58,12 +58,12 @@ func TestGetNodeGroupClusterNotFound(t *testing.T) {
 
 // TestListNodeGroupsSuccess lists the node groups of a cluster successfully.
 func TestListNodeGroupsSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleListNodeGroupsSuccess(t)
+	handleListNodeGroupsSuccess(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	ngPages, err := nodegroups.List(sc, clusterUUID, nodegroups.ListOpts{}).AllPages(context.TODO())
@@ -80,12 +80,12 @@ func TestListNodeGroupsSuccess(t *testing.T) {
 // with each returned page limited to one node group and
 // also giving a URL to get the next page.
 func TestListNodeGroupsLimitSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleListNodeGroupsLimitSuccess(t)
+	handleListNodeGroupsLimitSuccess(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	listOpts := nodegroups.ListOpts{Limit: 1}
@@ -102,12 +102,12 @@ func TestListNodeGroupsLimitSuccess(t *testing.T) {
 // TestListNodeGroupsClusterNotFound tries to list node groups
 // of a cluster which does not exist.
 func TestListNodeGroupsClusterNotFound(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleListNodeGroupsClusterNotFound(t)
+	handleListNodeGroupsClusterNotFound(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	_, err := nodegroups.List(sc, clusterUUID, nodegroups.ListOpts{}).AllPages(context.TODO())
@@ -116,12 +116,12 @@ func TestListNodeGroupsClusterNotFound(t *testing.T) {
 
 // TestCreateNodeGroupSuccess creates a node group successfully.
 func TestCreateNodeGroupSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleCreateNodeGroupSuccess(t)
+	handleCreateNodeGroupSuccess(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	createOpts := nodegroups.CreateOpts{
@@ -137,12 +137,12 @@ func TestCreateNodeGroupSuccess(t *testing.T) {
 // TestCreateNodeGroupDuplicate creates a node group with
 // the same name as an existing one.
 func TestCreateNodeGroupDuplicate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleCreateNodeGroupDuplicate(t)
+	handleCreateNodeGroupDuplicate(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	createOpts := nodegroups.CreateOpts{
@@ -156,12 +156,12 @@ func TestCreateNodeGroupDuplicate(t *testing.T) {
 // TestCreateNodeGroupMaster creates a node group with
 // role=master which is not allowed.
 func TestCreateNodeGroupMaster(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleCreateNodeGroupMaster(t)
+	handleCreateNodeGroupMaster(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	createOpts := nodegroups.CreateOpts{
@@ -176,12 +176,12 @@ func TestCreateNodeGroupMaster(t *testing.T) {
 // TestCreateNodeGroupBadSizes creates a node group with
 // min_nodes greater than max_nodes.
 func TestCreateNodeGroupBadSizes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleCreateNodeGroupBadSizes(t)
+	handleCreateNodeGroupBadSizes(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	maxNodes := 3
@@ -197,12 +197,12 @@ func TestCreateNodeGroupBadSizes(t *testing.T) {
 
 // TestUpdateNodeGroupSuccess updates a node group successfully.
 func TestUpdateNodeGroupSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleUpdateNodeGroupSuccess(t)
+	handleUpdateNodeGroupSuccess(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	updateOpts := []nodegroups.UpdateOptsBuilder{
@@ -221,12 +221,12 @@ func TestUpdateNodeGroupSuccess(t *testing.T) {
 // TestUpdateNodeGroupInternal tries to update an internal
 // property of the node group.
 func TestUpdateNodeGroupInternal(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleUpdateNodeGroupInternal(t)
+	handleUpdateNodeGroupInternal(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	updateOpts := []nodegroups.UpdateOptsBuilder{
@@ -244,12 +244,12 @@ func TestUpdateNodeGroupInternal(t *testing.T) {
 // TestUpdateNodeGroupBadField tries to update a
 // field of the node group that does not exist.
 func TestUpdateNodeGroupBadField(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleUpdateNodeGroupBadField(t)
+	handleUpdateNodeGroupBadField(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	updateOpts := []nodegroups.UpdateOptsBuilder{
@@ -267,12 +267,12 @@ func TestUpdateNodeGroupBadField(t *testing.T) {
 // TestUpdateNodeGroupBadMin tries to set a minimum node count
 // greater than the current node count
 func TestUpdateNodeGroupBadMin(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleUpdateNodeGroupBadMin(t)
+	handleUpdateNodeGroupBadMin(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	updateOpts := []nodegroups.UpdateOptsBuilder{
@@ -289,12 +289,12 @@ func TestUpdateNodeGroupBadMin(t *testing.T) {
 
 // TestDeleteNodeGroupSuccess deletes a node group successfully.
 func TestDeleteNodeGroupSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleDeleteNodeGroupSuccess(t)
+	handleDeleteNodeGroupSuccess(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	err := nodegroups.Delete(context.TODO(), sc, clusterUUID, nodeGroup2UUID).ExtractErr()
@@ -303,12 +303,12 @@ func TestDeleteNodeGroupSuccess(t *testing.T) {
 
 // TestDeleteNodeGroupNotFound tries to delete a node group that does not exist.
 func TestDeleteNodeGroupNotFound(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleDeleteNodeGroupNotFound(t)
+	handleDeleteNodeGroupNotFound(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	err := nodegroups.Delete(context.TODO(), sc, clusterUUID, badNodeGroupUUID).ExtractErr()
@@ -317,12 +317,12 @@ func TestDeleteNodeGroupNotFound(t *testing.T) {
 
 // TestDeleteNodeGroupClusterNotFound tries to delete a node group in a cluster that does not exist.
 func TestDeleteNodeGroupClusterNotFound(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleDeleteNodeGroupClusterNotFound(t)
+	handleDeleteNodeGroupClusterNotFound(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	err := nodegroups.Delete(context.TODO(), sc, badClusterUUID, badNodeGroupUUID).ExtractErr()
@@ -331,12 +331,12 @@ func TestDeleteNodeGroupClusterNotFound(t *testing.T) {
 
 // TestDeleteNodeGroupDefault tries to delete a protected default node group.
 func TestDeleteNodeGroupDefault(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	handleDeleteNodeGroupDefault(t)
+	handleDeleteNodeGroupDefault(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	err := nodegroups.Delete(context.TODO(), sc, clusterUUID, nodeGroup2UUID).ExtractErr()
diff --git a/openstack/containerinfra/v1/quotas/testing/fixtures_test.go b/openstack/containerinfra/v1/quotas/testing/fixtures_test.go
index 2aad3abb6..f4ead5d06 100644
--- a/openstack/containerinfra/v1/quotas/testing/fixtures_test.go
+++ b/openstack/containerinfra/v1/quotas/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const projectID = "aa5436ab58144c768ca4e9d2e9f5c3b2"
@@ -22,10 +22,10 @@ var CreateResponse = fmt.Sprintf(`
    "id": 26
 }`, projectID)
 
-func HandleCreateQuotaSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v1/quotas", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateQuotaSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v1/quotas", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.Header().Add("X-OpenStack-Request-Id", requestUUID)
diff --git a/openstack/containerinfra/v1/quotas/testing/requests_test.go b/openstack/containerinfra/v1/quotas/testing/requests_test.go
index 75dde3000..16d966cfa 100644
--- a/openstack/containerinfra/v1/quotas/testing/requests_test.go
+++ b/openstack/containerinfra/v1/quotas/testing/requests_test.go
@@ -6,14 +6,14 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/containerinfra/v1/quotas"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreateQuota(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCreateQuotaSuccessfully(t)
+	HandleCreateQuotaSuccessfully(t, fakeServer)
 
 	opts := quotas.CreateOpts{
 		ProjectID: "aa5436ab58144c768ca4e9d2e9f5c3b2",
@@ -21,7 +21,7 @@ func TestCreateQuota(t *testing.T) {
 		HardLimit: 10,
 	}
 
-	sc := fake.ServiceClient()
+	sc := client.ServiceClient(fakeServer)
 	sc.Endpoint = sc.Endpoint + "v1/"
 
 	res := quotas.Create(context.TODO(), sc, opts)
diff --git a/openstack/db/v1/configurations/testing/requests_test.go b/openstack/db/v1/configurations/testing/requests_test.go
index 49d928e94..11e14ebfb 100644
--- a/openstack/db/v1/configurations/testing/requests_test.go
+++ b/openstack/db/v1/configurations/testing/requests_test.go
@@ -8,7 +8,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/db/v1/instances"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 	"github.com/gophercloud/gophercloud/v2/testhelper/fixture"
 )
 
@@ -27,12 +27,12 @@ var (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, _baseURL, "GET", "", ListConfigsJSON, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, _baseURL, "GET", "", ListConfigsJSON, 200)
 
 	count := 0
-	err := configurations.List(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := configurations.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := configurations.ExtractConfigs(page)
 		th.AssertNoErr(t, err)
@@ -48,19 +48,19 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, resURL, "GET", "", GetConfigJSON, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, resURL, "GET", "", GetConfigJSON, 200)
 
-	config, err := configurations.Get(context.TODO(), fake.ServiceClient(), configID).Extract()
+	config, err := configurations.Get(context.TODO(), client.ServiceClient(fakeServer), configID).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, &ExampleConfig, config)
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, _baseURL, "POST", CreateReq, CreateConfigJSON, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, _baseURL, "POST", CreateReq, CreateConfigJSON, 200)
 
 	opts := configurations.CreateOpts{
 		Datastore: &configurations.DatastoreOpts{
@@ -75,15 +75,15 @@ func TestCreate(t *testing.T) {
 		},
 	}
 
-	config, err := configurations.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	config, err := configurations.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, &ExampleConfigWithValues, config)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, resURL, "PATCH", UpdateReq, "", 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, resURL, "PATCH", UpdateReq, "", 200)
 
 	opts := configurations.UpdateOpts{
 		Values: map[string]any{
@@ -91,14 +91,14 @@ func TestUpdate(t *testing.T) {
 		},
 	}
 
-	err := configurations.Update(context.TODO(), fake.ServiceClient(), configID, opts).ExtractErr()
+	err := configurations.Update(context.TODO(), client.ServiceClient(fakeServer), configID, opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestReplace(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, resURL, "PUT", UpdateReq, "", 202)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, resURL, "PUT", UpdateReq, "", 202)
 
 	opts := configurations.UpdateOpts{
 		Values: map[string]any{
@@ -106,23 +106,23 @@ func TestReplace(t *testing.T) {
 		},
 	}
 
-	err := configurations.Replace(context.TODO(), fake.ServiceClient(), configID, opts).ExtractErr()
+	err := configurations.Replace(context.TODO(), client.ServiceClient(fakeServer), configID, opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, resURL, "DELETE", "", "", 202)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, resURL, "DELETE", "", "", 202)
 
-	err := configurations.Delete(context.TODO(), fake.ServiceClient(), configID).ExtractErr()
+	err := configurations.Delete(context.TODO(), client.ServiceClient(fakeServer), configID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListInstances(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, resURL+"/instances", "GET", "", ListInstancesJSON, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, resURL+"/instances", "GET", "", ListInstancesJSON, 200)
 
 	expectedInstance := instances.Instance{
 		ID:   "d4603f69-ec7e-4e9b-803f-600b9205576f",
@@ -130,7 +130,7 @@ func TestListInstances(t *testing.T) {
 	}
 
 	pages := 0
-	err := configurations.ListInstances(fake.ServiceClient(), configID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := configurations.ListInstances(client.ServiceClient(fakeServer), configID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := instances.ExtractInstances(page)
@@ -148,12 +148,12 @@ func TestListInstances(t *testing.T) {
 }
 
 func TestListDSParams(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, dsParamListURL, "GET", "", ListParamsJSON, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, dsParamListURL, "GET", "", ListParamsJSON, 200)
 
 	pages := 0
-	err := configurations.ListDatastoreParams(fake.ServiceClient(), dsID, versionID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := configurations.ListDatastoreParams(client.ServiceClient(fakeServer), dsID, versionID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := configurations.ExtractParams(page)
@@ -178,11 +178,11 @@ func TestListDSParams(t *testing.T) {
 }
 
 func TestGetDSParam(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, dsParamGetURL, "GET", "", GetParamJSON, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, dsParamGetURL, "GET", "", GetParamJSON, 200)
 
-	param, err := configurations.GetDatastoreParam(context.TODO(), fake.ServiceClient(), dsID, versionID, paramID).Extract()
+	param, err := configurations.GetDatastoreParam(context.TODO(), client.ServiceClient(fakeServer), dsID, versionID, paramID).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &configurations.Param{
@@ -193,12 +193,12 @@ func TestGetDSParam(t *testing.T) {
 }
 
 func TestListGlobalParams(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, globalParamListURL, "GET", "", ListParamsJSON, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, globalParamListURL, "GET", "", ListParamsJSON, 200)
 
 	pages := 0
-	err := configurations.ListGlobalParams(fake.ServiceClient(), versionID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := configurations.ListGlobalParams(client.ServiceClient(fakeServer), versionID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := configurations.ExtractParams(page)
@@ -223,11 +223,11 @@ func TestListGlobalParams(t *testing.T) {
 }
 
 func TestGetGlobalParam(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, globalParamGetURL, "GET", "", GetParamJSON, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, globalParamGetURL, "GET", "", GetParamJSON, 200)
 
-	param, err := configurations.GetGlobalParam(context.TODO(), fake.ServiceClient(), versionID, paramID).Extract()
+	param, err := configurations.GetGlobalParam(context.TODO(), client.ServiceClient(fakeServer), versionID, paramID).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &configurations.Param{
diff --git a/openstack/db/v1/databases/testing/fixtures_test.go b/openstack/db/v1/databases/testing/fixtures_test.go
index b7362c086..bedeeacab 100644
--- a/openstack/db/v1/databases/testing/fixtures_test.go
+++ b/openstack/db/v1/databases/testing/fixtures_test.go
@@ -3,6 +3,7 @@ package testing
 import (
 	"testing"
 
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/fixture"
 )
 
@@ -48,14 +49,14 @@ var listDBsResp = `
 }
 `
 
-func HandleCreate(t *testing.T) {
-	fixture.SetupHandler(t, resURL, "POST", createDBsReq, "", 202)
+func HandleCreate(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL, "POST", createDBsReq, "", 202)
 }
 
-func HandleList(t *testing.T) {
-	fixture.SetupHandler(t, resURL, "GET", "", listDBsResp, 200)
+func HandleList(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL, "GET", "", listDBsResp, 200)
 }
 
-func HandleDelete(t *testing.T) {
-	fixture.SetupHandler(t, resURL+"/{dbName}", "DELETE", "", "", 202)
+func HandleDelete(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL+"/{dbName}", "DELETE", "", "", 202)
 }
diff --git a/openstack/db/v1/databases/testing/requests_test.go b/openstack/db/v1/databases/testing/requests_test.go
index d509a7f1a..d5d39f60e 100644
--- a/openstack/db/v1/databases/testing/requests_test.go
+++ b/openstack/db/v1/databases/testing/requests_test.go
@@ -7,27 +7,27 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/db/v1/databases"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreate(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreate(t, fakeServer)
 
 	opts := databases.BatchCreateOpts{
 		databases.CreateOpts{Name: "testingdb", CharSet: "utf8", Collate: "utf8_general_ci"},
 		databases.CreateOpts{Name: "sampledb"},
 	}
 
-	res := databases.Create(context.TODO(), fake.ServiceClient(), instanceID, opts)
+	res := databases.Create(context.TODO(), client.ServiceClient(fakeServer), instanceID, opts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleList(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleList(t, fakeServer)
 
 	expectedDBs := []databases.Database{
 		{Name: "anotherexampledb"},
@@ -38,7 +38,7 @@ func TestList(t *testing.T) {
 	}
 
 	pages := 0
-	err := databases.List(fake.ServiceClient(), instanceID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := databases.List(client.ServiceClient(fakeServer), instanceID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := databases.ExtractDBs(page)
@@ -59,10 +59,10 @@ func TestList(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDelete(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDelete(t, fakeServer)
 
-	err := databases.Delete(context.TODO(), fake.ServiceClient(), instanceID, "{dbName}").ExtractErr()
+	err := databases.Delete(context.TODO(), client.ServiceClient(fakeServer), instanceID, "{dbName}").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/db/v1/datastores/testing/requests_test.go b/openstack/db/v1/datastores/testing/requests_test.go
index 47e3dbfae..e902a6f25 100644
--- a/openstack/db/v1/datastores/testing/requests_test.go
+++ b/openstack/db/v1/datastores/testing/requests_test.go
@@ -7,18 +7,18 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/db/v1/datastores"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 	"github.com/gophercloud/gophercloud/v2/testhelper/fixture"
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, "/datastores", "GET", "", ListDSResp, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, "/datastores", "GET", "", ListDSResp, 200)
 
 	pages := 0
 
-	err := datastores.List(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := datastores.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := datastores.ExtractDatastores(page)
@@ -36,23 +36,23 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, "/datastores/{dsID}", "GET", "", GetDSResp, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, "/datastores/{dsID}", "GET", "", GetDSResp, 200)
 
-	ds, err := datastores.Get(context.TODO(), fake.ServiceClient(), "{dsID}").Extract()
+	ds, err := datastores.Get(context.TODO(), client.ServiceClient(fakeServer), "{dsID}").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, &ExampleDatastore, ds)
 }
 
 func TestListVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, "/datastores/{dsID}/versions", "GET", "", ListVersionsResp, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, "/datastores/{dsID}/versions", "GET", "", ListVersionsResp, 200)
 
 	pages := 0
 
-	err := datastores.ListVersions(fake.ServiceClient(), "{dsID}").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := datastores.ListVersions(client.ServiceClient(fakeServer), "{dsID}").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := datastores.ExtractVersions(page)
@@ -70,11 +70,11 @@ func TestListVersions(t *testing.T) {
 }
 
 func TestGetVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	fixture.SetupHandler(t, "/datastores/{dsID}/versions/{versionID}", "GET", "", GetVersionResp, 200)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fixture.SetupHandler(t, fakeServer, "/datastores/{dsID}/versions/{versionID}", "GET", "", GetVersionResp, 200)
 
-	ds, err := datastores.GetVersion(context.TODO(), fake.ServiceClient(), "{dsID}", "{versionID}").Extract()
+	ds, err := datastores.GetVersion(context.TODO(), client.ServiceClient(fakeServer), "{dsID}", "{versionID}").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, &ExampleVersion1, ds)
 }
diff --git a/openstack/db/v1/flavors/testing/fixtures_test.go b/openstack/db/v1/flavors/testing/fixtures_test.go
index 048b23592..8ba73b8eb 100644
--- a/openstack/db/v1/flavors/testing/fixtures_test.go
+++ b/openstack/db/v1/flavors/testing/fixtures_test.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"testing"
 
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/fixture"
 )
 
@@ -43,10 +44,10 @@ var (
 	getFlavorResp   = fmt.Sprintf(`{"flavor": %s}`, flavor1)
 )
 
-func HandleList(t *testing.T) {
-	fixture.SetupHandler(t, _baseURL, "GET", "", listFlavorsResp, 200)
+func HandleList(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, _baseURL, "GET", "", listFlavorsResp, 200)
 }
 
-func HandleGet(t *testing.T) {
-	fixture.SetupHandler(t, resURL, "GET", "", getFlavorResp, 200)
+func HandleGet(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL, "GET", "", getFlavorResp, 200)
 }
diff --git a/openstack/db/v1/flavors/testing/requests_test.go b/openstack/db/v1/flavors/testing/requests_test.go
index c4a419627..a1a9ecd3e 100644
--- a/openstack/db/v1/flavors/testing/requests_test.go
+++ b/openstack/db/v1/flavors/testing/requests_test.go
@@ -8,16 +8,16 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/db/v1/flavors"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestListFlavors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleList(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleList(t, fakeServer)
 
 	pages := 0
-	err := flavors.List(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := flavors.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := flavors.ExtractFlavors(page)
@@ -87,11 +87,11 @@ func TestListFlavors(t *testing.T) {
 }
 
 func TestGetFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGet(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGet(t, fakeServer)
 
-	actual, err := flavors.Get(context.TODO(), fake.ServiceClient(), flavorID).Extract()
+	actual, err := flavors.Get(context.TODO(), client.ServiceClient(fakeServer), flavorID).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &flavors.Flavor{
diff --git a/openstack/db/v1/instances/testing/fixtures_test.go b/openstack/db/v1/instances/testing/fixtures_test.go
index dc3b9dc0d..f31c2f5e2 100644
--- a/openstack/db/v1/instances/testing/fixtures_test.go
+++ b/openstack/db/v1/instances/testing/fixtures_test.go
@@ -8,6 +8,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/db/v1/datastores"
 	"github.com/gophercloud/gophercloud/v2/openstack/db/v1/instances"
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/fixture"
 )
 
@@ -285,50 +286,50 @@ var expectedInstanceWithFault = instances.Instance{
 	},
 }
 
-func HandleCreate(t *testing.T) {
-	fixture.SetupHandler(t, rootURL, "POST", createReq, createResp, 200)
+func HandleCreate(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, rootURL, "POST", createReq, createResp, 200)
 }
 
-func HandleCreateWithFault(t *testing.T) {
-	fixture.SetupHandler(t, rootURL, "POST", createReq, createWithFaultResp, 200)
+func HandleCreateWithFault(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, rootURL, "POST", createReq, createWithFaultResp, 200)
 }
 
-func HandleList(t *testing.T) {
-	fixture.SetupHandler(t, rootURL, "GET", "", listInstancesResp, 200)
+func HandleList(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, rootURL, "GET", "", listInstancesResp, 200)
 }
 
-func HandleGet(t *testing.T) {
-	fixture.SetupHandler(t, resURL, "GET", "", getInstanceResp, 200)
+func HandleGet(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL, "GET", "", getInstanceResp, 200)
 }
 
-func HandleDelete(t *testing.T) {
-	fixture.SetupHandler(t, resURL, "DELETE", "", "", 202)
+func HandleDelete(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL, "DELETE", "", "", 202)
 }
 
-func HandleEnableRoot(t *testing.T) {
-	fixture.SetupHandler(t, uRootURL, "POST", "", enableUserResp, 200)
+func HandleEnableRoot(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, uRootURL, "POST", "", enableUserResp, 200)
 }
 
-func HandleIsRootEnabled(t *testing.T) {
-	fixture.SetupHandler(t, uRootURL, "GET", "", isUserEnabledResp, 200)
+func HandleIsRootEnabled(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, uRootURL, "GET", "", isUserEnabledResp, 200)
 }
 
-func HandleRestart(t *testing.T) {
-	fixture.SetupHandler(t, aURL, "POST", restartReq, "", 202)
+func HandleRestart(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, aURL, "POST", restartReq, "", 202)
 }
 
-func HandleResize(t *testing.T) {
-	fixture.SetupHandler(t, aURL, "POST", resizeReq, "", 202)
+func HandleResize(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, aURL, "POST", resizeReq, "", 202)
 }
 
-func HandleResizeVol(t *testing.T) {
-	fixture.SetupHandler(t, aURL, "POST", resizeVolReq, "", 202)
+func HandleResizeVol(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, aURL, "POST", resizeVolReq, "", 202)
 }
 
-func HandleAttachConfigurationGroup(t *testing.T) {
-	fixture.SetupHandler(t, resURL, "PUT", attachConfigurationGroupReq, "", 202)
+func HandleAttachConfigurationGroup(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL, "PUT", attachConfigurationGroupReq, "", 202)
 }
 
-func HandleDetachConfigurationGroup(t *testing.T) {
-	fixture.SetupHandler(t, resURL, "PUT", detachConfigurationGroupReq, "", 202)
+func HandleDetachConfigurationGroup(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL, "PUT", detachConfigurationGroupReq, "", 202)
 }
diff --git a/openstack/db/v1/instances/testing/requests_test.go b/openstack/db/v1/instances/testing/requests_test.go
index 1e08a796a..b7278bf8d 100644
--- a/openstack/db/v1/instances/testing/requests_test.go
+++ b/openstack/db/v1/instances/testing/requests_test.go
@@ -9,13 +9,13 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/db/v1/users"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreate(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreate(t, fakeServer)
 
 	opts := instances.CreateOpts{
 		AvailabilityZone: "us-east1",
@@ -39,16 +39,16 @@ func TestCreate(t *testing.T) {
 		VolumeType: "ssd",
 	}
 
-	instance, err := instances.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	instance, err := instances.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, &expectedInstance, instance)
 }
 
 func TestCreateWithFault(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateWithFault(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateWithFault(t, fakeServer)
 
 	opts := instances.CreateOpts{
 		AvailabilityZone: "us-east1",
@@ -72,19 +72,19 @@ func TestCreateWithFault(t *testing.T) {
 		VolumeType: "ssd",
 	}
 
-	instance, err := instances.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	instance, err := instances.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, &expectedInstanceWithFault, instance)
 }
 
 func TestInstanceList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleList(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleList(t, fakeServer)
 
 	pages := 0
-	err := instances.List(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := instances.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := instances.ExtractInstances(page)
@@ -101,89 +101,89 @@ func TestInstanceList(t *testing.T) {
 }
 
 func TestGetInstance(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGet(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGet(t, fakeServer)
 
-	instance, err := instances.Get(context.TODO(), fake.ServiceClient(), instanceID).Extract()
+	instance, err := instances.Get(context.TODO(), client.ServiceClient(fakeServer), instanceID).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, &expectedGetInstance, instance)
 }
 
 func TestDeleteInstance(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDelete(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDelete(t, fakeServer)
 
-	res := instances.Delete(context.TODO(), fake.ServiceClient(), instanceID)
+	res := instances.Delete(context.TODO(), client.ServiceClient(fakeServer), instanceID)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestEnableRootUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleEnableRoot(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleEnableRoot(t, fakeServer)
 
 	expected := &users.User{Name: "root", Password: "secretsecret"}
-	user, err := instances.EnableRootUser(context.TODO(), fake.ServiceClient(), instanceID).Extract()
+	user, err := instances.EnableRootUser(context.TODO(), client.ServiceClient(fakeServer), instanceID).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expected, user)
 }
 
 func TestIsRootEnabled(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleIsRootEnabled(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleIsRootEnabled(t, fakeServer)
 
-	isEnabled, err := instances.IsRootEnabled(context.TODO(), fake.ServiceClient(), instanceID).Extract()
+	isEnabled, err := instances.IsRootEnabled(context.TODO(), client.ServiceClient(fakeServer), instanceID).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, true, isEnabled)
 }
 
 func TestRestart(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRestart(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRestart(t, fakeServer)
 
-	res := instances.Restart(context.TODO(), fake.ServiceClient(), instanceID)
+	res := instances.Restart(context.TODO(), client.ServiceClient(fakeServer), instanceID)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestResize(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleResize(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleResize(t, fakeServer)
 
-	res := instances.Resize(context.TODO(), fake.ServiceClient(), instanceID, "2")
+	res := instances.Resize(context.TODO(), client.ServiceClient(fakeServer), instanceID, "2")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestResizeVolume(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleResizeVol(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleResizeVol(t, fakeServer)
 
-	res := instances.ResizeVolume(context.TODO(), fake.ServiceClient(), instanceID, 4)
+	res := instances.ResizeVolume(context.TODO(), client.ServiceClient(fakeServer), instanceID, 4)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestAttachConfigurationGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAttachConfigurationGroup(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAttachConfigurationGroup(t, fakeServer)
 
-	res := instances.AttachConfigurationGroup(context.TODO(), fake.ServiceClient(), instanceID, configGroupID)
+	res := instances.AttachConfigurationGroup(context.TODO(), client.ServiceClient(fakeServer), instanceID, configGroupID)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestDetachConfigurationGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDetachConfigurationGroup(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDetachConfigurationGroup(t, fakeServer)
 
-	res := instances.DetachConfigurationGroup(context.TODO(), fake.ServiceClient(), instanceID)
+	res := instances.DetachConfigurationGroup(context.TODO(), client.ServiceClient(fakeServer), instanceID)
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/db/v1/quotas/testing/fixtures_test.go b/openstack/db/v1/quotas/testing/fixtures_test.go
index 6e19a51b4..e2fe2a285 100644
--- a/openstack/db/v1/quotas/testing/fixtures_test.go
+++ b/openstack/db/v1/quotas/testing/fixtures_test.go
@@ -3,6 +3,7 @@ package testing
 import (
 	"testing"
 
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/fixture"
 )
 
@@ -37,6 +38,6 @@ var getQuotasResp = `
 }
 `
 
-func HandleGet(t *testing.T) {
-	fixture.SetupHandler(t, resURL, "GET", "", getQuotasResp, 200)
+func HandleGet(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, resURL, "GET", "", getQuotasResp, 200)
 }
diff --git a/openstack/db/v1/quotas/testing/requests_test.go b/openstack/db/v1/quotas/testing/requests_test.go
index 31009b5d9..ed52125e3 100644
--- a/openstack/db/v1/quotas/testing/requests_test.go
+++ b/openstack/db/v1/quotas/testing/requests_test.go
@@ -10,9 +10,9 @@ import (
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGet(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGet(t, fakeServer)
 
 	expectedQuotas := []quotas.QuotaDetail{
 		{Resource: "instances", Limit: 15, InUse: 5, Reserved: 0},
@@ -20,7 +20,7 @@ func TestGet(t *testing.T) {
 		{Resource: "volumes", Limit: 40, InUse: 1, Reserved: 0},
 	}
 
-	actual, err := quotas.Get(context.TODO(), client.ServiceClient(), "e131f89a-c1d8-11ef-bfaa-370c246e2439").Extract()
+	actual, err := quotas.Get(context.TODO(), client.ServiceClient(fakeServer), "e131f89a-c1d8-11ef-bfaa-370c246e2439").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expectedQuotas, actual)
 }
diff --git a/openstack/db/v1/users/testing/fixtures_test.go b/openstack/db/v1/users/testing/fixtures_test.go
index 961e4f6ec..db758d804 100644
--- a/openstack/db/v1/users/testing/fixtures_test.go
+++ b/openstack/db/v1/users/testing/fixtures_test.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"testing"
 
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/fixture"
 )
 
@@ -24,14 +25,14 @@ var (
 	listResp   = fmt.Sprintf(`{"users":[%s, %s]}`, fmt.Sprintf(user1, ""), fmt.Sprintf(user2, ""))
 )
 
-func HandleCreate(t *testing.T) {
-	fixture.SetupHandler(t, _rootURL, "POST", createReq, "", 202)
+func HandleCreate(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, _rootURL, "POST", createReq, "", 202)
 }
 
-func HandleList(t *testing.T) {
-	fixture.SetupHandler(t, _rootURL, "GET", "", listResp, 200)
+func HandleList(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, _rootURL, "GET", "", listResp, 200)
 }
 
-func HandleDelete(t *testing.T) {
-	fixture.SetupHandler(t, _rootURL+"/{userName}", "DELETE", "", "", 202)
+func HandleDelete(t *testing.T, fakeServer th.FakeServer) {
+	fixture.SetupHandler(t, fakeServer, _rootURL+"/{userName}", "DELETE", "", "", 202)
 }
diff --git a/openstack/db/v1/users/testing/requests_test.go b/openstack/db/v1/users/testing/requests_test.go
index 40713f544..33665061e 100644
--- a/openstack/db/v1/users/testing/requests_test.go
+++ b/openstack/db/v1/users/testing/requests_test.go
@@ -8,13 +8,13 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/db/v1/users"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreate(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreate(t, fakeServer)
 
 	opts := users.BatchCreateOpts{
 		{
@@ -34,14 +34,14 @@ func TestCreate(t *testing.T) {
 		},
 	}
 
-	res := users.Create(context.TODO(), fake.ServiceClient(), instanceID, opts)
+	res := users.Create(context.TODO(), client.ServiceClient(fakeServer), instanceID, opts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUserList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleList(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleList(t, fakeServer)
 
 	expectedUsers := []users.User{
 		{
@@ -60,7 +60,7 @@ func TestUserList(t *testing.T) {
 	}
 
 	pages := 0
-	err := users.List(fake.ServiceClient(), instanceID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := users.List(client.ServiceClient(fakeServer), instanceID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := users.ExtractUsers(page)
@@ -77,10 +77,10 @@ func TestUserList(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDelete(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDelete(t, fakeServer)
 
-	res := users.Delete(context.TODO(), fake.ServiceClient(), instanceID, "{userName}")
+	res := users.Delete(context.TODO(), client.ServiceClient(fakeServer), instanceID, "{userName}")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/dns/v2/recordsets/testing/fixtures_test.go b/openstack/dns/v2/recordsets/testing/fixtures_test.go
index 71d1d0898..42a6c0d6e 100644
--- a/openstack/dns/v2/recordsets/testing/fixtures_test.go
+++ b/openstack/dns/v2/recordsets/testing/fixtures_test.go
@@ -200,8 +200,8 @@ var ExpectedRecordSetSlice = []recordsets.RecordSet{FirstRecordSet, SecondRecord
 var ExpectedRecordSetSliceLimited = []recordsets.RecordSet{SecondRecordSet}
 
 // HandleListByZoneSuccessfully configures the test server to respond to a ListByZone request.
-func HandleListByZoneSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets", func(w http.ResponseWriter, r *http.Request) {
+func HandleListByZoneSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -220,8 +220,8 @@ func HandleListByZoneSuccessfully(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a Get request.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets/f7b10e9b-0cae-4a91-b162-562bc6096648",
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets/f7b10e9b-0cae-4a91-b162-562bc6096648",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -273,8 +273,8 @@ const CreateRecordSetResponse = `
 var CreatedRecordSet = FirstRecordSet
 
 // HandleZoneCreationSuccessfully configures the test server to respond to a Create request.
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets",
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -325,8 +325,8 @@ const UpdateRecordSetResponse = `
 `
 
 // HandleUpdateSuccessfully configures the test server to respond to an Update request.
-func HandleUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets/f7b10e9b-0cae-4a91-b162-562bc6096648",
+func HandleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets/f7b10e9b-0cae-4a91-b162-562bc6096648",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PUT")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -365,8 +365,8 @@ const DeleteRecordSetResponse = `
 `
 
 // HandleDeleteSuccessfully configures the test server to respond to an Delete request.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets/f7b10e9b-0cae-4a91-b162-562bc6096648",
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones/2150b1bf-dee2-4221-9d85-11f7886fb15f/recordsets/f7b10e9b-0cae-4a91-b162-562bc6096648",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
diff --git a/openstack/dns/v2/recordsets/testing/requests_test.go b/openstack/dns/v2/recordsets/testing/requests_test.go
index 0c2a51b21..fb06587f8 100644
--- a/openstack/dns/v2/recordsets/testing/requests_test.go
+++ b/openstack/dns/v2/recordsets/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestListByZone(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListByZoneSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListByZoneSuccessfully(t, fakeServer)
 
 	count := 0
-	err := recordsets.ListByZone(client.ServiceClient(), "2150b1bf-dee2-4221-9d85-11f7886fb15f", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := recordsets.ListByZone(client.ServiceClient(fakeServer), "2150b1bf-dee2-4221-9d85-11f7886fb15f", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := recordsets.ExtractRecordSets(page)
 		th.AssertNoErr(t, err)
@@ -30,16 +30,16 @@ func TestListByZone(t *testing.T) {
 }
 
 func TestListByZoneLimited(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListByZoneSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListByZoneSuccessfully(t, fakeServer)
 
 	count := 0
 	listOpts := recordsets.ListOpts{
 		Limit:  1,
 		Marker: "f7b10e9b-0cae-4a91-b162-562bc6096648",
 	}
-	err := recordsets.ListByZone(client.ServiceClient(), "2150b1bf-dee2-4221-9d85-11f7886fb15f", listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := recordsets.ListByZone(client.ServiceClient(fakeServer), "2150b1bf-dee2-4221-9d85-11f7886fb15f", listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := recordsets.ExtractRecordSets(page)
 		th.AssertNoErr(t, err)
@@ -52,11 +52,11 @@ func TestListByZoneLimited(t *testing.T) {
 }
 
 func TestListByZoneAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListByZoneSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListByZoneSuccessfully(t, fakeServer)
 
-	allPages, err := recordsets.ListByZone(client.ServiceClient(), "2150b1bf-dee2-4221-9d85-11f7886fb15f", nil).AllPages(context.TODO())
+	allPages, err := recordsets.ListByZone(client.ServiceClient(fakeServer), "2150b1bf-dee2-4221-9d85-11f7886fb15f", nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	allRecordSets, err := recordsets.ExtractRecordSets(allPages)
 	th.AssertNoErr(t, err)
@@ -64,11 +64,11 @@ func TestListByZoneAllPages(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := recordsets.Get(context.TODO(), client.ServiceClient(), "2150b1bf-dee2-4221-9d85-11f7886fb15f", "f7b10e9b-0cae-4a91-b162-562bc6096648").Extract()
+	actual, err := recordsets.Get(context.TODO(), client.ServiceClient(fakeServer), "2150b1bf-dee2-4221-9d85-11f7886fb15f", "f7b10e9b-0cae-4a91-b162-562bc6096648").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstRecordSet, actual)
 }
@@ -88,9 +88,9 @@ func TestNextPageURL(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
 	createOpts := recordsets.CreateOpts{
 		Name:        "example.org.",
@@ -100,15 +100,15 @@ func TestCreate(t *testing.T) {
 		Records:     []string{"10.1.0.2"},
 	}
 
-	actual, err := recordsets.Create(context.TODO(), client.ServiceClient(), "2150b1bf-dee2-4221-9d85-11f7886fb15f", createOpts).Extract()
+	actual, err := recordsets.Create(context.TODO(), client.ServiceClient(fakeServer), "2150b1bf-dee2-4221-9d85-11f7886fb15f", createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &CreatedRecordSet, actual)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
 	var description = "Updated description"
 	ttl := 0
@@ -125,15 +125,15 @@ func TestUpdate(t *testing.T) {
 	UpdatedRecordSet.Records = []string{"10.1.0.2", "10.1.0.3"}
 	UpdatedRecordSet.Version = 2
 
-	actual, err := recordsets.Update(context.TODO(), client.ServiceClient(), UpdatedRecordSet.ZoneID, UpdatedRecordSet.ID, updateOpts).Extract()
+	actual, err := recordsets.Update(context.TODO(), client.ServiceClient(fakeServer), UpdatedRecordSet.ZoneID, UpdatedRecordSet.ID, updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &UpdatedRecordSet, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
 	DeletedRecordSet := CreatedRecordSet
 	DeletedRecordSet.Status = "PENDING"
@@ -142,7 +142,7 @@ func TestDelete(t *testing.T) {
 	DeletedRecordSet.Records = []string{"10.1.0.2", "10.1.0.3"}
 	DeletedRecordSet.Version = 2
 
-	err := recordsets.Delete(context.TODO(), client.ServiceClient(), DeletedRecordSet.ZoneID, DeletedRecordSet.ID).ExtractErr()
+	err := recordsets.Delete(context.TODO(), client.ServiceClient(fakeServer), DeletedRecordSet.ZoneID, DeletedRecordSet.ID).ExtractErr()
 	th.AssertNoErr(t, err)
 	//th.CheckDeepEquals(t, &DeletedZone, actual)
 }
diff --git a/openstack/dns/v2/transfer/accept/testing/accepts_test.go b/openstack/dns/v2/transfer/accept/testing/accepts_test.go
index db868bd77..1261cd158 100644
--- a/openstack/dns/v2/transfer/accept/testing/accepts_test.go
+++ b/openstack/dns/v2/transfer/accept/testing/accepts_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	count := 0
-	err := transferAccepts.List(client.ServiceClient(), nil).EachPage(
+	err := transferAccepts.List(client.ServiceClient(fakeServer), nil).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -30,15 +30,15 @@ func TestList(t *testing.T) {
 }
 
 func TestListWithOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFilteredListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFilteredListSuccessfully(t, fakeServer)
 
 	listOpts := transferAccepts.ListOpts{
 		Status: "ACTIVE",
 	}
 
-	allPages, err := transferAccepts.List(client.ServiceClient(), listOpts).AllPages(context.TODO())
+	allPages, err := transferAccepts.List(client.ServiceClient(fakeServer), listOpts).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	allTransferAccepts, err := transferAccepts.ExtractTransferAccepts(allPages)
 	th.AssertNoErr(t, err)
@@ -46,11 +46,11 @@ func TestListWithOpts(t *testing.T) {
 }
 
 func TestListAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
-	allPages, err := transferAccepts.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := transferAccepts.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	allTransferAccepts, err := transferAccepts.ExtractTransferAccepts(allPages)
 	th.AssertNoErr(t, err)
@@ -58,20 +58,20 @@ func TestListAllPages(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
 	actual, err := transferAccepts.Get(
-		context.TODO(), client.ServiceClient(), "92236f39-0fad-4f8f-bf25-fbdf027de34d").Extract()
+		context.TODO(), client.ServiceClient(fakeServer), "92236f39-0fad-4f8f-bf25-fbdf027de34d").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstTransferAccept, actual)
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
 	createOpts := transferAccepts.CreateOpts{
 		Key:                   "M2KA0Y20",
@@ -79,7 +79,7 @@ func TestCreate(t *testing.T) {
 	}
 
 	actual, err := transferAccepts.Create(
-		context.TODO(), client.ServiceClient(), createOpts).Extract()
+		context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &CreatedTransferAccept, actual)
 }
diff --git a/openstack/dns/v2/transfer/accept/testing/fixtures_test.go b/openstack/dns/v2/transfer/accept/testing/fixtures_test.go
index 3dae54e6a..4ef02e748 100644
--- a/openstack/dns/v2/transfer/accept/testing/fixtures_test.go
+++ b/openstack/dns/v2/transfer/accept/testing/fixtures_test.go
@@ -126,9 +126,9 @@ var SecondTransferAccept = transferAccepts.TransferAccept{
 var ExpectedTransferAcceptSlice = []transferAccepts.TransferAccept{FirstTransferAccept, SecondTransferAccept}
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	baseURL := "/zones/tasks/transfer_accepts"
-	th.Mux.HandleFunc(baseURL,
+	fakeServer.Mux.HandleFunc(baseURL,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -138,9 +138,9 @@ func HandleListSuccessfully(t *testing.T) {
 }
 
 // HandleFilteredListSuccessfully configures the test server to respond to a List request with Opts.
-func HandleFilteredListSuccessfully(t *testing.T) {
+func HandleFilteredListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	baseURL := "/zones/tasks/transfer_accepts"
-	th.Mux.HandleFunc(baseURL,
+	fakeServer.Mux.HandleFunc(baseURL,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -150,9 +150,9 @@ func HandleFilteredListSuccessfully(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a List request.
-func HandleGetSuccessfully(t *testing.T) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	baseURL := "/zones/tasks/transfer_accepts"
-	th.Mux.HandleFunc(s.Join([]string{baseURL, FirstTransferAccept.ID}, "/"),
+	fakeServer.Mux.HandleFunc(s.Join([]string{baseURL, FirstTransferAccept.ID}, "/"),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -190,9 +190,9 @@ const CreateTransferAcceptResponse = `
 var CreatedTransferAccept = FirstTransferAccept
 
 // HandleTransferRequestCreationSuccessfully configures the test server to respond to a Create request.
-func HandleCreateSuccessfully(t *testing.T) {
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	baseURL := "/zones/tasks/transfer_accepts"
-	th.Mux.HandleFunc(baseURL,
+	fakeServer.Mux.HandleFunc(baseURL,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
diff --git a/openstack/dns/v2/transfer/request/testing/fixtures_test.go b/openstack/dns/v2/transfer/request/testing/fixtures_test.go
index 3de1f2aca..52ed6b6d3 100644
--- a/openstack/dns/v2/transfer/request/testing/fixtures_test.go
+++ b/openstack/dns/v2/transfer/request/testing/fixtures_test.go
@@ -112,9 +112,9 @@ var SecondTransferRequest = transferRequests.TransferRequest{
 var ExpectedTransferRequestsSlice = []transferRequests.TransferRequest{FirstTransferRequest, SecondTransferRequest}
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	baseURL := "/zones/tasks/transfer_requests"
-	th.Mux.HandleFunc(baseURL,
+	fakeServer.Mux.HandleFunc(baseURL,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -124,9 +124,9 @@ func HandleListSuccessfully(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a List request.
-func HandleGetSuccessfully(t *testing.T) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	baseURL := "/zones/tasks/transfer_requests"
-	th.Mux.HandleFunc(s.Join([]string{baseURL, FirstTransferRequest.ID}, "/"),
+	fakeServer.Mux.HandleFunc(s.Join([]string{baseURL, FirstTransferRequest.ID}, "/"),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -165,9 +165,9 @@ const CreateTransferRequestResponse = `
 var CreatedTransferRequest = FirstTransferRequest
 
 // HandleTransferRequestCreationSuccessfully configures the test server to respond to a Create request.
-func HandleCreateSuccessfully(t *testing.T) {
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	createURL := "/zones/a6a8515c-5d80-48c0-955b-fde631b59791/tasks/transfer_requests"
-	th.Mux.HandleFunc(createURL,
+	fakeServer.Mux.HandleFunc(createURL,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -205,9 +205,9 @@ const UpdatedTransferRequestResponse = `
 `
 
 // HandleTransferRequestUpdateSuccessfully configures the test server to respond to an Update request.
-func HandleUpdateSuccessfully(t *testing.T) {
+func HandleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	baseURL := "/zones/tasks/transfer_requests"
-	th.Mux.HandleFunc(s.Join([]string{baseURL, FirstTransferRequest.ID}, "/"),
+	fakeServer.Mux.HandleFunc(s.Join([]string{baseURL, FirstTransferRequest.ID}, "/"),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PATCH")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -220,9 +220,9 @@ func HandleUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleTransferRequestDeleteSuccessfully configures the test server to respond to an Delete request.
-func HandleDeleteSuccessfully(t *testing.T) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 	baseURL := "/zones/tasks/transfer_requests"
-	th.Mux.HandleFunc(s.Join([]string{baseURL, FirstTransferRequest.ID}, "/"),
+	fakeServer.Mux.HandleFunc(s.Join([]string{baseURL, FirstTransferRequest.ID}, "/"),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
diff --git a/openstack/dns/v2/transfer/request/testing/requests_test.go b/openstack/dns/v2/transfer/request/testing/requests_test.go
index daad13b66..b2213f61a 100644
--- a/openstack/dns/v2/transfer/request/testing/requests_test.go
+++ b/openstack/dns/v2/transfer/request/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	count := 0
-	err := transferRequests.List(client.ServiceClient(), nil).EachPage(
+	err := transferRequests.List(client.ServiceClient(fakeServer), nil).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -30,15 +30,15 @@ func TestList(t *testing.T) {
 }
 
 func TestListWithOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	listOpts := transferRequests.ListOpts{
 		Status: "ACTIVE",
 	}
 
-	allPages, err := transferRequests.List(client.ServiceClient(), listOpts).AllPages(context.TODO())
+	allPages, err := transferRequests.List(client.ServiceClient(fakeServer), listOpts).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	allTransferRequests, err := transferRequests.ExtractTransferRequests(allPages)
 	th.AssertNoErr(t, err)
@@ -46,11 +46,11 @@ func TestListWithOpts(t *testing.T) {
 }
 
 func TestListAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
-	allPages, err := transferRequests.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := transferRequests.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	allTransferRequests, err := transferRequests.ExtractTransferRequests(allPages)
 	th.AssertNoErr(t, err)
@@ -58,20 +58,20 @@ func TestListAllPages(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
 	actual, err := transferRequests.Get(
-		context.TODO(), client.ServiceClient(), "a86dba58-0043-4cc6-a1bb-69d5e86f3ca3").Extract()
+		context.TODO(), client.ServiceClient(fakeServer), "a86dba58-0043-4cc6-a1bb-69d5e86f3ca3").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstTransferRequest, actual)
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
 	createOpts := transferRequests.CreateOpts{
 		TargetProjectID: "05d98711-b3a1-4264-a395-f46383671ee6",
@@ -79,15 +79,15 @@ func TestCreate(t *testing.T) {
 	}
 
 	actual, err := transferRequests.Create(
-		context.TODO(), client.ServiceClient(), FirstTransferRequest.ZoneID, createOpts).Extract()
+		context.TODO(), client.ServiceClient(fakeServer), FirstTransferRequest.ZoneID, createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &CreatedTransferRequest, actual)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
 	var description = "Updated Description"
 	updateOpts := transferRequests.UpdateOpts{
@@ -98,18 +98,18 @@ func TestUpdate(t *testing.T) {
 	UpdatedTransferRequest.Description = "Updated Description"
 
 	actual, err := transferRequests.Update(
-		context.TODO(), client.ServiceClient(), UpdatedTransferRequest.ID, updateOpts).Extract()
+		context.TODO(), client.ServiceClient(fakeServer), UpdatedTransferRequest.ID, updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &UpdatedTransferRequest, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
 	DeletedZone := CreatedTransferRequest
 
-	err := transferRequests.Delete(context.TODO(), client.ServiceClient(), DeletedZone.ID).ExtractErr()
+	err := transferRequests.Delete(context.TODO(), client.ServiceClient(fakeServer), DeletedZone.ID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/dns/v2/zones/testing/fixtures_test.go b/openstack/dns/v2/zones/testing/fixtures_test.go
index 6b0ee7ccf..8a7b12a09 100644
--- a/openstack/dns/v2/zones/testing/fixtures_test.go
+++ b/openstack/dns/v2/zones/testing/fixtures_test.go
@@ -143,8 +143,8 @@ var SecondZone = zones.Zone{
 var ExpectedZonesSlice = []zones.Zone{FirstZone, SecondZone}
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -154,8 +154,8 @@ func HandleListSuccessfully(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a List request.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones/a86dba58-0043-4cc6-a1bb-69d5e86f3ca3", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones/a86dba58-0043-4cc6-a1bb-69d5e86f3ca3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -204,8 +204,8 @@ const CreateZoneResponse = `
 var CreatedZone = FirstZone
 
 // HandleZoneCreationSuccessfully configures the test server to respond to a Create request.
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateZoneRequest)
@@ -250,8 +250,8 @@ const UpdateZoneResponse = `
 `
 
 // HandleZoneUpdateSuccessfully configures the test server to respond to an Update request.
-func HandleUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones/a86dba58-0043-4cc6-a1bb-69d5e86f3ca3",
+func HandleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones/a86dba58-0043-4cc6-a1bb-69d5e86f3ca3",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PATCH")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -289,8 +289,8 @@ const DeleteZoneResponse = `
 `
 
 // HandleZoneDeleteSuccessfully configures the test server to respond to an Delete request.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/zones/a86dba58-0043-4cc6-a1bb-69d5e86f3ca3",
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/zones/a86dba58-0043-4cc6-a1bb-69d5e86f3ca3",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -300,3 +300,57 @@ func HandleDeleteSuccessfully(t *testing.T) {
 			fmt.Fprint(w, DeleteZoneResponse)
 		})
 }
+
+// ShareZoneResponse is a sample response to share a zone.
+const ShareZoneResponse = `
+{
+    "id": "fd40b017-bf97-461c-8d30-d4e922b28edd",
+    "zone_id": "a3365b47-ee93-43ad-9a60-2b2ca96b1898",
+    "project_id": "16ade46c85a1435bb86d9138d37da57e",
+    "target_project_id": "232e37df46af42089710e2ae39111c2f",
+    "created_at": "2022-11-30T22:20:27.000000",
+    "updated_at": null,
+    "links": {
+        "self": "http://127.0.0.1:60053/v2/zones/a3365b47-ee93-43ad-9a60-2b2ca96b1898/shares/fd40b017-bf97-461c-8d30-d4e922b28edd",
+        "zone": "http://127.0.0.1:60053/v2/zones/a3365b47-ee93-43ad-9a60-2b2ca96b1898"
+    }
+}
+`
+
+// ShareZoneCreatedAt is the expected created at time for the shared zone
+var ShareZoneCreatedAt, _ = time.Parse(gophercloud.RFC3339MilliNoZ, "2022-11-30T22:20:27.000000")
+
+// ShareZone is the expected shared zone
+var ShareZone = zones.ZoneShare{
+	ID:              "fd40b017-bf97-461c-8d30-d4e922b28edd",
+	ZoneID:          "a3365b47-ee93-43ad-9a60-2b2ca96b1898",
+	ProjectID:       "16ade46c85a1435bb86d9138d37da57e",
+	TargetProjectID: "232e37df46af42089710e2ae39111c2f",
+	CreatedAt:       ShareZoneCreatedAt,
+}
+
+// ListSharesResponse is a sample response to list zone shares.
+const ListSharesResponse = `
+{
+  "shared_zones": [
+    {
+      "id": "fd40b017-bf97-461c-8d30-d4e922b28edd",
+      "zone_id": "a3365b47-ee93-43ad-9a60-2b2ca96b1898",
+      "project_id": "16ade46c85a1435bb86d9138d37da57e",
+      "target_project_id": "232e37df46af42089710e2ae39111c2f",
+      "created_at": "2022-11-30T22:20:27.000000",
+      "updated_at": null,
+      "links": {
+        "self": "http://127.0.0.1:60053/v2/zones/a3365b47-ee93-43ad-9a60-2b2ca96b1898/shares/fd40b017-bf97-461c-8d30-d4e922b28edd",
+        "zone": "http://127.0.0.1:60053/v2/zones/a3365b47-ee93-43ad-9a60-2b2ca96b1898"
+      }
+    }
+  ],
+  "links": {
+    "self": "http://127.0.0.1:60053/v2/zones/a3365b47-ee93-43ad-9a60-2b2ca96b1898/shares"
+  }
+}
+`
+
+// ListZoneShares is the expected list of shared zones
+var ListZoneShares = []zones.ZoneShare{ShareZone}
diff --git a/openstack/dns/v2/zones/testing/requests_test.go b/openstack/dns/v2/zones/testing/requests_test.go
index b75b99e96..fcc1838ce 100644
--- a/openstack/dns/v2/zones/testing/requests_test.go
+++ b/openstack/dns/v2/zones/testing/requests_test.go
@@ -3,6 +3,7 @@ package testing
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"io"
 	"net/http"
 	"testing"
@@ -14,12 +15,12 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	count := 0
-	err := zones.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := zones.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := zones.ExtractZones(page)
 		th.AssertNoErr(t, err)
@@ -32,11 +33,11 @@ func TestList(t *testing.T) {
 }
 
 func TestListAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
-	allPages, err := zones.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := zones.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	allZones, err := zones.ExtractZones(allPages)
 	th.AssertNoErr(t, err)
@@ -44,19 +45,19 @@ func TestListAllPages(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := zones.Get(context.TODO(), client.ServiceClient(), "a86dba58-0043-4cc6-a1bb-69d5e86f3ca3").Extract()
+	actual, err := zones.Get(context.TODO(), client.ServiceClient(fakeServer), "a86dba58-0043-4cc6-a1bb-69d5e86f3ca3").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstZone, actual)
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
 	createOpts := zones.CreateOpts{
 		Name:        "example.org.",
@@ -66,15 +67,15 @@ func TestCreate(t *testing.T) {
 		Description: "This is an example zone.",
 	}
 
-	actual, err := zones.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := zones.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &CreatedZone, actual)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
 	var description = "Updated Description"
 	updateOpts := zones.UpdateOpts{
@@ -88,15 +89,15 @@ func TestUpdate(t *testing.T) {
 	UpdatedZone.TTL = 600
 	UpdatedZone.Description = "Updated Description"
 
-	actual, err := zones.Update(context.TODO(), client.ServiceClient(), UpdatedZone.ID, updateOpts).Extract()
+	actual, err := zones.Update(context.TODO(), client.ServiceClient(fakeServer), UpdatedZone.ID, updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &UpdatedZone, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
 	DeletedZone := CreatedZone
 	DeletedZone.Status = "PENDING"
@@ -104,16 +105,16 @@ func TestDelete(t *testing.T) {
 	DeletedZone.TTL = 600
 	DeletedZone.Description = "Updated Description"
 
-	actual, err := zones.Delete(context.TODO(), client.ServiceClient(), DeletedZone.ID).Extract()
+	actual, err := zones.Delete(context.TODO(), client.ServiceClient(fakeServer), DeletedZone.ID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &DeletedZone, actual)
 }
 
 func TestShare(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/zones/zone-id/shares", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/zones/zone-id/shares", func(w http.ResponseWriter, r *http.Request) {
 		th.AssertEquals(t, r.Method, "POST")
 
 		body, err := io.ReadAll(r.Body)
@@ -127,22 +128,47 @@ func TestShare(t *testing.T) {
 		th.CheckDeepEquals(t, expectedBody, reqBody)
 
 		w.WriteHeader(http.StatusCreated)
+		w.Header().Add("Content-Type", "application/json")
+		fmt.Fprint(w, ShareZoneResponse)
 	})
 
 	opts := zones.ShareZoneOpts{TargetProjectID: "project-id"}
-	err := zones.Share(context.TODO(), client.ServiceClient(), "zone-id", opts).ExtractErr()
+	zone, err := zones.Share(context.TODO(), client.ServiceClient(fakeServer), "zone-id", opts).Extract()
 	th.AssertNoErr(t, err)
+	th.CheckDeepEquals(t, ShareZone, *zone)
 }
 
 func TestUnshare(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/zones/zone-id/shares/share-id", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/zones/zone-id/shares/share-id", func(w http.ResponseWriter, r *http.Request) {
 		th.AssertEquals(t, r.Method, "DELETE")
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := zones.Unshare(context.TODO(), client.ServiceClient(), "zone-id", "share-id").ExtractErr()
+	err := zones.Unshare(context.TODO(), client.ServiceClient(fakeServer), "zone-id", "share-id").ExtractErr()
 	th.AssertNoErr(t, err)
 }
+
+func TestListShares(t *testing.T) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	fakeServer.Mux.HandleFunc("/zones/zone-id/shares", func(w http.ResponseWriter, r *http.Request) {
+		th.AssertEquals(t, r.Method, "GET")
+		th.AssertEquals(t, "true", r.Header.Get("X-Auth-All-Projects"))
+
+		w.Header().Add("Content-Type", "application/json")
+		fmt.Fprint(w, ListSharesResponse)
+	})
+
+	opts := zones.ListSharesOpts{
+		AllProjects: true,
+	}
+	pages, err := zones.ListShares(client.ServiceClient(fakeServer), "zone-id", opts).AllPages(context.TODO())
+	th.AssertNoErr(t, err)
+	actual, err := zones.ExtractZoneShares(pages)
+	th.AssertNoErr(t, err)
+	th.CheckDeepEquals(t, ListZoneShares, actual)
+}
diff --git a/openstack/identity/v2/extensions/testing/fixtures_test.go b/openstack/identity/v2/extensions/testing/fixtures_test.go
index 8e9bfa14d..cffbc1ee3 100644
--- a/openstack/identity/v2/extensions/testing/fixtures_test.go
+++ b/openstack/identity/v2/extensions/testing/fixtures_test.go
@@ -30,8 +30,8 @@ const ListOutput = `
 
 // HandleListExtensionsSuccessfully creates an HTTP handler that returns ListOutput for a List
 // call.
-func HandleListExtensionsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/extensions", func(w http.ResponseWriter, r *http.Request) {
+func HandleListExtensionsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/extensions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v2/extensions/testing/requests_test.go b/openstack/identity/v2/extensions/testing/requests_test.go
index 53c10ab16..0ad8310e1 100644
--- a/openstack/identity/v2/extensions/testing/requests_test.go
+++ b/openstack/identity/v2/extensions/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListExtensionsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListExtensionsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := extensions.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := extensions.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := extensions.ExtractExtensions(page)
 		th.AssertNoErr(t, err)
@@ -30,11 +30,11 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	common.HandleGetExtensionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	common.HandleGetExtensionSuccessfully(t, fakeServer)
 
-	actual, err := extensions.Get(context.TODO(), client.ServiceClient(), "agent").Extract()
+	actual, err := extensions.Get(context.TODO(), client.ServiceClient(fakeServer), "agent").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, common.SingleExtension, actual)
 }
diff --git a/openstack/identity/v2/roles/testing/fixtures_test.go b/openstack/identity/v2/roles/testing/fixtures_test.go
index 170e80099..ea67ae987 100644
--- a/openstack/identity/v2/roles/testing/fixtures_test.go
+++ b/openstack/identity/v2/roles/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockListRoleResponse(t *testing.T) {
-	th.Mux.HandleFunc("/OS-KSADM/roles", func(w http.ResponseWriter, r *http.Request) {
+func MockListRoleResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-KSADM/roles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -31,18 +31,18 @@ func MockListRoleResponse(t *testing.T) {
 	})
 }
 
-func MockAddUserRoleResponse(t *testing.T) {
-	th.Mux.HandleFunc("/tenants/{tenant_id}/users/{user_id}/roles/OS-KSADM/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+func MockAddUserRoleResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/tenants/{tenant_id}/users/{user_id}/roles/OS-KSADM/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusCreated)
 	})
 }
 
-func MockDeleteUserRoleResponse(t *testing.T) {
-	th.Mux.HandleFunc("/tenants/{tenant_id}/users/{user_id}/roles/OS-KSADM/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteUserRoleResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/tenants/{tenant_id}/users/{user_id}/roles/OS-KSADM/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
diff --git a/openstack/identity/v2/roles/testing/requests_test.go b/openstack/identity/v2/roles/testing/requests_test.go
index a75f36220..52b4c0941 100644
--- a/openstack/identity/v2/roles/testing/requests_test.go
+++ b/openstack/identity/v2/roles/testing/requests_test.go
@@ -11,14 +11,14 @@ import (
 )
 
 func TestRole(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListRoleResponse(t)
+	MockListRoleResponse(t, fakeServer)
 
 	count := 0
 
-	err := roles.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := roles.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := roles.ExtractRoles(page)
 		if err != nil {
@@ -44,23 +44,23 @@ func TestRole(t *testing.T) {
 }
 
 func TestAddUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockAddUserRoleResponse(t)
+	MockAddUserRoleResponse(t, fakeServer)
 
-	err := roles.AddUser(context.TODO(), client.ServiceClient(), "{tenant_id}", "{user_id}", "{role_id}").ExtractErr()
+	err := roles.AddUser(context.TODO(), client.ServiceClient(fakeServer), "{tenant_id}", "{user_id}", "{role_id}").ExtractErr()
 
 	th.AssertNoErr(t, err)
 }
 
 func TestDeleteUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteUserRoleResponse(t)
+	MockDeleteUserRoleResponse(t, fakeServer)
 
-	err := roles.DeleteUser(context.TODO(), client.ServiceClient(), "{tenant_id}", "{user_id}", "{role_id}").ExtractErr()
+	err := roles.DeleteUser(context.TODO(), client.ServiceClient(fakeServer), "{tenant_id}", "{user_id}", "{role_id}").ExtractErr()
 
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/identity/v2/tenants/testing/fixtures_test.go b/openstack/identity/v2/tenants/testing/fixtures_test.go
index e7de74ccd..e35fd5275 100644
--- a/openstack/identity/v2/tenants/testing/fixtures_test.go
+++ b/openstack/identity/v2/tenants/testing/fixtures_test.go
@@ -51,8 +51,8 @@ var ExpectedTenantSlice = []tenants.Tenant{RedTeam, BlueTeam}
 
 // HandleListTenantsSuccessfully creates an HTTP handler at `/tenants` on the test handler mux that
 // responds with a list of two tenants.
-func HandleListTenantsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/tenants", func(w http.ResponseWriter, r *http.Request) {
+func HandleListTenantsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/tenants", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -63,8 +63,8 @@ func HandleListTenantsSuccessfully(t *testing.T) {
 	})
 }
 
-func mockCreateTenantResponse(t *testing.T) {
-	th.Mux.HandleFunc("/tenants", func(w http.ResponseWriter, r *http.Request) {
+func mockCreateTenantResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/tenants", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -94,16 +94,16 @@ func mockCreateTenantResponse(t *testing.T) {
 	})
 }
 
-func mockDeleteTenantResponse(t *testing.T) {
-	th.Mux.HandleFunc("/tenants/2466f69cd4714d89a548a68ed97ffcd4", func(w http.ResponseWriter, r *http.Request) {
+func mockDeleteTenantResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/tenants/2466f69cd4714d89a548a68ed97ffcd4", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func mockUpdateTenantResponse(t *testing.T) {
-	th.Mux.HandleFunc("/tenants/5c62ef576dc7444cbb73b1fe84b97648", func(w http.ResponseWriter, r *http.Request) {
+func mockUpdateTenantResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/tenants/5c62ef576dc7444cbb73b1fe84b97648", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -133,8 +133,8 @@ func mockUpdateTenantResponse(t *testing.T) {
 	})
 }
 
-func mockGetTenantResponse(t *testing.T) {
-	th.Mux.HandleFunc("/tenants/5c62ef576dc7444cbb73b1fe84b97648", func(w http.ResponseWriter, r *http.Request) {
+func mockGetTenantResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/tenants/5c62ef576dc7444cbb73b1fe84b97648", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v2/tenants/testing/requests_test.go b/openstack/identity/v2/tenants/testing/requests_test.go
index 1e3e05ce3..d658d3728 100644
--- a/openstack/identity/v2/tenants/testing/requests_test.go
+++ b/openstack/identity/v2/tenants/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestListTenants(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTenantsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTenantsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := tenants.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := tenants.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := tenants.ExtractTenants(page)
@@ -32,10 +32,10 @@ func TestListTenants(t *testing.T) {
 }
 
 func TestCreateTenant(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockCreateTenantResponse(t)
+	mockCreateTenantResponse(t, fakeServer)
 
 	opts := tenants.CreateOpts{
 		Name:        "new_tenant",
@@ -43,7 +43,7 @@ func TestCreateTenant(t *testing.T) {
 		Enabled:     gophercloud.Enabled,
 	}
 
-	tenant, err := tenants.Create(context.TODO(), client.ServiceClient(), opts).Extract()
+	tenant, err := tenants.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 
 	th.AssertNoErr(t, err)
 
@@ -58,20 +58,20 @@ func TestCreateTenant(t *testing.T) {
 }
 
 func TestDeleteTenant(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockDeleteTenantResponse(t)
+	mockDeleteTenantResponse(t, fakeServer)
 
-	err := tenants.Delete(context.TODO(), client.ServiceClient(), "2466f69cd4714d89a548a68ed97ffcd4").ExtractErr()
+	err := tenants.Delete(context.TODO(), client.ServiceClient(fakeServer), "2466f69cd4714d89a548a68ed97ffcd4").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdateTenant(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockUpdateTenantResponse(t)
+	mockUpdateTenantResponse(t, fakeServer)
 
 	id := "5c62ef576dc7444cbb73b1fe84b97648"
 	description := "This is new name"
@@ -81,7 +81,7 @@ func TestUpdateTenant(t *testing.T) {
 		Enabled:     gophercloud.Enabled,
 	}
 
-	tenant, err := tenants.Update(context.TODO(), client.ServiceClient(), id, opts).Extract()
+	tenant, err := tenants.Update(context.TODO(), client.ServiceClient(fakeServer), id, opts).Extract()
 
 	th.AssertNoErr(t, err)
 
@@ -96,12 +96,12 @@ func TestUpdateTenant(t *testing.T) {
 }
 
 func TestGetTenant(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockGetTenantResponse(t)
+	mockGetTenantResponse(t, fakeServer)
 
-	tenant, err := tenants.Get(context.TODO(), client.ServiceClient(), "5c62ef576dc7444cbb73b1fe84b97648").Extract()
+	tenant, err := tenants.Get(context.TODO(), client.ServiceClient(fakeServer), "5c62ef576dc7444cbb73b1fe84b97648").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &tenants.Tenant{
diff --git a/openstack/identity/v2/tokens/testing/fixtures_test.go b/openstack/identity/v2/tokens/testing/fixtures_test.go
index 1ee6d32e7..bd093fc7d 100644
--- a/openstack/identity/v2/tokens/testing/fixtures_test.go
+++ b/openstack/identity/v2/tokens/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/identity/v2/tenants"
 	"github.com/gophercloud/gophercloud/v2/openstack/identity/v2/tokens"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	thclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // ExpectedToken is the token that should be parsed from TokenCreationResponse.
@@ -142,8 +142,8 @@ const TokenGetResponse = `
 
 // HandleTokenPost expects a POST against a /tokens handler, ensures that the request body has been
 // constructed properly given certain auth options, and returns the result.
-func HandleTokenPost(t *testing.T, requestJSON string) {
-	th.Mux.HandleFunc("/tokens", func(w http.ResponseWriter, r *http.Request) {
+func HandleTokenPost(t *testing.T, fakeServer th.FakeServer, requestJSON string) {
+	fakeServer.Mux.HandleFunc("/tokens", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -158,11 +158,11 @@ func HandleTokenPost(t *testing.T, requestJSON string) {
 
 // HandleTokenGet expects a Get against a /tokens handler, ensures that the request body has been
 // constructed properly given certain auth options, and returns the result.
-func HandleTokenGet(t *testing.T, token string) {
-	th.Mux.HandleFunc("/tokens/"+token, func(w http.ResponseWriter, r *http.Request) {
+func HandleTokenGet(t *testing.T, fakeServer th.FakeServer, token string) {
+	fakeServer.Mux.HandleFunc("/tokens/"+token, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", thclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, TokenGetResponse)
diff --git a/openstack/identity/v2/tokens/testing/requests_test.go b/openstack/identity/v2/tokens/testing/requests_test.go
index a688369d6..21ff0a814 100644
--- a/openstack/identity/v2/tokens/testing/requests_test.go
+++ b/openstack/identity/v2/tokens/testing/requests_test.go
@@ -11,19 +11,19 @@ import (
 )
 
 func tokenPost(t *testing.T, options gophercloud.AuthOptions, requestJSON string) tokens.CreateResult {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleTokenPost(t, requestJSON)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleTokenPost(t, fakeServer, requestJSON)
 
-	return tokens.Create(context.TODO(), client.ServiceClient(), options)
+	return tokens.Create(context.TODO(), client.ServiceClient(fakeServer), options)
 }
 
 func tokenPostErr(t *testing.T, options gophercloud.AuthOptions, expectedErr error) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleTokenPost(t, "")
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleTokenPost(t, fakeServer, "")
 
-	actualErr := tokens.Create(context.TODO(), client.ServiceClient(), options).Err
+	actualErr := tokens.Create(context.TODO(), client.ServiceClient(fakeServer), options).Err
 	th.CheckDeepEquals(t, expectedErr, actualErr)
 }
 
@@ -94,10 +94,10 @@ func TestRequireUsername(t *testing.T) {
 }
 
 func tokenGet(t *testing.T, tokenId string) tokens.GetResult {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleTokenGet(t, tokenId)
-	return tokens.Get(context.TODO(), client.ServiceClient(), tokenId)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleTokenGet(t, fakeServer, tokenId)
+	return tokens.Get(context.TODO(), client.ServiceClient(fakeServer), tokenId)
 }
 
 func TestGetWithToken(t *testing.T) {
diff --git a/openstack/identity/v2/users/testing/fixtures_test.go b/openstack/identity/v2/users/testing/fixtures_test.go
index 3e5285360..260333293 100644
--- a/openstack/identity/v2/users/testing/fixtures_test.go
+++ b/openstack/identity/v2/users/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockListUserResponse(t *testing.T) {
-	th.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
+func MockListUserResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -42,10 +42,10 @@ func MockListUserResponse(t *testing.T) {
 	})
 }
 
-func mockCreateUserResponse(t *testing.T) {
-	th.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
+func mockCreateUserResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -75,10 +75,10 @@ func mockCreateUserResponse(t *testing.T) {
 	})
 }
 
-func mockGetUserResponse(t *testing.T) {
-	th.Mux.HandleFunc("/users/new_user", func(w http.ResponseWriter, r *http.Request) {
+func mockGetUserResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/new_user", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -97,10 +97,10 @@ func mockGetUserResponse(t *testing.T) {
 	})
 }
 
-func mockUpdateUserResponse(t *testing.T) {
-	th.Mux.HandleFunc("/users/c39e3de9be2d4c779f1dfd6abacc176d", func(w http.ResponseWriter, r *http.Request) {
+func mockUpdateUserResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/c39e3de9be2d4c779f1dfd6abacc176d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `
 {
@@ -129,18 +129,18 @@ func mockUpdateUserResponse(t *testing.T) {
 	})
 }
 
-func mockDeleteUserResponse(t *testing.T) {
-	th.Mux.HandleFunc("/users/c39e3de9be2d4c779f1dfd6abacc176d", func(w http.ResponseWriter, r *http.Request) {
+func mockDeleteUserResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/c39e3de9be2d4c779f1dfd6abacc176d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func mockListRolesResponse(t *testing.T) {
-	th.Mux.HandleFunc("/tenants/1d8b6120dcc640fda4fc9194ffc80273/users/c39e3de9be2d4c779f1dfd6abacc176d/roles", func(w http.ResponseWriter, r *http.Request) {
+func mockListRolesResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/tenants/1d8b6120dcc640fda4fc9194ffc80273/users/c39e3de9be2d4c779f1dfd6abacc176d/roles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
diff --git a/openstack/identity/v2/users/testing/requests_test.go b/openstack/identity/v2/users/testing/requests_test.go
index c66207d0c..78553213e 100644
--- a/openstack/identity/v2/users/testing/requests_test.go
+++ b/openstack/identity/v2/users/testing/requests_test.go
@@ -12,14 +12,14 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListUserResponse(t)
+	MockListUserResponse(t, fakeServer)
 
 	count := 0
 
-	err := users.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := users.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := users.ExtractUsers(page)
 		th.AssertNoErr(t, err)
@@ -50,10 +50,10 @@ func TestList(t *testing.T) {
 }
 
 func TestCreateUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockCreateUserResponse(t)
+	mockCreateUserResponse(t, fakeServer)
 
 	opts := users.CreateOpts{
 		Name:     "new_user",
@@ -62,7 +62,7 @@ func TestCreateUser(t *testing.T) {
 		Email:    "new_user@foo.com",
 	}
 
-	user, err := users.Create(context.TODO(), client.ServiceClient(), opts).Extract()
+	user, err := users.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 
 	th.AssertNoErr(t, err)
 
@@ -78,12 +78,12 @@ func TestCreateUser(t *testing.T) {
 }
 
 func TestGetUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockGetUserResponse(t)
+	mockGetUserResponse(t, fakeServer)
 
-	user, err := users.Get(context.TODO(), client.ServiceClient(), "new_user").Extract()
+	user, err := users.Get(context.TODO(), client.ServiceClient(fakeServer), "new_user").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := &users.User{
@@ -98,10 +98,10 @@ func TestGetUser(t *testing.T) {
 }
 
 func TestUpdateUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockUpdateUserResponse(t)
+	mockUpdateUserResponse(t, fakeServer)
 
 	id := "c39e3de9be2d4c779f1dfd6abacc176d"
 	opts := users.UpdateOpts{
@@ -110,7 +110,7 @@ func TestUpdateUser(t *testing.T) {
 		Email:   "new_email@foo.com",
 	}
 
-	user, err := users.Update(context.TODO(), client.ServiceClient(), id, opts).Extract()
+	user, err := users.Update(context.TODO(), client.ServiceClient(fakeServer), id, opts).Extract()
 
 	th.AssertNoErr(t, err)
 
@@ -126,25 +126,25 @@ func TestUpdateUser(t *testing.T) {
 }
 
 func TestDeleteUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockDeleteUserResponse(t)
+	mockDeleteUserResponse(t, fakeServer)
 
-	res := users.Delete(context.TODO(), client.ServiceClient(), "c39e3de9be2d4c779f1dfd6abacc176d")
+	res := users.Delete(context.TODO(), client.ServiceClient(fakeServer), "c39e3de9be2d4c779f1dfd6abacc176d")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListingUserRoles(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	mockListRolesResponse(t)
+	mockListRolesResponse(t, fakeServer)
 
 	tenantID := "1d8b6120dcc640fda4fc9194ffc80273"
 	userID := "c39e3de9be2d4c779f1dfd6abacc176d"
 
-	err := users.ListRoles(client.ServiceClient(), tenantID, userID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := users.ListRoles(client.ServiceClient(fakeServer), tenantID, userID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		actual, err := users.ExtractRoles(page)
 		th.AssertNoErr(t, err)
 
diff --git a/openstack/identity/v3/applicationcredentials/testing/fixtures_test.go b/openstack/identity/v3/applicationcredentials/testing/fixtures_test.go
index ae06c1bc5..5289cc29b 100644
--- a/openstack/identity/v3/applicationcredentials/testing/fixtures_test.go
+++ b/openstack/identity/v3/applicationcredentials/testing/fixtures_test.go
@@ -407,8 +407,8 @@ var ExpectedApplicationCredentialsSlice = []applicationcredentials.ApplicationCr
 
 // HandleListApplicationCredentialsSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that responds with a list of two applicationcredentials.
-func HandleListApplicationCredentialsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials", func(w http.ResponseWriter, r *http.Request) {
+func HandleListApplicationCredentialsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -421,8 +421,8 @@ func HandleListApplicationCredentialsSuccessfully(t *testing.T) {
 
 // HandleGetApplicationCredentialSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that responds with a single application credential.
-func HandleGetApplicationCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials/f741662395b249c9b8acdebf1722c5ae", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetApplicationCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials/f741662395b249c9b8acdebf1722c5ae", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -435,8 +435,8 @@ func HandleGetApplicationCredentialSuccessfully(t *testing.T) {
 
 // HandleCreateApplicationCredentialSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests application credential creation.
-func HandleCreateApplicationCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateApplicationCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -448,8 +448,8 @@ func HandleCreateApplicationCredentialSuccessfully(t *testing.T) {
 
 // HandleCreateNoOptionsApplicationCredentialSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests application credential creation.
-func HandleCreateNoSecretApplicationCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateNoSecretApplicationCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateNoSecretRequest)
@@ -459,8 +459,8 @@ func HandleCreateNoSecretApplicationCredentialSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleCreateUnrestrictedApplicationCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateUnrestrictedApplicationCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateUnrestrictedRequest)
@@ -472,8 +472,8 @@ func HandleCreateUnrestrictedApplicationCredentialSuccessfully(t *testing.T) {
 
 // HandleDeleteApplicationCredentialSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests application credential deletion.
-func HandleDeleteApplicationCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials/f741662395b249c9b8acdebf1722c5ae", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteApplicationCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/application_credentials/f741662395b249c9b8acdebf1722c5ae", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -483,8 +483,8 @@ func HandleDeleteApplicationCredentialSuccessfully(t *testing.T) {
 
 // HandleListAccessRulesSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that responds with a list of two applicationcredentials.
-func HandleListAccessRulesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/access_rules", func(w http.ResponseWriter, r *http.Request) {
+func HandleListAccessRulesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/access_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -497,8 +497,8 @@ func HandleListAccessRulesSuccessfully(t *testing.T) {
 
 // HandleGetAccessRuleSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that responds with a single application credential.
-func HandleGetAccessRuleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/access_rules/07d719df00f349ef8de77d542edf010c", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetAccessRuleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/access_rules/07d719df00f349ef8de77d542edf010c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -511,8 +511,8 @@ func HandleGetAccessRuleSuccessfully(t *testing.T) {
 
 // HandleDeleteAccessRuleSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests application credential deletion.
-func HandleDeleteAccessRuleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/access_rules/07d719df00f349ef8de77d542edf010c", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteAccessRuleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/access_rules/07d719df00f349ef8de77d542edf010c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v3/applicationcredentials/testing/requests_test.go b/openstack/identity/v3/applicationcredentials/testing/requests_test.go
index 11d863609..d31b183c2 100644
--- a/openstack/identity/v3/applicationcredentials/testing/requests_test.go
+++ b/openstack/identity/v3/applicationcredentials/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListApplicationCredentials(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListApplicationCredentialsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListApplicationCredentialsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := applicationcredentials.List(client.ServiceClient(), userID, nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := applicationcredentials.List(client.ServiceClient(fakeServer), userID, nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := applicationcredentials.ExtractApplicationCredentials(page)
@@ -31,11 +31,11 @@ func TestListApplicationCredentials(t *testing.T) {
 }
 
 func TestListApplicationCredentialsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListApplicationCredentialsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListApplicationCredentialsSuccessfully(t, fakeServer)
 
-	allPages, err := applicationcredentials.List(client.ServiceClient(), userID, nil).AllPages(context.TODO())
+	allPages, err := applicationcredentials.List(client.ServiceClient(fakeServer), userID, nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := applicationcredentials.ExtractApplicationCredentials(allPages)
 	th.AssertNoErr(t, err)
@@ -45,19 +45,19 @@ func TestListApplicationCredentialsAllPages(t *testing.T) {
 }
 
 func TestGetApplicationCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetApplicationCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetApplicationCredentialSuccessfully(t, fakeServer)
 
-	actual, err := applicationcredentials.Get(context.TODO(), client.ServiceClient(), userID, applicationCredentialID).Extract()
+	actual, err := applicationcredentials.Get(context.TODO(), client.ServiceClient(fakeServer), userID, applicationCredentialID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ApplicationCredential, *actual)
 }
 
 func TestCreateApplicationCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateApplicationCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateApplicationCredentialSuccessfully(t, fakeServer)
 
 	createOpts := applicationcredentials.CreateOpts{
 		Name:   "test",
@@ -77,15 +77,15 @@ func TestCreateApplicationCredential(t *testing.T) {
 	ApplicationCredentialResponse := ApplicationCredential
 	ApplicationCredentialResponse.Secret = "mysecret"
 
-	actual, err := applicationcredentials.Create(context.TODO(), client.ServiceClient(), userID, createOpts).Extract()
+	actual, err := applicationcredentials.Create(context.TODO(), client.ServiceClient(fakeServer), userID, createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ApplicationCredentialResponse, *actual)
 }
 
 func TestCreateNoSecretApplicationCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateNoSecretApplicationCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateNoSecretApplicationCredentialSuccessfully(t, fakeServer)
 
 	createOpts := applicationcredentials.CreateOpts{
 		Name: "test1",
@@ -94,15 +94,15 @@ func TestCreateNoSecretApplicationCredential(t *testing.T) {
 		},
 	}
 
-	actual, err := applicationcredentials.Create(context.TODO(), client.ServiceClient(), userID, createOpts).Extract()
+	actual, err := applicationcredentials.Create(context.TODO(), client.ServiceClient(fakeServer), userID, createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ApplicationCredentialNoSecretResponse, *actual)
 }
 
 func TestCreateUnrestrictedApplicationCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateUnrestrictedApplicationCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateUnrestrictedApplicationCredentialSuccessfully(t, fakeServer)
 
 	createOpts := applicationcredentials.CreateOpts{
 		Name:         "test2",
@@ -117,27 +117,27 @@ func TestCreateUnrestrictedApplicationCredential(t *testing.T) {
 	UnrestrictedApplicationCredentialResponse := UnrestrictedApplicationCredential
 	UnrestrictedApplicationCredentialResponse.Secret = "generated_secret"
 
-	actual, err := applicationcredentials.Create(context.TODO(), client.ServiceClient(), userID, createOpts).Extract()
+	actual, err := applicationcredentials.Create(context.TODO(), client.ServiceClient(fakeServer), userID, createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, UnrestrictedApplicationCredentialResponse, *actual)
 }
 
 func TestDeleteApplicationCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteApplicationCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteApplicationCredentialSuccessfully(t, fakeServer)
 
-	res := applicationcredentials.Delete(context.TODO(), client.ServiceClient(), userID, applicationCredentialID)
+	res := applicationcredentials.Delete(context.TODO(), client.ServiceClient(fakeServer), userID, applicationCredentialID)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListAccessRules(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAccessRulesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAccessRulesSuccessfully(t, fakeServer)
 
 	count := 0
-	err := applicationcredentials.ListAccessRules(client.ServiceClient(), userID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := applicationcredentials.ListAccessRules(client.ServiceClient(fakeServer), userID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := applicationcredentials.ExtractAccessRules(page)
@@ -152,20 +152,20 @@ func TestListAccessRules(t *testing.T) {
 }
 
 func TestGetAccessRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetAccessRuleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetAccessRuleSuccessfully(t, fakeServer)
 
-	actual, err := applicationcredentials.GetAccessRule(context.TODO(), client.ServiceClient(), userID, accessRuleID).Extract()
+	actual, err := applicationcredentials.GetAccessRule(context.TODO(), client.ServiceClient(fakeServer), userID, accessRuleID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, AccessRule, *actual)
 }
 
 func TestDeleteAccessRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteAccessRuleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteAccessRuleSuccessfully(t, fakeServer)
 
-	res := applicationcredentials.DeleteAccessRule(context.TODO(), client.ServiceClient(), userID, accessRuleID)
+	res := applicationcredentials.DeleteAccessRule(context.TODO(), client.ServiceClient(fakeServer), userID, accessRuleID)
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/catalog/testing/catalog_test.go b/openstack/identity/v3/catalog/testing/catalog_test.go
index 4b055081f..5f35803ca 100644
--- a/openstack/identity/v3/catalog/testing/catalog_test.go
+++ b/openstack/identity/v3/catalog/testing/catalog_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListCatalog(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListCatalogSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListCatalogSuccessfully(t, fakeServer)
 
 	count := 0
-	err := catalog.List(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := catalog.List(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := catalog.ExtractServiceCatalog(page)
diff --git a/openstack/identity/v3/catalog/testing/fixtures_test.go b/openstack/identity/v3/catalog/testing/fixtures_test.go
index ad9e9d9ce..310a40e68 100644
--- a/openstack/identity/v3/catalog/testing/fixtures_test.go
+++ b/openstack/identity/v3/catalog/testing/fixtures_test.go
@@ -77,8 +77,8 @@ var ExpectedCatalogSlice = []tokens.CatalogEntry{{
 
 // HandleListCatalogSuccessfully creates an HTTP handler at `/domains` on the
 // test handler mux that responds with a list of two domains.
-func HandleListCatalogSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/auth/catalog", func(w http.ResponseWriter, r *http.Request) {
+func HandleListCatalogSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/auth/catalog", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
diff --git a/openstack/identity/v3/credentials/testing/fixtures_test.go b/openstack/identity/v3/credentials/testing/fixtures_test.go
index e32d77d0d..206700ec0 100644
--- a/openstack/identity/v3/credentials/testing/fixtures_test.go
+++ b/openstack/identity/v3/credentials/testing/fixtures_test.go
@@ -153,8 +153,8 @@ var ExpectedCredentialsSlice = []credentials.Credential{FirstCredential, SecondC
 
 // HandleListCredentialsSuccessfully creates an HTTP handler at `/credentials` on the
 // test handler mux that responds with a list of two credentials.
-func HandleListCredentialsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/credentials", func(w http.ResponseWriter, r *http.Request) {
+func HandleListCredentialsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/credentials", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -167,8 +167,8 @@ func HandleListCredentialsSuccessfully(t *testing.T) {
 
 // HandleGetCredentialSuccessfully creates an HTTP handler at `/credentials` on the
 // test handler mux that responds with a single credential.
-func HandleGetCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/credentials/3d3367228f9c7665266604462ec60029bcd83ad89614021a80b2eb879c572510", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/credentials/3d3367228f9c7665266604462ec60029bcd83ad89614021a80b2eb879c572510", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -181,8 +181,8 @@ func HandleGetCredentialSuccessfully(t *testing.T) {
 
 // HandleCreateCredentialSuccessfully creates an HTTP handler at `/credentials` on the
 // test handler mux that tests credential creation.
-func HandleCreateCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/credentials", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/credentials", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -194,8 +194,8 @@ func HandleCreateCredentialSuccessfully(t *testing.T) {
 
 // HandleDeleteCredentialSuccessfully creates an HTTP handler at `/credentials` on the
 // test handler mux that tests credential deletion.
-func HandleDeleteCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/credentials/3d3367228f9c7665266604462ec60029bcd83ad89614021a80b2eb879c572510", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/credentials/3d3367228f9c7665266604462ec60029bcd83ad89614021a80b2eb879c572510", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -205,8 +205,8 @@ func HandleDeleteCredentialSuccessfully(t *testing.T) {
 
 // HandleUpdateCredentialsSuccessfully creates an HTTP handler at `/credentials` on the
 // test handler mux that tests credentials update.
-func HandleUpdateCredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/credentials/2441494e52ab6d594a34d74586075cb299489bdd1e9389e3ab06467a4f460609", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateCredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/credentials/2441494e52ab6d594a34d74586075cb299489bdd1e9389e3ab06467a4f460609", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
diff --git a/openstack/identity/v3/credentials/testing/requests_test.go b/openstack/identity/v3/credentials/testing/requests_test.go
index 7b90817c5..86cbe93b5 100644
--- a/openstack/identity/v3/credentials/testing/requests_test.go
+++ b/openstack/identity/v3/credentials/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListCredentials(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListCredentialsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListCredentialsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := credentials.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := credentials.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := credentials.ExtractCredentials(page)
@@ -31,11 +31,11 @@ func TestListCredentials(t *testing.T) {
 }
 
 func TestListCredentialsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListCredentialsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListCredentialsSuccessfully(t, fakeServer)
 
-	allPages, err := credentials.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := credentials.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := credentials.ExtractCredentials(allPages)
 	th.AssertNoErr(t, err)
@@ -45,19 +45,19 @@ func TestListCredentialsAllPages(t *testing.T) {
 }
 
 func TestGetCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetCredentialSuccessfully(t, fakeServer)
 
-	actual, err := credentials.Get(context.TODO(), client.ServiceClient(), credentialID).Extract()
+	actual, err := credentials.Get(context.TODO(), client.ServiceClient(fakeServer), credentialID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, Credential, *actual)
 }
 
 func TestCreateCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateCredentialSuccessfully(t, fakeServer)
 
 	createOpts := credentials.CreateOpts{
 		ProjectID: projectID,
@@ -68,24 +68,24 @@ func TestCreateCredential(t *testing.T) {
 
 	CredentialResponse := Credential
 
-	actual, err := credentials.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := credentials.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, CredentialResponse, *actual)
 }
 
 func TestDeleteCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteCredentialSuccessfully(t, fakeServer)
 
-	res := credentials.Delete(context.TODO(), client.ServiceClient(), credentialID)
+	res := credentials.Delete(context.TODO(), client.ServiceClient(fakeServer), credentialID)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateCredential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateCredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateCredentialSuccessfully(t, fakeServer)
 
 	updateOpts := credentials.UpdateOpts{
 		ProjectID: "731fc6f265cd486d900f16e84c5cb594",
@@ -94,7 +94,7 @@ func TestUpdateCredential(t *testing.T) {
 		Blob:      "{\"access\":\"181920\",\"secret\":\"secretKey\"}",
 	}
 
-	actual, err := credentials.Update(context.TODO(), client.ServiceClient(), "2441494e52ab6d594a34d74586075cb299489bdd1e9389e3ab06467a4f460609", updateOpts).Extract()
+	actual, err := credentials.Update(context.TODO(), client.ServiceClient(fakeServer), "2441494e52ab6d594a34d74586075cb299489bdd1e9389e3ab06467a4f460609", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondCredentialUpdated, *actual)
 }
diff --git a/openstack/identity/v3/domains/testing/fixtures_test.go b/openstack/identity/v3/domains/testing/fixtures_test.go
index a35813a23..6c0f57005 100644
--- a/openstack/identity/v3/domains/testing/fixtures_test.go
+++ b/openstack/identity/v3/domains/testing/fixtures_test.go
@@ -181,8 +181,8 @@ var ExpectedDomainsSlice = []domains.Domain{FirstDomain, SecondDomain}
 
 // HandleListAvailableDomainsSuccessfully creates an HTTP handler at `/auth/domains`
 // on the test handler mux that responds with a list of two domains.
-func HandleListAvailableDomainsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/auth/domains", func(w http.ResponseWriter, r *http.Request) {
+func HandleListAvailableDomainsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/auth/domains", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -195,8 +195,8 @@ func HandleListAvailableDomainsSuccessfully(t *testing.T) {
 
 // HandleListDomainsSuccessfully creates an HTTP handler at `/domains` on the
 // test handler mux that responds with a list of two domains.
-func HandleListDomainsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/domains", func(w http.ResponseWriter, r *http.Request) {
+func HandleListDomainsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/domains", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -209,8 +209,8 @@ func HandleListDomainsSuccessfully(t *testing.T) {
 
 // HandleGetDomainSuccessfully creates an HTTP handler at `/domains` on the
 // test handler mux that responds with a single domain.
-func HandleGetDomainSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/domains/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetDomainSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/domains/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -223,8 +223,8 @@ func HandleGetDomainSuccessfully(t *testing.T) {
 
 // HandleCreateDomainSuccessfully creates an HTTP handler at `/domains` on the
 // test handler mux that tests domain creation.
-func HandleCreateDomainSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/domains", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateDomainSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/domains", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -236,8 +236,8 @@ func HandleCreateDomainSuccessfully(t *testing.T) {
 
 // HandleDeleteDomainSuccessfully creates an HTTP handler at `/domains` on the
 // test handler mux that tests domain deletion.
-func HandleDeleteDomainSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/domains/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteDomainSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/domains/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -247,8 +247,8 @@ func HandleDeleteDomainSuccessfully(t *testing.T) {
 
 // HandleUpdateDomainSuccessfully creates an HTTP handler at `/domains` on the
 // test handler mux that tests domain update.
-func HandleUpdateDomainSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/domains/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateDomainSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/domains/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
diff --git a/openstack/identity/v3/domains/testing/requests_test.go b/openstack/identity/v3/domains/testing/requests_test.go
index 1e0f5ef8f..00819c788 100644
--- a/openstack/identity/v3/domains/testing/requests_test.go
+++ b/openstack/identity/v3/domains/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListAvailableDomains(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAvailableDomainsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAvailableDomainsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := domains.ListAvailable(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := domains.ListAvailable(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := domains.ExtractDomains(page)
@@ -31,12 +31,12 @@ func TestListAvailableDomains(t *testing.T) {
 }
 
 func TestListDomains(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListDomainsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListDomainsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := domains.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := domains.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := domains.ExtractDomains(page)
@@ -51,11 +51,11 @@ func TestListDomains(t *testing.T) {
 }
 
 func TestListDomainsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListDomainsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListDomainsSuccessfully(t, fakeServer)
 
-	allPages, err := domains.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := domains.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := domains.ExtractDomains(allPages)
 	th.AssertNoErr(t, err)
@@ -63,49 +63,49 @@ func TestListDomainsAllPages(t *testing.T) {
 }
 
 func TestGetDomain(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetDomainSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetDomainSuccessfully(t, fakeServer)
 
-	actual, err := domains.Get(context.TODO(), client.ServiceClient(), "9fe1d3").Extract()
+	actual, err := domains.Get(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondDomain, *actual)
 }
 
 func TestCreateDomain(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateDomainSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateDomainSuccessfully(t, fakeServer)
 
 	createOpts := domains.CreateOpts{
 		Name: "domain two",
 	}
 
-	actual, err := domains.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := domains.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondDomain, *actual)
 }
 
 func TestDeleteDomain(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteDomainSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteDomainSuccessfully(t, fakeServer)
 
-	res := domains.Delete(context.TODO(), client.ServiceClient(), "9fe1d3")
+	res := domains.Delete(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateDomain(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateDomainSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateDomainSuccessfully(t, fakeServer)
 
 	var description = "Staging Domain"
 	updateOpts := domains.UpdateOpts{
 		Description: &description,
 	}
 
-	actual, err := domains.Update(context.TODO(), client.ServiceClient(), "9fe1d3", updateOpts).Extract()
+	actual, err := domains.Update(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondDomainUpdated, *actual)
 }
diff --git a/openstack/identity/v3/ec2credentials/testing/fixtures_test.go b/openstack/identity/v3/ec2credentials/testing/fixtures_test.go
index 72a82e1ff..eb29689de 100644
--- a/openstack/identity/v3/ec2credentials/testing/fixtures_test.go
+++ b/openstack/identity/v3/ec2credentials/testing/fixtures_test.go
@@ -111,8 +111,8 @@ var ExpectedEC2CredentialsSlice = []ec2credentials.Credential{EC2Credential, Sec
 
 // HandleListEC2CredentialsSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that responds with a list of two applicationcredentials.
-func HandleListEC2CredentialsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/credentials/OS-EC2", func(w http.ResponseWriter, r *http.Request) {
+func HandleListEC2CredentialsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/credentials/OS-EC2", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -125,8 +125,8 @@ func HandleListEC2CredentialsSuccessfully(t *testing.T) {
 
 // HandleGetEC2CredentialSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that responds with a single application credential.
-func HandleGetEC2CredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/credentials/OS-EC2/f741662395b249c9b8acdebf1722c5ae", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetEC2CredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/credentials/OS-EC2/f741662395b249c9b8acdebf1722c5ae", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -139,8 +139,8 @@ func HandleGetEC2CredentialSuccessfully(t *testing.T) {
 
 // HandleCreateEC2CredentialSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests application credential creation.
-func HandleCreateEC2CredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/credentials/OS-EC2", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateEC2CredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/credentials/OS-EC2", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -152,8 +152,8 @@ func HandleCreateEC2CredentialSuccessfully(t *testing.T) {
 
 // HandleDeleteEC2CredentialSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests application credential deletion.
-func HandleDeleteEC2CredentialSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/credentials/OS-EC2/f741662395b249c9b8acdebf1722c5ae", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteEC2CredentialSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/2844b2a08be147a08ef58317d6471f1f/credentials/OS-EC2/f741662395b249c9b8acdebf1722c5ae", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v3/ec2credentials/testing/requests_test.go b/openstack/identity/v3/ec2credentials/testing/requests_test.go
index a20e4b70f..1344aed51 100644
--- a/openstack/identity/v3/ec2credentials/testing/requests_test.go
+++ b/openstack/identity/v3/ec2credentials/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListEC2Credentials(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListEC2CredentialsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListEC2CredentialsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := ec2credentials.List(client.ServiceClient(), userID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := ec2credentials.List(client.ServiceClient(fakeServer), userID).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := ec2credentials.ExtractCredentials(page)
@@ -31,11 +31,11 @@ func TestListEC2Credentials(t *testing.T) {
 }
 
 func TestListEC2CredentialsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListEC2CredentialsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListEC2CredentialsSuccessfully(t, fakeServer)
 
-	allPages, err := ec2credentials.List(client.ServiceClient(), userID).AllPages(context.TODO())
+	allPages, err := ec2credentials.List(client.ServiceClient(fakeServer), userID).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := ec2credentials.ExtractCredentials(allPages)
 	th.AssertNoErr(t, err)
@@ -43,34 +43,34 @@ func TestListEC2CredentialsAllPages(t *testing.T) {
 }
 
 func TestGetEC2Credential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetEC2CredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetEC2CredentialSuccessfully(t, fakeServer)
 
-	actual, err := ec2credentials.Get(context.TODO(), client.ServiceClient(), userID, credentialID).Extract()
+	actual, err := ec2credentials.Get(context.TODO(), client.ServiceClient(fakeServer), userID, credentialID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, EC2Credential, *actual)
 }
 
 func TestCreateEC2Credential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateEC2CredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateEC2CredentialSuccessfully(t, fakeServer)
 
 	createOpts := ec2credentials.CreateOpts{
 		TenantID: "6238dee2fec940a6bf31e49e9faf995a",
 	}
 
-	actual, err := ec2credentials.Create(context.TODO(), client.ServiceClient(), userID, createOpts).Extract()
+	actual, err := ec2credentials.Create(context.TODO(), client.ServiceClient(fakeServer), userID, createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, EC2Credential, *actual)
 }
 
 func TestDeleteEC2Credential(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteEC2CredentialSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteEC2CredentialSuccessfully(t, fakeServer)
 
-	res := ec2credentials.Delete(context.TODO(), client.ServiceClient(), userID, credentialID)
+	res := ec2credentials.Delete(context.TODO(), client.ServiceClient(fakeServer), userID, credentialID)
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/ec2tokens/testing/requests_test.go b/openstack/identity/v3/ec2tokens/testing/requests_test.go
index 8fe0b3c3f..ae075a4c8 100644
--- a/openstack/identity/v3/ec2tokens/testing/requests_test.go
+++ b/openstack/identity/v3/ec2tokens/testing/requests_test.go
@@ -17,15 +17,15 @@ import (
 
 // authTokenPost verifies that providing certain AuthOptions and Scope results in an expected JSON structure.
 func authTokenPost(t *testing.T, options ec2tokens.AuthOptions, requestJSON string) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	client := gophercloud.ServiceClient{
 		ProviderClient: &gophercloud.ProviderClient{},
-		Endpoint:       th.Endpoint(),
+		Endpoint:       fakeServer.Endpoint(),
 	}
 
-	th.Mux.HandleFunc("/ec2tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/ec2tokens", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/identity/v3/endpoints/testing/requests_test.go b/openstack/identity/v3/endpoints/testing/requests_test.go
index ad138acd4..7c418aed8 100644
--- a/openstack/identity/v3/endpoints/testing/requests_test.go
+++ b/openstack/identity/v3/endpoints/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestCreateSuccessful(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/endpoints", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/endpoints", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -47,7 +47,7 @@ func TestCreateSuccessful(t *testing.T) {
 		}`)
 	})
 
-	actual, err := endpoints.Create(context.TODO(), client.ServiceClient(), endpoints.CreateOpts{
+	actual, err := endpoints.Create(context.TODO(), client.ServiceClient(fakeServer), endpoints.CreateOpts{
 		Availability: gophercloud.AvailabilityPublic,
 		Name:         "the-endiest-of-points",
 		Region:       "underground",
@@ -70,10 +70,10 @@ func TestCreateSuccessful(t *testing.T) {
 }
 
 func TestListEndpoints(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/endpoints", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/endpoints", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -113,7 +113,7 @@ func TestListEndpoints(t *testing.T) {
 	})
 
 	count := 0
-	err := endpoints.List(client.ServiceClient(), endpoints.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := endpoints.List(client.ServiceClient(fakeServer), endpoints.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := endpoints.ExtractEndpoints(page)
 		if err != nil {
@@ -149,10 +149,10 @@ func TestListEndpoints(t *testing.T) {
 }
 
 func TestGetEndpoint(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/endpoints/12", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/endpoints/12", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -172,7 +172,7 @@ func TestGetEndpoint(t *testing.T) {
 		}`)
 	})
 
-	actual, err := endpoints.Get(context.TODO(), client.ServiceClient(), "12").Extract()
+	actual, err := endpoints.Get(context.TODO(), client.ServiceClient(fakeServer), "12").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected error from Get: %v", err)
 	}
@@ -190,10 +190,10 @@ func TestGetEndpoint(t *testing.T) {
 }
 
 func TestUpdateEndpoint(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/endpoints/12", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/endpoints/12", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -219,7 +219,7 @@ func TestUpdateEndpoint(t *testing.T) {
 		}`)
 	})
 
-	actual, err := endpoints.Update(context.TODO(), client.ServiceClient(), "12", endpoints.UpdateOpts{
+	actual, err := endpoints.Update(context.TODO(), client.ServiceClient(fakeServer), "12", endpoints.UpdateOpts{
 		Name:   "renamed",
 		Region: "somewhere-else",
 	}).Extract()
@@ -240,16 +240,16 @@ func TestUpdateEndpoint(t *testing.T) {
 }
 
 func TestDeleteEndpoint(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/endpoints/34", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/endpoints/34", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := endpoints.Delete(context.TODO(), client.ServiceClient(), "34")
+	res := endpoints.Delete(context.TODO(), client.ServiceClient(fakeServer), "34")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/federation/testing/fixtures_test.go b/openstack/identity/v3/federation/testing/fixtures_test.go
index 229d2f489..7213e3a91 100644
--- a/openstack/identity/v3/federation/testing/fixtures_test.go
+++ b/openstack/identity/v3/federation/testing/fixtures_test.go
@@ -281,8 +281,8 @@ var ExpectedMappingsSlice = []federation.Mapping{MappingACME}
 
 // HandleListMappingsSuccessfully creates an HTTP handler at `/mappings` on the
 // test handler mux that responds with a list of two mappings.
-func HandleListMappingsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-FEDERATION/mappings", func(w http.ResponseWriter, r *http.Request) {
+func HandleListMappingsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-FEDERATION/mappings", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -295,8 +295,8 @@ func HandleListMappingsSuccessfully(t *testing.T) {
 
 // HandleCreateMappingSuccessfully creates an HTTP handler at `/mappings` on the
 // test handler mux that tests mapping creation.
-func HandleCreateMappingSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-FEDERATION/mappings/ACME", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateMappingSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-FEDERATION/mappings/ACME", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -308,8 +308,8 @@ func HandleCreateMappingSuccessfully(t *testing.T) {
 
 // HandleGetMappingSuccessfully creates an HTTP handler at `/mappings` on the
 // test handler mux that responds with a single mapping.
-func HandleGetMappingSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-FEDERATION/mappings/ACME", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetMappingSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-FEDERATION/mappings/ACME", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -322,8 +322,8 @@ func HandleGetMappingSuccessfully(t *testing.T) {
 
 // HandleUpdateMappingSuccessfully creates an HTTP handler at `/mappings` on the
 // test handler mux that tests mapping update.
-func HandleUpdateMappingSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-FEDERATION/mappings/ACME", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateMappingSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-FEDERATION/mappings/ACME", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
@@ -335,8 +335,8 @@ func HandleUpdateMappingSuccessfully(t *testing.T) {
 
 // HandleDeleteMappingSuccessfully creates an HTTP handler at `/mappings` on the
 // test handler mux that tests mapping deletion.
-func HandleDeleteMappingSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-FEDERATION/mappings/ACME", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteMappingSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-FEDERATION/mappings/ACME", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v3/federation/testing/requests_test.go b/openstack/identity/v3/federation/testing/requests_test.go
index 0d156b8d1..29f2db2a8 100644
--- a/openstack/identity/v3/federation/testing/requests_test.go
+++ b/openstack/identity/v3/federation/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListMappings(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListMappingsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListMappingsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := federation.ListMappings(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := federation.ListMappings(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := federation.ExtractMappings(page)
@@ -31,11 +31,11 @@ func TestListMappings(t *testing.T) {
 }
 
 func TestListMappingsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListMappingsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListMappingsSuccessfully(t, fakeServer)
 
-	allPages, err := federation.ListMappings(client.ServiceClient()).AllPages(context.TODO())
+	allPages, err := federation.ListMappings(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := federation.ExtractMappings(allPages)
 	th.AssertNoErr(t, err)
@@ -43,9 +43,9 @@ func TestListMappingsAllPages(t *testing.T) {
 }
 
 func TestCreateMappings(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateMappingSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateMappingSuccessfully(t, fakeServer)
 
 	createOpts := federation.CreateMappingOpts{
 		Rules: []federation.MappingRule{
@@ -78,25 +78,25 @@ func TestCreateMappings(t *testing.T) {
 		},
 	}
 
-	actual, err := federation.CreateMapping(context.TODO(), client.ServiceClient(), "ACME", createOpts).Extract()
+	actual, err := federation.CreateMapping(context.TODO(), client.ServiceClient(fakeServer), "ACME", createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, MappingACME, *actual)
 }
 
 func TestGetMapping(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetMappingSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetMappingSuccessfully(t, fakeServer)
 
-	actual, err := federation.GetMapping(context.TODO(), client.ServiceClient(), "ACME").Extract()
+	actual, err := federation.GetMapping(context.TODO(), client.ServiceClient(fakeServer), "ACME").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, MappingACME, *actual)
 }
 
 func TestUpdateMapping(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateMappingSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateMappingSuccessfully(t, fakeServer)
 
 	updateOpts := federation.UpdateMappingOpts{
 		Rules: []federation.MappingRule{
@@ -129,16 +129,16 @@ func TestUpdateMapping(t *testing.T) {
 		},
 	}
 
-	actual, err := federation.UpdateMapping(context.TODO(), client.ServiceClient(), "ACME", updateOpts).Extract()
+	actual, err := federation.UpdateMapping(context.TODO(), client.ServiceClient(fakeServer), "ACME", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, MappingUpdated, *actual)
 }
 
 func TestDeleteMapping(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteMappingSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteMappingSuccessfully(t, fakeServer)
 
-	res := federation.DeleteMapping(context.TODO(), client.ServiceClient(), "ACME")
+	res := federation.DeleteMapping(context.TODO(), client.ServiceClient(fakeServer), "ACME")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/groups/testing/fixtures_test.go b/openstack/identity/v3/groups/testing/fixtures_test.go
index 415d81555..fb5bd178d 100644
--- a/openstack/identity/v3/groups/testing/fixtures_test.go
+++ b/openstack/identity/v3/groups/testing/fixtures_test.go
@@ -152,8 +152,8 @@ var ExpectedGroupsSlice = []groups.Group{FirstGroup, SecondGroup}
 
 // HandleListGroupsSuccessfully creates an HTTP handler at `/groups` on the
 // test handler mux that responds with a list of two groups.
-func HandleListGroupsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups", func(w http.ResponseWriter, r *http.Request) {
+func HandleListGroupsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -166,8 +166,8 @@ func HandleListGroupsSuccessfully(t *testing.T) {
 
 // HandleGetGroupSuccessfully creates an HTTP handler at `/groups` on the
 // test handler mux that responds with a single group.
-func HandleGetGroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetGroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -180,8 +180,8 @@ func HandleGetGroupSuccessfully(t *testing.T) {
 
 // HandleCreateGroupSuccessfully creates an HTTP handler at `/groups` on the
 // test handler mux that tests group creation.
-func HandleCreateGroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateGroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -193,8 +193,8 @@ func HandleCreateGroupSuccessfully(t *testing.T) {
 
 // HandleUpdateGroupSuccessfully creates an HTTP handler at `/groups` on the
 // test handler mux that tests group update.
-func HandleUpdateGroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateGroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
@@ -206,8 +206,8 @@ func HandleUpdateGroupSuccessfully(t *testing.T) {
 
 // HandleDeleteGroupSuccessfully creates an HTTP handler at `/groups` on the
 // test handler mux that tests group deletion.
-func HandleDeleteGroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteGroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v3/groups/testing/requests_test.go b/openstack/identity/v3/groups/testing/requests_test.go
index 5f6b7b9f5..811736802 100644
--- a/openstack/identity/v3/groups/testing/requests_test.go
+++ b/openstack/identity/v3/groups/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListGroups(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListGroupsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListGroupsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := groups.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := groups.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := groups.ExtractGroups(page)
@@ -31,11 +31,11 @@ func TestListGroups(t *testing.T) {
 }
 
 func TestListGroupsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListGroupsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListGroupsSuccessfully(t, fakeServer)
 
-	allPages, err := groups.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := groups.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := groups.ExtractGroups(allPages)
 	th.AssertNoErr(t, err)
@@ -77,11 +77,11 @@ func TestListGroupsFiltersCheck(t *testing.T) {
 }
 
 func TestGetGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetGroupSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetGroupSuccessfully(t, fakeServer)
 
-	actual, err := groups.Get(context.TODO(), client.ServiceClient(), "9fe1d3").Extract()
+	actual, err := groups.Get(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3").Extract()
 
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondGroup, *actual)
@@ -89,9 +89,9 @@ func TestGetGroup(t *testing.T) {
 }
 
 func TestCreateGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateGroupSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateGroupSuccessfully(t, fakeServer)
 
 	createOpts := groups.CreateOpts{
 		Name:        "support",
@@ -102,15 +102,15 @@ func TestCreateGroup(t *testing.T) {
 		},
 	}
 
-	actual, err := groups.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := groups.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondGroup, *actual)
 }
 
 func TestUpdateGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateGroupSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateGroupSuccessfully(t, fakeServer)
 
 	var description = "L2 Support Team"
 	updateOpts := groups.UpdateOpts{
@@ -120,16 +120,16 @@ func TestUpdateGroup(t *testing.T) {
 		},
 	}
 
-	actual, err := groups.Update(context.TODO(), client.ServiceClient(), "9fe1d3", updateOpts).Extract()
+	actual, err := groups.Update(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondGroupUpdated, *actual)
 }
 
 func TestDeleteGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteGroupSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteGroupSuccessfully(t, fakeServer)
 
-	res := groups.Delete(context.TODO(), client.ServiceClient(), "9fe1d3")
+	res := groups.Delete(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/limits/testing/fixtures_test.go b/openstack/identity/v3/limits/testing/fixtures_test.go
index 5f8cbff16..0674ffc08 100644
--- a/openstack/identity/v3/limits/testing/fixtures_test.go
+++ b/openstack/identity/v3/limits/testing/fixtures_test.go
@@ -175,8 +175,8 @@ var ExpectedLimitsSlice = []limits.Limit{FirstLimit, SecondLimit}
 
 // HandleGetEnforcementModelSuccessfully creates an HTTP handler at `/limits/model` on the
 // test handler mux that responds with a enforcement model.
-func HandleGetEnforcementModelSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits/model", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetEnforcementModelSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits/model", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -189,8 +189,8 @@ func HandleGetEnforcementModelSuccessfully(t *testing.T) {
 
 // HandleListLimitsSuccessfully creates an HTTP handler at `/limits` on the
 // test handler mux that responds with a list of two limits.
-func HandleListLimitsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
+func HandleListLimitsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -203,8 +203,8 @@ func HandleListLimitsSuccessfully(t *testing.T) {
 
 // HandleCreateLimitSuccessfully creates an HTTP handler at `/limits` on the
 // test handler mux that tests limit creation.
-func HandleCreateLimitSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateLimitSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -216,8 +216,8 @@ func HandleCreateLimitSuccessfully(t *testing.T) {
 
 // HandleGetLimitSuccessfully creates an HTTP handler at `/limits` on the
 // test handler mux that responds with a single limit.
-func HandleGetLimitSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits/25a04c7a065c430590881c646cdcdd58", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetLimitSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits/25a04c7a065c430590881c646cdcdd58", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -230,8 +230,8 @@ func HandleGetLimitSuccessfully(t *testing.T) {
 
 // HandleUpdateLimitSuccessfully creates an HTTP handler at `/limits` on the
 // test handler mux that tests limit update.
-func HandleUpdateLimitSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateLimitSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
@@ -243,8 +243,8 @@ func HandleUpdateLimitSuccessfully(t *testing.T) {
 
 // HandleDeleteLimitSuccessfully creates an HTTP handler at `/limits` on the
 // test handler mux that tests limit deletion.
-func HandleDeleteLimitSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteLimitSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v3/limits/testing/requests_test.go b/openstack/identity/v3/limits/testing/requests_test.go
index 15cf4dbb8..e1dca5f73 100644
--- a/openstack/identity/v3/limits/testing/requests_test.go
+++ b/openstack/identity/v3/limits/testing/requests_test.go
@@ -11,22 +11,22 @@ import (
 )
 
 func TestGetEnforcementModel(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetEnforcementModelSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetEnforcementModelSuccessfully(t, fakeServer)
 
-	actual, err := limits.GetEnforcementModel(context.TODO(), client.ServiceClient()).Extract()
+	actual, err := limits.GetEnforcementModel(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, Model, *actual)
 }
 
 func TestListLimits(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListLimitsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListLimitsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := limits.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := limits.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := limits.ExtractLimits(page)
@@ -41,11 +41,11 @@ func TestListLimits(t *testing.T) {
 }
 
 func TestListLimitsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListLimitsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListLimitsSuccessfully(t, fakeServer)
 
-	allPages, err := limits.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := limits.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := limits.ExtractLimits(allPages)
 	th.AssertNoErr(t, err)
@@ -53,9 +53,9 @@ func TestListLimitsAllPages(t *testing.T) {
 }
 
 func TestCreateLimits(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateLimitSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateLimitSuccessfully(t, fakeServer)
 
 	createOpts := limits.BatchCreateOpts{
 		limits.CreateOpts{
@@ -74,25 +74,25 @@ func TestCreateLimits(t *testing.T) {
 		},
 	}
 
-	actual, err := limits.BatchCreate(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := limits.BatchCreate(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedLimitsSlice, actual)
 }
 
 func TestGetLimit(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetLimitSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetLimitSuccessfully(t, fakeServer)
 
-	actual, err := limits.Get(context.TODO(), client.ServiceClient(), "25a04c7a065c430590881c646cdcdd58").Extract()
+	actual, err := limits.Get(context.TODO(), client.ServiceClient(fakeServer), "25a04c7a065c430590881c646cdcdd58").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, FirstLimit, *actual)
 }
 
 func TestUpdateLimit(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateLimitSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateLimitSuccessfully(t, fakeServer)
 
 	var description = "Number of snapshots for project 3a705b9f56bb439381b43c4fe59dccce"
 	var resourceLimit = 5
@@ -101,16 +101,16 @@ func TestUpdateLimit(t *testing.T) {
 		ResourceLimit: &resourceLimit,
 	}
 
-	actual, err := limits.Update(context.TODO(), client.ServiceClient(), "3229b3849f584faea483d6851f7aab05", updateOpts).Extract()
+	actual, err := limits.Update(context.TODO(), client.ServiceClient(fakeServer), "3229b3849f584faea483d6851f7aab05", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondLimitUpdated, *actual)
 }
 
 func TestDeleteLimit(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteLimitSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteLimitSuccessfully(t, fakeServer)
 
-	err := limits.Delete(context.TODO(), client.ServiceClient(), "3229b3849f584faea483d6851f7aab05").ExtractErr()
+	err := limits.Delete(context.TODO(), client.ServiceClient(fakeServer), "3229b3849f584faea483d6851f7aab05").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/identity/v3/oauth1/testing/fixtures_test.go b/openstack/identity/v3/oauth1/testing/fixtures_test.go
index b8d5dc332..493adad8e 100644
--- a/openstack/identity/v3/oauth1/testing/fixtures_test.go
+++ b/openstack/identity/v3/oauth1/testing/fixtures_test.go
@@ -220,8 +220,8 @@ var ExpectedUserAccessTokenRolesSlice = []oauth1.AccessTokenRole{UserAccessToken
 
 // HandleCreateConsumer creates an HTTP handler at `/OS-OAUTH1/consumers` on the
 // test handler mux that tests consumer creation.
-func HandleCreateConsumer(t *testing.T) {
-	th.Mux.HandleFunc("/OS-OAUTH1/consumers", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateConsumer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-OAUTH1/consumers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -235,8 +235,8 @@ func HandleCreateConsumer(t *testing.T) {
 
 // HandleUpdateConsumer creates an HTTP handler at `/OS-OAUTH1/consumers/7fea2d` on the
 // test handler mux that tests consumer update.
-func HandleUpdateConsumer(t *testing.T) {
-	th.Mux.HandleFunc("/OS-OAUTH1/consumers/7fea2d", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateConsumer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-OAUTH1/consumers/7fea2d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -250,8 +250,8 @@ func HandleUpdateConsumer(t *testing.T) {
 
 // HandleDeleteConsumer creates an HTTP handler at `/OS-OAUTH1/consumers/7fea2d` on the
 // test handler mux that tests consumer deletion.
-func HandleDeleteConsumer(t *testing.T) {
-	th.Mux.HandleFunc("/OS-OAUTH1/consumers/7fea2d", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteConsumer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-OAUTH1/consumers/7fea2d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -261,8 +261,8 @@ func HandleDeleteConsumer(t *testing.T) {
 
 // HandleGetConsumer creates an HTTP handler at `/OS-OAUTH1/consumers/7fea2d` on the
 // test handler mux that responds with a single consumer.
-func HandleGetConsumer(t *testing.T) {
-	th.Mux.HandleFunc("/OS-OAUTH1/consumers/7fea2d", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetConsumer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-OAUTH1/consumers/7fea2d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -298,8 +298,8 @@ var ExpectedConsumersSlice = []oauth1.Consumer{FirstConsumer, SecondConsumer}
 
 // HandleListConsumers creates an HTTP handler at `/OS-OAUTH1/consumers` on the
 // test handler mux that responds with a list of two consumers.
-func HandleListConsumers(t *testing.T) {
-	th.Mux.HandleFunc("/OS-OAUTH1/consumers", func(w http.ResponseWriter, r *http.Request) {
+func HandleListConsumers(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-OAUTH1/consumers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -318,8 +318,8 @@ var Token = oauth1.Token{
 
 // HandleRequestToken creates an HTTP handler at `/OS-OAUTH1/request_token` on the
 // test handler mux that responds with a OAuth1 unauthorized token.
-func HandleRequestToken(t *testing.T) {
-	th.Mux.HandleFunc("/OS-OAUTH1/request_token", func(w http.ResponseWriter, r *http.Request) {
+func HandleRequestToken(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-OAUTH1/request_token", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -335,8 +335,8 @@ func HandleRequestToken(t *testing.T) {
 
 // HandleAuthorizeToken creates an HTTP handler at `/OS-OAUTH1/authorize/29971f` on the
 // test handler mux that tests unauthorized token authorization.
-func HandleAuthorizeToken(t *testing.T) {
-	th.Mux.HandleFunc("/OS-OAUTH1/authorize/29971f", func(w http.ResponseWriter, r *http.Request) {
+func HandleAuthorizeToken(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-OAUTH1/authorize/29971f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -356,8 +356,8 @@ var AccessToken = oauth1.Token{
 
 // HandleCreateAccessToken creates an HTTP handler at `/OS-OAUTH1/access_token` on the
 // test handler mux that responds with a OAuth1 access token.
-func HandleCreateAccessToken(t *testing.T) {
-	th.Mux.HandleFunc("/OS-OAUTH1/access_token", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateAccessToken(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-OAUTH1/access_token", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -372,8 +372,8 @@ func HandleCreateAccessToken(t *testing.T) {
 
 // HandleGetAccessToken creates an HTTP handler at `/users/ce9e07/OS-OAUTH1/access_tokens/6be26a` on the
 // test handler mux that responds with a single access token.
-func HandleGetAccessToken(t *testing.T) {
-	th.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens/6be26a", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetAccessToken(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens/6be26a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -386,8 +386,8 @@ func HandleGetAccessToken(t *testing.T) {
 
 // HandleRevokeAccessToken creates an HTTP handler at `/users/ce9e07/OS-OAUTH1/access_tokens/6be26a` on the
 // test handler mux that tests access token deletion.
-func HandleRevokeAccessToken(t *testing.T) {
-	th.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens/6be26a", func(w http.ResponseWriter, r *http.Request) {
+func HandleRevokeAccessToken(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens/6be26a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -397,8 +397,8 @@ func HandleRevokeAccessToken(t *testing.T) {
 
 // HandleListAccessTokens creates an HTTP handler at `/users/ce9e07/OS-OAUTH1/access_tokens` on the
 // test handler mux that responds with a slice of access tokens.
-func HandleListAccessTokens(t *testing.T) {
-	th.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens", func(w http.ResponseWriter, r *http.Request) {
+func HandleListAccessTokens(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -411,8 +411,8 @@ func HandleListAccessTokens(t *testing.T) {
 
 // HandleListAccessTokenRoles creates an HTTP handler at `/users/ce9e07/OS-OAUTH1/access_tokens/6be26a/roles` on the
 // test handler mux that responds with a slice of access token roles.
-func HandleListAccessTokenRoles(t *testing.T) {
-	th.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens/6be26a/roles", func(w http.ResponseWriter, r *http.Request) {
+func HandleListAccessTokenRoles(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens/6be26a/roles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -425,8 +425,8 @@ func HandleListAccessTokenRoles(t *testing.T) {
 
 // HandleGetAccessTokenRole creates an HTTP handler at `/users/ce9e07/OS-OAUTH1/access_tokens/6be26a/roles/5ad150` on the
 // test handler mux that responds with an access token role.
-func HandleGetAccessTokenRole(t *testing.T) {
-	th.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens/6be26a/roles/5ad150", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetAccessTokenRole(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/ce9e07/OS-OAUTH1/access_tokens/6be26a/roles/5ad150", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -439,8 +439,8 @@ func HandleGetAccessTokenRole(t *testing.T) {
 
 // HandleAuthenticate creates an HTTP handler at `/auth/tokens` on the
 // test handler mux that responds with an OpenStack token.
-func HandleAuthenticate(t *testing.T) {
-	th.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+func HandleAuthenticate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/identity/v3/oauth1/testing/requests_test.go b/openstack/identity/v3/oauth1/testing/requests_test.go
index 75f37bca0..1cf2f7174 100644
--- a/openstack/identity/v3/oauth1/testing/requests_test.go
+++ b/openstack/identity/v3/oauth1/testing/requests_test.go
@@ -13,11 +13,11 @@ import (
 )
 
 func TestCreateConsumer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateConsumer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateConsumer(t, fakeServer)
 
-	consumer, err := oauth1.CreateConsumer(context.TODO(), client.ServiceClient(), oauth1.CreateConsumerOpts{
+	consumer, err := oauth1.CreateConsumer(context.TODO(), client.ServiceClient(fakeServer), oauth1.CreateConsumerOpts{
 		Description: "My consumer",
 	}).Extract()
 	th.AssertNoErr(t, err)
@@ -26,11 +26,11 @@ func TestCreateConsumer(t *testing.T) {
 }
 
 func TestUpdateConsumer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateConsumer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateConsumer(t, fakeServer)
 
-	consumer, err := oauth1.UpdateConsumer(context.TODO(), client.ServiceClient(), "7fea2d", oauth1.UpdateConsumerOpts{
+	consumer, err := oauth1.UpdateConsumer(context.TODO(), client.ServiceClient(fakeServer), "7fea2d", oauth1.UpdateConsumerOpts{
 		Description: "My new consumer",
 	}).Extract()
 	th.AssertNoErr(t, err)
@@ -39,32 +39,32 @@ func TestUpdateConsumer(t *testing.T) {
 }
 
 func TestDeleteConsumer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteConsumer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteConsumer(t, fakeServer)
 
-	err := oauth1.DeleteConsumer(context.TODO(), client.ServiceClient(), "7fea2d").ExtractErr()
+	err := oauth1.DeleteConsumer(context.TODO(), client.ServiceClient(fakeServer), "7fea2d").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetConsumer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetConsumer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetConsumer(t, fakeServer)
 
-	consumer, err := oauth1.GetConsumer(context.TODO(), client.ServiceClient(), "7fea2d").Extract()
+	consumer, err := oauth1.GetConsumer(context.TODO(), client.ServiceClient(fakeServer), "7fea2d").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, FirstConsumer, *consumer)
 }
 
 func TestListConsumers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListConsumers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListConsumers(t, fakeServer)
 
 	count := 0
-	err := oauth1.ListConsumers(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := oauth1.ListConsumers(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := oauth1.ExtractConsumers(page)
@@ -79,11 +79,11 @@ func TestListConsumers(t *testing.T) {
 }
 
 func TestListConsumersAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListConsumers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListConsumers(t, fakeServer)
 
-	allPages, err := oauth1.ListConsumers(client.ServiceClient()).AllPages(context.TODO())
+	allPages, err := oauth1.ListConsumers(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := oauth1.ExtractConsumers(allPages)
 	th.AssertNoErr(t, err)
@@ -91,12 +91,12 @@ func TestListConsumersAllPages(t *testing.T) {
 }
 
 func TestRequestToken(t *testing.T) {
-	th.SetupPersistentPortHTTP(t, 33199)
-	defer th.TeardownHTTP()
-	HandleRequestToken(t)
+	fakeServer := th.SetupPersistentPortHTTP(t, 33199)
+	defer fakeServer.Teardown()
+	HandleRequestToken(t, fakeServer)
 
 	ts := time.Unix(0, 0)
-	token, err := oauth1.RequestToken(context.TODO(), client.ServiceClient(), oauth1.RequestTokenOpts{
+	token, err := oauth1.RequestToken(context.TODO(), client.ServiceClient(fakeServer), oauth1.RequestTokenOpts{
 		OAuthConsumerKey:     Consumer.ID,
 		OAuthConsumerSecret:  Consumer.Secret,
 		OAuthSignatureMethod: oauth1.HMACSHA1,
@@ -110,11 +110,11 @@ func TestRequestToken(t *testing.T) {
 }
 
 func TestAuthorizeToken(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAuthorizeToken(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAuthorizeToken(t, fakeServer)
 
-	token, err := oauth1.AuthorizeToken(context.TODO(), client.ServiceClient(), "29971f", oauth1.AuthorizeTokenOpts{
+	token, err := oauth1.AuthorizeToken(context.TODO(), client.ServiceClient(fakeServer), "29971f", oauth1.AuthorizeTokenOpts{
 		Roles: []oauth1.Role{
 			{
 				ID: "a3b29b",
@@ -130,12 +130,12 @@ func TestAuthorizeToken(t *testing.T) {
 }
 
 func TestCreateAccessToken(t *testing.T) {
-	th.SetupPersistentPortHTTP(t, 33199)
-	defer th.TeardownHTTP()
-	HandleCreateAccessToken(t)
+	fakeServer := th.SetupPersistentPortHTTP(t, 33199)
+	defer fakeServer.Teardown()
+	HandleCreateAccessToken(t, fakeServer)
 
 	ts := time.Unix(1586804894, 0)
-	token, err := oauth1.CreateAccessToken(context.TODO(), client.ServiceClient(), oauth1.CreateAccessTokenOpts{
+	token, err := oauth1.CreateAccessToken(context.TODO(), client.ServiceClient(fakeServer), oauth1.CreateAccessTokenOpts{
 		OAuthConsumerKey:     Consumer.ID,
 		OAuthConsumerSecret:  Consumer.Secret,
 		OAuthToken:           Token.OAuthToken,
@@ -151,32 +151,32 @@ func TestCreateAccessToken(t *testing.T) {
 }
 
 func TestGetAccessToken(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetAccessToken(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetAccessToken(t, fakeServer)
 
-	token, err := oauth1.GetAccessToken(context.TODO(), client.ServiceClient(), "ce9e07", "6be26a").Extract()
+	token, err := oauth1.GetAccessToken(context.TODO(), client.ServiceClient(fakeServer), "ce9e07", "6be26a").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, UserAccessToken, *token)
 }
 
 func TestRevokeAccessToken(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRevokeAccessToken(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRevokeAccessToken(t, fakeServer)
 
-	err := oauth1.RevokeAccessToken(context.TODO(), client.ServiceClient(), "ce9e07", "6be26a").ExtractErr()
+	err := oauth1.RevokeAccessToken(context.TODO(), client.ServiceClient(fakeServer), "ce9e07", "6be26a").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListAccessTokens(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAccessTokens(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAccessTokens(t, fakeServer)
 
 	count := 0
-	err := oauth1.ListAccessTokens(client.ServiceClient(), "ce9e07").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := oauth1.ListAccessTokens(client.ServiceClient(fakeServer), "ce9e07").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := oauth1.ExtractAccessTokens(page)
@@ -191,11 +191,11 @@ func TestListAccessTokens(t *testing.T) {
 }
 
 func TestListAccessTokensAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAccessTokens(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAccessTokens(t, fakeServer)
 
-	allPages, err := oauth1.ListAccessTokens(client.ServiceClient(), "ce9e07").AllPages(context.TODO())
+	allPages, err := oauth1.ListAccessTokens(client.ServiceClient(fakeServer), "ce9e07").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := oauth1.ExtractAccessTokens(allPages)
 	th.AssertNoErr(t, err)
@@ -203,12 +203,12 @@ func TestListAccessTokensAllPages(t *testing.T) {
 }
 
 func TestListAccessTokenRoles(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAccessTokenRoles(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAccessTokenRoles(t, fakeServer)
 
 	count := 0
-	err := oauth1.ListAccessTokenRoles(client.ServiceClient(), "ce9e07", "6be26a").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := oauth1.ListAccessTokenRoles(client.ServiceClient(fakeServer), "ce9e07", "6be26a").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := oauth1.ExtractAccessTokenRoles(page)
@@ -223,11 +223,11 @@ func TestListAccessTokenRoles(t *testing.T) {
 }
 
 func TestListAccessTokenRolesAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAccessTokenRoles(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAccessTokenRoles(t, fakeServer)
 
-	allPages, err := oauth1.ListAccessTokenRoles(client.ServiceClient(), "ce9e07", "6be26a").AllPages(context.TODO())
+	allPages, err := oauth1.ListAccessTokenRoles(client.ServiceClient(fakeServer), "ce9e07", "6be26a").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := oauth1.ExtractAccessTokenRoles(allPages)
 	th.AssertNoErr(t, err)
@@ -235,20 +235,20 @@ func TestListAccessTokenRolesAllPages(t *testing.T) {
 }
 
 func TestGetAccessTokenRole(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetAccessTokenRole(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetAccessTokenRole(t, fakeServer)
 
-	role, err := oauth1.GetAccessTokenRole(context.TODO(), client.ServiceClient(), "ce9e07", "6be26a", "5ad150").Extract()
+	role, err := oauth1.GetAccessTokenRole(context.TODO(), client.ServiceClient(fakeServer), "ce9e07", "6be26a", "5ad150").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, UserAccessTokenRole, *role)
 }
 
 func TestAuthenticate(t *testing.T) {
-	th.SetupPersistentPortHTTP(t, 33199)
-	defer th.TeardownHTTP()
-	HandleAuthenticate(t)
+	fakeServer := th.SetupPersistentPortHTTP(t, 33199)
+	defer fakeServer.Teardown()
+	HandleAuthenticate(t, fakeServer)
 
 	expected := &tokens.Token{
 		ExpiresAt: time.Date(2017, 6, 3, 2, 19, 49, 0, time.UTC),
@@ -265,7 +265,7 @@ func TestAuthenticate(t *testing.T) {
 		OAuthNonce:           "66148873158553341551586804894",
 	}
 
-	actual, err := oauth1.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	actual, err := oauth1.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 }
diff --git a/openstack/identity/v3/osinherit/testing/fixtures_test.go b/openstack/identity/v3/osinherit/testing/fixtures_test.go
index e0c33646f..b053bba45 100644
--- a/openstack/identity/v3/osinherit/testing/fixtures_test.go
+++ b/openstack/identity/v3/osinherit/testing/fixtures_test.go
@@ -5,83 +5,83 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func HandleAssignSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+func HandleAssignSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func HandleValidateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+func HandleValidateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func HandleUnassignSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+func HandleUnassignSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/projects/{project_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/users/{user_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-INHERIT/domains/{domain_id}/groups/{group_id}/roles/{role_id}/inherited_to_projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
diff --git a/openstack/identity/v3/osinherit/testing/requests_test.go b/openstack/identity/v3/osinherit/testing/requests_test.go
index 7901a689c..8b90f2649 100644
--- a/openstack/identity/v3/osinherit/testing/requests_test.go
+++ b/openstack/identity/v3/osinherit/testing/requests_test.go
@@ -10,41 +10,41 @@ import (
 )
 
 func TestAssign(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAssignSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAssignSuccessfully(t, fakeServer)
 
-	err := osinherit.Assign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.AssignOpts{
+	err := osinherit.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.AssignOpts{
 		UserID:    "{user_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Assign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.AssignOpts{
+	err = osinherit.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.AssignOpts{
 		UserID:   "{user_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Assign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.AssignOpts{
+	err = osinherit.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.AssignOpts{
 		GroupID:   "{group_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Assign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.AssignOpts{
+	err = osinherit.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.AssignOpts{
 		GroupID:  "{group_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Assign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.AssignOpts{
+	err = osinherit.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.AssignOpts{
 		GroupID: "{group_id}",
 		UserID:  "{user_id}",
 	}).ExtractErr()
 	th.AssertErr(t, err)
 
-	err = osinherit.Assign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.AssignOpts{
+	err = osinherit.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.AssignOpts{
 		ProjectID: "{project_id}",
 		DomainID:  "{domain_id}",
 	}).ExtractErr()
@@ -52,41 +52,41 @@ func TestAssign(t *testing.T) {
 }
 
 func TestValidate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleValidateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleValidateSuccessfully(t, fakeServer)
 
-	err := osinherit.Validate(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.ValidateOpts{
+	err := osinherit.Validate(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.ValidateOpts{
 		UserID:    "{user_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Validate(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.ValidateOpts{
+	err = osinherit.Validate(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.ValidateOpts{
 		UserID:   "{user_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Validate(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.ValidateOpts{
+	err = osinherit.Validate(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.ValidateOpts{
 		GroupID:   "{group_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Validate(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.ValidateOpts{
+	err = osinherit.Validate(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.ValidateOpts{
 		GroupID:  "{group_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Validate(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.ValidateOpts{
+	err = osinherit.Validate(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.ValidateOpts{
 		GroupID: "{group_id}",
 		UserID:  "{user_id}",
 	}).ExtractErr()
 	th.AssertErr(t, err)
 
-	err = osinherit.Validate(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.ValidateOpts{
+	err = osinherit.Validate(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.ValidateOpts{
 		ProjectID: "{project_id}",
 		DomainID:  "{domain_id}",
 	}).ExtractErr()
@@ -94,41 +94,41 @@ func TestValidate(t *testing.T) {
 }
 
 func TestUnassign(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUnassignSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUnassignSuccessfully(t, fakeServer)
 
-	err := osinherit.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.UnassignOpts{
+	err := osinherit.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.UnassignOpts{
 		UserID:    "{user_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.UnassignOpts{
+	err = osinherit.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.UnassignOpts{
 		UserID:   "{user_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.UnassignOpts{
+	err = osinherit.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.UnassignOpts{
 		GroupID:   "{group_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.UnassignOpts{
+	err = osinherit.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.UnassignOpts{
 		GroupID:  "{group_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = osinherit.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.UnassignOpts{
+	err = osinherit.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.UnassignOpts{
 		GroupID: "{group_id}",
 		UserID:  "{user_id}",
 	}).ExtractErr()
 	th.AssertErr(t, err)
 
-	err = osinherit.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", osinherit.UnassignOpts{
+	err = osinherit.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", osinherit.UnassignOpts{
 		ProjectID: "{project_id}",
 		DomainID:  "{domain_id}",
 	}).ExtractErr()
diff --git a/openstack/identity/v3/policies/testing/fixtures_test.go b/openstack/identity/v3/policies/testing/fixtures_test.go
index d261ed865..50e9366fa 100644
--- a/openstack/identity/v3/policies/testing/fixtures_test.go
+++ b/openstack/identity/v3/policies/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/identity/v3/policies"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // ListOutput provides a single page of Policy results.
@@ -154,11 +154,11 @@ var ExpectedPoliciesSlice = []policies.Policy{FirstPolicy, SecondPolicy}
 
 // HandleListPoliciesSuccessfully creates an HTTP handler at `/policies` on the
 // test handler mux that responds with a list of two policies.
-func HandleListPoliciesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/policies", func(w http.ResponseWriter, r *http.Request) {
+func HandleListPoliciesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -175,10 +175,10 @@ func HandleListPoliciesSuccessfully(t *testing.T) {
 
 // HandleCreatePolicySuccessfully creates an HTTP handler at `/policies` on the
 // test handler mux that tests policy creation.
-func HandleCreatePolicySuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/policies", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreatePolicySuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
 
 		w.WriteHeader(http.StatusCreated)
@@ -188,12 +188,12 @@ func HandleCreatePolicySuccessfully(t *testing.T) {
 
 // HandleGetPolicySuccessfully creates an HTTP handler at `/policies` on the
 // test handler mux that responds with a single policy.
-func HandleGetPolicySuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/policies/b49884da9d31494ea02aff38d4b4e701",
+func HandleGetPolicySuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/policies/b49884da9d31494ea02aff38d4b4e701",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "Accept", "application/json")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Set("Content-Type", "application/json")
 			w.WriteHeader(http.StatusOK)
@@ -204,11 +204,11 @@ func HandleGetPolicySuccessfully(t *testing.T) {
 
 // HandleUpdatePolicySuccessfully creates an HTTP handler at `/policies` on the
 // test handler mux that tests role update.
-func HandleUpdatePolicySuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/policies/b49884da9d31494ea02aff38d4b4e701",
+func HandleUpdatePolicySuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/policies/b49884da9d31494ea02aff38d4b4e701",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PATCH")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, UpdateRequest)
 
 			w.WriteHeader(http.StatusOK)
@@ -219,10 +219,10 @@ func HandleUpdatePolicySuccessfully(t *testing.T) {
 
 // HandleDeletePolicySuccessfully creates an HTTP handler at `/policies` on the
 // test handler mux that tests policy deletion.
-func HandleDeletePolicySuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/policies/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeletePolicySuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/policies/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	})
diff --git a/openstack/identity/v3/policies/testing/requests_test.go b/openstack/identity/v3/policies/testing/requests_test.go
index f837543b3..e54f9703a 100644
--- a/openstack/identity/v3/policies/testing/requests_test.go
+++ b/openstack/identity/v3/policies/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestListPolicies(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListPoliciesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListPoliciesSuccessfully(t, fakeServer)
 
 	count := 0
-	err := policies.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := policies.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := policies.ExtractPolicies(page)
@@ -32,11 +32,11 @@ func TestListPolicies(t *testing.T) {
 }
 
 func TestListPoliciesAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListPoliciesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListPoliciesSuccessfully(t, fakeServer)
 
-	allPages, err := policies.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := policies.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := policies.ExtractPolicies(allPages)
 	th.AssertNoErr(t, err)
@@ -44,14 +44,14 @@ func TestListPoliciesAllPages(t *testing.T) {
 }
 
 func TestListPoliciesWithFilter(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListPoliciesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListPoliciesSuccessfully(t, fakeServer)
 
 	listOpts := policies.ListOpts{
 		Type: "application/json",
 	}
-	allPages, err := policies.List(client.ServiceClient(), listOpts).AllPages(context.TODO())
+	allPages, err := policies.List(client.ServiceClient(fakeServer), listOpts).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := policies.ExtractPolicies(allPages)
 	th.AssertNoErr(t, err)
@@ -91,9 +91,9 @@ func TestListPoliciesFiltersCheck(t *testing.T) {
 }
 
 func TestCreatePolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreatePolicySuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreatePolicySuccessfully(t, fakeServer)
 
 	createOpts := policies.CreateOpts{
 		Type: "application/json",
@@ -103,7 +103,7 @@ func TestCreatePolicy(t *testing.T) {
 		},
 	}
 
-	actual, err := policies.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := policies.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondPolicy, *actual)
 }
@@ -152,21 +152,21 @@ func TestCreatePolicyTypeLengthCheck(t *testing.T) {
 }
 
 func TestGetPolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetPolicySuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetPolicySuccessfully(t, fakeServer)
 
 	id := "b49884da9d31494ea02aff38d4b4e701"
-	actual, err := policies.Get(context.TODO(), client.ServiceClient(), id).Extract()
+	actual, err := policies.Get(context.TODO(), client.ServiceClient(fakeServer), id).Extract()
 
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondPolicy, *actual)
 }
 
 func TestUpdatePolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdatePolicySuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdatePolicySuccessfully(t, fakeServer)
 
 	updateOpts := policies.UpdateOpts{
 		Extra: map[string]any{
@@ -175,7 +175,7 @@ func TestUpdatePolicy(t *testing.T) {
 	}
 
 	id := "b49884da9d31494ea02aff38d4b4e701"
-	actual, err := policies.Update(context.TODO(), client.ServiceClient(), id, updateOpts).Extract()
+	actual, err := policies.Update(context.TODO(), client.ServiceClient(fakeServer), id, updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondPolicyUpdated, *actual)
 }
@@ -221,10 +221,10 @@ func TestUpdatePolicyTypeLengthCheck(t *testing.T) {
 }
 
 func TestDeletePolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeletePolicySuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeletePolicySuccessfully(t, fakeServer)
 
-	res := policies.Delete(context.TODO(), client.ServiceClient(), "9fe1d3")
+	res := policies.Delete(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/projectendpoints/testing/requests_test.go b/openstack/identity/v3/projectendpoints/testing/requests_test.go
index 2e8f6aad4..7e4f3c152 100644
--- a/openstack/identity/v3/projectendpoints/testing/requests_test.go
+++ b/openstack/identity/v3/projectendpoints/testing/requests_test.go
@@ -14,25 +14,25 @@ import (
 )
 
 func TestCreateSuccessful(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/OS-EP-FILTER/projects/project-id/endpoints/endpoint-id", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-EP-FILTER/projects/project-id/endpoints/endpoint-id", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := projectendpoints.Create(context.TODO(), client.ServiceClient(), "project-id", "endpoint-id").Err
+	err := projectendpoints.Create(context.TODO(), client.ServiceClient(fakeServer), "project-id", "endpoint-id").Err
 	th.AssertNoErr(t, err)
 }
 
 func TestListEndpoints(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/OS-EP-FILTER/projects/project-id/endpoints", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-EP-FILTER/projects/project-id/endpoints", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -71,7 +71,7 @@ func TestListEndpoints(t *testing.T) {
 	})
 
 	count := 0
-	err := projectendpoints.List(client.ServiceClient(), "project-id").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := projectendpoints.List(client.ServiceClient(fakeServer), "project-id").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := projectendpoints.ExtractEndpoints(page)
 		if err != nil {
@@ -103,16 +103,16 @@ func TestListEndpoints(t *testing.T) {
 }
 
 func TestDeleteEndpoint(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/OS-EP-FILTER/projects/project-id/endpoints/endpoint-id", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/OS-EP-FILTER/projects/project-id/endpoints/endpoint-id", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := projectendpoints.Delete(context.TODO(), client.ServiceClient(), "project-id", "endpoint-id")
+	res := projectendpoints.Delete(context.TODO(), client.ServiceClient(fakeServer), "project-id", "endpoint-id")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/projects/testing/fixtures_test.go b/openstack/identity/v3/projects/testing/fixtures_test.go
index 568305008..5c97fc7dd 100644
--- a/openstack/identity/v3/projects/testing/fixtures_test.go
+++ b/openstack/identity/v3/projects/testing/fixtures_test.go
@@ -277,8 +277,8 @@ var ExpectedProjects = projects.ProjectTags{
 
 // HandleListAvailableProjectsSuccessfully creates an HTTP handler at `/auth/projects`
 // on the test handler mux that responds with a list of two tenants.
-func HandleListAvailableProjectsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/auth/projects", func(w http.ResponseWriter, r *http.Request) {
+func HandleListAvailableProjectsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/auth/projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -291,8 +291,8 @@ func HandleListAvailableProjectsSuccessfully(t *testing.T) {
 
 // HandleListProjectsSuccessfully creates an HTTP handler at `/projects` on the
 // test handler mux that responds with a list of two tenants.
-func HandleListProjectsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects", func(w http.ResponseWriter, r *http.Request) {
+func HandleListProjectsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -305,8 +305,8 @@ func HandleListProjectsSuccessfully(t *testing.T) {
 
 // HandleGetProjectSuccessfully creates an HTTP handler at `/projects` on the
 // test handler mux that responds with a single project.
-func HandleGetProjectSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects/1234", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetProjectSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects/1234", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -319,8 +319,8 @@ func HandleGetProjectSuccessfully(t *testing.T) {
 
 // HandleCreateProjectSuccessfully creates an HTTP handler at `/projects` on the
 // test handler mux that tests project creation.
-func HandleCreateProjectSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateProjectSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -332,8 +332,8 @@ func HandleCreateProjectSuccessfully(t *testing.T) {
 
 // HandleDeleteProjectSuccessfully creates an HTTP handler at `/projects` on the
 // test handler mux that tests project deletion.
-func HandleDeleteProjectSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects/1234", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteProjectSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects/1234", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -343,8 +343,8 @@ func HandleDeleteProjectSuccessfully(t *testing.T) {
 
 // HandleUpdateProjectSuccessfully creates an HTTP handler at `/projects` on the
 // test handler mux that tests project updates.
-func HandleUpdateProjectSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects/1234", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateProjectSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects/1234", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
@@ -354,8 +354,8 @@ func HandleUpdateProjectSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleListProjectTagsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects/966b3c7d36a24facaf20b7e458bf2192/tags", func(w http.ResponseWriter, r *http.Request) {
+func HandleListProjectTagsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects/966b3c7d36a24facaf20b7e458bf2192/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -364,8 +364,8 @@ func HandleListProjectTagsSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleModifyProjectTagsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects/966b3c7d36a24facaf20b7e458bf2192/tags", func(w http.ResponseWriter, r *http.Request) {
+func HandleModifyProjectTagsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects/966b3c7d36a24facaf20b7e458bf2192/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, ModifyProjectTagsRequest)
@@ -374,8 +374,8 @@ func HandleModifyProjectTagsSuccessfully(t *testing.T) {
 		fmt.Fprint(w, ModifyProjectTagsOutput)
 	})
 }
-func HandleDeleteProjectTagsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects/966b3c7d36a24facaf20b7e458bf2192/tags", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteProjectTagsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects/966b3c7d36a24facaf20b7e458bf2192/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v3/projects/testing/requests_test.go b/openstack/identity/v3/projects/testing/requests_test.go
index aa27c5094..5ecc88e45 100644
--- a/openstack/identity/v3/projects/testing/requests_test.go
+++ b/openstack/identity/v3/projects/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListAvailableProjects(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAvailableProjectsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAvailableProjectsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := projects.ListAvailable(client.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := projects.ListAvailable(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := projects.ExtractProjects(page)
@@ -31,12 +31,12 @@ func TestListAvailableProjects(t *testing.T) {
 }
 
 func TestListProjects(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListProjectsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListProjectsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := projects.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := projects.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := projects.ExtractProjects(page)
@@ -83,19 +83,19 @@ func TestListGroupsFiltersCheck(t *testing.T) {
 }
 
 func TestGetProject(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetProjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetProjectSuccessfully(t, fakeServer)
 
-	actual, err := projects.Get(context.TODO(), client.ServiceClient(), "1234").Extract()
+	actual, err := projects.Get(context.TODO(), client.ServiceClient(fakeServer), "1234").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, RedTeam, *actual)
 }
 
 func TestCreateProject(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateProjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateProjectSuccessfully(t, fakeServer)
 
 	createOpts := projects.CreateOpts{
 		Name:        "Red Team",
@@ -104,24 +104,24 @@ func TestCreateProject(t *testing.T) {
 		Extra:       map[string]any{"test": "old"},
 	}
 
-	actual, err := projects.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := projects.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, RedTeam, *actual)
 }
 
 func TestDeleteProject(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteProjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteProjectSuccessfully(t, fakeServer)
 
-	res := projects.Delete(context.TODO(), client.ServiceClient(), "1234")
+	res := projects.Delete(context.TODO(), client.ServiceClient(fakeServer), "1234")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateProject(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateProjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateProjectSuccessfully(t, fakeServer)
 
 	var description = "The team that is bright red"
 	updateOpts := projects.UpdateOpts{
@@ -131,40 +131,40 @@ func TestUpdateProject(t *testing.T) {
 		Extra:       map[string]any{"test": "new"},
 	}
 
-	actual, err := projects.Update(context.TODO(), client.ServiceClient(), "1234", updateOpts).Extract()
+	actual, err := projects.Update(context.TODO(), client.ServiceClient(fakeServer), "1234", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, UpdatedRedTeam, *actual)
-	t.Log(projects.Update(context.TODO(), client.ServiceClient(), "1234", updateOpts))
+	t.Log(projects.Update(context.TODO(), client.ServiceClient(fakeServer), "1234", updateOpts))
 }
 
 func TestListProjectTags(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListProjectTagsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListProjectTagsSuccessfully(t, fakeServer)
 
-	actual, err := projects.ListTags(context.TODO(), client.ServiceClient(), "966b3c7d36a24facaf20b7e458bf2192").Extract()
+	actual, err := projects.ListTags(context.TODO(), client.ServiceClient(fakeServer), "966b3c7d36a24facaf20b7e458bf2192").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedTags, *actual)
 }
 
 func TestModifyProjectTags(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleModifyProjectTagsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleModifyProjectTagsSuccessfully(t, fakeServer)
 
 	modifyOpts := projects.ModifyTagsOpts{
 		Tags: []string{"foo", "bar"},
 	}
-	actual, err := projects.ModifyTags(context.TODO(), client.ServiceClient(), "966b3c7d36a24facaf20b7e458bf2192", modifyOpts).Extract()
+	actual, err := projects.ModifyTags(context.TODO(), client.ServiceClient(fakeServer), "966b3c7d36a24facaf20b7e458bf2192", modifyOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedProjects, *actual)
 }
 
 func TestDeleteTags(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteProjectTagsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteProjectTagsSuccessfully(t, fakeServer)
 
-	err := projects.DeleteTags(context.TODO(), client.ServiceClient(), "966b3c7d36a24facaf20b7e458bf2192").ExtractErr()
+	err := projects.DeleteTags(context.TODO(), client.ServiceClient(fakeServer), "966b3c7d36a24facaf20b7e458bf2192").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/identity/v3/regions/testing/fixtures_test.go b/openstack/identity/v3/regions/testing/fixtures_test.go
index 633ae86dc..d3d150093 100644
--- a/openstack/identity/v3/regions/testing/fixtures_test.go
+++ b/openstack/identity/v3/regions/testing/fixtures_test.go
@@ -164,8 +164,8 @@ var ExpectedRegionsSlice = []regions.Region{FirstRegion, SecondRegion}
 
 // HandleListRegionsSuccessfully creates an HTTP handler at `/regions` on the
 // test handler mux that responds with a list of two regions.
-func HandleListRegionsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/regions", func(w http.ResponseWriter, r *http.Request) {
+func HandleListRegionsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/regions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -178,8 +178,8 @@ func HandleListRegionsSuccessfully(t *testing.T) {
 
 // HandleGetRegionSuccessfully creates an HTTP handler at `/regions` on the
 // test handler mux that responds with a single region.
-func HandleGetRegionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/regions/RegionOne-West", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetRegionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/regions/RegionOne-West", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -192,8 +192,8 @@ func HandleGetRegionSuccessfully(t *testing.T) {
 
 // HandleCreateRegionSuccessfully creates an HTTP handler at `/regions` on the
 // test handler mux that tests region creation.
-func HandleCreateRegionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/regions", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateRegionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/regions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -205,8 +205,8 @@ func HandleCreateRegionSuccessfully(t *testing.T) {
 
 // HandleUpdateRegionSuccessfully creates an HTTP handler at `/regions` on the
 // test handler mux that tests region update.
-func HandleUpdateRegionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/regions/RegionOne-West", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateRegionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/regions/RegionOne-West", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
@@ -218,8 +218,8 @@ func HandleUpdateRegionSuccessfully(t *testing.T) {
 
 // HandleDeleteRegionSuccessfully creates an HTTP handler at `/regions` on the
 // test handler mux that tests region deletion.
-func HandleDeleteRegionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/regions/RegionOne-West", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteRegionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/regions/RegionOne-West", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/identity/v3/regions/testing/requests_test.go b/openstack/identity/v3/regions/testing/requests_test.go
index b85b112d1..0c82efd00 100644
--- a/openstack/identity/v3/regions/testing/requests_test.go
+++ b/openstack/identity/v3/regions/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListRegions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRegionsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRegionsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := regions.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := regions.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := regions.ExtractRegions(page)
@@ -31,11 +31,11 @@ func TestListRegions(t *testing.T) {
 }
 
 func TestListRegionsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRegionsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRegionsSuccessfully(t, fakeServer)
 
-	allPages, err := regions.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := regions.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := regions.ExtractRegions(allPages)
 	th.AssertNoErr(t, err)
@@ -44,20 +44,20 @@ func TestListRegionsAllPages(t *testing.T) {
 }
 
 func TestGetRegion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetRegionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetRegionSuccessfully(t, fakeServer)
 
-	actual, err := regions.Get(context.TODO(), client.ServiceClient(), "RegionOne-West").Extract()
+	actual, err := regions.Get(context.TODO(), client.ServiceClient(fakeServer), "RegionOne-West").Extract()
 
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondRegion, *actual)
 }
 
 func TestCreateRegion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateRegionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateRegionSuccessfully(t, fakeServer)
 
 	createOpts := regions.CreateOpts{
 		ID:          "RegionOne-West",
@@ -68,15 +68,15 @@ func TestCreateRegion(t *testing.T) {
 		ParentRegionID: "RegionOne",
 	}
 
-	actual, err := regions.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := regions.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondRegion, *actual)
 }
 
 func TestUpdateRegion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateRegionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateRegionSuccessfully(t, fakeServer)
 
 	var description = "First West sub-region of RegionOne"
 	updateOpts := regions.UpdateOpts{
@@ -92,16 +92,16 @@ func TestUpdateRegion(t *testing.T) {
 		*/
 	}
 
-	actual, err := regions.Update(context.TODO(), client.ServiceClient(), "RegionOne-West", updateOpts).Extract()
+	actual, err := regions.Update(context.TODO(), client.ServiceClient(fakeServer), "RegionOne-West", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondRegionUpdated, *actual)
 }
 
 func TestDeleteRegion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteRegionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteRegionSuccessfully(t, fakeServer)
 
-	res := regions.Delete(context.TODO(), client.ServiceClient(), "RegionOne-West")
+	res := regions.Delete(context.TODO(), client.ServiceClient(fakeServer), "RegionOne-West")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/registeredlimits/testing/fixtures_test.go b/openstack/identity/v3/registeredlimits/testing/fixtures_test.go
index 1bcfc5e86..81ddc3cd7 100644
--- a/openstack/identity/v3/registeredlimits/testing/fixtures_test.go
+++ b/openstack/identity/v3/registeredlimits/testing/fixtures_test.go
@@ -155,8 +155,8 @@ var ExpectedRegisteredLimitsSlice = []registeredlimits.RegisteredLimit{FirstRegi
 
 // HandleListRegisteredLimitsSuccessfully creates an HTTP handler at `/registered_limits` on the
 // test handler mux that responds with a list of two registered limits.
-func HandleListRegisteredLimitsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/registered_limits", func(w http.ResponseWriter, r *http.Request) {
+func HandleListRegisteredLimitsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/registered_limits", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -169,8 +169,8 @@ func HandleListRegisteredLimitsSuccessfully(t *testing.T) {
 
 // HandleGetRegisteredLimitSuccessfully creates an HTTP handler at `/registered_limits` on the
 // test handler mux that responds with a single project.
-func HandleGetRegisteredLimitSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/registered_limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetRegisteredLimitSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/registered_limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -183,8 +183,8 @@ func HandleGetRegisteredLimitSuccessfully(t *testing.T) {
 
 // HandleCreateRegisteredLimitSuccessfully creates an HTTP handler at `/registered_limits` on the
 // test handler mux that tests registered limit creation.
-func HandleCreateRegisteredLimitSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/registered_limits", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateRegisteredLimitSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/registered_limits", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -196,8 +196,8 @@ func HandleCreateRegisteredLimitSuccessfully(t *testing.T) {
 
 // HandleDeleteRegisteredLimitSuccessfully creates an HTTP handler at `/registered_limits` on the
 // test handler mux that tests registered_limit deletion.
-func HandleDeleteRegisteredLimitSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/registered_limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteRegisteredLimitSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/registered_limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -207,8 +207,8 @@ func HandleDeleteRegisteredLimitSuccessfully(t *testing.T) {
 
 // HandleUpdateRegisteredLimitSuccessfully creates an HTTP handler at `/registered_limits` on the
 // test handler mux that tests registered limits updates.
-func HandleUpdateRegisteredLimitSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/registered_limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateRegisteredLimitSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/registered_limits/3229b3849f584faea483d6851f7aab05", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
diff --git a/openstack/identity/v3/registeredlimits/testing/requests_test.go b/openstack/identity/v3/registeredlimits/testing/requests_test.go
index ad2a30cb3..a8f0e73bc 100644
--- a/openstack/identity/v3/registeredlimits/testing/requests_test.go
+++ b/openstack/identity/v3/registeredlimits/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListRegisteredLimits(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRegisteredLimitsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRegisteredLimitsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := registeredlimits.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := registeredlimits.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := registeredlimits.ExtractRegisteredLimits(page)
@@ -31,11 +31,11 @@ func TestListRegisteredLimits(t *testing.T) {
 }
 
 func TestListRegisteredLimitsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRegisteredLimitsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRegisteredLimitsSuccessfully(t, fakeServer)
 
-	allPages, err := registeredlimits.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := registeredlimits.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := registeredlimits.ExtractRegisteredLimits(allPages)
 	th.AssertNoErr(t, err)
@@ -43,9 +43,9 @@ func TestListRegisteredLimitsAllPages(t *testing.T) {
 }
 
 func TestCreateRegisteredLimits(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateRegisteredLimitSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateRegisteredLimitSuccessfully(t, fakeServer)
 
 	createOpts := registeredlimits.BatchCreateOpts{
 		registeredlimits.CreateOpts{
@@ -63,34 +63,34 @@ func TestCreateRegisteredLimits(t *testing.T) {
 		},
 	}
 
-	actual, err := registeredlimits.BatchCreate(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := registeredlimits.BatchCreate(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedRegisteredLimitsSlice, actual)
 }
 
 func TestGetRegisteredLimit(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetRegisteredLimitSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetRegisteredLimitSuccessfully(t, fakeServer)
 
-	actual, err := registeredlimits.Get(context.TODO(), client.ServiceClient(), "3229b3849f584faea483d6851f7aab05").Extract()
+	actual, err := registeredlimits.Get(context.TODO(), client.ServiceClient(fakeServer), "3229b3849f584faea483d6851f7aab05").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondRegisteredLimit, *actual)
 }
 
 func TestDeleteRegisteredLimit(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteRegisteredLimitSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteRegisteredLimitSuccessfully(t, fakeServer)
 
-	res := registeredlimits.Delete(context.TODO(), client.ServiceClient(), "3229b3849f584faea483d6851f7aab05")
+	res := registeredlimits.Delete(context.TODO(), client.ServiceClient(fakeServer), "3229b3849f584faea483d6851f7aab05")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateRegisteredLimit(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateRegisteredLimitSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateRegisteredLimitSuccessfully(t, fakeServer)
 
 	defaultLimit := 15
 	updateOpts := registeredlimits.UpdateOpts{
@@ -99,7 +99,7 @@ func TestUpdateRegisteredLimit(t *testing.T) {
 		DefaultLimit: &defaultLimit,
 	}
 
-	actual, err := registeredlimits.Update(context.TODO(), client.ServiceClient(), "3229b3849f584faea483d6851f7aab05", updateOpts).Extract()
+	actual, err := registeredlimits.Update(context.TODO(), client.ServiceClient(fakeServer), "3229b3849f584faea483d6851f7aab05", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, UpdatedSecondRegisteredLimit, *actual)
 }
diff --git a/openstack/identity/v3/roles/testing/fixtures_test.go b/openstack/identity/v3/roles/testing/fixtures_test.go
index 32fe745a9..1e8403eb6 100644
--- a/openstack/identity/v3/roles/testing/fixtures_test.go
+++ b/openstack/identity/v3/roles/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/identity/v3/roles"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // ListOutput provides a single page of Role results.
@@ -342,11 +342,11 @@ var ExpectedRolesSlice = []roles.Role{FirstRole, SecondRole}
 
 // HandleListRolesSuccessfully creates an HTTP handler at `/roles` on the
 // test handler mux that responds with a list of two roles.
-func HandleListRolesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/roles", func(w http.ResponseWriter, r *http.Request) {
+func HandleListRolesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/roles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -356,11 +356,11 @@ func HandleListRolesSuccessfully(t *testing.T) {
 
 // HandleGetRoleSuccessfully creates an HTTP handler at `/roles` on the
 // test handler mux that responds with a single role.
-func HandleGetRoleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/roles/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetRoleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/roles/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -370,10 +370,10 @@ func HandleGetRoleSuccessfully(t *testing.T) {
 
 // HandleCreateRoleSuccessfully creates an HTTP handler at `/roles` on the
 // test handler mux that tests role creation.
-func HandleCreateRoleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/roles", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateRoleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/roles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
 
 		w.WriteHeader(http.StatusCreated)
@@ -383,10 +383,10 @@ func HandleCreateRoleSuccessfully(t *testing.T) {
 
 // HandleUpdateRoleSuccessfully creates an HTTP handler at `/roles` on the
 // test handler mux that tests role update.
-func HandleUpdateRoleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/roles/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateRoleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/roles/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
 
 		w.WriteHeader(http.StatusOK)
@@ -396,63 +396,63 @@ func HandleUpdateRoleSuccessfully(t *testing.T) {
 
 // HandleDeleteRoleSuccessfully creates an HTTP handler at `/roles` on the
 // test handler mux that tests role deletion.
-func HandleDeleteRoleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/roles/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteRoleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/roles/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func HandleAssignSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects/{project_id}/users/{user_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+func HandleAssignSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects/{project_id}/users/{user_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/projects/{project_id}/groups/{group_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/projects/{project_id}/groups/{group_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/domains/{domain_id}/users/{user_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/domains/{domain_id}/users/{user_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/domains/{domain_id}/groups/{group_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/domains/{domain_id}/groups/{group_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func HandleUnassignSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/projects/{project_id}/users/{user_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+func HandleUnassignSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/projects/{project_id}/users/{user_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/projects/{project_id}/groups/{group_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/projects/{project_id}/groups/{group_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/domains/{domain_id}/users/{user_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/domains/{domain_id}/users/{user_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	th.Mux.HandleFunc("/domains/{domain_id}/groups/{group_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/domains/{domain_id}/groups/{group_id}/roles/{role_id}", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
@@ -491,11 +491,11 @@ var ExpectedRoleAssignmentsWithNamesSlice = []roles.RoleAssignment{ThirdRoleAssi
 
 // HandleListRoleAssignmentsSuccessfully creates an HTTP handler at `/role_assignments` on the
 // test handler mux that responds with a list of two role assignments.
-func HandleListRoleAssignmentsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/role_assignments", func(w http.ResponseWriter, r *http.Request) {
+func HandleListRoleAssignmentsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/role_assignments", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -505,11 +505,11 @@ func HandleListRoleAssignmentsSuccessfully(t *testing.T) {
 
 // HandleListRoleAssignmentsSuccessfully creates an HTTP handler at `/role_assignments` on the
 // test handler mux that responds with a list of two role assignments.
-func HandleListRoleAssignmentsWithNamesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/role_assignments", func(w http.ResponseWriter, r *http.Request) {
+func HandleListRoleAssignmentsWithNamesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/role_assignments", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.AssertEquals(t, "include_names=true", r.URL.RawQuery)
 
 		w.Header().Set("Content-Type", "application/json")
@@ -520,11 +520,11 @@ func HandleListRoleAssignmentsWithNamesSuccessfully(t *testing.T) {
 
 // HandleListRoleAssignmentsWithSubtreeSuccessfully creates an HTTP handler at `/role_assignments` on the
 // test handler mux that responds with a list of two role assignments.
-func HandleListRoleAssignmentsWithSubtreeSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/role_assignments", func(w http.ResponseWriter, r *http.Request) {
+func HandleListRoleAssignmentsWithSubtreeSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/role_assignments", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.AssertEquals(t, "include_subtree=true", r.URL.RawQuery)
 
 		w.Header().Set("Content-Type", "application/json")
@@ -549,60 +549,60 @@ var RoleOnResource = roles.Role{
 // from ListAssignmentsOnResourceOutput.
 var ExpectedRolesOnResourceSlice = []roles.Role{RoleOnResource}
 
-func HandleListAssignmentsOnResourceSuccessfully_ProjectsUsers(t *testing.T) {
+func HandleListAssignmentsOnResourceSuccessfully_ProjectsUsers(t *testing.T, fakeServer th.FakeServer) {
 	fn := func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, ListAssignmentsOnResourceOutput)
 	}
 
-	th.Mux.HandleFunc("/projects/{project_id}/users/{user_id}/roles", fn)
+	fakeServer.Mux.HandleFunc("/projects/{project_id}/users/{user_id}/roles", fn)
 }
 
-func HandleListAssignmentsOnResourceSuccessfully_ProjectsGroups(t *testing.T) {
+func HandleListAssignmentsOnResourceSuccessfully_ProjectsGroups(t *testing.T, fakeServer th.FakeServer) {
 	fn := func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, ListAssignmentsOnResourceOutput)
 	}
 
-	th.Mux.HandleFunc("/projects/{project_id}/groups/{group_id}/roles", fn)
+	fakeServer.Mux.HandleFunc("/projects/{project_id}/groups/{group_id}/roles", fn)
 }
 
-func HandleListAssignmentsOnResourceSuccessfully_DomainsUsers(t *testing.T) {
+func HandleListAssignmentsOnResourceSuccessfully_DomainsUsers(t *testing.T, fakeServer th.FakeServer) {
 	fn := func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, ListAssignmentsOnResourceOutput)
 	}
 
-	th.Mux.HandleFunc("/domains/{domain_id}/users/{user_id}/roles", fn)
+	fakeServer.Mux.HandleFunc("/domains/{domain_id}/users/{user_id}/roles", fn)
 }
 
-func HandleListAssignmentsOnResourceSuccessfully_DomainsGroups(t *testing.T) {
+func HandleListAssignmentsOnResourceSuccessfully_DomainsGroups(t *testing.T, fakeServer th.FakeServer) {
 	fn := func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, ListAssignmentsOnResourceOutput)
 	}
 
-	th.Mux.HandleFunc("/domains/{domain_id}/groups/{group_id}/roles", fn)
+	fakeServer.Mux.HandleFunc("/domains/{domain_id}/groups/{group_id}/roles", fn)
 }
 
 var expectedRoleInferenceRule = roles.RoleInferenceRule{
@@ -627,18 +627,18 @@ var expectedRoleInferenceRule = roles.RoleInferenceRule{
 	},
 }
 
-func HandleCreateRoleInferenceRule(t *testing.T) {
+func HandleCreateRoleInferenceRule(t *testing.T, fakeServer th.FakeServer) {
 	fn := func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusCreated)
 		fmt.Fprint(w, CreateRoleInferenceRuleOutput)
 	}
 
-	th.Mux.HandleFunc("/roles/7ceab6192ea34a548cc71b24f72e762c/implies/97e2f5d38bc94842bc3da818c16762ed", fn)
+	fakeServer.Mux.HandleFunc("/roles/7ceab6192ea34a548cc71b24f72e762c/implies/97e2f5d38bc94842bc3da818c16762ed", fn)
 }
 
 var expectedRoleInferenceRuleList = roles.RoleInferenceRuleList{
@@ -705,40 +705,40 @@ var expectedRoleInferenceRuleList = roles.RoleInferenceRuleList{
 	},
 }
 
-func HandleListRoleInferenceRules(t *testing.T) {
+func HandleListRoleInferenceRules(t *testing.T, fakeServer th.FakeServer) {
 	fn := func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, ListRoleInferenceRulesOutput)
 	}
 
-	th.Mux.HandleFunc("/role_inferences", fn)
+	fakeServer.Mux.HandleFunc("/role_inferences", fn)
 }
 
-func HandleDeleteRoleInferenceRule(t *testing.T) {
+func HandleDeleteRoleInferenceRule(t *testing.T, fakeServer th.FakeServer) {
 	fn := func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	}
-	th.Mux.HandleFunc("/roles/7ceab6192ea34a548cc71b24f72e762c/implies/97e2f5d38bc94842bc3da818c16762ed", fn)
+	fakeServer.Mux.HandleFunc("/roles/7ceab6192ea34a548cc71b24f72e762c/implies/97e2f5d38bc94842bc3da818c16762ed", fn)
 }
 
-func HandleGetRoleInferenceRule(t *testing.T) {
+func HandleGetRoleInferenceRule(t *testing.T, fakeServer th.FakeServer) {
 	fn := func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, CreateRoleInferenceRuleOutput)
 	}
 
-	th.Mux.HandleFunc("/roles/7ceab6192ea34a548cc71b24f72e762c/implies/97e2f5d38bc94842bc3da818c16762ed", fn)
+	fakeServer.Mux.HandleFunc("/roles/7ceab6192ea34a548cc71b24f72e762c/implies/97e2f5d38bc94842bc3da818c16762ed", fn)
 }
diff --git a/openstack/identity/v3/roles/testing/requests_test.go b/openstack/identity/v3/roles/testing/requests_test.go
index 5268fc06c..fb3021064 100644
--- a/openstack/identity/v3/roles/testing/requests_test.go
+++ b/openstack/identity/v3/roles/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListRoles(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRolesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRolesSuccessfully(t, fakeServer)
 
 	count := 0
-	err := roles.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := roles.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := roles.ExtractRoles(page)
@@ -31,11 +31,11 @@ func TestListRoles(t *testing.T) {
 }
 
 func TestListRolesAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRolesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRolesSuccessfully(t, fakeServer)
 
-	allPages, err := roles.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := roles.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := roles.ExtractRoles(allPages)
 	th.AssertNoErr(t, err)
@@ -76,20 +76,20 @@ func TestListUsersFiltersCheck(t *testing.T) {
 }
 
 func TestGetRole(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetRoleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetRoleSuccessfully(t, fakeServer)
 
-	actual, err := roles.Get(context.TODO(), client.ServiceClient(), "9fe1d3").Extract()
+	actual, err := roles.Get(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3").Extract()
 
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondRole, *actual)
 }
 
 func TestCreateRole(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateRoleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateRoleSuccessfully(t, fakeServer)
 
 	createOpts := roles.CreateOpts{
 		Name:     "support",
@@ -99,15 +99,15 @@ func TestCreateRole(t *testing.T) {
 		},
 	}
 
-	actual, err := roles.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := roles.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondRole, *actual)
 }
 
 func TestUpdateRole(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateRoleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateRoleSuccessfully(t, fakeServer)
 
 	updateOpts := roles.UpdateOpts{
 		Extra: map[string]any{
@@ -115,27 +115,27 @@ func TestUpdateRole(t *testing.T) {
 		},
 	}
 
-	actual, err := roles.Update(context.TODO(), client.ServiceClient(), "9fe1d3", updateOpts).Extract()
+	actual, err := roles.Update(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondRoleUpdated, *actual)
 }
 
 func TestDeleteRole(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteRoleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteRoleSuccessfully(t, fakeServer)
 
-	res := roles.Delete(context.TODO(), client.ServiceClient(), "9fe1d3")
+	res := roles.Delete(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListAssignmentsSinglePage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRoleAssignmentsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRoleAssignmentsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := roles.ListAssignments(client.ServiceClient(), roles.ListAssignmentsOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := roles.ListAssignments(client.ServiceClient(fakeServer), roles.ListAssignmentsOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := roles.ExtractRoleAssignments(page)
 		th.AssertNoErr(t, err)
@@ -149,9 +149,9 @@ func TestListAssignmentsSinglePage(t *testing.T) {
 }
 
 func TestListAssignmentsWithNamesSinglePage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRoleAssignmentsWithNamesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRoleAssignmentsWithNamesSuccessfully(t, fakeServer)
 
 	var includeNames = true
 	listOpts := roles.ListAssignmentsOpts{
@@ -159,7 +159,7 @@ func TestListAssignmentsWithNamesSinglePage(t *testing.T) {
 	}
 
 	count := 0
-	err := roles.ListAssignments(client.ServiceClient(), listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := roles.ListAssignments(client.ServiceClient(fakeServer), listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := roles.ExtractRoleAssignments(page)
 		th.AssertNoErr(t, err)
@@ -173,9 +173,9 @@ func TestListAssignmentsWithNamesSinglePage(t *testing.T) {
 }
 
 func TestListAssignmentsWithSubtreeSinglePage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRoleAssignmentsWithSubtreeSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRoleAssignmentsWithSubtreeSuccessfully(t, fakeServer)
 
 	var includeSubtree = true
 	listOpts := roles.ListAssignmentsOpts{
@@ -183,7 +183,7 @@ func TestListAssignmentsWithSubtreeSinglePage(t *testing.T) {
 	}
 
 	count := 0
-	err := roles.ListAssignments(client.ServiceClient(), listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := roles.ListAssignments(client.ServiceClient(fakeServer), listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := roles.ExtractRoleAssignments(page)
 		th.AssertNoErr(t, err)
@@ -197,12 +197,12 @@ func TestListAssignmentsWithSubtreeSinglePage(t *testing.T) {
 }
 
 func TestListAssignmentsOnResource_ProjectsUsers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAssignmentsOnResourceSuccessfully_ProjectsUsers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAssignmentsOnResourceSuccessfully_ProjectsUsers(t, fakeServer)
 
 	count := 0
-	err := roles.ListAssignmentsOnResource(client.ServiceClient(), roles.ListAssignmentsOnResourceOpts{
+	err := roles.ListAssignmentsOnResource(client.ServiceClient(fakeServer), roles.ListAssignmentsOnResourceOpts{
 		UserID:    "{user_id}",
 		ProjectID: "{project_id}",
 	}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -219,12 +219,12 @@ func TestListAssignmentsOnResource_ProjectsUsers(t *testing.T) {
 }
 
 func TestListAssignmentsOnResource_DomainsUsers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAssignmentsOnResourceSuccessfully_DomainsUsers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAssignmentsOnResourceSuccessfully_DomainsUsers(t, fakeServer)
 
 	count := 0
-	err := roles.ListAssignmentsOnResource(client.ServiceClient(), roles.ListAssignmentsOnResourceOpts{
+	err := roles.ListAssignmentsOnResource(client.ServiceClient(fakeServer), roles.ListAssignmentsOnResourceOpts{
 		UserID:   "{user_id}",
 		DomainID: "{domain_id}",
 	}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -241,12 +241,12 @@ func TestListAssignmentsOnResource_DomainsUsers(t *testing.T) {
 }
 
 func TestListAssignmentsOnResource_ProjectsGroups(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAssignmentsOnResourceSuccessfully_ProjectsGroups(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAssignmentsOnResourceSuccessfully_ProjectsGroups(t, fakeServer)
 
 	count := 0
-	err := roles.ListAssignmentsOnResource(client.ServiceClient(), roles.ListAssignmentsOnResourceOpts{
+	err := roles.ListAssignmentsOnResource(client.ServiceClient(fakeServer), roles.ListAssignmentsOnResourceOpts{
 		GroupID:   "{group_id}",
 		ProjectID: "{project_id}",
 	}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -263,12 +263,12 @@ func TestListAssignmentsOnResource_ProjectsGroups(t *testing.T) {
 }
 
 func TestListAssignmentsOnResource_DomainsGroups(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListAssignmentsOnResourceSuccessfully_DomainsGroups(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListAssignmentsOnResourceSuccessfully_DomainsGroups(t, fakeServer)
 
 	count := 0
-	err := roles.ListAssignmentsOnResource(client.ServiceClient(), roles.ListAssignmentsOnResourceOpts{
+	err := roles.ListAssignmentsOnResource(client.ServiceClient(fakeServer), roles.ListAssignmentsOnResourceOpts{
 		GroupID:  "{group_id}",
 		DomainID: "{domain_id}",
 	}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -285,29 +285,29 @@ func TestListAssignmentsOnResource_DomainsGroups(t *testing.T) {
 }
 
 func TestAssign(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAssignSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAssignSuccessfully(t, fakeServer)
 
-	err := roles.Assign(context.TODO(), client.ServiceClient(), "{role_id}", roles.AssignOpts{
+	err := roles.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", roles.AssignOpts{
 		UserID:    "{user_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = roles.Assign(context.TODO(), client.ServiceClient(), "{role_id}", roles.AssignOpts{
+	err = roles.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", roles.AssignOpts{
 		UserID:   "{user_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = roles.Assign(context.TODO(), client.ServiceClient(), "{role_id}", roles.AssignOpts{
+	err = roles.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", roles.AssignOpts{
 		GroupID:   "{group_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = roles.Assign(context.TODO(), client.ServiceClient(), "{role_id}", roles.AssignOpts{
+	err = roles.Assign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", roles.AssignOpts{
 		GroupID:  "{group_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
@@ -315,29 +315,29 @@ func TestAssign(t *testing.T) {
 }
 
 func TestUnassign(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUnassignSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUnassignSuccessfully(t, fakeServer)
 
-	err := roles.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", roles.UnassignOpts{
+	err := roles.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", roles.UnassignOpts{
 		UserID:    "{user_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = roles.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", roles.UnassignOpts{
+	err = roles.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", roles.UnassignOpts{
 		UserID:   "{user_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = roles.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", roles.UnassignOpts{
+	err = roles.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", roles.UnassignOpts{
 		GroupID:   "{group_id}",
 		ProjectID: "{project_id}",
 	}).ExtractErr()
 	th.AssertNoErr(t, err)
 
-	err = roles.Unassign(context.TODO(), client.ServiceClient(), "{role_id}", roles.UnassignOpts{
+	err = roles.Unassign(context.TODO(), client.ServiceClient(fakeServer), "{role_id}", roles.UnassignOpts{
 		GroupID:  "{group_id}",
 		DomainID: "{domain_id}",
 	}).ExtractErr()
@@ -345,40 +345,40 @@ func TestUnassign(t *testing.T) {
 }
 
 func TestCreateRoleInferenceRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateRoleInferenceRule(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateRoleInferenceRule(t, fakeServer)
 
-	actual, err := roles.CreateRoleInferenceRule(context.TODO(), client.ServiceClient(), "7ceab6192ea34a548cc71b24f72e762c", "97e2f5d38bc94842bc3da818c16762ed").Extract()
+	actual, err := roles.CreateRoleInferenceRule(context.TODO(), client.ServiceClient(fakeServer), "7ceab6192ea34a548cc71b24f72e762c", "97e2f5d38bc94842bc3da818c16762ed").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expectedRoleInferenceRule, *actual)
 }
 
 func TestListRoleInferenceRules(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListRoleInferenceRules(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListRoleInferenceRules(t, fakeServer)
 
-	actual, err := roles.ListRoleInferenceRules(context.TODO(), client.ServiceClient()).Extract()
+	actual, err := roles.ListRoleInferenceRules(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expectedRoleInferenceRuleList, *actual)
 }
 
 func TestDeleteRoleInferenceRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteRoleInferenceRule(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteRoleInferenceRule(t, fakeServer)
 
-	err := roles.DeleteRoleInferenceRule(context.TODO(), client.ServiceClient(), "7ceab6192ea34a548cc71b24f72e762c", "97e2f5d38bc94842bc3da818c16762ed").ExtractErr()
+	err := roles.DeleteRoleInferenceRule(context.TODO(), client.ServiceClient(fakeServer), "7ceab6192ea34a548cc71b24f72e762c", "97e2f5d38bc94842bc3da818c16762ed").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetInferenceRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetRoleInferenceRule(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetRoleInferenceRule(t, fakeServer)
 
-	actual, err := roles.GetRoleInferenceRule(context.TODO(), client.ServiceClient(), "7ceab6192ea34a548cc71b24f72e762c", "97e2f5d38bc94842bc3da818c16762ed").Extract()
+	actual, err := roles.GetRoleInferenceRule(context.TODO(), client.ServiceClient(fakeServer), "7ceab6192ea34a548cc71b24f72e762c", "97e2f5d38bc94842bc3da818c16762ed").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expectedRoleInferenceRule, *actual)
 }
diff --git a/openstack/identity/v3/services/testing/fixtures_test.go b/openstack/identity/v3/services/testing/fixtures_test.go
index 0a9274c50..9bd0076c5 100644
--- a/openstack/identity/v3/services/testing/fixtures_test.go
+++ b/openstack/identity/v3/services/testing/fixtures_test.go
@@ -156,8 +156,8 @@ var ExpectedServicesSlice = []services.Service{FirstService, SecondService}
 
 // HandleListServicesSuccessfully creates an HTTP handler at `/services` on the
 // test handler mux that responds with a list of two services.
-func HandleListServicesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) {
+func HandleListServicesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -170,8 +170,8 @@ func HandleListServicesSuccessfully(t *testing.T) {
 
 // HandleGetServiceSuccessfully creates an HTTP handler at `/services` on the
 // test handler mux that responds with a single service.
-func HandleGetServiceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/services/9876", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetServiceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/services/9876", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -184,8 +184,8 @@ func HandleGetServiceSuccessfully(t *testing.T) {
 
 // HandleCreateServiceSuccessfully creates an HTTP handler at `/services` on the
 // test handler mux that tests service creation.
-func HandleCreateServiceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateServiceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -197,8 +197,8 @@ func HandleCreateServiceSuccessfully(t *testing.T) {
 
 // HandleUpdateServiceSuccessfully creates an HTTP handler at `/services` on the
 // test handler mux that tests service update.
-func HandleUpdateServiceSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/services/9876", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateServiceSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/services/9876", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
diff --git a/openstack/identity/v3/services/testing/requests_test.go b/openstack/identity/v3/services/testing/requests_test.go
index 77a212654..12c241ea9 100644
--- a/openstack/identity/v3/services/testing/requests_test.go
+++ b/openstack/identity/v3/services/testing/requests_test.go
@@ -12,9 +12,9 @@ import (
 )
 
 func TestCreateSuccessful(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateServiceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateServiceSuccessfully(t, fakeServer)
 
 	createOpts := services.CreateOpts{
 		Type: "compute",
@@ -25,18 +25,18 @@ func TestCreateSuccessful(t *testing.T) {
 		},
 	}
 
-	actual, err := services.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := services.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondService, *actual)
 }
 
 func TestListServices(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListServicesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListServicesSuccessfully(t, fakeServer)
 
 	count := 0
-	err := services.List(client.ServiceClient(), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := services.List(client.ServiceClient(fakeServer), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := services.ExtractServices(page)
@@ -51,11 +51,11 @@ func TestListServices(t *testing.T) {
 }
 
 func TestListServicesAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListServicesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListServicesSuccessfully(t, fakeServer)
 
-	allPages, err := services.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := services.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := services.ExtractServices(allPages)
 	th.AssertNoErr(t, err)
@@ -65,11 +65,11 @@ func TestListServicesAllPages(t *testing.T) {
 }
 
 func TestGetSuccessful(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetServiceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetServiceSuccessfully(t, fakeServer)
 
-	actual, err := services.Get(context.TODO(), client.ServiceClient(), "9876").Extract()
+	actual, err := services.Get(context.TODO(), client.ServiceClient(fakeServer), "9876").Extract()
 
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondService, *actual)
@@ -77,9 +77,9 @@ func TestGetSuccessful(t *testing.T) {
 }
 
 func TestUpdateSuccessful(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateServiceSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateServiceSuccessfully(t, fakeServer)
 
 	updateOpts := services.UpdateOpts{
 		Type: "compute2",
@@ -87,22 +87,22 @@ func TestUpdateSuccessful(t *testing.T) {
 			"description": "Service Two Updated",
 		},
 	}
-	actual, err := services.Update(context.TODO(), client.ServiceClient(), "9876", updateOpts).Extract()
+	actual, err := services.Update(context.TODO(), client.ServiceClient(fakeServer), "9876", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondServiceUpdated, *actual)
 	th.AssertEquals(t, SecondServiceUpdated.Extra["description"], "Service Two Updated")
 }
 
 func TestDeleteSuccessful(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/services/12345", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/services/12345", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := services.Delete(context.TODO(), client.ServiceClient(), "12345")
+	res := services.Delete(context.TODO(), client.ServiceClient(fakeServer), "12345")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/identity/v3/tokens/testing/requests_test.go b/openstack/identity/v3/tokens/testing/requests_test.go
index 8bb00fbff..8157de3ca 100644
--- a/openstack/identity/v3/tokens/testing/requests_test.go
+++ b/openstack/identity/v3/tokens/testing/requests_test.go
@@ -15,15 +15,15 @@ import (
 
 // authTokenPost verifies that providing certain AuthOptions and Scope results in an expected JSON structure.
 func authTokenPost(t *testing.T, options tokens.AuthOptions, scope *tokens.Scope, requestJSON string) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	client := gophercloud.ServiceClient{
 		ProviderClient: &gophercloud.ProviderClient{},
-		Endpoint:       th.Endpoint(),
+		Endpoint:       fakeServer.Endpoint(),
 	}
 
-	th.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -50,12 +50,12 @@ func authTokenPost(t *testing.T, options tokens.AuthOptions, scope *tokens.Scope
 }
 
 func authTokenPostErr(t *testing.T, options tokens.AuthOptions, scope *tokens.Scope, includeToken bool, expectedErr error) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	client := gophercloud.ServiceClient{
 		ProviderClient: &gophercloud.ProviderClient{},
-		Endpoint:       th.Endpoint(),
+		Endpoint:       fakeServer.Endpoint(),
 	}
 	if includeToken {
 		client.TokenID = "abcdef123456"
@@ -303,8 +303,8 @@ func TestCreateSystemScope(t *testing.T) {
 }
 
 func TestCreateUserIDPasswordTrustID(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	requestJSON := `{
 		"auth": {
@@ -362,7 +362,7 @@ func TestCreateUserIDPasswordTrustID(t *testing.T) {
 			}
 		}
 	}`
-	th.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -380,7 +380,7 @@ func TestCreateUserIDPasswordTrustID(t *testing.T) {
 		},
 	}
 
-	rsp := tokens.Create(context.TODO(), client.ServiceClient(), &ao)
+	rsp := tokens.Create(context.TODO(), client.ServiceClient(fakeServer), &ao)
 
 	token, err := rsp.Extract()
 	if err != nil {
@@ -513,15 +513,15 @@ func TestCreatePasswordTOTPProjectNameAndDomainNameScope(t *testing.T) {
 }
 
 func TestCreateExtractsTokenFromResponse(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	client := gophercloud.ServiceClient{
 		ProviderClient: &gophercloud.ProviderClient{},
-		Endpoint:       th.Endpoint(),
+		Endpoint:       fakeServer.Endpoint(),
 	}
 
-	th.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("X-Subject-Token", "aaa111")
 
 		w.WriteHeader(http.StatusCreated)
@@ -652,17 +652,17 @@ func TestCreateFailureEmptyScope(t *testing.T) {
 */
 
 func TestGetRequest(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	client := gophercloud.ServiceClient{
 		ProviderClient: &gophercloud.ProviderClient{
 			TokenID: "12345abcdef",
 		},
-		Endpoint: th.Endpoint(),
+		Endpoint: fakeServer.Endpoint(),
 	}
 
-	th.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeaderUnset(t, r, "Content-Type")
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -686,15 +686,15 @@ func TestGetRequest(t *testing.T) {
 	}
 }
 
-func prepareAuthTokenHandler(t *testing.T, expectedMethod string, status int) gophercloud.ServiceClient {
+func prepareAuthTokenHandler(t *testing.T, fakeServer th.FakeServer, expectedMethod string, status int) gophercloud.ServiceClient {
 	client := gophercloud.ServiceClient{
 		ProviderClient: &gophercloud.ProviderClient{
 			TokenID: "12345abcdef",
 		},
-		Endpoint: th.Endpoint(),
+		Endpoint: fakeServer.Endpoint(),
 	}
 
-	th.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, expectedMethod)
 		th.TestHeaderUnset(t, r, "Content-Type")
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -708,9 +708,9 @@ func prepareAuthTokenHandler(t *testing.T, expectedMethod string, status int) go
 }
 
 func TestValidateRequestSuccessful(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	client := prepareAuthTokenHandler(t, "HEAD", http.StatusNoContent)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	client := prepareAuthTokenHandler(t, fakeServer, "HEAD", http.StatusNoContent)
 
 	ok, err := tokens.Validate(context.TODO(), &client, "abcdef12345")
 	if err != nil {
@@ -723,9 +723,9 @@ func TestValidateRequestSuccessful(t *testing.T) {
 }
 
 func TestValidateRequestFailure(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	client := prepareAuthTokenHandler(t, "HEAD", http.StatusNotFound)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	client := prepareAuthTokenHandler(t, fakeServer, "HEAD", http.StatusNotFound)
 
 	ok, err := tokens.Validate(context.TODO(), &client, "abcdef12345")
 	if err != nil {
@@ -738,9 +738,9 @@ func TestValidateRequestFailure(t *testing.T) {
 }
 
 func TestValidateRequestError(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	client := prepareAuthTokenHandler(t, "HEAD", http.StatusMethodNotAllowed)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	client := prepareAuthTokenHandler(t, fakeServer, "HEAD", http.StatusMethodNotAllowed)
 
 	_, err := tokens.Validate(context.TODO(), &client, "abcdef12345")
 	if err == nil {
@@ -749,18 +749,18 @@ func TestValidateRequestError(t *testing.T) {
 }
 
 func TestRevokeRequestSuccessful(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	client := prepareAuthTokenHandler(t, "DELETE", http.StatusNoContent)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	client := prepareAuthTokenHandler(t, fakeServer, "DELETE", http.StatusNoContent)
 
 	res := tokens.Revoke(context.TODO(), &client, "abcdef12345")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestRevokeRequestError(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	client := prepareAuthTokenHandler(t, "DELETE", http.StatusNotFound)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	client := prepareAuthTokenHandler(t, fakeServer, "DELETE", http.StatusNotFound)
 
 	res := tokens.Revoke(context.TODO(), &client, "abcdef12345")
 	if res.Err == nil {
@@ -769,15 +769,15 @@ func TestRevokeRequestError(t *testing.T) {
 }
 
 func TestNoTokenInResponse(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	client := gophercloud.ServiceClient{
 		ProviderClient: &gophercloud.ProviderClient{},
-		Endpoint:       th.Endpoint(),
+		Endpoint:       fakeServer.Endpoint(),
 	}
 
-	th.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusCreated)
 		fmt.Fprint(w, `{}`)
 	})
diff --git a/openstack/identity/v3/trusts/testing/fixtures_test.go b/openstack/identity/v3/trusts/testing/fixtures_test.go
index 3e7e77fc3..0962b53e0 100644
--- a/openstack/identity/v3/trusts/testing/fixtures_test.go
+++ b/openstack/identity/v3/trusts/testing/fixtures_test.go
@@ -200,8 +200,8 @@ var ExpectedTrustRolesSlice = []trusts.Role{FirstRole, SecondRole}
 
 // HandleCreateTrust creates an HTTP handler at `/OS-TRUST/trusts` on the
 // test handler mux that tests trust creation.
-func HandleCreateTrust(t *testing.T) {
-	th.Mux.HandleFunc("/OS-TRUST/trusts", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateTrust(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-TRUST/trusts", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -214,8 +214,8 @@ func HandleCreateTrust(t *testing.T) {
 
 // HandleCreateTrustNoExpire creates an HTTP handler at `/OS-TRUST/trusts` on the
 // test handler mux that tests trust creation.
-func HandleCreateTrustNoExpire(t *testing.T) {
-	th.Mux.HandleFunc("/OS-TRUST/trusts", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateTrustNoExpire(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-TRUST/trusts", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequestNoExpire)
@@ -228,8 +228,8 @@ func HandleCreateTrustNoExpire(t *testing.T) {
 
 // HandleDeleteUserSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests user deletion.
-func HandleDeleteTrust(t *testing.T) {
-	th.Mux.HandleFunc("/OS-TRUST/trusts/3422b7c113894f5d90665e1a79655e23", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteTrust(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-TRUST/trusts/3422b7c113894f5d90665e1a79655e23", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -239,8 +239,8 @@ func HandleDeleteTrust(t *testing.T) {
 
 // HandleGetTrustSuccessfully creates an HTTP handler at `/OS-TRUST/trusts` on the
 // test handler mux that responds with a single trusts.
-func HandleGetTrustSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-TRUST/trusts/987fe8", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetTrustSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-TRUST/trusts/987fe8", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -309,8 +309,8 @@ var ExpectedTrustsSlice = []trusts.Trust{FirstTrust, SecondTrust}
 
 // HandleListTrustsSuccessfully creates an HTTP handler at `/OS-TRUST/trusts` on the
 // test handler mux that responds with a list of two trusts.
-func HandleListTrustsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-TRUST/trusts", func(w http.ResponseWriter, r *http.Request) {
+func HandleListTrustsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-TRUST/trusts", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -323,8 +323,8 @@ func HandleListTrustsSuccessfully(t *testing.T) {
 
 // HandleListTrustRolesSuccessfully creates an HTTP handler at `/OS-TRUST/trusts/987fe8/roles` on the
 // test handler mux that responds with a list trust roles.
-func HandleListTrustRolesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-TRUST/trusts/987fe8/roles", func(w http.ResponseWriter, r *http.Request) {
+func HandleListTrustRolesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-TRUST/trusts/987fe8/roles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -337,8 +337,8 @@ func HandleListTrustRolesSuccessfully(t *testing.T) {
 
 // HandleGetTrustRoleSuccessfully creates an HTTP handler at `/OS-TRUST/trusts/987fe8/roles/c1648e` on the
 // test handler mux that responds with a trust role details.
-func HandleGetTrustRoleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-TRUST/trusts/987fe8/roles/c1648e", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetTrustRoleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-TRUST/trusts/987fe8/roles/c1648e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -351,8 +351,8 @@ func HandleGetTrustRoleSuccessfully(t *testing.T) {
 
 // HandleCheckTrustRoleSuccessfully creates an HTTP handler at `/OS-TRUST/trusts/987fe8/roles/c1648e` on the
 // test handler mux that responds with a list trust roles.
-func HandleCheckTrustRoleSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/OS-TRUST/trusts/987fe8/roles/c1648e", func(w http.ResponseWriter, r *http.Request) {
+func HandleCheckTrustRoleSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/OS-TRUST/trusts/987fe8/roles/c1648e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
diff --git a/openstack/identity/v3/trusts/testing/requests_test.go b/openstack/identity/v3/trusts/testing/requests_test.go
index 0b2d8149c..8f11e9285 100644
--- a/openstack/identity/v3/trusts/testing/requests_test.go
+++ b/openstack/identity/v3/trusts/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestCreateTrust(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateTrust(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateTrust(t, fakeServer)
 
 	expiresAt := time.Date(2019, 12, 1, 14, 0, 0, 0, time.UTC)
-	result, err := trusts.Create(context.TODO(), client.ServiceClient(), trusts.CreateOpts{
+	result, err := trusts.Create(context.TODO(), client.ServiceClient(fakeServer), trusts.CreateOpts{
 		ExpiresAt:         &expiresAt,
 		AllowRedelegation: true,
 		ProjectID:         "9b71012f5a4a4aef9193f1995fe159b2",
@@ -35,11 +35,11 @@ func TestCreateTrust(t *testing.T) {
 }
 
 func TestCreateTrustNoExpire(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateTrustNoExpire(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateTrustNoExpire(t, fakeServer)
 
-	result, err := trusts.Create(context.TODO(), client.ServiceClient(), trusts.CreateOpts{
+	result, err := trusts.Create(context.TODO(), client.ServiceClient(fakeServer), trusts.CreateOpts{
 		AllowRedelegation: true,
 		ProjectID:         "9b71012f5a4a4aef9193f1995fe159b2",
 		Roles: []trusts.Role{
@@ -56,30 +56,30 @@ func TestCreateTrustNoExpire(t *testing.T) {
 }
 
 func TestDeleteTrust(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteTrust(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteTrust(t, fakeServer)
 
-	res := trusts.Delete(context.TODO(), client.ServiceClient(), "3422b7c113894f5d90665e1a79655e23")
+	res := trusts.Delete(context.TODO(), client.ServiceClient(fakeServer), "3422b7c113894f5d90665e1a79655e23")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetTrust(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetTrustSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetTrustSuccessfully(t, fakeServer)
 
-	res := trusts.Get(context.TODO(), client.ServiceClient(), "987fe8")
+	res := trusts.Get(context.TODO(), client.ServiceClient(fakeServer), "987fe8")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListTrusts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTrustsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTrustsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := trusts.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := trusts.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := trusts.ExtractTrusts(page)
@@ -94,11 +94,11 @@ func TestListTrusts(t *testing.T) {
 }
 
 func TestListTrustsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTrustsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTrustsSuccessfully(t, fakeServer)
 
-	allPages, err := trusts.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := trusts.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := trusts.ExtractTrusts(allPages)
 	th.AssertNoErr(t, err)
@@ -106,13 +106,13 @@ func TestListTrustsAllPages(t *testing.T) {
 }
 
 func TestListTrustsFiltered(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTrustsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTrustsSuccessfully(t, fakeServer)
 	trustsListOpts := trusts.ListOpts{
 		TrustorUserID: "86c0d5",
 	}
-	allPages, err := trusts.List(client.ServiceClient(), trustsListOpts).AllPages(context.TODO())
+	allPages, err := trusts.List(client.ServiceClient(fakeServer), trustsListOpts).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := trusts.ExtractTrusts(allPages)
 	th.AssertNoErr(t, err)
@@ -120,12 +120,12 @@ func TestListTrustsFiltered(t *testing.T) {
 }
 
 func TestListTrustRoles(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTrustRolesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTrustRolesSuccessfully(t, fakeServer)
 
 	count := 0
-	err := trusts.ListRoles(client.ServiceClient(), "987fe8").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := trusts.ListRoles(client.ServiceClient(fakeServer), "987fe8").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := trusts.ExtractRoles(page)
@@ -140,11 +140,11 @@ func TestListTrustRoles(t *testing.T) {
 }
 
 func TestListTrustRolesAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTrustRolesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTrustRolesSuccessfully(t, fakeServer)
 
-	allPages, err := trusts.ListRoles(client.ServiceClient(), "987fe8").AllPages(context.TODO())
+	allPages, err := trusts.ListRoles(client.ServiceClient(fakeServer), "987fe8").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := trusts.ExtractRoles(allPages)
 	th.AssertNoErr(t, err)
@@ -152,21 +152,21 @@ func TestListTrustRolesAllPages(t *testing.T) {
 }
 
 func TestGetTrustRole(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetTrustRoleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetTrustRoleSuccessfully(t, fakeServer)
 
-	role, err := trusts.GetRole(context.TODO(), client.ServiceClient(), "987fe8", "c1648e").Extract()
+	role, err := trusts.GetRole(context.TODO(), client.ServiceClient(fakeServer), "987fe8", "c1648e").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, FirstRole, *role)
 }
 
 func TestCheckTrustRole(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCheckTrustRoleSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCheckTrustRoleSuccessfully(t, fakeServer)
 
-	err := trusts.CheckRole(context.TODO(), client.ServiceClient(), "987fe8", "c1648e").ExtractErr()
+	err := trusts.CheckRole(context.TODO(), client.ServiceClient(fakeServer), "987fe8", "c1648e").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/identity/v3/users/testing/fixtures_test.go b/openstack/identity/v3/users/testing/fixtures_test.go
index faff58d4d..8d409be0b 100644
--- a/openstack/identity/v3/users/testing/fixtures_test.go
+++ b/openstack/identity/v3/users/testing/fixtures_test.go
@@ -25,7 +25,7 @@ const ListOutput = `
     "users": [
         {
             "domain_id": "default",
-            "enabled": true,
+            "enabled": "True",
             "id": "2844b2a08be147a08ef58317d6471f1f",
             "links": {
                 "self": "http://example.com/identity/v3/users/2844b2a08be147a08ef58317d6471f1f"
@@ -374,8 +374,8 @@ var ExpectedProjectsSlice = []projects.Project{FirstProject, SecondProject}
 
 // HandleListUsersSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that responds with a list of two users.
-func HandleListUsersSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
+func HandleListUsersSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -388,8 +388,8 @@ func HandleListUsersSuccessfully(t *testing.T) {
 
 // HandleGetUserSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that responds with a single user.
-func HandleGetUserSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetUserSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -402,8 +402,8 @@ func HandleGetUserSuccessfully(t *testing.T) {
 
 // HandleCreateUserSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests user creation.
-func HandleCreateUserSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateUserSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -415,8 +415,8 @@ func HandleCreateUserSuccessfully(t *testing.T) {
 
 // HandleCreateNoOptionsUserSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests user creation.
-func HandleCreateNoOptionsUserSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateNoOptionsUserSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateNoOptionsRequest)
@@ -428,8 +428,8 @@ func HandleCreateNoOptionsUserSuccessfully(t *testing.T) {
 
 // HandleUpdateUserSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests user update.
-func HandleUpdateUserSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateUserSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
@@ -441,8 +441,8 @@ func HandleUpdateUserSuccessfully(t *testing.T) {
 
 // HandleChangeUserPasswordSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests change user password.
-func HandleChangeUserPasswordSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/9fe1d3/password", func(w http.ResponseWriter, r *http.Request) {
+func HandleChangeUserPasswordSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/9fe1d3/password", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, ChangePasswordRequest)
@@ -453,8 +453,8 @@ func HandleChangeUserPasswordSuccessfully(t *testing.T) {
 
 // HandleDeleteUserSuccessfully creates an HTTP handler at `/users` on the
 // test handler mux that tests user deletion.
-func HandleDeleteUserSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteUserSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -464,8 +464,8 @@ func HandleDeleteUserSuccessfully(t *testing.T) {
 
 // HandleListUserGroupsSuccessfully creates an HTTP handler at /users/{userID}/groups
 // on the test handler mux that respons with a list of two groups
-func HandleListUserGroupsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/9fe1d3/groups", func(w http.ResponseWriter, r *http.Request) {
+func HandleListUserGroupsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/9fe1d3/groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -478,8 +478,8 @@ func HandleListUserGroupsSuccessfully(t *testing.T) {
 
 // HandleAddToGroupSuccessfully creates an HTTP handler at /groups/{groupID}/users/{userID}
 // on the test handler mux that tests adding user to group.
-func HandleAddToGroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups/ea167b/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleAddToGroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups/ea167b/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -489,8 +489,8 @@ func HandleAddToGroupSuccessfully(t *testing.T) {
 
 // HandleIsMemberOfGroupSuccessfully creates an HTTP handler at /groups/{groupID}/users/{userID}
 // on the test handler mux that tests checking whether user belongs to group.
-func HandleIsMemberOfGroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups/ea167b/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleIsMemberOfGroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups/ea167b/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -500,8 +500,8 @@ func HandleIsMemberOfGroupSuccessfully(t *testing.T) {
 
 // HandleRemoveFromGroupSuccessfully creates an HTTP handler at /groups/{groupID}/users/{userID}
 // on the test handler mux that tests removing user from group.
-func HandleRemoveFromGroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups/ea167b/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
+func HandleRemoveFromGroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups/ea167b/users/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -511,8 +511,8 @@ func HandleRemoveFromGroupSuccessfully(t *testing.T) {
 
 // HandleListUserProjectsSuccessfully creates an HTTP handler at /users/{userID}/projects
 // on the test handler mux that respons wit a list of two projects
-func HandleListUserProjectsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/users/9fe1d3/projects", func(w http.ResponseWriter, r *http.Request) {
+func HandleListUserProjectsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/users/9fe1d3/projects", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -525,8 +525,8 @@ func HandleListUserProjectsSuccessfully(t *testing.T) {
 
 // HandleListInGroupSuccessfully creates an HTTP handler at /groups/{groupID}/users
 // on the test handler mux that response with a list of two users
-func HandleListInGroupSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/groups/ea167b/users", func(w http.ResponseWriter, r *http.Request) {
+func HandleListInGroupSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/groups/ea167b/users", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
diff --git a/openstack/identity/v3/users/testing/requests_test.go b/openstack/identity/v3/users/testing/requests_test.go
index cb890808e..12ed9323d 100644
--- a/openstack/identity/v3/users/testing/requests_test.go
+++ b/openstack/identity/v3/users/testing/requests_test.go
@@ -13,12 +13,12 @@ import (
 )
 
 func TestListUsers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListUsersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListUsersSuccessfully(t, fakeServer)
 
 	count := 0
-	err := users.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := users.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := users.ExtractUsers(page)
@@ -33,11 +33,11 @@ func TestListUsers(t *testing.T) {
 }
 
 func TestListUsersAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListUsersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListUsersSuccessfully(t, fakeServer)
 
-	allPages, err := users.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := users.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := users.ExtractUsers(allPages)
 	th.AssertNoErr(t, err)
@@ -79,20 +79,20 @@ func TestListUsersFiltersCheck(t *testing.T) {
 }
 
 func TestGetUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetUserSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetUserSuccessfully(t, fakeServer)
 
-	actual, err := users.Get(context.TODO(), client.ServiceClient(), "9fe1d3").Extract()
+	actual, err := users.Get(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondUser, *actual)
 	th.AssertEquals(t, SecondUser.Extra["email"], "jsmith@example.com")
 }
 
 func TestCreateUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateUserSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateUserSuccessfully(t, fakeServer)
 
 	iTrue := true
 	createOpts := users.CreateOpts{
@@ -113,15 +113,15 @@ func TestCreateUser(t *testing.T) {
 		},
 	}
 
-	actual, err := users.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := users.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondUser, *actual)
 }
 
 func TestCreateNoOptionsUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateNoOptionsUserSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateNoOptionsUserSuccessfully(t, fakeServer)
 
 	iTrue := true
 	createOpts := users.CreateOpts{
@@ -135,15 +135,15 @@ func TestCreateNoOptionsUser(t *testing.T) {
 		},
 	}
 
-	actual, err := users.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := users.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondUserNoOptions, *actual)
 }
 
 func TestUpdateUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateUserSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateUserSuccessfully(t, fakeServer)
 
 	iFalse := false
 	updateOpts := users.UpdateOpts{
@@ -156,39 +156,39 @@ func TestUpdateUser(t *testing.T) {
 		},
 	}
 
-	actual, err := users.Update(context.TODO(), client.ServiceClient(), "9fe1d3", updateOpts).Extract()
+	actual, err := users.Update(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, SecondUserUpdated, *actual)
 }
 
 func TestChangeUserPassword(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleChangeUserPasswordSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleChangeUserPasswordSuccessfully(t, fakeServer)
 
 	changePasswordOpts := users.ChangePasswordOpts{
 		OriginalPassword: "secretsecret",
 		Password:         "new_secretsecret",
 	}
 
-	res := users.ChangePassword(context.TODO(), client.ServiceClient(), "9fe1d3", changePasswordOpts)
+	res := users.ChangePassword(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3", changePasswordOpts)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestDeleteUser(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteUserSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteUserSuccessfully(t, fakeServer)
 
-	res := users.Delete(context.TODO(), client.ServiceClient(), "9fe1d3")
+	res := users.Delete(context.TODO(), client.ServiceClient(fakeServer), "9fe1d3")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListUserGroups(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListUserGroupsSuccessfully(t)
-	allPages, err := users.ListGroups(client.ServiceClient(), "9fe1d3").AllPages(context.TODO())
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListUserGroupsSuccessfully(t, fakeServer)
+	allPages, err := users.ListGroups(client.ServiceClient(fakeServer), "9fe1d3").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := groups.ExtractGroups(allPages)
 	th.AssertNoErr(t, err)
@@ -196,35 +196,35 @@ func TestListUserGroups(t *testing.T) {
 }
 
 func TestAddToGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAddToGroupSuccessfully(t)
-	res := users.AddToGroup(context.TODO(), client.ServiceClient(), "ea167b", "9fe1d3")
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAddToGroupSuccessfully(t, fakeServer)
+	res := users.AddToGroup(context.TODO(), client.ServiceClient(fakeServer), "ea167b", "9fe1d3")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestIsMemberOfGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleIsMemberOfGroupSuccessfully(t)
-	ok, err := users.IsMemberOfGroup(context.TODO(), client.ServiceClient(), "ea167b", "9fe1d3").Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleIsMemberOfGroupSuccessfully(t, fakeServer)
+	ok, err := users.IsMemberOfGroup(context.TODO(), client.ServiceClient(fakeServer), "ea167b", "9fe1d3").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, true, ok)
 }
 
 func TestRemoveFromGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRemoveFromGroupSuccessfully(t)
-	res := users.RemoveFromGroup(context.TODO(), client.ServiceClient(), "ea167b", "9fe1d3")
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRemoveFromGroupSuccessfully(t, fakeServer)
+	res := users.RemoveFromGroup(context.TODO(), client.ServiceClient(fakeServer), "ea167b", "9fe1d3")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListUserProjects(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListUserProjectsSuccessfully(t)
-	allPages, err := users.ListProjects(client.ServiceClient(), "9fe1d3").AllPages(context.TODO())
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListUserProjectsSuccessfully(t, fakeServer)
+	allPages, err := users.ListProjects(client.ServiceClient(fakeServer), "9fe1d3").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := projects.ExtractProjects(allPages)
 	th.AssertNoErr(t, err)
@@ -232,16 +232,16 @@ func TestListUserProjects(t *testing.T) {
 }
 
 func TestListInGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListInGroupSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListInGroupSuccessfully(t, fakeServer)
 
 	iTrue := true
 	listOpts := users.ListOpts{
 		Enabled: &iTrue,
 	}
 
-	allPages, err := users.ListInGroup(client.ServiceClient(), "ea167b", listOpts).AllPages(context.TODO())
+	allPages, err := users.ListInGroup(client.ServiceClient(fakeServer), "ea167b", listOpts).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := users.ExtractUsers(allPages)
 	th.AssertNoErr(t, err)
diff --git a/openstack/image/v2/imagedata/testing/fixtures_test.go b/openstack/image/v2/imagedata/testing/fixtures_test.go
index fa3b4af78..d9af6c170 100644
--- a/openstack/image/v2/imagedata/testing/fixtures_test.go
+++ b/openstack/image/v2/imagedata/testing/fixtures_test.go
@@ -6,14 +6,14 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // HandlePutImageDataSuccessfully setup
-func HandlePutImageDataSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/file", func(w http.ResponseWriter, r *http.Request) {
+func HandlePutImageDataSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/file", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		b, err := io.ReadAll(r.Body)
 		if err != nil {
@@ -27,10 +27,10 @@ func HandlePutImageDataSuccessfully(t *testing.T) {
 }
 
 // HandleStageImageDataSuccessfully setup
-func HandleStageImageDataSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/stage", func(w http.ResponseWriter, r *http.Request) {
+func HandleStageImageDataSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/stage", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		b, err := io.ReadAll(r.Body)
 		if err != nil {
@@ -44,10 +44,10 @@ func HandleStageImageDataSuccessfully(t *testing.T) {
 }
 
 // HandleGetImageDataSuccessfully setup
-func HandleGetImageDataSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/file", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetImageDataSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/file", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusOK)
 
diff --git a/openstack/image/v2/imagedata/testing/requests_test.go b/openstack/image/v2/imagedata/testing/requests_test.go
index 8e1461e1c..ad4dba86f 100644
--- a/openstack/image/v2/imagedata/testing/requests_test.go
+++ b/openstack/image/v2/imagedata/testing/requests_test.go
@@ -8,18 +8,18 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/image/v2/imagedata"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestUpload(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandlePutImageDataSuccessfully(t)
+	HandlePutImageDataSuccessfully(t, fakeServer)
 
 	err := imagedata.Upload(
 		context.TODO(),
-		fakeclient.ServiceClient(),
+		client.ServiceClient(fakeServer),
 		"da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
 		readSeekerOfBytes([]byte{5, 3, 7, 24})).ExtractErr()
 
@@ -27,14 +27,14 @@ func TestUpload(t *testing.T) {
 }
 
 func TestStage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleStageImageDataSuccessfully(t)
+	HandleStageImageDataSuccessfully(t, fakeServer)
 
 	err := imagedata.Stage(
 		context.TODO(),
-		fakeclient.ServiceClient(),
+		client.ServiceClient(fakeServer),
 		"da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
 		readSeekerOfBytes([]byte{5, 3, 7, 24})).ExtractErr()
 
@@ -88,12 +88,12 @@ func (rs *RS) Seek(offset int64, whence int) (int64, error) {
 }
 
 func TestDownload(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGetImageDataSuccessfully(t)
+	HandleGetImageDataSuccessfully(t, fakeServer)
 
-	rdr, err := imagedata.Download(context.TODO(), fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea").Extract()
+	rdr, err := imagedata.Download(context.TODO(), client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea").Extract()
 	th.AssertNoErr(t, err)
 
 	defer rdr.Close()
diff --git a/openstack/image/v2/imageimport/testing/requests_test.go b/openstack/image/v2/imageimport/testing/requests_test.go
index 74df12e54..05bcc9caf 100644
--- a/openstack/image/v2/imageimport/testing/requests_test.go
+++ b/openstack/image/v2/imageimport/testing/requests_test.go
@@ -8,16 +8,16 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/image/v2/imageimport"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/info/import", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/info/import", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -30,7 +30,7 @@ func TestGet(t *testing.T) {
 		string(imageimport.WebDownloadMethod),
 	}
 
-	s, err := imageimport.Get(context.TODO(), fakeclient.ServiceClient()).Extract()
+	s, err := imageimport.Get(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.ImportMethods.Description, "Import methods available.")
@@ -39,12 +39,12 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/import", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/import", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, ImportCreateRequest)
 
 		w.Header().Add("Content-Type", "application/json")
@@ -56,6 +56,6 @@ func TestCreate(t *testing.T) {
 		Name: imageimport.WebDownloadMethod,
 		URI:  "http://download.cirros-cloud.net/0.4.0/cirros-0.4.0-x86_64-disk.img",
 	}
-	err := imageimport.Create(context.TODO(), fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", opts).ExtractErr()
+	err := imageimport.Create(context.TODO(), client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/image/v2/images/testing/fixtures_test.go b/openstack/image/v2/images/testing/fixtures_test.go
index 693f6b996..0ec25214d 100644
--- a/openstack/image/v2/images/testing/fixtures_test.go
+++ b/openstack/image/v2/images/testing/fixtures_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 type imageEntry struct {
@@ -17,7 +17,7 @@ type imageEntry struct {
 }
 
 // HandleImageListSuccessfully test setup
-func HandleImageListSuccessfully(t *testing.T) {
+func HandleImageListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
 
 	images := make([]imageEntry, 3)
 
@@ -99,9 +99,9 @@ func HandleImageListSuccessfully(t *testing.T) {
             "hw_scsi_model": "virtio-scsi"
         }`}
 
-	th.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 
@@ -160,10 +160,10 @@ func HandleImageListSuccessfully(t *testing.T) {
 }
 
 // HandleImageCreationSuccessfully test setup
-func HandleImageCreationSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageCreationSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
 			"id": "e7db3b45-8db7-47ad-8109-3fb55c2c24fd",
 			"name": "Ubuntu 12.10",
@@ -206,10 +206,10 @@ func HandleImageCreationSuccessfully(t *testing.T) {
 
 // HandleImageCreationSuccessfullyNulls test setup
 // JSON null values could be also returned according to behaviour https://bugs.launchpad.net/glance/+bug/1481512
-func HandleImageCreationSuccessfullyNulls(t *testing.T) {
-	th.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageCreationSuccessfullyNulls(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
 			"id": "e7db3b45-8db7-47ad-8109-3fb55c2c24fd",
 			"architecture": "x86_64",
@@ -251,10 +251,10 @@ func HandleImageCreationSuccessfullyNulls(t *testing.T) {
 }
 
 // HandleImageGetSuccessfully test setup
-func HandleImageGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images/1bea47ed-f6a9-463b-b423-14b9cca9ad27", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/1bea47ed-f6a9-463b-b423-14b9cca9ad27", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -287,20 +287,20 @@ func HandleImageGetSuccessfully(t *testing.T) {
 }
 
 // HandleImageDeleteSuccessfully test setup
-func HandleImageDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images/1bea47ed-f6a9-463b-b423-14b9cca9ad27", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/1bea47ed-f6a9-463b-b423-14b9cca9ad27", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
 // HandleImageUpdateSuccessfully setup
-func HandleImageUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `[
 			{
@@ -380,10 +380,10 @@ func HandleImageUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleImageListByTagsSuccessfully tests a list operation with tags.
-func HandleImageListByTagsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageListByTagsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 
@@ -422,10 +422,10 @@ func HandleImageListByTagsSuccessfully(t *testing.T) {
 }
 
 // HandleImageUpdatePropertiesSuccessfully setup
-func HandleImageUpdatePropertiesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageUpdatePropertiesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `[
 			{
diff --git a/openstack/image/v2/images/testing/requests_test.go b/openstack/image/v2/images/testing/requests_test.go
index 8b857871a..90c9833be 100644
--- a/openstack/image/v2/images/testing/requests_test.go
+++ b/openstack/image/v2/images/testing/requests_test.go
@@ -8,18 +8,18 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/image/v2/images"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestListImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageListSuccessfully(t)
+	HandleImageListSuccessfully(t, fakeServer)
 
 	t.Logf("Id\tName\tOwner\tChecksum\tSizeBytes")
 
-	pager := images.List(fakeclient.ServiceClient(), images.ListOpts{Limit: 1})
+	pager := images.List(client.ServiceClient(fakeServer), images.ListOpts{Limit: 1})
 	t.Logf("Pager state %v", pager)
 	count, pages := 0, 0
 	err := pager.EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -45,12 +45,12 @@ func TestListImage(t *testing.T) {
 }
 
 func TestAllPagesImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageListSuccessfully(t)
+	HandleImageListSuccessfully(t, fakeServer)
 
-	pages, err := images.List(fakeclient.ServiceClient(), nil).AllPages(context.TODO())
+	pages, err := images.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	images, err := images.ExtractImages(pages)
 	th.AssertNoErr(t, err)
@@ -58,15 +58,15 @@ func TestAllPagesImage(t *testing.T) {
 }
 
 func TestCreateImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageCreationSuccessfully(t)
+	HandleImageCreationSuccessfully(t, fakeServer)
 
 	id := "e7db3b45-8db7-47ad-8109-3fb55c2c24fd"
 	name := "Ubuntu 12.10"
 
-	actualImage, err := images.Create(context.TODO(), fakeclient.ServiceClient(), images.CreateOpts{
+	actualImage, err := images.Create(context.TODO(), client.ServiceClient(fakeServer), images.CreateOpts{
 		ID:   id,
 		Name: name,
 		Properties: map[string]string{
@@ -119,15 +119,15 @@ func TestCreateImage(t *testing.T) {
 }
 
 func TestCreateImageNulls(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageCreationSuccessfullyNulls(t)
+	HandleImageCreationSuccessfullyNulls(t, fakeServer)
 
 	id := "e7db3b45-8db7-47ad-8109-3fb55c2c24fd"
 	name := "Ubuntu 12.10"
 
-	actualImage, err := images.Create(context.TODO(), fakeclient.ServiceClient(), images.CreateOpts{
+	actualImage, err := images.Create(context.TODO(), client.ServiceClient(fakeServer), images.CreateOpts{
 		ID:   id,
 		Name: name,
 		Tags: []string{"ubuntu", "quantal"},
@@ -188,12 +188,12 @@ func TestCreateImageNulls(t *testing.T) {
 }
 
 func TestGetImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageGetSuccessfully(t)
+	HandleImageGetSuccessfully(t, fakeServer)
 
-	actualImage, err := images.Get(context.TODO(), fakeclient.ServiceClient(), "1bea47ed-f6a9-463b-b423-14b9cca9ad27").Extract()
+	actualImage, err := images.Get(context.TODO(), client.ServiceClient(fakeServer), "1bea47ed-f6a9-463b-b423-14b9cca9ad27").Extract()
 
 	th.AssertNoErr(t, err)
 
@@ -246,22 +246,22 @@ func TestGetImage(t *testing.T) {
 }
 
 func TestDeleteImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageDeleteSuccessfully(t)
+	HandleImageDeleteSuccessfully(t, fakeServer)
 
-	result := images.Delete(context.TODO(), fakeclient.ServiceClient(), "1bea47ed-f6a9-463b-b423-14b9cca9ad27")
+	result := images.Delete(context.TODO(), client.ServiceClient(fakeServer), "1bea47ed-f6a9-463b-b423-14b9cca9ad27")
 	th.AssertNoErr(t, result.Err)
 }
 
 func TestUpdateImage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageUpdateSuccessfully(t)
+	HandleImageUpdateSuccessfully(t, fakeServer)
 
-	actualImage, err := images.Update(context.TODO(), fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", images.UpdateOpts{
+	actualImage, err := images.Update(context.TODO(), client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", images.UpdateOpts{
 		images.ReplaceImageName{NewName: "Fedora 17"},
 		images.ReplaceImageTags{NewTags: []string{"fedora", "beefy"}},
 		images.ReplaceImageMinDisk{NewMinDisk: 21},
@@ -342,10 +342,10 @@ func TestImageDateQuery(t *testing.T) {
 }
 
 func TestImageListByTags(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageListByTagsSuccessfully(t)
+	HandleImageListByTagsSuccessfully(t, fakeServer)
 
 	listOpts := images.ListOpts{
 		Tags: []string{"foo", "bar"},
@@ -356,7 +356,7 @@ func TestImageListByTags(t *testing.T) {
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, expectedQueryString, actualQueryString)
 
-	pages, err := images.List(fakeclient.ServiceClient(), listOpts).AllPages(context.TODO())
+	pages, err := images.List(client.ServiceClient(fakeServer), listOpts).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	allImages, err := images.ExtractImages(pages)
 	th.AssertNoErr(t, err)
@@ -410,12 +410,12 @@ func TestImageListByTags(t *testing.T) {
 }
 
 func TestUpdateImageProperties(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageUpdatePropertiesSuccessfully(t)
+	HandleImageUpdatePropertiesSuccessfully(t, fakeServer)
 
-	actualImage, err := images.Update(context.TODO(), fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", images.UpdateOpts{
+	actualImage, err := images.Update(context.TODO(), client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea", images.UpdateOpts{
 		images.UpdateImageProperty{
 			Op:    images.AddOp,
 			Name:  "hw_disk_bus",
diff --git a/openstack/image/v2/members/testing/fixtures_test.go b/openstack/image/v2/members/testing/fixtures_test.go
index 6e0bd326e..8c2f9261a 100644
--- a/openstack/image/v2/members/testing/fixtures_test.go
+++ b/openstack/image/v2/members/testing/fixtures_test.go
@@ -6,14 +6,14 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // HandleCreateImageMemberSuccessfully setup
-func HandleCreateImageMemberSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateImageMemberSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `{"member": "8989447062e04a818baf9e073fd04fa7"}`)
 
@@ -31,10 +31,10 @@ func HandleCreateImageMemberSuccessfully(t *testing.T) {
 }
 
 // HandleImageMemberList happy path setup
-func HandleImageMemberList(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageMemberList(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `{
@@ -62,10 +62,10 @@ func HandleImageMemberList(t *testing.T) {
 }
 
 // HandleImageMemberEmptyList happy path setup
-func HandleImageMemberEmptyList(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageMemberEmptyList(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `{
@@ -76,10 +76,10 @@ func HandleImageMemberEmptyList(t *testing.T) {
 }
 
 // HandleImageMemberDetails setup
-func HandleImageMemberDetails(t *testing.T) {
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members/8989447062e04a818baf9e073fd04fa7", func(w http.ResponseWriter, r *http.Request) {
+func HandleImageMemberDetails(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members/8989447062e04a818baf9e073fd04fa7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `{
@@ -94,13 +94,13 @@ func HandleImageMemberDetails(t *testing.T) {
 }
 
 // HandleImageMemberDeleteSuccessfully setup
-func HandleImageMemberDeleteSuccessfully(t *testing.T) *CallsCounter {
+func HandleImageMemberDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) *CallsCounter {
 	var counter CallsCounter
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members/8989447062e04a818baf9e073fd04fa7", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members/8989447062e04a818baf9e073fd04fa7", func(w http.ResponseWriter, r *http.Request) {
 		counter.Counter = counter.Counter + 1
 
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusNoContent)
 	})
@@ -108,13 +108,13 @@ func HandleImageMemberDeleteSuccessfully(t *testing.T) *CallsCounter {
 }
 
 // HandleImageMemberUpdate setup
-func HandleImageMemberUpdate(t *testing.T) *CallsCounter {
+func HandleImageMemberUpdate(t *testing.T, fakeServer th.FakeServer) *CallsCounter {
 	var counter CallsCounter
-	th.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members/8989447062e04a818baf9e073fd04fa7", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/images/da3b75d9-3f4a-40e7-8a2c-bfab23927dea/members/8989447062e04a818baf9e073fd04fa7", func(w http.ResponseWriter, r *http.Request) {
 		counter.Counter = counter.Counter + 1
 
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		th.TestJSONRequest(t, r, `{"status": "accepted"}`)
 
diff --git a/openstack/image/v2/members/testing/requests_test.go b/openstack/image/v2/members/testing/requests_test.go
index 273d82581..66798c432 100644
--- a/openstack/image/v2/members/testing/requests_test.go
+++ b/openstack/image/v2/members/testing/requests_test.go
@@ -8,18 +8,18 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/image/v2/members"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const createdAtString = "2013-09-20T19:22:19Z"
 const updatedAtString = "2013-09-20T19:25:31Z"
 
 func TestCreateMemberSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCreateImageMemberSuccessfully(t)
-	im, err := members.Create(context.TODO(), fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
+	HandleCreateImageMemberSuccessfully(t, fakeServer)
+	im, err := members.Create(context.TODO(), client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
 		"8989447062e04a818baf9e073fd04fa7").Extract()
 	th.AssertNoErr(t, err)
 
@@ -41,12 +41,12 @@ func TestCreateMemberSuccessfully(t *testing.T) {
 }
 
 func TestMemberListSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageMemberList(t)
+	HandleImageMemberList(t, fakeServer)
 
-	pager := members.List(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea")
+	pager := members.List(client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea")
 	t.Logf("Pager state %v", pager)
 	count, pages := 0, 0
 	err := pager.EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -71,12 +71,12 @@ func TestMemberListSuccessfully(t *testing.T) {
 }
 
 func TestMemberListEmpty(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageMemberEmptyList(t)
+	HandleImageMemberEmptyList(t, fakeServer)
 
-	pager := members.List(fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea")
+	pager := members.List(client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea")
 	t.Logf("Pager state %v", pager)
 	count, pages := 0, 0
 	err := pager.EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -101,11 +101,11 @@ func TestMemberListEmpty(t *testing.T) {
 }
 
 func TestShowMemberDetails(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleImageMemberDetails(t)
-	md, err := members.Get(context.TODO(), fakeclient.ServiceClient(),
+	HandleImageMemberDetails(t, fakeServer)
+	md, err := members.Get(context.TODO(), client.ServiceClient(fakeServer),
 		"da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
 		"8989447062e04a818baf9e073fd04fa7").Extract()
 
@@ -131,23 +131,23 @@ func TestShowMemberDetails(t *testing.T) {
 }
 
 func TestDeleteMember(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	counter := HandleImageMemberDeleteSuccessfully(t)
+	counter := HandleImageMemberDeleteSuccessfully(t, fakeServer)
 
-	result := members.Delete(context.TODO(), fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
+	result := members.Delete(context.TODO(), client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
 		"8989447062e04a818baf9e073fd04fa7")
 	th.AssertEquals(t, 1, counter.Counter)
 	th.AssertNoErr(t, result.Err)
 }
 
 func TestMemberUpdateSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	counter := HandleImageMemberUpdate(t)
-	im, err := members.Update(context.TODO(), fakeclient.ServiceClient(), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
+	counter := HandleImageMemberUpdate(t, fakeServer)
+	im, err := members.Update(context.TODO(), client.ServiceClient(fakeServer), "da3b75d9-3f4a-40e7-8a2c-bfab23927dea",
 		"8989447062e04a818baf9e073fd04fa7",
 		members.UpdateOpts{
 			Status: "accepted",
diff --git a/openstack/image/v2/tasks/testing/requests_test.go b/openstack/image/v2/tasks/testing/requests_test.go
index f93030442..1949d07c3 100644
--- a/openstack/image/v2/tasks/testing/requests_test.go
+++ b/openstack/image/v2/tasks/testing/requests_test.go
@@ -10,16 +10,16 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/image/v2/tasks"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fakeclient "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/tasks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/tasks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -29,7 +29,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := tasks.List(fakeclient.ServiceClient(), tasks.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := tasks.List(client.ServiceClient(fakeServer), tasks.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := tasks.ExtractTasks(page)
 		if err != nil {
@@ -54,12 +54,12 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/tasks/1252f636-1246-4319-bfba-c47cde0efbe0", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/tasks/1252f636-1246-4319-bfba-c47cde0efbe0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -67,7 +67,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, TasksGetResult)
 	})
 
-	s, err := tasks.Get(context.TODO(), fakeclient.ServiceClient(), "1252f636-1246-4319-bfba-c47cde0efbe0").Extract()
+	s, err := tasks.Get(context.TODO(), client.ServiceClient(fakeServer), "1252f636-1246-4319-bfba-c47cde0efbe0").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, string(tasks.TaskStatusPending))
@@ -91,12 +91,12 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/tasks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/tasks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fakeclient.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, TaskCreateRequest)
 
 		w.Header().Add("Content-Type", "application/json")
@@ -116,7 +116,7 @@ func TestCreate(t *testing.T) {
 			"import_from":        "https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64.img",
 		},
 	}
-	s, err := tasks.Create(context.TODO(), fakeclient.ServiceClient(), opts).Extract()
+	s, err := tasks.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, string(tasks.TaskStatusPending))
diff --git a/openstack/keymanager/v1/acls/testing/fixtures_test.go b/openstack/keymanager/v1/acls/testing/fixtures_test.go
index 89b6ea7d4..cc2624985 100644
--- a/openstack/keymanager/v1/acls/testing/fixtures_test.go
+++ b/openstack/keymanager/v1/acls/testing/fixtures_test.go
@@ -67,8 +67,8 @@ const UpdateRequest = `
 
 // HandleGetSecretACLSuccessfully creates an HTTP handler at `/secrets/uuid/acl`
 // on the test handler mux that responds with an acl.
-func HandleGetSecretACLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSecretACLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -81,8 +81,8 @@ func HandleGetSecretACLSuccessfully(t *testing.T) {
 
 // HandleGetContainerACLSuccessfully creates an HTTP handler at `/secrets/uuid/acl`
 // on the test handler mux that responds with an acl.
-func HandleGetContainerACLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetContainerACLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -95,8 +95,8 @@ func HandleGetContainerACLSuccessfully(t *testing.T) {
 
 // HandleSetSecretACLSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret creation.
-func HandleSetSecretACLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
+func HandleSetSecretACLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, SetRequest)
@@ -108,8 +108,8 @@ func HandleSetSecretACLSuccessfully(t *testing.T) {
 
 // HandleSetContainerACLSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret creation.
-func HandleSetContainerACLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
+func HandleSetContainerACLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, SetRequest)
@@ -121,8 +121,8 @@ func HandleSetContainerACLSuccessfully(t *testing.T) {
 
 // HandleUpdateSecretACLSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret creation.
-func HandleUpdateSecretACLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateSecretACLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
@@ -134,8 +134,8 @@ func HandleUpdateSecretACLSuccessfully(t *testing.T) {
 
 // HandleUpdateContainerACLSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret creation.
-func HandleUpdateContainerACLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateContainerACLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, UpdateRequest)
@@ -147,8 +147,8 @@ func HandleUpdateContainerACLSuccessfully(t *testing.T) {
 
 // HandleDeleteSecretACLSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret deletion.
-func HandleDeleteSecretACLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSecretACLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -158,8 +158,8 @@ func HandleDeleteSecretACLSuccessfully(t *testing.T) {
 
 // HandleDeleteContainerACLSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret deletion.
-func HandleDeleteContainerACLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteContainerACLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/acl", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/keymanager/v1/acls/testing/requests_test.go b/openstack/keymanager/v1/acls/testing/requests_test.go
index 336738152..6b8237fb0 100644
--- a/openstack/keymanager/v1/acls/testing/requests_test.go
+++ b/openstack/keymanager/v1/acls/testing/requests_test.go
@@ -10,29 +10,29 @@ import (
 )
 
 func TestGetSecretACL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSecretACLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSecretACLSuccessfully(t, fakeServer)
 
-	actual, err := acls.GetSecretACL(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c").Extract()
+	actual, err := acls.GetSecretACL(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedACL, *actual)
 }
 
 func TestGetContainerACL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetContainerACLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetContainerACLSuccessfully(t, fakeServer)
 
-	actual, err := acls.GetContainerACL(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c").Extract()
+	actual, err := acls.GetContainerACL(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedACL, *actual)
 }
 
 func TestSetSecretACL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSetSecretACLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSetSecretACLSuccessfully(t, fakeServer)
 
 	users := []string{"GG27dVwR9gBMnsOaRoJ1DFJmZfdVjIdW"}
 	iFalse := false
@@ -44,15 +44,15 @@ func TestSetSecretACL(t *testing.T) {
 		},
 	}
 
-	actual, err := acls.SetSecretACL(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", setOpts).Extract()
+	actual, err := acls.SetSecretACL(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", setOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedSecretACLRef, *actual)
 }
 
 func TestSetContainerACL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleSetContainerACLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleSetContainerACLSuccessfully(t, fakeServer)
 
 	users := []string{"GG27dVwR9gBMnsOaRoJ1DFJmZfdVjIdW"}
 	iFalse := false
@@ -64,33 +64,33 @@ func TestSetContainerACL(t *testing.T) {
 		},
 	}
 
-	actual, err := acls.SetContainerACL(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", setOpts).Extract()
+	actual, err := acls.SetContainerACL(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", setOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedContainerACLRef, *actual)
 }
 
 func TestDeleteSecretACL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSecretACLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSecretACLSuccessfully(t, fakeServer)
 
-	res := acls.DeleteSecretACL(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c")
+	res := acls.DeleteSecretACL(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestDeleteContainerACL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteContainerACLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteContainerACLSuccessfully(t, fakeServer)
 
-	res := acls.DeleteContainerACL(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c")
+	res := acls.DeleteContainerACL(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateSecretACL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSecretACLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSecretACLSuccessfully(t, fakeServer)
 
 	newUsers := []string{}
 	updateOpts := acls.SetOpts{
@@ -100,15 +100,15 @@ func TestUpdateSecretACL(t *testing.T) {
 		},
 	}
 
-	actual, err := acls.UpdateSecretACL(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", updateOpts).Extract()
+	actual, err := acls.UpdateSecretACL(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedSecretACLRef, *actual)
 }
 
 func TestUpdateContainerACL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateContainerACLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateContainerACLSuccessfully(t, fakeServer)
 
 	newUsers := []string{}
 	updateOpts := acls.SetOpts{
@@ -118,7 +118,7 @@ func TestUpdateContainerACL(t *testing.T) {
 		},
 	}
 
-	actual, err := acls.UpdateContainerACL(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", updateOpts).Extract()
+	actual, err := acls.UpdateContainerACL(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedContainerACLRef, *actual)
 }
diff --git a/openstack/keymanager/v1/containers/testing/fixtures_test.go b/openstack/keymanager/v1/containers/testing/fixtures_test.go
index d290a5a9a..a253e0bfd 100644
--- a/openstack/keymanager/v1/containers/testing/fixtures_test.go
+++ b/openstack/keymanager/v1/containers/testing/fixtures_test.go
@@ -227,8 +227,8 @@ const DeleteConsumerRequest = `
 
 // HandleListContainersSuccessfully creates an HTTP handler at `/containers` on the
 // test handler mux that responds with a list of two containers.
-func HandleListContainersSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers", func(w http.ResponseWriter, r *http.Request) {
+func HandleListContainersSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -241,8 +241,8 @@ func HandleListContainersSuccessfully(t *testing.T) {
 
 // HandleGetContainerSuccessfully creates an HTTP handler at `/containers` on the
 // test handler mux that responds with a single resource.
-func HandleGetContainerSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetContainerSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -255,8 +255,8 @@ func HandleGetContainerSuccessfully(t *testing.T) {
 
 // HandleCreateContainerSuccessfully creates an HTTP handler at `/containers` on the
 // test handler mux that tests resource creation.
-func HandleCreateContainerSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateContainerSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -268,8 +268,8 @@ func HandleCreateContainerSuccessfully(t *testing.T) {
 
 // HandleDeleteContainerSuccessfully creates an HTTP handler at `/containers` on the
 // test handler mux that tests resource deletion.
-func HandleDeleteContainerSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteContainerSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -280,8 +280,8 @@ func HandleDeleteContainerSuccessfully(t *testing.T) {
 // HandleListConsumersSuccessfully creates an HTTP handler at
 // `/containers/uuid/consumers` on the test handler mux that responds with
 // a list of consumers.
-func HandleListConsumersSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0/consumers", func(w http.ResponseWriter, r *http.Request) {
+func HandleListConsumersSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0/consumers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -295,8 +295,8 @@ func HandleListConsumersSuccessfully(t *testing.T) {
 // HandleCreateConsumerSuccessfully creates an HTTP handler at
 // `/containers/uuid/consumers` on the test handler mux that tests resource
 // creation.
-func HandleCreateConsumerSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0/consumers", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateConsumerSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0/consumers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateConsumerRequest)
@@ -309,8 +309,8 @@ func HandleCreateConsumerSuccessfully(t *testing.T) {
 // HandleDeleteConsumerSuccessfully creates an HTTP handler at
 // `/containers/uuid/consumers` on the test handler mux that tests resource
 // deletion.
-func HandleDeleteConsumerSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0/consumers", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteConsumerSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/containers/dfdb88f3-4ddb-4525-9da6-066453caa9b0/consumers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateConsumerRequest)
diff --git a/openstack/keymanager/v1/containers/testing/requests_test.go b/openstack/keymanager/v1/containers/testing/requests_test.go
index 44ed27b21..83fd23502 100644
--- a/openstack/keymanager/v1/containers/testing/requests_test.go
+++ b/openstack/keymanager/v1/containers/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListContainers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListContainersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListContainersSuccessfully(t, fakeServer)
 
 	count := 0
-	err := containers.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := containers.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := containers.ExtractContainers(page)
@@ -31,11 +31,11 @@ func TestListContainers(t *testing.T) {
 }
 
 func TestListContainersAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListContainersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListContainersSuccessfully(t, fakeServer)
 
-	allPages, err := containers.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := containers.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := containers.ExtractContainers(allPages)
 	th.AssertNoErr(t, err)
@@ -43,19 +43,19 @@ func TestListContainersAllPages(t *testing.T) {
 }
 
 func TestGetContainer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetContainerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetContainerSuccessfully(t, fakeServer)
 
-	actual, err := containers.Get(context.TODO(), client.ServiceClient(), "dfdb88f3-4ddb-4525-9da6-066453caa9b0").Extract()
+	actual, err := containers.Get(context.TODO(), client.ServiceClient(fakeServer), "dfdb88f3-4ddb-4525-9da6-066453caa9b0").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, FirstContainer, *actual)
 }
 
 func TestCreateContainer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateContainerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateContainerSuccessfully(t, fakeServer)
 
 	createOpts := containers.CreateOpts{
 		Type: containers.GenericContainer,
@@ -68,27 +68,27 @@ func TestCreateContainer(t *testing.T) {
 		},
 	}
 
-	actual, err := containers.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := containers.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, FirstContainer, *actual)
 }
 
 func TestDeleteContainer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteContainerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteContainerSuccessfully(t, fakeServer)
 
-	res := containers.Delete(context.TODO(), client.ServiceClient(), "dfdb88f3-4ddb-4525-9da6-066453caa9b0")
+	res := containers.Delete(context.TODO(), client.ServiceClient(fakeServer), "dfdb88f3-4ddb-4525-9da6-066453caa9b0")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListConsumers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListConsumersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListConsumersSuccessfully(t, fakeServer)
 
 	count := 0
-	err := containers.ListConsumers(client.ServiceClient(), "dfdb88f3-4ddb-4525-9da6-066453caa9b0", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := containers.ListConsumers(client.ServiceClient(fakeServer), "dfdb88f3-4ddb-4525-9da6-066453caa9b0", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := containers.ExtractConsumers(page)
@@ -103,11 +103,11 @@ func TestListConsumers(t *testing.T) {
 }
 
 func TestListConsumersAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListConsumersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListConsumersSuccessfully(t, fakeServer)
 
-	allPages, err := containers.ListConsumers(client.ServiceClient(), "dfdb88f3-4ddb-4525-9da6-066453caa9b0", nil).AllPages(context.TODO())
+	allPages, err := containers.ListConsumers(client.ServiceClient(fakeServer), "dfdb88f3-4ddb-4525-9da6-066453caa9b0", nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := containers.ExtractConsumers(allPages)
 	th.AssertNoErr(t, err)
@@ -115,31 +115,31 @@ func TestListConsumersAllPages(t *testing.T) {
 }
 
 func TestCreateConsumer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateConsumerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateConsumerSuccessfully(t, fakeServer)
 
 	createOpts := containers.CreateConsumerOpts{
 		Name: "CONSUMER-LZILN1zq",
 		URL:  "http://example.com",
 	}
 
-	actual, err := containers.CreateConsumer(context.TODO(), client.ServiceClient(), "dfdb88f3-4ddb-4525-9da6-066453caa9b0", createOpts).Extract()
+	actual, err := containers.CreateConsumer(context.TODO(), client.ServiceClient(fakeServer), "dfdb88f3-4ddb-4525-9da6-066453caa9b0", createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedCreatedConsumer, *actual)
 }
 
 func TestDeleteConsumer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteConsumerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteConsumerSuccessfully(t, fakeServer)
 
 	deleteOpts := containers.DeleteConsumerOpts{
 		Name: "CONSUMER-LZILN1zq",
 		URL:  "http://example.com",
 	}
 
-	actual, err := containers.DeleteConsumer(context.TODO(), client.ServiceClient(), "dfdb88f3-4ddb-4525-9da6-066453caa9b0", deleteOpts).Extract()
+	actual, err := containers.DeleteConsumer(context.TODO(), client.ServiceClient(fakeServer), "dfdb88f3-4ddb-4525-9da6-066453caa9b0", deleteOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, FirstContainer, *actual)
 }
diff --git a/openstack/keymanager/v1/orders/testing/fixtures_test.go b/openstack/keymanager/v1/orders/testing/fixtures_test.go
index 7eb14e0ed..40d55c21f 100644
--- a/openstack/keymanager/v1/orders/testing/fixtures_test.go
+++ b/openstack/keymanager/v1/orders/testing/fixtures_test.go
@@ -135,8 +135,8 @@ var ExpectedOrdersSlice = []orders.Order{FirstOrder, SecondOrder}
 
 // HandleListOrdersSuccessfully creates an HTTP handler at `/orders` on the
 // test handler mux that responds with a list of two orders.
-func HandleListOrdersSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/orders", func(w http.ResponseWriter, r *http.Request) {
+func HandleListOrdersSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/orders", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -149,8 +149,8 @@ func HandleListOrdersSuccessfully(t *testing.T) {
 
 // HandleGetOrderSuccessfully creates an HTTP handler at `/orders` on the
 // test handler mux that responds with a single resource.
-func HandleGetOrderSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/orders/46f73695-82bb-447a-bf96-6635f0fb0ce7", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetOrderSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/orders/46f73695-82bb-447a-bf96-6635f0fb0ce7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -163,8 +163,8 @@ func HandleGetOrderSuccessfully(t *testing.T) {
 
 // HandleCreateOrderSuccessfully creates an HTTP handler at `/orders` on the
 // test handler mux that tests resource creation.
-func HandleCreateOrderSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/orders", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateOrderSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/orders", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -176,8 +176,8 @@ func HandleCreateOrderSuccessfully(t *testing.T) {
 
 // HandleDeleteOrderSuccessfully creates an HTTP handler at `/orders` on the
 // test handler mux that tests resource deletion.
-func HandleDeleteOrderSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/orders/46f73695-82bb-447a-bf96-6635f0fb0ce7", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteOrderSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/orders/46f73695-82bb-447a-bf96-6635f0fb0ce7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/keymanager/v1/orders/testing/requests_test.go b/openstack/keymanager/v1/orders/testing/requests_test.go
index df2b10d9c..f3545313d 100644
--- a/openstack/keymanager/v1/orders/testing/requests_test.go
+++ b/openstack/keymanager/v1/orders/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListOrders(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListOrdersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListOrdersSuccessfully(t, fakeServer)
 
 	count := 0
-	err := orders.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := orders.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := orders.ExtractOrders(page)
@@ -31,11 +31,11 @@ func TestListOrders(t *testing.T) {
 }
 
 func TestListOrdersAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListOrdersSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListOrdersSuccessfully(t, fakeServer)
 
-	allPages, err := orders.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := orders.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := orders.ExtractOrders(allPages)
 	th.AssertNoErr(t, err)
@@ -43,19 +43,19 @@ func TestListOrdersAllPages(t *testing.T) {
 }
 
 func TestGetOrder(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetOrderSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetOrderSuccessfully(t, fakeServer)
 
-	actual, err := orders.Get(context.TODO(), client.ServiceClient(), "46f73695-82bb-447a-bf96-6635f0fb0ce7").Extract()
+	actual, err := orders.Get(context.TODO(), client.ServiceClient(fakeServer), "46f73695-82bb-447a-bf96-6635f0fb0ce7").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, SecondOrder, *actual)
 }
 
 func TestCreateOrder(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateOrderSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateOrderSuccessfully(t, fakeServer)
 
 	createOpts := orders.CreateOpts{
 		Type: orders.KeyOrder,
@@ -67,16 +67,16 @@ func TestCreateOrder(t *testing.T) {
 		},
 	}
 
-	actual, err := orders.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := orders.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, SecondOrder, *actual)
 }
 
 func TestDeleteOrder(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteOrderSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteOrderSuccessfully(t, fakeServer)
 
-	res := orders.Delete(context.TODO(), client.ServiceClient(), "46f73695-82bb-447a-bf96-6635f0fb0ce7")
+	res := orders.Delete(context.TODO(), client.ServiceClient(fakeServer), "46f73695-82bb-447a-bf96-6635f0fb0ce7")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/keymanager/v1/secrets/testing/fixtures_test.go b/openstack/keymanager/v1/secrets/testing/fixtures_test.go
index ed0e9ffad..e20732515 100644
--- a/openstack/keymanager/v1/secrets/testing/fixtures_test.go
+++ b/openstack/keymanager/v1/secrets/testing/fixtures_test.go
@@ -190,8 +190,8 @@ var ExpectedMetadatum = secrets.Metadatum{
 
 // HandleListSecretsSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that responds with a list of two secrets.
-func HandleListSecretsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSecretsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -204,8 +204,8 @@ func HandleListSecretsSuccessfully(t *testing.T) {
 
 // HandleGetSecretSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that responds with a single secret.
-func HandleGetSecretSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSecretSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -218,8 +218,8 @@ func HandleGetSecretSuccessfully(t *testing.T) {
 
 // HandleGetPayloadSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that responds with a single secret.
-func HandleGetPayloadSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/payload", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetPayloadSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/payload", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -231,8 +231,8 @@ func HandleGetPayloadSuccessfully(t *testing.T) {
 
 // HandleCreateSecretSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret creation.
-func HandleCreateSecretSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSecretSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, CreateRequest)
@@ -244,8 +244,8 @@ func HandleCreateSecretSuccessfully(t *testing.T) {
 
 // HandleDeleteSecretSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret deletion.
-func HandleDeleteSecretSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSecretSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -255,8 +255,8 @@ func HandleDeleteSecretSuccessfully(t *testing.T) {
 
 // HandleUpdateSecretSuccessfully creates an HTTP handler at `/secrets` on the
 // test handler mux that tests secret updates.
-func HandleUpdateSecretSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateSecretSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestBody(t, r, `foobar`)
@@ -269,8 +269,8 @@ func HandleUpdateSecretSuccessfully(t *testing.T) {
 // HandleGetMetadataSuccessfully creates an HTTP handler at
 // `/secrets/uuid/metadata` on the test handler mux that responds with
 // retrieved metadata.
-func HandleGetMetadataSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetMetadataSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -284,8 +284,8 @@ func HandleGetMetadataSuccessfully(t *testing.T) {
 // HandleCreateMetadataSuccessfully creates an HTTP handler at
 // `/secrets/uuid/metadata` on the test handler mux that responds with
 // a metadata reference URL.
-func HandleCreateMetadataSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateMetadataSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -300,8 +300,8 @@ func HandleCreateMetadataSuccessfully(t *testing.T) {
 // HandleGetMetadatumSuccessfully creates an HTTP handler at
 // `/secrets/uuid/metadata/foo` on the test handler mux that responds with a
 // single metadatum.
-func HandleGetMetadatumSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetMetadatumSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -315,8 +315,8 @@ func HandleGetMetadatumSuccessfully(t *testing.T) {
 // HandleCreateMetadatumSuccessfully creates an HTTP handler at
 // `/secrets/uuid/metadata` on the test handler mux that responds with
 // a single created metadata.
-func HandleCreateMetadatumSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateMetadatumSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -331,8 +331,8 @@ func HandleCreateMetadatumSuccessfully(t *testing.T) {
 // HandleUpdateMetadatumSuccessfully creates an HTTP handler at
 // `/secrets/uuid/metadata/foo` on the test handler mux that responds with a
 // single updated metadatum.
-func HandleUpdateMetadatumSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateMetadatumSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
@@ -347,8 +347,8 @@ func HandleUpdateMetadatumSuccessfully(t *testing.T) {
 // HandleDeleteMetadatumSuccessfully creates an HTTP handler at
 // `/secrets/uuid/metadata/key` on the test handler mux that tests metadata
 // deletion.
-func HandleDeleteMetadatumSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteMetadatumSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/secrets/1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c/metadata/foo", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/keymanager/v1/secrets/testing/requests_test.go b/openstack/keymanager/v1/secrets/testing/requests_test.go
index 0458354bc..92475da63 100644
--- a/openstack/keymanager/v1/secrets/testing/requests_test.go
+++ b/openstack/keymanager/v1/secrets/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestListSecrets(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSecretsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSecretsSuccessfully(t, fakeServer)
 
 	count := 0
-	err := secrets.List(client.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := secrets.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := secrets.ExtractSecrets(page)
@@ -32,11 +32,11 @@ func TestListSecrets(t *testing.T) {
 }
 
 func TestListSecretsAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSecretsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSecretsSuccessfully(t, fakeServer)
 
-	allPages, err := secrets.List(client.ServiceClient(), nil).AllPages(context.TODO())
+	allPages, err := secrets.List(client.ServiceClient(fakeServer), nil).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := secrets.ExtractSecrets(allPages)
 	th.AssertNoErr(t, err)
@@ -44,19 +44,19 @@ func TestListSecretsAllPages(t *testing.T) {
 }
 
 func TestGetSecret(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSecretSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSecretSuccessfully(t, fakeServer)
 
-	actual, err := secrets.Get(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c").Extract()
+	actual, err := secrets.Get(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, FirstSecret, *actual)
 }
 
 func TestCreateSecret(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSecretSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSecretSuccessfully(t, fakeServer)
 
 	expiration := time.Date(2028, 6, 21, 2, 49, 48, 0, time.UTC)
 	createOpts := secrets.CreateOpts{
@@ -70,39 +70,39 @@ func TestCreateSecret(t *testing.T) {
 		Expiration:         &expiration,
 	}
 
-	actual, err := secrets.Create(context.TODO(), client.ServiceClient(), createOpts).Extract()
+	actual, err := secrets.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedCreateResult, *actual)
 }
 
 func TestDeleteSecret(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSecretSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSecretSuccessfully(t, fakeServer)
 
-	res := secrets.Delete(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c")
+	res := secrets.Delete(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateSecret(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSecretSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSecretSuccessfully(t, fakeServer)
 
 	updateOpts := secrets.UpdateOpts{
 		Payload: "foobar",
 	}
 
-	err := secrets.Update(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", updateOpts).ExtractErr()
+	err := secrets.Update(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", updateOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetPayloadSecret(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetPayloadSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetPayloadSuccessfully(t, fakeServer)
 
-	res := secrets.GetPayload(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", nil)
+	res := secrets.GetPayload(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", nil)
 	th.AssertNoErr(t, res.Err)
 	payload, err := res.Extract()
 	th.AssertNoErr(t, err)
@@ -110,74 +110,74 @@ func TestGetPayloadSecret(t *testing.T) {
 }
 
 func TestGetMetadataSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetMetadataSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetMetadataSuccessfully(t, fakeServer)
 
-	actual, err := secrets.GetMetadata(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c").Extract()
+	actual, err := secrets.GetMetadata(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedMetadata, actual)
 }
 
 func TestCreateMetadataSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateMetadataSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateMetadataSuccessfully(t, fakeServer)
 
 	createOpts := secrets.MetadataOpts{
 		"foo":       "bar",
 		"something": "something else",
 	}
 
-	actual, err := secrets.CreateMetadata(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", createOpts).Extract()
+	actual, err := secrets.CreateMetadata(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedCreateMetadataResult, actual)
 }
 
 func TestGetMetadatumSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetMetadatumSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetMetadatumSuccessfully(t, fakeServer)
 
-	actual, err := secrets.GetMetadatum(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", "foo").Extract()
+	actual, err := secrets.GetMetadatum(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", "foo").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedMetadatum, *actual)
 }
 
 func TestCreateMetadatumSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateMetadatumSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateMetadatumSuccessfully(t, fakeServer)
 
 	createOpts := secrets.MetadatumOpts{
 		Key:   "foo",
 		Value: "bar",
 	}
 
-	err := secrets.CreateMetadatum(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", createOpts).ExtractErr()
+	err := secrets.CreateMetadatum(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", createOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdateMetadatumSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateMetadatumSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateMetadatumSuccessfully(t, fakeServer)
 
 	updateOpts := secrets.MetadatumOpts{
 		Key:   "foo",
 		Value: "bar",
 	}
 
-	actual, err := secrets.UpdateMetadatum(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", updateOpts).Extract()
+	actual, err := secrets.UpdateMetadatum(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedMetadatum, *actual)
 }
 
 func TestDeleteMetadatumSuccessfully(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteMetadatumSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteMetadatumSuccessfully(t, fakeServer)
 
-	err := secrets.DeleteMetadatum(context.TODO(), client.ServiceClient(), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", "foo").ExtractErr()
+	err := secrets.DeleteMetadatum(context.TODO(), client.ServiceClient(fakeServer), "1b8068c4-3bb6-4be6-8f1e-da0d1ea0b67c", "foo").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/loadbalancer/v2/amphorae/testing/fixtures_test.go b/openstack/loadbalancer/v2/amphorae/testing/fixtures_test.go
index 049f0697b..7c18ccea4 100644
--- a/openstack/loadbalancer/v2/amphorae/testing/fixtures_test.go
+++ b/openstack/loadbalancer/v2/amphorae/testing/fixtures_test.go
@@ -138,8 +138,8 @@ var SecondAmphora = amphorae.Amphora{
 var ExpectedAmphoraeSlice = []amphorae.Amphora{FirstAmphora, SecondAmphora}
 
 // HandleAmphoraListSuccessfully sets up the test server to respond to a amphorae List request.
-func HandleAmphoraListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/octavia/amphorae", func(w http.ResponseWriter, r *http.Request) {
+func HandleAmphoraListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/octavia/amphorae", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -160,8 +160,8 @@ func HandleAmphoraListSuccessfully(t *testing.T) {
 }
 
 // HandleAmphoraGetSuccessfully sets up the test server to respond to am amphora Get request.
-func HandleAmphoraGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/octavia/amphorae/45f40289-0551-483a-b089-47214bc2a8a4", func(w http.ResponseWriter, r *http.Request) {
+func HandleAmphoraGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/octavia/amphorae/45f40289-0551-483a-b089-47214bc2a8a4", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -171,8 +171,8 @@ func HandleAmphoraGetSuccessfully(t *testing.T) {
 }
 
 // HandleAmphoraFailoverSuccessfully sets up the test server to respond to an amphora failover request.
-func HandleAmphoraFailoverSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/octavia/amphorae/36e08a3e-a78f-4b40-a229-1e7e23eee1ab/failover", func(w http.ResponseWriter, r *http.Request) {
+func HandleAmphoraFailoverSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/octavia/amphorae/36e08a3e-a78f-4b40-a229-1e7e23eee1ab/failover", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/loadbalancer/v2/amphorae/testing/requests_test.go b/openstack/loadbalancer/v2/amphorae/testing/requests_test.go
index bc5feed40..bd65f0d2f 100644
--- a/openstack/loadbalancer/v2/amphorae/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/amphorae/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListAmphorae(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAmphoraListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAmphoraListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := amphorae.List(fake.ServiceClient(), amphorae.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := amphorae.List(fake.ServiceClient(fakeServer), amphorae.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := amphorae.ExtractAmphorae(page)
@@ -39,11 +39,11 @@ func TestListAmphorae(t *testing.T) {
 }
 
 func TestListAllAmphorae(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAmphoraListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAmphoraListSuccessfully(t, fakeServer)
 
-	allPages, err := amphorae.List(fake.ServiceClient(), amphorae.ListOpts{}).AllPages(context.TODO())
+	allPages, err := amphorae.List(fake.ServiceClient(fakeServer), amphorae.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := amphorae.ExtractAmphorae(allPages)
 	th.AssertNoErr(t, err)
@@ -52,11 +52,11 @@ func TestListAllAmphorae(t *testing.T) {
 }
 
 func TestGetAmphora(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAmphoraGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAmphoraGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := amphorae.Get(context.TODO(), client, "45f40289-0551-483a-b089-47214bc2a8a4").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -66,10 +66,10 @@ func TestGetAmphora(t *testing.T) {
 }
 
 func TestFailoverAmphora(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAmphoraFailoverSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAmphoraFailoverSuccessfully(t, fakeServer)
 
-	res := amphorae.Failover(context.TODO(), fake.ServiceClient(), "36e08a3e-a78f-4b40-a229-1e7e23eee1ab")
+	res := amphorae.Failover(context.TODO(), fake.ServiceClient(fakeServer), "36e08a3e-a78f-4b40-a229-1e7e23eee1ab")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/loadbalancer/v2/apiversions/testing/fixture.go b/openstack/loadbalancer/v2/apiversions/testing/fixture.go
index b427378d9..61db7b7d0 100644
--- a/openstack/loadbalancer/v2/apiversions/testing/fixture.go
+++ b/openstack/loadbalancer/v2/apiversions/testing/fixture.go
@@ -80,8 +80,8 @@ var OctaviaAllAPIVersionResults = []apiversions.APIVersion{
 	},
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/loadbalancer/v2/apiversions/testing/requests_test.go b/openstack/loadbalancer/v2/apiversions/testing/requests_test.go
index c0e3aa181..4a8da72dc 100644
--- a/openstack/loadbalancer/v2/apiversions/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/apiversions/testing/requests_test.go
@@ -10,12 +10,12 @@ import (
 )
 
 func TestListVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allVersions, err := apiversions.List(client.ServiceClient()).AllPages(context.TODO())
+	allVersions, err := apiversions.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := apiversions.ExtractAPIVersions(allVersions)
diff --git a/openstack/loadbalancer/v2/flavorprofiles/testing/fixtures.go b/openstack/loadbalancer/v2/flavorprofiles/testing/fixtures.go
index 3558a2191..2ef66175b 100644
--- a/openstack/loadbalancer/v2/flavorprofiles/testing/fixtures.go
+++ b/openstack/loadbalancer/v2/flavorprofiles/testing/fixtures.go
@@ -82,8 +82,8 @@ var (
 	}
 )
 
-func HandleFlavorProfileListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorProfileListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -103,8 +103,8 @@ func HandleFlavorProfileListSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleFlavorProfileCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorProfileCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -121,8 +121,8 @@ func HandleFlavorProfileCreationSuccessfully(t *testing.T, response string) {
 	})
 }
 
-func HandleFlavorProfileGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles/dcd65be5-f117-4260-ab3d-b32cc5bd1272", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorProfileGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles/dcd65be5-f117-4260-ab3d-b32cc5bd1272", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -131,8 +131,8 @@ func HandleFlavorProfileGetSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleFlavorProfileDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles/dcd65be5-f117-4260-ab3d-b32cc5bd1272", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorProfileDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles/dcd65be5-f117-4260-ab3d-b32cc5bd1272", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -140,8 +140,8 @@ func HandleFlavorProfileDeletionSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleFlavorProfileUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles/dcd65be5-f117-4260-ab3d-b32cc5bd1272", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorProfileUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavorprofiles/dcd65be5-f117-4260-ab3d-b32cc5bd1272", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/loadbalancer/v2/flavorprofiles/testing/requests_test.go b/openstack/loadbalancer/v2/flavorprofiles/testing/requests_test.go
index 5cefc8c97..1f838adb6 100644
--- a/openstack/loadbalancer/v2/flavorprofiles/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/flavorprofiles/testing/requests_test.go
@@ -13,12 +13,12 @@ import (
 )
 
 func TestListFlavorProfiles(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorProfileListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorProfileListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := flavorprofiles.List(fake.ServiceClient(), flavorprofiles.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := flavorprofiles.List(fake.ServiceClient(fakeServer), flavorprofiles.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := flavorprofiles.ExtractFlavorProfiles(page)
@@ -43,11 +43,11 @@ func TestListFlavorProfiles(t *testing.T) {
 }
 
 func TestListAllFlavorProfiles(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorProfileListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorProfileListSuccessfully(t, fakeServer)
 
-	allPages, err := flavorprofiles.List(fake.ServiceClient(), flavorprofiles.ListOpts{}).AllPages(context.TODO())
+	allPages, err := flavorprofiles.List(fake.ServiceClient(fakeServer), flavorprofiles.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := flavorprofiles.ExtractFlavorProfiles(allPages)
 	th.AssertNoErr(t, err)
@@ -56,11 +56,11 @@ func TestListAllFlavorProfiles(t *testing.T) {
 }
 
 func TestCreateFlavorProfile(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorProfileCreationSuccessfully(t, SingleFlavorProfileBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorProfileCreationSuccessfully(t, fakeServer, SingleFlavorProfileBody)
 
-	actual, err := flavorprofiles.Create(context.TODO(), fake.ServiceClient(), flavorprofiles.CreateOpts{
+	actual, err := flavorprofiles.Create(context.TODO(), fake.ServiceClient(fakeServer), flavorprofiles.CreateOpts{
 		Name:         "amphora-test",
 		ProviderName: "amphora",
 		FlavorData:   "{\"loadbalancer_topology\": \"ACTIVE_STANDBY\"}",
@@ -71,18 +71,21 @@ func TestCreateFlavorProfile(t *testing.T) {
 }
 
 func TestRequiredCreateOpts(t *testing.T) {
-	res := flavorprofiles.Create(context.TODO(), fake.ServiceClient(), flavorprofiles.CreateOpts{})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := flavorprofiles.Create(context.TODO(), fake.ServiceClient(fakeServer), flavorprofiles.CreateOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestGetFlavorProfiles(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorProfileGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorProfileGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := flavorprofiles.Get(context.TODO(), client, "dcd65be5-f117-4260-ab3d-b32cc5bd1272").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -92,20 +95,20 @@ func TestGetFlavorProfiles(t *testing.T) {
 }
 
 func TestDeleteFlavorProfile(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorProfileDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorProfileDeletionSuccessfully(t, fakeServer)
 
-	res := flavorprofiles.Delete(context.TODO(), fake.ServiceClient(), "dcd65be5-f117-4260-ab3d-b32cc5bd1272")
+	res := flavorprofiles.Delete(context.TODO(), fake.ServiceClient(fakeServer), "dcd65be5-f117-4260-ab3d-b32cc5bd1272")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateFlavorProfile(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorProfileUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorProfileUpdateSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := flavorprofiles.Update(context.TODO(), client, "dcd65be5-f117-4260-ab3d-b32cc5bd1272", flavorprofiles.UpdateOpts{
 		Name:         ptr.To("amphora-test-updated"),
 		ProviderName: ptr.To("amphora"),
diff --git a/openstack/loadbalancer/v2/flavors/testing/fixtures.go b/openstack/loadbalancer/v2/flavors/testing/fixtures.go
index b33166dfa..355ac7fcf 100644
--- a/openstack/loadbalancer/v2/flavors/testing/fixtures.go
+++ b/openstack/loadbalancer/v2/flavors/testing/fixtures.go
@@ -110,8 +110,8 @@ var (
 	}
 )
 
-func HandleFlavorListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavors", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavors", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -131,8 +131,8 @@ func HandleFlavorListSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleFlavorCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavors", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavors", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -150,8 +150,8 @@ func HandleFlavorCreationSuccessfully(t *testing.T, response string) {
 	})
 }
 
-func HandleFlavorCreationSuccessfullyDisabled(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavors", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorCreationSuccessfullyDisabled(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavors", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -169,8 +169,8 @@ func HandleFlavorCreationSuccessfullyDisabled(t *testing.T, response string) {
 	})
 }
 
-func HandleFlavorGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavors/5548c807-e6e8-43d7-9ea4-b38d34dd74a0", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavors/5548c807-e6e8-43d7-9ea4-b38d34dd74a0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -179,8 +179,8 @@ func HandleFlavorGetSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleFlavorDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavors/5548c807-e6e8-43d7-9ea4-b38d34dd74a0", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavors/5548c807-e6e8-43d7-9ea4-b38d34dd74a0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -188,8 +188,8 @@ func HandleFlavorDeletionSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleFlavorUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/flavors/5548c807-e6e8-43d7-9ea4-b38d34dd74a0", func(w http.ResponseWriter, r *http.Request) {
+func HandleFlavorUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavors/5548c807-e6e8-43d7-9ea4-b38d34dd74a0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/loadbalancer/v2/flavors/testing/requests_test.go b/openstack/loadbalancer/v2/flavors/testing/requests_test.go
index 1321716c9..eb9323584 100644
--- a/openstack/loadbalancer/v2/flavors/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/flavors/testing/requests_test.go
@@ -16,12 +16,12 @@ import (
 )
 
 func TestListFlavors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := flavors.List(fake.ServiceClient(), flavors.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := flavors.List(fake.ServiceClient(fakeServer), flavors.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := flavors.ExtractFlavors(page)
@@ -46,8 +46,8 @@ func TestListFlavors(t *testing.T) {
 }
 
 func TestListFlavorsEnabled(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	func() {
 		testCases := []string{
@@ -57,7 +57,7 @@ func TestListFlavorsEnabled(t *testing.T) {
 		}
 
 		cases := 0
-		th.Mux.HandleFunc("/v2.0/lbaas/flavors", func(w http.ResponseWriter, r *http.Request) {
+		fakeServer.Mux.HandleFunc("/v2.0/lbaas/flavors", func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -82,7 +82,7 @@ func TestListFlavorsEnabled(t *testing.T) {
 		nilBool,
 	}
 	for _, filter := range filters {
-		allPages, err := flavors.List(fake.ServiceClient(), flavors.ListOpts{Enabled: filter}).AllPages(context.TODO())
+		allPages, err := flavors.List(fake.ServiceClient(fakeServer), flavors.ListOpts{Enabled: filter}).AllPages(context.TODO())
 		th.AssertNoErr(t, err)
 		_, err = flavors.ExtractFlavors(allPages)
 		th.AssertNoErr(t, err)
@@ -90,11 +90,11 @@ func TestListFlavorsEnabled(t *testing.T) {
 }
 
 func TestListAllFlavors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorListSuccessfully(t, fakeServer)
 
-	allPages, err := flavors.List(fake.ServiceClient(), flavors.ListOpts{}).AllPages(context.TODO())
+	allPages, err := flavors.List(fake.ServiceClient(fakeServer), flavors.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := flavors.ExtractFlavors(allPages)
 	th.AssertNoErr(t, err)
@@ -103,11 +103,11 @@ func TestListAllFlavors(t *testing.T) {
 }
 
 func TestCreateFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorCreationSuccessfully(t, SingleFlavorBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorCreationSuccessfully(t, fakeServer, SingleFlavorBody)
 
-	actual, err := flavors.Create(context.TODO(), fake.ServiceClient(), flavors.CreateOpts{
+	actual, err := flavors.Create(context.TODO(), fake.ServiceClient(fakeServer), flavors.CreateOpts{
 		Name:            "Basic",
 		Description:     "A basic standalone Octavia load balancer.",
 		Enabled:         ptr.To(true),
@@ -119,11 +119,11 @@ func TestCreateFlavor(t *testing.T) {
 }
 
 func TestCreateFlavorDisabled(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorCreationSuccessfullyDisabled(t, SingleFlavorDisabledBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorCreationSuccessfullyDisabled(t, fakeServer, SingleFlavorDisabledBody)
 
-	actual, err := flavors.Create(context.TODO(), fake.ServiceClient(), flavors.CreateOpts{
+	actual, err := flavors.Create(context.TODO(), fake.ServiceClient(fakeServer), flavors.CreateOpts{
 		Name:            "Basic",
 		Description:     "A basic standalone Octavia load balancer.",
 		Enabled:         ptr.To(false),
@@ -135,18 +135,21 @@ func TestCreateFlavorDisabled(t *testing.T) {
 }
 
 func TestRequiredCreateOpts(t *testing.T) {
-	res := flavors.Create(context.TODO(), fake.ServiceClient(), flavors.CreateOpts{})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := flavors.Create(context.TODO(), fake.ServiceClient(fakeServer), flavors.CreateOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestGetFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := flavors.Get(context.TODO(), client, "5548c807-e6e8-43d7-9ea4-b38d34dd74a0").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -156,20 +159,20 @@ func TestGetFlavor(t *testing.T) {
 }
 
 func TestDeleteFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorDeletionSuccessfully(t, fakeServer)
 
-	res := flavors.Delete(context.TODO(), fake.ServiceClient(), "5548c807-e6e8-43d7-9ea4-b38d34dd74a0")
+	res := flavors.Delete(context.TODO(), fake.ServiceClient(fakeServer), "5548c807-e6e8-43d7-9ea4-b38d34dd74a0")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateFlavor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFlavorUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFlavorUpdateSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := flavors.Update(context.TODO(), client, "5548c807-e6e8-43d7-9ea4-b38d34dd74a0", flavors.UpdateOpts{
 		Name:        ptr.To("Basic v2"),
 		Description: ptr.To("Rename flavor"),
diff --git a/openstack/loadbalancer/v2/l7policies/testing/fixtures_test.go b/openstack/loadbalancer/v2/l7policies/testing/fixtures_test.go
index 56b35cd0e..98efa14b8 100644
--- a/openstack/loadbalancer/v2/l7policies/testing/fixtures_test.go
+++ b/openstack/loadbalancer/v2/l7policies/testing/fixtures_test.go
@@ -116,8 +116,8 @@ var (
 
 // HandleL7PolicyCreationSuccessfully sets up the test server to respond to a l7policy creation request
 // with a given response.
-func HandleL7PolicyCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies", func(w http.ResponseWriter, r *http.Request) {
+func HandleL7PolicyCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -206,8 +206,8 @@ const PostUpdateL7PolicyNullRedirectURLBody = `
 `
 
 // HandleL7PolicyListSuccessfully sets up the test server to respond to a l7policy List request.
-func HandleL7PolicyListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies", func(w http.ResponseWriter, r *http.Request) {
+func HandleL7PolicyListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -228,8 +228,8 @@ func HandleL7PolicyListSuccessfully(t *testing.T) {
 }
 
 // HandleL7PolicyGetSuccessfully sets up the test server to respond to a l7policy Get request.
-func HandleL7PolicyGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd", func(w http.ResponseWriter, r *http.Request) {
+func HandleL7PolicyGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -239,8 +239,8 @@ func HandleL7PolicyGetSuccessfully(t *testing.T) {
 }
 
 // HandleL7PolicyDeletionSuccessfully sets up the test server to respond to a l7policy deletion request.
-func HandleL7PolicyDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd", func(w http.ResponseWriter, r *http.Request) {
+func HandleL7PolicyDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -249,8 +249,8 @@ func HandleL7PolicyDeletionSuccessfully(t *testing.T) {
 }
 
 // HandleL7PolicyUpdateSuccessfully sets up the test server to respond to a l7policy Update request.
-func HandleL7PolicyUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd", func(w http.ResponseWriter, r *http.Request) {
+func HandleL7PolicyUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -268,8 +268,8 @@ func HandleL7PolicyUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleL7PolicyUpdateNullRedirectURLSuccessfully sets up the test server to respond to a l7policy Update request.
-func HandleL7PolicyUpdateNullRedirectURLSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd", func(w http.ResponseWriter, r *http.Request) {
+func HandleL7PolicyUpdateNullRedirectURLSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -303,8 +303,8 @@ const SingleRuleBody = `
 
 // HandleRuleCreationSuccessfully sets up the test server to respond to a rule creation request
 // with a given response.
-func HandleRuleCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules", func(w http.ResponseWriter, r *http.Request) {
+func HandleRuleCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -350,8 +350,8 @@ const RulesListBody = `
 `
 
 // HandleRuleListSuccessfully sets up the test server to respond to a rule List request.
-func HandleRuleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules", func(w http.ResponseWriter, r *http.Request) {
+func HandleRuleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -372,8 +372,8 @@ func HandleRuleListSuccessfully(t *testing.T) {
 }
 
 // HandleRuleGetSuccessfully sets up the test server to respond to a rule Get request.
-func HandleRuleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules/16621dbb-a736-4888-a57a-3ecd53df784c", func(w http.ResponseWriter, r *http.Request) {
+func HandleRuleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules/16621dbb-a736-4888-a57a-3ecd53df784c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -383,8 +383,8 @@ func HandleRuleGetSuccessfully(t *testing.T) {
 }
 
 // HandleRuleDeletionSuccessfully sets up the test server to respond to a rule deletion request.
-func HandleRuleDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules/16621dbb-a736-4888-a57a-3ecd53df784c", func(w http.ResponseWriter, r *http.Request) {
+func HandleRuleDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules/16621dbb-a736-4888-a57a-3ecd53df784c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -409,8 +409,8 @@ const PostUpdateRuleBody = `
 `
 
 // HandleRuleUpdateSuccessfully sets up the test server to respond to a rule Update request.
-func HandleRuleUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules/16621dbb-a736-4888-a57a-3ecd53df784c", func(w http.ResponseWriter, r *http.Request) {
+func HandleRuleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/l7policies/8a1412f0-4c32-4257-8b07-af4770b604fd/rules/16621dbb-a736-4888-a57a-3ecd53df784c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/loadbalancer/v2/l7policies/testing/requests_test.go b/openstack/loadbalancer/v2/l7policies/testing/requests_test.go
index 328215982..324515152 100644
--- a/openstack/loadbalancer/v2/l7policies/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/l7policies/testing/requests_test.go
@@ -11,11 +11,11 @@ import (
 )
 
 func TestCreateL7Policy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleL7PolicyCreationSuccessfully(t, SingleL7PolicyBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleL7PolicyCreationSuccessfully(t, fakeServer, SingleL7PolicyBody)
 
-	actual, err := l7policies.Create(context.TODO(), fake.ServiceClient(), l7policies.CreateOpts{
+	actual, err := l7policies.Create(context.TODO(), fake.ServiceClient(fakeServer), l7policies.CreateOpts{
 		Name:        "redirect-example.com",
 		ListenerID:  "023f2e34-7806-443b-bfae-16c324569a3d",
 		Action:      l7policies.ActionRedirectToURL,
@@ -27,14 +27,17 @@ func TestCreateL7Policy(t *testing.T) {
 }
 
 func TestRequiredL7PolicyCreateOpts(t *testing.T) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
 	// no param specified.
-	res := l7policies.Create(context.TODO(), fake.ServiceClient(), l7policies.CreateOpts{})
+	res := l7policies.Create(context.TODO(), fake.ServiceClient(fakeServer), l7policies.CreateOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 
 	// Action is invalid.
-	res = l7policies.Create(context.TODO(), fake.ServiceClient(), l7policies.CreateOpts{
+	res = l7policies.Create(context.TODO(), fake.ServiceClient(fakeServer), l7policies.CreateOpts{
 		ListenerID: "023f2e34-7806-443b-bfae-16c324569a3d",
 		Action:     l7policies.Action("invalid"),
 	})
@@ -44,12 +47,12 @@ func TestRequiredL7PolicyCreateOpts(t *testing.T) {
 }
 
 func TestListL7Policies(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleL7PolicyListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleL7PolicyListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := l7policies.List(fake.ServiceClient(), l7policies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := l7policies.List(fake.ServiceClient(fakeServer), l7policies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := l7policies.ExtractL7Policies(page)
@@ -74,11 +77,11 @@ func TestListL7Policies(t *testing.T) {
 }
 
 func TestListAllL7Policies(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleL7PolicyListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleL7PolicyListSuccessfully(t, fakeServer)
 
-	allPages, err := l7policies.List(fake.ServiceClient(), l7policies.ListOpts{}).AllPages(context.TODO())
+	allPages, err := l7policies.List(fake.ServiceClient(fakeServer), l7policies.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := l7policies.ExtractL7Policies(allPages)
 	th.AssertNoErr(t, err)
@@ -87,11 +90,11 @@ func TestListAllL7Policies(t *testing.T) {
 }
 
 func TestGetL7Policy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleL7PolicyGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleL7PolicyGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := l7policies.Get(context.TODO(), client, "8a1412f0-4c32-4257-8b07-af4770b604fd").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -101,20 +104,20 @@ func TestGetL7Policy(t *testing.T) {
 }
 
 func TestDeleteL7Policy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleL7PolicyDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleL7PolicyDeletionSuccessfully(t, fakeServer)
 
-	res := l7policies.Delete(context.TODO(), fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd")
+	res := l7policies.Delete(context.TODO(), fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateL7Policy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleL7PolicyUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleL7PolicyUpdateSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	newName := "NewL7PolicyName"
 	redirectURL := "http://www.new-example.com"
 	actual, err := l7policies.Update(context.TODO(), client, "8a1412f0-4c32-4257-8b07-af4770b604fd",
@@ -131,11 +134,11 @@ func TestUpdateL7Policy(t *testing.T) {
 }
 
 func TestUpdateL7PolicyNullRedirectURL(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleL7PolicyUpdateNullRedirectURLSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleL7PolicyUpdateNullRedirectURLSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	newName := "NewL7PolicyName"
 	redirectURL := ""
 	actual, err := l7policies.Update(context.TODO(), client, "8a1412f0-4c32-4257-8b07-af4770b604fd",
@@ -151,10 +154,10 @@ func TestUpdateL7PolicyNullRedirectURL(t *testing.T) {
 }
 
 func TestUpdateL7PolicyWithInvalidOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	res := l7policies.Update(context.TODO(), fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.UpdateOpts{
+	res := l7policies.Update(context.TODO(), fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.UpdateOpts{
 		Action: l7policies.Action("invalid"),
 	})
 	if res.Err == nil {
@@ -163,11 +166,11 @@ func TestUpdateL7PolicyWithInvalidOpts(t *testing.T) {
 }
 
 func TestCreateRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRuleCreationSuccessfully(t, SingleRuleBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRuleCreationSuccessfully(t, fakeServer, SingleRuleBody)
 
-	actual, err := l7policies.CreateRule(context.TODO(), fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.CreateRuleOpts{
+	actual, err := l7policies.CreateRule(context.TODO(), fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.CreateRuleOpts{
 		RuleType:    l7policies.TypePath,
 		CompareType: l7policies.CompareTypeRegex,
 		Value:       "/images*",
@@ -178,20 +181,20 @@ func TestCreateRule(t *testing.T) {
 }
 
 func TestRequiredRuleCreateOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	res := l7policies.CreateRule(context.TODO(), fake.ServiceClient(), "", l7policies.CreateRuleOpts{})
+	res := l7policies.CreateRule(context.TODO(), fake.ServiceClient(fakeServer), "", l7policies.CreateRuleOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = l7policies.CreateRule(context.TODO(), fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.CreateRuleOpts{
+	res = l7policies.CreateRule(context.TODO(), fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.CreateRuleOpts{
 		RuleType: l7policies.TypePath,
 	})
 	if res.Err == nil {
 		t.Fatalf("Expected error, but got none")
 	}
-	res = l7policies.CreateRule(context.TODO(), fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.CreateRuleOpts{
+	res = l7policies.CreateRule(context.TODO(), fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.CreateRuleOpts{
 		RuleType:    l7policies.RuleType("invalid"),
 		CompareType: l7policies.CompareTypeRegex,
 		Value:       "/images*",
@@ -199,7 +202,7 @@ func TestRequiredRuleCreateOpts(t *testing.T) {
 	if res.Err == nil {
 		t.Fatalf("Expected error, but got none")
 	}
-	res = l7policies.CreateRule(context.TODO(), fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.CreateRuleOpts{
+	res = l7policies.CreateRule(context.TODO(), fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.CreateRuleOpts{
 		RuleType:    l7policies.TypePath,
 		CompareType: l7policies.CompareType("invalid"),
 		Value:       "/images*",
@@ -210,12 +213,12 @@ func TestRequiredRuleCreateOpts(t *testing.T) {
 }
 
 func TestListRules(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRuleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRuleListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := l7policies.ListRules(fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.ListRulesOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := l7policies.ListRules(fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.ListRulesOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := l7policies.ExtractRules(page)
@@ -240,11 +243,11 @@ func TestListRules(t *testing.T) {
 }
 
 func TestListAllRules(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRuleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRuleListSuccessfully(t, fakeServer)
 
-	allPages, err := l7policies.ListRules(fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.ListRulesOpts{}).AllPages(context.TODO())
+	allPages, err := l7policies.ListRules(fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd", l7policies.ListRulesOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := l7policies.ExtractRules(allPages)
@@ -254,11 +257,11 @@ func TestListAllRules(t *testing.T) {
 }
 
 func TestGetRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRuleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRuleGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := l7policies.GetRule(context.TODO(), client, "8a1412f0-4c32-4257-8b07-af4770b604fd", "16621dbb-a736-4888-a57a-3ecd53df784c").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -268,20 +271,20 @@ func TestGetRule(t *testing.T) {
 }
 
 func TestDeleteRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRuleDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRuleDeletionSuccessfully(t, fakeServer)
 
-	res := l7policies.DeleteRule(context.TODO(), fake.ServiceClient(), "8a1412f0-4c32-4257-8b07-af4770b604fd", "16621dbb-a736-4888-a57a-3ecd53df784c")
+	res := l7policies.DeleteRule(context.TODO(), fake.ServiceClient(fakeServer), "8a1412f0-4c32-4257-8b07-af4770b604fd", "16621dbb-a736-4888-a57a-3ecd53df784c")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleRuleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleRuleUpdateSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	invert := false
 	key := ""
 	actual, err := l7policies.UpdateRule(context.TODO(), client, "8a1412f0-4c32-4257-8b07-af4770b604fd", "16621dbb-a736-4888-a57a-3ecd53df784c", l7policies.UpdateRuleOpts{
@@ -299,17 +302,17 @@ func TestUpdateRule(t *testing.T) {
 }
 
 func TestUpdateRuleWithInvalidOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	res := l7policies.UpdateRule(context.TODO(), fake.ServiceClient(), "", "", l7policies.UpdateRuleOpts{
+	res := l7policies.UpdateRule(context.TODO(), fake.ServiceClient(fakeServer), "", "", l7policies.UpdateRuleOpts{
 		RuleType: l7policies.RuleType("invalid"),
 	})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 
-	res = l7policies.UpdateRule(context.TODO(), fake.ServiceClient(), "", "", l7policies.UpdateRuleOpts{
+	res = l7policies.UpdateRule(context.TODO(), fake.ServiceClient(fakeServer), "", "", l7policies.UpdateRuleOpts{
 		CompareType: l7policies.CompareType("invalid"),
 	})
 	if res.Err == nil {
diff --git a/openstack/loadbalancer/v2/listeners/testing/fixtures_test.go b/openstack/loadbalancer/v2/listeners/testing/fixtures_test.go
index 9f8564941..9cc5d3a0a 100644
--- a/openstack/loadbalancer/v2/listeners/testing/fixtures_test.go
+++ b/openstack/loadbalancer/v2/listeners/testing/fixtures_test.go
@@ -206,8 +206,8 @@ var (
 )
 
 // HandleListenerListSuccessfully sets up the test server to respond to a listener List request.
-func HandleListenerListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/listeners", func(w http.ResponseWriter, r *http.Request) {
+func HandleListenerListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/listeners", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -229,8 +229,8 @@ func HandleListenerListSuccessfully(t *testing.T) {
 
 // HandleListenerCreationSuccessfully sets up the test server to respond to a listener creation request
 // with a given response.
-func HandleListenerCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/listeners", func(w http.ResponseWriter, r *http.Request) {
+func HandleListenerCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/listeners", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -260,8 +260,8 @@ func HandleListenerCreationSuccessfully(t *testing.T, response string) {
 }
 
 // HandleListenerGetSuccessfully sets up the test server to respond to a listener Get request.
-func HandleListenerGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/listeners/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
+func HandleListenerGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/listeners/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -271,8 +271,8 @@ func HandleListenerGetSuccessfully(t *testing.T) {
 }
 
 // HandleListenerDeletionSuccessfully sets up the test server to respond to a listener deletion request.
-func HandleListenerDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/listeners/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
+func HandleListenerDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/listeners/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -281,8 +281,8 @@ func HandleListenerDeletionSuccessfully(t *testing.T) {
 }
 
 // HandleListenerUpdateSuccessfully sets up the test server to respond to a listener Update request.
-func HandleListenerUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/listeners/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
+func HandleListenerUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/listeners/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -309,8 +309,8 @@ func HandleListenerUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleListenerGetStatsTree sets up the test server to respond to a listener Get stats tree request.
-func HandleListenerGetStatsTree(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/listeners/4ec89087-d057-4e2c-911f-60a3b47ee304/stats", func(w http.ResponseWriter, r *http.Request) {
+func HandleListenerGetStatsTree(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/listeners/4ec89087-d057-4e2c-911f-60a3b47ee304/stats", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/loadbalancer/v2/listeners/testing/requests_test.go b/openstack/loadbalancer/v2/listeners/testing/requests_test.go
index 220119a43..346aa8613 100644
--- a/openstack/loadbalancer/v2/listeners/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/listeners/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 )
 
 func TestListListeners(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListenerListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListenerListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := listeners.List(fake.ServiceClient(), listeners.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := listeners.List(fake.ServiceClient(fakeServer), listeners.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := listeners.ExtractListeners(page)
@@ -42,11 +42,11 @@ func TestListListeners(t *testing.T) {
 }
 
 func TestListAllListeners(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListenerListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListenerListSuccessfully(t, fakeServer)
 
-	allPages, err := listeners.List(fake.ServiceClient(), listeners.ListOpts{}).AllPages(context.TODO())
+	allPages, err := listeners.List(fake.ServiceClient(fakeServer), listeners.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := listeners.ExtractListeners(allPages)
 	th.AssertNoErr(t, err)
@@ -55,11 +55,11 @@ func TestListAllListeners(t *testing.T) {
 }
 
 func TestCreateListener(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListenerCreationSuccessfully(t, SingleListenerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListenerCreationSuccessfully(t, fakeServer, SingleListenerBody)
 
-	actual, err := listeners.Create(context.TODO(), fake.ServiceClient(), listeners.CreateOpts{
+	actual, err := listeners.Create(context.TODO(), fake.ServiceClient(fakeServer), listeners.CreateOpts{
 		Protocol:               "TCP",
 		Name:                   "db",
 		LoadbalancerID:         "79e05663-7f03-45d2-a092-8b94062f22ab",
@@ -77,34 +77,37 @@ func TestCreateListener(t *testing.T) {
 }
 
 func TestRequiredCreateOpts(t *testing.T) {
-	res := listeners.Create(context.TODO(), fake.ServiceClient(), listeners.CreateOpts{})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := listeners.Create(context.TODO(), fake.ServiceClient(fakeServer), listeners.CreateOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = listeners.Create(context.TODO(), fake.ServiceClient(), listeners.CreateOpts{Name: "foo"})
+	res = listeners.Create(context.TODO(), fake.ServiceClient(fakeServer), listeners.CreateOpts{Name: "foo"})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = listeners.Create(context.TODO(), fake.ServiceClient(), listeners.CreateOpts{Name: "foo", ProjectID: "bar"})
+	res = listeners.Create(context.TODO(), fake.ServiceClient(fakeServer), listeners.CreateOpts{Name: "foo", ProjectID: "bar"})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = listeners.Create(context.TODO(), fake.ServiceClient(), listeners.CreateOpts{Name: "foo", ProjectID: "bar", Protocol: "bar"})
+	res = listeners.Create(context.TODO(), fake.ServiceClient(fakeServer), listeners.CreateOpts{Name: "foo", ProjectID: "bar", Protocol: "bar"})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = listeners.Create(context.TODO(), fake.ServiceClient(), listeners.CreateOpts{Name: "foo", ProjectID: "bar", Protocol: "bar", ProtocolPort: 80})
+	res = listeners.Create(context.TODO(), fake.ServiceClient(fakeServer), listeners.CreateOpts{Name: "foo", ProjectID: "bar", Protocol: "bar", ProtocolPort: 80})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestGetListener(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListenerGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListenerGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := listeners.Get(context.TODO(), client, "4ec89087-d057-4e2c-911f-60a3b47ee304").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -114,20 +117,20 @@ func TestGetListener(t *testing.T) {
 }
 
 func TestDeleteListener(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListenerDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListenerDeletionSuccessfully(t, fakeServer)
 
-	res := listeners.Delete(context.TODO(), fake.ServiceClient(), "4ec89087-d057-4e2c-911f-60a3b47ee304")
+	res := listeners.Delete(context.TODO(), fake.ServiceClient(fakeServer), "4ec89087-d057-4e2c-911f-60a3b47ee304")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateListener(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListenerUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListenerUpdateSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	i1001 := 1001
 	i181000 := 181000
 	name := "NewListenerName"
@@ -156,11 +159,11 @@ func TestUpdateListener(t *testing.T) {
 }
 
 func TestGetListenerStatsTree(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListenerGetStatsTree(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListenerGetStatsTree(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := listeners.GetStats(context.TODO(), client, "4ec89087-d057-4e2c-911f-60a3b47ee304").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
diff --git a/openstack/loadbalancer/v2/loadbalancers/testing/fixtures_test.go b/openstack/loadbalancer/v2/loadbalancers/testing/fixtures_test.go
index 76ef3ec2a..a9e7f0a62 100644
--- a/openstack/loadbalancer/v2/loadbalancers/testing/fixtures_test.go
+++ b/openstack/loadbalancer/v2/loadbalancers/testing/fixtures_test.go
@@ -441,8 +441,8 @@ var (
 )
 
 // HandleLoadbalancerListSuccessfully sets up the test server to respond to a loadbalancer List request.
-func HandleLoadbalancerListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers", func(w http.ResponseWriter, r *http.Request) {
+func HandleLoadbalancerListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -464,8 +464,8 @@ func HandleLoadbalancerListSuccessfully(t *testing.T) {
 
 // HandleFullyPopulatedLoadbalancerCreationSuccessfully sets up the test server to respond to a
 // fully populated loadbalancer creation request with a given response.
-func HandleFullyPopulatedLoadbalancerCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers", func(w http.ResponseWriter, r *http.Request) {
+func HandleFullyPopulatedLoadbalancerCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -539,8 +539,8 @@ func HandleFullyPopulatedLoadbalancerCreationSuccessfully(t *testing.T, response
 
 // HandleLoadbalancerCreationSuccessfully sets up the test server to respond to a loadbalancer creation request
 // with a given response.
-func HandleLoadbalancerCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers", func(w http.ResponseWriter, r *http.Request) {
+func HandleLoadbalancerCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -564,8 +564,8 @@ func HandleLoadbalancerCreationSuccessfully(t *testing.T, response string) {
 }
 
 // HandleLoadbalancerGetSuccessfully sets up the test server to respond to a loadbalancer Get request.
-func HandleLoadbalancerGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab", func(w http.ResponseWriter, r *http.Request) {
+func HandleLoadbalancerGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -575,8 +575,8 @@ func HandleLoadbalancerGetSuccessfully(t *testing.T) {
 }
 
 // HandleLoadbalancerGetStatusesTree sets up the test server to respond to a loadbalancer Get statuses tree request.
-func HandleLoadbalancerGetStatusesTree(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab/status", func(w http.ResponseWriter, r *http.Request) {
+func HandleLoadbalancerGetStatusesTree(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab/status", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -586,8 +586,8 @@ func HandleLoadbalancerGetStatusesTree(t *testing.T) {
 }
 
 // HandleLoadbalancerDeletionSuccessfully sets up the test server to respond to a loadbalancer deletion request.
-func HandleLoadbalancerDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab", func(w http.ResponseWriter, r *http.Request) {
+func HandleLoadbalancerDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -596,8 +596,8 @@ func HandleLoadbalancerDeletionSuccessfully(t *testing.T) {
 }
 
 // HandleLoadbalancerUpdateSuccessfully sets up the test server to respond to a loadbalancer Update request.
-func HandleLoadbalancerUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab", func(w http.ResponseWriter, r *http.Request) {
+func HandleLoadbalancerUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -614,8 +614,8 @@ func HandleLoadbalancerUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleLoadbalancerGetStatsTree sets up the test server to respond to a loadbalancer Get stats tree request.
-func HandleLoadbalancerGetStatsTree(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab/stats", func(w http.ResponseWriter, r *http.Request) {
+func HandleLoadbalancerGetStatsTree(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab/stats", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -625,8 +625,8 @@ func HandleLoadbalancerGetStatsTree(t *testing.T) {
 }
 
 // HandleLoadbalancerFailoverSuccessfully sets up the test server to respond to a loadbalancer failover request.
-func HandleLoadbalancerFailoverSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab/failover", func(w http.ResponseWriter, r *http.Request) {
+func HandleLoadbalancerFailoverSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/loadbalancers/36e08a3e-a78f-4b40-a229-1e7e23eee1ab/failover", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/loadbalancer/v2/loadbalancers/testing/requests_test.go b/openstack/loadbalancer/v2/loadbalancers/testing/requests_test.go
index 04fe8549d..64a3ddc83 100644
--- a/openstack/loadbalancer/v2/loadbalancers/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/loadbalancers/testing/requests_test.go
@@ -17,12 +17,12 @@ import (
 )
 
 func TestListLoadbalancers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := loadbalancers.List(fake.ServiceClient(), loadbalancers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := loadbalancers.List(fake.ServiceClient(fakeServer), loadbalancers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := loadbalancers.ExtractLoadBalancers(page)
@@ -47,11 +47,11 @@ func TestListLoadbalancers(t *testing.T) {
 }
 
 func TestListAllLoadbalancers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerListSuccessfully(t, fakeServer)
 
-	allPages, err := loadbalancers.List(fake.ServiceClient(), loadbalancers.ListOpts{}).AllPages(context.TODO())
+	allPages, err := loadbalancers.List(fake.ServiceClient(fakeServer), loadbalancers.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := loadbalancers.ExtractLoadBalancers(allPages)
 	th.AssertNoErr(t, err)
@@ -60,11 +60,11 @@ func TestListAllLoadbalancers(t *testing.T) {
 }
 
 func TestCreateLoadbalancer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerCreationSuccessfully(t, SingleLoadbalancerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerCreationSuccessfully(t, fakeServer, SingleLoadbalancerBody)
 
-	actual, err := loadbalancers.Create(context.TODO(), fake.ServiceClient(), loadbalancers.CreateOpts{
+	actual, err := loadbalancers.Create(context.TODO(), fake.ServiceClient(fakeServer), loadbalancers.CreateOpts{
 		Name:         "db_lb",
 		AdminStateUp: gophercloud.Enabled,
 		VipPortID:    "2bf413c8-41a9-4477-b505-333d5cbe8b55",
@@ -86,11 +86,11 @@ func TestCreateLoadbalancer(t *testing.T) {
 }
 
 func TestCreateFullyPopulatedLoadbalancer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFullyPopulatedLoadbalancerCreationSuccessfully(t, PostFullyPopulatedLoadbalancerBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFullyPopulatedLoadbalancerCreationSuccessfully(t, fakeServer, PostFullyPopulatedLoadbalancerBody)
 
-	actual, err := loadbalancers.Create(context.TODO(), fake.ServiceClient(), loadbalancers.CreateOpts{
+	actual, err := loadbalancers.Create(context.TODO(), fake.ServiceClient(fakeServer), loadbalancers.CreateOpts{
 		Name:         "db_lb",
 		AdminStateUp: gophercloud.Enabled,
 		VipPortID:    "2bf413c8-41a9-4477-b505-333d5cbe8b55",
@@ -144,11 +144,11 @@ func TestCreateFullyPopulatedLoadbalancer(t *testing.T) {
 }
 
 func TestGetLoadbalancer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := loadbalancers.Get(context.TODO(), client, "36e08a3e-a78f-4b40-a229-1e7e23eee1ab").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -158,11 +158,11 @@ func TestGetLoadbalancer(t *testing.T) {
 }
 
 func TestGetLoadbalancerStatusesTree(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerGetStatusesTree(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerGetStatusesTree(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := loadbalancers.GetStatuses(context.TODO(), client, "36e08a3e-a78f-4b40-a229-1e7e23eee1ab").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -172,20 +172,20 @@ func TestGetLoadbalancerStatusesTree(t *testing.T) {
 }
 
 func TestDeleteLoadbalancer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerDeletionSuccessfully(t, fakeServer)
 
-	res := loadbalancers.Delete(context.TODO(), fake.ServiceClient(), "36e08a3e-a78f-4b40-a229-1e7e23eee1ab", nil)
+	res := loadbalancers.Delete(context.TODO(), fake.ServiceClient(fakeServer), "36e08a3e-a78f-4b40-a229-1e7e23eee1ab", nil)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateLoadbalancer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerUpdateSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	name := "NewLoadbalancerName"
 	tags := []string{"test"}
 	actual, err := loadbalancers.Update(context.TODO(), client, "36e08a3e-a78f-4b40-a229-1e7e23eee1ab", loadbalancers.UpdateOpts{
@@ -200,11 +200,11 @@ func TestUpdateLoadbalancer(t *testing.T) {
 }
 
 func TestCascadingDeleteLoadbalancer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerDeletionSuccessfully(t, fakeServer)
 
-	sc := fake.ServiceClient()
+	sc := fake.ServiceClient(fakeServer)
 	deleteOpts := loadbalancers.DeleteOpts{
 		Cascade: true,
 	}
@@ -218,11 +218,11 @@ func TestCascadingDeleteLoadbalancer(t *testing.T) {
 }
 
 func TestGetLoadbalancerStatsTree(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerGetStatsTree(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerGetStatsTree(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := loadbalancers.GetStats(context.TODO(), client, "36e08a3e-a78f-4b40-a229-1e7e23eee1ab").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -232,10 +232,10 @@ func TestGetLoadbalancerStatsTree(t *testing.T) {
 }
 
 func TestFailoverLoadbalancer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleLoadbalancerFailoverSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleLoadbalancerFailoverSuccessfully(t, fakeServer)
 
-	res := loadbalancers.Failover(context.TODO(), fake.ServiceClient(), "36e08a3e-a78f-4b40-a229-1e7e23eee1ab")
+	res := loadbalancers.Failover(context.TODO(), fake.ServiceClient(fakeServer), "36e08a3e-a78f-4b40-a229-1e7e23eee1ab")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/loadbalancer/v2/monitors/testing/fixtures_test.go b/openstack/loadbalancer/v2/monitors/testing/fixtures_test.go
index 6b12d2c11..039da6708 100644
--- a/openstack/loadbalancer/v2/monitors/testing/fixtures_test.go
+++ b/openstack/loadbalancer/v2/monitors/testing/fixtures_test.go
@@ -31,11 +31,13 @@ const HealthmonitorsListBody = `
 			"admin_state_up":true,
 			"project_id":"83657cfcdfe44cd5920adaf26c48ceea",
 			"delay":5,
+			"domain_name": "www.example.com",
 			"name":"db",
 			"expected_codes":"200",
 			"max_retries":2,
 			"max_retries_down":4,
 			"http_method":"GET",
+			"http_version": 1.1,
 			"timeout":2,
 			"url_path":"/",
 			"type":"HTTP",
@@ -54,11 +56,13 @@ const SingleHealthmonitorBody = `
 		"admin_state_up":true,
 		"project_id":"83657cfcdfe44cd5920adaf26c48ceea",
 		"delay":5,
+		"domain_name": "www.example.com",
 		"name":"db",
 		"expected_codes":"200",
 		"max_retries":2,
 		"max_retries_down":4,
 		"http_method":"GET",
+		"http_version": 1.1,
 		"timeout":2,
 		"url_path":"/",
 		"type":"HTTP",
@@ -76,11 +80,13 @@ const PostUpdateHealthmonitorBody = `
 		"admin_state_up":true,
 		"project_id":"83657cfcdfe44cd5920adaf26c48ceea",
 		"delay":3,
+		"domain_name": "www.example.com",
 		"name":"NewHealthmonitorName",
 		"expected_codes":"301",
 		"max_retries":10,
 		"max_retries_down":8,
 		"http_method":"GET",
+		"http_version": 1.1,
 		"timeout":20,
 		"url_path":"/another_check",
 		"type":"HTTP",
@@ -107,6 +113,7 @@ var (
 	}
 	HealthmonitorDb = monitors.Monitor{
 		AdminStateUp:   true,
+		DomainName:     "www.example.com",
 		Name:           "db",
 		ProjectID:      "83657cfcdfe44cd5920adaf26c48ceea",
 		Delay:          5,
@@ -117,12 +124,14 @@ var (
 		URLPath:        "/",
 		Type:           "HTTP",
 		HTTPMethod:     "GET",
+		HTTPVersion:    "1.1",
 		ID:             "5d4b5228-33b0-4e60-b225-9b727c1a20e7",
 		Pools:          []monitors.PoolID{{ID: "d459f7d8-c6ee-439d-8713-d3fc08aeed8d"}},
 		Tags:           []string{},
 	}
 	HealthmonitorUpdated = monitors.Monitor{
 		AdminStateUp:   true,
+		DomainName:     "www.example.com",
 		Name:           "NewHealthmonitorName",
 		ProjectID:      "83657cfcdfe44cd5920adaf26c48ceea",
 		Delay:          3,
@@ -133,6 +142,7 @@ var (
 		URLPath:        "/another_check",
 		Type:           "HTTP",
 		HTTPMethod:     "GET",
+		HTTPVersion:    "1.1",
 		ID:             "5d4b5228-33b0-4e60-b225-9b727c1a20e7",
 		Pools:          []monitors.PoolID{{ID: "d459f7d8-c6ee-439d-8713-d3fc08aeed8d"}},
 		Tags:           []string{},
@@ -140,8 +150,8 @@ var (
 )
 
 // HandleHealthmonitorListSuccessfully sets up the test server to respond to a healthmonitor List request.
-func HandleHealthmonitorListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/healthmonitors", func(w http.ResponseWriter, r *http.Request) {
+func HandleHealthmonitorListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/healthmonitors", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -163,8 +173,8 @@ func HandleHealthmonitorListSuccessfully(t *testing.T) {
 
 // HandleHealthmonitorCreationSuccessfully sets up the test server to respond to a healthmonitor creation request
 // with a given response.
-func HandleHealthmonitorCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/healthmonitors", func(w http.ResponseWriter, r *http.Request) {
+func HandleHealthmonitorCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/healthmonitors", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -173,7 +183,9 @@ func HandleHealthmonitorCreationSuccessfully(t *testing.T, response string) {
 				"pool_id":"84f1b61f-58c4-45bf-a8a9-2dafb9e5214d",
 				"project_id":"453105b9-1754-413f-aab1-55f1af620750",
 				"delay":20,
+				"domain_name": "www.example.com",
 				"name":"db",
+				"http_version": 1.1,
 				"timeout":10,
 				"max_retries":5,
 				"max_retries_down":4,
@@ -189,8 +201,8 @@ func HandleHealthmonitorCreationSuccessfully(t *testing.T, response string) {
 }
 
 // HandleHealthmonitorGetSuccessfully sets up the test server to respond to a healthmonitor Get request.
-func HandleHealthmonitorGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/healthmonitors/5d4b5228-33b0-4e60-b225-9b727c1a20e7", func(w http.ResponseWriter, r *http.Request) {
+func HandleHealthmonitorGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/healthmonitors/5d4b5228-33b0-4e60-b225-9b727c1a20e7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -200,8 +212,8 @@ func HandleHealthmonitorGetSuccessfully(t *testing.T) {
 }
 
 // HandleHealthmonitorDeletionSuccessfully sets up the test server to respond to a healthmonitor deletion request.
-func HandleHealthmonitorDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/healthmonitors/5d4b5228-33b0-4e60-b225-9b727c1a20e7", func(w http.ResponseWriter, r *http.Request) {
+func HandleHealthmonitorDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/healthmonitors/5d4b5228-33b0-4e60-b225-9b727c1a20e7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -210,8 +222,8 @@ func HandleHealthmonitorDeletionSuccessfully(t *testing.T) {
 }
 
 // HandleHealthmonitorUpdateSuccessfully sets up the test server to respond to a healthmonitor Update request.
-func HandleHealthmonitorUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/healthmonitors/5d4b5228-33b0-4e60-b225-9b727c1a20e7", func(w http.ResponseWriter, r *http.Request) {
+func HandleHealthmonitorUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/healthmonitors/5d4b5228-33b0-4e60-b225-9b727c1a20e7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/loadbalancer/v2/monitors/testing/requests_test.go b/openstack/loadbalancer/v2/monitors/testing/requests_test.go
index 0ca13f360..25f2c96c5 100644
--- a/openstack/loadbalancer/v2/monitors/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/monitors/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListHealthmonitors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHealthmonitorListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHealthmonitorListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := monitors.List(fake.ServiceClient(), monitors.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := monitors.List(fake.ServiceClient(fakeServer), monitors.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := monitors.ExtractMonitors(page)
@@ -41,11 +41,11 @@ func TestListHealthmonitors(t *testing.T) {
 }
 
 func TestListAllHealthmonitors(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHealthmonitorListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHealthmonitorListSuccessfully(t, fakeServer)
 
-	allPages, err := monitors.List(fake.ServiceClient(), monitors.ListOpts{}).AllPages(context.TODO())
+	allPages, err := monitors.List(fake.ServiceClient(fakeServer), monitors.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := monitors.ExtractMonitors(allPages)
 	th.AssertNoErr(t, err)
@@ -54,12 +54,13 @@ func TestListAllHealthmonitors(t *testing.T) {
 }
 
 func TestCreateHealthmonitor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHealthmonitorCreationSuccessfully(t, SingleHealthmonitorBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHealthmonitorCreationSuccessfully(t, fakeServer, SingleHealthmonitorBody)
 
-	actual, err := monitors.Create(context.TODO(), fake.ServiceClient(), monitors.CreateOpts{
+	actual, err := monitors.Create(context.TODO(), fake.ServiceClient(fakeServer), monitors.CreateOpts{
 		Type:           "HTTP",
+		DomainName:     "www.example.com",
 		Name:           "db",
 		PoolID:         "84f1b61f-58c4-45bf-a8a9-2dafb9e5214d",
 		ProjectID:      "453105b9-1754-413f-aab1-55f1af620750",
@@ -67,6 +68,7 @@ func TestCreateHealthmonitor(t *testing.T) {
 		Timeout:        10,
 		MaxRetries:     5,
 		MaxRetriesDown: 4,
+		HTTPVersion:    "1.1",
 		Tags:           []string{},
 		URLPath:        "/check",
 		ExpectedCodes:  "200-299",
@@ -77,22 +79,25 @@ func TestCreateHealthmonitor(t *testing.T) {
 }
 
 func TestRequiredCreateOpts(t *testing.T) {
-	res := monitors.Create(context.TODO(), fake.ServiceClient(), monitors.CreateOpts{})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := monitors.Create(context.TODO(), fake.ServiceClient(fakeServer), monitors.CreateOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = monitors.Create(context.TODO(), fake.ServiceClient(), monitors.CreateOpts{Type: monitors.TypeHTTP})
+	res = monitors.Create(context.TODO(), fake.ServiceClient(fakeServer), monitors.CreateOpts{Type: monitors.TypeHTTP})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestGetHealthmonitor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHealthmonitorGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHealthmonitorGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := monitors.Get(context.TODO(), client, "5d4b5228-33b0-4e60-b225-9b727c1a20e7").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -102,20 +107,20 @@ func TestGetHealthmonitor(t *testing.T) {
 }
 
 func TestDeleteHealthmonitor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHealthmonitorDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHealthmonitorDeletionSuccessfully(t, fakeServer)
 
-	res := monitors.Delete(context.TODO(), fake.ServiceClient(), "5d4b5228-33b0-4e60-b225-9b727c1a20e7")
+	res := monitors.Delete(context.TODO(), fake.ServiceClient(fakeServer), "5d4b5228-33b0-4e60-b225-9b727c1a20e7")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateHealthmonitor(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleHealthmonitorUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleHealthmonitorUpdateSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	name := "NewHealthmonitorName"
 	actual, err := monitors.Update(context.TODO(), client, "5d4b5228-33b0-4e60-b225-9b727c1a20e7", monitors.UpdateOpts{
 		Name:           &name,
@@ -134,7 +139,10 @@ func TestUpdateHealthmonitor(t *testing.T) {
 }
 
 func TestDelayMustBeGreaterOrEqualThanTimeout(t *testing.T) {
-	_, err := monitors.Create(context.TODO(), fake.ServiceClient(), monitors.CreateOpts{
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	_, err := monitors.Create(context.TODO(), fake.ServiceClient(fakeServer), monitors.CreateOpts{
 		Type:          "HTTP",
 		PoolID:        "d459f7d8-c6ee-439d-8713-d3fc08aeed8d",
 		Delay:         1,
@@ -148,7 +156,7 @@ func TestDelayMustBeGreaterOrEqualThanTimeout(t *testing.T) {
 		t.Fatalf("Expected error, got none")
 	}
 
-	_, err = monitors.Update(context.TODO(), fake.ServiceClient(), "453105b9-1754-413f-aab1-55f1af620750", monitors.UpdateOpts{
+	_, err = monitors.Update(context.TODO(), fake.ServiceClient(fakeServer), "453105b9-1754-413f-aab1-55f1af620750", monitors.UpdateOpts{
 		Delay:   1,
 		Timeout: 10,
 	}).Extract()
diff --git a/openstack/loadbalancer/v2/pools/testing/fixtures_test.go b/openstack/loadbalancer/v2/pools/testing/fixtures_test.go
index bcc582a63..a2073952b 100644
--- a/openstack/loadbalancer/v2/pools/testing/fixtures_test.go
+++ b/openstack/loadbalancer/v2/pools/testing/fixtures_test.go
@@ -133,8 +133,8 @@ var (
 )
 
 // HandlePoolListSuccessfully sets up the test server to respond to a pool List request.
-func HandlePoolListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools", func(w http.ResponseWriter, r *http.Request) {
+func HandlePoolListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -156,8 +156,8 @@ func HandlePoolListSuccessfully(t *testing.T) {
 
 // HandlePoolCreationSuccessfully sets up the test server to respond to a pool creation request
 // with a given response.
-func HandlePoolCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools", func(w http.ResponseWriter, r *http.Request) {
+func HandlePoolCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -177,8 +177,8 @@ func HandlePoolCreationSuccessfully(t *testing.T, response string) {
 }
 
 // HandlePoolGetSuccessfully sets up the test server to respond to a pool Get request.
-func HandlePoolGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/c3741b06-df4d-4715-b142-276b6bce75ab", func(w http.ResponseWriter, r *http.Request) {
+func HandlePoolGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/c3741b06-df4d-4715-b142-276b6bce75ab", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -188,8 +188,8 @@ func HandlePoolGetSuccessfully(t *testing.T) {
 }
 
 // HandlePoolDeletionSuccessfully sets up the test server to respond to a pool deletion request.
-func HandlePoolDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/c3741b06-df4d-4715-b142-276b6bce75ab", func(w http.ResponseWriter, r *http.Request) {
+func HandlePoolDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/c3741b06-df4d-4715-b142-276b6bce75ab", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -198,8 +198,8 @@ func HandlePoolDeletionSuccessfully(t *testing.T) {
 }
 
 // HandlePoolUpdateSuccessfully sets up the test server to respond to a pool Update request.
-func HandlePoolUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/c3741b06-df4d-4715-b142-276b6bce75ab", func(w http.ResponseWriter, r *http.Request) {
+func HandlePoolUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/c3741b06-df4d-4715-b142-276b6bce75ab", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -330,8 +330,8 @@ var (
 )
 
 // HandleMemberListSuccessfully sets up the test server to respond to a member List request.
-func HandleMemberListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members", func(w http.ResponseWriter, r *http.Request) {
+func HandleMemberListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -353,8 +353,8 @@ func HandleMemberListSuccessfully(t *testing.T) {
 
 // HandleMemberCreationSuccessfully sets up the test server to respond to a member creation request
 // with a given response.
-func HandleMemberCreationSuccessfully(t *testing.T, response string) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members", func(w http.ResponseWriter, r *http.Request) {
+func HandleMemberCreationSuccessfully(t *testing.T, fakeServer th.FakeServer, response string) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestJSONRequest(t, r, `{
@@ -375,8 +375,8 @@ func HandleMemberCreationSuccessfully(t *testing.T, response string) {
 }
 
 // HandleMemberGetSuccessfully sets up the test server to respond to a member Get request.
-func HandleMemberGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members/2a280670-c202-4b0b-a562-34077415aabf", func(w http.ResponseWriter, r *http.Request) {
+func HandleMemberGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members/2a280670-c202-4b0b-a562-34077415aabf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -386,8 +386,8 @@ func HandleMemberGetSuccessfully(t *testing.T) {
 }
 
 // HandleMemberDeletionSuccessfully sets up the test server to respond to a member deletion request.
-func HandleMemberDeletionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members/2a280670-c202-4b0b-a562-34077415aabf", func(w http.ResponseWriter, r *http.Request) {
+func HandleMemberDeletionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members/2a280670-c202-4b0b-a562-34077415aabf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -396,8 +396,8 @@ func HandleMemberDeletionSuccessfully(t *testing.T) {
 }
 
 // HandleMemberUpdateSuccessfully sets up the test server to respond to a member Update request.
-func HandleMemberUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members/2a280670-c202-4b0b-a562-34077415aabf", func(w http.ResponseWriter, r *http.Request) {
+func HandleMemberUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members/2a280670-c202-4b0b-a562-34077415aabf", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -414,8 +414,8 @@ func HandleMemberUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleMembersUpdateSuccessfully sets up the test server to respond to a batch member Update request.
-func HandleMembersUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members", func(w http.ResponseWriter, r *http.Request) {
+func HandleMembersUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -444,8 +444,8 @@ func HandleMembersUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleEmptyMembersUpdateSuccessfully sets up the test server to respond to an empty batch member Update request.
-func HandleEmptyMembersUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members", func(w http.ResponseWriter, r *http.Request) {
+func HandleEmptyMembersUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/pools/332abe93-f488-41ba-870b-2ac66be7f853/members", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
diff --git a/openstack/loadbalancer/v2/pools/testing/requests_test.go b/openstack/loadbalancer/v2/pools/testing/requests_test.go
index 6e3126329..17ae97661 100644
--- a/openstack/loadbalancer/v2/pools/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/pools/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListPools(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePoolListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePoolListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := pools.List(fake.ServiceClient(), pools.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := pools.List(fake.ServiceClient(fakeServer), pools.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := pools.ExtractPools(page)
@@ -41,11 +41,11 @@ func TestListPools(t *testing.T) {
 }
 
 func TestListAllPools(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePoolListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePoolListSuccessfully(t, fakeServer)
 
-	allPages, err := pools.List(fake.ServiceClient(), pools.ListOpts{}).AllPages(context.TODO())
+	allPages, err := pools.List(fake.ServiceClient(fakeServer), pools.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := pools.ExtractPools(allPages)
 	th.AssertNoErr(t, err)
@@ -54,11 +54,11 @@ func TestListAllPools(t *testing.T) {
 }
 
 func TestCreatePool(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePoolCreationSuccessfully(t, SinglePoolBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePoolCreationSuccessfully(t, fakeServer, SinglePoolBody)
 
-	actual, err := pools.Create(context.TODO(), fake.ServiceClient(), pools.CreateOpts{
+	actual, err := pools.Create(context.TODO(), fake.ServiceClient(fakeServer), pools.CreateOpts{
 		LBMethod:       pools.LBMethodRoundRobin,
 		Protocol:       "HTTP",
 		Name:           "Example pool",
@@ -71,11 +71,11 @@ func TestCreatePool(t *testing.T) {
 }
 
 func TestGetPool(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePoolGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePoolGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := pools.Get(context.TODO(), client, "c3741b06-df4d-4715-b142-276b6bce75ab").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -85,20 +85,20 @@ func TestGetPool(t *testing.T) {
 }
 
 func TestDeletePool(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePoolDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePoolDeletionSuccessfully(t, fakeServer)
 
-	res := pools.Delete(context.TODO(), fake.ServiceClient(), "c3741b06-df4d-4715-b142-276b6bce75ab")
+	res := pools.Delete(context.TODO(), fake.ServiceClient(fakeServer), "c3741b06-df4d-4715-b142-276b6bce75ab")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdatePool(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePoolUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePoolUpdateSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	name := "NewPoolName"
 	actual, err := pools.Update(context.TODO(), client, "c3741b06-df4d-4715-b142-276b6bce75ab", pools.UpdateOpts{
 		Name:     &name,
@@ -112,11 +112,14 @@ func TestUpdatePool(t *testing.T) {
 }
 
 func TestRequiredPoolCreateOpts(t *testing.T) {
-	res := pools.Create(context.TODO(), fake.ServiceClient(), pools.CreateOpts{})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := pools.Create(context.TODO(), fake.ServiceClient(fakeServer), pools.CreateOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = pools.Create(context.TODO(), fake.ServiceClient(), pools.CreateOpts{
+	res = pools.Create(context.TODO(), fake.ServiceClient(fakeServer), pools.CreateOpts{
 		LBMethod:       pools.LBMethod("invalid"),
 		Protocol:       pools.ProtocolHTTPS,
 		LoadbalancerID: "69055154-f603-4a28-8951-7cc2d9e54a9a",
@@ -125,7 +128,7 @@ func TestRequiredPoolCreateOpts(t *testing.T) {
 		t.Fatalf("Expected error, but got none")
 	}
 
-	res = pools.Create(context.TODO(), fake.ServiceClient(), pools.CreateOpts{
+	res = pools.Create(context.TODO(), fake.ServiceClient(fakeServer), pools.CreateOpts{
 		LBMethod:       pools.LBMethodRoundRobin,
 		Protocol:       pools.Protocol("invalid"),
 		LoadbalancerID: "69055154-f603-4a28-8951-7cc2d9e54a9a",
@@ -134,7 +137,7 @@ func TestRequiredPoolCreateOpts(t *testing.T) {
 		t.Fatalf("Expected error, but got none")
 	}
 
-	res = pools.Create(context.TODO(), fake.ServiceClient(), pools.CreateOpts{
+	res = pools.Create(context.TODO(), fake.ServiceClient(fakeServer), pools.CreateOpts{
 		LBMethod: pools.LBMethodRoundRobin,
 		Protocol: pools.ProtocolHTTPS,
 	})
@@ -144,12 +147,12 @@ func TestRequiredPoolCreateOpts(t *testing.T) {
 }
 
 func TestListMembers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMemberListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMemberListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := pools.ListMembers(fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", pools.ListMembersOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := pools.ListMembers(fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", pools.ListMembersOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := pools.ExtractMembers(page)
@@ -174,11 +177,11 @@ func TestListMembers(t *testing.T) {
 }
 
 func TestListAllMembers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMemberListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMemberListSuccessfully(t, fakeServer)
 
-	allPages, err := pools.ListMembers(fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", pools.ListMembersOpts{}).AllPages(context.TODO())
+	allPages, err := pools.ListMembers(fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", pools.ListMembersOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := pools.ExtractMembers(allPages)
 	th.AssertNoErr(t, err)
@@ -187,12 +190,12 @@ func TestListAllMembers(t *testing.T) {
 }
 
 func TestCreateMember(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMemberCreationSuccessfully(t, SingleMemberBody)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMemberCreationSuccessfully(t, fakeServer, SingleMemberBody)
 
 	weight := 10
-	actual, err := pools.CreateMember(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", pools.CreateMemberOpts{
+	actual, err := pools.CreateMember(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", pools.CreateMemberOpts{
 		Name:         "db",
 		SubnetID:     "1981f108-3c48-48d2-b908-30f7d28532c9",
 		ProjectID:    "2ffc6e22aae24e4795f87155d24c896f",
@@ -206,30 +209,33 @@ func TestCreateMember(t *testing.T) {
 }
 
 func TestRequiredMemberCreateOpts(t *testing.T) {
-	res := pools.CreateMember(context.TODO(), fake.ServiceClient(), "", pools.CreateMemberOpts{})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := pools.CreateMember(context.TODO(), fake.ServiceClient(fakeServer), "", pools.CreateMemberOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = pools.CreateMember(context.TODO(), fake.ServiceClient(), "", pools.CreateMemberOpts{Address: "1.2.3.4", ProtocolPort: 80})
+	res = pools.CreateMember(context.TODO(), fake.ServiceClient(fakeServer), "", pools.CreateMemberOpts{Address: "1.2.3.4", ProtocolPort: 80})
 	if res.Err == nil {
 		t.Fatalf("Expected error, but got none")
 	}
-	res = pools.CreateMember(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", pools.CreateMemberOpts{ProtocolPort: 80})
+	res = pools.CreateMember(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", pools.CreateMemberOpts{ProtocolPort: 80})
 	if res.Err == nil {
 		t.Fatalf("Expected error, but got none")
 	}
-	res = pools.CreateMember(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", pools.CreateMemberOpts{Address: "1.2.3.4"})
+	res = pools.CreateMember(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", pools.CreateMemberOpts{Address: "1.2.3.4"})
 	if res.Err == nil {
 		t.Fatalf("Expected error, but got none")
 	}
 }
 
 func TestGetMember(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMemberGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMemberGetSuccessfully(t, fakeServer)
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	actual, err := pools.GetMember(context.TODO(), client, "332abe93-f488-41ba-870b-2ac66be7f853", "2a280670-c202-4b0b-a562-34077415aabf").Extract()
 	if err != nil {
 		t.Fatalf("Unexpected Get error: %v", err)
@@ -239,21 +245,21 @@ func TestGetMember(t *testing.T) {
 }
 
 func TestDeleteMember(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMemberDeletionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMemberDeletionSuccessfully(t, fakeServer)
 
-	res := pools.DeleteMember(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", "2a280670-c202-4b0b-a562-34077415aabf")
+	res := pools.DeleteMember(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", "2a280670-c202-4b0b-a562-34077415aabf")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdateMember(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMemberUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMemberUpdateSuccessfully(t, fakeServer)
 
 	weight := 4
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	name := "newMemberName"
 	actual, err := pools.UpdateMember(context.TODO(), client, "332abe93-f488-41ba-870b-2ac66be7f853", "2a280670-c202-4b0b-a562-34077415aabf", pools.UpdateMemberOpts{
 		Name:   &name,
@@ -267,9 +273,9 @@ func TestUpdateMember(t *testing.T) {
 }
 
 func TestBatchUpdateMembers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMembersUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMembersUpdateSuccessfully(t, fakeServer)
 
 	name_1 := "web-server-1"
 	weight_1 := 20
@@ -293,25 +299,25 @@ func TestBatchUpdateMembers(t *testing.T) {
 	}
 	members := []pools.BatchUpdateMemberOpts{member1, member2}
 
-	res := pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", members)
+	res := pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", members)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestEmptyBatchUpdateMembers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleEmptyMembersUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleEmptyMembersUpdateSuccessfully(t, fakeServer)
 
-	res := pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", []pools.BatchUpdateMemberOpts{})
+	res := pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", []pools.BatchUpdateMemberOpts{})
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestRequiredBatchUpdateMemberOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	name := "web-server-1"
-	res := pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", []pools.BatchUpdateMemberOpts{
+	res := pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", []pools.BatchUpdateMemberOpts{
 		{
 			Name: &name,
 		},
@@ -320,7 +326,7 @@ func TestRequiredBatchUpdateMemberOpts(t *testing.T) {
 		t.Fatalf("Expected error, but got none")
 	}
 
-	res = pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", []pools.BatchUpdateMemberOpts{
+	res = pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", []pools.BatchUpdateMemberOpts{
 		{
 			Address: "192.0.2.17",
 			Name:    &name,
@@ -330,7 +336,7 @@ func TestRequiredBatchUpdateMemberOpts(t *testing.T) {
 		t.Fatalf("Expected error, but got none")
 	}
 
-	res = pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(), "332abe93-f488-41ba-870b-2ac66be7f853", []pools.BatchUpdateMemberOpts{
+	res = pools.BatchUpdateMembers(context.TODO(), fake.ServiceClient(fakeServer), "332abe93-f488-41ba-870b-2ac66be7f853", []pools.BatchUpdateMemberOpts{
 		{
 			ProtocolPort: 80,
 			Name:         &name,
diff --git a/openstack/loadbalancer/v2/providers/testing/fixtures_test.go b/openstack/loadbalancer/v2/providers/testing/fixtures_test.go
index b8a857e61..78c9f7a10 100644
--- a/openstack/loadbalancer/v2/providers/testing/fixtures_test.go
+++ b/openstack/loadbalancer/v2/providers/testing/fixtures_test.go
@@ -38,8 +38,8 @@ var (
 )
 
 // HandleProviderListSuccessfully sets up the test server to respond to a provider List request.
-func HandleProviderListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/lbaas/providers", func(w http.ResponseWriter, r *http.Request) {
+func HandleProviderListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/lbaas/providers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/loadbalancer/v2/providers/testing/requests_test.go b/openstack/loadbalancer/v2/providers/testing/requests_test.go
index c5a5278aa..6046cde03 100644
--- a/openstack/loadbalancer/v2/providers/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/providers/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListProviders(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleProviderListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleProviderListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := providers.List(fake.ServiceClient(), providers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := providers.List(fake.ServiceClient(fakeServer), providers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := providers.ExtractProviders(page)
@@ -41,11 +41,11 @@ func TestListProviders(t *testing.T) {
 }
 
 func TestListAllProviders(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleProviderListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleProviderListSuccessfully(t, fakeServer)
 
-	allPages, err := providers.List(fake.ServiceClient(), providers.ListOpts{}).AllPages(context.TODO())
+	allPages, err := providers.List(fake.ServiceClient(fakeServer), providers.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := providers.ExtractProviders(allPages)
 	th.AssertNoErr(t, err)
diff --git a/openstack/loadbalancer/v2/quotas/testing/requests_test.go b/openstack/loadbalancer/v2/quotas/testing/requests_test.go
index 6f990428f..ccf8e51f3 100644
--- a/openstack/loadbalancer/v2/quotas/testing/requests_test.go
+++ b/openstack/loadbalancer/v2/quotas/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestGet_1(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -26,16 +26,16 @@ func TestGet_1(t *testing.T) {
 		fmt.Fprint(w, GetResponseRaw_1)
 	})
 
-	q, err := quotas.Get(context.TODO(), fake.ServiceClient(), "0a73845280574ad389c292f6a74afa76").Extract()
+	q, err := quotas.Get(context.TODO(), fake.ServiceClient(fakeServer), "0a73845280574ad389c292f6a74afa76").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, q, &GetResponse)
 }
 
 func TestGet_2(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -45,16 +45,16 @@ func TestGet_2(t *testing.T) {
 		fmt.Fprint(w, GetResponseRaw_2)
 	})
 
-	q, err := quotas.Get(context.TODO(), fake.ServiceClient(), "0a73845280574ad389c292f6a74afa76").Extract()
+	q, err := quotas.Get(context.TODO(), fake.ServiceClient(fakeServer), "0a73845280574ad389c292f6a74afa76").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, q, &GetResponse)
 }
 
 func TestUpdate_1(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -64,7 +64,7 @@ func TestUpdate_1(t *testing.T) {
 		fmt.Fprint(w, UpdateRequestResponseRaw_1)
 	})
 
-	q, err := quotas.Update(context.TODO(), fake.ServiceClient(), "0a73845280574ad389c292f6a74afa76", quotas.UpdateOpts{
+	q, err := quotas.Update(context.TODO(), fake.ServiceClient(fakeServer), "0a73845280574ad389c292f6a74afa76", quotas.UpdateOpts{
 		Loadbalancer:  gophercloud.IntToPointer(20),
 		Listener:      gophercloud.IntToPointer(40),
 		Member:        gophercloud.IntToPointer(200),
@@ -79,10 +79,10 @@ func TestUpdate_1(t *testing.T) {
 }
 
 func TestUpdate_2(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -92,7 +92,7 @@ func TestUpdate_2(t *testing.T) {
 		fmt.Fprint(w, UpdateRequestResponseRaw_2)
 	})
 
-	q, err := quotas.Update(context.TODO(), fake.ServiceClient(), "0a73845280574ad389c292f6a74afa76", quotas.UpdateOpts{
+	q, err := quotas.Update(context.TODO(), fake.ServiceClient(fakeServer), "0a73845280574ad389c292f6a74afa76", quotas.UpdateOpts{
 		Loadbalancer:  gophercloud.IntToPointer(20),
 		Listener:      gophercloud.IntToPointer(40),
 		Member:        gophercloud.IntToPointer(200),
diff --git a/openstack/loadbalancer/v2/testhelper/client.go b/openstack/loadbalancer/v2/testhelper/client.go
index f32313a10..581c9803a 100644
--- a/openstack/loadbalancer/v2/testhelper/client.go
+++ b/openstack/loadbalancer/v2/testhelper/client.go
@@ -2,13 +2,14 @@ package common
 
 import (
 	"github.com/gophercloud/gophercloud/v2"
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const TokenID = client.TokenID
 
-func ServiceClient() *gophercloud.ServiceClient {
-	sc := client.ServiceClient()
+func ServiceClient(fakeServer th.FakeServer) *gophercloud.ServiceClient {
+	sc := client.ServiceClient(fakeServer)
 	sc.ResourceBase = sc.Endpoint + "v2.0/"
 	return sc
 }
diff --git a/openstack/messaging/v2/claims/testing/fixtures_test.go b/openstack/messaging/v2/claims/testing/fixtures_test.go
index 5912ff64e..b8087d663 100644
--- a/openstack/messaging/v2/claims/testing/fixtures_test.go
+++ b/openstack/messaging/v2/claims/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/messaging/v2/claims"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // QueueName is the name of the queue
@@ -84,11 +84,11 @@ var FirstClaim = claims.Claim{
 }
 
 // HandleCreateSuccessfully configures the test server to respond to a Create request.
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims", QueueName),
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, CreateClaimRequest)
 
 			w.WriteHeader(http.StatusCreated)
@@ -98,11 +98,11 @@ func HandleCreateSuccessfully(t *testing.T) {
 }
 
 // HandleCreateNoContent configures the test server to respond to a Create request with no content.
-func HandleCreateNoContent(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims", QueueName),
+func HandleCreateNoContent(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, CreateClaimRequest)
 
 			w.WriteHeader(http.StatusNoContent)
@@ -110,11 +110,11 @@ func HandleCreateNoContent(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a Get request.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims/%s", QueueName, ClaimID),
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims/%s", QueueName, ClaimID),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			fmt.Fprint(w, GetClaimResponse)
@@ -122,11 +122,11 @@ func HandleGetSuccessfully(t *testing.T) {
 }
 
 // HandleUpdateSuccessfully configures the test server to respond to a Update request.
-func HandleUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims/%s", QueueName, ClaimID),
+func HandleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims/%s", QueueName, ClaimID),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PATCH")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, UpdateClaimRequest)
 
 			w.WriteHeader(http.StatusNoContent)
@@ -134,11 +134,11 @@ func HandleUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleDeleteSuccessfully configures the test server to respond to an Delete request.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims/%s", QueueName, ClaimID),
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/claims/%s", QueueName, ClaimID),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.WriteHeader(http.StatusNoContent)
 		})
diff --git a/openstack/messaging/v2/claims/testing/requests_test.go b/openstack/messaging/v2/claims/testing/requests_test.go
index 804079660..2a5bebd48 100644
--- a/openstack/messaging/v2/claims/testing/requests_test.go
+++ b/openstack/messaging/v2/claims/testing/requests_test.go
@@ -6,13 +6,13 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/messaging/v2/claims"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
 	createOpts := claims.CreateOpts{
 		TTL:   3600,
@@ -20,15 +20,15 @@ func TestCreate(t *testing.T) {
 		Limit: 10,
 	}
 
-	actual, err := claims.Create(context.TODO(), fake.ServiceClient(), QueueName, createOpts).Extract()
+	actual, err := claims.Create(context.TODO(), client.ServiceClient(fakeServer), QueueName, createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, CreatedClaim, actual)
 }
 
 func TestCreateNoContent(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateNoContent(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateNoContent(t, fakeServer)
 
 	createOpts := claims.CreateOpts{
 		TTL:   3600,
@@ -36,41 +36,41 @@ func TestCreateNoContent(t *testing.T) {
 		Limit: 10,
 	}
 
-	actual, err := claims.Create(context.TODO(), fake.ServiceClient(), QueueName, createOpts).Extract()
+	actual, err := claims.Create(context.TODO(), client.ServiceClient(fakeServer), QueueName, createOpts).Extract()
 	th.AssertNoErr(t, err)
 	var expected []claims.Messages
 	th.CheckDeepEquals(t, expected, actual)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := claims.Get(context.TODO(), fake.ServiceClient(), QueueName, ClaimID).Extract()
+	actual, err := claims.Get(context.TODO(), client.ServiceClient(fakeServer), QueueName, ClaimID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &FirstClaim, actual)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
 	updateOpts := claims.UpdateOpts{
 		Grace: 1600,
 		TTL:   1200,
 	}
 
-	err := claims.Update(context.TODO(), fake.ServiceClient(), QueueName, ClaimID, updateOpts).ExtractErr()
+	err := claims.Update(context.TODO(), client.ServiceClient(fakeServer), QueueName, ClaimID, updateOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	err := claims.Delete(context.TODO(), fake.ServiceClient(), QueueName, ClaimID).ExtractErr()
+	err := claims.Delete(context.TODO(), client.ServiceClient(fakeServer), QueueName, ClaimID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/messaging/v2/messages/testing/fixtures_test.go b/openstack/messaging/v2/messages/testing/fixtures_test.go
index 95cd47592..b7f6d194a 100644
--- a/openstack/messaging/v2/messages/testing/fixtures_test.go
+++ b/openstack/messaging/v2/messages/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/messaging/v2/messages"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // QueueName is the name of the queue
@@ -220,11 +220,11 @@ var ExpectedPopMessage = []messages.PopMessage{{
 }}
 
 // HandleCreateSuccessfully configures the test server to respond to a Create request.
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, CreateMessageRequest)
 
 			w.Header().Add("Content-Type", "application/json")
@@ -234,11 +234,11 @@ func HandleCreateSuccessfully(t *testing.T) {
 }
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			next := r.RequestURI
@@ -255,11 +255,11 @@ func HandleListSuccessfully(t *testing.T) {
 }
 
 // HandleGetMessagesSuccessfully configures the test server to respond to a GetMessages request.
-func HandleGetMessagesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
+func HandleGetMessagesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			fmt.Fprint(w, GetMessagesResponse)
@@ -267,11 +267,11 @@ func HandleGetMessagesSuccessfully(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a Get request.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages/%s", QueueName, MessageID),
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages/%s", QueueName, MessageID),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			fmt.Fprint(w, GetMessageResponse)
@@ -279,11 +279,11 @@ func HandleGetSuccessfully(t *testing.T) {
 }
 
 // HandleDeleteMessagesSuccessfully configures the test server to respond to a Delete request.
-func HandleDeleteMessagesSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
+func HandleDeleteMessagesSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			w.WriteHeader(http.StatusNoContent)
@@ -291,11 +291,11 @@ func HandleDeleteMessagesSuccessfully(t *testing.T) {
 }
 
 // HandlePopSuccessfully configures the test server to respond to a Pop request.
-func HandlePopSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
+func HandlePopSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			w.WriteHeader(http.StatusOK)
@@ -304,11 +304,11 @@ func HandlePopSuccessfully(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a Get request.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages/%s", QueueName, MessageID),
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/messages/%s", QueueName, MessageID),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			w.WriteHeader(http.StatusNoContent)
diff --git a/openstack/messaging/v2/messages/testing/requests_test.go b/openstack/messaging/v2/messages/testing/requests_test.go
index e2ee71be8..cd09f1b48 100644
--- a/openstack/messaging/v2/messages/testing/requests_test.go
+++ b/openstack/messaging/v2/messages/testing/requests_test.go
@@ -7,20 +7,20 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/messaging/v2/messages"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	listOpts := messages.ListOpts{
 		Limit: 1,
 	}
 
 	count := 0
-	err := messages.List(fake.ServiceClient(), QueueName, listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := messages.List(client.ServiceClient(fakeServer), QueueName, listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		actual, err := messages.ExtractMessages(page)
 		th.AssertNoErr(t, err)
 
@@ -35,9 +35,9 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 
 	createOpts := messages.BatchCreateOpts{
 		messages.CreateOpts{
@@ -57,71 +57,71 @@ func TestCreate(t *testing.T) {
 		},
 	}
 
-	actual, err := messages.Create(context.TODO(), fake.ServiceClient(), QueueName, createOpts).Extract()
+	actual, err := messages.Create(context.TODO(), client.ServiceClient(fakeServer), QueueName, createOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedResources, actual)
 }
 
 func TestGetMessages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetMessagesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetMessagesSuccessfully(t, fakeServer)
 
 	getMessagesOpts := messages.GetMessagesOpts{
 		IDs: []string{"9988776655"},
 	}
 
-	actual, err := messages.GetMessages(context.TODO(), fake.ServiceClient(), QueueName, getMessagesOpts).Extract()
+	actual, err := messages.GetMessages(context.TODO(), client.ServiceClient(fakeServer), QueueName, getMessagesOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedMessagesSet, actual)
 }
 
 func TestGetMessage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := messages.Get(context.TODO(), fake.ServiceClient(), QueueName, MessageID).Extract()
+	actual, err := messages.Get(context.TODO(), client.ServiceClient(fakeServer), QueueName, MessageID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, FirstMessage, actual)
 }
 
 func TestDeleteMessages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteMessagesSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteMessagesSuccessfully(t, fakeServer)
 
 	deleteMessagesOpts := messages.DeleteMessagesOpts{
 		IDs: []string{"9988776655"},
 	}
 
-	err := messages.DeleteMessages(context.TODO(), fake.ServiceClient(), QueueName, deleteMessagesOpts).ExtractErr()
+	err := messages.DeleteMessages(context.TODO(), client.ServiceClient(fakeServer), QueueName, deleteMessagesOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestPopMessages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePopSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePopSuccessfully(t, fakeServer)
 
 	popMessagesOpts := messages.PopMessagesOpts{
 		Pop: 1,
 	}
 
-	actual, err := messages.PopMessages(context.TODO(), fake.ServiceClient(), QueueName, popMessagesOpts).Extract()
+	actual, err := messages.PopMessages(context.TODO(), client.ServiceClient(fakeServer), QueueName, popMessagesOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedPopMessage, actual)
 }
 
 func TestDeleteMessage(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
 	deleteOpts := messages.DeleteOpts{
 		ClaimID: "12345",
 	}
 
-	err := messages.Delete(context.TODO(), fake.ServiceClient(), QueueName, MessageID, deleteOpts).ExtractErr()
+	err := messages.Delete(context.TODO(), client.ServiceClient(fakeServer), QueueName, MessageID, deleteOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/messaging/v2/queues/testing/fixtures_test.go b/openstack/messaging/v2/queues/testing/fixtures_test.go
index 7abfdc35b..c0d62f3e7 100644
--- a/openstack/messaging/v2/queues/testing/fixtures_test.go
+++ b/openstack/messaging/v2/queues/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/messaging/v2/queues"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // QueueName is the name of the queue
@@ -215,11 +215,11 @@ var ExpectedShare = queues.QueueShare{
 }
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2/queues",
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2/queues",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			next := r.RequestURI
@@ -236,11 +236,11 @@ func HandleListSuccessfully(t *testing.T) {
 }
 
 // HandleCreateSuccessfully configures the test server to respond to a Create request.
-func HandleCreateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s", QueueName),
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PUT")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, CreateQueueRequest)
 
 			w.WriteHeader(http.StatusNoContent)
@@ -248,11 +248,11 @@ func HandleCreateSuccessfully(t *testing.T) {
 }
 
 // HandleUpdateSuccessfully configures the test server to respond to an Update request.
-func HandleUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s", QueueName),
+func HandleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PATCH")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, UpdateQueueRequest)
 
 			w.Header().Add("Content-Type", "application/json")
@@ -261,11 +261,11 @@ func HandleUpdateSuccessfully(t *testing.T) {
 }
 
 // HandleGetSuccessfully configures the test server to respond to a Get request.
-func HandleGetSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s", QueueName),
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			fmt.Fprint(w, GetQueueResponse)
@@ -273,21 +273,21 @@ func HandleGetSuccessfully(t *testing.T) {
 }
 
 // HandleDeleteSuccessfully configures the test server to respond to a Delete request.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s", QueueName),
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			w.WriteHeader(http.StatusNoContent)
 		})
 }
 
 // HandleGetSuccessfully configures the test server to respond to a Get request.
-func HandleGetStatsSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/stats", QueueName),
+func HandleGetStatsSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/stats", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			fmt.Fprint(w, GetStatsResponse)
@@ -295,11 +295,11 @@ func HandleGetStatsSuccessfully(t *testing.T) {
 }
 
 // HandleShareSuccessfully configures the test server to respond to a Share request.
-func HandleShareSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/share", QueueName),
+func HandleShareSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/share", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, CreateShareRequest)
 
 			w.Header().Add("Content-Type", "application/json")
@@ -308,11 +308,11 @@ func HandleShareSuccessfully(t *testing.T) {
 }
 
 // HandlePurgeSuccessfully configures the test server to respond to a Purge request.
-func HandlePurgeSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/purge", QueueName),
+func HandlePurgeSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(fmt.Sprintf("/v2/queues/%s/purge", QueueName),
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestJSONRequest(t, r, CreatePurgeRequest)
 
 			w.WriteHeader(http.StatusNoContent)
diff --git a/openstack/messaging/v2/queues/testing/requests_test.go b/openstack/messaging/v2/queues/testing/requests_test.go
index eb83908d5..8f882cf12 100644
--- a/openstack/messaging/v2/queues/testing/requests_test.go
+++ b/openstack/messaging/v2/queues/testing/requests_test.go
@@ -7,13 +7,13 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/messaging/v2/queues"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	listOpts := queues.ListOpts{
 		Limit:     1,
@@ -21,7 +21,7 @@ func TestList(t *testing.T) {
 	}
 
 	count := 0
-	err := queues.List(fake.ServiceClient(), listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := queues.List(client.ServiceClient(fakeServer), listOpts).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		actual, err := queues.ExtractQueues(page)
 		th.AssertNoErr(t, err)
 		countField, err := page.(queues.QueuePage).GetCount()
@@ -39,9 +39,9 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer)
 	var enableEncrypted *bool = new(bool)
 
 	createOpts := queues.CreateOpts{
@@ -56,14 +56,14 @@ func TestCreate(t *testing.T) {
 		Extra:                      map[string]any{"description": "Queue for unit testing."},
 	}
 
-	err := queues.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractErr()
+	err := queues.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
 	updateOpts := queues.BatchUpdateOpts{
 		queues.UpdateOpts{
@@ -76,44 +76,44 @@ func TestUpdate(t *testing.T) {
 		Extra: map[string]any{"description": "Update queue description"},
 	}
 
-	actual, err := queues.Update(context.TODO(), fake.ServiceClient(), QueueName, updateOpts).Extract()
+	actual, err := queues.Update(context.TODO(), client.ServiceClient(fakeServer), QueueName, updateOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, updatedQueueResult, actual)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer)
 
-	actual, err := queues.Get(context.TODO(), fake.ServiceClient(), QueueName).Extract()
+	actual, err := queues.Get(context.TODO(), client.ServiceClient(fakeServer), QueueName).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, QueueDetails, actual)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	err := queues.Delete(context.TODO(), fake.ServiceClient(), QueueName).ExtractErr()
+	err := queues.Delete(context.TODO(), client.ServiceClient(fakeServer), QueueName).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetStat(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetStatsSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetStatsSuccessfully(t, fakeServer)
 
-	actual, err := queues.GetStats(context.TODO(), fake.ServiceClient(), QueueName).Extract()
+	actual, err := queues.GetStats(context.TODO(), client.ServiceClient(fakeServer), QueueName).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedStats, actual)
 }
 
 func TestShare(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleShareSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleShareSuccessfully(t, fakeServer)
 
 	shareOpts := queues.ShareOpts{
 		Paths:   []queues.SharePath{queues.PathMessages, queues.PathClaims, queues.PathSubscriptions},
@@ -121,20 +121,20 @@ func TestShare(t *testing.T) {
 		Expires: "2016-09-01T00:00:00",
 	}
 
-	actual, err := queues.Share(context.TODO(), fake.ServiceClient(), QueueName, shareOpts).Extract()
+	actual, err := queues.Share(context.TODO(), client.ServiceClient(fakeServer), QueueName, shareOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, ExpectedShare, actual)
 }
 
 func TestPurge(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePurgeSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePurgeSuccessfully(t, fakeServer)
 
 	purgeOpts := queues.PurgeOpts{
 		ResourceTypes: []queues.PurgeResource{queues.ResourceMessages, queues.ResourceSubscriptions},
 	}
 
-	err := queues.Purge(context.TODO(), fake.ServiceClient(), QueueName, purgeOpts).ExtractErr()
+	err := queues.Purge(context.TODO(), client.ServiceClient(fakeServer), QueueName, purgeOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/networking/v2/apiversions/testing/requests_test.go b/openstack/networking/v2/apiversions/testing/requests_test.go
index dbdf61d9f..842b439c4 100644
--- a/openstack/networking/v2/apiversions/testing/requests_test.go
+++ b/openstack/networking/v2/apiversions/testing/requests_test.go
@@ -9,16 +9,16 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/apiversions"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestListVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -42,7 +42,7 @@ func TestListVersions(t *testing.T) {
 
 	count := 0
 
-	err := apiversions.ListVersions(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := apiversions.ListVersions(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := apiversions.ExtractAPIVersions(page)
 		if err != nil {
@@ -69,14 +69,14 @@ func TestListVersions(t *testing.T) {
 }
 
 func TestNonJSONCannotBeExtractedIntoAPIVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 
-	err := apiversions.ListVersions(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := apiversions.ListVersions(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		if _, err := apiversions.ExtractAPIVersions(page); err == nil {
 			t.Fatalf("Expected error, got nil")
 		}
@@ -86,12 +86,12 @@ func TestNonJSONCannotBeExtractedIntoAPIVersions(t *testing.T) {
 }
 
 func TestAPIInfo(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -136,7 +136,7 @@ func TestAPIInfo(t *testing.T) {
 
 	count := 0
 
-	err := apiversions.ListVersionResources(fake.ServiceClient(), "v2.0").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := apiversions.ListVersionResources(client.ServiceClient(fakeServer), "v2.0").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := apiversions.ExtractVersionResources(page)
 		if err != nil {
@@ -171,14 +171,14 @@ func TestAPIInfo(t *testing.T) {
 }
 
 func TestNonJSONCannotBeExtractedIntoAPIVersionResources(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 
-	err := apiversions.ListVersionResources(fake.ServiceClient(), "v2.0").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := apiversions.ListVersionResources(client.ServiceClient(fakeServer), "v2.0").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		if _, err := apiversions.ExtractVersionResources(page); err == nil {
 			t.Fatalf("Expected error, got nil")
 		}
diff --git a/openstack/networking/v2/common/common_tests.go b/openstack/networking/v2/common/common_tests.go
index f32313a10..581c9803a 100644
--- a/openstack/networking/v2/common/common_tests.go
+++ b/openstack/networking/v2/common/common_tests.go
@@ -2,13 +2,14 @@ package common
 
 import (
 	"github.com/gophercloud/gophercloud/v2"
+	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const TokenID = client.TokenID
 
-func ServiceClient() *gophercloud.ServiceClient {
-	sc := client.ServiceClient()
+func ServiceClient(fakeServer th.FakeServer) *gophercloud.ServiceClient {
+	sc := client.ServiceClient(fakeServer)
 	sc.ResourceBase = sc.Endpoint + "v2.0/"
 	return sc
 }
diff --git a/openstack/networking/v2/extensions/agents/testing/requests_test.go b/openstack/networking/v2/extensions/agents/testing/requests_test.go
index 41380edac..e5b5888c4 100644
--- a/openstack/networking/v2/extensions/agents/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/agents/testing/requests_test.go
@@ -15,10 +15,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -30,7 +30,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := agents.List(fake.ServiceClient(), agents.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := agents.List(fake.ServiceClient(fakeServer), agents.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := agents.ExtractAgents(page)
 
@@ -56,10 +56,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -69,7 +69,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, AgentsGetResult)
 	})
 
-	s, err := agents.Get(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a").Extract()
+	s, err := agents.Get(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.ID, "43583cf5-472e-4dc8-af5b-6aed4c94ee3a")
@@ -93,10 +93,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -115,17 +115,17 @@ func TestUpdate(t *testing.T) {
 		Description:  &description,
 		AdminStateUp: &iTrue,
 	}
-	s, err := agents.Update(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", updateOpts).Extract()
+	s, err := agents.Update(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, *s, Agent)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -134,15 +134,15 @@ func TestDelete(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := agents.Delete(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a").ExtractErr()
+	err := agents.Delete(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListDHCPNetworks(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/dhcp-networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/dhcp-networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -152,7 +152,7 @@ func TestListDHCPNetworks(t *testing.T) {
 		fmt.Fprint(w, AgentDHCPNetworksListResult)
 	})
 
-	s, err := agents.ListDHCPNetworks(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a").Extract()
+	s, err := agents.ListDHCPNetworks(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a").Extract()
 	th.AssertNoErr(t, err)
 
 	var nilSlice []string
@@ -171,10 +171,10 @@ func TestListDHCPNetworks(t *testing.T) {
 }
 
 func TestScheduleDHCPNetwork(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/dhcp-networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/dhcp-networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -188,15 +188,15 @@ func TestScheduleDHCPNetwork(t *testing.T) {
 	opts := &agents.ScheduleDHCPNetworkOpts{
 		NetworkID: "1ae075ca-708b-4e66-b4a7-b7698632f05f",
 	}
-	err := agents.ScheduleDHCPNetwork(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", opts).ExtractErr()
+	err := agents.ScheduleDHCPNetwork(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestRemoveDHCPNetwork(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/dhcp-networks/1ae075ca-708b-4e66-b4a7-b7698632f05f", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/dhcp-networks/1ae075ca-708b-4e66-b4a7-b7698632f05f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -205,17 +205,17 @@ func TestRemoveDHCPNetwork(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := agents.RemoveDHCPNetwork(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", "1ae075ca-708b-4e66-b4a7-b7698632f05f").ExtractErr()
+	err := agents.RemoveDHCPNetwork(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", "1ae075ca-708b-4e66-b4a7-b7698632f05f").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListBGPSpeakers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	agentID := "30d76012-46de-4215-aaa1-a1630d01d891"
 
-	th.Mux.HandleFunc("/v2.0/agents/"+agentID+"/bgp-drinstances",
+	fakeServer.Mux.HandleFunc("/v2.0/agents/"+agentID+"/bgp-drinstances",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -227,7 +227,7 @@ func TestListBGPSpeakers(t *testing.T) {
 		})
 
 	count := 0
-	err := agents.ListBGPSpeakers(fake.ServiceClient(), agentID).EachPage(
+	err := agents.ListBGPSpeakers(fake.ServiceClient(fakeServer), agentID).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -248,13 +248,13 @@ func TestListBGPSpeakers(t *testing.T) {
 }
 
 func TestScheduleBGPSpeaker(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	agentID := "30d76012-46de-4215-aaa1-a1630d01d891"
 	speakerID := "8edb2c68-0654-49a9-b3fe-030f92e3ddf6"
 
-	th.Mux.HandleFunc("/v2.0/agents/"+agentID+"/bgp-drinstances",
+	fakeServer.Mux.HandleFunc("/v2.0/agents/"+agentID+"/bgp-drinstances",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "POST")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -268,18 +268,18 @@ func TestScheduleBGPSpeaker(t *testing.T) {
 
 	var opts agents.ScheduleBGPSpeakerOpts
 	opts.SpeakerID = speakerID
-	err := agents.ScheduleBGPSpeaker(context.TODO(), fake.ServiceClient(), agentID, opts).ExtractErr()
+	err := agents.ScheduleBGPSpeaker(context.TODO(), fake.ServiceClient(fakeServer), agentID, opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestRemoveBGPSpeaker(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	agentID := "30d76012-46de-4215-aaa1-a1630d01d891"
 	speakerID := "8edb2c68-0654-49a9-b3fe-030f92e3ddf6"
 
-	th.Mux.HandleFunc("/v2.0/agents/"+agentID+"/bgp-drinstances/"+speakerID,
+	fakeServer.Mux.HandleFunc("/v2.0/agents/"+agentID+"/bgp-drinstances/"+speakerID,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "DELETE")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -289,16 +289,16 @@ func TestRemoveBGPSpeaker(t *testing.T) {
 			w.WriteHeader(http.StatusNoContent)
 		})
 
-	err := agents.RemoveBGPSpeaker(context.TODO(), fake.ServiceClient(), agentID, speakerID).ExtractErr()
+	err := agents.RemoveBGPSpeaker(context.TODO(), fake.ServiceClient(fakeServer), agentID, speakerID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListDRAgentHostingBGPSpeakers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	speakerID := "3f511b1b-d541-45f1-aa98-2e44e8183d4c"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+speakerID+"/bgp-dragents",
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+speakerID+"/bgp-dragents",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -309,7 +309,7 @@ func TestListDRAgentHostingBGPSpeakers(t *testing.T) {
 		})
 
 	count := 0
-	err := agents.ListDRAgentHostingBGPSpeakers(fake.ServiceClient(), speakerID).EachPage(
+	err := agents.ListDRAgentHostingBGPSpeakers(fake.ServiceClient(fakeServer), speakerID).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -332,10 +332,10 @@ func TestListDRAgentHostingBGPSpeakers(t *testing.T) {
 }
 
 func TestListL3Routers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/l3-routers", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/l3-routers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -345,7 +345,7 @@ func TestListL3Routers(t *testing.T) {
 		fmt.Fprint(w, AgentL3RoutersListResult)
 	})
 
-	s, err := agents.ListL3Routers(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a").Extract()
+	s, err := agents.ListL3Routers(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a").Extract()
 	th.AssertNoErr(t, err)
 
 	routes := []routers.Route{
@@ -390,10 +390,10 @@ func TestListL3Routers(t *testing.T) {
 }
 
 func TestScheduleL3Router(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/l3-routers", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/l3-routers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -407,15 +407,15 @@ func TestScheduleL3Router(t *testing.T) {
 	opts := &agents.ScheduleL3RouterOpts{
 		RouterID: "43e66290-79a4-415d-9eb9-7ff7919839e1",
 	}
-	err := agents.ScheduleL3Router(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", opts).ExtractErr()
+	err := agents.ScheduleL3Router(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestRemoveL3Router(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/l3-routers/43e66290-79a4-415d-9eb9-7ff7919839e1", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/agents/43583cf5-472e-4dc8-af5b-6aed4c94ee3a/l3-routers/43e66290-79a4-415d-9eb9-7ff7919839e1", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -424,6 +424,6 @@ func TestRemoveL3Router(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := agents.RemoveL3Router(context.TODO(), fake.ServiceClient(), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", "43e66290-79a4-415d-9eb9-7ff7919839e1").ExtractErr()
+	err := agents.RemoveL3Router(context.TODO(), fake.ServiceClient(fakeServer), "43583cf5-472e-4dc8-af5b-6aed4c94ee3a", "43e66290-79a4-415d-9eb9-7ff7919839e1").ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/networking/v2/extensions/attributestags/testing/requests_test.go b/openstack/networking/v2/extensions/attributestags/testing/requests_test.go
index 5f20bdff5..dc35bd12d 100644
--- a/openstack/networking/v2/extensions/attributestags/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/attributestags/testing/requests_test.go
@@ -12,10 +12,10 @@ import (
 )
 
 func TestReplaceAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/fakeid/tags", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/fakeid/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -31,17 +31,17 @@ func TestReplaceAll(t *testing.T) {
 	opts := attributestags.ReplaceAllOpts{
 		Tags: []string{"abc", "xyz"},
 	}
-	res, err := attributestags.ReplaceAll(context.TODO(), fake.ServiceClient(), "networks", "fakeid", opts).Extract()
+	res, err := attributestags.ReplaceAll(context.TODO(), fake.ServiceClient(fakeServer), "networks", "fakeid", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, res, []string{"abc", "xyz"})
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/fakeid/tags", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/fakeid/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -51,17 +51,17 @@ func TestList(t *testing.T) {
 		fmt.Fprint(w, attributestagsListResult)
 	})
 
-	res, err := attributestags.List(context.TODO(), fake.ServiceClient(), "networks", "fakeid").Extract()
+	res, err := attributestags.List(context.TODO(), fake.ServiceClient(fakeServer), "networks", "fakeid").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, res, []string{"abc", "xyz"})
 }
 
 func TestDeleteAll(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/fakeid/tags", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/fakeid/tags", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -69,15 +69,15 @@ func TestDeleteAll(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := attributestags.DeleteAll(context.TODO(), fake.ServiceClient(), "networks", "fakeid").ExtractErr()
+	err := attributestags.DeleteAll(context.TODO(), fake.ServiceClient(fakeServer), "networks", "fakeid").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestAdd(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/fakeid/tags/atag", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/fakeid/tags/atag", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -85,15 +85,15 @@ func TestAdd(t *testing.T) {
 		w.WriteHeader(http.StatusCreated)
 	})
 
-	err := attributestags.Add(context.TODO(), fake.ServiceClient(), "networks", "fakeid", "atag").ExtractErr()
+	err := attributestags.Add(context.TODO(), fake.ServiceClient(fakeServer), "networks", "fakeid", "atag").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/fakeid/tags/atag", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/fakeid/tags/atag", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -101,15 +101,15 @@ func TestDelete(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := attributestags.Delete(context.TODO(), fake.ServiceClient(), "networks", "fakeid", "atag").ExtractErr()
+	err := attributestags.Delete(context.TODO(), fake.ServiceClient(fakeServer), "networks", "fakeid", "atag").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestConfirmTrue(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/fakeid/tags/atag", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/fakeid/tags/atag", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -117,16 +117,16 @@ func TestConfirmTrue(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	exists, err := attributestags.Confirm(context.TODO(), fake.ServiceClient(), "networks", "fakeid", "atag").Extract()
+	exists, err := attributestags.Confirm(context.TODO(), fake.ServiceClient(fakeServer), "networks", "fakeid", "atag").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, true, exists)
 }
 
 func TestConfirmFalse(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/fakeid/tags/atag", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/fakeid/tags/atag", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -134,6 +134,6 @@ func TestConfirmFalse(t *testing.T) {
 		w.WriteHeader(http.StatusNotFound)
 	})
 
-	exists, _ := attributestags.Confirm(context.TODO(), fake.ServiceClient(), "networks", "fakeid", "atag").Extract()
+	exists, _ := attributestags.Confirm(context.TODO(), fake.ServiceClient(fakeServer), "networks", "fakeid", "atag").Extract()
 	th.AssertEquals(t, false, exists)
 }
diff --git a/openstack/networking/v2/extensions/bgp/peers/testing/requests_test.go b/openstack/networking/v2/extensions/bgp/peers/testing/requests_test.go
index f24a0a1a0..8f4040ba0 100644
--- a/openstack/networking/v2/extensions/bgp/peers/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/bgp/peers/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgp-peers",
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-peers",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -27,7 +27,7 @@ func TestList(t *testing.T) {
 		})
 	count := 0
 
-	err := peers.List(fake.ServiceClient()).EachPage(
+	err := peers.List(fake.ServiceClient(fakeServer)).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -45,11 +45,11 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpPeerID := "afacc0e8-6b66-44e4-be53-a1ef16033ceb"
-	th.Mux.HandleFunc("/v2.0/bgp-peers/"+bgpPeerID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-peers/"+bgpPeerID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -57,16 +57,16 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, GetBGPPeerResult)
 	})
 
-	s, err := peers.Get(context.TODO(), fake.ServiceClient(), bgpPeerID).Extract()
+	s, err := peers.Get(context.TODO(), fake.ServiceClient(fakeServer), bgpPeerID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, *s, BGPPeer1)
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgp-peers", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-peers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -84,7 +84,7 @@ func TestCreate(t *testing.T) {
 	opts.Name = "gophercloud-testing-bgp-peer"
 	opts.PeerIP = "192.168.0.1"
 
-	r, err := peers.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	r, err := peers.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, r.AuthType, opts.AuthType)
 	th.AssertEquals(t, r.RemoteAS, opts.RemoteAS)
@@ -93,10 +93,10 @@ func TestCreate(t *testing.T) {
 
 func TestDelete(t *testing.T) {
 	bgpPeerID := "afacc0e8-6b66-44e4-be53-a1ef16033ceb"
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgp-peers/"+bgpPeerID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-peers/"+bgpPeerID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -105,16 +105,16 @@ func TestDelete(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := peers.Delete(context.TODO(), fake.ServiceClient(), bgpPeerID).ExtractErr()
+	err := peers.Delete(context.TODO(), fake.ServiceClient(fakeServer), bgpPeerID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
 	bgpPeerID := "afacc0e8-6b66-44e4-be53-a1ef16033ceb"
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgp-peers/"+bgpPeerID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-peers/"+bgpPeerID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -131,7 +131,7 @@ func TestUpdate(t *testing.T) {
 	opts.Name = "test-rename-bgp-peer"
 	opts.Password = "superStrong"
 
-	r, err := peers.Update(context.TODO(), fake.ServiceClient(), bgpPeerID, opts).Extract()
+	r, err := peers.Update(context.TODO(), fake.ServiceClient(fakeServer), bgpPeerID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, r.Name, opts.Name)
 }
diff --git a/openstack/networking/v2/extensions/bgp/speakers/testing/requests_test.go b/openstack/networking/v2/extensions/bgp/speakers/testing/requests_test.go
index 0ace6b240..edcf11637 100644
--- a/openstack/networking/v2/extensions/bgp/speakers/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/bgp/speakers/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgp-speakers",
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -27,7 +27,7 @@ func TestList(t *testing.T) {
 		})
 	count := 0
 
-	err := speakers.List(fake.ServiceClient()).EachPage(
+	err := speakers.List(fake.ServiceClient(fakeServer)).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -45,11 +45,11 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -57,16 +57,16 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, GetBGPSpeakerResult)
 	})
 
-	s, err := speakers.Get(context.TODO(), fake.ServiceClient(), bgpSpeakerID).Extract()
+	s, err := speakers.Get(context.TODO(), fake.ServiceClient(fakeServer), bgpSpeakerID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, *s, BGPSpeaker1)
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgp-speakers", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -85,7 +85,7 @@ func TestCreate(t *testing.T) {
 		LocalAS:                       "2000",
 		Networks:                      []string{},
 	}
-	r, err := speakers.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	r, err := speakers.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, r.Name, opts.Name)
 	th.AssertEquals(t, r.LocalAS, 2000)
@@ -96,11 +96,11 @@ func TestCreate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -109,16 +109,16 @@ func TestDelete(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := speakers.Delete(context.TODO(), fake.ServiceClient(), bgpSpeakerID).ExtractErr()
+	err := speakers.Delete(context.TODO(), fake.ServiceClient(fakeServer), bgpSpeakerID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID, func(w http.ResponseWriter, r *http.Request) {
 		if r.Method == "GET" {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -146,7 +146,7 @@ func TestUpdate(t *testing.T) {
 		AdvertiseFloatingIPHostRoutes: true,
 	}
 
-	r, err := speakers.Update(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).Extract()
+	r, err := speakers.Update(context.TODO(), fake.ServiceClient(fakeServer), bgpSpeakerID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, r.Name, opts.Name)
 	th.AssertEquals(t, r.AdvertiseTenantNetworks, opts.AdvertiseTenantNetworks)
@@ -154,12 +154,12 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestAddBGPPeer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
 	bgpPeerID := "f5884c7c-71d5-43a3-88b4-1742e97674aa"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/add_bgp_peer", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/add_bgp_peer", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -172,18 +172,18 @@ func TestAddBGPPeer(t *testing.T) {
 	})
 
 	opts := speakers.AddBGPPeerOpts{BGPPeerID: bgpPeerID}
-	r, err := speakers.AddBGPPeer(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).Extract()
+	r, err := speakers.AddBGPPeer(context.TODO(), fake.ServiceClient(fakeServer), bgpSpeakerID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, bgpPeerID, r.BGPPeerID)
 }
 
 func TestRemoveBGPPeer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
 	bgpPeerID := "f5884c7c-71d5-43a3-88b4-1742e97674aa"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/remove_bgp_peer", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/remove_bgp_peer", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -193,16 +193,16 @@ func TestRemoveBGPPeer(t *testing.T) {
 	})
 
 	opts := speakers.RemoveBGPPeerOpts{BGPPeerID: bgpPeerID}
-	err := speakers.RemoveBGPPeer(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).ExtractErr()
+	err := speakers.RemoveBGPPeer(context.TODO(), fake.ServiceClient(fakeServer), bgpSpeakerID, opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGetAdvertisedRoutes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/get_advertised_routes", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/get_advertised_routes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -211,7 +211,7 @@ func TestGetAdvertisedRoutes(t *testing.T) {
 	})
 
 	count := 0
-	err := speakers.GetAdvertisedRoutes(fake.ServiceClient(), bgpSpeakerID).EachPage(
+	err := speakers.GetAdvertisedRoutes(fake.ServiceClient(fakeServer), bgpSpeakerID).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -235,12 +235,12 @@ func TestGetAdvertisedRoutes(t *testing.T) {
 }
 
 func TestAddGatewayNetwork(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
 	networkID := "ac13bb26-6219-49c3-a880-08847f6830b7"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/add_gateway_network", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/add_gateway_network", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -253,18 +253,18 @@ func TestAddGatewayNetwork(t *testing.T) {
 	})
 
 	opts := speakers.AddGatewayNetworkOpts{NetworkID: networkID}
-	r, err := speakers.AddGatewayNetwork(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).Extract()
+	r, err := speakers.AddGatewayNetwork(context.TODO(), fake.ServiceClient(fakeServer), bgpSpeakerID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, r.NetworkID, networkID)
 }
 
 func TestRemoveGatewayNetwork(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpSpeakerID := "ab01ade1-ae62-43c9-8a1f-3c24225b96d8"
 	networkID := "ac13bb26-6219-49c3-a880-08847f6830b7"
-	th.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/remove_gateway_network", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgp-speakers/"+bgpSpeakerID+"/remove_gateway_network", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -277,6 +277,6 @@ func TestRemoveGatewayNetwork(t *testing.T) {
 	})
 
 	opts := speakers.RemoveGatewayNetworkOpts{NetworkID: networkID}
-	err := speakers.RemoveGatewayNetwork(context.TODO(), fake.ServiceClient(), bgpSpeakerID, opts).ExtractErr()
+	err := speakers.RemoveGatewayNetwork(context.TODO(), fake.ServiceClient(fakeServer), bgpSpeakerID, opts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/networking/v2/extensions/bgpvpns/testing/requests_test.go b/openstack/networking/v2/extensions/bgpvpns/testing/requests_test.go
index aacc57aa9..095fc5056 100644
--- a/openstack/networking/v2/extensions/bgpvpns/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/bgpvpns/testing/requests_test.go
@@ -13,8 +13,8 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	filterProjectID := []string{"b7549121395844bea941bb92feb3fad9"}
 	fields := []string{"id", "name"}
@@ -22,7 +22,7 @@ func TestList(t *testing.T) {
 		Fields:    fields,
 		ProjectID: filterProjectID[0],
 	}
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns",
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -39,7 +39,7 @@ func TestList(t *testing.T) {
 		})
 	count := 0
 
-	err := bgpvpns.List(fake.ServiceClient(), listOpts).EachPage(
+	err := bgpvpns.List(fake.ServiceClient(fakeServer), listOpts).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -58,11 +58,11 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -70,16 +70,16 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, GetBGPVPNResult)
 	})
 
-	r, err := bgpvpns.Get(context.TODO(), fake.ServiceClient(), bgpVpnID).Extract()
+	r, err := bgpvpns.Get(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, GetBGPVPN, *r)
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -110,17 +110,17 @@ func TestCreate(t *testing.T) {
 		VNI:  1000,
 	}
 
-	r, err := bgpvpns.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	r, err := bgpvpns.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, CreateBGPVPN, *r)
 }
 
 func TestDelete(t *testing.T) {
 	bgpVpnID := "0f9d472a-908f-40f5-8574-b4e8a63ccbf0"
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
@@ -129,16 +129,16 @@ func TestDelete(t *testing.T) {
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := bgpvpns.Delete(context.TODO(), fake.ServiceClient(), bgpVpnID).ExtractErr()
+	err := bgpvpns.Delete(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
 	bgpVpnID := "4d627abf-06dd-45ab-920b-8e61422bb984"
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -161,21 +161,21 @@ func TestUpdate(t *testing.T) {
 		ExportTargets: &emptyTarget,
 	}
 
-	r, err := bgpvpns.Update(context.TODO(), fake.ServiceClient(), bgpVpnID, opts).Extract()
+	r, err := bgpvpns.Update(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, *opts.Name, r.Name)
 }
 
 func TestListNetworkAssociations(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	fields := []string{"id", "name"}
 	listOpts := bgpvpns.ListNetworkAssociationsOpts{
 		Fields: fields,
 	}
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/network_associations", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/network_associations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -190,7 +190,7 @@ func TestListNetworkAssociations(t *testing.T) {
 	})
 
 	count := 0
-	err := bgpvpns.ListNetworkAssociations(fake.ServiceClient(), bgpVpnID, listOpts).EachPage(
+	err := bgpvpns.ListNetworkAssociations(fake.ServiceClient(fakeServer), bgpVpnID, listOpts).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -211,11 +211,11 @@ func TestListNetworkAssociations(t *testing.T) {
 }
 
 func TestCreateNetworkAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/network_associations", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/network_associations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -229,18 +229,18 @@ func TestCreateNetworkAssociation(t *testing.T) {
 	opts := bgpvpns.CreateNetworkAssociationOpts{
 		NetworkID: "8c5d88dc-60ac-4b02-a65a-36b65888ddcd",
 	}
-	r, err := bgpvpns.CreateNetworkAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, opts).Extract()
+	r, err := bgpvpns.CreateNetworkAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, CreateNetworkAssociation, *r)
 }
 
 func TestGetNetworkAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	networkAssociationID := "73238ca1-e05d-4c7a-b4d4-70407b4b8730"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/network_associations/"+networkAssociationID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/network_associations/"+networkAssociationID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -248,37 +248,37 @@ func TestGetNetworkAssociation(t *testing.T) {
 		fmt.Fprint(w, GetNetworkAssociationResult)
 	})
 
-	r, err := bgpvpns.GetNetworkAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, networkAssociationID).Extract()
+	r, err := bgpvpns.GetNetworkAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, networkAssociationID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, GetNetworkAssociation, *r)
 }
 
 func TestDeleteNetworkAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	networkAssociationID := "73238ca1-e05d-4c7a-b4d4-70407b4b8730"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/network_associations/"+networkAssociationID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/network_associations/"+networkAssociationID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := bgpvpns.DeleteNetworkAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, networkAssociationID).ExtractErr()
+	err := bgpvpns.DeleteNetworkAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, networkAssociationID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListRouterAssociations(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	fields := []string{"id", "name"}
 	listOpts := bgpvpns.ListRouterAssociationsOpts{
 		Fields: fields,
 	}
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -293,7 +293,7 @@ func TestListRouterAssociations(t *testing.T) {
 	})
 
 	count := 0
-	err := bgpvpns.ListRouterAssociations(fake.ServiceClient(), bgpVpnID, listOpts).EachPage(
+	err := bgpvpns.ListRouterAssociations(fake.ServiceClient(fakeServer), bgpVpnID, listOpts).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -314,11 +314,11 @@ func TestListRouterAssociations(t *testing.T) {
 }
 
 func TestCreateRouterAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -332,18 +332,18 @@ func TestCreateRouterAssociation(t *testing.T) {
 	opts := bgpvpns.CreateRouterAssociationOpts{
 		RouterID: "8c5d88dc-60ac-4b02-a65a-36b65888ddcd",
 	}
-	r, err := bgpvpns.CreateRouterAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, opts).Extract()
+	r, err := bgpvpns.CreateRouterAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, CreateRouterAssociation, *r)
 }
 
 func TestGetRouterAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	routerAssociationID := "73238ca1-e05d-4c7a-b4d4-70407b4b8730"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations/"+routerAssociationID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations/"+routerAssociationID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -351,7 +351,7 @@ func TestGetRouterAssociation(t *testing.T) {
 		fmt.Fprint(w, GetRouterAssociationResult)
 	})
 
-	r, err := bgpvpns.GetRouterAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, routerAssociationID).Extract()
+	r, err := bgpvpns.GetRouterAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, routerAssociationID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, GetRouterAssociation, *r)
 }
@@ -359,10 +359,10 @@ func TestGetRouterAssociation(t *testing.T) {
 func TestUpdateRouterAssociation(t *testing.T) {
 	bgpVpnID := "4d627abf-06dd-45ab-920b-8e61422bb984"
 	routerAssociationID := "73238ca1-e05d-4c7a-b4d4-70407b4b8730"
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations/"+routerAssociationID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations/"+routerAssociationID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -376,37 +376,37 @@ func TestUpdateRouterAssociation(t *testing.T) {
 	opts := bgpvpns.UpdateRouterAssociationOpts{
 		AdvertiseExtraRoutes: new(bool),
 	}
-	r, err := bgpvpns.UpdateRouterAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, routerAssociationID, opts).Extract()
+	r, err := bgpvpns.UpdateRouterAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, routerAssociationID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, UpdateRouterAssociation, *r)
 }
 
 func TestDeleteRouterAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	routerAssociationID := "73238ca1-e05d-4c7a-b4d4-70407b4b8730"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations/"+routerAssociationID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/router_associations/"+routerAssociationID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := bgpvpns.DeleteRouterAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, routerAssociationID).ExtractErr()
+	err := bgpvpns.DeleteRouterAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, routerAssociationID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListPortAssociations(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	fields := []string{"id", "name"}
 	listOpts := bgpvpns.ListPortAssociationsOpts{
 		Fields: fields,
 	}
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -421,7 +421,7 @@ func TestListPortAssociations(t *testing.T) {
 	})
 
 	count := 0
-	err := bgpvpns.ListPortAssociations(fake.ServiceClient(), bgpVpnID, listOpts).EachPage(
+	err := bgpvpns.ListPortAssociations(fake.ServiceClient(fakeServer), bgpVpnID, listOpts).EachPage(
 		context.TODO(),
 		func(_ context.Context, page pagination.Page) (bool, error) {
 			count++
@@ -442,11 +442,11 @@ func TestListPortAssociations(t *testing.T) {
 }
 
 func TestCreatePortAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -460,18 +460,18 @@ func TestCreatePortAssociation(t *testing.T) {
 	opts := bgpvpns.CreatePortAssociationOpts{
 		PortID: "8c5d88dc-60ac-4b02-a65a-36b65888ddcd",
 	}
-	r, err := bgpvpns.CreatePortAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, opts).Extract()
+	r, err := bgpvpns.CreatePortAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, CreatePortAssociation, *r)
 }
 
 func TestGetPortAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	portAssociationID := "73238ca1-e05d-4c7a-b4d4-70407b4b8730"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations/"+portAssociationID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations/"+portAssociationID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -479,7 +479,7 @@ func TestGetPortAssociation(t *testing.T) {
 		fmt.Fprint(w, GetPortAssociationResult)
 	})
 
-	r, err := bgpvpns.GetPortAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, portAssociationID).Extract()
+	r, err := bgpvpns.GetPortAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, portAssociationID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, GetPortAssociation, *r)
 }
@@ -487,10 +487,10 @@ func TestGetPortAssociation(t *testing.T) {
 func TestUpdatePortAssociation(t *testing.T) {
 	bgpVpnID := "4d627abf-06dd-45ab-920b-8e61422bb984"
 	portAssociationID := "73238ca1-e05d-4c7a-b4d4-70407b4b8730"
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations/"+portAssociationID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations/"+portAssociationID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -504,23 +504,23 @@ func TestUpdatePortAssociation(t *testing.T) {
 	opts := bgpvpns.UpdatePortAssociationOpts{
 		AdvertiseFixedIPs: new(bool),
 	}
-	r, err := bgpvpns.UpdatePortAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, portAssociationID, opts).Extract()
+	r, err := bgpvpns.UpdatePortAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, portAssociationID, opts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, UpdatePortAssociation, *r)
 }
 
 func TestDeletePortAssociation(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	bgpVpnID := "460ac411-3dfb-45bb-8116-ed1a7233d143"
 	portAssociationID := "73238ca1-e05d-4c7a-b4d4-70407b4b8730"
-	th.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations/"+portAssociationID, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/bgpvpn/bgpvpns/"+bgpVpnID+"/port_associations/"+portAssociationID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	err := bgpvpns.DeletePortAssociation(context.TODO(), fake.ServiceClient(), bgpVpnID, portAssociationID).ExtractErr()
+	err := bgpvpns.DeletePortAssociation(context.TODO(), fake.ServiceClient(fakeServer), bgpVpnID, portAssociationID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/networking/v2/extensions/dns/testing/fixtures_test.go b/openstack/networking/v2/extensions/dns/testing/fixtures_test.go
index 85679382d..5f3dbd993 100644
--- a/openstack/networking/v2/extensions/dns/testing/fixtures_test.go
+++ b/openstack/networking/v2/extensions/dns/testing/fixtures_test.go
@@ -68,8 +68,8 @@ const NetworkUpdateResponse = `
     }
 }`
 
-func PortHandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+func PortHandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -82,8 +82,8 @@ func PortHandleListSuccessfully(t *testing.T) {
 	})
 }
 
-func PortHandleGet(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
+func PortHandleGet(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -94,8 +94,8 @@ func PortHandleGet(t *testing.T) {
 	})
 }
 
-func PortHandleCreate(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+func PortHandleCreate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -157,8 +157,8 @@ func PortHandleCreate(t *testing.T) {
 	})
 }
 
-func PortHandleUpdate(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+func PortHandleUpdate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -219,8 +219,8 @@ func PortHandleUpdate(t *testing.T) {
 	})
 }
 
-func FloatingIPHandleList(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
+func FloatingIPHandleList(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -233,8 +233,8 @@ func FloatingIPHandleList(t *testing.T) {
 	})
 }
 
-func FloatingIPHandleGet(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/floatingips/2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e", func(w http.ResponseWriter, r *http.Request) {
+func FloatingIPHandleGet(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -245,8 +245,8 @@ func FloatingIPHandleGet(t *testing.T) {
 	})
 }
 
-func FloatingIPHandleCreate(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
+func FloatingIPHandleCreate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -268,8 +268,8 @@ func FloatingIPHandleCreate(t *testing.T) {
 	})
 }
 
-func NetworkHandleList(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+func NetworkHandleList(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -282,8 +282,8 @@ func NetworkHandleList(t *testing.T) {
 	})
 }
 
-func NetworkHandleGet(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+func NetworkHandleGet(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -294,8 +294,8 @@ func NetworkHandleGet(t *testing.T) {
 	})
 }
 
-func NetworkHandleCreate(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+func NetworkHandleCreate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -308,8 +308,8 @@ func NetworkHandleCreate(t *testing.T) {
 	})
 }
 
-func NetworkHandleUpdate(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/networks/db193ab3-96e3-4cb3-8fc5-05f4296d0324", func(w http.ResponseWriter, r *http.Request) {
+func NetworkHandleUpdate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/db193ab3-96e3-4cb3-8fc5-05f4296d0324", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
diff --git a/openstack/networking/v2/extensions/dns/testing/requests_test.go b/openstack/networking/v2/extensions/dns/testing/requests_test.go
index 645edf7d3..886be4489 100644
--- a/openstack/networking/v2/extensions/dns/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/dns/testing/requests_test.go
@@ -32,10 +32,10 @@ var createdTime, _ = time.Parse(time.RFC3339, "2019-06-30T04:15:37Z")
 var updatedTime, _ = time.Parse(time.RFC3339, "2019-06-30T05:18:49Z")
 
 func TestPortList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	PortHandleListSuccessfully(t)
+	PortHandleListSuccessfully(t, fakeServer)
 
 	var actual []PortDNS
 
@@ -79,7 +79,7 @@ func TestPortList(t *testing.T) {
 		DNSName:         "test-port",
 	}
 
-	allPages, err := ports.List(fake.ServiceClient(), listOptsBuilder).AllPages(context.TODO())
+	allPages, err := ports.List(fake.ServiceClient(fakeServer), listOptsBuilder).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	err = ports.ExtractPortsInto(allPages, &actual)
@@ -89,14 +89,14 @@ func TestPortList(t *testing.T) {
 }
 
 func TestPortGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	PortHandleGet(t)
+	PortHandleGet(t, fakeServer)
 
 	var s PortDNS
 
-	err := ports.Get(context.TODO(), fake.ServiceClient(), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").ExtractInto(&s)
+	err := ports.Get(context.TODO(), fake.ServiceClient(fakeServer), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, "ACTIVE")
@@ -124,10 +124,10 @@ func TestPortGet(t *testing.T) {
 }
 
 func TestPortCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	PortHandleCreate(t)
+	PortHandleCreate(t, fakeServer)
 
 	var s PortDNS
 
@@ -147,7 +147,7 @@ func TestPortCreate(t *testing.T) {
 		DNSName:           "test-port",
 	}
 
-	err := ports.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractInto(&s)
+	err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), createOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, "DOWN")
@@ -174,17 +174,20 @@ func TestPortCreate(t *testing.T) {
 }
 
 func TestPortRequiredCreateOpts(t *testing.T) {
-	res := ports.Create(context.TODO(), fake.ServiceClient(), dns.PortCreateOptsExt{CreateOptsBuilder: ports.CreateOpts{}})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), dns.PortCreateOptsExt{CreateOptsBuilder: ports.CreateOpts{}})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestPortUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	PortHandleUpdate(t)
+	PortHandleUpdate(t, fakeServer)
 
 	var s PortDNS
 
@@ -203,7 +206,7 @@ func TestPortUpdate(t *testing.T) {
 		DNSName:           &dnsName,
 	}
 
-	err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&s)
+	err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "new_port_name")
@@ -222,13 +225,13 @@ func TestPortUpdate(t *testing.T) {
 }
 
 func TestFloatingIPGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	FloatingIPHandleGet(t)
+	FloatingIPHandleGet(t, fakeServer)
 
 	var actual FloatingIPDNS
-	err := floatingips.Get(context.TODO(), fake.ServiceClient(), "2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e").ExtractInto(&actual)
+	err := floatingips.Get(context.TODO(), fake.ServiceClient(fakeServer), "2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e").ExtractInto(&actual)
 	th.AssertNoErr(t, err)
 
 	expected := FloatingIPDNS{
@@ -254,10 +257,10 @@ func TestFloatingIPGet(t *testing.T) {
 }
 
 func TestFloatingIPCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	FloatingIPHandleCreate(t)
+	FloatingIPHandleCreate(t, fakeServer)
 
 	var actual FloatingIPDNS
 
@@ -271,7 +274,7 @@ func TestFloatingIPCreate(t *testing.T) {
 		DNSDomain:         "local.",
 	}
 
-	err := floatingips.Create(context.TODO(), fake.ServiceClient(), options).ExtractInto(&actual)
+	err := floatingips.Create(context.TODO(), fake.ServiceClient(fakeServer), options).ExtractInto(&actual)
 	th.AssertNoErr(t, err)
 
 	expected := FloatingIPDNS{
@@ -297,14 +300,14 @@ func TestFloatingIPCreate(t *testing.T) {
 }
 
 func TestNetworkGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	NetworkHandleGet(t)
+	NetworkHandleGet(t, fakeServer)
 
 	var actual NetworkDNS
 
-	err := networks.Get(context.TODO(), fake.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&actual)
+	err := networks.Get(context.TODO(), fake.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&actual)
 	th.AssertNoErr(t, err)
 
 	expected := NetworkDNS{
@@ -328,10 +331,10 @@ func TestNetworkGet(t *testing.T) {
 }
 
 func TestNetworkCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	NetworkHandleCreate(t)
+	NetworkHandleCreate(t, fakeServer)
 
 	var actual NetworkDNS
 
@@ -342,7 +345,7 @@ func TestNetworkCreate(t *testing.T) {
 		DNSDomain:         "local.",
 	}
 
-	err := networks.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractInto(&actual)
+	err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), createOpts).ExtractInto(&actual)
 	th.AssertNoErr(t, err)
 
 	expected := NetworkDNS{
@@ -366,10 +369,10 @@ func TestNetworkCreate(t *testing.T) {
 }
 
 func TestNetworkUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	NetworkHandleUpdate(t)
+	NetworkHandleUpdate(t, fakeServer)
 
 	var actual NetworkDNS
 
@@ -380,7 +383,7 @@ func TestNetworkUpdate(t *testing.T) {
 		DNSDomain:         new(string),
 	}
 
-	err := networks.Update(context.TODO(), fake.ServiceClient(), "db193ab3-96e3-4cb3-8fc5-05f4296d0324", updateOpts).ExtractInto(&actual)
+	err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "db193ab3-96e3-4cb3-8fc5-05f4296d0324", updateOpts).ExtractInto(&actual)
 	th.AssertNoErr(t, err)
 
 	expected := NetworkDNS{
diff --git a/openstack/networking/v2/extensions/external/testing/results_test.go b/openstack/networking/v2/extensions/external/testing/results_test.go
index bf5c02d63..8de68e70e 100644
--- a/openstack/networking/v2/extensions/external/testing/results_test.go
+++ b/openstack/networking/v2/extensions/external/testing/results_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -33,7 +33,7 @@ func TestList(t *testing.T) {
 	}
 	var actual []NetworkWithExternalExt
 
-	allPages, err := networks.List(fake.ServiceClient(), networks.ListOpts{}).AllPages(context.TODO())
+	allPages, err := networks.List(fake.ServiceClient(fakeServer), networks.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	err = networks.ExtractNetworksInto(allPages, &actual)
@@ -44,10 +44,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -62,7 +62,7 @@ func TestGet(t *testing.T) {
 		external.NetworkExternalExt
 	}
 
-	err := networks.Get(context.TODO(), fake.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&s)
+	err := networks.Get(context.TODO(), fake.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "d32019d3-bc6e-4319-9c1d-6722fc136a22", s.ID)
@@ -70,10 +70,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -98,17 +98,17 @@ func TestCreate(t *testing.T) {
 		External:          &iFalse,
 	}
 
-	_, err := networks.Create(context.TODO(), fake.ServiceClient(), externalCreateOpts).Extract()
+	_, err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), externalCreateOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -135,6 +135,6 @@ func TestUpdate(t *testing.T) {
 		External:          &iFalse,
 	}
 
-	_, err := networks.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", externalUpdateOpts).Extract()
+	_, err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", externalUpdateOpts).Extract()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/networking/v2/extensions/fwaas_v2/groups/testing/requests_test.go b/openstack/networking/v2/extensions/fwaas_v2/groups/testing/requests_test.go
index 540f80aaf..2e903b647 100644
--- a/openstack/networking/v2/extensions/fwaas_v2/groups/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/fwaas_v2/groups/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_groups", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -68,7 +68,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := groups.List(fake.ServiceClient(), groups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := groups.List(fake.ServiceClient(fakeServer), groups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := groups.ExtractGroups(page)
 		if err != nil {
@@ -126,10 +126,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/6bfb0f10-07f7-4a40-b534-bad4b4ca3428", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/6bfb0f10-07f7-4a40-b534-bad4b4ca3428", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -157,7 +157,7 @@ func TestGet(t *testing.T) {
         `)
 	})
 
-	group, err := groups.Get(context.TODO(), fake.ServiceClient(), "6bfb0f10-07f7-4a40-b534-bad4b4ca3428").Extract()
+	group, err := groups.Get(context.TODO(), fake.ServiceClient(fakeServer), "6bfb0f10-07f7-4a40-b534-bad4b4ca3428").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "6bfb0f10-07f7-4a40-b534-bad4b4ca3428", group.ID)
@@ -175,10 +175,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_groups", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -230,15 +230,15 @@ func TestCreate(t *testing.T) {
 		},
 	}
 
-	_, err := groups.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	_, err := groups.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/6bfb0f10-07f7-4a40-b534-bad4b4ca3428", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/6bfb0f10-07f7-4a40-b534-bad4b4ca3428", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -295,15 +295,15 @@ func TestUpdate(t *testing.T) {
 		AdminStateUp: &adminStateUp,
 	}
 
-	_, err := groups.Update(context.TODO(), fake.ServiceClient(), "6bfb0f10-07f7-4a40-b534-bad4b4ca3428", options).Extract()
+	_, err := groups.Update(context.TODO(), fake.ServiceClient(fakeServer), "6bfb0f10-07f7-4a40-b534-bad4b4ca3428", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestRemoveIngressPolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/6bfb0f10-07f7-4a40-b534-bad4b4ca3428", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/6bfb0f10-07f7-4a40-b534-bad4b4ca3428", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -341,17 +341,17 @@ func TestRemoveIngressPolicy(t *testing.T) {
     `)
 	})
 
-	removeIngressPolicy, err := groups.RemoveIngressPolicy(context.TODO(), fake.ServiceClient(), "6bfb0f10-07f7-4a40-b534-bad4b4ca3428").Extract()
+	removeIngressPolicy, err := groups.RemoveIngressPolicy(context.TODO(), fake.ServiceClient(fakeServer), "6bfb0f10-07f7-4a40-b534-bad4b4ca3428").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, removeIngressPolicy.IngressFirewallPolicyID, "")
 	th.AssertEquals(t, removeIngressPolicy.EgressFirewallPolicyID, "43a11f3a-ddac-4129-9469-02b9df26548e")
 }
 
 func TestRemoveEgressPolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/6bfb0f10-07f7-4a40-b534-bad4b4ca3428", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/6bfb0f10-07f7-4a40-b534-bad4b4ca3428", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -389,22 +389,22 @@ func TestRemoveEgressPolicy(t *testing.T) {
     `)
 	})
 
-	removeEgressPolicy, err := groups.RemoveEgressPolicy(context.TODO(), fake.ServiceClient(), "6bfb0f10-07f7-4a40-b534-bad4b4ca3428").Extract()
+	removeEgressPolicy, err := groups.RemoveEgressPolicy(context.TODO(), fake.ServiceClient(fakeServer), "6bfb0f10-07f7-4a40-b534-bad4b4ca3428").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, removeEgressPolicy.IngressFirewallPolicyID, "e3f11142-3792-454b-8d3e-91ac1bf127b4")
 	th.AssertEquals(t, removeEgressPolicy.EgressFirewallPolicyID, "")
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/4ec89077-d057-4a2b-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_groups/4ec89077-d057-4a2b-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := groups.Delete(context.TODO(), fake.ServiceClient(), "4ec89077-d057-4a2b-911f-60a3b47ee304")
+	res := groups.Delete(context.TODO(), fake.ServiceClient(fakeServer), "4ec89077-d057-4a2b-911f-60a3b47ee304")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/fwaas_v2/policies/testing/requests_test.go b/openstack/networking/v2/extensions/fwaas_v2/policies/testing/requests_test.go
index 217c062f4..6fb831821 100644
--- a/openstack/networking/v2/extensions/fwaas_v2/policies/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/fwaas_v2/policies/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_policies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -59,7 +59,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := policies.List(fake.ServiceClient(), policies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := policies.List(fake.ServiceClient(fakeServer), policies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := policies.ExtractPolicies(page)
 		if err != nil {
@@ -107,10 +107,10 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_policies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -166,15 +166,15 @@ func TestCreate(t *testing.T) {
 		},
 	}
 
-	_, err := policies.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	_, err := policies.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestInsertRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/e3c78ab6-e827-4297-8d68-739063865a8b/insert_rule", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/e3c78ab6-e827-4297-8d68-739063865a8b/insert_rule", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -211,7 +211,7 @@ func TestInsertRule(t *testing.T) {
 		InsertBefore: "3062ed90-1fb0-4c25-af3d-318dff2143ae",
 	}
 
-	policy, err := policies.InsertRule(context.TODO(), fake.ServiceClient(), "e3c78ab6-e827-4297-8d68-739063865a8b", options).Extract()
+	policy, err := policies.InsertRule(context.TODO(), fake.ServiceClient(fakeServer), "e3c78ab6-e827-4297-8d68-739063865a8b", options).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, "TESTACC-2LnMayeG", policy.Name)
 	th.AssertEquals(t, 2, len(policy.Rules))
@@ -224,8 +224,8 @@ func TestInsertRule(t *testing.T) {
 }
 
 func TestInsertRuleWithInvalidParameters(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	//invalid opts, its not allowed to specify InsertBefore and InsertAfter together
 	options := policies.InsertRuleOpts{
@@ -234,7 +234,7 @@ func TestInsertRuleWithInvalidParameters(t *testing.T) {
 		InsertAfter:  "2",
 	}
 
-	_, err := policies.InsertRule(context.TODO(), fake.ServiceClient(), "0", options).Extract()
+	_, err := policies.InsertRule(context.TODO(), fake.ServiceClient(fakeServer), "0", options).Extract()
 
 	// expect to fail with an gophercloud error
 	th.AssertErr(t, err)
@@ -242,10 +242,10 @@ func TestInsertRuleWithInvalidParameters(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/f2b08c1e-aa81-4668-8ae1-1401bcb0576c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/f2b08c1e-aa81-4668-8ae1-1401bcb0576c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -271,7 +271,7 @@ func TestGet(t *testing.T) {
         `)
 	})
 
-	policy, err := policies.Get(context.TODO(), fake.ServiceClient(), "f2b08c1e-aa81-4668-8ae1-1401bcb0576c").Extract()
+	policy, err := policies.Get(context.TODO(), fake.ServiceClient(fakeServer), "f2b08c1e-aa81-4668-8ae1-1401bcb0576c").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "www", policy.Name)
@@ -286,10 +286,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/f2b08c1e-aa81-4668-8ae1-1401bcb0576c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/f2b08c1e-aa81-4668-8ae1-1401bcb0576c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -341,29 +341,29 @@ func TestUpdate(t *testing.T) {
 		},
 	}
 
-	_, err := policies.Update(context.TODO(), fake.ServiceClient(), "f2b08c1e-aa81-4668-8ae1-1401bcb0576c", options).Extract()
+	_, err := policies.Update(context.TODO(), fake.ServiceClient(fakeServer), "f2b08c1e-aa81-4668-8ae1-1401bcb0576c", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/4ec89077-d057-4a2b-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/4ec89077-d057-4a2b-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := policies.Delete(context.TODO(), fake.ServiceClient(), "4ec89077-d057-4a2b-911f-60a3b47ee304")
+	res := policies.Delete(context.TODO(), fake.ServiceClient(fakeServer), "4ec89077-d057-4a2b-911f-60a3b47ee304")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestRemoveRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/9fed8075-06ee-463f-83a6-d4118791b02f/remove_rule", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_policies/9fed8075-06ee-463f-83a6-d4118791b02f/remove_rule", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -393,7 +393,7 @@ func TestRemoveRule(t *testing.T) {
     `)
 	})
 
-	policy, err := policies.RemoveRule(context.TODO(), fake.ServiceClient(), "9fed8075-06ee-463f-83a6-d4118791b02f", "9fed8075-06ee-463f-83a6-d4118791b02f").Extract()
+	policy, err := policies.RemoveRule(context.TODO(), fake.ServiceClient(fakeServer), "9fed8075-06ee-463f-83a6-d4118791b02f", "9fed8075-06ee-463f-83a6-d4118791b02f").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, "9fed8075-06ee-463f-83a6-d4118791b02f", policy.ID)
 
diff --git a/openstack/networking/v2/extensions/fwaas_v2/rules/testing/requests_test.go b/openstack/networking/v2/extensions/fwaas_v2/rules/testing/requests_test.go
index f251c563c..78419e4b8 100644
--- a/openstack/networking/v2/extensions/fwaas_v2/rules/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/fwaas_v2/rules/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -68,7 +68,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := rules.List(fake.ServiceClient(), rules.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := rules.List(fake.ServiceClient(fakeServer), rules.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := rules.ExtractRules(page)
 		if err != nil {
@@ -124,10 +124,10 @@ func TestList(t *testing.T) {
 	}
 }
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -185,15 +185,15 @@ func TestCreate(t *testing.T) {
 		Action:               "allow",
 	}
 
-	_, err := rules.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	_, err := rules.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestCreateAnyProtocol(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -249,15 +249,15 @@ func TestCreateAnyProtocol(t *testing.T) {
 		Action:               "allow",
 	}
 
-	_, err := rules.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	_, err := rules.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_rules/f03bd950-6c56-4f5e-a307-45967078f507", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_rules/f03bd950-6c56-4f5e-a307-45967078f507", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -288,7 +288,7 @@ func TestGet(t *testing.T) {
         `)
 	})
 
-	rule, err := rules.Get(context.TODO(), fake.ServiceClient(), "f03bd950-6c56-4f5e-a307-45967078f507").Extract()
+	rule, err := rules.Get(context.TODO(), fake.ServiceClient(fakeServer), "f03bd950-6c56-4f5e-a307-45967078f507").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "tcp", rule.Protocol)
@@ -308,10 +308,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_rules/f03bd950-6c56-4f5e-a307-45967078f507", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_rules/f03bd950-6c56-4f5e-a307-45967078f507", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -372,20 +372,20 @@ func TestUpdate(t *testing.T) {
 		Enabled:              gophercloud.Disabled,
 	}
 
-	_, err := rules.Update(context.TODO(), fake.ServiceClient(), "f03bd950-6c56-4f5e-a307-45967078f507", options).Extract()
+	_, err := rules.Update(context.TODO(), fake.ServiceClient(fakeServer), "f03bd950-6c56-4f5e-a307-45967078f507", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/fwaas/firewall_rules/4ec89077-d057-4a2b-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/fwaas/firewall_rules/4ec89077-d057-4a2b-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := rules.Delete(context.TODO(), fake.ServiceClient(), "4ec89077-d057-4a2b-911f-60a3b47ee304")
+	res := rules.Delete(context.TODO(), fake.ServiceClient(fakeServer), "4ec89077-d057-4a2b-911f-60a3b47ee304")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/layer3/addressscopes/testing/requests_test.go b/openstack/networking/v2/extensions/layer3/addressscopes/testing/requests_test.go
index 815a0c0f0..10738657b 100644
--- a/openstack/networking/v2/extensions/layer3/addressscopes/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/layer3/addressscopes/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/address-scopes", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/address-scopes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -28,7 +28,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := addressscopes.List(fake.ServiceClient(), addressscopes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := addressscopes.List(fake.ServiceClient(fakeServer), addressscopes.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := addressscopes.ExtractAddressScopes(page)
 		if err != nil {
@@ -53,10 +53,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/address-scopes/9cc35860-522a-4d35-974d-51d4b011801e", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/address-scopes/9cc35860-522a-4d35-974d-51d4b011801e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -66,7 +66,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, AddressScopesGetResult)
 	})
 
-	s, err := addressscopes.Get(context.TODO(), fake.ServiceClient(), "9cc35860-522a-4d35-974d-51d4b011801e").Extract()
+	s, err := addressscopes.Get(context.TODO(), fake.ServiceClient(fakeServer), "9cc35860-522a-4d35-974d-51d4b011801e").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.ID, "9cc35860-522a-4d35-974d-51d4b011801e")
@@ -78,10 +78,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/address-scopes", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/address-scopes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -99,7 +99,7 @@ func TestCreate(t *testing.T) {
 		Shared:    true,
 		Name:      "test0",
 	}
-	s, err := addressscopes.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	s, err := addressscopes.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "test0")
@@ -111,10 +111,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/address-scopes/9cc35860-522a-4d35-974d-51d4b011801e", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/address-scopes/9cc35860-522a-4d35-974d-51d4b011801e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -133,7 +133,7 @@ func TestUpdate(t *testing.T) {
 		Name:   &newName,
 		Shared: &shared,
 	}
-	s, err := addressscopes.Update(context.TODO(), fake.ServiceClient(), "9cc35860-522a-4d35-974d-51d4b011801e", updateOpts).Extract()
+	s, err := addressscopes.Update(context.TODO(), fake.ServiceClient(fakeServer), "9cc35860-522a-4d35-974d-51d4b011801e", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "test1")
@@ -141,15 +141,15 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/address-scopes/9cc35860-522a-4d35-974d-51d4b011801e", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/address-scopes/9cc35860-522a-4d35-974d-51d4b011801e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := addressscopes.Delete(context.TODO(), fake.ServiceClient(), "9cc35860-522a-4d35-974d-51d4b011801e")
+	res := addressscopes.Delete(context.TODO(), fake.ServiceClient(fakeServer), "9cc35860-522a-4d35-974d-51d4b011801e")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/layer3/extraroutes/testing/requests_test.go b/openstack/networking/v2/extensions/layer3/extraroutes/testing/requests_test.go
index 35d7516e1..ec1676290 100644
--- a/openstack/networking/v2/extensions/layer3/extraroutes/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/layer3/extraroutes/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestAddExtraRoutes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c/add_extraroutes", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c/add_extraroutes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -63,7 +63,7 @@ func TestAddExtraRoutes(t *testing.T) {
 	}
 	options := extraroutes.Opts{Routes: &r}
 
-	n, err := extraroutes.Add(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
+	n, err := extraroutes.Add(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, n.Routes, []routers.Route{
@@ -87,10 +87,10 @@ func TestAddExtraRoutes(t *testing.T) {
 }
 
 func TestRemoveExtraRoutes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c/remove_extraroutes", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c/remove_extraroutes", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -135,7 +135,7 @@ func TestRemoveExtraRoutes(t *testing.T) {
 	}
 	options := extraroutes.Opts{Routes: &r}
 
-	n, err := extraroutes.Remove(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
+	n, err := extraroutes.Remove(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, n.Routes, []routers.Route{
diff --git a/openstack/networking/v2/extensions/layer3/floatingips/testing/requests_test.go b/openstack/networking/v2/extensions/layer3/floatingips/testing/requests_test.go
index 40f5054b9..4447b04ad 100644
--- a/openstack/networking/v2/extensions/layer3/floatingips/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/layer3/floatingips/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -29,7 +29,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := floatingips.List(fake.ServiceClient(), floatingips.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := floatingips.List(fake.ServiceClient(fakeServer), floatingips.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := floatingips.ExtractFloatingIPs(page)
 		if err != nil {
@@ -82,16 +82,16 @@ func TestList(t *testing.T) {
 }
 
 func TestInvalidNextPageURLs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `{"floatingips": [{}], "floatingips_links": {}}`)
 	})
 
-	err := floatingips.List(fake.ServiceClient(), floatingips.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := floatingips.List(fake.ServiceClient(fakeServer), floatingips.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		_, err := floatingips.ExtractFloatingIPs(page)
 		if err != nil {
 			return false, err
@@ -101,23 +101,26 @@ func TestInvalidNextPageURLs(t *testing.T) {
 	th.AssertErr(t, err)
 }
 
-func TestRequiredFieldsForCreate(t *testing.T) {
-	res1 := floatingips.Create(context.TODO(), fake.ServiceClient(), floatingips.CreateOpts{FloatingNetworkID: ""})
+func TestRequiredCreateOpts(t *testing.T) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res1 := floatingips.Create(context.TODO(), fake.ServiceClient(fakeServer), floatingips.CreateOpts{FloatingNetworkID: ""})
 	if res1.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 
-	res2 := floatingips.Create(context.TODO(), fake.ServiceClient(), floatingips.CreateOpts{FloatingNetworkID: "foo", PortID: ""})
+	res2 := floatingips.Create(context.TODO(), fake.ServiceClient(fakeServer), floatingips.CreateOpts{FloatingNetworkID: "foo", PortID: ""})
 	if res2.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -156,7 +159,7 @@ func TestCreate(t *testing.T) {
 		PortID:            "ce705c24-c1ef-408a-bda3-7bbd946164ab",
 	}
 
-	ip, err := floatingips.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	ip, err := floatingips.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "2f245a7b-796b-4f26-9cf9-9e82d248fda7", ip.ID)
@@ -170,10 +173,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestCreateEmptyPort(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -209,7 +212,7 @@ func TestCreateEmptyPort(t *testing.T) {
 		FloatingNetworkID: "376da547-b977-4cfe-9cba-275c80debf57",
 	}
 
-	ip, err := floatingips.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	ip, err := floatingips.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "2f245a7b-796b-4f26-9cf9-9e82d248fda7", ip.ID)
@@ -223,10 +226,10 @@ func TestCreateEmptyPort(t *testing.T) {
 }
 
 func TestCreateWithSubnetID(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -265,7 +268,7 @@ func TestCreateWithSubnetID(t *testing.T) {
 		SubnetID:          "37adf01c-24db-467a-b845-7ab1e8216c01",
 	}
 
-	ip, err := floatingips.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	ip, err := floatingips.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "2f245a7b-796b-4f26-9cf9-9e82d248fda7", ip.ID)
@@ -279,10 +282,10 @@ func TestCreateWithSubnetID(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -307,7 +310,7 @@ func TestGet(t *testing.T) {
       `)
 	})
 
-	ip, err := floatingips.Get(context.TODO(), fake.ServiceClient(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7").Extract()
+	ip, err := floatingips.Get(context.TODO(), fake.ServiceClient(fakeServer), "2f245a7b-796b-4f26-9cf9-9e82d248fda7").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "90f742b1-6d17-487b-ba95-71881dbc0b64", ip.FloatingNetworkID)
@@ -323,10 +326,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestAssociate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -358,17 +361,17 @@ func TestAssociate(t *testing.T) {
 	})
 
 	portID := "423abc8d-2991-4a55-ba98-2aaea84cc72e"
-	ip, err := floatingips.Update(context.TODO(), fake.ServiceClient(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", floatingips.UpdateOpts{PortID: &portID}).Extract()
+	ip, err := floatingips.Update(context.TODO(), fake.ServiceClient(fakeServer), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", floatingips.UpdateOpts{PortID: &portID}).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, portID, ip.PortID)
 }
 
 func TestDisassociate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -399,7 +402,7 @@ func TestDisassociate(t *testing.T) {
     `)
 	})
 
-	ip, err := floatingips.Update(context.TODO(), fake.ServiceClient(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", floatingips.UpdateOpts{PortID: new(string)}).Extract()
+	ip, err := floatingips.Update(context.TODO(), fake.ServiceClient(fakeServer), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", floatingips.UpdateOpts{PortID: new(string)}).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, "", ip.FixedIP)
@@ -407,15 +410,15 @@ func TestDisassociate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := floatingips.Delete(context.TODO(), fake.ServiceClient(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7")
+	res := floatingips.Delete(context.TODO(), fake.ServiceClient(fakeServer), "2f245a7b-796b-4f26-9cf9-9e82d248fda7")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/layer3/portforwarding/testing/requests_test.go b/openstack/networking/v2/extensions/layer3/portforwarding/testing/requests_test.go
index dc2aa8c49..57f7fce6c 100644
--- a/openstack/networking/v2/extensions/layer3/portforwarding/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/layer3/portforwarding/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestPortForwardingList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e/port_forwardings", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e/port_forwardings", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -28,7 +28,7 @@ func TestPortForwardingList(t *testing.T) {
 
 	count := 0
 
-	err := portforwarding.List(fake.ServiceClient(), portforwarding.ListOpts{}, "2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := portforwarding.List(fake.ServiceClient(fakeServer), portforwarding.ListOpts{}, "2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e").EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := portforwarding.ExtractPortForwardings(page)
 		if err != nil {
@@ -67,10 +67,10 @@ func TestPortForwardingList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e/port_forwardings", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e/port_forwardings", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -112,7 +112,7 @@ func TestCreate(t *testing.T) {
 		InternalPortID:    "1238be08-a2a8-4b8d-addf-fb5e2250e480",
 	}
 
-	pf, err := portforwarding.Create(context.TODO(), fake.ServiceClient(), "2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e", options).Extract()
+	pf, err := portforwarding.Create(context.TODO(), fake.ServiceClient(fakeServer), "2f95fd2b-9f6a-4e8e-9e9a-2cbe286cbf9e", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "725ade3c-9760-4880-8080-8fc2dbab9acc", pf.ID)
@@ -124,10 +124,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7/port_forwardings/725ade3c-9760-4880-8080-8fc2dbab9acc", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7/port_forwardings/725ade3c-9760-4880-8080-8fc2dbab9acc", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -148,7 +148,7 @@ func TestGet(t *testing.T) {
       `)
 	})
 
-	pf, err := portforwarding.Get(context.TODO(), fake.ServiceClient(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", "725ade3c-9760-4880-8080-8fc2dbab9acc").Extract()
+	pf, err := portforwarding.Get(context.TODO(), fake.ServiceClient(fakeServer), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", "725ade3c-9760-4880-8080-8fc2dbab9acc").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "tcp", pf.Protocol)
@@ -160,24 +160,24 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7/port_forwardings/725ade3c-9760-4880-8080-8fc2dbab9acc", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7/port_forwardings/725ade3c-9760-4880-8080-8fc2dbab9acc", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := portforwarding.Delete(context.TODO(), fake.ServiceClient(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", "725ade3c-9760-4880-8080-8fc2dbab9acc")
+	res := portforwarding.Delete(context.TODO(), fake.ServiceClient(fakeServer), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", "725ade3c-9760-4880-8080-8fc2dbab9acc")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7/port_forwardings/725ade3c-9760-4880-8080-8fc2dbab9acc", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/floatingips/2f245a7b-796b-4f26-9cf9-9e82d248fda7/port_forwardings/725ade3c-9760-4880-8080-8fc2dbab9acc", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -221,7 +221,7 @@ func TestUpdate(t *testing.T) {
 		ExternalPort:   updatedExternalPort,
 	}
 
-	actual, err := portforwarding.Update(context.TODO(), fake.ServiceClient(), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", "725ade3c-9760-4880-8080-8fc2dbab9acc", options).Extract()
+	actual, err := portforwarding.Update(context.TODO(), fake.ServiceClient(fakeServer), "2f245a7b-796b-4f26-9cf9-9e82d248fda7", "725ade3c-9760-4880-8080-8fc2dbab9acc", options).Extract()
 	th.AssertNoErr(t, err)
 	expected := portforwarding.PortForwarding{
 		Protocol:          "udp",
diff --git a/openstack/networking/v2/extensions/layer3/routers/testing/requests_test.go b/openstack/networking/v2/extensions/layer3/routers/testing/requests_test.go
index 6ff124236..f66dda4e0 100644
--- a/openstack/networking/v2/extensions/layer3/routers/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/layer3/routers/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -70,7 +70,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := routers.List(fake.ServiceClient(), routers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := routers.List(fake.ServiceClient(fakeServer), routers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := routers.ExtractRouters(page)
 		if err != nil {
@@ -127,10 +127,10 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -199,7 +199,7 @@ func TestCreate(t *testing.T) {
 		GatewayInfo:           &gwi,
 		AvailabilityZoneHints: []string{"zone1", "zone2"},
 	}
-	r, err := routers.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	r, err := routers.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	gwi.ExternalFixedIPs = []routers.ExternalFixedIP{{
@@ -214,10 +214,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/a07eea83-7710-4860-931b-5fe220fae533", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/a07eea83-7710-4860-931b-5fe220fae533", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -252,7 +252,7 @@ func TestGet(t *testing.T) {
 			`)
 	})
 
-	n, err := routers.Get(context.TODO(), fake.ServiceClient(), "a07eea83-7710-4860-931b-5fe220fae533").Extract()
+	n, err := routers.Get(context.TODO(), fake.ServiceClient(fakeServer), "a07eea83-7710-4860-931b-5fe220fae533").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "ACTIVE")
@@ -272,10 +272,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -335,7 +335,7 @@ func TestUpdate(t *testing.T) {
 	r := []routers.Route{{DestinationCIDR: "40.0.1.0/24", NextHop: "10.1.0.10"}}
 	options := routers.UpdateOpts{Name: "new_name", GatewayInfo: &gwi, Routes: &r}
 
-	n, err := routers.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
+	n, err := routers.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	gwi.ExternalFixedIPs = []routers.ExternalFixedIP{
@@ -348,10 +348,10 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestUpdateWithoutRoutes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -395,7 +395,7 @@ func TestUpdateWithoutRoutes(t *testing.T) {
 
 	options := routers.UpdateOpts{Name: "new_name"}
 
-	n, err := routers.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
+	n, err := routers.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Name, "new_name")
@@ -403,10 +403,10 @@ func TestUpdateWithoutRoutes(t *testing.T) {
 }
 
 func TestAllRoutesRemoved(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -443,31 +443,31 @@ func TestAllRoutesRemoved(t *testing.T) {
 	r := []routers.Route{}
 	options := routers.UpdateOpts{Routes: &r}
 
-	n, err := routers.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
+	n, err := routers.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, n.Routes, []routers.Route{})
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := routers.Delete(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c")
+	res := routers.Delete(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestAddInterface(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c/add_router_interface", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c/add_router_interface", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -492,7 +492,7 @@ func TestAddInterface(t *testing.T) {
 	})
 
 	opts := routers.AddInterfaceOpts{SubnetID: "a2f1f29d-571b-4533-907f-5803ab96ead1"}
-	res, err := routers.AddInterface(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", opts).Extract()
+	res, err := routers.AddInterface(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "0d32a837-8069-4ec3-84c4-3eef3e10b188", res.SubnetID)
@@ -502,21 +502,24 @@ func TestAddInterface(t *testing.T) {
 }
 
 func TestAddInterfaceRequiredOpts(t *testing.T) {
-	_, err := routers.AddInterface(context.TODO(), fake.ServiceClient(), "foo", routers.AddInterfaceOpts{}).Extract()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	_, err := routers.AddInterface(context.TODO(), fake.ServiceClient(fakeServer), "foo", routers.AddInterfaceOpts{}).Extract()
 	if err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	_, err = routers.AddInterface(context.TODO(), fake.ServiceClient(), "foo", routers.AddInterfaceOpts{SubnetID: "bar", PortID: "baz"}).Extract()
+	_, err = routers.AddInterface(context.TODO(), fake.ServiceClient(fakeServer), "foo", routers.AddInterfaceOpts{SubnetID: "bar", PortID: "baz"}).Extract()
 	if err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestRemoveInterface(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c/remove_router_interface", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/4e8e5957-649f-477b-9e5b-f1f75b21c03c/remove_router_interface", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -541,7 +544,7 @@ func TestRemoveInterface(t *testing.T) {
 	})
 
 	opts := routers.RemoveInterfaceOpts{SubnetID: "a2f1f29d-571b-4533-907f-5803ab96ead1"}
-	res, err := routers.RemoveInterface(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", opts).Extract()
+	res, err := routers.RemoveInterface(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "0d32a837-8069-4ec3-84c4-3eef3e10b188", res.SubnetID)
@@ -551,10 +554,10 @@ func TestRemoveInterface(t *testing.T) {
 }
 
 func TestListL3Agents(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/routers/fa3a4aaa-c73f-48aa-a603-8c8bf642b7c0/l3-agents", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/routers/fa3a4aaa-c73f-48aa-a603-8c8bf642b7c0/l3-agents", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -623,7 +626,7 @@ func TestListL3Agents(t *testing.T) {
 			`)
 	})
 
-	l3AgentsPages, err := routers.ListL3Agents(fake.ServiceClient(), "fa3a4aaa-c73f-48aa-a603-8c8bf642b7c0").AllPages(context.TODO())
+	l3AgentsPages, err := routers.ListL3Agents(fake.ServiceClient(fakeServer), "fa3a4aaa-c73f-48aa-a603-8c8bf642b7c0").AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := routers.ExtractL3Agents(l3AgentsPages)
 	th.AssertNoErr(t, err)
diff --git a/openstack/networking/v2/extensions/mtu/testing/results_test.go b/openstack/networking/v2/extensions/mtu/testing/results_test.go
index 916bbc00f..99b2b2e74 100644
--- a/openstack/networking/v2/extensions/mtu/testing/results_test.go
+++ b/openstack/networking/v2/extensions/mtu/testing/results_test.go
@@ -19,10 +19,10 @@ type NetworkMTU struct {
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -38,7 +38,7 @@ func TestList(t *testing.T) {
 	}
 	var actual []NetworkWithMTUExt
 
-	allPages, err := networks.List(fake.ServiceClient(), networks.ListOpts{}).AllPages(context.TODO())
+	allPages, err := networks.List(fake.ServiceClient(fakeServer), networks.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	err = networks.ExtractNetworksInto(allPages, &actual)
@@ -49,10 +49,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -64,7 +64,7 @@ func TestGet(t *testing.T) {
 
 	var s NetworkMTU
 
-	err := networks.Get(context.TODO(), fake.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&s)
+	err := networks.Get(context.TODO(), fake.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "d32019d3-bc6e-4319-9c1d-6722fc136a22", s.ID)
@@ -72,10 +72,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -101,7 +101,7 @@ func TestCreate(t *testing.T) {
 
 	var s NetworkMTU
 
-	err := networks.Create(context.TODO(), fake.ServiceClient(), mtuCreateOpts).ExtractInto(&s)
+	err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), mtuCreateOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "db193ab3-96e3-4cb3-8fc5-05f4296d0324", s.ID)
@@ -110,10 +110,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -142,7 +142,7 @@ func TestUpdate(t *testing.T) {
 
 	var s NetworkMTU
 
-	err := networks.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", mtuUpdateOpts).ExtractInto(&s)
+	err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", mtuUpdateOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "4e8e5957-649f-477b-9e5b-f1f75b21c03c", s.ID)
diff --git a/openstack/networking/v2/extensions/networkipavailabilities/testing/requests_test.go b/openstack/networking/v2/extensions/networkipavailabilities/testing/requests_test.go
index cdd6d8d4e..349d4784d 100644
--- a/openstack/networking/v2/extensions/networkipavailabilities/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/networkipavailabilities/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/network-ip-availabilities", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/network-ip-availabilities", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -29,7 +29,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := networkipavailabilities.List(fake.ServiceClient(), networkipavailabilities.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := networkipavailabilities.List(fake.ServiceClient(fakeServer), networkipavailabilities.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := networkipavailabilities.ExtractNetworkIPAvailabilities(page)
 		if err != nil {
@@ -55,10 +55,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/network-ip-availabilities/cf11ab78-2302-49fa-870f-851a08c7afb8", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/network-ip-availabilities/cf11ab78-2302-49fa-870f-851a08c7afb8", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -68,7 +68,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, NetworkIPAvailabilityGetResult)
 	})
 
-	s, err := networkipavailabilities.Get(context.TODO(), fake.ServiceClient(), "cf11ab78-2302-49fa-870f-851a08c7afb8").Extract()
+	s, err := networkipavailabilities.Get(context.TODO(), fake.ServiceClient(fakeServer), "cf11ab78-2302-49fa-870f-851a08c7afb8").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.NetworkID, "cf11ab78-2302-49fa-870f-851a08c7afb8")
diff --git a/openstack/networking/v2/extensions/portsbinding/testing/fixtures_test.go b/openstack/networking/v2/extensions/portsbinding/testing/fixtures_test.go
index 44e2b5db9..2a639214d 100644
--- a/openstack/networking/v2/extensions/portsbinding/testing/fixtures_test.go
+++ b/openstack/networking/v2/extensions/portsbinding/testing/fixtures_test.go
@@ -10,8 +10,8 @@ import (
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
 )
 
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -22,8 +22,8 @@ func HandleListSuccessfully(t *testing.T) {
 	})
 }
 
-func HandleGet(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
+func HandleGet(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -34,8 +34,8 @@ func HandleGet(t *testing.T) {
 	})
 }
 
-func HandleCreate(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -92,8 +92,8 @@ func HandleCreate(t *testing.T) {
 	})
 }
 
-func HandleUpdate(t *testing.T) {
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
diff --git a/openstack/networking/v2/extensions/portsbinding/testing/requests_test.go b/openstack/networking/v2/extensions/portsbinding/testing/requests_test.go
index 4f0073b4a..e48981fd0 100644
--- a/openstack/networking/v2/extensions/portsbinding/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/portsbinding/testing/requests_test.go
@@ -12,10 +12,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleListSuccessfully(t)
+	HandleListSuccessfully(t, fakeServer)
 
 	type PortWithExt struct {
 		ports.Port
@@ -52,7 +52,7 @@ func TestList(t *testing.T) {
 		},
 	}
 
-	allPages, err := ports.List(fake.ServiceClient(), ports.ListOpts{}).AllPages(context.TODO())
+	allPages, err := ports.List(fake.ServiceClient(fakeServer), ports.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	err = ports.ExtractPortsInto(allPages, &actual)
@@ -62,17 +62,17 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleGet(t)
+	HandleGet(t, fakeServer)
 
 	var s struct {
 		ports.Port
 		portsbinding.PortsBindingExt
 	}
 
-	err := ports.Get(context.TODO(), fake.ServiceClient(), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").ExtractInto(&s)
+	err := ports.Get(context.TODO(), fake.ServiceClient(fakeServer), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, "ACTIVE")
@@ -96,10 +96,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleCreate(t)
+	HandleCreate(t, fakeServer)
 
 	var s struct {
 		ports.Port
@@ -123,7 +123,7 @@ func TestCreate(t *testing.T) {
 		VNICType:          "normal",
 	}
 
-	err := ports.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractInto(&s)
+	err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), createOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, "DOWN")
@@ -143,17 +143,20 @@ func TestCreate(t *testing.T) {
 }
 
 func TestRequiredCreateOpts(t *testing.T) {
-	res := ports.Create(context.TODO(), fake.ServiceClient(), portsbinding.CreateOptsExt{CreateOptsBuilder: ports.CreateOpts{}})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), portsbinding.CreateOptsExt{CreateOptsBuilder: ports.CreateOpts{}})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleUpdate(t)
+	HandleUpdate(t, fakeServer)
 
 	var s struct {
 		ports.Port
@@ -176,7 +179,7 @@ func TestUpdate(t *testing.T) {
 		VNICType:          "normal",
 	}
 
-	err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&s)
+	err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "new_port_name")
diff --git a/openstack/networking/v2/extensions/provider/testing/results_test.go b/openstack/networking/v2/extensions/provider/testing/results_test.go
index acbf9f7a1..c8f7874b9 100644
--- a/openstack/networking/v2/extensions/provider/testing/results_test.go
+++ b/openstack/networking/v2/extensions/provider/testing/results_test.go
@@ -15,10 +15,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -34,7 +34,7 @@ func TestList(t *testing.T) {
 	}
 	var actual []NetworkWithExt
 
-	allPages, err := networks.List(fake.ServiceClient(), networks.ListOpts{}).AllPages(context.TODO())
+	allPages, err := networks.List(fake.ServiceClient(fakeServer), networks.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	err = networks.ExtractNetworksInto(allPages, &actual)
@@ -50,10 +50,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -68,7 +68,7 @@ func TestGet(t *testing.T) {
 		provider.NetworkProviderExt
 	}
 
-	err := networks.Get(context.TODO(), fake.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&s)
+	err := networks.Get(context.TODO(), fake.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "d32019d3-bc6e-4319-9c1d-6722fc136a22", s.ID)
@@ -78,10 +78,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -100,7 +100,7 @@ func TestCreate(t *testing.T) {
 	}
 
 	options := networks.CreateOpts{Name: "private", AdminStateUp: gophercloud.Enabled}
-	err := networks.Create(context.TODO(), fake.ServiceClient(), options).ExtractInto(&s)
+	err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), options).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "db193ab3-96e3-4cb3-8fc5-05f4296d0324", s.ID)
@@ -110,10 +110,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestCreateWithMultipleProvider(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -185,13 +185,13 @@ func TestCreateWithMultipleProvider(t *testing.T) {
 		Segments:          segments,
 	}
 
-	_, err := networks.Create(context.TODO(), fake.ServiceClient(), providerCreateOpts).Extract()
+	_, err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), providerCreateOpts).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	iTrue := true
 	name := "new_network_name"
@@ -204,7 +204,7 @@ func TestUpdate(t *testing.T) {
 		Segments:          &segments,
 	}
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -235,7 +235,7 @@ func TestUpdate(t *testing.T) {
 		provider.NetworkProviderExt
 	}
 
-	err := networks.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", providerUpdateOpts).ExtractInto(&s)
+	err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", providerUpdateOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "4e8e5957-649f-477b-9e5b-f1f75b21c03c", s.ID)
diff --git a/openstack/networking/v2/extensions/qos/policies/testing/requests_test.go b/openstack/networking/v2/extensions/qos/policies/testing/requests_test.go
index 4ad4cf308..4b84d773b 100644
--- a/openstack/networking/v2/extensions/qos/policies/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/qos/policies/testing/requests_test.go
@@ -16,10 +16,10 @@ import (
 )
 
 func TestGetPort(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -34,7 +34,7 @@ func TestGetPort(t *testing.T) {
 		ports.Port
 		policies.QoSPolicyExt
 	}
-	err := ports.Get(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d").ExtractInto(&p)
+	err := ports.Get(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d").ExtractInto(&p)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, p.ID, "65c0ee9f-d634-4522-8954-51021b570b0d")
@@ -42,10 +42,10 @@ func TestGetPort(t *testing.T) {
 }
 
 func TestCreatePort(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -70,7 +70,7 @@ func TestCreatePort(t *testing.T) {
 		CreateOptsBuilder: portCreateOpts,
 		QoSPolicyID:       "591e0597-39a6-4665-8149-2111d8de9a08",
 	}
-	err := ports.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractInto(&p)
+	err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), createOpts).ExtractInto(&p)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, p.NetworkID, "a87cc70a-3e15-4acf-8205-9b711a3531b7")
@@ -80,10 +80,10 @@ func TestCreatePort(t *testing.T) {
 }
 
 func TestUpdatePortWithPolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -108,7 +108,7 @@ func TestUpdatePortWithPolicy(t *testing.T) {
 		UpdateOptsBuilder: portUpdateOpts,
 		QoSPolicyID:       &policyID,
 	}
-	err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&p)
+	err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&p)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, p.NetworkID, "a87cc70a-3e15-4acf-8205-9b711a3531b7")
@@ -118,10 +118,10 @@ func TestUpdatePortWithPolicy(t *testing.T) {
 }
 
 func TestUpdatePortWithoutPolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -146,7 +146,7 @@ func TestUpdatePortWithoutPolicy(t *testing.T) {
 		UpdateOptsBuilder: portUpdateOpts,
 		QoSPolicyID:       &policyID,
 	}
-	err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&p)
+	err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&p)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, p.NetworkID, "a87cc70a-3e15-4acf-8205-9b711a3531b7")
@@ -156,10 +156,10 @@ func TestUpdatePortWithoutPolicy(t *testing.T) {
 }
 
 func TestGetNetwork(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -174,7 +174,7 @@ func TestGetNetwork(t *testing.T) {
 		networks.Network
 		policies.QoSPolicyExt
 	}
-	err := networks.Get(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d").ExtractInto(&n)
+	err := networks.Get(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d").ExtractInto(&n)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.ID, "65c0ee9f-d634-4522-8954-51021b570b0d")
@@ -182,10 +182,10 @@ func TestGetNetwork(t *testing.T) {
 }
 
 func TestCreateNetwork(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -210,7 +210,7 @@ func TestCreateNetwork(t *testing.T) {
 		CreateOptsBuilder: networkCreateOpts,
 		QoSPolicyID:       "591e0597-39a6-4665-8149-2111d8de9a08",
 	}
-	err := networks.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractInto(&n)
+	err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), createOpts).ExtractInto(&n)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.TenantID, "4fd44f30292945e481c7b8a0c8908869")
@@ -219,10 +219,10 @@ func TestCreateNetwork(t *testing.T) {
 }
 
 func TestUpdateNetworkWithPolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -250,7 +250,7 @@ func TestUpdateNetworkWithPolicy(t *testing.T) {
 		UpdateOptsBuilder: networkUpdateOpts,
 		QoSPolicyID:       &policyID,
 	}
-	err := networks.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&n)
+	err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&n)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.TenantID, "4fd44f30292945e481c7b8a0c8908869")
@@ -260,10 +260,10 @@ func TestUpdateNetworkWithPolicy(t *testing.T) {
 }
 
 func TestUpdateNetworkWithoutPolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -288,7 +288,7 @@ func TestUpdateNetworkWithoutPolicy(t *testing.T) {
 		UpdateOptsBuilder: networkUpdateOpts,
 		QoSPolicyID:       &policyID,
 	}
-	err := networks.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&n)
+	err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&n)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.TenantID, "4fd44f30292945e481c7b8a0c8908869")
@@ -297,10 +297,10 @@ func TestUpdateNetworkWithoutPolicy(t *testing.T) {
 }
 
 func TestListPolicies(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -312,7 +312,7 @@ func TestListPolicies(t *testing.T) {
 
 	count := 0
 
-	err := policies.List(fake.ServiceClient(), policies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := policies.List(fake.ServiceClient(fakeServer), policies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := policies.ExtractPolicies(page)
 		if err != nil {
@@ -337,10 +337,10 @@ func TestListPolicies(t *testing.T) {
 }
 
 func TestGetPolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -350,7 +350,7 @@ func TestGetPolicy(t *testing.T) {
 		fmt.Fprint(w, GetPolicyResponse)
 	})
 
-	p, err := policies.Get(context.TODO(), fake.ServiceClient(), "30a57f4a-336b-4382-8275-d708babd2241").Extract()
+	p, err := policies.Get(context.TODO(), fake.ServiceClient(fakeServer), "30a57f4a-336b-4382-8275-d708babd2241").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "bw-limiter", p.Name)
@@ -374,10 +374,10 @@ func TestGetPolicy(t *testing.T) {
 }
 
 func TestCreatePolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -396,7 +396,7 @@ func TestCreatePolicy(t *testing.T) {
 		IsDefault:   true,
 		Description: "use-me",
 	}
-	p, err := policies.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	p, err := policies.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "shared-default-policy", p.Name)
@@ -412,10 +412,10 @@ func TestCreatePolicy(t *testing.T) {
 }
 
 func TestUpdatePolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/d6ae28ce-fcb5-4180-aa62-d260a27e09ae", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/d6ae28ce-fcb5-4180-aa62-d260a27e09ae", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -435,7 +435,7 @@ func TestUpdatePolicy(t *testing.T) {
 		Shared:      &shared,
 		Description: &description,
 	}
-	p, err := policies.Update(context.TODO(), fake.ServiceClient(), "d6ae28ce-fcb5-4180-aa62-d260a27e09ae", opts).Extract()
+	p, err := policies.Update(context.TODO(), fake.ServiceClient(fakeServer), "d6ae28ce-fcb5-4180-aa62-d260a27e09ae", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "new-name", p.Name)
@@ -451,15 +451,15 @@ func TestUpdatePolicy(t *testing.T) {
 }
 
 func TestDeletePolicy(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/d6ae28ce-fcb5-4180-aa62-d260a27e09ae", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/d6ae28ce-fcb5-4180-aa62-d260a27e09ae", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := policies.Delete(context.TODO(), fake.ServiceClient(), "d6ae28ce-fcb5-4180-aa62-d260a27e09ae")
+	res := policies.Delete(context.TODO(), fake.ServiceClient(fakeServer), "d6ae28ce-fcb5-4180-aa62-d260a27e09ae")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/qos/rules/testing/requests_test.go b/openstack/networking/v2/extensions/qos/rules/testing/requests_test.go
index 20de75513..0c6402d1b 100644
--- a/openstack/networking/v2/extensions/qos/rules/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/qos/rules/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestListBandwidthLimitRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -29,7 +29,7 @@ func TestListBandwidthLimitRule(t *testing.T) {
 	count := 0
 
 	err := rules.ListBandwidthLimitRules(
-		fake.ServiceClient(),
+		fake.ServiceClient(fakeServer),
 		"501005fa-3b56-4061-aaca-3f24995112e1",
 		rules.BandwidthLimitRulesListOpts{},
 	).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -61,10 +61,10 @@ func TestListBandwidthLimitRule(t *testing.T) {
 }
 
 func TestGetBandwidthLimitRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -74,7 +74,7 @@ func TestGetBandwidthLimitRule(t *testing.T) {
 		fmt.Fprint(w, BandwidthLimitRulesGetResult)
 	})
 
-	r, err := rules.GetBandwidthLimitRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractBandwidthLimitRule()
+	r, err := rules.GetBandwidthLimitRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractBandwidthLimitRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, r.ID, "30a57f4a-336b-4382-8275-d708babd2241")
@@ -84,10 +84,10 @@ func TestGetBandwidthLimitRule(t *testing.T) {
 }
 
 func TestCreateBandwidthLimitRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -104,7 +104,7 @@ func TestCreateBandwidthLimitRule(t *testing.T) {
 		MaxKBps:      2000,
 		MaxBurstKBps: 200,
 	}
-	r, err := rules.CreateBandwidthLimitRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", opts).ExtractBandwidthLimitRule()
+	r, err := rules.CreateBandwidthLimitRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", opts).ExtractBandwidthLimitRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, 200, r.MaxBurstKBps)
@@ -112,10 +112,10 @@ func TestCreateBandwidthLimitRule(t *testing.T) {
 }
 
 func TestUpdateBandwidthLimitRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -134,7 +134,7 @@ func TestUpdateBandwidthLimitRule(t *testing.T) {
 		MaxKBps:      &maxKBps,
 		MaxBurstKBps: &maxBurstKBps,
 	}
-	r, err := rules.UpdateBandwidthLimitRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241", opts).ExtractBandwidthLimitRule()
+	r, err := rules.UpdateBandwidthLimitRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241", opts).ExtractBandwidthLimitRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, 0, r.MaxBurstKBps)
@@ -142,24 +142,24 @@ func TestUpdateBandwidthLimitRule(t *testing.T) {
 }
 
 func TestDeleteBandwidthLimitRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/bandwidth_limit_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := rules.DeleteBandwidthLimitRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241")
+	res := rules.DeleteBandwidthLimitRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListDSCPMarkingRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -172,7 +172,7 @@ func TestListDSCPMarkingRule(t *testing.T) {
 	count := 0
 
 	err := rules.ListDSCPMarkingRules(
-		fake.ServiceClient(),
+		fake.ServiceClient(fakeServer),
 		"501005fa-3b56-4061-aaca-3f24995112e1",
 		rules.DSCPMarkingRulesListOpts{},
 	).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -202,10 +202,10 @@ func TestListDSCPMarkingRule(t *testing.T) {
 }
 
 func TestGetDSCPMarkingRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -215,7 +215,7 @@ func TestGetDSCPMarkingRule(t *testing.T) {
 		fmt.Fprint(w, DSCPMarkingRuleGetResult)
 	})
 
-	r, err := rules.GetDSCPMarkingRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractDSCPMarkingRule()
+	r, err := rules.GetDSCPMarkingRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractDSCPMarkingRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, r.ID, "30a57f4a-336b-4382-8275-d708babd2241")
@@ -223,10 +223,10 @@ func TestGetDSCPMarkingRule(t *testing.T) {
 }
 
 func TestCreateDSCPMarkingRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -242,7 +242,7 @@ func TestCreateDSCPMarkingRule(t *testing.T) {
 	opts := rules.CreateDSCPMarkingRuleOpts{
 		DSCPMark: 20,
 	}
-	r, err := rules.CreateDSCPMarkingRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", opts).ExtractDSCPMarkingRule()
+	r, err := rules.CreateDSCPMarkingRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", opts).ExtractDSCPMarkingRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "30a57f4a-336b-4382-8275-d708babd2241", r.ID)
@@ -250,10 +250,10 @@ func TestCreateDSCPMarkingRule(t *testing.T) {
 }
 
 func TestUpdateDSCPMarkingRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -270,7 +270,7 @@ func TestUpdateDSCPMarkingRule(t *testing.T) {
 	opts := rules.UpdateDSCPMarkingRuleOpts{
 		DSCPMark: &dscpMark,
 	}
-	r, err := rules.UpdateDSCPMarkingRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241", opts).ExtractDSCPMarkingRule()
+	r, err := rules.UpdateDSCPMarkingRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241", opts).ExtractDSCPMarkingRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "30a57f4a-336b-4382-8275-d708babd2241", r.ID)
@@ -278,24 +278,24 @@ func TestUpdateDSCPMarkingRule(t *testing.T) {
 }
 
 func TestDeleteDSCPMarkingRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/dscp_marking_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := rules.DeleteDSCPMarkingRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241")
+	res := rules.DeleteDSCPMarkingRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListMinimumBandwidthRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -308,7 +308,7 @@ func TestListMinimumBandwidthRule(t *testing.T) {
 	count := 0
 
 	err := rules.ListMinimumBandwidthRules(
-		fake.ServiceClient(),
+		fake.ServiceClient(fakeServer),
 		"501005fa-3b56-4061-aaca-3f24995112e1",
 		rules.MinimumBandwidthRulesListOpts{},
 	).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -339,10 +339,10 @@ func TestListMinimumBandwidthRule(t *testing.T) {
 }
 
 func TestGetMinimumBandwidthRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -352,7 +352,7 @@ func TestGetMinimumBandwidthRule(t *testing.T) {
 		fmt.Fprint(w, MinimumBandwidthRulesGetResult)
 	})
 
-	r, err := rules.GetMinimumBandwidthRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractMinimumBandwidthRule()
+	r, err := rules.GetMinimumBandwidthRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241").ExtractMinimumBandwidthRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, r.ID, "30a57f4a-336b-4382-8275-d708babd2241")
@@ -361,10 +361,10 @@ func TestGetMinimumBandwidthRule(t *testing.T) {
 }
 
 func TestCreateMinimumBandwidthRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -380,17 +380,17 @@ func TestCreateMinimumBandwidthRule(t *testing.T) {
 	opts := rules.CreateMinimumBandwidthRuleOpts{
 		MinKBps: 2000,
 	}
-	r, err := rules.CreateMinimumBandwidthRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", opts).ExtractMinimumBandwidthRule()
+	r, err := rules.CreateMinimumBandwidthRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", opts).ExtractMinimumBandwidthRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, 2000, r.MinKBps)
 }
 
 func TestUpdateMinimumBandwidthRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -407,22 +407,22 @@ func TestUpdateMinimumBandwidthRule(t *testing.T) {
 	opts := rules.UpdateMinimumBandwidthRuleOpts{
 		MinKBps: &minKBps,
 	}
-	r, err := rules.UpdateMinimumBandwidthRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241", opts).ExtractMinimumBandwidthRule()
+	r, err := rules.UpdateMinimumBandwidthRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241", opts).ExtractMinimumBandwidthRule()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, 500, r.MinKBps)
 }
 
 func TestDeleteMinimumBandwidthRule(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/qos/policies/501005fa-3b56-4061-aaca-3f24995112e1/minimum_bandwidth_rules/30a57f4a-336b-4382-8275-d708babd2241", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := rules.DeleteMinimumBandwidthRule(context.TODO(), fake.ServiceClient(), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241")
+	res := rules.DeleteMinimumBandwidthRule(context.TODO(), fake.ServiceClient(fakeServer), "501005fa-3b56-4061-aaca-3f24995112e1", "30a57f4a-336b-4382-8275-d708babd2241")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/qos/ruletypes/testing/requests_test.go b/openstack/networking/v2/extensions/qos/ruletypes/testing/requests_test.go
index 7bea9f6b6..7d2bfc583 100644
--- a/openstack/networking/v2/extensions/qos/ruletypes/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/qos/ruletypes/testing/requests_test.go
@@ -8,16 +8,16 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/extensions/qos/ruletypes"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestListRuleTypes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -25,7 +25,7 @@ func TestListRuleTypes(t *testing.T) {
 		fmt.Fprint(w, ListRuleTypesResponse)
 	})
 
-	page, err := ruletypes.ListRuleTypes(fake.ServiceClient()).AllPages(context.TODO())
+	page, err := ruletypes.ListRuleTypes(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	if err != nil {
 		t.Errorf("Failed to list rule types pages: %v", err)
 		return
@@ -42,12 +42,12 @@ func TestListRuleTypes(t *testing.T) {
 }
 
 func TestGetRuleType(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/qos/rule-types/bandwidth_limit", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/qos/rule-types/bandwidth_limit", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -56,7 +56,7 @@ func TestGetRuleType(t *testing.T) {
 		th.AssertNoErr(t, err)
 	})
 
-	r, err := ruletypes.GetRuleType(context.TODO(), fake.ServiceClient(), "bandwidth_limit").Extract()
+	r, err := ruletypes.GetRuleType(context.TODO(), client.ServiceClient(fakeServer), "bandwidth_limit").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "bandwidth_limit", r.Type)
diff --git a/openstack/networking/v2/extensions/quotas/testing/requests_test.go b/openstack/networking/v2/extensions/quotas/testing/requests_test.go
index a5714d17f..597edd485 100644
--- a/openstack/networking/v2/extensions/quotas/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/quotas/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -26,16 +26,16 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, GetResponseRaw)
 	})
 
-	q, err := quotas.Get(context.TODO(), fake.ServiceClient(), "0a73845280574ad389c292f6a74afa76").Extract()
+	q, err := quotas.Get(context.TODO(), fake.ServiceClient(fakeServer), "0a73845280574ad389c292f6a74afa76").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, q, &GetResponse)
 }
 
 func TestGetDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76/details.json", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76/details.json", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -45,16 +45,16 @@ func TestGetDetail(t *testing.T) {
 		fmt.Fprint(w, GetDetailedResponseRaw)
 	})
 
-	q, err := quotas.GetDetail(context.TODO(), fake.ServiceClient(), "0a73845280574ad389c292f6a74afa76").Extract()
+	q, err := quotas.GetDetail(context.TODO(), fake.ServiceClient(fakeServer), "0a73845280574ad389c292f6a74afa76").Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, q, &GetDetailResponse)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/quotas/0a73845280574ad389c292f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -64,7 +64,7 @@ func TestUpdate(t *testing.T) {
 		fmt.Fprint(w, UpdateRequestResponseRaw)
 	})
 
-	q, err := quotas.Update(context.TODO(), fake.ServiceClient(), "0a73845280574ad389c292f6a74afa76", quotas.UpdateOpts{
+	q, err := quotas.Update(context.TODO(), fake.ServiceClient(fakeServer), "0a73845280574ad389c292f6a74afa76", quotas.UpdateOpts{
 		FloatingIP:        gophercloud.IntToPointer(0),
 		Network:           gophercloud.IntToPointer(-1),
 		Port:              gophercloud.IntToPointer(5),
diff --git a/openstack/networking/v2/extensions/rbacpolicies/testing/requests_test.go b/openstack/networking/v2/extensions/rbacpolicies/testing/requests_test.go
index 9fc04412f..68cba4a15 100644
--- a/openstack/networking/v2/extensions/rbacpolicies/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/rbacpolicies/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/rbac-policies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/rbac-policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -34,17 +34,17 @@ func TestCreate(t *testing.T) {
 		TargetTenant: "6e547a3bcfe44702889fdeff3c3520c3",
 		ObjectID:     "240d22bf-bd17-4238-9758-25f72610ecdc",
 	}
-	rbacResult, err := rbacpolicies.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	rbacResult, err := rbacpolicies.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &rbacPolicy1, rbacResult)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/rbac-policies/2cf7523a-93b5-4e69-9360-6c6bf986bb7c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/rbac-policies/2cf7523a-93b5-4e69-9360-6c6bf986bb7c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -54,16 +54,16 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, GetResponse)
 	})
 
-	n, err := rbacpolicies.Get(context.TODO(), fake.ServiceClient(), "2cf7523a-93b5-4e69-9360-6c6bf986bb7c").Extract()
+	n, err := rbacpolicies.Get(context.TODO(), fake.ServiceClient(fakeServer), "2cf7523a-93b5-4e69-9360-6c6bf986bb7c").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &rbacPolicy1, n)
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/rbac-policies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/rbac-policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -73,7 +73,7 @@ func TestList(t *testing.T) {
 		fmt.Fprint(w, ListResponse)
 	})
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	count := 0
 
 	err := rbacpolicies.List(client, rbacpolicies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -96,10 +96,10 @@ func TestList(t *testing.T) {
 }
 
 func TestListWithAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/rbac-policies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/rbac-policies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -109,7 +109,7 @@ func TestListWithAllPages(t *testing.T) {
 		fmt.Fprint(w, ListResponse)
 	})
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 
 	type newRBACPolicy struct {
 		rbacpolicies.RBACPolicy
@@ -132,24 +132,24 @@ func TestListWithAllPages(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/rbac-policies/71d55b18-d2f8-4c76-a5e6-e0a3dd114361", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/rbac-policies/71d55b18-d2f8-4c76-a5e6-e0a3dd114361", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := rbacpolicies.Delete(context.TODO(), fake.ServiceClient(), "71d55b18-d2f8-4c76-a5e6-e0a3dd114361").ExtractErr()
+	res := rbacpolicies.Delete(context.TODO(), fake.ServiceClient(fakeServer), "71d55b18-d2f8-4c76-a5e6-e0a3dd114361").ExtractErr()
 	th.AssertNoErr(t, res)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/rbac-policies/2cf7523a-93b5-4e69-9360-6c6bf986bb7c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/rbac-policies/2cf7523a-93b5-4e69-9360-6c6bf986bb7c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -163,7 +163,7 @@ func TestUpdate(t *testing.T) {
 	})
 
 	options := rbacpolicies.UpdateOpts{TargetTenant: "9d766060b6354c9e8e2da44cab0e8f38"}
-	rbacResult, err := rbacpolicies.Update(context.TODO(), fake.ServiceClient(), "2cf7523a-93b5-4e69-9360-6c6bf986bb7c", options).Extract()
+	rbacResult, err := rbacpolicies.Update(context.TODO(), fake.ServiceClient(fakeServer), "2cf7523a-93b5-4e69-9360-6c6bf986bb7c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, rbacResult.TargetTenant, "9d766060b6354c9e8e2da44cab0e8f38")
diff --git a/openstack/networking/v2/extensions/security/groups/testing/requests_test.go b/openstack/networking/v2/extensions/security/groups/testing/requests_test.go
index f816f0d6d..320e537e0 100644
--- a/openstack/networking/v2/extensions/security/groups/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/security/groups/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-groups", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -29,7 +29,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := groups.List(fake.ServiceClient(), groups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := groups.List(fake.ServiceClient(fakeServer), groups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := groups.ExtractGroups(page)
 		if err != nil {
@@ -51,10 +51,10 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-groups", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -68,15 +68,15 @@ func TestCreate(t *testing.T) {
 	})
 
 	opts := groups.CreateOpts{Name: "new-webservers", Description: "security group for webservers"}
-	_, err := groups.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	_, err := groups.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-groups/2076db17-a522-4506-91de-c6dd8e837028",
+	fakeServer.Mux.HandleFunc("/v2.0/security-groups/2076db17-a522-4506-91de-c6dd8e837028",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "PUT")
 			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -91,7 +91,7 @@ func TestUpdate(t *testing.T) {
 		})
 
 	opts := groups.UpdateOpts{Name: "newer-webservers"}
-	sg, err := groups.Update(context.TODO(), fake.ServiceClient(), "2076db17-a522-4506-91de-c6dd8e837028", opts).Extract()
+	sg, err := groups.Update(context.TODO(), fake.ServiceClient(fakeServer), "2076db17-a522-4506-91de-c6dd8e837028", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "newer-webservers", sg.Name)
@@ -102,10 +102,10 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-groups/85cc3048-abc3-43cc-89b3-377341426ac5", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-groups/85cc3048-abc3-43cc-89b3-377341426ac5", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -115,7 +115,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, SecurityGroupGetResponse)
 	})
 
-	sg, err := groups.Get(context.TODO(), fake.ServiceClient(), "85cc3048-abc3-43cc-89b3-377341426ac5").Extract()
+	sg, err := groups.Get(context.TODO(), fake.ServiceClient(fakeServer), "85cc3048-abc3-43cc-89b3-377341426ac5").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "default", sg.Description)
@@ -128,15 +128,15 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-groups/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-groups/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := groups.Delete(context.TODO(), fake.ServiceClient(), "4ec89087-d057-4e2c-911f-60a3b47ee304")
+	res := groups.Delete(context.TODO(), fake.ServiceClient(fakeServer), "4ec89087-d057-4e2c-911f-60a3b47ee304")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/security/rules/testing/requests_test.go b/openstack/networking/v2/extensions/security/rules/testing/requests_test.go
index ad6552a77..15975ed4e 100644
--- a/openstack/networking/v2/extensions/security/rules/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/security/rules/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-group-rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-group-rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -57,7 +57,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := rules.List(fake.ServiceClient(), rules.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := rules.List(fake.ServiceClient(fakeServer), rules.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := rules.ExtractRules(page)
 		if err != nil {
@@ -105,10 +105,10 @@ func TestList(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-group-rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-group-rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -160,15 +160,15 @@ func TestCreate(t *testing.T) {
 		RemoteGroupID: "85cc3048-abc3-43cc-89b3-377341426ac5",
 		SecGroupID:    "a7734e61-b545-452d-a3cd-0189cbd9747a",
 	}
-	_, err := rules.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	_, err := rules.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestCreateAnyProtocol(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-group-rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-group-rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -218,15 +218,15 @@ func TestCreateAnyProtocol(t *testing.T) {
 		RemoteGroupID: "85cc3048-abc3-43cc-89b3-377341426ac5",
 		SecGroupID:    "a7734e61-b545-452d-a3cd-0189cbd9747a",
 	}
-	_, err := rules.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	_, err := rules.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestCreateBulk(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-group-rules", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-group-rules", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -314,7 +314,7 @@ func TestCreateBulk(t *testing.T) {
 		},
 	}
 	{
-		_, err := rules.CreateBulk(context.TODO(), fake.ServiceClient(), opts).Extract()
+		_, err := rules.CreateBulk(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 		th.AssertNoErr(t, err)
 	}
 
@@ -323,35 +323,38 @@ func TestCreateBulk(t *testing.T) {
 		for i := range opts {
 			optsBuilder[i] = opts[i]
 		}
-		_, err := rules.CreateBulk(context.TODO(), fake.ServiceClient(), optsBuilder).Extract()
+		_, err := rules.CreateBulk(context.TODO(), fake.ServiceClient(fakeServer), optsBuilder).Extract()
 		th.AssertNoErr(t, err)
 	}
 }
 
 func TestRequiredCreateOpts(t *testing.T) {
-	res := rules.Create(context.TODO(), fake.ServiceClient(), rules.CreateOpts{Direction: rules.DirIngress})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := rules.Create(context.TODO(), fake.ServiceClient(fakeServer), rules.CreateOpts{Direction: rules.DirIngress})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = rules.Create(context.TODO(), fake.ServiceClient(), rules.CreateOpts{Direction: rules.DirIngress, EtherType: rules.EtherType4})
+	res = rules.Create(context.TODO(), fake.ServiceClient(fakeServer), rules.CreateOpts{Direction: rules.DirIngress, EtherType: rules.EtherType4})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = rules.Create(context.TODO(), fake.ServiceClient(), rules.CreateOpts{Direction: rules.DirIngress, EtherType: rules.EtherType4})
+	res = rules.Create(context.TODO(), fake.ServiceClient(fakeServer), rules.CreateOpts{Direction: rules.DirIngress, EtherType: rules.EtherType4})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
-	res = rules.Create(context.TODO(), fake.ServiceClient(), rules.CreateOpts{Direction: rules.DirIngress, EtherType: rules.EtherType4, SecGroupID: "something", Protocol: "foo"})
+	res = rules.Create(context.TODO(), fake.ServiceClient(fakeServer), rules.CreateOpts{Direction: rules.DirIngress, EtherType: rules.EtherType4, SecGroupID: "something", Protocol: "foo"})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-group-rules/3c0e45ff-adaf-4124-b083-bf390e5482ff", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-group-rules/3c0e45ff-adaf-4124-b083-bf390e5482ff", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -376,7 +379,7 @@ func TestGet(t *testing.T) {
       `)
 	})
 
-	sr, err := rules.Get(context.TODO(), fake.ServiceClient(), "3c0e45ff-adaf-4124-b083-bf390e5482ff").Extract()
+	sr, err := rules.Get(context.TODO(), fake.ServiceClient(fakeServer), "3c0e45ff-adaf-4124-b083-bf390e5482ff").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "egress", sr.Direction)
@@ -392,15 +395,15 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/security-group-rules/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/security-group-rules/4ec89087-d057-4e2c-911f-60a3b47ee304", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := rules.Delete(context.TODO(), fake.ServiceClient(), "4ec89087-d057-4e2c-911f-60a3b47ee304")
+	res := rules.Delete(context.TODO(), fake.ServiceClient(fakeServer), "4ec89087-d057-4e2c-911f-60a3b47ee304")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/subnetpools/testing/requests_test.go b/openstack/networking/v2/extensions/subnetpools/testing/requests_test.go
index 2d8df7018..8520ef110 100644
--- a/openstack/networking/v2/extensions/subnetpools/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/subnetpools/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnetpools", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnetpools", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -29,7 +29,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := subnetpools.List(fake.ServiceClient(), subnetpools.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := subnetpools.List(fake.ServiceClient(fakeServer), subnetpools.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := subnetpools.ExtractSubnetPools(page)
 		if err != nil {
@@ -56,10 +56,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnetpools/0a738452-8057-4ad3-89c2-92f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnetpools/0a738452-8057-4ad3-89c2-92f6a74afa76", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -69,7 +69,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, SubnetPoolGetResult)
 	})
 
-	s, err := subnetpools.Get(context.TODO(), fake.ServiceClient(), "0a738452-8057-4ad3-89c2-92f6a74afa76").Extract()
+	s, err := subnetpools.Get(context.TODO(), fake.ServiceClient(fakeServer), "0a738452-8057-4ad3-89c2-92f6a74afa76").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.ID, "0a738452-8057-4ad3-89c2-92f6a74afa76")
@@ -93,10 +93,10 @@ func TestGet(t *testing.T) {
 	th.AssertEquals(t, s.RevisionNumber, 2)
 }
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnetpools", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnetpools", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -120,7 +120,7 @@ func TestCreate(t *testing.T) {
 		AddressScopeID: "3d4e2e2a-552b-42ad-a16d-820bbf3edaf3",
 		Description:    "ipv4 prefixes",
 	}
-	s, err := subnetpools.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	s, err := subnetpools.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "my_ipv4_pool")
@@ -135,10 +135,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnetpools/099546ca-788d-41e5-a76d-17d8cd282d3e", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnetpools/099546ca-788d-41e5-a76d-17d8cd282d3e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -164,7 +164,7 @@ func TestUpdate(t *testing.T) {
 		DefaultQuota:   &nullInt,
 		Description:    &nullString,
 	}
-	n, err := subnetpools.Update(context.TODO(), fake.ServiceClient(), "099546ca-788d-41e5-a76d-17d8cd282d3e", updateOpts).Extract()
+	n, err := subnetpools.Update(context.TODO(), fake.ServiceClient(fakeServer), "099546ca-788d-41e5-a76d-17d8cd282d3e", updateOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Name, "new_subnetpool_name")
@@ -181,15 +181,15 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnetpools/099546ca-788d-41e5-a76d-17d8cd282d3e", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnetpools/099546ca-788d-41e5-a76d-17d8cd282d3e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := subnetpools.Delete(context.TODO(), fake.ServiceClient(), "099546ca-788d-41e5-a76d-17d8cd282d3e")
+	res := subnetpools.Delete(context.TODO(), fake.ServiceClient(fakeServer), "099546ca-788d-41e5-a76d-17d8cd282d3e")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/networking/v2/extensions/testing/delegate_test.go b/openstack/networking/v2/extensions/testing/delegate_test.go
index 9f3421f27..95fa8461d 100644
--- a/openstack/networking/v2/extensions/testing/delegate_test.go
+++ b/openstack/networking/v2/extensions/testing/delegate_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/extensions", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/extensions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -41,7 +41,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := extensions.List(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := extensions.List(fake.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := extensions.ExtractExtensions(page)
 		if err != nil {
@@ -73,10 +73,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/extensions/agent", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/extensions/agent", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -97,7 +97,7 @@ func TestGet(t *testing.T) {
     `)
 	})
 
-	ext, err := extensions.Get(context.TODO(), fake.ServiceClient(), "agent").Extract()
+	ext, err := extensions.Get(context.TODO(), fake.ServiceClient(fakeServer), "agent").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, ext.Updated, "2013-02-03T10:00:00-00:00")
diff --git a/openstack/networking/v2/extensions/trunk_details/testing/requests_test.go b/openstack/networking/v2/extensions/trunk_details/testing/requests_test.go
index b99e711b1..fdbd4329f 100644
--- a/openstack/networking/v2/extensions/trunk_details/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/trunk_details/testing/requests_test.go
@@ -9,18 +9,18 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/extensions/trunk_details"
 	"github.com/gophercloud/gophercloud/v2/openstack/networking/v2/ports"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestServerWithUsageExt(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	const portIDFixture = "dc3e8758-ee96-402d-94b0-4be5e9396c82"
 
-	th.Mux.HandleFunc("/ports/"+portIDFixture, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/ports/"+portIDFixture, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		fmt.Fprint(w, PortWithTrunkDetailsResult)
@@ -32,7 +32,7 @@ func TestServerWithUsageExt(t *testing.T) {
 	}
 
 	// Extract basic fields.
-	err := ports.Get(context.TODO(), fake.ServiceClient(), portIDFixture).ExtractInto(&portExt)
+	err := ports.Get(context.TODO(), client.ServiceClient(fakeServer), portIDFixture).ExtractInto(&portExt)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, portExt.TrunkDetails.TrunkID, "f170c831-8c55-4ceb-ad13-75eab4a121e5")
diff --git a/openstack/networking/v2/extensions/trunks/testing/requests_test.go b/openstack/networking/v2/extensions/trunks/testing/requests_test.go
index 81e6bef8c..955a549f5 100644
--- a/openstack/networking/v2/extensions/trunks/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/trunks/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -46,12 +46,12 @@ func TestCreate(t *testing.T) {
 			},
 		},
 	}
-	_, err := trunks.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	_, err := trunks.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	if err == nil {
 		t.Fatalf("Failed to detect missing parent PortID field")
 	}
 	options.PortID = "c373d2fa-3d3b-4492-924c-aff54dea19b6"
-	n, err := trunks.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	n, err := trunks.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "ACTIVE")
@@ -61,10 +61,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestCreateNoSubports(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -83,7 +83,7 @@ func TestCreateNoSubports(t *testing.T) {
 		AdminStateUp: &iTrue,
 		PortID:       "c373d2fa-3d3b-4492-924c-aff54dea19b6",
 	}
-	n, err := trunks.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	n, err := trunks.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "ACTIVE")
@@ -91,24 +91,24 @@ func TestCreateNoSubports(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := trunks.Delete(context.TODO(), fake.ServiceClient(), "f6a9718c-5a64-43e3-944f-4deccad8e78c")
+	res := trunks.Delete(context.TODO(), fake.ServiceClient(fakeServer), "f6a9718c-5a64-43e3-944f-4deccad8e78c")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -118,7 +118,7 @@ func TestList(t *testing.T) {
 		fmt.Fprint(w, ListResponse)
 	})
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	count := 0
 
 	err := trunks.List(client, trunks.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -143,10 +143,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -156,7 +156,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, GetResponse)
 	})
 
-	n, err := trunks.Get(context.TODO(), fake.ServiceClient(), "f6a9718c-5a64-43e3-944f-4deccad8e78c").Extract()
+	n, err := trunks.Get(context.TODO(), fake.ServiceClient(fakeServer), "f6a9718c-5a64-43e3-944f-4deccad8e78c").Extract()
 	th.AssertNoErr(t, err)
 	expectedTrunks, err := ExpectedTrunkSlice()
 	th.AssertNoErr(t, err)
@@ -164,10 +164,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -188,7 +188,7 @@ func TestUpdate(t *testing.T) {
 		AdminStateUp: &iFalse,
 		Description:  &description,
 	}
-	n, err := trunks.Update(context.TODO(), fake.ServiceClient(), "f6a9718c-5a64-43e3-944f-4deccad8e78c", options).Extract()
+	n, err := trunks.Update(context.TODO(), fake.ServiceClient(fakeServer), "f6a9718c-5a64-43e3-944f-4deccad8e78c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Name, name)
@@ -197,10 +197,10 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestGetSubports(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c/get_subports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c/get_subports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -210,7 +210,7 @@ func TestGetSubports(t *testing.T) {
 		fmt.Fprint(w, ListSubportsResponse)
 	})
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 
 	subports, err := trunks.GetSubports(context.TODO(), client, "f6a9718c-5a64-43e3-944f-4deccad8e78c").Extract()
 	th.AssertNoErr(t, err)
@@ -248,10 +248,10 @@ func TestMissingFields(t *testing.T) {
 }
 
 func TestAddSubports(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c/add_subports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c/add_subports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -262,7 +262,7 @@ func TestAddSubports(t *testing.T) {
 		fmt.Fprint(w, AddSubportsResponse)
 	})
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 
 	opts := trunks.AddSubportsOpts{
 		Subports: ExpectedSubports,
@@ -276,10 +276,10 @@ func TestAddSubports(t *testing.T) {
 }
 
 func TestRemoveSubports(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c/remove_subports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/trunks/f6a9718c-5a64-43e3-944f-4deccad8e78c/remove_subports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -290,7 +290,7 @@ func TestRemoveSubports(t *testing.T) {
 		fmt.Fprint(w, RemoveSubportsResponse)
 	})
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 
 	opts := trunks.RemoveSubportsOpts{
 		Subports: []trunks.RemoveSubport{
diff --git a/openstack/networking/v2/extensions/vlantransparent/testing/requests_test.go b/openstack/networking/v2/extensions/vlantransparent/testing/requests_test.go
index dc5d55043..1850f4db0 100644
--- a/openstack/networking/v2/extensions/vlantransparent/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/vlantransparent/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -32,7 +32,7 @@ func TestList(t *testing.T) {
 	}
 	var actual []networkVLANTransparentExt
 
-	allPages, err := networks.List(fake.ServiceClient(), networks.ListOpts{}).AllPages(context.TODO())
+	allPages, err := networks.List(fake.ServiceClient(fakeServer), networks.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	err = networks.ExtractNetworksInto(allPages, &actual)
@@ -49,10 +49,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/db193ab3-96e3-4cb3-8fc5-05f4296d0324", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/db193ab3-96e3-4cb3-8fc5-05f4296d0324", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -67,7 +67,7 @@ func TestGet(t *testing.T) {
 		vlantransparent.TransparentExt
 	}
 
-	err := networks.Get(context.TODO(), fake.ServiceClient(), "db193ab3-96e3-4cb3-8fc5-05f4296d0324").ExtractInto(&s)
+	err := networks.Get(context.TODO(), fake.ServiceClient(fakeServer), "db193ab3-96e3-4cb3-8fc5-05f4296d0324").ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "db193ab3-96e3-4cb3-8fc5-05f4296d0324", s.ID)
@@ -81,10 +81,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -112,7 +112,7 @@ func TestCreate(t *testing.T) {
 		vlantransparent.TransparentExt
 	}
 
-	err := networks.Create(context.TODO(), fake.ServiceClient(), vlanTransparentCreateOpts).ExtractInto(&s)
+	err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), vlanTransparentCreateOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "db193ab3-96e3-4cb3-8fc5-05f4296d0324", s.ID)
@@ -126,10 +126,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -159,7 +159,7 @@ func TestUpdate(t *testing.T) {
 		vlantransparent.TransparentExt
 	}
 
-	err := networks.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", vlanTransparentUpdateOpts).ExtractInto(&s)
+	err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", vlanTransparentUpdateOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, "db193ab3-96e3-4cb3-8fc5-05f4296d0324", s.ID)
diff --git a/openstack/networking/v2/extensions/vpnaas/endpointgroups/testing/requests_test.go b/openstack/networking/v2/extensions/vpnaas/endpointgroups/testing/requests_test.go
index dbf3ba515..c7620500e 100644
--- a/openstack/networking/v2/extensions/vpnaas/endpointgroups/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/vpnaas/endpointgroups/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/endpoint-groups", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/endpoint-groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -62,7 +62,7 @@ func TestCreate(t *testing.T) {
 			"10.3.0.0/24",
 		},
 	}
-	actual, err := endpointgroups.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	actual, err := endpointgroups.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 	expected := endpointgroups.EndpointGroup{
 		Name:        "peers",
@@ -80,10 +80,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/endpoint-groups/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/endpoint-groups/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -108,7 +108,7 @@ func TestGet(t *testing.T) {
         `)
 	})
 
-	actual, err := endpointgroups.Get(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
+	actual, err := endpointgroups.Get(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
 	th.AssertNoErr(t, err)
 	expected := endpointgroups.EndpointGroup{
 		Name:        "peers",
@@ -126,10 +126,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/endpoint-groups", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/endpoint-groups", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -157,7 +157,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := endpointgroups.List(fake.ServiceClient(), endpointgroups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := endpointgroups.List(fake.ServiceClient(fakeServer), endpointgroups.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := endpointgroups.ExtractEndpointGroups(page)
 		if err != nil {
@@ -190,24 +190,24 @@ func TestList(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/endpoint-groups/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/endpoint-groups/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := endpointgroups.Delete(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
+	res := endpointgroups.Delete(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/endpoint-groups/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/endpoint-groups/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -249,7 +249,7 @@ func TestUpdate(t *testing.T) {
 		Description: &updatedDescription,
 	}
 
-	actual, err := endpointgroups.Update(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
+	actual, err := endpointgroups.Update(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
 	th.AssertNoErr(t, err)
 	expected := endpointgroups.EndpointGroup{
 		Name:        "updatedname",
diff --git a/openstack/networking/v2/extensions/vpnaas/ikepolicies/testing/requests_test.go b/openstack/networking/v2/extensions/vpnaas/ikepolicies/testing/requests_test.go
index e8e63dfde..60b8939a6 100644
--- a/openstack/networking/v2/extensions/vpnaas/ikepolicies/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/vpnaas/ikepolicies/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ikepolicies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ikepolicies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -64,7 +64,7 @@ func TestCreate(t *testing.T) {
 		IKEVersion:  ikepolicies.IKEVersionv2,
 	}
 
-	actual, err := ikepolicies.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	actual, err := ikepolicies.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 	expectedLifetime := ikepolicies.Lifetime{
 		Units: "seconds",
@@ -87,10 +87,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ikepolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ikepolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -119,7 +119,7 @@ func TestGet(t *testing.T) {
         `)
 	})
 
-	actual, err := ikepolicies.Get(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
+	actual, err := ikepolicies.Get(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
 	th.AssertNoErr(t, err)
 	expectedLifetime := ikepolicies.Lifetime{
 		Units: "seconds",
@@ -142,24 +142,24 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ikepolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ikepolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := ikepolicies.Delete(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
+	res := ikepolicies.Delete(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ikepolicies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ikepolicies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -191,7 +191,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := ikepolicies.List(fake.ServiceClient(), ikepolicies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := ikepolicies.List(fake.ServiceClient(fakeServer), ikepolicies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := ikepolicies.ExtractPolicies(page)
 		if err != nil {
@@ -230,10 +230,10 @@ func TestList(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ikepolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ikepolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -285,7 +285,7 @@ func TestUpdate(t *testing.T) {
 		},
 	}
 
-	actual, err := ikepolicies.Update(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
+	actual, err := ikepolicies.Update(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
 	th.AssertNoErr(t, err)
 	expectedLifetime := ikepolicies.Lifetime{
 		Units: "seconds",
diff --git a/openstack/networking/v2/extensions/vpnaas/ipsecpolicies/testing/requests_test.go b/openstack/networking/v2/extensions/vpnaas/ipsecpolicies/testing/requests_test.go
index 35c09a4ad..27435c51a 100644
--- a/openstack/networking/v2/extensions/vpnaas/ipsecpolicies/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/vpnaas/ipsecpolicies/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -78,7 +78,7 @@ func TestCreate(t *testing.T) {
 		Lifetime:            &lifetime,
 		Description:         "",
 	}
-	actual, err := ipsecpolicies.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	actual, err := ipsecpolicies.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 	expectedLifetime := ipsecpolicies.Lifetime{
 		Units: "seconds",
@@ -101,10 +101,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -133,7 +133,7 @@ func TestGet(t *testing.T) {
         `)
 	})
 
-	actual, err := ipsecpolicies.Get(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
+	actual, err := ipsecpolicies.Get(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
 	th.AssertNoErr(t, err)
 	expectedLifetime := ipsecpolicies.Lifetime{
 		Units: "seconds",
@@ -156,24 +156,24 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := ipsecpolicies.Delete(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
+	res := ipsecpolicies.Delete(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -206,7 +206,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := ipsecpolicies.List(fake.ServiceClient(), ipsecpolicies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := ipsecpolicies.List(fake.ServiceClient(fakeServer), ipsecpolicies.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := ipsecpolicies.ExtractPolicies(page)
 		if err != nil {
@@ -245,10 +245,10 @@ func TestList(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsecpolicies/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -300,7 +300,7 @@ func TestUpdate(t *testing.T) {
 		},
 	}
 
-	actual, err := ipsecpolicies.Update(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
+	actual, err := ipsecpolicies.Update(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
 	th.AssertNoErr(t, err)
 	expectedLifetime := ipsecpolicies.Lifetime{
 		Units: "seconds",
diff --git a/openstack/networking/v2/extensions/vpnaas/services/testing/requests_test.go b/openstack/networking/v2/extensions/vpnaas/services/testing/requests_test.go
index c0a33e8d0..84c14a05f 100644
--- a/openstack/networking/v2/extensions/vpnaas/services/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/vpnaas/services/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/vpnservices", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/vpnservices", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -62,7 +62,7 @@ func TestCreate(t *testing.T) {
 		AdminStateUp: gophercloud.Enabled,
 		RouterID:     "66e3b16c-8ce5-40fb-bb49-ab6d8dc3f2aa",
 	}
-	actual, err := services.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	actual, err := services.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 	expected := services.Service{
 		RouterID:     "66e3b16c-8ce5-40fb-bb49-ab6d8dc3f2aa",
@@ -81,10 +81,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/vpnservices", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/vpnservices", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -111,7 +111,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := services.List(fake.ServiceClient(), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := services.List(fake.ServiceClient(fakeServer), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := services.ExtractServices(page)
 		if err != nil {
@@ -144,10 +144,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/vpnservices/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/vpnservices/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -171,7 +171,7 @@ func TestGet(t *testing.T) {
         `)
 	})
 
-	actual, err := services.Get(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
+	actual, err := services.Get(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
 	th.AssertNoErr(t, err)
 	expected := services.Service{
 		Status:       "PENDING_CREATE",
@@ -188,23 +188,23 @@ func TestGet(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/vpnservices/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/vpnservices/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
-	res := services.Delete(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
+	res := services.Delete(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/vpnservices/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/vpnservices/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
@@ -249,7 +249,7 @@ func TestUpdate(t *testing.T) {
 		AdminStateUp: gophercloud.Disabled,
 	}
 
-	actual, err := services.Update(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
+	actual, err := services.Update(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
 	th.AssertNoErr(t, err)
 	expected := services.Service{
 		RouterID:     "66e3b16c-8ce5-40fb-bb49-ab6d8dc3f2aa",
diff --git a/openstack/networking/v2/extensions/vpnaas/siteconnections/testing/requests_test.go b/openstack/networking/v2/extensions/vpnaas/siteconnections/testing/requests_test.go
index 58279b75d..689e153ad 100644
--- a/openstack/networking/v2/extensions/vpnaas/siteconnections/testing/requests_test.go
+++ b/openstack/networking/v2/extensions/vpnaas/siteconnections/testing/requests_test.go
@@ -14,10 +14,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -92,7 +92,7 @@ func TestCreate(t *testing.T) {
 		PeerAddress:    "172.24.4.233",
 		PeerID:         "172.24.4.233",
 	}
-	actual, err := siteconnections.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	actual, err := siteconnections.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 	expectedDPD := siteconnections.DPD{
 		Action:   "hold",
@@ -126,24 +126,24 @@ func TestCreate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := siteconnections.Delete(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
+	res := siteconnections.Delete(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -183,7 +183,7 @@ func TestGet(t *testing.T) {
         `)
 	})
 
-	actual, err := siteconnections.Get(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
+	actual, err := siteconnections.Get(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828").Extract()
 	th.AssertNoErr(t, err)
 	expectedDPD := siteconnections.DPD{
 		Action:   "hold",
@@ -217,10 +217,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -263,7 +263,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := siteconnections.List(fake.ServiceClient(), siteconnections.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := siteconnections.List(fake.ServiceClient(fakeServer), siteconnections.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := siteconnections.ExtractConnections(page)
 		if err != nil {
@@ -314,10 +314,10 @@ func TestList(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/vpn/ipsec-site-connections/5c561d9d-eaea-45f6-ae3e-08d1a7080828", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -379,7 +379,7 @@ func TestUpdate(t *testing.T) {
 		PSK:         "updatedsecret",
 	}
 
-	actual, err := siteconnections.Update(context.TODO(), fake.ServiceClient(), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
+	actual, err := siteconnections.Update(context.TODO(), fake.ServiceClient(fakeServer), "5c561d9d-eaea-45f6-ae3e-08d1a7080828", options).Extract()
 	th.AssertNoErr(t, err)
 
 	expectedDPD := siteconnections.DPD{
diff --git a/openstack/networking/v2/networks/testing/requests_test.go b/openstack/networking/v2/networks/testing/requests_test.go
index f4e905a64..bd8775869 100644
--- a/openstack/networking/v2/networks/testing/requests_test.go
+++ b/openstack/networking/v2/networks/testing/requests_test.go
@@ -15,10 +15,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -28,7 +28,7 @@ func TestList(t *testing.T) {
 		fmt.Fprint(w, ListResponse)
 	})
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 	count := 0
 
 	err := networks.List(client, networks.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -52,10 +52,10 @@ func TestList(t *testing.T) {
 }
 
 func TestListWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -65,7 +65,7 @@ func TestListWithExtensions(t *testing.T) {
 		fmt.Fprint(w, ListResponse)
 	})
 
-	client := fake.ServiceClient()
+	client := fake.ServiceClient(fakeServer)
 
 	type networkWithExt struct {
 		networks.Network
@@ -91,10 +91,10 @@ func TestListWithExtensions(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -104,7 +104,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, GetResponse)
 	})
 
-	n, err := networks.Get(context.TODO(), fake.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
+	n, err := networks.Get(context.TODO(), fake.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &Network1, n)
 	th.AssertEquals(t, n.CreatedAt.Format(time.RFC3339), "2019-06-30T04:15:37Z")
@@ -112,10 +112,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestGetWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/d32019d3-bc6e-4319-9c1d-6722fc136a22", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -130,7 +130,7 @@ func TestGetWithExtensions(t *testing.T) {
 		portsecurity.PortSecurityExt
 	}
 
-	err := networks.Get(context.TODO(), fake.ServiceClient(), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&networkWithExtensions)
+	err := networks.Get(context.TODO(), fake.ServiceClient(fakeServer), "d32019d3-bc6e-4319-9c1d-6722fc136a22").ExtractInto(&networkWithExtensions)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, networkWithExtensions.Status, "ACTIVE")
@@ -138,10 +138,10 @@ func TestGetWithExtensions(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -155,7 +155,7 @@ func TestCreate(t *testing.T) {
 
 	iTrue := true
 	options := networks.CreateOpts{Name: "private", AdminStateUp: &iTrue}
-	n, err := networks.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	n, err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "ACTIVE")
@@ -165,10 +165,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestCreateWithOptionalFields(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -187,15 +187,15 @@ func TestCreateWithOptionalFields(t *testing.T) {
 		TenantID:              "12345",
 		AvailabilityZoneHints: []string{"zone1", "zone2"},
 	}
-	_, err := networks.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	_, err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -211,7 +211,7 @@ func TestUpdate(t *testing.T) {
 	iTrue, iFalse := true, false
 	name := "new_network_name"
 	options := networks.UpdateOpts{Name: &name, AdminStateUp: &iFalse, Shared: &iTrue}
-	n, err := networks.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
+	n, err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Name, "new_network_name")
@@ -223,10 +223,10 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestUpdateRevision(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -240,7 +240,7 @@ func TestUpdateRevision(t *testing.T) {
 		fmt.Fprint(w, UpdateResponse)
 	})
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -257,34 +257,34 @@ func TestUpdateRevision(t *testing.T) {
 	iTrue, iFalse := true, false
 	name := "new_network_name"
 	options := networks.UpdateOpts{Name: &name, AdminStateUp: &iFalse, Shared: &iTrue}
-	_, err := networks.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
+	_, err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	revisionNumber := 42
 	options.RevisionNumber = &revisionNumber
-	_, err = networks.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03d", options).Extract()
+	_, err = networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03d", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := networks.Delete(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c")
+	res := networks.Delete(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestCreatePortSecurity(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -309,7 +309,7 @@ func TestCreatePortSecurity(t *testing.T) {
 		PortSecurityEnabled: &iFalse,
 	}
 
-	err := networks.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractInto(&networkWithExtensions)
+	err := networks.Create(context.TODO(), fake.ServiceClient(fakeServer), createOpts).ExtractInto(&networkWithExtensions)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, networkWithExtensions.Status, "ACTIVE")
@@ -317,10 +317,10 @@ func TestCreatePortSecurity(t *testing.T) {
 }
 
 func TestUpdatePortSecurity(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/networks/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -345,7 +345,7 @@ func TestUpdatePortSecurity(t *testing.T) {
 		PortSecurityEnabled: &iFalse,
 	}
 
-	err := networks.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", updateOpts).ExtractInto(&networkWithExtensions)
+	err := networks.Update(context.TODO(), fake.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", updateOpts).ExtractInto(&networkWithExtensions)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, networkWithExtensions.Name, "private")
diff --git a/openstack/networking/v2/ports/testing/requests_test.go b/openstack/networking/v2/ports/testing/requests_test.go
index 1b7778061..ac1a2cd79 100644
--- a/openstack/networking/v2/ports/testing/requests_test.go
+++ b/openstack/networking/v2/ports/testing/requests_test.go
@@ -17,10 +17,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -32,7 +32,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := ports.List(fake.ServiceClient(), ports.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := ports.List(fake.ServiceClient(fakeServer), ports.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := ports.ExtractPorts(page)
 		if err != nil {
@@ -76,10 +76,10 @@ func TestList(t *testing.T) {
 }
 
 func TestListWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -96,7 +96,7 @@ func TestListWithExtensions(t *testing.T) {
 
 	var allPorts []portWithExt
 
-	allPages, err := ports.List(fake.ServiceClient(), ports.ListOpts{}).AllPages(context.TODO())
+	allPages, err := ports.List(fake.ServiceClient(fakeServer), ports.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	err = ports.ExtractPortsInto(allPages, &allPorts)
@@ -107,10 +107,10 @@ func TestListWithExtensions(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -120,7 +120,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, GetResponse)
 	})
 
-	n, err := ports.Get(context.TODO(), fake.ServiceClient(), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").Extract()
+	n, err := ports.Get(context.TODO(), fake.ServiceClient(fakeServer), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "ACTIVE")
@@ -142,10 +142,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestGetWithExtensions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -160,7 +160,7 @@ func TestGetWithExtensions(t *testing.T) {
 		portsecurity.PortSecurityExt
 	}
 
-	err := ports.Get(context.TODO(), fake.ServiceClient(), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").ExtractInto(&portWithExtensions)
+	err := ports.Get(context.TODO(), fake.ServiceClient(fakeServer), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").ExtractInto(&portWithExtensions)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, portWithExtensions.Status, "ACTIVE")
@@ -168,10 +168,10 @@ func TestGetWithExtensions(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -197,7 +197,7 @@ func TestCreate(t *testing.T) {
 			{IPAddress: "10.0.0.4", MACAddress: "fa:16:3e:c9:cb:f0"},
 		},
 	}
-	n, err := ports.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	n, err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "DOWN")
@@ -218,10 +218,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestCreateOmitSecurityGroups(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -246,7 +246,7 @@ func TestCreateOmitSecurityGroups(t *testing.T) {
 			{IPAddress: "10.0.0.4", MACAddress: "fa:16:3e:c9:cb:f0"},
 		},
 	}
-	n, err := ports.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	n, err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "DOWN")
@@ -267,10 +267,10 @@ func TestCreateOmitSecurityGroups(t *testing.T) {
 }
 
 func TestCreateWithNoSecurityGroup(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -296,7 +296,7 @@ func TestCreateWithNoSecurityGroup(t *testing.T) {
 			{IPAddress: "10.0.0.4", MACAddress: "fa:16:3e:c9:cb:f0"},
 		},
 	}
-	n, err := ports.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	n, err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "DOWN")
@@ -316,10 +316,10 @@ func TestCreateWithNoSecurityGroup(t *testing.T) {
 }
 
 func TestCreateWithPropagateUplinkStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -343,7 +343,7 @@ func TestCreateWithPropagateUplinkStatus(t *testing.T) {
 		},
 		PropagateUplinkStatus: &propagateUplinkStatus,
 	}
-	n, err := ports.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	n, err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "DOWN")
@@ -361,10 +361,10 @@ func TestCreateWithPropagateUplinkStatus(t *testing.T) {
 }
 
 func TestCreateWithValueSpecs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -393,7 +393,7 @@ func TestCreateWithValueSpecs(t *testing.T) {
 			"test": "value",
 		},
 	}
-	n, err := ports.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	n, err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Status, "DOWN")
@@ -414,10 +414,10 @@ func TestCreateWithValueSpecs(t *testing.T) {
 }
 
 func TestCreateWithInvalidValueSpecs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -449,7 +449,7 @@ func TestCreateWithInvalidValueSpecs(t *testing.T) {
 	}
 
 	// We expect an error here since we used a fobidden key in the value specs.
-	_, err := ports.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	_, err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertErr(t, err)
 
 	options.ValueSpecs = &map[string]string{
@@ -458,22 +458,25 @@ func TestCreateWithInvalidValueSpecs(t *testing.T) {
 	}
 
 	// We expect an error here since the value specs would overwrite an existing field.
-	_, err = ports.Create(context.TODO(), fake.ServiceClient(), options).Extract()
+	_, err = ports.Create(context.TODO(), fake.ServiceClient(fakeServer), options).Extract()
 	th.AssertErr(t, err)
 }
 
 func TestRequiredCreateOpts(t *testing.T) {
-	res := ports.Create(context.TODO(), fake.ServiceClient(), ports.CreateOpts{})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), ports.CreateOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestCreatePortSecurity(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -510,7 +513,7 @@ func TestCreatePortSecurity(t *testing.T) {
 		PortSecurityEnabled: &iFalse,
 	}
 
-	err := ports.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractInto(&portWithExt)
+	err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), createOpts).ExtractInto(&portWithExt)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, portWithExt.Status, "DOWN")
@@ -518,10 +521,10 @@ func TestCreatePortSecurity(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -546,7 +549,7 @@ func TestUpdate(t *testing.T) {
 		},
 	}
 
-	s, err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
+	s, err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "new_port_name")
@@ -560,10 +563,10 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestUpdateOmitSecurityGroups(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -587,7 +590,7 @@ func TestUpdateOmitSecurityGroups(t *testing.T) {
 		},
 	}
 
-	s, err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
+	s, err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "new_port_name")
@@ -601,10 +604,10 @@ func TestUpdateOmitSecurityGroups(t *testing.T) {
 }
 
 func TestUpdatePropagateUplinkStatus(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -622,17 +625,17 @@ func TestUpdatePropagateUplinkStatus(t *testing.T) {
 		PropagateUplinkStatus: &propagateUplinkStatus,
 	}
 
-	s, err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
+	s, err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, s.PropagateUplinkStatus, propagateUplinkStatus)
 }
 
 func TestUpdateValueSpecs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -651,15 +654,15 @@ func TestUpdateValueSpecs(t *testing.T) {
 		},
 	}
 
-	_, err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
+	_, err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdatePortSecurity(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -684,7 +687,7 @@ func TestUpdatePortSecurity(t *testing.T) {
 		PortSecurityEnabled: &iFalse,
 	}
 
-	err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&portWithExt)
+	err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&portWithExt)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, portWithExt.Status, "DOWN")
@@ -693,10 +696,10 @@ func TestUpdatePortSecurity(t *testing.T) {
 }
 
 func TestUpdateRevision(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -709,7 +712,7 @@ func TestUpdateRevision(t *testing.T) {
 
 		fmt.Fprint(w, UpdateResponse)
 	})
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0e", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -734,20 +737,20 @@ func TestUpdateRevision(t *testing.T) {
 			{IPAddress: "10.0.0.4", MACAddress: "fa:16:3e:c9:cb:f0"},
 		},
 	}
-	_, err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
+	_, err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
 	th.AssertNoErr(t, err)
 
 	revisionNumber := 42
 	options.RevisionNumber = &revisionNumber
-	_, err = ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0e", options).Extract()
+	_, err = ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0e", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestRemoveSecurityGroups(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -772,7 +775,7 @@ func TestRemoveSecurityGroups(t *testing.T) {
 		},
 	}
 
-	s, err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
+	s, err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "new_port_name")
@@ -786,10 +789,10 @@ func TestRemoveSecurityGroups(t *testing.T) {
 }
 
 func TestRemoveAllowedAddressPairs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -812,7 +815,7 @@ func TestRemoveAllowedAddressPairs(t *testing.T) {
 		AllowedAddressPairs: &[]ports.AddressPair{},
 	}
 
-	s, err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
+	s, err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "new_port_name")
@@ -824,10 +827,10 @@ func TestRemoveAllowedAddressPairs(t *testing.T) {
 }
 
 func TestDontUpdateAllowedAddressPairs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -849,7 +852,7 @@ func TestDontUpdateAllowedAddressPairs(t *testing.T) {
 		SecurityGroups: &[]string{"f0ac4394-7e4a-4409-9701-ba8be283dbc3"},
 	}
 
-	s, err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
+	s, err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "new_port_name")
@@ -863,24 +866,24 @@ func TestDontUpdateAllowedAddressPairs(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := ports.Delete(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d")
+	res := ports.Delete(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetWithExtraDHCPOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -895,7 +898,7 @@ func TestGetWithExtraDHCPOpts(t *testing.T) {
 		extradhcpopts.ExtraDHCPOptsExt
 	}
 
-	err := ports.Get(context.TODO(), fake.ServiceClient(), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").ExtractInto(&s)
+	err := ports.Get(context.TODO(), fake.ServiceClient(fakeServer), "46d4bfb9-b26e-41f3-bd2e-e6dcc1ccedb2").ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, "ACTIVE")
@@ -920,10 +923,10 @@ func TestGetWithExtraDHCPOpts(t *testing.T) {
 }
 
 func TestCreateWithExtraDHCPOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -961,7 +964,7 @@ func TestCreateWithExtraDHCPOpts(t *testing.T) {
 		extradhcpopts.ExtraDHCPOptsExt
 	}
 
-	err := ports.Create(context.TODO(), fake.ServiceClient(), createOpts).ExtractInto(&s)
+	err := ports.Create(context.TODO(), fake.ServiceClient(fakeServer), createOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, "DOWN")
@@ -983,10 +986,10 @@ func TestCreateWithExtraDHCPOpts(t *testing.T) {
 }
 
 func TestUpdateWithExtraDHCPOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/ports/65c0ee9f-d634-4522-8954-51021b570b0d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -1026,7 +1029,7 @@ func TestUpdateWithExtraDHCPOpts(t *testing.T) {
 		extradhcpopts.ExtraDHCPOptsExt
 	}
 
-	err := ports.Update(context.TODO(), fake.ServiceClient(), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&s)
+	err := ports.Update(context.TODO(), fake.ServiceClient(fakeServer), "65c0ee9f-d634-4522-8954-51021b570b0d", updateOpts).ExtractInto(&s)
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Status, "DOWN")
diff --git a/openstack/networking/v2/subnets/testing/requests_test.go b/openstack/networking/v2/subnets/testing/requests_test.go
index 41ec607cd..fd8c810db 100644
--- a/openstack/networking/v2/subnets/testing/requests_test.go
+++ b/openstack/networking/v2/subnets/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 )
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -28,7 +28,7 @@ func TestList(t *testing.T) {
 
 	count := 0
 
-	err := subnets.List(fake.ServiceClient(), subnets.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := subnets.List(fake.ServiceClient(fakeServer), subnets.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := subnets.ExtractSubnets(page)
 		if err != nil {
@@ -55,10 +55,10 @@ func TestList(t *testing.T) {
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/54d6f61d-db07-451c-9ab3-b9609b6b6f0b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/54d6f61d-db07-451c-9ab3-b9609b6b6f0b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 
@@ -68,7 +68,7 @@ func TestGet(t *testing.T) {
 		fmt.Fprint(w, SubnetGetResult)
 	})
 
-	s, err := subnets.Get(context.TODO(), fake.ServiceClient(), "54d6f61d-db07-451c-9ab3-b9609b6b6f0b").Extract()
+	s, err := subnets.Get(context.TODO(), fake.ServiceClient(fakeServer), "54d6f61d-db07-451c-9ab3-b9609b6b6f0b").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "my_subnet")
@@ -91,10 +91,10 @@ func TestGet(t *testing.T) {
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -128,7 +128,7 @@ func TestCreate(t *testing.T) {
 		},
 		SubnetPoolID: "b80340c7-9960-4f67-a99c-02501656284b",
 	}
-	s, err := subnets.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	s, err := subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "")
@@ -153,10 +153,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestCreateNoGateway(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -183,7 +183,7 @@ func TestCreateNoGateway(t *testing.T) {
 		},
 		DNSNameservers: []string{},
 	}
-	s, err := subnets.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	s, err := subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "")
@@ -204,10 +204,10 @@ func TestCreateNoGateway(t *testing.T) {
 }
 
 func TestCreateDefaultGateway(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -232,7 +232,7 @@ func TestCreateDefaultGateway(t *testing.T) {
 		},
 		DNSNameservers: []string{},
 	}
-	s, err := subnets.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	s, err := subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "")
@@ -253,10 +253,10 @@ func TestCreateDefaultGateway(t *testing.T) {
 }
 
 func TestCreateIPv6RaAddressMode(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -278,7 +278,7 @@ func TestCreateIPv6RaAddressMode(t *testing.T) {
 		IPv6AddressMode: "slaac",
 		IPv6RAMode:      "slaac",
 	}
-	s, err := subnets.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	s, err := subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "")
@@ -294,10 +294,10 @@ func TestCreateIPv6RaAddressMode(t *testing.T) {
 }
 
 func TestCreateWithNoCIDR(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -319,7 +319,7 @@ func TestCreateWithNoCIDR(t *testing.T) {
 		},
 		SubnetPoolID: "b80340c7-9960-4f67-a99c-02501656284b",
 	}
-	s, err := subnets.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	s, err := subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "")
@@ -343,10 +343,10 @@ func TestCreateWithNoCIDR(t *testing.T) {
 }
 
 func TestCreateWithPrefixlen(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -369,7 +369,7 @@ func TestCreateWithPrefixlen(t *testing.T) {
 		SubnetPoolID: "b80340c7-9960-4f67-a99c-02501656284b",
 		Prefixlen:    12,
 	}
-	s, err := subnets.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	s, err := subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "")
@@ -393,27 +393,30 @@ func TestCreateWithPrefixlen(t *testing.T) {
 }
 
 func TestRequiredCreateOpts(t *testing.T) {
-	res := subnets.Create(context.TODO(), fake.ServiceClient(), subnets.CreateOpts{})
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	res := subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), subnets.CreateOpts{})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 
-	res = subnets.Create(context.TODO(), fake.ServiceClient(), subnets.CreateOpts{NetworkID: "foo"})
+	res = subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), subnets.CreateOpts{NetworkID: "foo"})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 
-	res = subnets.Create(context.TODO(), fake.ServiceClient(), subnets.CreateOpts{NetworkID: "foo", CIDR: "bar", IPVersion: 40})
+	res = subnets.Create(context.TODO(), fake.ServiceClient(fakeServer), subnets.CreateOpts{NetworkID: "foo", CIDR: "bar", IPVersion: 40})
 	if res.Err == nil {
 		t.Fatalf("Expected error, got none")
 	}
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -435,7 +438,7 @@ func TestUpdate(t *testing.T) {
 			{NextHop: "bar"},
 		},
 	}
-	s, err := subnets.Update(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
+	s, err := subnets.Update(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "my_new_subnet")
@@ -443,10 +446,10 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestUpdateGateway(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -465,7 +468,7 @@ func TestUpdateGateway(t *testing.T) {
 		Name:      &name,
 		GatewayIP: &gatewayIP,
 	}
-	s, err := subnets.Update(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
+	s, err := subnets.Update(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "my_new_subnet")
@@ -474,10 +477,10 @@ func TestUpdateGateway(t *testing.T) {
 }
 
 func TestUpdateRemoveGateway(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -496,7 +499,7 @@ func TestUpdateRemoveGateway(t *testing.T) {
 		Name:      &name,
 		GatewayIP: &noGateway,
 	}
-	s, err := subnets.Update(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
+	s, err := subnets.Update(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "my_new_subnet")
@@ -505,10 +508,10 @@ func TestUpdateRemoveGateway(t *testing.T) {
 }
 
 func TestUpdateHostRoutes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -533,7 +536,7 @@ func TestUpdateHostRoutes(t *testing.T) {
 		Name:       &name,
 		HostRoutes: &HostRoutes,
 	}
-	s, err := subnets.Update(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
+	s, err := subnets.Update(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "my_new_subnet")
@@ -542,10 +545,10 @@ func TestUpdateHostRoutes(t *testing.T) {
 }
 
 func TestUpdateRemoveHostRoutes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -562,7 +565,7 @@ func TestUpdateRemoveHostRoutes(t *testing.T) {
 	opts := subnets.UpdateOpts{
 		HostRoutes: &noHostRoutes,
 	}
-	s, err := subnets.Update(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
+	s, err := subnets.Update(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "my_new_subnet")
@@ -571,10 +574,10 @@ func TestUpdateRemoveHostRoutes(t *testing.T) {
 }
 
 func TestUpdateAllocationPool(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -597,7 +600,7 @@ func TestUpdateAllocationPool(t *testing.T) {
 			},
 		},
 	}
-	s, err := subnets.Update(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
+	s, err := subnets.Update(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "my_new_subnet")
@@ -611,10 +614,10 @@ func TestUpdateAllocationPool(t *testing.T) {
 }
 
 func TestUpdateRevision(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -628,7 +631,7 @@ func TestUpdateRevision(t *testing.T) {
 		fmt.Fprint(w, SubnetUpdateResponse)
 	})
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1c", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
@@ -651,25 +654,25 @@ func TestUpdateRevision(t *testing.T) {
 			{NextHop: "bar"},
 		},
 	}
-	_, err := subnets.Update(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
+	_, err := subnets.Update(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1b", opts).Extract()
 	th.AssertNoErr(t, err)
 
 	revisionNumber := 42
 	opts.RevisionNumber = &revisionNumber
-	_, err = subnets.Update(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1c", opts).Extract()
+	_, err = subnets.Update(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1c", opts).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/subnets/08eae331-0402-425a-923c-34f7cfe39c1b", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 
-	res := subnets.Delete(context.TODO(), fake.ServiceClient(), "08eae331-0402-425a-923c-34f7cfe39c1b")
+	res := subnets.Delete(context.TODO(), fake.ServiceClient(fakeServer), "08eae331-0402-425a-923c-34f7cfe39c1b")
 	th.AssertNoErr(t, res.Err)
 }
diff --git a/openstack/objectstorage/v1/accounts/testing/fixtures.go b/openstack/objectstorage/v1/accounts/testing/fixtures.go
index 42284933e..5e97d2de6 100644
--- a/openstack/objectstorage/v1/accounts/testing/fixtures.go
+++ b/openstack/objectstorage/v1/accounts/testing/fixtures.go
@@ -5,15 +5,15 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // HandleGetAccountSuccessfully creates an HTTP handler at `/` on the test handler mux that
 // responds with a `Get` response.
-func HandleGetAccountSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetAccountSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("X-Account-Container-Count", "2")
 		w.Header().Set("X-Account-Object-Count", "5")
@@ -29,10 +29,10 @@ func HandleGetAccountSuccessfully(t *testing.T) {
 
 // HandleGetAccountNoQuotaSuccessfully creates an HTTP handler at `/` on the
 // test handler mux that responds with a `Get` response.
-func HandleGetAccountNoQuotaSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetAccountNoQuotaSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Set("X-Account-Container-Count", "2")
 		w.Header().Set("X-Account-Object-Count", "5")
@@ -46,10 +46,10 @@ func HandleGetAccountNoQuotaSuccessfully(t *testing.T) {
 
 // HandleUpdateAccountSuccessfully creates an HTTP handler at `/` on the test handler mux that
 // responds with a `Update` response.
-func HandleUpdateAccountSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateAccountSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "X-Account-Meta-Gophercloud-Test", "accounts")
 		th.TestHeader(t, r, "X-Remove-Account-Meta-Gophercloud-Test-Remove", "remove")
 		th.TestHeader(t, r, "Content-Type", "")
diff --git a/openstack/objectstorage/v1/accounts/testing/requests_test.go b/openstack/objectstorage/v1/accounts/testing/requests_test.go
index 6ed29c1ae..19067efbb 100644
--- a/openstack/objectstorage/v1/accounts/testing/requests_test.go
+++ b/openstack/objectstorage/v1/accounts/testing/requests_test.go
@@ -7,13 +7,13 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/objectstorage/v1/accounts"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestUpdateAccount(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateAccountSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateAccountSuccessfully(t, fakeServer)
 
 	options := &accounts.UpdateOpts{
 		Metadata:          map[string]string{"gophercloud-test": "accounts"},
@@ -21,7 +21,7 @@ func TestUpdateAccount(t *testing.T) {
 		ContentType:       new(string),
 		DetectContentType: new(bool),
 	}
-	res := accounts.Update(context.TODO(), fake.ServiceClient(), options)
+	res := accounts.Update(context.TODO(), client.ServiceClient(fakeServer), options)
 	th.AssertNoErr(t, res.Err)
 
 	expected := &accounts.UpdateHeader{
@@ -33,12 +33,12 @@ func TestUpdateAccount(t *testing.T) {
 }
 
 func TestGetAccount(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetAccountSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetAccountSuccessfully(t, fakeServer)
 
 	expectedMetadata := map[string]string{"Subject": "books", "Quota-Bytes": "42", "Temp-Url-Key": "testsecret"}
-	res := accounts.Get(context.TODO(), fake.ServiceClient(), &accounts.GetOpts{})
+	res := accounts.Get(context.TODO(), client.ServiceClient(fakeServer), &accounts.GetOpts{})
 	th.AssertNoErr(t, res.Err)
 	actualMetadata, _ := res.ExtractMetadata()
 	th.CheckDeepEquals(t, expectedMetadata, actualMetadata)
@@ -60,12 +60,12 @@ func TestGetAccount(t *testing.T) {
 }
 
 func TestGetAccountNoQuota(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetAccountNoQuotaSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetAccountNoQuotaSuccessfully(t, fakeServer)
 
 	expectedMetadata := map[string]string{"Subject": "books"}
-	res := accounts.Get(context.TODO(), fake.ServiceClient(), &accounts.GetOpts{})
+	res := accounts.Get(context.TODO(), client.ServiceClient(fakeServer), &accounts.GetOpts{})
 	th.AssertNoErr(t, res.Err)
 	actualMetadata, _ := res.ExtractMetadata()
 	th.CheckDeepEquals(t, expectedMetadata, actualMetadata)
diff --git a/openstack/objectstorage/v1/containers/testing/fixtures.go b/openstack/objectstorage/v1/containers/testing/fixtures.go
index 35c0f734c..8e35743a7 100644
--- a/openstack/objectstorage/v1/containers/testing/fixtures.go
+++ b/openstack/objectstorage/v1/containers/testing/fixtures.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/objectstorage/v1/containers"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 type handlerOptions struct {
@@ -43,10 +43,10 @@ var ExpectedListNames = []string{"janeausten", "marktwain"}
 
 // HandleListContainerInfoSuccessfully creates an HTTP handler at `/` on the test handler mux that
 // responds with a `List` response when full info is requested.
-func HandleListContainerInfoSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func HandleListContainerInfoSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -87,10 +87,10 @@ func HandleListContainerInfoSuccessfully(t *testing.T) {
 // HandleListZeroContainerNames204 creates an HTTP handler at `/` on the test handler mux that
 // responds with "204 No Content" when container names are requested. This happens on some, but not all,
 // objectstorage instances. This case is peculiar in that the server sends no `content-type` header.
-func HandleListZeroContainerNames204(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func HandleListZeroContainerNames204(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.WriteHeader(http.StatusNoContent)
@@ -99,10 +99,10 @@ func HandleListZeroContainerNames204(t *testing.T) {
 
 // HandleCreateContainerSuccessfully creates an HTTP handler at `/testContainer` on the test handler mux that
 // responds with a `Create` response.
-func HandleCreateContainerSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/testContainer", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateContainerSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/testContainer", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Add("X-Container-Meta-Foo", "bar")
@@ -117,7 +117,7 @@ func HandleCreateContainerSuccessfully(t *testing.T) {
 
 // HandleDeleteContainerSuccessfully creates an HTTP handler at `/testContainer` on the test handler mux that
 // responds with a `Delete` response.
-func HandleDeleteContainerSuccessfully(t *testing.T, options ...option) {
+func HandleDeleteContainerSuccessfully(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer",
 	}
@@ -125,9 +125,9 @@ func HandleDeleteContainerSuccessfully(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.WriteHeader(http.StatusNoContent)
 	})
@@ -145,10 +145,10 @@ const bulkDeleteResponse = `
 
 // HandleBulkDeleteSuccessfully creates an HTTP handler at `/` on the test
 // handler mux that responds with a `Delete` response.
-func HandleBulkDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func HandleBulkDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "Content-Type", "text/plain")
 		th.TestFormValues(t, r, map[string]string{
@@ -164,7 +164,7 @@ func HandleBulkDeleteSuccessfully(t *testing.T) {
 
 // HandleUpdateContainerSuccessfully creates an HTTP handler at `/testContainer` on the test handler mux that
 // responds with a `Update` response.
-func HandleUpdateContainerSuccessfully(t *testing.T, options ...option) {
+func HandleUpdateContainerSuccessfully(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer",
 	}
@@ -172,9 +172,9 @@ func HandleUpdateContainerSuccessfully(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Container-Write", "")
 		th.TestHeader(t, r, "X-Container-Read", "")
@@ -187,7 +187,7 @@ func HandleUpdateContainerSuccessfully(t *testing.T, options ...option) {
 
 // HandleUpdateContainerVersioningOn creates an HTTP handler at `/testVersioning` on the test handler mux that
 // responds with a `Update` response.
-func HandleUpdateContainerVersioningOn(t *testing.T, options ...option) {
+func HandleUpdateContainerVersioningOn(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testVersioning",
 	}
@@ -195,9 +195,9 @@ func HandleUpdateContainerVersioningOn(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Container-Write", "")
 		th.TestHeader(t, r, "X-Container-Read", "")
@@ -211,7 +211,7 @@ func HandleUpdateContainerVersioningOn(t *testing.T, options ...option) {
 
 // HandleUpdateContainerVersioningOff creates an HTTP handler at `/testVersioning` on the test handler mux that
 // responds with a `Update` response.
-func HandleUpdateContainerVersioningOff(t *testing.T, options ...option) {
+func HandleUpdateContainerVersioningOff(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testVersioning",
 	}
@@ -219,9 +219,9 @@ func HandleUpdateContainerVersioningOff(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Container-Write", "")
 		th.TestHeader(t, r, "X-Container-Read", "")
@@ -235,7 +235,7 @@ func HandleUpdateContainerVersioningOff(t *testing.T, options ...option) {
 
 // HandleGetContainerSuccessfully creates an HTTP handler at `/testContainer` on the test handler mux that
 // responds with a `Get` response.
-func HandleGetContainerSuccessfully(t *testing.T, options ...option) {
+func HandleGetContainerSuccessfully(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer",
 	}
@@ -243,9 +243,9 @@ func HandleGetContainerSuccessfully(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.Header().Set("Accept-Ranges", "bytes")
 		w.Header().Set("Content-Type", "application/json; charset=utf-8")
diff --git a/openstack/objectstorage/v1/containers/testing/requests_test.go b/openstack/objectstorage/v1/containers/testing/requests_test.go
index fedf0f2fe..5fcc669ba 100644
--- a/openstack/objectstorage/v1/containers/testing/requests_test.go
+++ b/openstack/objectstorage/v1/containers/testing/requests_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/objectstorage/v1/containers"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestContainerNames(t *testing.T) {
@@ -31,25 +31,25 @@ func TestContainerNames(t *testing.T) {
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Run("create", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleCreateContainerSuccessfully(t)
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleCreateContainerSuccessfully(t, fakeServer)
 
-				_, err := containers.Create(context.TODO(), fake.ServiceClient(), tc.containerName, nil).Extract()
+				_, err := containers.Create(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, nil).Extract()
 				th.CheckErr(t, err, &tc.expectedError)
 			})
 			t.Run("delete", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleDeleteContainerSuccessfully(t, WithPath("/"))
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleDeleteContainerSuccessfully(t, fakeServer, WithPath("/"))
 
-				res := containers.Delete(context.TODO(), fake.ServiceClient(), tc.containerName)
+				res := containers.Delete(context.TODO(), client.ServiceClient(fakeServer), tc.containerName)
 				th.CheckErr(t, res.Err, &tc.expectedError)
 			})
 			t.Run("update", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleUpdateContainerSuccessfully(t, WithPath("/"))
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleUpdateContainerSuccessfully(t, fakeServer, WithPath("/"))
 
 				contentType := "text/plain"
 				options := &containers.UpdateOpts{
@@ -60,15 +60,15 @@ func TestContainerNames(t *testing.T) {
 					ContainerSyncKey: new(string),
 					ContentType:      &contentType,
 				}
-				res := containers.Update(context.TODO(), fake.ServiceClient(), tc.containerName, options)
+				res := containers.Update(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, options)
 				th.CheckErr(t, res.Err, &tc.expectedError)
 			})
 			t.Run("get", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleGetContainerSuccessfully(t, WithPath("/"))
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleGetContainerSuccessfully(t, fakeServer, WithPath("/"))
 
-				res := containers.Get(context.TODO(), fake.ServiceClient(), tc.containerName, nil)
+				res := containers.Get(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, nil)
 				_, err := res.ExtractMetadata()
 				th.CheckErr(t, err, &tc.expectedError)
 
@@ -80,12 +80,12 @@ func TestContainerNames(t *testing.T) {
 }
 
 func TestListContainerInfo(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListContainerInfoSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListContainerInfoSuccessfully(t, fakeServer)
 
 	count := 0
-	err := containers.List(fake.ServiceClient(), &containers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := containers.List(client.ServiceClient(fakeServer), &containers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := containers.ExtractInfo(page)
 		th.AssertNoErr(t, err)
@@ -99,11 +99,11 @@ func TestListContainerInfo(t *testing.T) {
 }
 
 func TestListAllContainerInfo(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListContainerInfoSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListContainerInfoSuccessfully(t, fakeServer)
 
-	allPages, err := containers.List(fake.ServiceClient(), &containers.ListOpts{}).AllPages(context.TODO())
+	allPages, err := containers.List(client.ServiceClient(fakeServer), &containers.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := containers.ExtractInfo(allPages)
 	th.AssertNoErr(t, err)
@@ -111,12 +111,12 @@ func TestListAllContainerInfo(t *testing.T) {
 }
 
 func TestListContainerNames(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListContainerInfoSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListContainerInfoSuccessfully(t, fakeServer)
 
 	count := 0
-	err := containers.List(fake.ServiceClient(), &containers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := containers.List(client.ServiceClient(fakeServer), &containers.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := containers.ExtractNames(page)
 		if err != nil {
@@ -133,11 +133,11 @@ func TestListContainerNames(t *testing.T) {
 }
 
 func TestListAllContainerNames(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListContainerInfoSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListContainerInfoSuccessfully(t, fakeServer)
 
-	allPages, err := containers.List(fake.ServiceClient(), &containers.ListOpts{}).AllPages(context.TODO())
+	allPages, err := containers.List(client.ServiceClient(fakeServer), &containers.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := containers.ExtractNames(allPages)
 	th.AssertNoErr(t, err)
@@ -145,11 +145,11 @@ func TestListAllContainerNames(t *testing.T) {
 }
 
 func TestListZeroContainerNames(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListZeroContainerNames204(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListZeroContainerNames204(t, fakeServer)
 
-	allPages, err := containers.List(fake.ServiceClient(), &containers.ListOpts{}).AllPages(context.TODO())
+	allPages, err := containers.List(client.ServiceClient(fakeServer), &containers.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := containers.ExtractNames(allPages)
 	th.AssertNoErr(t, err)
@@ -157,12 +157,12 @@ func TestListZeroContainerNames(t *testing.T) {
 }
 
 func TestCreateContainer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateContainerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateContainerSuccessfully(t, fakeServer)
 
 	options := containers.CreateOpts{ContentType: "application/json", Metadata: map[string]string{"foo": "bar"}}
-	res := containers.Create(context.TODO(), fake.ServiceClient(), "testContainer", options)
+	res := containers.Create(context.TODO(), client.ServiceClient(fakeServer), "testContainer", options)
 	th.CheckEquals(t, "bar", res.Header["X-Container-Meta-Foo"][0])
 
 	expected := &containers.CreateHeader{
@@ -177,18 +177,18 @@ func TestCreateContainer(t *testing.T) {
 }
 
 func TestDeleteContainer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteContainerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteContainerSuccessfully(t, fakeServer)
 
-	res := containers.Delete(context.TODO(), fake.ServiceClient(), "testContainer")
+	res := containers.Delete(context.TODO(), client.ServiceClient(fakeServer), "testContainer")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestBulkDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleBulkDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleBulkDeleteSuccessfully(t, fakeServer)
 
 	expected := containers.BulkDeleteResponse{
 		ResponseStatus: "foo",
@@ -197,15 +197,15 @@ func TestBulkDelete(t *testing.T) {
 		Errors:         [][]string{},
 	}
 
-	resp, err := containers.BulkDelete(context.TODO(), fake.ServiceClient(), []string{"testContainer1", "testContainer2"}).Extract()
+	resp, err := containers.BulkDelete(context.TODO(), client.ServiceClient(fakeServer), []string{"testContainer1", "testContainer2"}).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expected, *resp)
 }
 
 func TestUpdateContainer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateContainerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateContainerSuccessfully(t, fakeServer)
 
 	contentType := "text/plain"
 	options := &containers.UpdateOpts{
@@ -216,19 +216,19 @@ func TestUpdateContainer(t *testing.T) {
 		ContainerSyncKey: new(string),
 		ContentType:      &contentType,
 	}
-	res := containers.Update(context.TODO(), fake.ServiceClient(), "testContainer", options)
+	res := containers.Update(context.TODO(), client.ServiceClient(fakeServer), "testContainer", options)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetContainer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetContainerSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetContainerSuccessfully(t, fakeServer)
 
 	getOpts := containers.GetOpts{
 		Newest: true,
 	}
-	res := containers.Get(context.TODO(), fake.ServiceClient(), "testContainer", getOpts)
+	res := containers.Get(context.TODO(), client.ServiceClient(fakeServer), "testContainer", getOpts)
 	_, err := res.ExtractMetadata()
 	th.AssertNoErr(t, err)
 
@@ -253,9 +253,9 @@ func TestGetContainer(t *testing.T) {
 }
 
 func TestUpdateContainerVersioningOff(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateContainerVersioningOff(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateContainerVersioningOff(t, fakeServer)
 
 	contentType := "text/plain"
 	options := &containers.UpdateOpts{
@@ -267,14 +267,14 @@ func TestUpdateContainerVersioningOff(t *testing.T) {
 		ContentType:      &contentType,
 		VersionsEnabled:  new(bool),
 	}
-	_, err := containers.Update(context.TODO(), fake.ServiceClient(), "testVersioning", options).Extract()
+	_, err := containers.Update(context.TODO(), client.ServiceClient(fakeServer), "testVersioning", options).Extract()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdateContainerVersioningOn(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateContainerVersioningOn(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateContainerVersioningOn(t, fakeServer)
 
 	iTrue := true
 	contentType := "text/plain"
@@ -287,6 +287,6 @@ func TestUpdateContainerVersioningOn(t *testing.T) {
 		ContentType:      &contentType,
 		VersionsEnabled:  &iTrue,
 	}
-	_, err := containers.Update(context.TODO(), fake.ServiceClient(), "testVersioning", options).Extract()
+	_, err := containers.Update(context.TODO(), client.ServiceClient(fakeServer), "testVersioning", options).Extract()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/objectstorage/v1/objects/testing/fixtures_test.go b/openstack/objectstorage/v1/objects/testing/fixtures_test.go
index f4546d6ab..b6c6f7814 100644
--- a/openstack/objectstorage/v1/objects/testing/fixtures_test.go
+++ b/openstack/objectstorage/v1/objects/testing/fixtures_test.go
@@ -10,7 +10,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/objectstorage/v1/objects"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 type handlerOptions struct {
@@ -27,7 +27,7 @@ func WithPath(s string) option {
 
 // HandleDownloadObjectSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler mux that
 // responds with a `Download` response.
-func HandleDownloadObjectSuccessfully(t *testing.T, options ...option) {
+func HandleDownloadObjectSuccessfully(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer/testObject",
 	}
@@ -35,10 +35,10 @@ func HandleDownloadObjectSuccessfully(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		date := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.Header().Set("Date", date.Format(time.RFC1123))
 		w.Header().Set("X-Static-Large-Object", "True")
@@ -98,7 +98,7 @@ var ExpectedListNames = []string{"goodbye", "hello"}
 
 // HandleListObjectsInfoSuccessfully creates an HTTP handler at `/testContainer` on the test handler mux that
 // responds with a `List` response when full info is requested.
-func HandleListObjectsInfoSuccessfully(t *testing.T, options ...option) {
+func HandleListObjectsInfoSuccessfully(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer",
 	}
@@ -106,9 +106,9 @@ func HandleListObjectsInfoSuccessfully(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -144,10 +144,10 @@ func HandleListObjectsInfoSuccessfully(t *testing.T, options ...option) {
 
 // HandleListSubdirSuccessfully creates an HTTP handler at `/testContainer` on the test handler mux that
 // responds with a `List` response when full info is requested.
-func HandleListSubdirSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/testContainer", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSubdirSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/testContainer", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -173,10 +173,10 @@ func HandleListSubdirSuccessfully(t *testing.T) {
 // HandleListZeroObjectNames204 creates an HTTP handler at `/testContainer` on the test handler mux that
 // responds with "204 No Content" when object names are requested. This happens on some, but not all, objectstorage
 // instances. This case is peculiar in that the server sends no `content-type` header.
-func HandleListZeroObjectNames204(t *testing.T) {
-	th.Mux.HandleFunc("/testContainer", func(w http.ResponseWriter, r *http.Request) {
+func HandleListZeroObjectNames204(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/testContainer", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.WriteHeader(http.StatusNoContent)
@@ -185,7 +185,7 @@ func HandleListZeroObjectNames204(t *testing.T) {
 
 // HandleCreateTextObjectSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler mux
 // that responds with a `Create` response. A Content-Type of "text/plain" is expected.
-func HandleCreateTextObjectSuccessfully(t *testing.T, content string, options ...option) {
+func HandleCreateTextObjectSuccessfully(t *testing.T, fakeServer th.FakeServer, content string, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer/testObject",
 	}
@@ -193,9 +193,9 @@ func HandleCreateTextObjectSuccessfully(t *testing.T, content string, options ..
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "text/plain")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestBody(t, r, `Did gyre and gimble in the wabe`)
@@ -212,10 +212,10 @@ func HandleCreateTextObjectSuccessfully(t *testing.T, content string, options ..
 
 // HandleCreateTextWithCacheControlSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler
 // mux that responds with a `Create` response. A Cache-Control of `max-age="3600", public` is expected.
-func HandleCreateTextWithCacheControlSuccessfully(t *testing.T, content string) {
-	th.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateTextWithCacheControlSuccessfully(t *testing.T, fakeServer th.FakeServer, content string) {
+	fakeServer.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Cache-Control", `max-age="3600", public`)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestBody(t, r, `All mimsy were the borogoves`)
@@ -233,10 +233,10 @@ func HandleCreateTextWithCacheControlSuccessfully(t *testing.T, content string)
 // HandleCreateTypelessObjectSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler
 // mux that responds with a `Create` response. No Content-Type header may be present in the request, so that server-
 // side content-type detection will be triggered properly.
-func HandleCreateTypelessObjectSuccessfully(t *testing.T, content string) {
-	th.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateTypelessObjectSuccessfully(t *testing.T, fakeServer th.FakeServer, content string) {
+	fakeServer.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestBody(t, r, `The sky was the color of television, tuned to a dead channel.`)
 
@@ -256,10 +256,10 @@ func HandleCreateTypelessObjectSuccessfully(t *testing.T, content string) {
 
 // HandleCopyObjectSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler mux that
 // responds with a `Copy` response.
-func HandleCopyObjectSuccessfully(t *testing.T, destination string) {
-	th.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
+func HandleCopyObjectSuccessfully(t *testing.T, fakeServer th.FakeServer, destination string) {
+	fakeServer.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "COPY")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "Destination", destination)
 		w.WriteHeader(http.StatusCreated)
@@ -268,10 +268,10 @@ func HandleCopyObjectSuccessfully(t *testing.T, destination string) {
 
 // HandleCopyObjectSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler mux that
 // responds with a `Copy` response.
-func HandleCopyObjectVersionSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
+func HandleCopyObjectVersionSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/testContainer/testObject", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "COPY")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "Destination", "/newTestContainer/newTestObject")
 		th.TestFormValues(t, r, map[string]string{"version-id": "123456788"})
@@ -282,7 +282,7 @@ func HandleCopyObjectVersionSuccessfully(t *testing.T) {
 
 // HandleDeleteObjectSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler mux that
 // responds with a `Delete` response.
-func HandleDeleteObjectSuccessfully(t *testing.T, options ...option) {
+func HandleDeleteObjectSuccessfully(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer/testObject",
 	}
@@ -290,9 +290,9 @@ func HandleDeleteObjectSuccessfully(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.WriteHeader(http.StatusNoContent)
 	})
@@ -310,10 +310,10 @@ const bulkDeleteResponse = `
 
 // HandleBulkDeleteSuccessfully creates an HTTP handler at `/` on the test
 // handler mux that responds with a `BulkDelete` response.
-func HandleBulkDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func HandleBulkDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "Content-Type", "text/plain")
 		th.TestFormValues(t, r, map[string]string{
@@ -329,7 +329,7 @@ func HandleBulkDeleteSuccessfully(t *testing.T) {
 
 // HandleUpdateObjectSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler mux that
 // responds with a `Update` response.
-func HandleUpdateObjectSuccessfully(t *testing.T, options ...option) {
+func HandleUpdateObjectSuccessfully(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer/testObject",
 	}
@@ -337,9 +337,9 @@ func HandleUpdateObjectSuccessfully(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-Object-Meta-Gophercloud-Test", "objects")
 		th.TestHeader(t, r, "X-Remove-Object-Meta-Gophercloud-Test-Remove", "remove")
@@ -355,7 +355,7 @@ func HandleUpdateObjectSuccessfully(t *testing.T, options ...option) {
 
 // HandleGetObjectSuccessfully creates an HTTP handler at `/testContainer/testObject` on the test handler mux that
 // responds with a `Get` response.
-func HandleGetObjectSuccessfully(t *testing.T, options ...option) {
+func HandleGetObjectSuccessfully(t *testing.T, fakeServer th.FakeServer, options ...option) {
 	ho := handlerOptions{
 		path: "/testContainer/testObject",
 	}
@@ -363,9 +363,9 @@ func HandleGetObjectSuccessfully(t *testing.T, options ...option) {
 		apply(&ho)
 	}
 
-	th.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(ho.path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "HEAD")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.Header().Add("X-Object-Meta-Gophercloud-Test", "objects")
 		w.Header().Add("X-Static-Large-Object", "true")
diff --git a/openstack/objectstorage/v1/objects/testing/requests_test.go b/openstack/objectstorage/v1/objects/testing/requests_test.go
index 60747a2ef..d131f1bdc 100644
--- a/openstack/objectstorage/v1/objects/testing/requests_test.go
+++ b/openstack/objectstorage/v1/objects/testing/requests_test.go
@@ -17,7 +17,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/objectstorage/v1/objects"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestContainerNames(t *testing.T) {
@@ -39,69 +39,68 @@ func TestContainerNames(t *testing.T) {
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Run("list", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleListObjectsInfoSuccessfully(t, WithPath("/"))
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleListObjectsInfoSuccessfully(t, fakeServer, WithPath("/"))
 
-				_, err := objects.List(fake.ServiceClient(), tc.containerName, nil).AllPages(context.TODO())
+				_, err := objects.List(client.ServiceClient(fakeServer), tc.containerName, nil).AllPages(context.TODO())
 				th.CheckErr(t, err, &tc.expectedError)
 			})
 			t.Run("download", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleDownloadObjectSuccessfully(t, WithPath("/"))
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleDownloadObjectSuccessfully(t, fakeServer, WithPath("/"))
 
-				_, err := objects.Download(context.TODO(), fake.ServiceClient(), tc.containerName, "testObject", nil).Extract()
+				_, err := objects.Download(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, "testObject", nil).Extract()
 				th.CheckErr(t, err, &tc.expectedError)
 			})
 			t.Run("create", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
 				content := "Ceci n'est pas une pipe"
-				HandleCreateTextObjectSuccessfully(t, content, WithPath("/"))
+				HandleCreateTextObjectSuccessfully(t, fakeServer, content, WithPath("/"))
 
-				res := objects.Create(context.TODO(), fake.ServiceClient(), tc.containerName, "testObject", &objects.CreateOpts{
+				res := objects.Create(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, "testObject", &objects.CreateOpts{
 					ContentType: "text/plain",
 					Content:     strings.NewReader(content),
 				})
 				th.CheckErr(t, res.Err, &tc.expectedError)
 			})
 			t.Run("delete", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleDeleteObjectSuccessfully(t, WithPath("/"))
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleDeleteObjectSuccessfully(t, fakeServer, WithPath("/"))
 
-				res := objects.Delete(context.TODO(), fake.ServiceClient(), tc.containerName, "testObject", nil)
+				res := objects.Delete(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, "testObject", nil)
 				th.CheckErr(t, res.Err, &tc.expectedError)
 			})
 			t.Run("get", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleGetObjectSuccessfully(t, WithPath("/"))
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleGetObjectSuccessfully(t, fakeServer, WithPath("/"))
 
-				_, err := objects.Get(context.TODO(), fake.ServiceClient(), tc.containerName, "testObject", nil).ExtractMetadata()
+				_, err := objects.Get(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, "testObject", nil).ExtractMetadata()
 				th.CheckErr(t, err, &tc.expectedError)
 			})
 			t.Run("update", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleUpdateObjectSuccessfully(t)
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleUpdateObjectSuccessfully(t, fakeServer)
 
-				res := objects.Update(context.TODO(), fake.ServiceClient(), tc.containerName, "testObject", &objects.UpdateOpts{
+				res := objects.Update(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, "testObject", &objects.UpdateOpts{
 					Metadata: map[string]string{"Gophercloud-Test": "objects"},
 				})
 				th.CheckErr(t, res.Err, &tc.expectedError)
 			})
 			t.Run("createTempURL", func(t *testing.T) {
 				port := 33200
-				th.SetupHTTP()
-				th.SetupPersistentPortHTTP(t, port)
-				defer th.TeardownHTTP()
+				fakeServer := th.SetupPersistentPortHTTP(t, port)
+				defer fakeServer.Teardown()
 
 				// Handle fetching of secret key inside of CreateTempURL
-				containerTesting.HandleGetContainerSuccessfully(t)
-				accountTesting.HandleGetAccountSuccessfully(t)
-				client := fake.ServiceClient()
+				containerTesting.HandleGetContainerSuccessfully(t, fakeServer)
+				accountTesting.HandleGetAccountSuccessfully(t, fakeServer)
+				client := client.ServiceClient(fakeServer)
 
 				// Append v1/ to client endpoint URL to be compliant with tempURL generator
 				client.Endpoint = client.Endpoint + "v1/"
@@ -114,11 +113,11 @@ func TestContainerNames(t *testing.T) {
 				th.CheckErr(t, err, &tc.expectedError)
 			})
 			t.Run("bulk-delete", func(t *testing.T) {
-				th.SetupHTTP()
-				defer th.TeardownHTTP()
-				HandleBulkDeleteSuccessfully(t)
+				fakeServer := th.SetupHTTP()
+				defer fakeServer.Teardown()
+				HandleBulkDeleteSuccessfully(t, fakeServer)
 
-				res := objects.BulkDelete(context.TODO(), fake.ServiceClient(), tc.containerName, []string{"testObject"})
+				res := objects.BulkDelete(context.TODO(), client.ServiceClient(fakeServer), tc.containerName, []string{"testObject"})
 				th.CheckErr(t, res.Err, &tc.expectedError)
 			})
 		})
@@ -126,11 +125,11 @@ func TestContainerNames(t *testing.T) {
 }
 
 func TestDownloadReader(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDownloadObjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDownloadObjectSuccessfully(t, fakeServer)
 
-	response := objects.Download(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", nil)
+	response := objects.Download(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", nil)
 	defer response.Body.Close()
 
 	// Check reader
@@ -141,11 +140,11 @@ func TestDownloadReader(t *testing.T) {
 }
 
 func TestDownloadExtraction(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDownloadObjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDownloadObjectSuccessfully(t, fakeServer)
 
-	response := objects.Download(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", nil)
+	response := objects.Download(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", nil)
 
 	// Check []byte extraction
 	bytes, err := response.ExtractContent()
@@ -165,34 +164,34 @@ func TestDownloadExtraction(t *testing.T) {
 }
 
 func TestDownloadWithLastModified(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDownloadObjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDownloadObjectSuccessfully(t, fakeServer)
 
 	options1 := &objects.DownloadOpts{
 		IfUnmodifiedSince: time.Date(2009, time.November, 10, 22, 59, 59, 0, time.UTC),
 	}
-	response1 := objects.Download(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options1)
+	response1 := objects.Download(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options1)
 	_, err1 := response1.Extract()
 	th.AssertErr(t, err1)
 
 	options2 := &objects.DownloadOpts{
 		IfModifiedSince: time.Date(2009, time.November, 10, 23, 0, 1, 0, time.UTC),
 	}
-	response2 := objects.Download(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options2)
+	response2 := objects.Download(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options2)
 	content, err2 := response2.ExtractContent()
 	th.AssertNoErr(t, err2)
 	th.AssertEquals(t, 0, len(content))
 }
 
 func TestListObjectInfo(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListObjectsInfoSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListObjectsInfoSuccessfully(t, fakeServer)
 
 	count := 0
 	options := &objects.ListOpts{}
-	err := objects.List(fake.ServiceClient(), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := objects.List(client.ServiceClient(fakeServer), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := objects.ExtractInfo(page)
 		th.AssertNoErr(t, err)
@@ -206,13 +205,13 @@ func TestListObjectInfo(t *testing.T) {
 }
 
 func TestListObjectSubdir(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSubdirSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSubdirSuccessfully(t, fakeServer)
 
 	count := 0
 	options := &objects.ListOpts{Prefix: "", Delimiter: "/"}
-	err := objects.List(fake.ServiceClient(), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := objects.List(client.ServiceClient(fakeServer), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := objects.ExtractInfo(page)
 		th.AssertNoErr(t, err)
@@ -226,14 +225,14 @@ func TestListObjectSubdir(t *testing.T) {
 }
 
 func TestListObjectNames(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListObjectsInfoSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListObjectsInfoSuccessfully(t, fakeServer)
 
 	// Check without delimiter.
 	count := 0
 	options := &objects.ListOpts{}
-	err := objects.List(fake.ServiceClient(), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := objects.List(client.ServiceClient(fakeServer), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := objects.ExtractNames(page)
 		if err != nil {
@@ -251,7 +250,7 @@ func TestListObjectNames(t *testing.T) {
 	// Check with delimiter.
 	count = 0
 	options = &objects.ListOpts{Delimiter: "/"}
-	err = objects.List(fake.ServiceClient(), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err = objects.List(client.ServiceClient(fakeServer), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := objects.ExtractNames(page)
 		if err != nil {
@@ -268,13 +267,13 @@ func TestListObjectNames(t *testing.T) {
 }
 
 func TestListZeroObjectNames204(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListZeroObjectNames204(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListZeroObjectNames204(t, fakeServer)
 
 	count := 0
 	options := &objects.ListOpts{}
-	err := objects.List(fake.ServiceClient(), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := objects.List(client.ServiceClient(fakeServer), "testContainer", options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := objects.ExtractNames(page)
 		if err != nil {
@@ -291,100 +290,100 @@ func TestListZeroObjectNames204(t *testing.T) {
 }
 
 func TestCreateObject(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	content := "Did gyre and gimble in the wabe"
 
-	HandleCreateTextObjectSuccessfully(t, content)
+	HandleCreateTextObjectSuccessfully(t, fakeServer, content)
 
 	options := &objects.CreateOpts{ContentType: "text/plain", Content: strings.NewReader(content)}
-	res := objects.Create(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options)
+	res := objects.Create(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestCreateObjectWithCacheControl(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	content := "All mimsy were the borogoves"
 
-	HandleCreateTextWithCacheControlSuccessfully(t, content)
+	HandleCreateTextWithCacheControlSuccessfully(t, fakeServer, content)
 
 	options := &objects.CreateOpts{
 		CacheControl: `max-age="3600", public`,
 		Content:      strings.NewReader(content),
 	}
-	res := objects.Create(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options)
+	res := objects.Create(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestCreateObjectWithoutContentType(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	content := "The sky was the color of television, tuned to a dead channel."
 
-	HandleCreateTypelessObjectSuccessfully(t, content)
+	HandleCreateTypelessObjectSuccessfully(t, fakeServer, content)
 
-	res := objects.Create(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", &objects.CreateOpts{Content: strings.NewReader(content)})
+	res := objects.Create(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", &objects.CreateOpts{Content: strings.NewReader(content)})
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestCopyObject(t *testing.T) {
 	t.Run("simple", func(t *testing.T) {
-		th.SetupHTTP()
-		defer th.TeardownHTTP()
-		HandleCopyObjectSuccessfully(t, "/newTestContainer/newTestObject")
+		fakeServer := th.SetupHTTP()
+		defer fakeServer.Teardown()
+		HandleCopyObjectSuccessfully(t, fakeServer, "/newTestContainer/newTestObject")
 
 		options := &objects.CopyOpts{Destination: "/newTestContainer/newTestObject"}
-		res := objects.Copy(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options)
+		res := objects.Copy(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options)
 		th.AssertNoErr(t, res.Err)
 	})
 	t.Run("slash", func(t *testing.T) {
-		th.SetupHTTP()
-		defer th.TeardownHTTP()
-		HandleCopyObjectSuccessfully(t, "/newTestContainer/path%2Fto%2FnewTestObject")
+		fakeServer := th.SetupHTTP()
+		defer fakeServer.Teardown()
+		HandleCopyObjectSuccessfully(t, fakeServer, "/newTestContainer/path%2Fto%2FnewTestObject")
 
 		options := &objects.CopyOpts{Destination: "/newTestContainer/path/to/newTestObject"}
-		res := objects.Copy(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options)
+		res := objects.Copy(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options)
 		th.AssertNoErr(t, res.Err)
 	})
 	t.Run("emojis", func(t *testing.T) {
-		th.SetupHTTP()
-		defer th.TeardownHTTP()
-		HandleCopyObjectSuccessfully(t, "/newTestContainer/new%F0%9F%98%8ATest%2C%3B%22O%28bject%21_%E7%AF%84")
+		fakeServer := th.SetupHTTP()
+		defer fakeServer.Teardown()
+		HandleCopyObjectSuccessfully(t, fakeServer, "/newTestContainer/new%F0%9F%98%8ATest%2C%3B%22O%28bject%21_%E7%AF%84")
 
 		options := &objects.CopyOpts{Destination: "/newTestContainer/new😊Test,;\"O(bject!_範"}
-		res := objects.Copy(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options)
+		res := objects.Copy(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options)
 		th.AssertNoErr(t, res.Err)
 	})
 }
 
 func TestCopyObjectVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCopyObjectVersionSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCopyObjectVersionSuccessfully(t, fakeServer)
 
 	options := &objects.CopyOpts{Destination: "/newTestContainer/newTestObject", ObjectVersionID: "123456788"}
-	res, err := objects.Copy(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options).Extract()
+	res, err := objects.Copy(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, "123456789", res.ObjectVersionID)
 }
 
 func TestDeleteObject(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteObjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteObjectSuccessfully(t, fakeServer)
 
-	res := objects.Delete(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", nil)
+	res := objects.Delete(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", nil)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestBulkDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleBulkDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleBulkDeleteSuccessfully(t, fakeServer)
 
 	expected := objects.BulkDeleteResponse{
 		ResponseStatus: "foo",
@@ -393,15 +392,15 @@ func TestBulkDelete(t *testing.T) {
 		Errors:         [][]string{},
 	}
 
-	resp, err := objects.BulkDelete(context.TODO(), fake.ServiceClient(), "testContainer", []string{"testObject1", "testObject2"}).Extract()
+	resp, err := objects.BulkDelete(context.TODO(), client.ServiceClient(fakeServer), "testContainer", []string{"testObject1", "testObject2"}).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, expected, *resp)
 }
 
 func TestUpateObjectMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateObjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateObjectSuccessfully(t, fakeServer)
 
 	s := new(string)
 	i := new(int64)
@@ -414,24 +413,24 @@ func TestUpateObjectMetadata(t *testing.T) {
 		DeleteAt:           i,
 		DetectContentType:  new(bool),
 	}
-	res := objects.Update(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", options)
+	res := objects.Update(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", options)
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetObject(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetObjectSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetObjectSuccessfully(t, fakeServer)
 
 	expected := map[string]string{"Gophercloud-Test": "objects"}
-	actual, err := objects.Get(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", nil).ExtractMetadata()
+	actual, err := objects.Get(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", nil).ExtractMetadata()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expected, actual)
 
 	getOpts := objects.GetOpts{
 		Newest: true,
 	}
-	actualHeaders, err := objects.Get(context.TODO(), fake.ServiceClient(), "testContainer", "testObject", getOpts).Extract()
+	actualHeaders, err := objects.Get(context.TODO(), client.ServiceClient(fakeServer), "testContainer", "testObject", getOpts).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, true, actualHeaders.StaticLargeObject)
 }
@@ -505,14 +504,13 @@ func TestObjectCreateParamsWithSeek(t *testing.T) {
 
 func TestCreateTempURL(t *testing.T) {
 	port := 33200
-	th.SetupHTTP()
-	th.SetupPersistentPortHTTP(t, port)
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupPersistentPortHTTP(t, port)
+	defer fakeServer.Teardown()
 
 	// Handle fetching of secret key inside of CreateTempURL
-	containerTesting.HandleGetContainerSuccessfully(t)
-	accountTesting.HandleGetAccountSuccessfully(t)
-	client := fake.ServiceClient()
+	containerTesting.HandleGetContainerSuccessfully(t, fakeServer)
+	accountTesting.HandleGetAccountSuccessfully(t, fakeServer)
+	client := client.ServiceClient(fakeServer)
 
 	// Append v1/ to client endpoint URL to be compliant with tempURL generator
 	client.Endpoint = client.Endpoint + "v1/"
diff --git a/openstack/objectstorage/v1/swauth/testing/fixtures_test.go b/openstack/objectstorage/v1/swauth/testing/fixtures_test.go
index 01bbfd1a8..796132da3 100644
--- a/openstack/objectstorage/v1/swauth/testing/fixtures_test.go
+++ b/openstack/objectstorage/v1/swauth/testing/fixtures_test.go
@@ -16,8 +16,8 @@ var AuthResult = swauth.AuthResult{
 }
 
 // HandleAuthSuccessfully configures the test server to respond to an Auth request.
-func HandleAuthSuccessfully(t *testing.T, authOpts swauth.AuthOpts) {
-	th.Mux.HandleFunc("/auth/v1.0", func(w http.ResponseWriter, r *http.Request) {
+func HandleAuthSuccessfully(t *testing.T, fakeServer th.FakeServer, authOpts swauth.AuthOpts) {
+	fakeServer.Mux.HandleFunc("/auth/v1.0", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-User", authOpts.User)
 		th.TestHeader(t, r, "X-Auth-Key", authOpts.Key)
diff --git a/openstack/objectstorage/v1/swauth/testing/requests_test.go b/openstack/objectstorage/v1/swauth/testing/requests_test.go
index cd095d0c1..066da2849 100644
--- a/openstack/objectstorage/v1/swauth/testing/requests_test.go
+++ b/openstack/objectstorage/v1/swauth/testing/requests_test.go
@@ -15,11 +15,11 @@ func TestAuth(t *testing.T) {
 		Key:  "testing",
 	}
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAuthSuccessfully(t, authOpts)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAuthSuccessfully(t, fakeServer, authOpts)
 
-	providerClient, err := openstack.NewClient(th.Endpoint())
+	providerClient, err := openstack.NewClient(fakeServer.Endpoint())
 	th.AssertNoErr(t, err)
 
 	swiftClient, err := swauth.NewObjectStorageV1(context.TODO(), providerClient, authOpts)
diff --git a/openstack/orchestration/v1/apiversions/testing/requests_test.go b/openstack/orchestration/v1/apiversions/testing/requests_test.go
index d7149f1cb..80613508c 100644
--- a/openstack/orchestration/v1/apiversions/testing/requests_test.go
+++ b/openstack/orchestration/v1/apiversions/testing/requests_test.go
@@ -10,16 +10,16 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/apiversions"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestListVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -43,7 +43,7 @@ func TestListVersions(t *testing.T) {
 
 	count := 0
 
-	err := apiversions.ListVersions(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := apiversions.ListVersions(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := apiversions.ExtractAPIVersions(page)
 		if err != nil {
@@ -76,14 +76,14 @@ func TestListVersions(t *testing.T) {
 }
 
 func TestNonJSONCannotBeExtractedIntoAPIVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 
-	err := apiversions.ListVersions(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := apiversions.ListVersions(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		if _, err := apiversions.ExtractAPIVersions(page); err == nil {
 			t.Fatalf("Expected error, got nil")
 		}
diff --git a/openstack/orchestration/v1/buildinfo/testing/fixtures_test.go b/openstack/orchestration/v1/buildinfo/testing/fixtures_test.go
index 74a91e4df..8a89455e5 100644
--- a/openstack/orchestration/v1/buildinfo/testing/fixtures_test.go
+++ b/openstack/orchestration/v1/buildinfo/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/buildinfo"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // GetExpected represents the expected object from a Get request.
@@ -33,10 +33,10 @@ const GetOutput = `
 
 // HandleGetSuccessfully creates an HTTP handler at `/build_info`
 // on the test handler mux that responds with a `Get` response.
-func HandleGetSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/build_info", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/build_info", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
diff --git a/openstack/orchestration/v1/buildinfo/testing/requests_test.go b/openstack/orchestration/v1/buildinfo/testing/requests_test.go
index 5177e7d40..978003325 100644
--- a/openstack/orchestration/v1/buildinfo/testing/requests_test.go
+++ b/openstack/orchestration/v1/buildinfo/testing/requests_test.go
@@ -6,15 +6,15 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/buildinfo"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestGetTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t, GetOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer, GetOutput)
 
-	actual, err := buildinfo.Get(context.TODO(), fake.ServiceClient()).Extract()
+	actual, err := buildinfo.Get(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := GetExpected
diff --git a/openstack/orchestration/v1/resourcetypes/testing/fixtures_test.go b/openstack/orchestration/v1/resourcetypes/testing/fixtures_test.go
index 37a91b090..4883edd8d 100644
--- a/openstack/orchestration/v1/resourcetypes/testing/fixtures_test.go
+++ b/openstack/orchestration/v1/resourcetypes/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/resourcetypes"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const BasicListOutput = `
@@ -75,11 +75,11 @@ var FilteredListExpected = []resourcetypes.ResourceTypeSummary{
 
 // HandleListSuccessfully creates an HTTP handler at `/resource_types`
 // on the test handler mux that responds with a `List` response.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/resource_types",
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/resource_types",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Accept", "application/json")
 
 			w.Header().Set("Content-Type", "application/json")
@@ -324,11 +324,11 @@ const GetSchemaOutput = `
 // HandleGetSchemaSuccessfully creates an HTTP handler at
 // `/resource_types/OS::Test::TestServer` on the test handler mux that
 // responds with a `GetSchema` response.
-func HandleGetSchemaSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/resource_types/OS::Test::TestServer",
+func HandleGetSchemaSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/resource_types/OS::Test::TestServer",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Accept", "application/json")
 
 			w.Header().Set("Content-Type", "application/json")
@@ -370,11 +370,11 @@ const GenerateTemplateOutput = `
 // HandleGenerateTemplateSuccessfully creates an HTTP handler at
 // `/resource_types/OS::Heat::None/template` on the test handler mux that
 // responds with a template.
-func HandleGenerateTemplateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/resource_types/OS::Heat::None/template",
+func HandleGenerateTemplateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/resource_types/OS::Heat::None/template",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 			th.TestHeader(t, r, "Accept", "application/json")
 
 			w.Header().Set("Content-Type", "application/json")
diff --git a/openstack/orchestration/v1/resourcetypes/testing/requests_test.go b/openstack/orchestration/v1/resourcetypes/testing/requests_test.go
index b426d55f6..6a0fb4356 100644
--- a/openstack/orchestration/v1/resourcetypes/testing/requests_test.go
+++ b/openstack/orchestration/v1/resourcetypes/testing/requests_test.go
@@ -6,15 +6,15 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/resourcetypes"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestBasicListResourceTypes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
-	result := resourcetypes.List(context.TODO(), fake.ServiceClient(), nil)
+	result := resourcetypes.List(context.TODO(), client.ServiceClient(fakeServer), nil)
 	th.AssertNoErr(t, result.Err)
 
 	actual, err := result.Extract()
@@ -24,11 +24,11 @@ func TestBasicListResourceTypes(t *testing.T) {
 }
 
 func TestFullListResourceTypes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
-	result := resourcetypes.List(context.TODO(), fake.ServiceClient(), resourcetypes.ListOpts{
+	result := resourcetypes.List(context.TODO(), client.ServiceClient(fakeServer), resourcetypes.ListOpts{
 		WithDescription: true,
 	})
 	th.AssertNoErr(t, result.Err)
@@ -40,11 +40,11 @@ func TestFullListResourceTypes(t *testing.T) {
 }
 
 func TestFilteredListResourceTypes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
-	result := resourcetypes.List(context.TODO(), fake.ServiceClient(), resourcetypes.ListOpts{
+	result := resourcetypes.List(context.TODO(), client.ServiceClient(fakeServer), resourcetypes.ListOpts{
 		NameRegex:       listFilterRegex,
 		WithDescription: true,
 	})
@@ -57,11 +57,11 @@ func TestFilteredListResourceTypes(t *testing.T) {
 }
 
 func TestGetSchema(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSchemaSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSchemaSuccessfully(t, fakeServer)
 
-	result := resourcetypes.GetSchema(context.TODO(), fake.ServiceClient(), "OS::Test::TestServer")
+	result := resourcetypes.GetSchema(context.TODO(), client.ServiceClient(fakeServer), "OS::Test::TestServer")
 	th.AssertNoErr(t, result.Err)
 
 	actual, err := result.Extract()
@@ -71,11 +71,11 @@ func TestGetSchema(t *testing.T) {
 }
 
 func TestGenerateTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGenerateTemplateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGenerateTemplateSuccessfully(t, fakeServer)
 
-	result := resourcetypes.GenerateTemplate(context.TODO(), fake.ServiceClient(), "OS::Heat::None", nil)
+	result := resourcetypes.GenerateTemplate(context.TODO(), client.ServiceClient(fakeServer), "OS::Heat::None", nil)
 	th.AssertNoErr(t, result.Err)
 
 	actual, err := result.Extract()
diff --git a/openstack/orchestration/v1/stackevents/testing/fixtures_test.go b/openstack/orchestration/v1/stackevents/testing/fixtures_test.go
index a0e31b4ba..d450ca559 100644
--- a/openstack/orchestration/v1/stackevents/testing/fixtures_test.go
+++ b/openstack/orchestration/v1/stackevents/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/stackevents"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 var Timestamp1, _ = time.Parse(time.RFC3339, "2018-06-26T07:58:17Z")
@@ -120,10 +120,10 @@ const FindOutput = `
 
 // HandleFindSuccessfully creates an HTTP handler at `/stacks/postman_stack/events`
 // on the test handler mux that responds with a `Find` response.
-func HandleFindSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/postman_stack/events", func(w http.ResponseWriter, r *http.Request) {
+func HandleFindSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/postman_stack/events", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -237,10 +237,10 @@ const ListOutput = `
 
 // HandleListSuccessfully creates an HTTP handler at `/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/events`
 // on the test handler mux that responds with a `List` response.
-func HandleListSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/events", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/events", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -364,10 +364,10 @@ const ListResourceEventsOutput = `
 
 // HandleListResourceEventsSuccessfully creates an HTTP handler at `/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources/my_resource/events`
 // on the test handler mux that responds with a `ListResourceEvents` response.
-func HandleListResourceEventsSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources/my_resource/events", func(w http.ResponseWriter, r *http.Request) {
+func HandleListResourceEventsSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources/my_resource/events", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -441,10 +441,10 @@ const GetOutput = `
 
 // HandleGetSuccessfully creates an HTTP handler at `/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources/my_resource/events/93940999-7d40-44ae-8de4-19624e7b8d18`
 // on the test handler mux that responds with a `Get` response.
-func HandleGetSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources/my_resource/events/93940999-7d40-44ae-8de4-19624e7b8d18", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources/my_resource/events/93940999-7d40-44ae-8de4-19624e7b8d18", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
diff --git a/openstack/orchestration/v1/stackevents/testing/requests_test.go b/openstack/orchestration/v1/stackevents/testing/requests_test.go
index bed2d8a2b..d1c60abf3 100644
--- a/openstack/orchestration/v1/stackevents/testing/requests_test.go
+++ b/openstack/orchestration/v1/stackevents/testing/requests_test.go
@@ -7,15 +7,15 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/stackevents"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestFindEvents(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFindSuccessfully(t, FindOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFindSuccessfully(t, fakeServer, FindOutput)
 
-	actual, err := stackevents.Find(context.TODO(), fake.ServiceClient(), "postman_stack").Extract()
+	actual, err := stackevents.Find(context.TODO(), client.ServiceClient(fakeServer), "postman_stack").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := FindExpected
@@ -23,12 +23,12 @@ func TestFindEvents(t *testing.T) {
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t, ListOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer, ListOutput)
 
 	count := 0
-	err := stackevents.List(fake.ServiceClient(), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := stackevents.List(client.ServiceClient(fakeServer), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := stackevents.ExtractEvents(page)
 		th.AssertNoErr(t, err)
@@ -42,12 +42,12 @@ func TestList(t *testing.T) {
 }
 
 func TestListResourceEvents(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListResourceEventsSuccessfully(t, ListResourceEventsOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListResourceEventsSuccessfully(t, fakeServer, ListResourceEventsOutput)
 
 	count := 0
-	err := stackevents.ListResourceEvents(fake.ServiceClient(), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", "my_resource", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := stackevents.ListResourceEvents(client.ServiceClient(fakeServer), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", "my_resource", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := stackevents.ExtractResourceEvents(page)
 		th.AssertNoErr(t, err)
@@ -61,11 +61,11 @@ func TestListResourceEvents(t *testing.T) {
 }
 
 func TestGetEvent(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t, GetOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer, GetOutput)
 
-	actual, err := stackevents.Get(context.TODO(), fake.ServiceClient(), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", "my_resource", "93940999-7d40-44ae-8de4-19624e7b8d18").Extract()
+	actual, err := stackevents.Get(context.TODO(), client.ServiceClient(fakeServer), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", "my_resource", "93940999-7d40-44ae-8de4-19624e7b8d18").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := GetExpected
diff --git a/openstack/orchestration/v1/stackresources/testing/fixtures_test.go b/openstack/orchestration/v1/stackresources/testing/fixtures_test.go
index fa1e66575..45800807f 100644
--- a/openstack/orchestration/v1/stackresources/testing/fixtures_test.go
+++ b/openstack/orchestration/v1/stackresources/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/stackresources"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 var Create_time, _ = time.Parse(time.RFC3339, "2018-06-26T07:57:17Z")
@@ -74,10 +74,10 @@ const FindOutput = `
 
 // HandleFindSuccessfully creates an HTTP handler at `/stacks/hello_world/resources`
 // on the test handler mux that responds with a `Find` response.
-func HandleFindSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/hello_world/resources", func(w http.ResponseWriter, r *http.Request) {
+func HandleFindSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/hello_world/resources", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -144,10 +144,10 @@ const ListOutput = `{
 
 // HandleListSuccessfully creates an HTTP handler at `/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources`
 // on the test handler mux that responds with a `List` response.
-func HandleListSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/hello_world/49181cd6-169a-4130-9455-31185bbfc5bf/resources", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -219,10 +219,10 @@ const GetOutput = `
 
 // HandleGetSuccessfully creates an HTTP handler at `/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance`
 // on the test handler mux that responds with a `Get` response.
-func HandleGetSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -248,10 +248,10 @@ const MetadataOutput = `
 
 // HandleMetadataSuccessfully creates an HTTP handler at `/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance/metadata`
 // on the test handler mux that responds with a `Metadata` response.
-func HandleMetadataSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance/metadata", func(w http.ResponseWriter, r *http.Request) {
+func HandleMetadataSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -301,10 +301,10 @@ const ListTypesOutput = `
 
 // HandleListTypesSuccessfully creates an HTTP handler at `/resource_types`
 // on the test handler mux that responds with a `ListTypes` response.
-func HandleListTypesSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/resource_types", func(w http.ResponseWriter, r *http.Request) {
+func HandleListTypesSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/resource_types", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -362,10 +362,10 @@ const GetSchemaOutput = `
 
 // HandleGetSchemaSuccessfully creates an HTTP handler at `/resource_types/OS::Heat::AResourceName`
 // on the test handler mux that responds with a `Schema` response.
-func HandleGetSchemaSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/resource_types/OS::Heat::AResourceName", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSchemaSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/resource_types/OS::Heat::AResourceName", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -432,10 +432,10 @@ const GetTemplateOutput = `
 
 // HandleGetTemplateSuccessfully creates an HTTP handler at `/resource_types/OS::Heat::AResourceName/template`
 // on the test handler mux that responds with a `Template` response.
-func HandleGetTemplateSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/resource_types/OS::Heat::AResourceName/template", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetTemplateSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/resource_types/OS::Heat::AResourceName/template", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -446,10 +446,10 @@ func HandleGetTemplateSuccessfully(t *testing.T, output string) {
 
 // HandleMarkUnhealthySuccessfully creates an HTTP handler at `/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance`
 // on the test handler mux that responds with a `MarkUnhealthy` response.
-func HandleMarkUnhealthySuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance", func(w http.ResponseWriter, r *http.Request) {
+func HandleMarkUnhealthySuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/stacks/teststack/0b1771bd-9336-4f2b-ae86-a80f971faf1e/resources/wordpress_instance", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
diff --git a/openstack/orchestration/v1/stackresources/testing/requests_test.go b/openstack/orchestration/v1/stackresources/testing/requests_test.go
index 358b30621..2852716bd 100644
--- a/openstack/orchestration/v1/stackresources/testing/requests_test.go
+++ b/openstack/orchestration/v1/stackresources/testing/requests_test.go
@@ -8,15 +8,15 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/stackresources"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestFindResources(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFindSuccessfully(t, FindOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFindSuccessfully(t, fakeServer, FindOutput)
 
-	actual, err := stackresources.Find(context.TODO(), fake.ServiceClient(), "hello_world").Extract()
+	actual, err := stackresources.Find(context.TODO(), client.ServiceClient(fakeServer), "hello_world").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := FindExpected
@@ -24,12 +24,12 @@ func TestFindResources(t *testing.T) {
 }
 
 func TestListResources(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t, ListOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer, ListOutput)
 
 	count := 0
-	err := stackresources.List(fake.ServiceClient(), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := stackresources.List(client.ServiceClient(fakeServer), "hello_world", "49181cd6-169a-4130-9455-31185bbfc5bf", nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := stackresources.ExtractResources(page)
 		th.AssertNoErr(t, err)
@@ -43,11 +43,11 @@ func TestListResources(t *testing.T) {
 }
 
 func TestGetResource(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t, GetOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer, GetOutput)
 
-	actual, err := stackresources.Get(context.TODO(), fake.ServiceClient(), "teststack", "0b1771bd-9336-4f2b-ae86-a80f971faf1e", "wordpress_instance").Extract()
+	actual, err := stackresources.Get(context.TODO(), client.ServiceClient(fakeServer), "teststack", "0b1771bd-9336-4f2b-ae86-a80f971faf1e", "wordpress_instance").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := GetExpected
@@ -55,11 +55,11 @@ func TestGetResource(t *testing.T) {
 }
 
 func TestResourceMetadata(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMetadataSuccessfully(t, MetadataOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMetadataSuccessfully(t, fakeServer, MetadataOutput)
 
-	actual, err := stackresources.Metadata(context.TODO(), fake.ServiceClient(), "teststack", "0b1771bd-9336-4f2b-ae86-a80f971faf1e", "wordpress_instance").Extract()
+	actual, err := stackresources.Metadata(context.TODO(), client.ServiceClient(fakeServer), "teststack", "0b1771bd-9336-4f2b-ae86-a80f971faf1e", "wordpress_instance").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := MetadataExpected
@@ -67,12 +67,12 @@ func TestResourceMetadata(t *testing.T) {
 }
 
 func TestListResourceTypes(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTypesSuccessfully(t, ListTypesOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTypesSuccessfully(t, fakeServer, ListTypesOutput)
 
 	count := 0
-	err := stackresources.ListTypes(fake.ServiceClient()).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := stackresources.ListTypes(client.ServiceClient(fakeServer)).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := stackresources.ExtractResourceTypes(page)
 		th.AssertNoErr(t, err)
@@ -89,11 +89,11 @@ func TestListResourceTypes(t *testing.T) {
 }
 
 func TestGetResourceSchema(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSchemaSuccessfully(t, GetSchemaOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSchemaSuccessfully(t, fakeServer, GetSchemaOutput)
 
-	actual, err := stackresources.Schema(context.TODO(), fake.ServiceClient(), "OS::Heat::AResourceName").Extract()
+	actual, err := stackresources.Schema(context.TODO(), client.ServiceClient(fakeServer), "OS::Heat::AResourceName").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := GetSchemaExpected
@@ -101,11 +101,11 @@ func TestGetResourceSchema(t *testing.T) {
 }
 
 func TestGetResourceTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetTemplateSuccessfully(t, GetTemplateOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetTemplateSuccessfully(t, fakeServer, GetTemplateOutput)
 
-	actual, err := stackresources.Template(context.TODO(), fake.ServiceClient(), "OS::Heat::AResourceName").Extract()
+	actual, err := stackresources.Template(context.TODO(), client.ServiceClient(fakeServer), "OS::Heat::AResourceName").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := GetTemplateExpected
@@ -113,14 +113,14 @@ func TestGetResourceTemplate(t *testing.T) {
 }
 
 func TestMarkUnhealthyResource(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleMarkUnhealthySuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleMarkUnhealthySuccessfully(t, fakeServer)
 
 	markUnhealthyOpts := &stackresources.MarkUnhealthyOpts{
 		MarkUnhealthy:        true,
 		ResourceStatusReason: "Kubelet.Ready is Unknown more than 10 mins.",
 	}
-	err := stackresources.MarkUnhealthy(context.TODO(), fake.ServiceClient(), "teststack", "0b1771bd-9336-4f2b-ae86-a80f971faf1e", "wordpress_instance", markUnhealthyOpts).ExtractErr()
+	err := stackresources.MarkUnhealthy(context.TODO(), client.ServiceClient(fakeServer), "teststack", "0b1771bd-9336-4f2b-ae86-a80f971faf1e", "wordpress_instance", markUnhealthyOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/orchestration/v1/stacks/environment_test.go b/openstack/orchestration/v1/stacks/environment_test.go
index b69e52705..c3b900543 100644
--- a/openstack/orchestration/v1/stacks/environment_test.go
+++ b/openstack/orchestration/v1/stacks/environment_test.go
@@ -71,8 +71,8 @@ func TestIgnoreIfEnvironment(t *testing.T) {
 }
 
 func TestGetRRFileContents(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 	environmentContent := `
 heat_template_version: 2013-05-23
 
@@ -129,10 +129,10 @@ service_db:
 	th.AssertNoErr(t, err)
 
 	// Serve "my_env.yaml" and "my_db.yaml"
-	fakeEnvURL := th.ServeFile(t, baseurl, "my_env.yaml", "application/json", environmentContent)
-	fakeDBURL := th.ServeFile(t, baseurl, "my_db.yaml", "application/json", dbContent)
+	fakeEnvURL := fakeServer.ServeFile(t, baseurl, "my_env.yaml", "application/json", environmentContent)
+	fakeDBURL := fakeServer.ServeFile(t, baseurl, "my_db.yaml", "application/json", dbContent)
 
-	client := fakeClient{BaseClient: getHTTPClient()}
+	client := fakeClient{BaseClient: getHTTPClient(), FakeServer: fakeServer}
 	env := new(Environment)
 	env.Bin = []byte(`{"resource_registry": {"My::WP::Server": "my_env.yaml", "resources": {"my_db_server": {"OS::DBInstance": "my_db.yaml"}}}}`)
 	env.client = client
diff --git a/openstack/orchestration/v1/stacks/template_test.go b/openstack/orchestration/v1/stacks/template_test.go
index 9ab257d70..1f304e0cb 100644
--- a/openstack/orchestration/v1/stacks/template_test.go
+++ b/openstack/orchestration/v1/stacks/template_test.go
@@ -111,14 +111,14 @@ var myNovaExpected = map[string]any{
 }
 
 func TestGetFileContentsWithType(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 	baseurl, err := getBasePath()
 	th.AssertNoErr(t, err)
 
-	fakeURL := th.ServeFile(t, baseurl, "my_nova.yaml", "application/json", myNovaContent)
+	fakeURL := fakeServer.ServeFile(t, baseurl, "my_nova.yaml", "application/json", myNovaContent)
 
-	client := fakeClient{BaseClient: getHTTPClient()}
+	client := fakeClient{BaseClient: getHTTPClient(), FakeServer: fakeServer}
 	te := new(Template)
 	te.Bin = []byte(`heat_template_version: 2015-04-30
 resources:
@@ -148,15 +148,15 @@ resources:
 }
 
 func TestGetFileContentsWithFile(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 	baseurl, err := getBasePath()
 	th.AssertNoErr(t, err)
 
 	somefile := `Welcome!`
-	fakeURL := th.ServeFile(t, baseurl, "somefile", "text/plain", somefile)
+	fakeURL := fakeServer.ServeFile(t, baseurl, "somefile", "text/plain", somefile)
 
-	client := fakeClient{BaseClient: getHTTPClient()}
+	client := fakeClient{BaseClient: getHTTPClient(), FakeServer: fakeServer}
 	te := new(Template)
 	// Note: We include the path that should be replaced also as a not-to-be-replaced
 	// keyword ("path: somefile" below) to validate that no updates happen outside of
@@ -195,13 +195,13 @@ resources:
 }
 
 func TestGetFileContentsComposeRelativePath(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 	baseurl, err := getBasePath()
 	th.AssertNoErr(t, err)
 
 	novaPath := strings.Join([]string{"templates", "my_nova.yaml"}, "/")
-	novaURL := th.ServeFile(t, baseurl, novaPath, "application/json", myNovaContent)
+	novaURL := fakeServer.ServeFile(t, baseurl, novaPath, "application/json", myNovaContent)
 
 	mySubStackContent := `heat_template_version: 2015-04-30
 resources:
@@ -237,9 +237,9 @@ resources:
 		},
 	}
 	subStacksPath := strings.Join([]string{"substacks", "my_substack.yaml"}, "/")
-	subStackURL := th.ServeFile(t, baseurl, subStacksPath, "application/json", mySubStackContent)
+	subStackURL := fakeServer.ServeFile(t, baseurl, subStacksPath, "application/json", mySubStackContent)
 
-	client := fakeClient{BaseClient: getHTTPClient()}
+	client := fakeClient{BaseClient: getHTTPClient(), FakeServer: fakeServer}
 	te := new(Template)
 	te.Bin = []byte(`heat_template_version: 2015-04-30
 resources:
diff --git a/openstack/orchestration/v1/stacks/testing/fixtures_test.go b/openstack/orchestration/v1/stacks/testing/fixtures_test.go
index 9baed3ace..4b293dbf8 100644
--- a/openstack/orchestration/v1/stacks/testing/fixtures_test.go
+++ b/openstack/orchestration/v1/stacks/testing/fixtures_test.go
@@ -9,7 +9,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/stacks"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 var Create_time, _ = time.Parse(time.RFC3339, "2018-06-26T07:58:17Z")
@@ -42,10 +42,10 @@ const CreateOutput = `
 
 // HandleCreateSuccessfully creates an HTTP handler at `/stacks` on the test handler mux
 // that responds with a `Create` response.
-func HandleCreateSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.WriteHeader(http.StatusCreated)
 		fmt.Fprint(w, output)
@@ -129,10 +129,10 @@ const FullListOutput = `
 
 // HandleListSuccessfully creates an HTTP handler at `/stacks` on the test handler mux
 // that responds with a `List` response.
-func HandleListSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -213,10 +213,10 @@ const GetOutput = `
 
 // HandleGetSuccessfully creates an HTTP handler at `/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87`
 // on the test handler mux that responds with a `Get` response.
-func HandleGetSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -225,10 +225,10 @@ func HandleGetSuccessfully(t *testing.T, output string) {
 	})
 }
 
-func HandleFindSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/16ef0584-4458-41eb-87c8-0dc8d5f66c87", func(w http.ResponseWriter, r *http.Request) {
+func HandleFindSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/16ef0584-4458-41eb-87c8-0dc8d5f66c87", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -239,10 +239,10 @@ func HandleFindSuccessfully(t *testing.T, output string) {
 
 // HandleUpdateSuccessfully creates an HTTP handler at `/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87`
 // on the test handler mux that responds with an `Update` response.
-func HandleUpdateSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/stacks/gophercloud-test-stack-2/db6977b2-27aa-4775-9ae7-6213212d4ada", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdateSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/stacks/gophercloud-test-stack-2/db6977b2-27aa-4775-9ae7-6213212d4ada", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -252,10 +252,10 @@ func HandleUpdateSuccessfully(t *testing.T) {
 
 // HandleUpdatePatchSuccessfully creates an HTTP handler at `/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87`
 // on the test handler mux that responds with an `Update` response.
-func HandleUpdatePatchSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/stacks/gophercloud-test-stack-2/db6977b2-27aa-4775-9ae7-6213212d4ada", func(w http.ResponseWriter, r *http.Request) {
+func HandleUpdatePatchSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/stacks/gophercloud-test-stack-2/db6977b2-27aa-4775-9ae7-6213212d4ada", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PATCH")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -265,10 +265,10 @@ func HandleUpdatePatchSuccessfully(t *testing.T) {
 
 // HandleDeleteSuccessfully creates an HTTP handler at `/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87`
 // on the test handler mux that responds with a `Delete` response.
-func HandleDeleteSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/stacks/gophercloud-test-stack-2/db6977b2-27aa-4775-9ae7-6213212d4ada", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/stacks/gophercloud-test-stack-2/db6977b2-27aa-4775-9ae7-6213212d4ada", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -301,10 +301,10 @@ var PreviewExpected = &stacks.PreviewedStack{
 
 // HandlePreviewSuccessfully creates an HTTP handler at `/stacks/preview`
 // on the test handler mux that responds with a `Preview` response.
-func HandlePreviewSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/preview", func(w http.ResponseWriter, r *http.Request) {
+func HandlePreviewSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/preview", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -424,10 +424,10 @@ const AbandonOutput = `
 
 // HandleAbandonSuccessfully creates an HTTP handler at `/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87/abandon`
 // on the test handler mux that responds with an `Abandon` response.
-func HandleAbandonSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c8/abandon", func(w http.ResponseWriter, r *http.Request) {
+func HandleAbandonSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c8/abandon", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
diff --git a/openstack/orchestration/v1/stacks/testing/requests_test.go b/openstack/orchestration/v1/stacks/testing/requests_test.go
index 224893f5d..6c373315e 100644
--- a/openstack/orchestration/v1/stacks/testing/requests_test.go
+++ b/openstack/orchestration/v1/stacks/testing/requests_test.go
@@ -8,13 +8,13 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/stacks"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreateStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t, CreateOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer, CreateOutput)
 	template := new(stacks.Template)
 	template.Bin = []byte(`
 		{
@@ -33,7 +33,7 @@ func TestCreateStack(t *testing.T) {
 		TemplateOpts:    template,
 		DisableRollback: gophercloud.Disabled,
 	}
-	actual, err := stacks.Create(context.TODO(), fake.ServiceClient(), createOpts).Extract()
+	actual, err := stacks.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := CreateExpected
@@ -41,9 +41,9 @@ func TestCreateStack(t *testing.T) {
 }
 
 func TestCreateStackMissingRequiredInOpts(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t, CreateOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer, CreateOutput)
 	template := new(stacks.Template)
 	template.Bin = []byte(`
 		{
@@ -59,14 +59,14 @@ func TestCreateStackMissingRequiredInOpts(t *testing.T) {
 	createOpts := stacks.CreateOpts{
 		DisableRollback: gophercloud.Disabled,
 	}
-	r := stacks.Create(context.TODO(), fake.ServiceClient(), createOpts)
+	r := stacks.Create(context.TODO(), client.ServiceClient(fakeServer), createOpts)
 	th.AssertEquals(t, "error creating the options map: Missing input for argument [Name]", r.Err.Error())
 }
 
 func TestAdoptStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateSuccessfully(t, CreateOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateSuccessfully(t, fakeServer, CreateOutput)
 	template := new(stacks.Template)
 	template.Bin = []byte(`
 {
@@ -102,7 +102,7 @@ func TestAdoptStack(t *testing.T) {
 		TemplateOpts:    template,
 		DisableRollback: gophercloud.Disabled,
 	}
-	actual, err := stacks.Adopt(context.TODO(), fake.ServiceClient(), adoptOpts).Extract()
+	actual, err := stacks.Adopt(context.TODO(), client.ServiceClient(fakeServer), adoptOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := CreateExpected
@@ -110,12 +110,12 @@ func TestAdoptStack(t *testing.T) {
 }
 
 func TestListStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t, FullListOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer, FullListOutput)
 
 	count := 0
-	err := stacks.List(fake.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := stacks.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		actual, err := stacks.ExtractStacks(page)
 		th.AssertNoErr(t, err)
@@ -129,11 +129,11 @@ func TestListStack(t *testing.T) {
 }
 
 func TestGetStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t, GetOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer, GetOutput)
 
-	actual, err := stacks.Get(context.TODO(), fake.ServiceClient(), "postman_stack", "16ef0584-4458-41eb-87c8-0dc8d5f66c87").Extract()
+	actual, err := stacks.Get(context.TODO(), client.ServiceClient(fakeServer), "postman_stack", "16ef0584-4458-41eb-87c8-0dc8d5f66c87").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := GetExpected
@@ -141,11 +141,11 @@ func TestGetStack(t *testing.T) {
 }
 
 func TestFindStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleFindSuccessfully(t, GetOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleFindSuccessfully(t, fakeServer, GetOutput)
 
-	actual, err := stacks.Find(context.TODO(), fake.ServiceClient(), "16ef0584-4458-41eb-87c8-0dc8d5f66c87").Extract()
+	actual, err := stacks.Find(context.TODO(), client.ServiceClient(fakeServer), "16ef0584-4458-41eb-87c8-0dc8d5f66c87").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := GetExpected
@@ -153,9 +153,9 @@ func TestFindStack(t *testing.T) {
 }
 
 func TestUpdateStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
 	template := new(stacks.Template)
 	template.Bin = []byte(`
@@ -172,14 +172,14 @@ func TestUpdateStack(t *testing.T) {
 	updateOpts := &stacks.UpdateOpts{
 		TemplateOpts: template,
 	}
-	err := stacks.Update(context.TODO(), fake.ServiceClient(), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada", updateOpts).ExtractErr()
+	err := stacks.Update(context.TODO(), client.ServiceClient(fakeServer), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada", updateOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestUpdateStackNoTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdateSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdateSuccessfully(t, fakeServer)
 
 	parameters := make(map[string]any)
 	parameters["flavor"] = "m1.tiny"
@@ -189,14 +189,14 @@ func TestUpdateStackNoTemplate(t *testing.T) {
 	}
 	expected := stacks.ErrTemplateRequired{}
 
-	err := stacks.Update(context.TODO(), fake.ServiceClient(), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada", updateOpts).ExtractErr()
+	err := stacks.Update(context.TODO(), client.ServiceClient(fakeServer), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada", updateOpts).ExtractErr()
 	th.AssertEquals(t, expected, err)
 }
 
 func TestUpdatePatchStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleUpdatePatchSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleUpdatePatchSuccessfully(t, fakeServer)
 
 	parameters := make(map[string]any)
 	parameters["flavor"] = "m1.tiny"
@@ -204,23 +204,23 @@ func TestUpdatePatchStack(t *testing.T) {
 	updateOpts := &stacks.UpdateOpts{
 		Parameters: parameters,
 	}
-	err := stacks.UpdatePatch(context.TODO(), fake.ServiceClient(), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada", updateOpts).ExtractErr()
+	err := stacks.UpdatePatch(context.TODO(), client.ServiceClient(fakeServer), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada", updateOpts).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDeleteStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteSuccessfully(t, fakeServer)
 
-	err := stacks.Delete(context.TODO(), fake.ServiceClient(), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada").ExtractErr()
+	err := stacks.Delete(context.TODO(), client.ServiceClient(fakeServer), "gophercloud-test-stack-2", "db6977b2-27aa-4775-9ae7-6213212d4ada").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestPreviewStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePreviewSuccessfully(t, GetOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePreviewSuccessfully(t, fakeServer, GetOutput)
 
 	template := new(stacks.Template)
 	template.Bin = []byte(`
@@ -240,7 +240,7 @@ func TestPreviewStack(t *testing.T) {
 		TemplateOpts:    template,
 		DisableRollback: gophercloud.Disabled,
 	}
-	actual, err := stacks.Preview(context.TODO(), fake.ServiceClient(), previewOpts).Extract()
+	actual, err := stacks.Preview(context.TODO(), client.ServiceClient(fakeServer), previewOpts).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := PreviewExpected
@@ -248,11 +248,11 @@ func TestPreviewStack(t *testing.T) {
 }
 
 func TestAbandonStack(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAbandonSuccessfully(t, AbandonOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAbandonSuccessfully(t, fakeServer, AbandonOutput)
 
-	actual, err := stacks.Abandon(context.TODO(), fake.ServiceClient(), "postman_stack", "16ef0584-4458-41eb-87c8-0dc8d5f66c8").Extract()
+	actual, err := stacks.Abandon(context.TODO(), client.ServiceClient(fakeServer), "postman_stack", "16ef0584-4458-41eb-87c8-0dc8d5f66c8").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := AbandonExpected
diff --git a/openstack/orchestration/v1/stacks/utils_test.go b/openstack/orchestration/v1/stacks/utils_test.go
index b7dd86bf0..bb9099370 100644
--- a/openstack/orchestration/v1/stacks/utils_test.go
+++ b/openstack/orchestration/v1/stacks/utils_test.go
@@ -44,34 +44,35 @@ func TestGetHTTPClient(t *testing.T) {
 // Implement a fakeclient that can be used to mock out HTTP requests
 type fakeClient struct {
 	BaseClient Client
+	FakeServer th.FakeServer
 }
 
 // this client's Get method first changes the URL given to point to
 // testhelper's (th) endpoints. This is done because the http Mux does not seem
 // to work for fqdns with the `file` scheme
 func (c fakeClient) Get(url string) (*http.Response, error) {
-	newurl := strings.Replace(url, "file://", th.Endpoint(), 1)
+	newurl := strings.Replace(url, "file://", c.FakeServer.Endpoint(), 1)
 	return c.BaseClient.Get(newurl)
 }
 
 // test the fetch function
 func TestFetch(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 	baseurl, err := getBasePath()
 	th.AssertNoErr(t, err)
 	fakeURL := strings.Join([]string{baseurl, "file.yaml"}, "/")
 	urlparsed, err := url.Parse(fakeURL)
 	th.AssertNoErr(t, err)
 
-	th.Mux.HandleFunc(urlparsed.Path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(urlparsed.Path, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		w.Header().Set("Content-Type", "application/jason")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, "Fee-fi-fo-fum")
 	})
 
-	client := fakeClient{BaseClient: getHTTPClient()}
+	client := fakeClient{BaseClient: getHTTPClient(), FakeServer: fakeServer}
 	te := TE{
 		URL:    "file.yaml",
 		client: client,
diff --git a/openstack/orchestration/v1/stacktemplates/testing/fixtures_test.go b/openstack/orchestration/v1/stacktemplates/testing/fixtures_test.go
index 2e6505702..7ee957aeb 100644
--- a/openstack/orchestration/v1/stacktemplates/testing/fixtures_test.go
+++ b/openstack/orchestration/v1/stacktemplates/testing/fixtures_test.go
@@ -7,7 +7,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/stacktemplates"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // GetExpected represents the expected object from a Get request.
@@ -40,10 +40,10 @@ const GetOutput = `
 
 // HandleGetSuccessfully creates an HTTP handler at `/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87/template`
 // on the test handler mux that responds with a `Get` response.
-func HandleGetSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87/template", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/stacks/postman_stack/16ef0584-4458-41eb-87c8-0dc8d5f66c87/template", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
@@ -83,10 +83,10 @@ const ValidateOutput = `
 
 // HandleValidateSuccessfully creates an HTTP handler at `/validate`
 // on the test handler mux that responds with a `Validate` response.
-func HandleValidateSuccessfully(t *testing.T, output string) {
-	th.Mux.HandleFunc("/validate", func(w http.ResponseWriter, r *http.Request) {
+func HandleValidateSuccessfully(t *testing.T, fakeServer th.FakeServer, output string) {
+	fakeServer.Mux.HandleFunc("/validate", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 
 		w.Header().Set("Content-Type", "application/json")
diff --git a/openstack/orchestration/v1/stacktemplates/testing/requests_test.go b/openstack/orchestration/v1/stacktemplates/testing/requests_test.go
index f52f4f75d..3e2eae944 100644
--- a/openstack/orchestration/v1/stacktemplates/testing/requests_test.go
+++ b/openstack/orchestration/v1/stacktemplates/testing/requests_test.go
@@ -6,15 +6,15 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/openstack/orchestration/v1/stacktemplates"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestGetTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetSuccessfully(t, GetOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetSuccessfully(t, fakeServer, GetOutput)
 
-	actual, err := stacktemplates.Get(context.TODO(), fake.ServiceClient(), "postman_stack", "16ef0584-4458-41eb-87c8-0dc8d5f66c87").Extract()
+	actual, err := stacktemplates.Get(context.TODO(), client.ServiceClient(fakeServer), "postman_stack", "16ef0584-4458-41eb-87c8-0dc8d5f66c87").Extract()
 	th.AssertNoErr(t, err)
 
 	expected := GetExpected
@@ -22,9 +22,9 @@ func TestGetTemplate(t *testing.T) {
 }
 
 func TestValidateTemplate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleValidateSuccessfully(t, ValidateOutput)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleValidateSuccessfully(t, fakeServer, ValidateOutput)
 
 	opts := stacktemplates.ValidateOpts{
 		Template: `{
@@ -51,7 +51,7 @@ func TestValidateTemplate(t *testing.T) {
 		  }
 		}`,
 	}
-	actual, err := stacktemplates.Validate(context.TODO(), fake.ServiceClient(), opts).Extract()
+	actual, err := stacktemplates.Validate(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	expected := ValidateExpected
diff --git a/openstack/placement/v1/resourceproviders/testing/fixtures_test.go b/openstack/placement/v1/resourceproviders/testing/fixtures_test.go
index 8766d88e2..7ddc91b24 100644
--- a/openstack/placement/v1/resourceproviders/testing/fixtures_test.go
+++ b/openstack/placement/v1/resourceproviders/testing/fixtures_test.go
@@ -8,7 +8,7 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/placement/v1/resourceproviders"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const ResourceProviderTestID = "99c09379-6e52-4ef8-9a95-b9ce6f68452e"
@@ -268,11 +268,11 @@ var ExpectedTraits = resourceproviders.ResourceProviderTraits{
 	},
 }
 
-func HandleResourceProviderList(t *testing.T) {
-	th.Mux.HandleFunc("/resource_providers",
+func HandleResourceProviderList(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/resource_providers",
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			w.WriteHeader(http.StatusOK)
@@ -281,10 +281,10 @@ func HandleResourceProviderList(t *testing.T) {
 		})
 }
 
-func HandleResourceProviderCreate(t *testing.T) {
-	th.Mux.HandleFunc("/resource_providers", func(w http.ResponseWriter, r *http.Request) {
+func HandleResourceProviderCreate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/resource_providers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -293,10 +293,10 @@ func HandleResourceProviderCreate(t *testing.T) {
 	})
 }
 
-func HandleResourceProviderGet(t *testing.T) {
-	th.Mux.HandleFunc("/resource_providers/99c09379-6e52-4ef8-9a95-b9ce6f68452e", func(w http.ResponseWriter, r *http.Request) {
+func HandleResourceProviderGet(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/resource_providers/99c09379-6e52-4ef8-9a95-b9ce6f68452e", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -305,18 +305,18 @@ func HandleResourceProviderGet(t *testing.T) {
 	})
 }
 
-func HandleResourceProviderDelete(t *testing.T) {
-	th.Mux.HandleFunc("/resource_providers/b99b3ab4-3aa6-4fba-b827-69b88b9c544a", func(w http.ResponseWriter, r *http.Request) {
+func HandleResourceProviderDelete(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/resource_providers/b99b3ab4-3aa6-4fba-b827-69b88b9c544a", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusNoContent)
 	})
 }
 
-func HandleResourceProviderUpdate(t *testing.T) {
-	th.Mux.HandleFunc("/resource_providers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
+func HandleResourceProviderUpdate(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/resource_providers/4e8e5957-649f-477b-9e5b-f1f75b21c03c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, ResourceProviderUpdateRequest)
@@ -328,13 +328,13 @@ func HandleResourceProviderUpdate(t *testing.T) {
 	})
 }
 
-func HandleResourceProviderGetUsages(t *testing.T) {
+func HandleResourceProviderGetUsages(t *testing.T, fakeServer th.FakeServer) {
 	usageTestUrl := fmt.Sprintf("/resource_providers/%s/usages", ResourceProviderTestID)
 
-	th.Mux.HandleFunc(usageTestUrl,
+	fakeServer.Mux.HandleFunc(usageTestUrl,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			w.WriteHeader(http.StatusOK)
@@ -343,13 +343,13 @@ func HandleResourceProviderGetUsages(t *testing.T) {
 		})
 }
 
-func HandleResourceProviderGetInventories(t *testing.T) {
+func HandleResourceProviderGetInventories(t *testing.T, fakeServer th.FakeServer) {
 	inventoriesTestUrl := fmt.Sprintf("/resource_providers/%s/inventories", ResourceProviderTestID)
 
-	th.Mux.HandleFunc(inventoriesTestUrl,
+	fakeServer.Mux.HandleFunc(inventoriesTestUrl,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			w.WriteHeader(http.StatusOK)
@@ -358,13 +358,13 @@ func HandleResourceProviderGetInventories(t *testing.T) {
 		})
 }
 
-func HandleResourceProviderGetAllocations(t *testing.T) {
+func HandleResourceProviderGetAllocations(t *testing.T, fakeServer th.FakeServer) {
 	allocationsTestUrl := fmt.Sprintf("/resource_providers/%s/allocations", ResourceProviderTestID)
 
-	th.Mux.HandleFunc(allocationsTestUrl,
+	fakeServer.Mux.HandleFunc(allocationsTestUrl,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			w.WriteHeader(http.StatusOK)
@@ -373,13 +373,13 @@ func HandleResourceProviderGetAllocations(t *testing.T) {
 		})
 }
 
-func HandleResourceProviderGetTraits(t *testing.T) {
+func HandleResourceProviderGetTraits(t *testing.T, fakeServer th.FakeServer) {
 	traitsTestUrl := fmt.Sprintf("/resource_providers/%s/traits", ResourceProviderTestID)
 
-	th.Mux.HandleFunc(traitsTestUrl,
+	fakeServer.Mux.HandleFunc(traitsTestUrl,
 		func(w http.ResponseWriter, r *http.Request) {
 			th.TestMethod(t, r, "GET")
-			th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 			w.Header().Add("Content-Type", "application/json")
 			w.WriteHeader(http.StatusOK)
diff --git a/openstack/placement/v1/resourceproviders/testing/requests_test.go b/openstack/placement/v1/resourceproviders/testing/requests_test.go
index ad0db1475..1336126ec 100644
--- a/openstack/placement/v1/resourceproviders/testing/requests_test.go
+++ b/openstack/placement/v1/resourceproviders/testing/requests_test.go
@@ -8,17 +8,17 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestListResourceProviders(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderList(t)
+	HandleResourceProviderList(t, fakeServer)
 
 	count := 0
-	err := resourceproviders.List(fake.ServiceClient(), resourceproviders.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := resourceproviders.List(client.ServiceClient(fakeServer), resourceproviders.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := resourceproviders.ExtractResourceProviders(page)
@@ -39,10 +39,10 @@ func TestListResourceProviders(t *testing.T) {
 }
 
 func TestCreateResourceProvider(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderCreate(t)
+	HandleResourceProviderCreate(t, fakeServer)
 
 	expected := ExpectedResourceProvider1
 
@@ -52,41 +52,41 @@ func TestCreateResourceProvider(t *testing.T) {
 		ParentProviderUUID: ExpectedResourceProvider1.ParentProviderUUID,
 	}
 
-	actual, err := resourceproviders.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	actual, err := resourceproviders.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &expected, actual)
 }
 
 func TestGetResourceProvider(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderGet(t)
+	HandleResourceProviderGet(t, fakeServer)
 
 	expected := ExpectedResourceProvider1
 
-	actual, err := resourceproviders.Get(context.TODO(), fake.ServiceClient(), ExpectedResourceProvider1.UUID).Extract()
+	actual, err := resourceproviders.Get(context.TODO(), client.ServiceClient(fakeServer), ExpectedResourceProvider1.UUID).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, &expected, actual)
 }
 
 func TestDeleteResourceProvider(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderDelete(t)
+	HandleResourceProviderDelete(t, fakeServer)
 
-	res := resourceproviders.Delete(context.TODO(), fake.ServiceClient(), "b99b3ab4-3aa6-4fba-b827-69b88b9c544a")
+	res := resourceproviders.Delete(context.TODO(), client.ServiceClient(fakeServer), "b99b3ab4-3aa6-4fba-b827-69b88b9c544a")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderUpdate(t)
+	HandleResourceProviderUpdate(t, fakeServer)
 
 	name := "new_name"
 	parentProviderUUID := "b99b3ab4-3aa6-4fba-b827-69b88b9c544a"
@@ -95,7 +95,7 @@ func TestUpdate(t *testing.T) {
 		Name:               &name,
 		ParentProviderUUID: &parentProviderUUID,
 	}
-	rp, err := resourceproviders.Update(context.TODO(), fake.ServiceClient(), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
+	rp, err := resourceproviders.Update(context.TODO(), client.ServiceClient(fakeServer), "4e8e5957-649f-477b-9e5b-f1f75b21c03c", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, rp.Name, name)
@@ -103,45 +103,45 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestGetResourceProvidersUsages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderGetUsages(t)
+	HandleResourceProviderGetUsages(t, fakeServer)
 
-	actual, err := resourceproviders.GetUsages(context.TODO(), fake.ServiceClient(), ResourceProviderTestID).Extract()
+	actual, err := resourceproviders.GetUsages(context.TODO(), client.ServiceClient(fakeServer), ResourceProviderTestID).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedUsages, *actual)
 }
 
 func TestGetResourceProvidersInventories(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderGetInventories(t)
+	HandleResourceProviderGetInventories(t, fakeServer)
 
-	actual, err := resourceproviders.GetInventories(context.TODO(), fake.ServiceClient(), ResourceProviderTestID).Extract()
+	actual, err := resourceproviders.GetInventories(context.TODO(), client.ServiceClient(fakeServer), ResourceProviderTestID).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedInventories, *actual)
 }
 
 func TestGetResourceProvidersAllocations(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderGetAllocations(t)
+	HandleResourceProviderGetAllocations(t, fakeServer)
 
-	actual, err := resourceproviders.GetAllocations(context.TODO(), fake.ServiceClient(), ResourceProviderTestID).Extract()
+	actual, err := resourceproviders.GetAllocations(context.TODO(), client.ServiceClient(fakeServer), ResourceProviderTestID).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedAllocations, *actual)
 }
 
 func TestGetResourceProvidersTraits(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	HandleResourceProviderGetTraits(t)
+	HandleResourceProviderGetTraits(t, fakeServer)
 
-	actual, err := resourceproviders.GetTraits(context.TODO(), fake.ServiceClient(), ResourceProviderTestID).Extract()
+	actual, err := resourceproviders.GetTraits(context.TODO(), client.ServiceClient(fakeServer), ResourceProviderTestID).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, ExpectedTraits, *actual)
 }
diff --git a/openstack/sharedfilesystems/apiversions/testing/fixtures_test.go b/openstack/sharedfilesystems/apiversions/testing/fixtures_test.go
index 37826cab7..ed60efd6f 100644
--- a/openstack/sharedfilesystems/apiversions/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/apiversions/testing/fixtures_test.go
@@ -178,8 +178,8 @@ var ManilaAllAPIVersionResults = []apiversions.APIVersion{
 	ManilaAPIVersion2Result,
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -190,8 +190,8 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/v2/", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -202,8 +202,8 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockGetNoResponse(t *testing.T) {
-	th.Mux.HandleFunc("/v2/", func(w http.ResponseWriter, r *http.Request) {
+func MockGetNoResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -214,8 +214,8 @@ func MockGetNoResponse(t *testing.T) {
 	})
 }
 
-func MockGetMultipleResponses(t *testing.T) {
-	th.Mux.HandleFunc("/v2/", func(w http.ResponseWriter, r *http.Request) {
+func MockGetMultipleResponses(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/v2/", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/sharedfilesystems/apiversions/testing/requests_test.go b/openstack/sharedfilesystems/apiversions/testing/requests_test.go
index 1e09f7daa..ab2d2a184 100644
--- a/openstack/sharedfilesystems/apiversions/testing/requests_test.go
+++ b/openstack/sharedfilesystems/apiversions/testing/requests_test.go
@@ -10,12 +10,12 @@ import (
 )
 
 func TestListAPIVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allVersions, err := apiversions.List(client.ServiceClient()).AllPages(context.TODO())
+	allVersions, err := apiversions.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := apiversions.ExtractAPIVersions(allVersions)
@@ -25,33 +25,33 @@ func TestListAPIVersions(t *testing.T) {
 }
 
 func TestGetAPIVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	actual, err := apiversions.Get(context.TODO(), client.ServiceClient(), "v2").Extract()
+	actual, err := apiversions.Get(context.TODO(), client.ServiceClient(fakeServer), "v2").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertDeepEquals(t, ManilaAPIVersion2Result, *actual)
 }
 
 func TestGetNoAPIVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetNoResponse(t)
+	MockGetNoResponse(t, fakeServer)
 
-	_, err := apiversions.Get(context.TODO(), client.ServiceClient(), "v2").Extract()
+	_, err := apiversions.Get(context.TODO(), client.ServiceClient(fakeServer), "v2").Extract()
 	th.AssertEquals(t, err.Error(), "Unable to find requested API version")
 }
 
 func TestGetMultipleAPIVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetMultipleResponses(t)
+	MockGetMultipleResponses(t, fakeServer)
 
-	_, err := apiversions.Get(context.TODO(), client.ServiceClient(), "v2").Extract()
+	_, err := apiversions.Get(context.TODO(), client.ServiceClient(fakeServer), "v2").Extract()
 	th.AssertEquals(t, err.Error(), "Found 2 API versions")
 }
diff --git a/openstack/sharedfilesystems/v2/availabilityzones/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/availabilityzones/testing/fixtures_test.go
index fa18c4cfc..5523f8a02 100644
--- a/openstack/sharedfilesystems/v2/availabilityzones/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/availabilityzones/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/os-availability-zone", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/os-availability-zone", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
diff --git a/openstack/sharedfilesystems/v2/availabilityzones/testing/requests_test.go b/openstack/sharedfilesystems/v2/availabilityzones/testing/requests_test.go
index 8d69781c3..e487b21e2 100644
--- a/openstack/sharedfilesystems/v2/availabilityzones/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/availabilityzones/testing/requests_test.go
@@ -12,12 +12,12 @@ import (
 
 // Verifies that availability zones can be listed correctly
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := availabilityzones.List(client.ServiceClient()).AllPages(context.TODO())
+	allPages, err := availabilityzones.List(client.ServiceClient(fakeServer)).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := availabilityzones.ExtractAvailabilityZones(allPages)
 	th.AssertNoErr(t, err)
diff --git a/openstack/sharedfilesystems/v2/errors/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/errors/testing/fixtures_test.go
index 3adbc89b2..5d70a1282 100644
--- a/openstack/sharedfilesystems/v2/errors/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/errors/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const shareEndpoint = "/shares"
@@ -28,10 +28,10 @@ var createResponse = `{
 }`
 
 // MockCreateResponse creates a mock response
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint, func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, createRequest)
diff --git a/openstack/sharedfilesystems/v2/errors/testing/request_test.go b/openstack/sharedfilesystems/v2/errors/testing/request_test.go
index f405721d7..cc3d98734 100644
--- a/openstack/sharedfilesystems/v2/errors/testing/request_test.go
+++ b/openstack/sharedfilesystems/v2/errors/testing/request_test.go
@@ -11,13 +11,13 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &shares.CreateOpts{Size: 1, Name: "my_test_share", ShareProto: "NFS", SnapshotID: "70bfbebc-d3ff-4528-8bbb-58422daa280b"}
-	_, err := shares.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	_, err := shares.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 
 	if err == nil {
 		t.Fatal("Expected error")
diff --git a/openstack/sharedfilesystems/v2/messages/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/messages/testing/fixtures_test.go
index 123bad35c..8b1f1fa02 100644
--- a/openstack/sharedfilesystems/v2/messages/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/messages/testing/fixtures_test.go
@@ -6,21 +6,21 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/messages/messageID", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/messages/messageID", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/messages", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/messages", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -59,10 +59,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockFilteredListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/messages", func(w http.ResponseWriter, r *http.Request) {
+func MockFilteredListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/messages", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -88,10 +88,10 @@ func MockFilteredListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/messages/2076373e-13a7-4b84-9e67-15ce8cceaff8", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/messages/2076373e-13a7-4b84-9e67-15ce8cceaff8", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
diff --git a/openstack/sharedfilesystems/v2/messages/testing/requests_test.go b/openstack/sharedfilesystems/v2/messages/testing/requests_test.go
index 75b0b57dc..1206d090c 100644
--- a/openstack/sharedfilesystems/v2/messages/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/messages/testing/requests_test.go
@@ -12,23 +12,23 @@ import (
 
 // Verifies that message deletion works
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := messages.Delete(context.TODO(), client.ServiceClient(), "messageID")
+	res := messages.Delete(context.TODO(), client.ServiceClient(fakeServer), "messageID")
 	th.AssertNoErr(t, res.Err)
 }
 
 // Verifies that messages can be listed correctly
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := messages.List(client.ServiceClient(), &messages.ListOpts{}).AllPages(context.TODO())
+	allPages, err := messages.List(client.ServiceClient(fakeServer), &messages.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := messages.ExtractMessages(allPages)
 	th.AssertNoErr(t, err)
@@ -66,16 +66,16 @@ func TestList(t *testing.T) {
 
 // Verifies that messages list can be called with query parameters
 func TestFilteredList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockFilteredListResponse(t)
+	MockFilteredListResponse(t, fakeServer)
 
 	options := &messages.ListOpts{
 		RequestID: "req-21767eee-22ca-40a4-b6c0-ae7d35cd434f",
 	}
 
-	allPages, err := messages.List(client.ServiceClient(), options).AllPages(context.TODO())
+	allPages, err := messages.List(client.ServiceClient(fakeServer), options).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := messages.ExtractMessages(allPages)
 	th.AssertNoErr(t, err)
@@ -100,10 +100,10 @@ func TestFilteredList(t *testing.T) {
 
 // Verifies that it is possible to get a message
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
 	expected := messages.Message{
 		ResourceID:   "4336d74f-3bdc-4f27-9657-c01ec63680bf",
@@ -119,7 +119,7 @@ func TestGet(t *testing.T) {
 		ActionID:     "002",
 	}
 
-	n, err := messages.Get(context.TODO(), client.ServiceClient(), "2076373e-13a7-4b84-9e67-15ce8cceaff8").Extract()
+	n, err := messages.Get(context.TODO(), client.ServiceClient(fakeServer), "2076373e-13a7-4b84-9e67-15ce8cceaff8").Extract()
 	th.AssertNoErr(t, err)
 
 	th.CheckDeepEquals(t, &expected, n)
diff --git a/openstack/sharedfilesystems/v2/replicas/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/replicas/testing/fixtures_test.go
index 41fa0164c..5e14cb28d 100644
--- a/openstack/sharedfilesystems/v2/replicas/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/replicas/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const (
@@ -38,10 +38,10 @@ var createResponse = `{
 `
 
 // MockCreateResponse creates a mock response
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint, func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
@@ -53,10 +53,10 @@ func MockCreateResponse(t *testing.T) {
 }
 
 // MockDeleteResponse creates a mock delete response
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID, func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
 		w.WriteHeader(http.StatusAccepted)
 	})
@@ -69,10 +69,10 @@ var promoteRequest = `{
 }
 `
 
-func MockPromoteResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockPromoteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
@@ -86,10 +86,10 @@ var resyncRequest = `{
 }
 `
 
-func MockResyncResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockResyncResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
@@ -105,10 +105,10 @@ var resetStatusRequest = `{
 }
 `
 
-func MockResetStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockResetStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
@@ -124,10 +124,10 @@ var resetStateRequest = `{
 }
 `
 
-func MockResetStateResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockResetStateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
@@ -141,10 +141,10 @@ var deleteRequest = `{
 }
 `
 
-func MockForceDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockForceDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
@@ -169,10 +169,10 @@ var getResponse = `{
 `
 
 // MockGetResponse creates a mock get response
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID, func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, getResponse)
@@ -206,10 +206,10 @@ var listResponse = `{
 var listEmptyResponse = `{"share_replicas": []}`
 
 // MockListResponse creates a mock detailed-list response
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint, func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
 
 		w.Header().Add("Content-Type", "application/json")
@@ -275,10 +275,10 @@ var listDetailResponse = `{
 var listDetailEmptyResponse = `{"share_replicas": []}`
 
 // MockListDetailResponse creates a mock detailed-list response
-func MockListDetailResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListDetailResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.11")
 
 		w.Header().Add("Content-Type", "application/json")
@@ -323,10 +323,10 @@ var listExportLocationsResponse = `{
 `
 
 // MockListExportLocationsResponse creates a mock get export locations response
-func MockListExportLocationsResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/export-locations", func(w http.ResponseWriter, r *http.Request) {
+func MockListExportLocationsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/export-locations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.47")
 		w.WriteHeader(http.StatusOK)
@@ -348,10 +348,10 @@ var getExportLocationResponse = `{
 `
 
 // MockGetExportLocationResponse creates a mock get export location response
-func MockGetExportLocationResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/export-locations/ae73e762-e8b9-4aad-aad3-23afb7cd6825", func(w http.ResponseWriter, r *http.Request) {
+func MockGetExportLocationResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+replicaID+"/export-locations/ae73e762-e8b9-4aad-aad3-23afb7cd6825", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		th.TestHeader(t, r, "X-OpenStack-Manila-API-Version", "2.47")
 		w.WriteHeader(http.StatusOK)
diff --git a/openstack/sharedfilesystems/v2/replicas/testing/request_test.go b/openstack/sharedfilesystems/v2/replicas/testing/request_test.go
index 167bc2c87..f083ad664 100644
--- a/openstack/sharedfilesystems/v2/replicas/testing/request_test.go
+++ b/openstack/sharedfilesystems/v2/replicas/testing/request_test.go
@@ -11,24 +11,24 @@ import (
 	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func getClient(microVersion string) *gophercloud.ServiceClient {
-	c := client.ServiceClient()
+func getClient(fakeServer th.FakeServer, microVersion string) *gophercloud.ServiceClient {
+	c := client.ServiceClient(fakeServer)
 	c.Type = "sharev2"
 	c.Microversion = microVersion
 	return c
 }
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &replicas.CreateOpts{
 		ShareID:          "65a34695-f9e5-4eea-b48d-a0b261d82943",
 		AvailabilityZone: "zone-1",
 	}
-	actual, err := replicas.Create(context.TODO(), getClient("2.11"), options).Extract()
+	actual, err := replicas.Create(context.TODO(), getClient(fakeServer, "2.11"), options).Extract()
 
 	expected := &replicas.Replica{
 		ID:               "3b9c33e8-b136-45c6-84a6-019c8db1d550",
@@ -44,32 +44,32 @@ func TestCreate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	result := replicas.Delete(context.TODO(), getClient("2.11"), replicaID)
+	result := replicas.Delete(context.TODO(), getClient(fakeServer, "2.11"), replicaID)
 	th.AssertNoErr(t, result.Err)
 }
 
 func TestForceDeleteSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockForceDeleteResponse(t)
+	MockForceDeleteResponse(t, fakeServer)
 
-	err := replicas.ForceDelete(context.TODO(), getClient("2.11"), replicaID).ExtractErr()
+	err := replicas.ForceDelete(context.TODO(), getClient(fakeServer, "2.11"), replicaID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	actual, err := replicas.Get(context.TODO(), getClient("2.11"), replicaID).Extract()
+	actual, err := replicas.Get(context.TODO(), getClient(fakeServer, "2.11"), replicaID).Extract()
 
 	expected := &replicas.Replica{
 		AvailabilityZone: "zone-1",
@@ -88,15 +88,15 @@ func TestGet(t *testing.T) {
 }
 
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
 	listOpts := &replicas.ListOpts{
 		ShareID: "65a34695-f9e5-4eea-b48d-a0b261d82943",
 	}
-	allPages, err := replicas.List(getClient("2.11"), listOpts).AllPages(context.TODO())
+	allPages, err := replicas.List(getClient(fakeServer, "2.11"), listOpts).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := replicas.ExtractReplicas(allPages)
@@ -127,15 +127,15 @@ func TestList(t *testing.T) {
 }
 
 func TestListDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListDetailResponse(t)
+	MockListDetailResponse(t, fakeServer)
 
 	listOpts := &replicas.ListOpts{
 		ShareID: "65a34695-f9e5-4eea-b48d-a0b261d82943",
 	}
-	allPages, err := replicas.ListDetail(getClient("2.11"), listOpts).AllPages(context.TODO())
+	allPages, err := replicas.ListDetail(getClient(fakeServer, "2.11"), listOpts).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 
 	actual, err := replicas.ExtractReplicas(allPages)
@@ -181,12 +181,12 @@ func TestListDetail(t *testing.T) {
 }
 
 func TestListExportLocationsSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListExportLocationsResponse(t)
+	MockListExportLocationsResponse(t, fakeServer)
 
-	actual, err := replicas.ListExportLocations(context.TODO(), getClient("2.47"), replicaID).Extract()
+	actual, err := replicas.ListExportLocations(context.TODO(), getClient(fakeServer, "2.47"), replicaID).Extract()
 
 	expected := []replicas.ExportLocation{
 		{
@@ -210,12 +210,12 @@ func TestListExportLocationsSuccess(t *testing.T) {
 }
 
 func TestGetExportLocationSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetExportLocationResponse(t)
+	MockGetExportLocationResponse(t, fakeServer)
 
-	s, err := replicas.GetExportLocation(context.TODO(), getClient("2.47"), replicaID, "ae73e762-e8b9-4aad-aad3-23afb7cd6825").Extract()
+	s, err := replicas.GetExportLocation(context.TODO(), getClient(fakeServer, "2.47"), replicaID, "ae73e762-e8b9-4aad-aad3-23afb7cd6825").Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, s, &replicas.ExportLocation{
@@ -230,41 +230,41 @@ func TestGetExportLocationSuccess(t *testing.T) {
 }
 
 func TestResetStatusSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStatusResponse(t)
+	MockResetStatusResponse(t, fakeServer)
 
-	err := replicas.ResetStatus(context.TODO(), getClient("2.11"), replicaID, &replicas.ResetStatusOpts{Status: "available"}).ExtractErr()
+	err := replicas.ResetStatus(context.TODO(), getClient(fakeServer, "2.11"), replicaID, &replicas.ResetStatusOpts{Status: "available"}).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestResetStateSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStateResponse(t)
+	MockResetStateResponse(t, fakeServer)
 
-	err := replicas.ResetState(context.TODO(), getClient("2.11"), replicaID, &replicas.ResetStateOpts{State: "active"}).ExtractErr()
+	err := replicas.ResetState(context.TODO(), getClient(fakeServer, "2.11"), replicaID, &replicas.ResetStateOpts{State: "active"}).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestResyncSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResyncResponse(t)
+	MockResyncResponse(t, fakeServer)
 
-	err := replicas.Resync(context.TODO(), getClient("2.11"), replicaID).ExtractErr()
+	err := replicas.Resync(context.TODO(), getClient(fakeServer, "2.11"), replicaID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestPromoteSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockPromoteResponse(t)
+	MockPromoteResponse(t, fakeServer)
 
-	err := replicas.Promote(context.TODO(), getClient("2.11"), replicaID, &replicas.PromoteOpts{QuiesceWaitTime: 30}).ExtractErr()
+	err := replicas.Promote(context.TODO(), getClient(fakeServer, "2.11"), replicaID, &replicas.PromoteOpts{QuiesceWaitTime: 30}).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/sharedfilesystems/v2/schedulerstats/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/schedulerstats/testing/fixtures_test.go
index fdd861d9c..ed4b325da 100644
--- a/openstack/sharedfilesystems/v2/schedulerstats/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/schedulerstats/testing/fixtures_test.go
@@ -264,8 +264,8 @@ var (
 	}
 )
 
-func HandlePoolsListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/scheduler-stats/pools", func(w http.ResponseWriter, r *http.Request) {
+func HandlePoolsListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/scheduler-stats/pools", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -277,7 +277,7 @@ func HandlePoolsListSuccessfully(t *testing.T) {
 		fmt.Fprint(w, PoolsListBody)
 
 	})
-	th.Mux.HandleFunc("/scheduler-stats/pools/detail", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/scheduler-stats/pools/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/sharedfilesystems/v2/schedulerstats/testing/requests_test.go b/openstack/sharedfilesystems/v2/schedulerstats/testing/requests_test.go
index d6b826ed7..057f4458a 100644
--- a/openstack/sharedfilesystems/v2/schedulerstats/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/schedulerstats/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListPoolsDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandlePoolsListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandlePoolsListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := schedulerstats.List(client.ServiceClient(), schedulerstats.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := schedulerstats.List(client.ServiceClient(fakeServer), schedulerstats.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := schedulerstats.ExtractPools(page)
@@ -40,7 +40,7 @@ func TestListPoolsDetail(t *testing.T) {
 	}
 
 	pages = 0
-	err = schedulerstats.ListDetail(client.ServiceClient(), schedulerstats.ListDetailOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err = schedulerstats.ListDetail(client.ServiceClient(fakeServer), schedulerstats.ListDetailOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := schedulerstats.ExtractPools(page)
diff --git a/openstack/sharedfilesystems/v2/securityservices/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/securityservices/testing/fixtures_test.go
index 279fcee4a..1cd713922 100644
--- a/openstack/sharedfilesystems/v2/securityservices/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/securityservices/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/security-services", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/security-services", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -51,18 +51,18 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/security-services/securityServiceID", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/security-services/securityServiceID", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/security-services/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/security-services/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -105,10 +105,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockFilteredListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/security-services/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockFilteredListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/security-services/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -136,10 +136,10 @@ func MockFilteredListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/security-services/3c829734-0679-4c17-9637-801da48c0d5f", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/security-services/3c829734-0679-4c17-9637-801da48c0d5f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -164,10 +164,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/security-services/securityServiceID", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/security-services/securityServiceID", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `
             {
diff --git a/openstack/sharedfilesystems/v2/securityservices/testing/requests_test.go b/openstack/sharedfilesystems/v2/securityservices/testing/requests_test.go
index 391485cdc..39232ad7a 100644
--- a/openstack/sharedfilesystems/v2/securityservices/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/securityservices/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 
 // Verifies that a security service can be created correctly
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &securityservices.CreateOpts{
 		Name:        "SecServ1",
@@ -27,7 +27,7 @@ func TestCreate(t *testing.T) {
 		Type:        "kerberos",
 	}
 
-	s, err := securityservices.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	s, err := securityservices.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, s.Name, "SecServ1")
@@ -39,7 +39,10 @@ func TestCreate(t *testing.T) {
 }
 
 // Verifies that a security service cannot be created without a type
-func TestCreateFails(t *testing.T) {
+func TestRequiredCreateOpts(t *testing.T) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
 	options := &securityservices.CreateOpts{
 		Name:        "SecServ1",
 		Description: "Creating my first Security Service",
@@ -48,7 +51,7 @@ func TestCreateFails(t *testing.T) {
 		Password:    "***",
 	}
 
-	_, err := securityservices.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	_, err := securityservices.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	if _, ok := err.(gophercloud.ErrMissingInput); !ok {
 		t.Fatal("ErrMissingInput was expected to occur")
 	}
@@ -56,23 +59,23 @@ func TestCreateFails(t *testing.T) {
 
 // Verifies that security service deletion works
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := securityservices.Delete(context.TODO(), client.ServiceClient(), "securityServiceID")
+	res := securityservices.Delete(context.TODO(), client.ServiceClient(fakeServer), "securityServiceID")
 	th.AssertNoErr(t, res.Err)
 }
 
 // Verifies that security services can be listed correctly
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := securityservices.List(client.ServiceClient(), &securityservices.ListOpts{}).AllPages(context.TODO())
+	allPages, err := securityservices.List(client.ServiceClient(fakeServer), &securityservices.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := securityservices.ExtractSecurityServices(allPages)
 	th.AssertNoErr(t, err)
@@ -115,16 +118,16 @@ func TestList(t *testing.T) {
 
 // Verifies that security services list can be called with query parameters
 func TestFilteredList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockFilteredListResponse(t)
+	MockFilteredListResponse(t, fakeServer)
 
 	options := &securityservices.ListOpts{
 		Type: "kerberos",
 	}
 
-	allPages, err := securityservices.List(client.ServiceClient(), options).AllPages(context.TODO())
+	allPages, err := securityservices.List(client.ServiceClient(fakeServer), options).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := securityservices.ExtractSecurityServices(allPages)
 	th.AssertNoErr(t, err)
@@ -152,10 +155,10 @@ func TestFilteredList(t *testing.T) {
 
 // Verifies that it is possible to get a security service
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
 	var nilTime time.Time
 	expected := securityservices.SecurityService{
@@ -174,7 +177,7 @@ func TestGet(t *testing.T) {
 		Password:    "supersecret",
 	}
 
-	n, err := securityservices.Get(context.TODO(), client.ServiceClient(), "3c829734-0679-4c17-9637-801da48c0d5f").Extract()
+	n, err := securityservices.Get(context.TODO(), client.ServiceClient(fakeServer), "3c829734-0679-4c17-9637-801da48c0d5f").Extract()
 	th.AssertNoErr(t, err)
 
 	th.CheckDeepEquals(t, &expected, n)
@@ -182,10 +185,10 @@ func TestGet(t *testing.T) {
 
 // Verifies that it is possible to update a security service
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateResponse(t)
+	MockUpdateResponse(t, fakeServer)
 	expected := securityservices.SecurityService{
 		ID:          "securityServiceID",
 		Name:        "SecServ2",
@@ -204,7 +207,7 @@ func TestUpdate(t *testing.T) {
 
 	name := "SecServ2"
 	options := securityservices.UpdateOpts{Name: &name}
-	s, err := securityservices.Update(context.TODO(), client.ServiceClient(), "securityServiceID", options).Extract()
+	s, err := securityservices.Update(context.TODO(), client.ServiceClient(fakeServer), "securityServiceID", options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, s)
 }
diff --git a/openstack/sharedfilesystems/v2/services/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/services/testing/fixtures_test.go
index 9916b033f..1c8bd7a57 100644
--- a/openstack/sharedfilesystems/v2/services/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/services/testing/fixtures_test.go
@@ -60,8 +60,8 @@ var SecondFakeService = services.Service{
 }
 
 // HandleListSuccessfully configures the test server to respond to a List request.
-func HandleListSuccessfully(t *testing.T) {
-	th.Mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) {
+func HandleListSuccessfully(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/services", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/openstack/sharedfilesystems/v2/services/testing/requests_test.go b/openstack/sharedfilesystems/v2/services/testing/requests_test.go
index d4845ca09..af5e657b4 100644
--- a/openstack/sharedfilesystems/v2/services/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/services/testing/requests_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 func TestListServices(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListSuccessfully(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListSuccessfully(t, fakeServer)
 
 	pages := 0
-	err := services.List(client.ServiceClient(), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := services.List(client.ServiceClient(fakeServer), services.ListOpts{}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 
 		actual, err := services.ExtractServices(page)
diff --git a/openstack/sharedfilesystems/v2/shareaccessrules/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/shareaccessrules/testing/fixtures_test.go
index cc63ffac9..eb5a90a20 100644
--- a/openstack/sharedfilesystems/v2/shareaccessrules/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/shareaccessrules/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const (
@@ -33,10 +33,10 @@ var getResponse = `{
     }
 }`
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareAccessRulesEndpoint+"/"+shareAccessRuleID, func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareAccessRulesEndpoint+"/"+shareAccessRuleID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
diff --git a/openstack/sharedfilesystems/v2/shareaccessrules/testing/requests_test.go b/openstack/sharedfilesystems/v2/shareaccessrules/testing/requests_test.go
index 7566788e4..d0600a183 100644
--- a/openstack/sharedfilesystems/v2/shareaccessrules/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/shareaccessrules/testing/requests_test.go
@@ -10,16 +10,15 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/sharedfilesystems/v2/shareaccessrules"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
 	"github.com/gophercloud/gophercloud/v2/testhelper/client"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	resp := shareaccessrules.Get(context.TODO(), client.ServiceClient(), "507bf114-36f2-4f56-8cf4-857985ca87c1")
+	resp := shareaccessrules.Get(context.TODO(), client.ServiceClient(fakeServer), "507bf114-36f2-4f56-8cf4-857985ca87c1")
 	th.AssertNoErr(t, resp.Err)
 
 	accessRule, err := resp.Extract()
@@ -42,10 +41,10 @@ func TestGet(t *testing.T) {
 	}, accessRule)
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareAccessRulesEndpoint, func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareAccessRulesEndpoint, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
diff --git a/openstack/sharedfilesystems/v2/sharenetworks/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/sharenetworks/testing/fixtures_test.go
index eb608f9b6..5dc89b882 100644
--- a/openstack/sharedfilesystems/v2/sharenetworks/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/sharenetworks/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func createReq(name, description, network, subnetwork string) string {
@@ -41,10 +41,10 @@ func createResp(name, description, network, subnetwork string) string {
     }`, name, description, network, subnetwork)
 }
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, createReq("my_network",
@@ -62,18 +62,18 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks/fa158a3d-6d9f-4187-9ca5-abbb82646eb2", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks/fa158a3d-6d9f-4187-9ca5-abbb82646eb2", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -143,10 +143,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockFilteredListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockFilteredListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -228,10 +228,10 @@ func MockFilteredListResponse(t *testing.T) {
 	})
 }
 
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks/7f950b52-6141-4a08-bbb5-bb7ffa3ea5fd", func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks/7f950b52-6141-4a08-bbb5-bb7ffa3ea5fd", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -256,10 +256,10 @@ func MockGetResponse(t *testing.T) {
 	})
 }
 
-func MockUpdateNeutronResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks/713df749-aac0-4a54-af52-10f6c991e80c", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateNeutronResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks/713df749-aac0-4a54-af52-10f6c991e80c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `
             {
@@ -283,10 +283,10 @@ func MockUpdateNeutronResponse(t *testing.T) {
 	})
 }
 
-func MockUpdateNovaResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks/713df749-aac0-4a54-af52-10f6c991e80c", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateNovaResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks/713df749-aac0-4a54-af52-10f6c991e80c", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `
             {
@@ -310,10 +310,10 @@ func MockUpdateNovaResponse(t *testing.T) {
 	})
 }
 
-func MockAddSecurityServiceResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks/shareNetworkID/action", func(w http.ResponseWriter, r *http.Request) {
+func MockAddSecurityServiceResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks/shareNetworkID/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `
         {
@@ -336,10 +336,10 @@ func MockAddSecurityServiceResponse(t *testing.T) {
 	})
 }
 
-func MockRemoveSecurityServiceResponse(t *testing.T) {
-	th.Mux.HandleFunc("/share-networks/shareNetworkID/action", func(w http.ResponseWriter, r *http.Request) {
+func MockRemoveSecurityServiceResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-networks/shareNetworkID/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, `
         {
diff --git a/openstack/sharedfilesystems/v2/sharenetworks/testing/requests_test.go b/openstack/sharedfilesystems/v2/sharenetworks/testing/requests_test.go
index 1cbbb6df5..5ad5bae07 100644
--- a/openstack/sharedfilesystems/v2/sharenetworks/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/sharenetworks/testing/requests_test.go
@@ -13,10 +13,10 @@ import (
 
 // Verifies that a share network can be created correctly
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &sharenetworks.CreateOpts{
 		Name:            "my_network",
@@ -25,7 +25,7 @@ func TestCreate(t *testing.T) {
 		NeutronSubnetID: "53482b62-2c84-4a53-b6ab-30d9d9800d06",
 	}
 
-	n, err := sharenetworks.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := sharenetworks.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, n.Name, "my_network")
@@ -36,23 +36,23 @@ func TestCreate(t *testing.T) {
 
 // Verifies that share network deletion works
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	res := sharenetworks.Delete(context.TODO(), client.ServiceClient(), "fa158a3d-6d9f-4187-9ca5-abbb82646eb2")
+	res := sharenetworks.Delete(context.TODO(), client.ServiceClient(fakeServer), "fa158a3d-6d9f-4187-9ca5-abbb82646eb2")
 	th.AssertNoErr(t, res.Err)
 }
 
 // Verifies that share networks can be listed correctly
 func TestListDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := sharenetworks.ListDetail(client.ServiceClient(), &sharenetworks.ListOpts{}).AllPages(context.TODO())
+	allPages, err := sharenetworks.ListDetail(client.ServiceClient(fakeServer), &sharenetworks.ListOpts{}).AllPages(context.TODO())
 
 	th.AssertNoErr(t, err)
 	actual, err := sharenetworks.ExtractShareNetworks(allPages)
@@ -112,10 +112,10 @@ func TestListDetail(t *testing.T) {
 
 // Verifies that share networks list can be called with query parameters
 func TestPaginatedListDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockFilteredListResponse(t)
+	MockFilteredListResponse(t, fakeServer)
 
 	options := &sharenetworks.ListOpts{
 		Offset: 0,
@@ -124,7 +124,7 @@ func TestPaginatedListDetail(t *testing.T) {
 
 	count := 0
 
-	err := sharenetworks.ListDetail(client.ServiceClient(), options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := sharenetworks.ListDetail(client.ServiceClient(fakeServer), options).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 		_, err := sharenetworks.ExtractShareNetworks(page)
 		if err != nil {
@@ -141,10 +141,10 @@ func TestPaginatedListDetail(t *testing.T) {
 
 // Verifies that it is possible to get a share network
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
 	var nilTime time.Time
 	expected := sharenetworks.ShareNetwork{
@@ -163,7 +163,7 @@ func TestGet(t *testing.T) {
 		ProjectID:       "16e1ab15c35a457e9c2b2aa189f544e1",
 	}
 
-	n, err := sharenetworks.Get(context.TODO(), client.ServiceClient(), "7f950b52-6141-4a08-bbb5-bb7ffa3ea5fd").Extract()
+	n, err := sharenetworks.Get(context.TODO(), client.ServiceClient(fakeServer), "7f950b52-6141-4a08-bbb5-bb7ffa3ea5fd").Extract()
 	th.AssertNoErr(t, err)
 
 	th.CheckDeepEquals(t, &expected, n)
@@ -171,10 +171,10 @@ func TestGet(t *testing.T) {
 
 // Verifies that it is possible to update a share network using neutron network
 func TestUpdateNeutron(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateNeutronResponse(t)
+	MockUpdateNeutronResponse(t, fakeServer)
 
 	expected := sharenetworks.ShareNetwork{
 		ID:              "713df749-aac0-4a54-af52-10f6c991e80c",
@@ -201,17 +201,17 @@ func TestUpdateNeutron(t *testing.T) {
 		NeutronSubnetID: "new-neutron-subnet-id",
 	}
 
-	v, err := sharenetworks.Update(context.TODO(), client.ServiceClient(), "713df749-aac0-4a54-af52-10f6c991e80c", options).Extract()
+	v, err := sharenetworks.Update(context.TODO(), client.ServiceClient(fakeServer), "713df749-aac0-4a54-af52-10f6c991e80c", options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, v)
 }
 
 // Verifies that it is possible to update a share network using nova network
 func TestUpdateNova(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateNovaResponse(t)
+	MockUpdateNovaResponse(t, fakeServer)
 
 	expected := sharenetworks.ShareNetwork{
 		ID:              "713df749-aac0-4a54-af52-10f6c991e80c",
@@ -237,17 +237,17 @@ func TestUpdateNova(t *testing.T) {
 		NovaNetID:   "new-nova-id",
 	}
 
-	v, err := sharenetworks.Update(context.TODO(), client.ServiceClient(), "713df749-aac0-4a54-af52-10f6c991e80c", options).Extract()
+	v, err := sharenetworks.Update(context.TODO(), client.ServiceClient(fakeServer), "713df749-aac0-4a54-af52-10f6c991e80c", options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, v)
 }
 
 // Verifies that it is possible to add a security service to a share network
 func TestAddSecurityService(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockAddSecurityServiceResponse(t)
+	MockAddSecurityServiceResponse(t, fakeServer)
 
 	var nilTime time.Time
 	expected := sharenetworks.ShareNetwork{
@@ -267,19 +267,19 @@ func TestAddSecurityService(t *testing.T) {
 	}
 
 	options := sharenetworks.AddSecurityServiceOpts{SecurityServiceID: "securityServiceID"}
-	s, err := sharenetworks.AddSecurityService(context.TODO(), client.ServiceClient(), "shareNetworkID", options).Extract()
+	s, err := sharenetworks.AddSecurityService(context.TODO(), client.ServiceClient(fakeServer), "shareNetworkID", options).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, s)
 }
 
 // Verifies that it is possible to remove a security service from a share network
 func TestRemoveSecurityService(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockRemoveSecurityServiceResponse(t)
+	MockRemoveSecurityServiceResponse(t, fakeServer)
 
 	options := sharenetworks.RemoveSecurityServiceOpts{SecurityServiceID: "securityServiceID"}
-	_, err := sharenetworks.RemoveSecurityService(context.TODO(), client.ServiceClient(), "shareNetworkID", options).Extract()
+	_, err := sharenetworks.RemoveSecurityService(context.TODO(), client.ServiceClient(fakeServer), "shareNetworkID", options).Extract()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/sharedfilesystems/v2/shares/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/shares/testing/fixtures_test.go
index 36db8b7a2..c7ff0d287 100644
--- a/openstack/sharedfilesystems/v2/shares/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/shares/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const (
@@ -75,10 +75,10 @@ var createResponse = `{
 	}`
 
 // MockCreateResponse creates a mock response
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint, func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, createRequest)
@@ -89,10 +89,10 @@ func MockCreateResponse(t *testing.T) {
 }
 
 // MockDeleteResponse creates a mock delete response
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID, func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
@@ -149,10 +149,10 @@ var updateResponse = `
 }
 `
 
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID, func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, updateRequest)
@@ -206,10 +206,10 @@ var getResponse = `{
 }`
 
 // MockGetResponse creates a mock get response
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID, func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, getResponse)
 	})
@@ -263,10 +263,10 @@ var listDetailResponse = `{
 var listDetailEmptyResponse = `{"shares": []}`
 
 // MockListDetailResponse creates a mock detailed-list response
-func MockListDetailResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListDetailResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -298,10 +298,10 @@ var listExportLocationsResponse = `{
 }`
 
 // MockListExportLocationsResponse creates a mock get export locations response
-func MockListExportLocationsResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/export_locations", func(w http.ResponseWriter, r *http.Request) {
+func MockListExportLocationsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/export_locations", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, listExportLocationsResponse)
@@ -319,10 +319,10 @@ var getExportLocationResponse = `{
 }`
 
 // MockGetExportLocationResponse creates a mock get export location response
-func MockGetExportLocationResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/export_locations/80ed63fc-83bc-4afc-b881-da4a345ac83d", func(w http.ResponseWriter, r *http.Request) {
+func MockGetExportLocationResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/export_locations/80ed63fc-83bc-4afc-b881-da4a345ac83d", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, getExportLocationResponse)
@@ -350,10 +350,10 @@ var grantAccessResponse = `{
 }`
 
 // MockGrantAccessResponse creates a mock grant access response
-func MockGrantAccessResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockGrantAccessResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, grantAccessRequest)
@@ -370,10 +370,10 @@ var revokeAccessRequest = `{
 }`
 
 // MockRevokeAccessResponse creates a mock revoke access response
-func MockRevokeAccessResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockRevokeAccessResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, revokeAccessRequest)
@@ -401,10 +401,10 @@ var listAccessRightsResponse = `{
 	}`
 
 // MockListAccessRightsResponse creates a mock list access response
-func MockListAccessRightsResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockListAccessRightsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, listAccessRightsRequest)
@@ -421,10 +421,10 @@ var extendRequest = `{
 	}`
 
 // MockExtendResponse creates a mock extend share response
-func MockExtendResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockExtendResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, extendRequest)
@@ -440,10 +440,10 @@ var shrinkRequest = `{
 	}`
 
 // MockShrinkResponse creates a mock shrink share response
-func MockShrinkResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockShrinkResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, shrinkRequest)
@@ -459,10 +459,10 @@ var getMetadataResponse = `{
 	}`
 
 // MockGetMetadataResponse creates a mock get metadata response
-func MockGetMetadataResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata", func(w http.ResponseWriter, r *http.Request) {
+func MockGetMetadataResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -477,10 +477,10 @@ var getMetadatumResponse = `{
 	}`
 
 // MockGetMetadatumResponse creates a mock get metadatum response
-func MockGetMetadatumResponse(t *testing.T, key string) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata/"+key, func(w http.ResponseWriter, r *http.Request) {
+func MockGetMetadatumResponse(t *testing.T, fakeServer th.FakeServer, key string) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata/"+key, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Accept", "application/json")
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -501,10 +501,10 @@ var setMetadataResponse = `{
 	}`
 
 // MockSetMetadataResponse creates a mock set metadata response
-func MockSetMetadataResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata", func(w http.ResponseWriter, r *http.Request) {
+func MockSetMetadataResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, setMetadataRequest)
@@ -527,10 +527,10 @@ var updateMetadataResponse = `{
 	}`
 
 // MockUpdateMetadataResponse creates a mock update metadata response
-func MockUpdateMetadataResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata", func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateMetadataResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, updateMetadataRequest)
@@ -541,10 +541,10 @@ func MockUpdateMetadataResponse(t *testing.T) {
 }
 
 // MockDeleteMetadatumResponse creates a mock unset metadata response
-func MockDeleteMetadatumResponse(t *testing.T, key string) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata/"+key, func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteMetadatumResponse(t *testing.T, fakeServer th.FakeServer, key string) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/metadata/"+key, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 	})
 }
@@ -556,10 +556,10 @@ var revertRequest = `{
 	}`
 
 // MockRevertResponse creates a mock revert share response
-func MockRevertResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockRevertResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, revertRequest)
@@ -575,10 +575,10 @@ var resetStatusRequest = `{
 	}`
 
 // MockResetStatusResponse creates a mock reset status share response
-func MockResetStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockResetStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, resetStatusRequest)
@@ -592,10 +592,10 @@ var forceDeleteRequest = `{
         }`
 
 // MockForceDeleteResponse creates a mock force delete share response
-func MockForceDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockForceDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, forceDeleteRequest)
@@ -609,10 +609,10 @@ var unmanageRequest = `{
         }`
 
 // MockUnmanageResponse creates a mock unmanage share response
-func MockUnmanageResponse(t *testing.T) {
-	th.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockUnmanageResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(shareEndpoint+"/"+shareID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, unmanageRequest)
diff --git a/openstack/sharedfilesystems/v2/shares/testing/request_test.go b/openstack/sharedfilesystems/v2/shares/testing/request_test.go
index 396c73a79..809a39316 100644
--- a/openstack/sharedfilesystems/v2/shares/testing/request_test.go
+++ b/openstack/sharedfilesystems/v2/shares/testing/request_test.go
@@ -11,10 +11,10 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &shares.CreateOpts{
 		Size:       1,
@@ -25,7 +25,7 @@ func TestCreate(t *testing.T) {
 			DifferentHost: "e268f4aa-d571-43dd-9ab3-f49ad06ffaef",
 		},
 	}
-	n, err := shares.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := shares.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, n.Name, "my_test_share")
@@ -36,10 +36,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateResponse(t)
+	MockUpdateResponse(t, fakeServer)
 
 	name := "my_new_test_share"
 	description := ""
@@ -49,7 +49,7 @@ func TestUpdate(t *testing.T) {
 		DisplayDescription: &description,
 		IsPublic:           &iFalse,
 	}
-	n, err := shares.Update(context.TODO(), client.ServiceClient(), shareID, options).Extract()
+	n, err := shares.Update(context.TODO(), client.ServiceClient(fakeServer), shareID, options).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, n.Name, "my_new_test_share")
@@ -58,22 +58,22 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	result := shares.Delete(context.TODO(), client.ServiceClient(), shareID)
+	result := shares.Delete(context.TODO(), client.ServiceClient(fakeServer), shareID)
 	th.AssertNoErr(t, result.Err)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	s, err := shares.Get(context.TODO(), client.ServiceClient(), shareID).Extract()
+	s, err := shares.Get(context.TODO(), client.ServiceClient(fakeServer), shareID).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, s, &shares.Share{
 		AvailabilityZone:   "nova",
@@ -118,12 +118,12 @@ func TestGet(t *testing.T) {
 }
 
 func TestListDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListDetailResponse(t)
+	MockListDetailResponse(t, fakeServer)
 
-	allPages, err := shares.ListDetail(client.ServiceClient(), &shares.ListOpts{}).AllPages(context.TODO())
+	allPages, err := shares.ListDetail(client.ServiceClient(fakeServer), &shares.ListOpts{}).AllPages(context.TODO())
 
 	th.AssertNoErr(t, err)
 
@@ -175,12 +175,12 @@ func TestListDetail(t *testing.T) {
 }
 
 func TestListExportLocationsSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListExportLocationsResponse(t)
+	MockListExportLocationsResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for List Export Locations is 2.9
 	c.Microversion = "2.9"
 
@@ -199,12 +199,12 @@ func TestListExportLocationsSuccess(t *testing.T) {
 }
 
 func TestGetExportLocationSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetExportLocationResponse(t)
+	MockGetExportLocationResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for Get Export Location is 2.9
 	c.Microversion = "2.9"
 
@@ -221,12 +221,12 @@ func TestGetExportLocationSuccess(t *testing.T) {
 }
 
 func TestGrantAcessSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGrantAccessResponse(t)
+	MockGrantAccessResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for Grant Access is 2.7
 	c.Microversion = "2.7"
 
@@ -250,12 +250,12 @@ func TestGrantAcessSuccess(t *testing.T) {
 }
 
 func TestRevokeAccessSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockRevokeAccessResponse(t)
+	MockRevokeAccessResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for Revoke Access is 2.7
 	c.Microversion = "2.7"
 
@@ -266,12 +266,12 @@ func TestRevokeAccessSuccess(t *testing.T) {
 }
 
 func TestListAccessRightsSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListAccessRightsResponse(t)
+	MockListAccessRightsResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for Grant Access is 2.7
 	c.Microversion = "2.7"
 
@@ -292,12 +292,12 @@ func TestListAccessRightsSuccess(t *testing.T) {
 }
 
 func TestExtendSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockExtendResponse(t)
+	MockExtendResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for Grant Access is 2.7
 	c.Microversion = "2.7"
 
@@ -306,12 +306,12 @@ func TestExtendSuccess(t *testing.T) {
 }
 
 func TestShrinkSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockShrinkResponse(t)
+	MockShrinkResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for Grant Access is 2.7
 	c.Microversion = "2.7"
 
@@ -320,12 +320,12 @@ func TestShrinkSuccess(t *testing.T) {
 }
 
 func TestGetMetadataSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetMetadataResponse(t)
+	MockGetMetadataResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 
 	actual, err := shares.GetMetadata(context.TODO(), c, shareID).Extract()
 	th.AssertNoErr(t, err)
@@ -333,12 +333,12 @@ func TestGetMetadataSuccess(t *testing.T) {
 }
 
 func TestGetMetadatumSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetMetadatumResponse(t, "foo")
+	MockGetMetadatumResponse(t, fakeServer, "foo")
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 
 	actual, err := shares.GetMetadatum(context.TODO(), c, shareID, "foo").Extract()
 	th.AssertNoErr(t, err)
@@ -346,12 +346,12 @@ func TestGetMetadatumSuccess(t *testing.T) {
 }
 
 func TestSetMetadataSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockSetMetadataResponse(t)
+	MockSetMetadataResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 
 	actual, err := shares.SetMetadata(context.TODO(), c, shareID, &shares.SetMetadataOpts{Metadata: map[string]string{"foo": "bar"}}).Extract()
 	th.AssertNoErr(t, err)
@@ -359,12 +359,12 @@ func TestSetMetadataSuccess(t *testing.T) {
 }
 
 func TestUpdateMetadataSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateMetadataResponse(t)
+	MockUpdateMetadataResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 
 	actual, err := shares.UpdateMetadata(context.TODO(), c, shareID, &shares.UpdateMetadataOpts{Metadata: map[string]string{"foo": "bar"}}).Extract()
 	th.AssertNoErr(t, err)
@@ -372,24 +372,24 @@ func TestUpdateMetadataSuccess(t *testing.T) {
 }
 
 func TestUnsetMetadataSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteMetadatumResponse(t, "foo")
+	MockDeleteMetadatumResponse(t, fakeServer, "foo")
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 
 	err := shares.DeleteMetadatum(context.TODO(), c, shareID, "foo").ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestRevertSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockRevertResponse(t)
+	MockRevertResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for Revert is 2.27
 	c.Microversion = "2.27"
 
@@ -398,12 +398,12 @@ func TestRevertSuccess(t *testing.T) {
 }
 
 func TestResetStatusSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStatusResponse(t)
+	MockResetStatusResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for ResetStatus is 2.7
 	c.Microversion = "2.7"
 
@@ -412,12 +412,12 @@ func TestResetStatusSuccess(t *testing.T) {
 }
 
 func TestForceDeleteSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockForceDeleteResponse(t)
+	MockForceDeleteResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for ForceDelete is 2.7
 	c.Microversion = "2.7"
 
@@ -426,12 +426,12 @@ func TestForceDeleteSuccess(t *testing.T) {
 }
 
 func TestUnmanageSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUnmanageResponse(t)
+	MockUnmanageResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 	// Client c must have Microversion set; minimum supported microversion for Unmanage is 2.7
 	c.Microversion = "2.7"
 
diff --git a/openstack/sharedfilesystems/v2/sharetransfers/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/sharetransfers/testing/fixtures_test.go
index 342c4c510..3175e10ef 100644
--- a/openstack/sharedfilesystems/v2/sharetransfers/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/sharetransfers/testing/fixtures_test.go
@@ -139,8 +139,8 @@ var AcceptResponse = sharetransfers.Transfer{
 	},
 }
 
-func HandleCreateTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/share-transfers", func(w http.ResponseWriter, r *http.Request) {
+func HandleCreateTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-transfers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -151,8 +151,8 @@ func HandleCreateTransfer(t *testing.T) {
 	})
 }
 
-func HandleAcceptTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/share-transfers/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f/accept", func(w http.ResponseWriter, r *http.Request) {
+func HandleAcceptTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-transfers/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f/accept", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -162,8 +162,8 @@ func HandleAcceptTransfer(t *testing.T) {
 	})
 }
 
-func HandleDeleteTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/share-transfers/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
+func HandleDeleteTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-transfers/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
@@ -171,8 +171,8 @@ func HandleDeleteTransfer(t *testing.T) {
 	})
 }
 
-func HandleListTransfers(t *testing.T) {
-	th.Mux.HandleFunc("/share-transfers", func(w http.ResponseWriter, r *http.Request) {
+func HandleListTransfers(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-transfers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -183,8 +183,8 @@ func HandleListTransfers(t *testing.T) {
 	})
 }
 
-func HandleListTransfersDetail(t *testing.T) {
-	th.Mux.HandleFunc("/share-transfers/detail", func(w http.ResponseWriter, r *http.Request) {
+func HandleListTransfersDetail(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-transfers/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
@@ -195,8 +195,8 @@ func HandleListTransfersDetail(t *testing.T) {
 	})
 }
 
-func HandleGetTransfer(t *testing.T) {
-	th.Mux.HandleFunc("/share-transfers/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
+func HandleGetTransfer(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/share-transfers/b8913bfd-a4d3-4ec5-bd8b-fe2dbeef9f4f", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
diff --git a/openstack/sharedfilesystems/v2/sharetransfers/testing/requests_test.go b/openstack/sharedfilesystems/v2/sharetransfers/testing/requests_test.go
index a0a2fefcf..06a81ed9f 100644
--- a/openstack/sharedfilesystems/v2/sharetransfers/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/sharetransfers/testing/requests_test.go
@@ -11,43 +11,43 @@ import (
 )
 
 func TestCreateTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleCreateTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleCreateTransfer(t, fakeServer)
 
-	actual, err := sharetransfers.Create(context.TODO(), client.ServiceClient(), TransferRequest).Extract()
+	actual, err := sharetransfers.Create(context.TODO(), client.ServiceClient(fakeServer), TransferRequest).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, TransferResponse, *actual)
 }
 
 func TestAcceptTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleAcceptTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleAcceptTransfer(t, fakeServer)
 
-	err := sharetransfers.Accept(context.TODO(), client.ServiceClient(), TransferResponse.ID, AcceptRequest).ExtractErr()
+	err := sharetransfers.Accept(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID, AcceptRequest).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestDeleteTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleDeleteTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleDeleteTransfer(t, fakeServer)
 
-	err := sharetransfers.Delete(context.TODO(), client.ServiceClient(), TransferResponse.ID).ExtractErr()
+	err := sharetransfers.Delete(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestListTransfers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTransfers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTransfers(t, fakeServer)
 
 	expectedResponse := TransferListResponse
 	expectedResponse[0].AuthKey = ""
 
 	count := 0
-	err := sharetransfers.List(client.ServiceClient(), &sharetransfers.ListOpts{AllTenants: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := sharetransfers.List(client.ServiceClient(fakeServer), &sharetransfers.ListOpts{AllTenants: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := sharetransfers.ExtractTransfers(page)
@@ -62,15 +62,15 @@ func TestListTransfers(t *testing.T) {
 }
 
 func TestListTransfersDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTransfersDetail(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTransfersDetail(t, fakeServer)
 
 	expectedResponse := TransferListResponse
 	expectedResponse[0].AuthKey = ""
 
 	count := 0
-	err := sharetransfers.ListDetail(client.ServiceClient(), &sharetransfers.ListOpts{AllTenants: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := sharetransfers.ListDetail(client.ServiceClient(fakeServer), &sharetransfers.ListOpts{AllTenants: true}).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		count++
 
 		actual, err := sharetransfers.ExtractTransfers(page)
@@ -85,14 +85,14 @@ func TestListTransfersDetail(t *testing.T) {
 }
 
 func TestListTransfersAllPages(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleListTransfers(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleListTransfers(t, fakeServer)
 
 	expectedResponse := TransferListResponse
 	expectedResponse[0].AuthKey = ""
 
-	allPages, err := sharetransfers.List(client.ServiceClient(), &sharetransfers.ListOpts{AllTenants: true}).AllPages(context.TODO())
+	allPages, err := sharetransfers.List(client.ServiceClient(fakeServer), &sharetransfers.ListOpts{AllTenants: true}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := sharetransfers.ExtractTransfers(allPages)
 	th.AssertNoErr(t, err)
@@ -100,14 +100,14 @@ func TestListTransfersAllPages(t *testing.T) {
 }
 
 func TestGetTransfer(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	HandleGetTransfer(t)
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	HandleGetTransfer(t, fakeServer)
 
 	expectedResponse := TransferResponse
 	expectedResponse.AuthKey = ""
 
-	actual, err := sharetransfers.Get(context.TODO(), client.ServiceClient(), TransferResponse.ID).Extract()
+	actual, err := sharetransfers.Get(context.TODO(), client.ServiceClient(fakeServer), TransferResponse.ID).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, expectedResponse, *actual)
 }
diff --git a/openstack/sharedfilesystems/v2/sharetypes/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/sharetypes/testing/fixtures_test.go
index 17fb21fa7..6acf017b8 100644
--- a/openstack/sharedfilesystems/v2/sharetypes/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/sharetypes/testing/fixtures_test.go
@@ -6,13 +6,13 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types", func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -60,18 +60,18 @@ func MockCreateResponse(t *testing.T) {
 	})
 }
 
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/shareTypeID", func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/shareTypeID", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockListResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types", func(w http.ResponseWriter, r *http.Request) {
+func MockListResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -134,10 +134,10 @@ func MockListResponse(t *testing.T) {
 	})
 }
 
-func MockGetDefaultResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/default", func(w http.ResponseWriter, r *http.Request) {
+func MockGetDefaultResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/default", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -165,10 +165,10 @@ func MockGetDefaultResponse(t *testing.T) {
 	})
 }
 
-func MockGetExtraSpecsResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/shareTypeID/extra_specs", func(w http.ResponseWriter, r *http.Request) {
+func MockGetExtraSpecsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/shareTypeID/extra_specs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -183,10 +183,10 @@ func MockGetExtraSpecsResponse(t *testing.T) {
 	})
 }
 
-func MockSetExtraSpecsResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/shareTypeID/extra_specs", func(w http.ResponseWriter, r *http.Request) {
+func MockSetExtraSpecsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/shareTypeID/extra_specs", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -208,18 +208,18 @@ func MockSetExtraSpecsResponse(t *testing.T) {
 	})
 }
 
-func MockUnsetExtraSpecsResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/shareTypeID/extra_specs/my_key", func(w http.ResponseWriter, r *http.Request) {
+func MockUnsetExtraSpecsResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/shareTypeID/extra_specs/my_key", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
 
-func MockShowAccessResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/shareTypeID/share_type_access", func(w http.ResponseWriter, r *http.Request) {
+func MockShowAccessResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/shareTypeID/share_type_access", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -239,10 +239,10 @@ func MockShowAccessResponse(t *testing.T) {
 	})
 }
 
-func MockAddAccessResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/shareTypeID/action", func(w http.ResponseWriter, r *http.Request) {
+func MockAddAccessResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/shareTypeID/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
@@ -255,10 +255,10 @@ func MockAddAccessResponse(t *testing.T) {
 	})
 }
 
-func MockRemoveAccessResponse(t *testing.T) {
-	th.Mux.HandleFunc("/types/shareTypeID/action", func(w http.ResponseWriter, r *http.Request) {
+func MockRemoveAccessResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/types/shareTypeID/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, `
diff --git a/openstack/sharedfilesystems/v2/sharetypes/testing/requests_test.go b/openstack/sharedfilesystems/v2/sharetypes/testing/requests_test.go
index a88145561..7e1af98ca 100644
--- a/openstack/sharedfilesystems/v2/sharetypes/testing/requests_test.go
+++ b/openstack/sharedfilesystems/v2/sharetypes/testing/requests_test.go
@@ -12,10 +12,10 @@ import (
 
 // Verifies that a share type can be created correctly
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	snapshotSupport := true
 	extraSpecs := sharetypes.ExtraSpecsOpts{
@@ -29,7 +29,7 @@ func TestCreate(t *testing.T) {
 		ExtraSpecs: extraSpecs,
 	}
 
-	st, err := sharetypes.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	st, err := sharetypes.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, st.Name, "my_new_share_type")
@@ -37,12 +37,15 @@ func TestCreate(t *testing.T) {
 }
 
 // Verifies that a share type can't be created if the required parameters are missing
-func TestCreateFails(t *testing.T) {
+func TestRequiredCreateOpts(t *testing.T) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
 	options := &sharetypes.CreateOpts{
 		Name: "my_new_share_type",
 	}
 
-	_, err := sharetypes.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	_, err := sharetypes.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	if _, ok := err.(gophercloud.ErrMissingInput); !ok {
 		t.Fatal("ErrMissingInput was expected to occur")
 	}
@@ -55,7 +58,7 @@ func TestCreateFails(t *testing.T) {
 		ExtraSpecs: extraSpecs,
 	}
 
-	_, err = sharetypes.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	_, err = sharetypes.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 	if _, ok := err.(gophercloud.ErrMissingInput); !ok {
 		t.Fatal("ErrMissingInput was expected to occur")
 	}
@@ -63,22 +66,22 @@ func TestCreateFails(t *testing.T) {
 
 // Verifies that share type deletion works
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
-	res := sharetypes.Delete(context.TODO(), client.ServiceClient(), "shareTypeID")
+	MockDeleteResponse(t, fakeServer)
+	res := sharetypes.Delete(context.TODO(), client.ServiceClient(fakeServer), "shareTypeID")
 	th.AssertNoErr(t, res.Err)
 }
 
 // Verifies that share types can be listed correctly
 func TestList(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListResponse(t)
+	MockListResponse(t, fakeServer)
 
-	allPages, err := sharetypes.List(client.ServiceClient(), &sharetypes.ListOpts{}).AllPages(context.TODO())
+	allPages, err := sharetypes.List(client.ServiceClient(fakeServer), &sharetypes.ListOpts{}).AllPages(context.TODO())
 	th.AssertNoErr(t, err)
 	actual, err := sharetypes.ExtractShareTypes(allPages)
 	th.AssertNoErr(t, err)
@@ -104,10 +107,10 @@ func TestList(t *testing.T) {
 
 // Verifies that it is possible to get the default share type
 func TestGetDefault(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetDefaultResponse(t)
+	MockGetDefaultResponse(t, fakeServer)
 
 	expected := sharetypes.ShareType{
 		ID:                 "be27425c-f807-4500-a056-d00721db45cf",
@@ -116,19 +119,19 @@ func TestGetDefault(t *testing.T) {
 		RequiredExtraSpecs: map[string]any(nil),
 	}
 
-	actual, err := sharetypes.GetDefault(context.TODO(), client.ServiceClient()).Extract()
+	actual, err := sharetypes.GetDefault(context.TODO(), client.ServiceClient(fakeServer)).Extract()
 	th.AssertNoErr(t, err)
 	th.CheckDeepEquals(t, &expected, actual)
 }
 
 // Verifies that it is possible to get the extra specifications for a share type
 func TestGetExtraSpecs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetExtraSpecsResponse(t)
+	MockGetExtraSpecsResponse(t, fakeServer)
 
-	st, err := sharetypes.GetExtraSpecs(context.TODO(), client.ServiceClient(), "shareTypeID").Extract()
+	st, err := sharetypes.GetExtraSpecs(context.TODO(), client.ServiceClient(fakeServer), "shareTypeID").Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, st["snapshot_support"], "True")
@@ -138,16 +141,16 @@ func TestGetExtraSpecs(t *testing.T) {
 
 // Verifies that an extra specs can be added to a share type
 func TestSetExtraSpecs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockSetExtraSpecsResponse(t)
+	MockSetExtraSpecsResponse(t, fakeServer)
 
 	options := &sharetypes.SetExtraSpecsOpts{
 		ExtraSpecs: map[string]any{"my_key": "my_value"},
 	}
 
-	es, err := sharetypes.SetExtraSpecs(context.TODO(), client.ServiceClient(), "shareTypeID", options).Extract()
+	es, err := sharetypes.SetExtraSpecs(context.TODO(), client.ServiceClient(fakeServer), "shareTypeID", options).Extract()
 	th.AssertNoErr(t, err)
 
 	th.AssertEquals(t, es["my_key"], "my_value")
@@ -155,20 +158,20 @@ func TestSetExtraSpecs(t *testing.T) {
 
 // Verifies that an extra specification can be unset for a share type
 func TestUnsetExtraSpecs(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUnsetExtraSpecsResponse(t)
-	res := sharetypes.UnsetExtraSpecs(context.TODO(), client.ServiceClient(), "shareTypeID", "my_key")
+	MockUnsetExtraSpecsResponse(t, fakeServer)
+	res := sharetypes.UnsetExtraSpecs(context.TODO(), client.ServiceClient(fakeServer), "shareTypeID", "my_key")
 	th.AssertNoErr(t, res.Err)
 }
 
 // Verifies that it is possible to see the access for a share type
 func TestShowAccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockShowAccessResponse(t)
+	MockShowAccessResponse(t, fakeServer)
 
 	expected := []sharetypes.ShareTypeAccess{
 		{
@@ -181,7 +184,7 @@ func TestShowAccess(t *testing.T) {
 		},
 	}
 
-	shareType, err := sharetypes.ShowAccess(context.TODO(), client.ServiceClient(), "shareTypeID").Extract()
+	shareType, err := sharetypes.ShowAccess(context.TODO(), client.ServiceClient(fakeServer), "shareTypeID").Extract()
 	th.AssertNoErr(t, err)
 
 	th.CheckDeepEquals(t, expected, shareType)
@@ -189,30 +192,30 @@ func TestShowAccess(t *testing.T) {
 
 // Verifies that an access can be added to a share type
 func TestAddAccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockAddAccessResponse(t)
+	MockAddAccessResponse(t, fakeServer)
 
 	options := &sharetypes.AccessOpts{
 		Project: "e1284adea3ee4d2482af5ed214f3ad90",
 	}
 
-	err := sharetypes.AddAccess(context.TODO(), client.ServiceClient(), "shareTypeID", options).ExtractErr()
+	err := sharetypes.AddAccess(context.TODO(), client.ServiceClient(fakeServer), "shareTypeID", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 // Verifies that an access can be removed from a share type
 func TestRemoveAccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockRemoveAccessResponse(t)
+	MockRemoveAccessResponse(t, fakeServer)
 
 	options := &sharetypes.AccessOpts{
 		Project: "e1284adea3ee4d2482af5ed214f3ad90",
 	}
 
-	err := sharetypes.RemoveAccess(context.TODO(), client.ServiceClient(), "shareTypeID", options).ExtractErr()
+	err := sharetypes.RemoveAccess(context.TODO(), client.ServiceClient(fakeServer), "shareTypeID", options).ExtractErr()
 	th.AssertNoErr(t, err)
 }
diff --git a/openstack/sharedfilesystems/v2/snapshots/testing/fixtures_test.go b/openstack/sharedfilesystems/v2/snapshots/testing/fixtures_test.go
index 88e94c371..dc18cf7c9 100644
--- a/openstack/sharedfilesystems/v2/snapshots/testing/fixtures_test.go
+++ b/openstack/sharedfilesystems/v2/snapshots/testing/fixtures_test.go
@@ -6,7 +6,7 @@ import (
 	"testing"
 
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 const (
@@ -50,10 +50,10 @@ var createResponse = `{
 }`
 
 // MockCreateResponse creates a mock response
-func MockCreateResponse(t *testing.T) {
-	th.Mux.HandleFunc(snapshotEndpoint, func(w http.ResponseWriter, r *http.Request) {
+func MockCreateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(snapshotEndpoint, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, createRequest)
@@ -64,10 +64,10 @@ func MockCreateResponse(t *testing.T) {
 }
 
 // MockDeleteResponse creates a mock delete response
-func MockDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID, func(w http.ResponseWriter, r *http.Request) {
+func MockDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
 }
@@ -105,10 +105,10 @@ var updateResponse = `{
 	}
 }`
 
-func MockUpdateResponse(t *testing.T) {
-	th.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID, func(w http.ResponseWriter, r *http.Request) {
+func MockUpdateResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "PUT")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, updateRequest)
@@ -145,10 +145,10 @@ var getResponse = `{
 }`
 
 // MockGetResponse creates a mock get response
-func MockGetResponse(t *testing.T) {
-	th.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID, func(w http.ResponseWriter, r *http.Request) {
+func MockGetResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusOK)
 		fmt.Fprint(w, getResponse)
 	})
@@ -185,10 +185,10 @@ var listDetailResponse = `{
 var listDetailEmptyResponse = `{"snapshots": []}`
 
 // MockListDetailResponse creates a mock detailed-list response
-func MockListDetailResponse(t *testing.T) {
-	th.Mux.HandleFunc(snapshotEndpoint+"/detail", func(w http.ResponseWriter, r *http.Request) {
+func MockListDetailResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(snapshotEndpoint+"/detail", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		w.WriteHeader(http.StatusOK)
@@ -214,10 +214,10 @@ var resetStatusRequest = `{
         }`
 
 // MockResetStatusResponse creates a mock reset status snapshot response
-func MockResetStatusResponse(t *testing.T) {
-	th.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockResetStatusResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, resetStatusRequest)
@@ -231,10 +231,10 @@ var forceDeleteRequest = `{
         }`
 
 // MockForceDeleteResponse creates a mock force delete snapshot response
-func MockForceDeleteResponse(t *testing.T) {
-	th.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID+"/action", func(w http.ResponseWriter, r *http.Request) {
+func MockForceDeleteResponse(t *testing.T, fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc(snapshotEndpoint+"/"+snapshotID+"/action", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "application/json")
 		th.TestHeader(t, r, "Accept", "application/json")
 		th.TestJSONRequest(t, r, forceDeleteRequest)
diff --git a/openstack/sharedfilesystems/v2/snapshots/testing/request_test.go b/openstack/sharedfilesystems/v2/snapshots/testing/request_test.go
index 759ad0d78..29330e177 100644
--- a/openstack/sharedfilesystems/v2/snapshots/testing/request_test.go
+++ b/openstack/sharedfilesystems/v2/snapshots/testing/request_test.go
@@ -11,13 +11,13 @@ import (
 )
 
 func TestCreate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockCreateResponse(t)
+	MockCreateResponse(t, fakeServer)
 
 	options := &snapshots.CreateOpts{ShareID: shareID, Name: "test snapshot", Description: "test description"}
-	n, err := snapshots.Create(context.TODO(), client.ServiceClient(), options).Extract()
+	n, err := snapshots.Create(context.TODO(), client.ServiceClient(fakeServer), options).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, n.Name, "test snapshot")
@@ -28,10 +28,10 @@ func TestCreate(t *testing.T) {
 }
 
 func TestUpdate(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockUpdateResponse(t)
+	MockUpdateResponse(t, fakeServer)
 
 	name := "my_new_test_snapshot"
 	description := ""
@@ -39,7 +39,7 @@ func TestUpdate(t *testing.T) {
 		DisplayName:        &name,
 		DisplayDescription: &description,
 	}
-	n, err := snapshots.Update(context.TODO(), client.ServiceClient(), snapshotID, options).Extract()
+	n, err := snapshots.Update(context.TODO(), client.ServiceClient(fakeServer), snapshotID, options).Extract()
 
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, n.Name, "my_new_test_snapshot")
@@ -47,22 +47,22 @@ func TestUpdate(t *testing.T) {
 }
 
 func TestDelete(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockDeleteResponse(t)
+	MockDeleteResponse(t, fakeServer)
 
-	result := snapshots.Delete(context.TODO(), client.ServiceClient(), snapshotID)
+	result := snapshots.Delete(context.TODO(), client.ServiceClient(fakeServer), snapshotID)
 	th.AssertNoErr(t, result.Err)
 }
 
 func TestGet(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockGetResponse(t)
+	MockGetResponse(t, fakeServer)
 
-	s, err := snapshots.Get(context.TODO(), client.ServiceClient(), snapshotID).Extract()
+	s, err := snapshots.Get(context.TODO(), client.ServiceClient(fakeServer), snapshotID).Extract()
 	th.AssertNoErr(t, err)
 	th.AssertDeepEquals(t, s, &snapshots.Snapshot{
 		ID:          snapshotID,
@@ -89,12 +89,12 @@ func TestGet(t *testing.T) {
 }
 
 func TestListDetail(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockListDetailResponse(t)
+	MockListDetailResponse(t, fakeServer)
 
-	allPages, err := snapshots.ListDetail(client.ServiceClient(), &snapshots.ListOpts{}).AllPages(context.TODO())
+	allPages, err := snapshots.ListDetail(client.ServiceClient(fakeServer), &snapshots.ListOpts{}).AllPages(context.TODO())
 
 	th.AssertNoErr(t, err)
 
@@ -128,24 +128,24 @@ func TestListDetail(t *testing.T) {
 }
 
 func TestResetStatusSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockResetStatusResponse(t)
+	MockResetStatusResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 
 	err := snapshots.ResetStatus(context.TODO(), c, snapshotID, &snapshots.ResetStatusOpts{Status: "error"}).ExtractErr()
 	th.AssertNoErr(t, err)
 }
 
 func TestForceDeleteSuccess(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	MockForceDeleteResponse(t)
+	MockForceDeleteResponse(t, fakeServer)
 
-	c := client.ServiceClient()
+	c := client.ServiceClient(fakeServer)
 
 	err := snapshots.ForceDelete(context.TODO(), c, snapshotID).ExtractErr()
 	th.AssertNoErr(t, err)
diff --git a/openstack/testing/client_test.go b/openstack/testing/client_test.go
index 75192a524..214c68ccd 100644
--- a/openstack/testing/client_test.go
+++ b/openstack/testing/client_test.go
@@ -14,10 +14,10 @@ import (
 const ID = "0123456789"
 
 func TestAuthenticatedClientV3(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, `
 			{
 				"versions": {
@@ -39,10 +39,10 @@ func TestAuthenticatedClientV3(t *testing.T) {
 					]
 				}
 			}
-		`, th.Endpoint()+"v3/", th.Endpoint()+"v2.0/")
+		`, fakeServer.Endpoint()+"v3/", fakeServer.Endpoint()+"v2.0/")
 	})
 
-	th.Mux.HandleFunc("/v3/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v3/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("X-Subject-Token", ID)
 
 		w.WriteHeader(http.StatusCreated)
@@ -54,7 +54,7 @@ func TestAuthenticatedClientV3(t *testing.T) {
 		Password:         "secret",
 		DomainName:       "default",
 		TenantName:       "project",
-		IdentityEndpoint: th.Endpoint(),
+		IdentityEndpoint: fakeServer.Endpoint(),
 	}
 	client, err := openstack.AuthenticatedClient(context.TODO(), options)
 	th.AssertNoErr(t, err)
@@ -62,10 +62,10 @@ func TestAuthenticatedClientV3(t *testing.T) {
 }
 
 func TestAuthenticatedClientV2(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, `
 			{
 				"versions": {
@@ -87,10 +87,10 @@ func TestAuthenticatedClientV2(t *testing.T) {
 					]
 				}
 			}
-		`, th.Endpoint()+"v3/", th.Endpoint()+"v2.0/")
+		`, fakeServer.Endpoint()+"v3/", fakeServer.Endpoint()+"v2.0/")
 	})
 
-	th.Mux.HandleFunc("/v2.0/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v2.0/tokens", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprint(w, `
 			{
 				"access": {
@@ -157,7 +157,7 @@ func TestAuthenticatedClientV2(t *testing.T) {
 	options := gophercloud.AuthOptions{
 		Username:         "me",
 		Password:         "secret",
-		IdentityEndpoint: th.Endpoint(),
+		IdentityEndpoint: fakeServer.Endpoint(),
 	}
 	client, err := openstack.AuthenticatedClient(context.TODO(), options)
 	th.AssertNoErr(t, err)
@@ -165,10 +165,10 @@ func TestAuthenticatedClientV2(t *testing.T) {
 }
 
 func TestIdentityAdminV3Client(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, `
 			{
 				"versions": {
@@ -190,10 +190,10 @@ func TestIdentityAdminV3Client(t *testing.T) {
 					]
 				}
 			}
-		`, th.Endpoint()+"v3/", th.Endpoint()+"v2.0/")
+		`, fakeServer.Endpoint()+"v3/", fakeServer.Endpoint()+"v2.0/")
 	})
 
-	th.Mux.HandleFunc("/v3/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/v3/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("X-Subject-Token", ID)
 
 		w.WriteHeader(http.StatusCreated)
@@ -282,7 +282,7 @@ func TestIdentityAdminV3Client(t *testing.T) {
 		Username:         "me",
 		Password:         "secret",
 		DomainID:         "12345",
-		IdentityEndpoint: th.Endpoint(),
+		IdentityEndpoint: fakeServer.Endpoint(),
 	}
 	pc, err := openstack.AuthenticatedClient(context.TODO(), options)
 	th.AssertNoErr(t, err)
diff --git a/openstack/utils/testing/choose_version_test.go b/openstack/utils/testing/choose_version_test.go
index c237e4e03..e1a813ea1 100644
--- a/openstack/utils/testing/choose_version_test.go
+++ b/openstack/utils/testing/choose_version_test.go
@@ -12,8 +12,8 @@ import (
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
 )
 
-func setupVersionHandler() {
-	th.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+func setupVersionHandler(fakeServer th.FakeServer) {
+	fakeServer.Mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, `
 			{
 				"versions": {
@@ -35,10 +35,10 @@ func setupVersionHandler() {
 					]
 				}
 			}
-		`, th.Server.URL, th.Server.URL)
+		`, fakeServer.Server.URL, fakeServer.Server.URL)
 	})
 	// Compute v2.1 API
-	th.Mux.HandleFunc("/compute/v2.1/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/compute/v2.1/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, `
 			{
 				"version": {
@@ -66,10 +66,10 @@ func setupVersionHandler() {
 					]
 				}
 			}
-		`, th.Server.URL)
+		`, fakeServer.Server.URL)
 	})
 	// Compute v2 API
-	th.Mux.HandleFunc("/compute/v2/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/compute/v2/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, `
 			{
 				"version": {
@@ -97,10 +97,10 @@ func setupVersionHandler() {
 					]
 				}
 			}
-		`, th.Server.URL)
+		`, fakeServer.Server.URL)
 	})
 	// Ironic API
-	th.Mux.HandleFunc("/ironic/v1/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/ironic/v1/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, `
 		{
 			"name": "OpenStack Ironic API",
@@ -132,10 +132,10 @@ func setupVersionHandler() {
 				}
 			]
 		}
-		`, th.Server.URL, th.Server.URL)
+		`, fakeServer.Server.URL, fakeServer.Server.URL)
 	})
 	// Ironic multi-version
-	th.Mux.HandleFunc("/ironic/v1.2/", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/ironic/v1.2/", func(w http.ResponseWriter, r *http.Request) {
 		fmt.Fprintf(w, `
 		{
 			"name": "OpenStack Ironic API",
@@ -179,20 +179,20 @@ func setupVersionHandler() {
 				}
 			]
 		}
-		`, th.Server.URL, th.Server.URL, th.Server.URL)
+		`, fakeServer.Server.URL, fakeServer.Server.URL, fakeServer.Server.URL)
 	})
 }
 
 func TestChooseVersion(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	setupVersionHandler()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	setupVersionHandler(fakeServer)
 
 	v2 := &utils.Version{ID: "v2.0", Priority: 2, Suffix: "blarg"}
 	v3 := &utils.Version{ID: "v3.0", Priority: 3, Suffix: "hargl"}
 
 	c := &gophercloud.ProviderClient{
-		IdentityBase:     th.Endpoint(),
+		IdentityBase:     fakeServer.Endpoint(),
 		IdentityEndpoint: "",
 	}
 	v, endpoint, err := utils.ChooseVersion(context.TODO(), c, []*utils.Version{v2, v3})
@@ -205,23 +205,23 @@ func TestChooseVersion(t *testing.T) {
 		t.Errorf("Expected %#v to win, but %#v did instead", v3, v)
 	}
 
-	expected := th.Endpoint() + "v3.0/"
+	expected := fakeServer.Endpoint() + "v3.0/"
 	if endpoint != expected {
 		t.Errorf("Expected endpoint [%s], but was [%s] instead", expected, endpoint)
 	}
 }
 
 func TestChooseVersionOpinionatedLink(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	setupVersionHandler()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	setupVersionHandler(fakeServer)
 
 	v2 := &utils.Version{ID: "v2.0", Priority: 2, Suffix: "nope"}
 	v3 := &utils.Version{ID: "v3.0", Priority: 3, Suffix: "northis"}
 
 	c := &gophercloud.ProviderClient{
-		IdentityBase:     th.Endpoint(),
-		IdentityEndpoint: th.Endpoint() + "v2.0/",
+		IdentityBase:     fakeServer.Endpoint(),
+		IdentityEndpoint: fakeServer.Endpoint() + "v2.0/",
 	}
 	v, endpoint, err := utils.ChooseVersion(context.TODO(), c, []*utils.Version{v2, v3})
 	if err != nil {
@@ -232,22 +232,22 @@ func TestChooseVersionOpinionatedLink(t *testing.T) {
 		t.Errorf("Expected %#v to win, but %#v did instead", v2, v)
 	}
 
-	expected := th.Endpoint() + "v2.0/"
+	expected := fakeServer.Endpoint() + "v2.0/"
 	if endpoint != expected {
 		t.Errorf("Expected endpoint [%s], but was [%s] instead", expected, endpoint)
 	}
 }
 
 func TestChooseVersionFromSuffix(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	v2 := &utils.Version{ID: "v2.0", Priority: 2, Suffix: "/v2.0/"}
 	v3 := &utils.Version{ID: "v3.0", Priority: 3, Suffix: "/v3.0/"}
 
 	c := &gophercloud.ProviderClient{
-		IdentityBase:     th.Endpoint(),
-		IdentityEndpoint: th.Endpoint() + "v2.0/",
+		IdentityBase:     fakeServer.Endpoint(),
+		IdentityEndpoint: fakeServer.Endpoint() + "v2.0/",
 	}
 	v, endpoint, err := utils.ChooseVersion(context.TODO(), c, []*utils.Version{v2, v3})
 	if err != nil {
@@ -258,7 +258,7 @@ func TestChooseVersionFromSuffix(t *testing.T) {
 		t.Errorf("Expected %#v to win, but %#v did instead", v2, v)
 	}
 
-	expected := th.Endpoint() + "v2.0/"
+	expected := fakeServer.Endpoint() + "v2.0/"
 	if endpoint != expected {
 		t.Errorf("Expected endpoint [%s], but was [%s] instead", expected, endpoint)
 	}
@@ -272,33 +272,33 @@ type getSupportedServiceMicroversions struct {
 }
 
 func TestGetSupportedVersions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	setupVersionHandler()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	setupVersionHandler(fakeServer)
 
 	tests := []getSupportedServiceMicroversions{
 		{
 			// v2 does not support microversions and returns error
-			Endpoint:    th.Endpoint() + "compute/v2/",
+			Endpoint:    fakeServer.Endpoint() + "compute/v2/",
 			ExpectedMax: "",
 			ExpectedMin: "",
 			ExpectedErr: true,
 		},
 		{
-			Endpoint:    th.Endpoint() + "compute/v2.1/",
+			Endpoint:    fakeServer.Endpoint() + "compute/v2.1/",
 			ExpectedMax: "2.90",
 			ExpectedMin: "2.1",
 			ExpectedErr: false,
 		},
 		{
-			Endpoint:    th.Endpoint() + "ironic/v1/",
+			Endpoint:    fakeServer.Endpoint() + "ironic/v1/",
 			ExpectedMax: "1.87",
 			ExpectedMin: "1.1",
 			ExpectedErr: false,
 		},
 		{
 			// This endpoint returns multiple versions, which is not supported
-			Endpoint:    th.Endpoint() + "ironic/v1.2/",
+			Endpoint:    fakeServer.Endpoint() + "ironic/v1.2/",
 			ExpectedMax: "not-relevant",
 			ExpectedMin: "not-relevant",
 			ExpectedErr: true,
@@ -307,8 +307,8 @@ func TestGetSupportedVersions(t *testing.T) {
 
 	for _, test := range tests {
 		c := &gophercloud.ProviderClient{
-			IdentityBase:     th.Endpoint(),
-			IdentityEndpoint: th.Endpoint() + "v2.0/",
+			IdentityBase:     fakeServer.Endpoint(),
+			IdentityEndpoint: fakeServer.Endpoint() + "v2.0/",
 		}
 
 		client := &gophercloud.ServiceClient{
diff --git a/openstack/workflow/v2/crontriggers/testing/requests_test.go b/openstack/workflow/v2/crontriggers/testing/requests_test.go
index 8267e2bc7..0926f9748 100644
--- a/openstack/workflow/v2/crontriggers/testing/requests_test.go
+++ b/openstack/workflow/v2/crontriggers/testing/requests_test.go
@@ -12,16 +12,16 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/workflow/v2/crontriggers"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreateCronTrigger(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/cron_triggers", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/cron_triggers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusCreated)
 
 		w.Header().Add("Content-Type", "application/json")
@@ -58,7 +58,7 @@ func TestCreateCronTrigger(t *testing.T) {
 		},
 	}
 
-	actual, err := crontriggers.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	actual, err := crontriggers.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	if err != nil {
 		t.Fatalf("Unable to create cron trigger: %v", err)
 	}
@@ -89,26 +89,26 @@ func TestCreateCronTrigger(t *testing.T) {
 }
 
 func TestDeleteCronTrigger(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/cron_triggers/0520ffd8-f7f1-4f2e-845b-55d953a1cf46", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/cron_triggers/0520ffd8-f7f1-4f2e-845b-55d953a1cf46", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusAccepted)
 	})
 
-	res := crontriggers.Delete(context.TODO(), fake.ServiceClient(), "0520ffd8-f7f1-4f2e-845b-55d953a1cf46")
+	res := crontriggers.Delete(context.TODO(), client.ServiceClient(fakeServer), "0520ffd8-f7f1-4f2e-845b-55d953a1cf46")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetCronTrigger(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	th.Mux.HandleFunc("/cron_triggers/0520ffd8-f7f1-4f2e-845b-55d953a1cf46", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fakeServer.Mux.HandleFunc("/cron_triggers/0520ffd8-f7f1-4f2e-845b-55d953a1cf46", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `
 			{
@@ -129,7 +129,7 @@ func TestGetCronTrigger(t *testing.T) {
 			}
 		`)
 	})
-	actual, err := crontriggers.Get(context.TODO(), fake.ServiceClient(), "0520ffd8-f7f1-4f2e-845b-55d953a1cf46").Extract()
+	actual, err := crontriggers.Get(context.TODO(), client.ServiceClient(fakeServer), "0520ffd8-f7f1-4f2e-845b-55d953a1cf46").Extract()
 	if err != nil {
 		t.Fatalf("Unable to get cron trigger: %v", err)
 	}
@@ -161,11 +161,11 @@ func TestGetCronTrigger(t *testing.T) {
 }
 
 func TestListCronTriggers(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	th.Mux.HandleFunc("/cron_triggers", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fakeServer.Mux.HandleFunc("/cron_triggers", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		if err := r.ParseForm(); err != nil {
 			t.Errorf("Failed to parse request form %v", err)
@@ -193,7 +193,7 @@ func TestListCronTriggers(t *testing.T) {
 					}
 				],
 				"next": "%s/cron_triggers?marker=0520ffd8-f7f1-4f2e-845b-55d953a1cf46"
-			}`, th.Server.URL)
+			}`, fakeServer.Server.URL)
 		case "0520ffd8-f7f1-4f2e-845b-55d953a1cf46":
 			fmt.Fprint(w, `{ "cron_triggers": [] }`)
 		default:
@@ -202,7 +202,7 @@ func TestListCronTriggers(t *testing.T) {
 	})
 	pages := 0
 	// Get all cron triggers
-	err := crontriggers.List(fake.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := crontriggers.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 		actual, err := crontriggers.ExtractCronTriggers(page)
 		if err != nil {
diff --git a/openstack/workflow/v2/executions/testing/requests_test.go b/openstack/workflow/v2/executions/testing/requests_test.go
index 86a470045..6ba94a9aa 100644
--- a/openstack/workflow/v2/executions/testing/requests_test.go
+++ b/openstack/workflow/v2/executions/testing/requests_test.go
@@ -12,16 +12,16 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/workflow/v2/executions"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreateExecution(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/executions", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/executions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusCreated)
 
 		w.Header().Add("Content-Type", "application/json")
@@ -54,7 +54,7 @@ func TestCreateExecution(t *testing.T) {
 		Description: "description",
 	}
 
-	actual, err := executions.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	actual, err := executions.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	if err != nil {
 		t.Fatalf("Unable to create execution: %v", err)
 	}
@@ -84,12 +84,12 @@ func TestCreateExecution(t *testing.T) {
 }
 
 func TestGetExecution(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/executions/50bb59f1-eb77-4017-a77f-6d575b002667", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/executions/50bb59f1-eb77-4017-a77f-6d575b002667", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-token", client.TokenID)
 
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `
@@ -113,7 +113,7 @@ func TestGetExecution(t *testing.T) {
 		`)
 	})
 
-	actual, err := executions.Get(context.TODO(), fake.ServiceClient(), "50bb59f1-eb77-4017-a77f-6d575b002667").Extract()
+	actual, err := executions.Get(context.TODO(), client.ServiceClient(fakeServer), "50bb59f1-eb77-4017-a77f-6d575b002667").Extract()
 	if err != nil {
 		t.Fatalf("Unable to get execution: %v", err)
 	}
@@ -143,23 +143,23 @@ func TestGetExecution(t *testing.T) {
 }
 
 func TestDeleteExecution(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	th.Mux.HandleFunc("/executions/1", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fakeServer.Mux.HandleFunc("/executions/1", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.WriteHeader(http.StatusAccepted)
 	})
-	res := executions.Delete(context.TODO(), fake.ServiceClient(), "1")
+	res := executions.Delete(context.TODO(), client.ServiceClient(fakeServer), "1")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestListExecutions(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	th.Mux.HandleFunc("/executions", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fakeServer.Mux.HandleFunc("/executions", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		if err := r.ParseForm(); err != nil {
 			t.Errorf("Failed to parse request form %v", err)
@@ -187,7 +187,7 @@ func TestListExecutions(t *testing.T) {
 					}
 				],
 				"next": "%s/executions?marker=50bb59f1-eb77-4017-a77f-6d575b002667"
-			}`, th.Server.URL)
+			}`, fakeServer.Server.URL)
 		case "50bb59f1-eb77-4017-a77f-6d575b002667":
 			fmt.Fprint(w, `{ "executions": [] }`)
 		default:
@@ -196,7 +196,7 @@ func TestListExecutions(t *testing.T) {
 	})
 	pages := 0
 	// Get all executions
-	err := executions.List(fake.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := executions.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 		actual, err := executions.ExtractExecutions(page)
 		if err != nil {
diff --git a/openstack/workflow/v2/workflows/testing/requests_test.go b/openstack/workflow/v2/workflows/testing/requests_test.go
index a5d656685..d194631b3 100644
--- a/openstack/workflow/v2/workflows/testing/requests_test.go
+++ b/openstack/workflow/v2/workflows/testing/requests_test.go
@@ -13,12 +13,12 @@ import (
 	"github.com/gophercloud/gophercloud/v2/openstack/workflow/v2/workflows"
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
-	fake "github.com/gophercloud/gophercloud/v2/testhelper/client"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 func TestCreateWorkflow(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	definition := `---
 version: '2.0'
@@ -33,9 +33,9 @@ workflow_echo:
 		test:
         	action: std.echo output="<% $.msg %>"`
 
-	th.Mux.HandleFunc("/workflows", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/workflows", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "POST")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		th.TestHeader(t, r, "Content-Type", "text/plain")
 		th.TestFormValues(t, r, map[string]string{
 			"namespace": "some-namespace",
@@ -70,7 +70,7 @@ workflow_echo:
 		Definition: strings.NewReader(definition),
 	}
 
-	actual, err := workflows.Create(context.TODO(), fake.ServiceClient(), opts).Extract()
+	actual, err := workflows.Create(context.TODO(), client.ServiceClient(fakeServer), opts).Extract()
 	if err != nil {
 		t.Fatalf("Unable to create workflow: %v", err)
 	}
@@ -97,26 +97,26 @@ workflow_echo:
 }
 
 func TestDeleteWorkflow(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/workflows/604a3a1e-94e3-4066-a34a-aa56873ef236", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/workflows/604a3a1e-94e3-4066-a34a-aa56873ef236", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "DELETE")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
 		w.WriteHeader(http.StatusAccepted)
 	})
 
-	res := workflows.Delete(context.TODO(), fake.ServiceClient(), "604a3a1e-94e3-4066-a34a-aa56873ef236")
+	res := workflows.Delete(context.TODO(), client.ServiceClient(fakeServer), "604a3a1e-94e3-4066-a34a-aa56873ef236")
 	th.AssertNoErr(t, res.Err)
 }
 
 func TestGetWorkflow(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	th.Mux.HandleFunc("/workflows/1", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fakeServer.Mux.HandleFunc("/workflows/1", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `
 			{
@@ -133,7 +133,7 @@ func TestGetWorkflow(t *testing.T) {
 			}
 		`)
 	})
-	actual, err := workflows.Get(context.TODO(), fake.ServiceClient(), "1").Extract()
+	actual, err := workflows.Get(context.TODO(), client.ServiceClient(fakeServer), "1").Extract()
 	if err != nil {
 		t.Fatalf("Unable to get workflow: %v", err)
 	}
@@ -157,11 +157,11 @@ func TestGetWorkflow(t *testing.T) {
 }
 
 func TestListWorkflows(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	th.Mux.HandleFunc("/workflows", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fakeServer.Mux.HandleFunc("/workflows", func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, "GET")
-		th.TestHeader(t, r, "X-Auth-Token", fake.TokenID)
+		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 		w.Header().Add("Content-Type", "application/json")
 		if err := r.ParseForm(); err != nil {
 			t.Errorf("Failed to parse request form %v", err)
@@ -185,7 +185,7 @@ func TestListWorkflows(t *testing.T) {
 						"updated_at": "2018-09-12 15:48:17"
 					}
 				]
-			}`, th.Server.URL)
+			}`, fakeServer.Server.URL)
 		case "604a3a1e-94e3-4066-a34a-aa56873ef236":
 			fmt.Fprint(w, `{ "workflows": [] }`)
 		default:
@@ -194,7 +194,7 @@ func TestListWorkflows(t *testing.T) {
 	})
 	pages := 0
 	// Get all workflows
-	err := workflows.List(fake.ServiceClient(), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
+	err := workflows.List(client.ServiceClient(fakeServer), nil).EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		pages++
 		actual, err := workflows.ExtractWorkflows(page)
 		if err != nil {
diff --git a/pagination/testing/linked_test.go b/pagination/testing/linked_test.go
index e28c2b048..ec0476c7d 100644
--- a/pagination/testing/linked_test.go
+++ b/pagination/testing/linked_test.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // LinkedPager sample and test cases.
@@ -30,36 +31,36 @@ func ExtractLinkedInts(r pagination.Page) ([]int, error) {
 	return s.Ints, err
 }
 
-func createLinked() pagination.Pager {
-	th.SetupHTTP()
-
-	th.Mux.HandleFunc("/page1", func(w http.ResponseWriter, r *http.Request) {
+func createLinked(fakeServer th.FakeServer) pagination.Pager {
+	fakeServer.Mux.HandleFunc("/page1", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("Content-Type", "application/json")
-		fmt.Fprintf(w, `{ "ints": [1, 2, 3], "links": { "next": "%s/page2" } }`, th.Server.URL)
+		fmt.Fprintf(w, `{ "ints": [1, 2, 3], "links": { "next": "%s/page2" } }`, fakeServer.Server.URL)
 	})
 
-	th.Mux.HandleFunc("/page2", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/page2", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("Content-Type", "application/json")
-		fmt.Fprintf(w, `{ "ints": [4, 5, 6], "links": { "next": "%s/page3" } }`, th.Server.URL)
+		fmt.Fprintf(w, `{ "ints": [4, 5, 6], "links": { "next": "%s/page3" } }`, fakeServer.Server.URL)
 	})
 
-	th.Mux.HandleFunc("/page3", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/page3", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `{ "ints": [7, 8, 9], "links": { "next": null } }`)
 	})
 
-	client := createClient()
+	client := client.ServiceClient(fakeServer)
 
 	createPage := func(r pagination.PageResult) pagination.Page {
 		return LinkedPageResult{pagination.LinkedPageBase{PageResult: r}}
 	}
 
-	return pagination.NewPager(client, th.Server.URL+"/page1", createPage)
+	return pagination.NewPager(client, fakeServer.Server.URL+"/page1", createPage)
 }
 
 func TestEnumerateLinked(t *testing.T) {
-	pager := createLinked()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	pager := createLinked(fakeServer)
 
 	callCount := 0
 	err := pager.EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -100,8 +101,10 @@ func TestEnumerateLinked(t *testing.T) {
 }
 
 func TestAllPagesLinked(t *testing.T) {
-	pager := createLinked()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	pager := createLinked(fakeServer)
 
 	page, err := pager.AllPages(context.TODO())
 	th.AssertNoErr(t, err)
diff --git a/pagination/testing/marker_test.go b/pagination/testing/marker_test.go
index a41915175..4c9441f37 100644
--- a/pagination/testing/marker_test.go
+++ b/pagination/testing/marker_test.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // MarkerPager sample and test cases.
@@ -36,10 +37,8 @@ func (r MarkerPageResult) LastMarker() (string, error) {
 	return results[len(results)-1], nil
 }
 
-func createMarkerPaged(t *testing.T) pagination.Pager {
-	th.SetupHTTP()
-
-	th.Mux.HandleFunc("/page", func(w http.ResponseWriter, r *http.Request) {
+func createMarkerPaged(t *testing.T, fakeServer th.FakeServer) pagination.Pager {
+	fakeServer.Mux.HandleFunc("/page", func(w http.ResponseWriter, r *http.Request) {
 		if err := r.ParseForm(); err != nil {
 			t.Errorf("Failed to parse request form %v", err)
 		}
@@ -58,7 +57,7 @@ func createMarkerPaged(t *testing.T) pagination.Pager {
 		}
 	})
 
-	client := createClient()
+	client := client.ServiceClient(fakeServer)
 
 	createPage := func(r pagination.PageResult) pagination.Page {
 		p := MarkerPageResult{pagination.MarkerPageBase{PageResult: r}}
@@ -66,7 +65,7 @@ func createMarkerPaged(t *testing.T) pagination.Pager {
 		return p
 	}
 
-	return pagination.NewPager(client, th.Server.URL+"/page", createPage)
+	return pagination.NewPager(client, fakeServer.Server.URL+"/page", createPage)
 }
 
 func ExtractMarkerStrings(page pagination.Page) ([]string, error) {
@@ -82,8 +81,10 @@ func ExtractMarkerStrings(page pagination.Page) ([]string, error) {
 }
 
 func TestEnumerateMarker(t *testing.T) {
-	pager := createMarkerPaged(t)
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	pager := createMarkerPaged(t, fakeServer)
 
 	callCount := 0
 	err := pager.EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
@@ -117,8 +118,10 @@ func TestEnumerateMarker(t *testing.T) {
 }
 
 func TestAllPagesMarker(t *testing.T) {
-	pager := createMarkerPaged(t)
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	pager := createMarkerPaged(t, fakeServer)
 
 	page, err := pager.AllPages(context.TODO())
 	th.AssertNoErr(t, err)
diff --git a/pagination/testing/pagination_test.go b/pagination/testing/pagination_test.go
deleted file mode 100644
index e10ef5684..000000000
--- a/pagination/testing/pagination_test.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package testing
-
-import (
-	"github.com/gophercloud/gophercloud/v2"
-	th "github.com/gophercloud/gophercloud/v2/testhelper"
-)
-
-func createClient() *gophercloud.ServiceClient {
-	return &gophercloud.ServiceClient{
-		ProviderClient: &gophercloud.ProviderClient{TokenID: "abc123"},
-		Endpoint:       th.Endpoint(),
-	}
-}
diff --git a/pagination/testing/single_test.go b/pagination/testing/single_test.go
index 090324a57..4a7f010dc 100644
--- a/pagination/testing/single_test.go
+++ b/pagination/testing/single_test.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2/pagination"
 	th "github.com/gophercloud/gophercloud/v2/testhelper"
+	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
 // SinglePage sample and test cases.
@@ -32,11 +33,10 @@ func ExtractSingleInts(r pagination.Page) ([]int, error) {
 	return s.Ints, err
 }
 
-func setupSinglePaged() pagination.Pager {
-	th.SetupHTTP()
-	client := createClient()
+func setupSinglePaged(fakeServer th.FakeServer) pagination.Pager {
+	client := client.ServiceClient(fakeServer)
 
-	th.Mux.HandleFunc("/only", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/only", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Add("Content-Type", "application/json")
 		fmt.Fprint(w, `{ "ints": [1, 2, 3] }`)
 	})
@@ -45,13 +45,15 @@ func setupSinglePaged() pagination.Pager {
 		return SinglePageResult{pagination.SinglePageBase(r)}
 	}
 
-	return pagination.NewPager(client, th.Server.URL+"/only", createPage)
+	return pagination.NewPager(client, fakeServer.Server.URL+"/only", createPage)
 }
 
 func TestEnumerateSinglePaged(t *testing.T) {
 	callCount := 0
-	pager := setupSinglePaged()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	pager := setupSinglePaged(fakeServer)
 
 	err := pager.EachPage(context.TODO(), func(_ context.Context, page pagination.Page) (bool, error) {
 		callCount++
@@ -67,8 +69,10 @@ func TestEnumerateSinglePaged(t *testing.T) {
 }
 
 func TestAllPagesSingle(t *testing.T) {
-	pager := setupSinglePaged()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+
+	pager := setupSinglePaged(fakeServer)
 
 	page, err := pager.AllPages(context.TODO())
 	th.AssertNoErr(t, err)
diff --git a/testhelper/client/fake.go b/testhelper/client/fake.go
index 29514b0a6..f6ae0b05e 100644
--- a/testhelper/client/fake.go
+++ b/testhelper/client/fake.go
@@ -9,9 +9,9 @@ import (
 const TokenID = "cbc36478b0bd8e67e89469c7749d4127"
 
 // ServiceClient returns a generic service client for use in tests.
-func ServiceClient() *gophercloud.ServiceClient {
+func ServiceClient(fakeServer th.FakeServer) *gophercloud.ServiceClient {
 	return &gophercloud.ServiceClient{
 		ProviderClient: &gophercloud.ProviderClient{TokenID: TokenID},
-		Endpoint:       th.Endpoint(),
+		Endpoint:       fakeServer.Endpoint(),
 	}
 }
diff --git a/testhelper/fixture/helper.go b/testhelper/fixture/helper.go
index 7c8437877..1967b0f48 100644
--- a/testhelper/fixture/helper.go
+++ b/testhelper/fixture/helper.go
@@ -9,8 +9,8 @@ import (
 	"github.com/gophercloud/gophercloud/v2/testhelper/client"
 )
 
-func SetupHandler(t *testing.T, url, method, requestBody, responseBody string, status int) {
-	th.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
+func SetupHandler(t *testing.T, fakeServer th.FakeServer, url, method, requestBody, responseBody string, status int) {
+	fakeServer.Mux.HandleFunc(url, func(w http.ResponseWriter, r *http.Request) {
 		th.TestMethod(t, r, method)
 		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
 
diff --git a/testhelper/http_responses.go b/testhelper/http_responses.go
index 28ecb1e53..f57645e44 100644
--- a/testhelper/http_responses.go
+++ b/testhelper/http_responses.go
@@ -13,48 +13,28 @@ import (
 	"testing"
 )
 
-var (
+type FakeServer struct {
 	// Mux is a multiplexer that can be used to register handlers.
 	Mux *http.ServeMux
 
 	// Server is an in-memory HTTP server for testing.
 	Server *httptest.Server
-)
-
-// SetupPersistentPortHTTP prepares the Mux and Server listening specific port.
-func SetupPersistentPortHTTP(t *testing.T, port int) {
-	l, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port))
-	if err != nil {
-		t.Errorf("Failed to listen to 127.0.0.1:%d: %s", port, err)
-	}
-	Mux = http.NewServeMux()
-	Server = httptest.NewUnstartedServer(Mux)
-	Server.Listener = l
-	Server.Start()
-}
-
-// SetupHTTP prepares the Mux and Server.
-func SetupHTTP() {
-	Mux = http.NewServeMux()
-	Server = httptest.NewServer(Mux)
 }
 
-// TeardownHTTP releases HTTP-related resources.
-func TeardownHTTP() {
-	Server.Close()
+func (fakeServer FakeServer) Teardown() {
+	fakeServer.Server.Close()
 }
 
-// Endpoint returns a fake endpoint that will actually target the Mux.
-func Endpoint() string {
-	return Server.URL + "/"
+func (fakeServer FakeServer) Endpoint() string {
+	return fakeServer.Server.URL + "/"
 }
 
 // Serves a static content at baseURL/relPath
-func ServeFile(t *testing.T, baseURL, relPath, contentType, content string) string {
+func (fakeServer FakeServer) ServeFile(t *testing.T, baseURL, relPath, contentType, content string) string {
 	rawURL := strings.Join([]string{baseURL, relPath}, "/")
 	parsedURL, err := url.Parse(rawURL)
 	AssertNoErr(t, err)
-	Mux.HandleFunc(parsedURL.Path, func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc(parsedURL.Path, func(w http.ResponseWriter, r *http.Request) {
 		TestMethod(t, r, "GET")
 		w.Header().Set("Content-Type", contentType)
 		w.WriteHeader(http.StatusOK)
@@ -64,6 +44,34 @@ func ServeFile(t *testing.T, baseURL, relPath, contentType, content string) stri
 	return rawURL
 }
 
+// SetupPersistentPortHTTP prepares the Mux and Server listening specific port.
+func SetupPersistentPortHTTP(t *testing.T, port int) FakeServer {
+	mux := http.NewServeMux()
+	server := httptest.NewUnstartedServer(mux)
+	l, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port))
+	if err != nil {
+		t.Errorf("Failed to listen to 127.0.0.1:%d: %s", port, err)
+	}
+	server.Listener = l
+	server.Start()
+
+	return FakeServer{
+		Mux:    mux,
+		Server: server,
+	}
+}
+
+// SetupHTTP prepares the Mux and Server.
+func SetupHTTP() FakeServer {
+	mux := http.NewServeMux()
+	server := httptest.NewServer(mux)
+
+	return FakeServer{
+		Mux:    mux,
+		Server: server,
+	}
+}
+
 // TestFormValues ensures that all the URL parameters given to the http.Request are the same as values.
 func TestFormValues(t *testing.T, r *http.Request, values map[string]string) {
 	want := url.Values{}
diff --git a/testing/provider_client_test.go b/testing/provider_client_test.go
index 44fc37756..900d53021 100644
--- a/testing/provider_client_test.go
+++ b/testing/provider_client_test.go
@@ -79,10 +79,10 @@ func TestConcurrentReauth(t *testing.T) {
 		return nil
 	}
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		if r.Header.Get("X-Auth-Token") != postreauthTok {
 			w.WriteHeader(http.StatusUnauthorized)
 			info.mut.Lock()
@@ -113,7 +113,7 @@ func TestConcurrentReauth(t *testing.T) {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			resp, err := p.Request(context.TODO(), "GET", fmt.Sprintf("%s/route", th.Endpoint()), reqopts)
+			resp, err := p.Request(context.TODO(), "GET", fmt.Sprintf("%s/route", fakeServer.Endpoint()), reqopts)
 			th.CheckNoErr(t, err)
 			if resp == nil {
 				t.Errorf("got a nil response")
@@ -171,10 +171,10 @@ func TestReauthEndLoop(t *testing.T) {
 		return nil
 	}
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		// route always return 401
 		w.WriteHeader(http.StatusUnauthorized)
 	})
@@ -190,7 +190,7 @@ func TestReauthEndLoop(t *testing.T) {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			_, err := p.Request(context.TODO(), "GET", fmt.Sprintf("%s/route", th.Endpoint()), reqopts)
+			_, err := p.Request(context.TODO(), "GET", fmt.Sprintf("%s/route", fakeServer.Endpoint()), reqopts)
 
 			mut.Lock()
 			defer mut.Unlock()
@@ -256,10 +256,10 @@ func TestRequestThatCameDuringReauthWaitsUntilItIsCompleted(t *testing.T) {
 		return nil
 	}
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		if r.Header.Get("X-Auth-Token") != postreauthTok {
 			info.mut.Lock()
 			info.failedAuths++
@@ -293,7 +293,7 @@ func TestRequestThatCameDuringReauthWaitsUntilItIsCompleted(t *testing.T) {
 			if i != 0 {
 				<-info.reauthCh
 			}
-			resp, err := p.Request(context.TODO(), "GET", fmt.Sprintf("%s/route", th.Endpoint()), reqopts)
+			resp, err := p.Request(context.TODO(), "GET", fmt.Sprintf("%s/route", fakeServer.Endpoint()), reqopts)
 			th.CheckNoErr(t, err)
 			if resp == nil {
 				t.Errorf("got a nil response")
@@ -339,13 +339,13 @@ func TestRequestReauthsAtMostOnce(t *testing.T) {
 		return nil
 	}
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	requestCounter := 0
 	var requestCounterMutex sync.Mutex
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		requestCounterMutex.Lock()
 		requestCounter++
 		//avoid infinite loop
@@ -363,7 +363,7 @@ func TestRequestReauthsAtMostOnce(t *testing.T) {
 	// the part before the colon), but when encountering another 401 response, we
 	// did not attempt reauthentication again and just passed that 401 response to
 	// the caller as ErrDefault401.
-	_, err := p.Request(context.TODO(), "GET", th.Endpoint()+"/route", &gophercloud.RequestOpts{})
+	_, err := p.Request(context.TODO(), "GET", fakeServer.Endpoint()+"/route", &gophercloud.RequestOpts{})
 	expectedErrorRx := regexp.MustCompile(`^Successfully re-authenticated, but got error executing request: Expected HTTP response code \[200\] when accessing \[GET http://[^/]*//route\], but got 401 instead: unauthorized$`)
 	if !expectedErrorRx.MatchString(err.Error()) {
 		t.Errorf("expected error that looks like %q, but got %q", expectedErrorRx.String(), err.Error())
@@ -501,17 +501,17 @@ func TestRequestRetry(t *testing.T) {
 
 	p.RetryBackoffFunc = retryBackoffTest(&retryCounter, t)
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Retry-After", "1")
 
 		//always reply 429
 		http.Error(w, "retry later", http.StatusTooManyRequests)
 	})
 
-	_, err := p.Request(context.TODO(), "GET", th.Endpoint()+"/route", &gophercloud.RequestOpts{})
+	_, err := p.Request(context.TODO(), "GET", fakeServer.Endpoint()+"/route", &gophercloud.RequestOpts{})
 	if err == nil {
 		t.Fatal("expecting error, got nil")
 	}
@@ -528,17 +528,17 @@ func TestRequestRetryHTTPDate(t *testing.T) {
 
 	p.RetryBackoffFunc = retryBackoffTest(&retryCounter, t)
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Retry-After", time.Now().Add(1*time.Second).UTC().Format(http.TimeFormat))
 
 		//always reply 429
 		http.Error(w, "retry later", http.StatusTooManyRequests)
 	})
 
-	_, err := p.Request(context.TODO(), "GET", th.Endpoint()+"/route", &gophercloud.RequestOpts{})
+	_, err := p.Request(context.TODO(), "GET", fakeServer.Endpoint()+"/route", &gophercloud.RequestOpts{})
 	if err == nil {
 		t.Fatal("expecting error, got nil")
 	}
@@ -555,17 +555,17 @@ func TestRequestRetryError(t *testing.T) {
 
 	p.RetryBackoffFunc = retryBackoffTest(&retryCounter, t)
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Retry-After", "foo bar")
 
 		//always reply 429
 		http.Error(w, "retry later", http.StatusTooManyRequests)
 	})
 
-	_, err := p.Request(context.TODO(), "GET", th.Endpoint()+"/route", &gophercloud.RequestOpts{})
+	_, err := p.Request(context.TODO(), "GET", fakeServer.Endpoint()+"/route", &gophercloud.RequestOpts{})
 	if err == nil {
 		t.Fatal("expecting error, got nil")
 	}
@@ -582,15 +582,15 @@ func TestRequestRetrySuccess(t *testing.T) {
 
 	p.RetryBackoffFunc = retryBackoffTest(&retryCounter, t)
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		//always reply 200
 		http.Error(w, "retry later", http.StatusOK)
 	})
 
-	_, err := p.Request(context.TODO(), "GET", th.Endpoint()+"/route", &gophercloud.RequestOpts{})
+	_, err := p.Request(context.TODO(), "GET", fakeServer.Endpoint()+"/route", &gophercloud.RequestOpts{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -614,17 +614,17 @@ func TestRequestRetryContext(t *testing.T) {
 
 	p.RetryBackoffFunc = retryBackoffTest(&retryCounter, t)
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Retry-After", "1")
 
 		//always reply 429
 		http.Error(w, "retry later", http.StatusTooManyRequests)
 	})
 
-	_, err := p.Request(ctx, "GET", th.Endpoint()+"/route", &gophercloud.RequestOpts{})
+	_, err := p.Request(ctx, "GET", fakeServer.Endpoint()+"/route", &gophercloud.RequestOpts{})
 	if err == nil {
 		t.Fatal("expecting error, got nil")
 	}
@@ -643,11 +643,11 @@ func TestRequestGeneralRetry(t *testing.T) {
 		return nil
 	}
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	count := 0
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		if count < 3 {
 			http.Error(w, "bad gateway", http.StatusBadGateway)
 			count += 1
@@ -656,7 +656,7 @@ func TestRequestGeneralRetry(t *testing.T) {
 		}
 	})
 
-	_, err := p.Request(context.TODO(), "GET", th.Endpoint()+"/route", &gophercloud.RequestOpts{})
+	_, err := p.Request(context.TODO(), "GET", fakeServer.Endpoint()+"/route", &gophercloud.RequestOpts{})
 	if err != nil {
 		t.Fatal("expecting nil, got err")
 	}
@@ -671,11 +671,11 @@ func TestRequestGeneralRetryAbort(t *testing.T) {
 		return err
 	}
 
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
 
 	count := 0
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		if count < 3 {
 			http.Error(w, "bad gateway", http.StatusBadGateway)
 			count += 1
@@ -684,7 +684,7 @@ func TestRequestGeneralRetryAbort(t *testing.T) {
 		}
 	})
 
-	_, err := p.Request(context.TODO(), "GET", th.Endpoint()+"/route", &gophercloud.RequestOpts{})
+	_, err := p.Request(context.TODO(), "GET", fakeServer.Endpoint()+"/route", &gophercloud.RequestOpts{})
 	if err == nil {
 		t.Fatal("expecting err, got nil")
 	}
diff --git a/testing/service_client_test.go b/testing/service_client_test.go
index 6253b698d..6d409d20e 100644
--- a/testing/service_client_test.go
+++ b/testing/service_client_test.go
@@ -18,9 +18,9 @@ func TestServiceURL(t *testing.T) {
 }
 
 func TestMoreHeaders(t *testing.T) {
-	th.SetupHTTP()
-	defer th.TeardownHTTP()
-	th.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
+	fakeServer := th.SetupHTTP()
+	defer fakeServer.Teardown()
+	fakeServer.Mux.HandleFunc("/route", func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusOK)
 	})
 
@@ -29,7 +29,7 @@ func TestMoreHeaders(t *testing.T) {
 		"custom": "header",
 	}
 	c.ProviderClient = new(gophercloud.ProviderClient)
-	resp, err := c.Get(context.TODO(), fmt.Sprintf("%s/route", th.Endpoint()), nil, nil)
+	resp, err := c.Get(context.TODO(), fmt.Sprintf("%s/route", fakeServer.Endpoint()), nil, nil)
 	th.AssertNoErr(t, err)
 	th.AssertEquals(t, resp.Request.Header.Get("custom"), "header")
 }