Merge 46ccfff71d into 6275399327

2024-11-26 08:53:05 +00:00 · 2024-11-19 00:10:59 +13:00
57 changed files with 923 additions and 3047 deletions
--- a/.github/workflows/test-integration.yaml
+++ b/.github/workflows/test-integration.yaml
@ -21,7 +21,6 @@ jobs:
          - TestPolicyUpdateWhileRunningWithCLIInDatabase
          - TestOIDCAuthenticationPingAll
          - TestOIDCExpireNodesBasedOnTokenExpiry
-          - TestOIDC024UserCreation
          - TestAuthWebFlowAuthenticationPingAll
          - TestAuthWebFlowLogoutAndRelogin
          - TestUserCommand
@ -39,7 +38,6 @@ jobs:
          - TestNodeMoveCommand
          - TestPolicyCommand
          - TestPolicyBrokenConfigCommand
-          - TestDERPVerifyEndpoint
          - TestResolveMagicDNS
          - TestValidateResolvConf
          - TestDERPServerScenario
--- a/.golangci.yaml
+++ b/.golangci.yaml
@ -27,7 +27,6 @@ linters:
    - nolintlint
    - musttag # causes issues with imported libs
    - depguard
-    - exportloopref

    # We should strive to enable these:
    - wrapcheck
@ -57,14 +56,9 @@ linters-settings:
      - ok
      - c
      - tt
-      - tx
-      - rx

  gocritic:
    disabled-checks:
      - appendAssign
      # TODO(kradalby): Remove this
      - ifElseChain
-
-  nlreturn:
-    block-size: 4
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -2,82 +2,16 @@

 ## Next

-### Security fix: OIDC changes in Headscale 0.24.0
-
-_Headscale v0.23.0 and earlier_ identified OIDC users by the "username" part of their email address (when `strip_email_domain: true`, the default) or whole email address (when `strip_email_domain: false`).
-
-Depending on how Headscale and your Identity Provider (IdP) were configured, only using the `email` claim could allow a malicious user with an IdP account to take over another Headscale user's account, even when `strip_email_domain: false`.
-
-This would also cause a user to lose access to their Headscale account if they changed their email address.
-
-_Headscale v0.24.0_ now identifies OIDC users by the `iss` and `sub` claims. [These are guaranteed by the OIDC specification to be stable and unique](https://openid.net/specs/openid-connect-core-1_0.html#ClaimStability), even if a user changes email address. A well-designed IdP will typically set `sub` to an opaque identifier like a UUID or numeric ID, which has no relation to the user's name or email address.
-
-This issue _only_ affects Headscale installations which authenticate with OIDC.
-
-Headscale v0.24.0 and later will also automatically update profile fields with OIDC data on login. This means that users can change those details in your IdP, and have it populate to Headscale automatically the next time they log in. However, this may affect the way you reference users in policies.
-
-#### Migrating existing installations
-
-Headscale v0.23.0 and earlier never recorded the `iss` and `sub` fields, so all legacy (existing) OIDC accounts from _need to be migrated_ to be properly secured.
-
-Headscale v0.24.0 has an automatic migration feature, which is enabled by default (`map_legacy_users: true`). **This will be disabled by default in a future version of Headscale – any unmigrated users will get new accounts.**
-
-Headscale v0.24.0 will ignore any `email` claim if the IdP does not provide an `email_verified` claim set to `true`. [What "verified" actually means is contextually dependent](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) – Headscale uses it as a signal that the contents of the `email` claim is reasonably trustworthy.
-
-Headscale v0.23.0 and earlier never checked the `email_verified` claim. This means even if an IdP explicitly indicated to Headscale that its `email` claim was untrustworthy, Headscale would have still accepted it.
-
-##### What does automatic migration do?
-
-When automatic migration is enabled (`map_legacy_users: true`), Headscale will first match an OIDC account to a Headscale account by `iss` and `sub`, and then fall back to matching OIDC users similarly to how Headscale v0.23.0 did:
-
- If `strip_email_domain: true` (the default): the Headscale username matches the "username" part of their email address.
- If `strip_email_domain: false`: the Headscale username matches the _whole_ email address.
-
-On migration, Headscale will change the account's username to their `preferred_username`. **This could break any ACLs or policies which are configured to match by username.**
-
-Like with Headscale v0.23.0 and earlier, this migration only works for users who haven't changed their email address since their last Headscale login.
-
-A _successful_ automated migration should otherwise be transparent to users.
-
-Once a Headscale account has been migrated, it will be _unavailable_ to be matched by the legacy process. An OIDC login with a matching username, but _non-matching_ `iss` and `sub` will instead get a _new_ Headscale account.
-
-Because of the way OIDC works, Headscale's automated migration process can _only_ work when a user tries to log in after the update. Mass updates would require Headscale implement a protocol like SCIM, which is **extremely** complicated and not available in all identity providers.
-
-Administrators could also attempt to migrate users manually by editing the database, using their own mapping rules with known-good data sources.
-
-Legacy account migration should have no effect on new installations where all users have a recorded `sub` and `iss`.
-
-##### What happens when automatic migration is disabled?
-
-When automatic migration is disabled (`map_legacy_users: false`), Headscale will only try to match an OIDC account to a Headscale account by `iss` and `sub`.
-
-If there is no match, it will get a _new_ Headscale account – even if there was a legacy account which _could_ have matched and migrated.
-
-We recommend new Headscale users explicitly disable automatic migration – but it should otherwise have no effect if every account has a recorded `iss` and `sub`.
-
-When automatic migration is disabled, the `strip_email_domain` setting will have no effect.
-
-Special thanks to @micolous for reviewing, proposing and working with us on these changes.
-
-#### Other OIDC changes
-
-Headscale now uses [the standard OIDC claims](https://openid.net/specs/openid-connect-core-1_0.html#StandardClaims) to populate and update user information every time they log in:
-
-| Headscale profile field | OIDC claim           | Notes / examples                                                                                          |
-| ----------------------- | -------------------- | --------------------------------------------------------------------------------------------------------- |
-| email address           | `email`              | Only used when `"email_verified": true`                                                                   |
-| display name            | `name`               | eg: `Sam Smith`                                                                                           |
-| username                | `preferred_username` | Varies depending on IdP and configuration, eg: `ssmith`, `ssmith@idp.example.com`, `\\example.com\ssmith` |
-| profile picture         | `picture`            | URL to a profile picture or avatar                                                                        |
-
-These should show up nicely in the Tailscale client.
-
-This will also affect the way you [reference users in policies](https://github.com/juanfont/headscale/pull/2205).
-
 ### BREAKING

 - Remove `dns.use_username_in_magic_dns` configuration option [#2020](https://github.com/juanfont/headscale/pull/2020)
  - Having usernames in magic DNS is no longer possible.
+- Redo OpenID Connect configuration [#2020](https://github.com/juanfont/headscale/pull/2020)
+  - `strip_email_domain` has been removed, domain is _always_ part of the username for OIDC.
+  - Users are now identified by `sub` claim in the ID token instead of username, allowing the username, name and email to be updated.
+  - User has been extended to store username, display name, profile picture url and email.
+    - These fields are forwarded to the client, and shows up nicely in the user switcher.
+    - These fields can be made available via the API/CLI for non-OIDC users in the future.
 - Remove versions older than 1.56 [#2149](https://github.com/juanfont/headscale/pull/2149)
  - Clean up old code required by old versions

@ -89,7 +23,6 @@ This will also affect the way you [reference users in policies](https://github.c
 - Added conversion of 'Hostname' to 'givenName' in a node with FQDN rules applied [#2198](https://github.com/juanfont/headscale/pull/2198)
 - Fixed updating of hostname and givenName when it is updated in HostInfo [#2199](https://github.com/juanfont/headscale/pull/2199)
 - Fixed missing `stable-debug` container tag [#2232](https://github.com/juanfont/headscale/pr/2232)
- Loosened up `server_url` and `base_domain` check. It was overly strict in some cases.

 ## 0.23.0 (2024-09-18)

--- a/Dockerfile.integration
+++ b/Dockerfile.integration
--- a/Dockerfile.derper
+++ b/Dockerfile.derper
@ -1,19 +0,0 @@
-# For testing purposes only
-
-FROM golang:alpine AS build-env
-
-WORKDIR /go/src
-
-RUN apk add --no-cache git
-ARG VERSION_BRANCH=main
-RUN git clone https://github.com/tailscale/tailscale.git --branch=$VERSION_BRANCH --depth=1
-WORKDIR /go/src/tailscale
-
-ARG TARGETARCH
-RUN GOARCH=$TARGETARCH go install -v ./cmd/derper
-
-FROM alpine:3.18
-RUN apk add --no-cache ca-certificates iptables iproute2 ip6tables curl
-
-COPY --from=build-env /go/bin/* /usr/local/bin/
-ENTRYPOINT [ "/usr/local/bin/derper" ]
--- a/Dockerfile.tailscale-HEAD
+++ b/Dockerfile.tailscale-HEAD
@ -28,9 +28,7 @@ ARG VERSION_GIT_HASH=""
 ENV VERSION_GIT_HASH=$VERSION_GIT_HASH
 ARG TARGETARCH

-ARG BUILD_TAGS=""
-
-RUN GOARCH=$TARGETARCH go install -tags="${BUILD_TAGS}" -ldflags="\
+RUN GOARCH=$TARGETARCH go install -ldflags="\
      -X tailscale.com/version.longStamp=$VERSION_LONG \
      -X tailscale.com/version.shortStamp=$VERSION_SHORT \
      -X tailscale.com/version.gitCommitStamp=$VERSION_GIT_HASH" \
--- a/cmd/headscale/cli/mockoidc.go
+++ b/cmd/headscale/cli/mockoidc.go
@ -1,10 +1,8 @@
 package cli

 import (
-	"encoding/json"
 	"fmt"
 	"net"
-	"net/http"
 	"os"
 	"strconv"
 	"time"
@ -66,19 +64,6 @@ func mockOIDC() error {
 		accessTTL = newTTL
 	}

-	userStr := os.Getenv("MOCKOIDC_USERS")
-	if userStr == "" {
-		return fmt.Errorf("MOCKOIDC_USERS not defined")
-	}
-
-	var users []mockoidc.MockUser
-	err := json.Unmarshal([]byte(userStr), &users)
-	if err != nil {
-		return fmt.Errorf("unmarshalling users: %w", err)
-	}
-
-	log.Info().Interface("users", users).Msg("loading users from JSON")
-
 	log.Info().Msgf("Access token TTL: %s", accessTTL)

 	port, err := strconv.Atoi(portStr)
@ -86,7 +71,7 @@ func mockOIDC() error {
 		return err
 	}

-	mock, err := getMockOIDC(clientID, clientSecret, users)
+	mock, err := getMockOIDC(clientID, clientSecret)
 	if err != nil {
 		return err
 	}
@ -108,18 +93,12 @@ func mockOIDC() error {
 	return nil
 }

-func getMockOIDC(clientID string, clientSecret string, users []mockoidc.MockUser) (*mockoidc.MockOIDC, error) {
+func getMockOIDC(clientID string, clientSecret string) (*mockoidc.MockOIDC, error) {
 	keypair, err := mockoidc.NewKeypair(nil)
 	if err != nil {
 		return nil, err
 	}

-	userQueue := mockoidc.UserQueue{}
-
-	for _, user := range users {
-		userQueue.Push(&user)
-	}
-
 	mock := mockoidc.MockOIDC{
 		ClientID:                      clientID,
 		ClientSecret:                  clientSecret,
@ -128,19 +107,9 @@ func getMockOIDC(clientID string, clientSecret string, users []mockoidc.MockUser
 		CodeChallengeMethodsSupported: []string{"plain", "S256"},
 		Keypair:                       keypair,
 		SessionStore:                  mockoidc.NewSessionStore(),
-		UserQueue:                     &userQueue,
+		UserQueue:                     &mockoidc.UserQueue{},
 		ErrorQueue:                    &mockoidc.ErrorQueue{},
 	}

-	mock.AddMiddleware(func(h http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			log.Info().Msgf("Request: %+v", r)
-			h.ServeHTTP(w, r)
-			if r.Response != nil {
-				log.Info().Msgf("Response: %+v", r.Response)
-			}
-		})
-	})
-
 	return &mock, nil
 }
--- a/config-example.yaml
+++ b/config-example.yaml
@ -168,11 +168,6 @@ database:
    # https://www.sqlite.org/wal.html
    write_ahead_log: true

-    # Maximum number of WAL file frames before the WAL file is automatically checkpointed.
-    # https://www.sqlite.org/c3ref/wal_autocheckpoint.html
-    # Set to 0 to disable automatic checkpointing.
-    wal_autocheckpoint: 1000
-
  # # Postgres config
  # Please note that using Postgres is highly discouraged as it is only supported for legacy reasons.
  # See database.type for more information.
@ -369,18 +364,12 @@ unix_socket_permission: "0770"
 #   allowed_users:
 #     - alice@example.com
 #
-#   # Map legacy users from pre-0.24.0 versions of headscale to the new OIDC users
-#   # by taking the username from the legacy user and matching it with the username
-#   # provided by the OIDC. This is useful when migrating from legacy users to OIDC
-#   # to force them using the unique identifier from the OIDC and to give them a
-#   # proper display name and picture if available.
-#   # Note that this will only work if the username from the legacy user is the same
-#   # and ther is a posibility for account takeover should a username have changed
-#   # with the provider.
-#   # Disabling this feature will cause all new logins to be created as new users.
-#   # Note this option will be removed in the future and should be set to false
-#   # on all new installations, or when all users have logged in with OIDC once.
-#   map_legacy_users: true
+#   # If `strip_email_domain` is set to `true`, the domain part of the username email address will be removed.
+#   # This will transform `first-name.last-name@example.com` to the user `first-name.last-name`
+#   # If `strip_email_domain` is set to `false` the domain part will NOT be removed resulting to the following
+#   user: `first-name.last-name.example.com`
+#
+#   strip_email_domain: true

 # Logtail configuration
 # Logtail is Tailscales logging and auditing infrastructure, it allows the control panel
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@ -1,5 +1,7 @@
-mkdocs-include-markdown-plugin~=7.1
-mkdocs-macros-plugin~=1.3
-mkdocs-material[imaging]~=9.5
-mkdocs-minify-plugin~=0.7
-mkdocs-redirects~=1.2
+cairosvg~=2.7.1
+mkdocs-include-markdown-plugin~=6.2.2
+mkdocs-macros-plugin~=1.2.0
+mkdocs-material~=9.5.18
+mkdocs-minify-plugin~=0.7.1
+mkdocs-redirects~=1.2.1
+pillow~=10.1.0
--- a/flake.nix
+++ b/flake.nix
@ -32,7 +32,7 @@

          # When updating go.mod or go.sum, a new sha will need to be calculated,
          # update this if you have a mismatch after doing a change to thos files.
-          vendorHash = "sha256-4VNiHUblvtcl9UetwiL6ZeVYb0h2e9zhYVsirhAkvOg=";
+          vendorHash = "sha256-CMkYTRjmhvTTrB7JbLj0cj9VEyzpG0iUWXkaOagwYTk=";

          subPackages = ["cmd/headscale"];

@ -102,7 +102,6 @@
          ko
          yq-go
          ripgrep
-          postgresql

          # 'dot' is needed for pprof graphs
          # go tool pprof -http=: <source>
--- a/go.mod
+++ b/go.mod
@ -49,7 +49,6 @@ require (
 	gorm.io/gorm v1.25.11
 	tailscale.com v1.75.0-pre.0.20240926101731-7d1160ddaab7
 	zgo.at/zcache/v2 v2.1.0
-	zombiezen.com/go/postgrestest v1.0.1
 )

 require (
@ -135,7 +134,6 @@ require (
 	github.com/kortschak/wol v0.0.0-20200729010619-da482cc4850a // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
-	github.com/lib/pq v1.10.9 // indirect
 	github.com/lithammer/fuzzysearch v1.1.8 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
--- a/go.sum
+++ b/go.sum
@ -311,7 +311,6 @@ github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
 github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
-github.com/lib/pq v1.8.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/lithammer/fuzzysearch v1.1.8 h1:/HIuJnjHuXS8bKaiTMeeDlW2/AyIWk2brx1V8LFgLN4=
@ -732,5 +731,3 @@ tailscale.com v1.75.0-pre.0.20240926101731-7d1160ddaab7 h1:nfRWV6ECxwNvvXKtbqSVs
 tailscale.com v1.75.0-pre.0.20240926101731-7d1160ddaab7/go.mod h1:xKxYf3B3PuezFlRaMT+VhuVu8XTFUTLy+VCzLPMJVmg=
 zgo.at/zcache/v2 v2.1.0 h1:USo+ubK+R4vtjw4viGzTe/zjXyPw6R7SK/RL3epBBxs=
 zgo.at/zcache/v2 v2.1.0/go.mod h1:gyCeoLVo01QjDZynjime8xUGHHMbsLiPyUTBpDGd4Gk=
-zombiezen.com/go/postgrestest v1.0.1 h1:aXoADQAJmZDU3+xilYVut0pHhgc0sF8ZspPW9gFNwP4=
-zombiezen.com/go/postgrestest v1.0.1/go.mod h1:marlZezr+k2oSJrvXHnZUs1olHqpE9czlz8ZYkVxliQ=
--- a/hscontrol/app.go
+++ b/hscontrol/app.go
@ -457,8 +457,6 @@ func (h *Headscale) createRouter(grpcMux *grpcRuntime.ServeMux) *mux.Router {
 	router.HandleFunc("/swagger/v1/openapiv2.json", headscale.SwaggerAPIv1).
 		Methods(http.MethodGet)

-	router.HandleFunc("/verify", h.VerifyHandler).Methods(http.MethodPost)
-
 	if h.cfg.DERP.ServerEnabled {
 		router.HandleFunc("/derp", h.DERPServer.DERPHandler)
 		router.HandleFunc("/derp/probe", derpServer.DERPProbeHandler)
@ -1029,18 +1027,14 @@ func (h *Headscale) loadACLPolicy() error {
 		if err != nil {
 			return fmt.Errorf("loading nodes from database to validate policy: %w", err)
 		}
-		users, err := h.db.ListUsers()
-		if err != nil {
-			return fmt.Errorf("loading users from database to validate policy: %w", err)
-		}

-		_, err = pol.CompileFilterRules(users, nodes)
+		_, err = pol.CompileFilterRules(nodes)
 		if err != nil {
 			return fmt.Errorf("verifying policy rules: %w", err)
 		}

 		if len(nodes) > 0 {
-			_, err = pol.CompileSSHPolicy(nodes[0], users, nodes)
+			_, err = pol.CompileSSHPolicy(nodes[0], nodes)
 			if err != nil {
 				return fmt.Errorf("verifying SSH rules: %w", err)
 			}
--- a/hscontrol/db/db.go
+++ b/hscontrol/db/db.go
@ -474,8 +474,6 @@ func NewHeadscaleDatabase(
 				Rollback: func(db *gorm.DB) error { return nil },
 			},
 			{
-				// Pick up new user fields used for OIDC and to
-				// populate the user with more interesting information.
 				ID: "202407191627",
 				Migrate: func(tx *gorm.DB) error {
 					err := tx.AutoMigrate(&types.User{})
@ -487,40 +485,6 @@ func NewHeadscaleDatabase(
 				},
 				Rollback: func(db *gorm.DB) error { return nil },
 			},
-			{
-				// The unique constraint of Name has been dropped
-				// in favour of a unique together of name and
-				// provider identity.
-				ID: "202408181235",
-				Migrate: func(tx *gorm.DB) error {
-					err := tx.AutoMigrate(&types.User{})
-					if err != nil {
-						return err
-					}
-
-					// Set up indexes and unique constraints outside of GORM, it does not support
-					// conditional unique constraints.
-					// This ensures the following:
-					// - A user name and provider_identifier is unique
-					// - A provider_identifier is unique
-					// - A user name is unique if there is no provider_identifier is not set
-					for _, idx := range []string{
-						"DROP INDEX IF EXISTS idx_provider_identifier",
-						"DROP INDEX IF EXISTS idx_name_provider_identifier",
-						"CREATE UNIQUE INDEX IF NOT EXISTS idx_provider_identifier ON users (provider_identifier) WHERE provider_identifier IS NOT NULL;",
-						"CREATE UNIQUE INDEX IF NOT EXISTS idx_name_provider_identifier ON users (name,provider_identifier);",
-						"CREATE UNIQUE INDEX IF NOT EXISTS idx_name_no_provider_identifier ON users (name) WHERE provider_identifier IS NULL;",
-					} {
-						err = tx.Exec(idx).Error
-						if err != nil {
-							return fmt.Errorf("creating username index: %w", err)
-						}
-					}
-
-					return nil
-				},
-				Rollback: func(db *gorm.DB) error { return nil },
-			},
 		},
 	)

@ -579,10 +543,10 @@ func openDB(cfg types.DatabaseConfig) (*gorm.DB, error) {
 		}

 		if cfg.Sqlite.WriteAheadLog {
-			if err := db.Exec(fmt.Sprintf(`
+			if err := db.Exec(`
 				PRAGMA journal_mode=WAL;
-				PRAGMA wal_autocheckpoint=%d;
-				`, cfg.Sqlite.WALAutoCheckPoint)).Error; err != nil {
+				PRAGMA wal_autocheckpoint=0;
+				`).Error; err != nil {
 				return nil, fmt.Errorf("setting WAL mode: %w", err)
 			}
 		}
--- a/hscontrol/db/db_test.go
+++ b/hscontrol/db/db_test.go
@ -1,7 +1,6 @@
 package db

 import (
-	"database/sql"
 	"fmt"
 	"io"
 	"net/netip"
@ -9,7 +8,6 @@ import (
 	"path/filepath"
 	"slices"
 	"sort"
-	"strings"
 	"testing"
 	"time"

@ -18,7 +16,6 @@ import (
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"gorm.io/gorm"
 	"zgo.at/zcache/v2"
 )
@ -47,7 +44,7 @@ func TestMigrations(t *testing.T) {
 				routes, err := Read(h.DB, func(rx *gorm.DB) (types.Routes, error) {
 					return GetRoutes(rx)
 				})
-				require.NoError(t, err)
+				assert.NoError(t, err)

 				assert.Len(t, routes, 10)
 				want := types.Routes{
@ -73,7 +70,7 @@ func TestMigrations(t *testing.T) {
 				routes, err := Read(h.DB, func(rx *gorm.DB) (types.Routes, error) {
 					return GetRoutes(rx)
 				})
-				require.NoError(t, err)
+				assert.NoError(t, err)

 				assert.Len(t, routes, 4)
 				want := types.Routes{
@ -123,19 +120,19 @@ func TestMigrations(t *testing.T) {
 			dbPath: "testdata/0-23-0-to-0-24-0-preauthkey-tags-table.sqlite",
 			wantFunc: func(t *testing.T, h *HSDatabase) {
 				keys, err := Read(h.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
-					kratest, err := ListPreAuthKeysByUser(rx, 1) // kratest
+					kratest, err := ListPreAuthKeys(rx, "kratest")
 					if err != nil {
 						return nil, err
 					}

-					testkra, err := ListPreAuthKeysByUser(rx, 2) // testkra
+					testkra, err := ListPreAuthKeys(rx, "testkra")
 					if err != nil {
 						return nil, err
 					}

 					return append(kratest, testkra...), nil
 				})
-				require.NoError(t, err)
+				assert.NoError(t, err)

 				assert.Len(t, keys, 5)
 				want := []types.PreAuthKey{
@ -180,7 +177,7 @@ func TestMigrations(t *testing.T) {
 				nodes, err := Read(h.DB, func(rx *gorm.DB) (types.Nodes, error) {
 					return ListNodes(rx)
 				})
-				require.NoError(t, err)
+				assert.NoError(t, err)

 				for _, node := range nodes {
 					assert.Falsef(t, node.MachineKey.IsZero(), "expected non zero machinekey")
@ -259,120 +256,3 @@ func testCopyOfDatabase(src string) (string, error) {
 func emptyCache() *zcache.Cache[string, types.Node] {
 	return zcache.New[string, types.Node](time.Minute, time.Hour)
 }
-
-// requireConstraintFailed checks if the error is a constraint failure with
-// either SQLite and PostgreSQL error messages.
-func requireConstraintFailed(t *testing.T, err error) {
-	t.Helper()
-	require.Error(t, err)
-	if !strings.Contains(err.Error(), "UNIQUE constraint failed:") && !strings.Contains(err.Error(), "violates unique constraint") {
-		require.Failf(t, "expected error to contain a constraint failure, got: %s", err.Error())
-	}
-}
-
-func TestConstraints(t *testing.T) {
-	tests := []struct {
-		name string
-		run  func(*testing.T, *gorm.DB)
-	}{
-		{
-			name: "no-duplicate-username-if-no-oidc",
-			run: func(t *testing.T, db *gorm.DB) {
-				_, err := CreateUser(db, "user1")
-				require.NoError(t, err)
-				_, err = CreateUser(db, "user1")
-				requireConstraintFailed(t, err)
-			},
-		},
-		{
-			name: "no-oidc-duplicate-username-and-id",
-			run: func(t *testing.T, db *gorm.DB) {
-				user := types.User{
-					Model: gorm.Model{ID: 1},
-					Name:  "user1",
-				}
-				user.ProviderIdentifier = sql.NullString{String: "http://test.com/user1", Valid: true}
-
-				err := db.Save(&user).Error
-				require.NoError(t, err)
-
-				user = types.User{
-					Model: gorm.Model{ID: 2},
-					Name:  "user1",
-				}
-				user.ProviderIdentifier = sql.NullString{String: "http://test.com/user1", Valid: true}
-
-				err = db.Save(&user).Error
-				requireConstraintFailed(t, err)
-			},
-		},
-		{
-			name: "no-oidc-duplicate-id",
-			run: func(t *testing.T, db *gorm.DB) {
-				user := types.User{
-					Model: gorm.Model{ID: 1},
-					Name:  "user1",
-				}
-				user.ProviderIdentifier = sql.NullString{String: "http://test.com/user1", Valid: true}
-
-				err := db.Save(&user).Error
-				require.NoError(t, err)
-
-				user = types.User{
-					Model: gorm.Model{ID: 2},
-					Name:  "user1.1",
-				}
-				user.ProviderIdentifier = sql.NullString{String: "http://test.com/user1", Valid: true}
-
-				err = db.Save(&user).Error
-				requireConstraintFailed(t, err)
-			},
-		},
-		{
-			name: "allow-duplicate-username-cli-then-oidc",
-			run: func(t *testing.T, db *gorm.DB) {
-				_, err := CreateUser(db, "user1") // Create CLI username
-				require.NoError(t, err)
-
-				user := types.User{
-					Name:               "user1",
-					ProviderIdentifier: sql.NullString{String: "http://test.com/user1", Valid: true},
-				}
-
-				err = db.Save(&user).Error
-				require.NoError(t, err)
-			},
-		},
-		{
-			name: "allow-duplicate-username-oidc-then-cli",
-			run: func(t *testing.T, db *gorm.DB) {
-				user := types.User{
-					Name:               "user1",
-					ProviderIdentifier: sql.NullString{String: "http://test.com/user1", Valid: true},
-				}
-
-				err := db.Save(&user).Error
-				require.NoError(t, err)
-
-				_, err = CreateUser(db, "user1") // Create CLI username
-				require.NoError(t, err)
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name+"-postgres", func(t *testing.T) {
-			db := newPostgresTestDB(t)
-			tt.run(t, db.DB.Debug())
-		})
-		t.Run(tt.name+"-sqlite", func(t *testing.T) {
-			db, err := newSQLiteTestDB()
-			if err != nil {
-				t.Fatalf("creating database: %s", err)
-			}
-
-			tt.run(t, db.DB.Debug())
-		})
-
-	}
-}
--- a/hscontrol/db/ip_test.go
+++ b/hscontrol/db/ip_test.go
@ -12,7 +12,6 @@ import (
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"tailscale.com/net/tsaddr"
 	"tailscale.com/types/ptr"
 )
@ -458,12 +457,7 @@ func TestBackfillIPAddresses(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			db := tt.dbFunc()

-			alloc, err := NewIPAllocator(
-				db,
-				tt.prefix4,
-				tt.prefix6,
-				types.IPAllocationStrategySequential,
-			)
+			alloc, err := NewIPAllocator(db, tt.prefix4, tt.prefix6, types.IPAllocationStrategySequential)
 			if err != nil {
 				t.Fatalf("failed to set up ip alloc: %s", err)
 			}
@ -488,29 +482,24 @@ func TestBackfillIPAddresses(t *testing.T) {
 }

 func TestIPAllocatorNextNoReservedIPs(t *testing.T) {
-	alloc, err := NewIPAllocator(
-		db,
-		ptr.To(tsaddr.CGNATRange()),
-		ptr.To(tsaddr.TailscaleULARange()),
-		types.IPAllocationStrategySequential,
-	)
+	alloc, err := NewIPAllocator(db, ptr.To(tsaddr.CGNATRange()), ptr.To(tsaddr.TailscaleULARange()), types.IPAllocationStrategySequential)
 	if err != nil {
 		t.Fatalf("failed to set up ip alloc: %s", err)
 	}

 	// Validate that we do not give out 100.100.100.100
 	nextQuad100, err := alloc.next(na("100.100.100.99"), ptr.To(tsaddr.CGNATRange()))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, na("100.100.100.101"), *nextQuad100)

 	// Validate that we do not give out fd7a:115c:a1e0::53
 	nextQuad100v6, err := alloc.next(na("fd7a:115c:a1e0::52"), ptr.To(tsaddr.TailscaleULARange()))
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, na("fd7a:115c:a1e0::54"), *nextQuad100v6)

 	// Validate that we do not give out fd7a:115c:a1e0::53
 	nextChrome, err := alloc.next(na("100.115.91.255"), ptr.To(tsaddr.CGNATRange()))
 	t.Logf("chrome: %s", nextChrome.String())
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, na("100.115.94.0"), *nextChrome)
 }
--- a/hscontrol/db/node.go
+++ b/hscontrol/db/node.go
@ -91,15 +91,15 @@ func (hsdb *HSDatabase) ListEphemeralNodes() (types.Nodes, error) {
 	})
 }

-func (hsdb *HSDatabase) getNode(uid types.UserID, name string) (*types.Node, error) {
+func (hsdb *HSDatabase) getNode(user string, name string) (*types.Node, error) {
 	return Read(hsdb.DB, func(rx *gorm.DB) (*types.Node, error) {
-		return getNode(rx, uid, name)
+		return getNode(rx, user, name)
 	})
 }

 // getNode finds a Node by name and user and returns the Node struct.
-func getNode(tx *gorm.DB, uid types.UserID, name string) (*types.Node, error) {
-	nodes, err := ListNodesByUser(tx, uid)
+func getNode(tx *gorm.DB, user string, name string) (*types.Node, error) {
+	nodes, err := ListNodesByUser(tx, user)
 	if err != nil {
 		return nil, err
 	}
--- a/hscontrol/db/node_test.go
+++ b/hscontrol/db/node_test.go
@ -17,7 +17,6 @@ import (
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/puzpuzpuz/xsync/v3"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"gopkg.in/check.v1"
 	"gorm.io/gorm"
 	"tailscale.com/net/tsaddr"
@ -30,10 +29,10 @@ func (s *Suite) TestGetNode(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "testnode")
+	_, err = db.getNode("test", "testnode")
 	c.Assert(err, check.NotNil)

 	nodeKey := key.NewNode()
@ -51,7 +50,7 @@ func (s *Suite) TestGetNode(c *check.C) {
 	trx := db.DB.Save(node)
 	c.Assert(trx.Error, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "testnode")
+	_, err = db.getNode("test", "testnode")
 	c.Assert(err, check.IsNil)
 }

@ -59,7 +58,7 @@ func (s *Suite) TestGetNodeByID(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	_, err = db.GetNodeByID(0)
@ -88,7 +87,7 @@ func (s *Suite) TestGetNodeByAnyNodeKey(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	_, err = db.GetNodeByID(0)
@ -136,7 +135,7 @@ func (s *Suite) TestHardDeleteNode(c *check.C) {
 	_, err = db.DeleteNode(&node, xsync.NewMapOf[types.NodeID, bool]())
 	c.Assert(err, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "testnode3")
+	_, err = db.getNode(user.Name, "testnode3")
 	c.Assert(err, check.NotNil)
 }

@ -144,7 +143,7 @@ func (s *Suite) TestListPeers(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	_, err = db.GetNodeByID(0)
@ -190,7 +189,7 @@ func (s *Suite) TestGetACLFilteredPeers(c *check.C) {
 	for _, name := range []string{"test", "admin"} {
 		user, err := db.CreateUser(name)
 		c.Assert(err, check.IsNil)
-		pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+		pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 		c.Assert(err, check.IsNil)
 		stor = append(stor, base{user, pak})
 	}
@ -256,10 +255,10 @@ func (s *Suite) TestGetACLFilteredPeers(c *check.C) {
 	c.Assert(err, check.IsNil)
 	c.Assert(len(testPeers), check.Equals, 9)

-	adminRules, _, err := policy.GenerateFilterAndSSHRulesForTests(aclPolicy, adminNode, adminPeers, []types.User{*stor[0].user, *stor[1].user})
+	adminRules, _, err := policy.GenerateFilterAndSSHRulesForTests(aclPolicy, adminNode, adminPeers)
 	c.Assert(err, check.IsNil)

-	testRules, _, err := policy.GenerateFilterAndSSHRulesForTests(aclPolicy, testNode, testPeers, []types.User{*stor[0].user, *stor[1].user})
+	testRules, _, err := policy.GenerateFilterAndSSHRulesForTests(aclPolicy, testNode, testPeers)
 	c.Assert(err, check.IsNil)

 	peersOfAdminNode := policy.FilterNodesByACL(adminNode, adminPeers, adminRules)
@ -282,10 +281,10 @@ func (s *Suite) TestExpireNode(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "testnode")
+	_, err = db.getNode("test", "testnode")
 	c.Assert(err, check.NotNil)

 	nodeKey := key.NewNode()
@ -303,7 +302,7 @@ func (s *Suite) TestExpireNode(c *check.C) {
 	}
 	db.DB.Save(node)

-	nodeFromDB, err := db.getNode(types.UserID(user.ID), "testnode")
+	nodeFromDB, err := db.getNode("test", "testnode")
 	c.Assert(err, check.IsNil)
 	c.Assert(nodeFromDB, check.NotNil)

@ -313,7 +312,7 @@ func (s *Suite) TestExpireNode(c *check.C) {
 	err = db.NodeSetExpiry(nodeFromDB.ID, now)
 	c.Assert(err, check.IsNil)

-	nodeFromDB, err = db.getNode(types.UserID(user.ID), "testnode")
+	nodeFromDB, err = db.getNode("test", "testnode")
 	c.Assert(err, check.IsNil)

 	c.Assert(nodeFromDB.IsExpired(), check.Equals, true)
@ -323,10 +322,10 @@ func (s *Suite) TestSetTags(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "testnode")
+	_, err = db.getNode("test", "testnode")
 	c.Assert(err, check.NotNil)

 	nodeKey := key.NewNode()
@ -349,7 +348,7 @@ func (s *Suite) TestSetTags(c *check.C) {
 	sTags := []string{"tag:test", "tag:foo"}
 	err = db.SetTags(node.ID, sTags)
 	c.Assert(err, check.IsNil)
-	node, err = db.getNode(types.UserID(user.ID), "testnode")
+	node, err = db.getNode("test", "testnode")
 	c.Assert(err, check.IsNil)
 	c.Assert(node.ForcedTags, check.DeepEquals, sTags)

@ -357,7 +356,7 @@ func (s *Suite) TestSetTags(c *check.C) {
 	eTags := []string{"tag:bar", "tag:test", "tag:unknown", "tag:test"}
 	err = db.SetTags(node.ID, eTags)
 	c.Assert(err, check.IsNil)
-	node, err = db.getNode(types.UserID(user.ID), "testnode")
+	node, err = db.getNode("test", "testnode")
 	c.Assert(err, check.IsNil)
 	c.Assert(
 		node.ForcedTags,
@ -368,7 +367,7 @@ func (s *Suite) TestSetTags(c *check.C) {
 	// test removing tags
 	err = db.SetTags(node.ID, []string{})
 	c.Assert(err, check.IsNil)
-	node, err = db.getNode(types.UserID(user.ID), "testnode")
+	node, err = db.getNode("test", "testnode")
 	c.Assert(err, check.IsNil)
 	c.Assert(node.ForcedTags, check.DeepEquals, []string{})
 }
@ -558,18 +557,18 @@ func TestAutoApproveRoutes(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			adb, err := newSQLiteTestDB()
-			require.NoError(t, err)
+			adb, err := newTestDB()
+			assert.NoError(t, err)
 			pol, err := policy.LoadACLPolicyFromBytes([]byte(tt.acl))

-			require.NoError(t, err)
+			assert.NoError(t, err)
 			assert.NotNil(t, pol)

 			user, err := adb.CreateUser("test")
-			require.NoError(t, err)
+			assert.NoError(t, err)

-			pak, err := adb.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
-			require.NoError(t, err)
+			pak, err := adb.CreatePreAuthKey(user.Name, false, false, nil, nil)
+			assert.NoError(t, err)

 			nodeKey := key.NewNode()
 			machineKey := key.NewMachine()
@ -591,21 +590,21 @@ func TestAutoApproveRoutes(t *testing.T) {
 			}

 			trx := adb.DB.Save(&node)
-			require.NoError(t, trx.Error)
+			assert.NoError(t, trx.Error)

 			sendUpdate, err := adb.SaveNodeRoutes(&node)
-			require.NoError(t, err)
+			assert.NoError(t, err)
 			assert.False(t, sendUpdate)

 			node0ByID, err := adb.GetNodeByID(0)
-			require.NoError(t, err)
+			assert.NoError(t, err)

 			// TODO(kradalby): Check state update
 			err = adb.EnableAutoApprovedRoutes(pol, node0ByID)
-			require.NoError(t, err)
+			assert.NoError(t, err)

 			enabledRoutes, err := adb.GetEnabledRoutes(node0ByID)
-			require.NoError(t, err)
+			assert.NoError(t, err)
 			assert.Len(t, enabledRoutes, len(tt.want))

 			tsaddr.SortPrefixes(enabledRoutes)
@ -692,19 +691,19 @@ func generateRandomNumber(t *testing.T, max int64) int64 {
 }

 func TestListEphemeralNodes(t *testing.T) {
-	db, err := newSQLiteTestDB()
+	db, err := newTestDB()
 	if err != nil {
 		t.Fatalf("creating db: %s", err)
 	}

 	user, err := db.CreateUser("test")
-	require.NoError(t, err)
+	assert.NoError(t, err)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
-	require.NoError(t, err)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
+	assert.NoError(t, err)

-	pakEph, err := db.CreatePreAuthKey(types.UserID(user.ID), false, true, nil, nil)
-	require.NoError(t, err)
+	pakEph, err := db.CreatePreAuthKey(user.Name, false, true, nil, nil)
+	assert.NoError(t, err)

 	node := types.Node{
 		ID:             0,
@ -727,16 +726,16 @@ func TestListEphemeralNodes(t *testing.T) {
 	}

 	err = db.DB.Save(&node).Error
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	err = db.DB.Save(&nodeEph).Error
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	nodes, err := db.ListNodes()
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	ephemeralNodes, err := db.ListEphemeralNodes()
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	assert.Len(t, nodes, 2)
 	assert.Len(t, ephemeralNodes, 1)
@ -748,16 +747,16 @@ func TestListEphemeralNodes(t *testing.T) {
 }

 func TestRenameNode(t *testing.T) {
-	db, err := newSQLiteTestDB()
+	db, err := newTestDB()
 	if err != nil {
 		t.Fatalf("creating db: %s", err)
 	}

 	user, err := db.CreateUser("test")
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	user2, err := db.CreateUser("test2")
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	node := types.Node{
 		ID:             0,
@ -778,10 +777,10 @@ func TestRenameNode(t *testing.T) {
 	}

 	err = db.DB.Save(&node).Error
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	err = db.DB.Save(&node2).Error
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	err = db.DB.Transaction(func(tx *gorm.DB) error {
 		_, err := RegisterNode(tx, node, nil, nil)
@ -791,10 +790,10 @@ func TestRenameNode(t *testing.T) {
 		_, err = RegisterNode(tx, node2, nil, nil)
 		return err
 	})
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	nodes, err := db.ListNodes()
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	assert.Len(t, nodes, 2)

@ -816,26 +815,26 @@ func TestRenameNode(t *testing.T) {
 	err = db.Write(func(tx *gorm.DB) error {
 		return RenameNode(tx, nodes[0].ID, "newname")
 	})
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	nodes, err = db.ListNodes()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, nodes, 2)
-	assert.Equal(t, "test", nodes[0].Hostname)
-	assert.Equal(t, "newname", nodes[0].GivenName)
+	assert.Equal(t, nodes[0].Hostname, "test")
+	assert.Equal(t, nodes[0].GivenName, "newname")

 	// Nodes can reuse name that is no longer used
 	err = db.Write(func(tx *gorm.DB) error {
 		return RenameNode(tx, nodes[1].ID, "test")
 	})
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	nodes, err = db.ListNodes()
-	require.NoError(t, err)
+	assert.NoError(t, err)
 	assert.Len(t, nodes, 2)
-	assert.Equal(t, "test", nodes[0].Hostname)
-	assert.Equal(t, "newname", nodes[0].GivenName)
-	assert.Equal(t, "test", nodes[1].GivenName)
+	assert.Equal(t, nodes[0].Hostname, "test")
+	assert.Equal(t, nodes[0].GivenName, "newname")
+	assert.Equal(t, nodes[1].GivenName, "test")

 	// Nodes cannot be renamed to used names
 	err = db.Write(func(tx *gorm.DB) error {
--- a/hscontrol/db/preauth_keys.go
+++ b/hscontrol/db/preauth_keys.go
@ -23,27 +23,29 @@ var (
 )

 func (hsdb *HSDatabase) CreatePreAuthKey(
-	uid types.UserID,
+	// TODO(kradalby): Should be ID, not name
+	userName string,
 	reusable bool,
 	ephemeral bool,
 	expiration *time.Time,
 	aclTags []string,
 ) (*types.PreAuthKey, error) {
 	return Write(hsdb.DB, func(tx *gorm.DB) (*types.PreAuthKey, error) {
-		return CreatePreAuthKey(tx, uid, reusable, ephemeral, expiration, aclTags)
+		return CreatePreAuthKey(tx, userName, reusable, ephemeral, expiration, aclTags)
 	})
 }

 // CreatePreAuthKey creates a new PreAuthKey in a user, and returns it.
 func CreatePreAuthKey(
 	tx *gorm.DB,
-	uid types.UserID,
+	// TODO(kradalby): Should be ID, not name
+	userName string,
 	reusable bool,
 	ephemeral bool,
 	expiration *time.Time,
 	aclTags []string,
 ) (*types.PreAuthKey, error) {
-	user, err := GetUserByID(tx, uid)
+	user, err := GetUserByUsername(tx, userName)
 	if err != nil {
 		return nil, err
 	}
@ -87,15 +89,15 @@ func CreatePreAuthKey(
 	return &key, nil
 }

-func (hsdb *HSDatabase) ListPreAuthKeys(uid types.UserID) ([]types.PreAuthKey, error) {
+func (hsdb *HSDatabase) ListPreAuthKeys(userName string) ([]types.PreAuthKey, error) {
 	return Read(hsdb.DB, func(rx *gorm.DB) ([]types.PreAuthKey, error) {
-		return ListPreAuthKeysByUser(rx, uid)
+		return ListPreAuthKeys(rx, userName)
 	})
 }

-// ListPreAuthKeysByUser returns the list of PreAuthKeys for a user.
-func ListPreAuthKeysByUser(tx *gorm.DB, uid types.UserID) ([]types.PreAuthKey, error) {
-	user, err := GetUserByID(tx, uid)
+// ListPreAuthKeys returns the list of PreAuthKeys for a user.
+func ListPreAuthKeys(tx *gorm.DB, userName string) ([]types.PreAuthKey, error) {
+	user, err := GetUserByUsername(tx, userName)
 	if err != nil {
 		return nil, err
 	}
--- a/hscontrol/db/preauth_keys_test.go
+++ b/hscontrol/db/preauth_keys_test.go
@ -11,14 +11,14 @@ import (
 )

 func (*Suite) TestCreatePreAuthKey(c *check.C) {
-	// ID does not exist
-	_, err := db.CreatePreAuthKey(12345, true, false, nil, nil)
+	_, err := db.CreatePreAuthKey("bogus", true, false, nil, nil)
+
 	c.Assert(err, check.NotNil)

 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	key, err := db.CreatePreAuthKey(types.UserID(user.ID), true, false, nil, nil)
+	key, err := db.CreatePreAuthKey(user.Name, true, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	// Did we get a valid key?
@ -26,18 +26,17 @@ func (*Suite) TestCreatePreAuthKey(c *check.C) {
 	c.Assert(len(key.Key), check.Equals, 48)

 	// Make sure the User association is populated
-	c.Assert(key.User.ID, check.Equals, user.ID)
+	c.Assert(key.User.Name, check.Equals, user.Name)

-	// ID does not exist
-	_, err = db.ListPreAuthKeys(1000000)
+	_, err = db.ListPreAuthKeys("bogus")
 	c.Assert(err, check.NotNil)

-	keys, err := db.ListPreAuthKeys(types.UserID(user.ID))
+	keys, err := db.ListPreAuthKeys(user.Name)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(keys), check.Equals, 1)

 	// Make sure the User association is populated
-	c.Assert((keys)[0].User.ID, check.Equals, user.ID)
+	c.Assert((keys)[0].User.Name, check.Equals, user.Name)
 }

 func (*Suite) TestExpiredPreAuthKey(c *check.C) {
@ -45,7 +44,7 @@ func (*Suite) TestExpiredPreAuthKey(c *check.C) {
 	c.Assert(err, check.IsNil)

 	now := time.Now().Add(-5 * time.Second)
-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), true, false, &now, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, true, false, &now, nil)
 	c.Assert(err, check.IsNil)

 	key, err := db.ValidatePreAuthKey(pak.Key)
@ -63,7 +62,7 @@ func (*Suite) TestValidateKeyOk(c *check.C) {
 	user, err := db.CreateUser("test3")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), true, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, true, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	key, err := db.ValidatePreAuthKey(pak.Key)
@ -75,7 +74,7 @@ func (*Suite) TestAlreadyUsedKey(c *check.C) {
 	user, err := db.CreateUser("test4")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	node := types.Node{
@ -97,7 +96,7 @@ func (*Suite) TestReusableBeingUsedKey(c *check.C) {
 	user, err := db.CreateUser("test5")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), true, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, true, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	node := types.Node{
@ -119,7 +118,7 @@ func (*Suite) TestNotReusableNotBeingUsedKey(c *check.C) {
 	user, err := db.CreateUser("test6")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	key, err := db.ValidatePreAuthKey(pak.Key)
@ -131,7 +130,7 @@ func (*Suite) TestExpirePreauthKey(c *check.C) {
 	user, err := db.CreateUser("test3")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), true, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, true, false, nil, nil)
 	c.Assert(err, check.IsNil)
 	c.Assert(pak.Expiration, check.IsNil)

@ -148,7 +147,7 @@ func (*Suite) TestNotReusableMarkedAsUsed(c *check.C) {
 	user, err := db.CreateUser("test6")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)
 	pak.Used = true
 	db.DB.Save(&pak)
@ -161,15 +160,15 @@ func (*Suite) TestPreAuthKeyACLTags(c *check.C) {
 	user, err := db.CreateUser("test8")
 	c.Assert(err, check.IsNil)

-	_, err = db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, []string{"badtag"})
+	_, err = db.CreatePreAuthKey(user.Name, false, false, nil, []string{"badtag"})
 	c.Assert(err, check.NotNil) // Confirm that malformed tags are rejected

 	tags := []string{"tag:test1", "tag:test2"}
 	tagsWithDuplicate := []string{"tag:test1", "tag:test2", "tag:test2"}
-	_, err = db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, tagsWithDuplicate)
+	_, err = db.CreatePreAuthKey(user.Name, false, false, nil, tagsWithDuplicate)
 	c.Assert(err, check.IsNil)

-	listedPaks, err := db.ListPreAuthKeys(types.UserID(user.ID))
+	listedPaks, err := db.ListPreAuthKeys("test8")
 	c.Assert(err, check.IsNil)
 	gotTags := listedPaks[0].Proto().GetAclTags()
 	sort.Sort(sort.StringSlice(gotTags))
--- a/hscontrol/db/routes.go
+++ b/hscontrol/db/routes.go
@ -639,7 +639,7 @@ func EnableAutoApprovedRoutes(

 		log.Trace().
 			Str("node", node.Hostname).
-			Uint("user.id", node.User.ID).
+			Str("user", node.User.Name).
 			Strs("routeApprovers", routeApprovers).
 			Str("prefix", netip.Prefix(advertisedRoute.Prefix).String()).
 			Msg("looking up route for autoapproving")
@ -648,13 +648,8 @@ func EnableAutoApprovedRoutes(
 			if approvedAlias == node.User.Username() {
 				approvedRoutes = append(approvedRoutes, advertisedRoute)
 			} else {
-				users, err := ListUsers(tx)
-				if err != nil {
-					return fmt.Errorf("looking up users to expand route alias: %w", err)
-				}
-
 				// TODO(kradalby): figure out how to get this to depend on less stuff
-				approvedIps, err := aclPolicy.ExpandAlias(types.Nodes{node}, users, approvedAlias)
+				approvedIps, err := aclPolicy.ExpandAlias(types.Nodes{node}, approvedAlias)
 				if err != nil {
 					return fmt.Errorf("expanding alias %q for autoApprovers: %w", approvedAlias, err)
 				}
--- a/hscontrol/db/routes_test.go
+++ b/hscontrol/db/routes_test.go
@ -35,10 +35,10 @@ func (s *Suite) TestGetRoutes(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "test_get_route_node")
+	_, err = db.getNode("test", "test_get_route_node")
 	c.Assert(err, check.NotNil)

 	route, err := netip.ParsePrefix("10.0.0.0/24")
@ -79,10 +79,10 @@ func (s *Suite) TestGetEnableRoutes(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "test_enable_route_node")
+	_, err = db.getNode("test", "test_enable_route_node")
 	c.Assert(err, check.NotNil)

 	route, err := netip.ParsePrefix(
@ -153,10 +153,10 @@ func (s *Suite) TestIsUniquePrefix(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "test_enable_route_node")
+	_, err = db.getNode("test", "test_enable_route_node")
 	c.Assert(err, check.NotNil)

 	route, err := netip.ParsePrefix(
@ -234,10 +234,10 @@ func (s *Suite) TestDeleteRoutes(c *check.C) {
 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

-	_, err = db.getNode(types.UserID(user.ID), "test_enable_route_node")
+	_, err = db.getNode("test", "test_enable_route_node")
 	c.Assert(err, check.NotNil)

 	prefix, err := netip.ParsePrefix(
--- a/hscontrol/db/suite_test.go
+++ b/hscontrol/db/suite_test.go
@ -1,17 +1,12 @@
 package db

 import (
-	"context"
 	"log"
-	"net/url"
 	"os"
-	"strconv"
-	"strings"
 	"testing"

 	"github.com/juanfont/headscale/hscontrol/types"
 	"gopkg.in/check.v1"
-	"zombiezen.com/go/postgrestest"
 )

 func Test(t *testing.T) {
@ -41,15 +36,13 @@ func (s *Suite) ResetDB(c *check.C) {
 	// }

 	var err error
-	db, err = newSQLiteTestDB()
+	db, err = newTestDB()
 	if err != nil {
 		c.Fatal(err)
 	}
 }

-// TODO(kradalby): make this a t.Helper when we dont depend
-// on check test framework.
-func newSQLiteTestDB() (*HSDatabase, error) {
+func newTestDB() (*HSDatabase, error) {
 	var err error
 	tmpDir, err = os.MkdirTemp("", "headscale-db-test-*")
 	if err != nil {
@ -60,7 +53,7 @@ func newSQLiteTestDB() (*HSDatabase, error) {

 	db, err = NewHeadscaleDatabase(
 		types.DatabaseConfig{
-			Type: types.DatabaseSqlite,
+			Type: "sqlite3",
 			Sqlite: types.SqliteConfig{
 				Path: tmpDir + "/headscale_test.db",
 			},
@ -74,53 +67,3 @@ func newSQLiteTestDB() (*HSDatabase, error) {

 	return db, nil
 }
-
-func newPostgresTestDB(t *testing.T) *HSDatabase {
-	t.Helper()
-
-	var err error
-	tmpDir, err = os.MkdirTemp("", "headscale-db-test-*")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	log.Printf("database path: %s", tmpDir+"/headscale_test.db")
-
-	ctx := context.Background()
-	srv, err := postgrestest.Start(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(srv.Cleanup)
-
-	u, err := srv.CreateDatabase(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Logf("created local postgres: %s", u)
-	pu, _ := url.Parse(u)
-
-	pass, _ := pu.User.Password()
-	port, _ := strconv.Atoi(pu.Port())
-
-	db, err = NewHeadscaleDatabase(
-		types.DatabaseConfig{
-			Type: types.DatabasePostgres,
-			Postgres: types.PostgresConfig{
-				Host: pu.Hostname(),
-				User: pu.User.Username(),
-				Name: strings.TrimLeft(pu.Path, "/"),
-				Pass: pass,
-				Port: port,
-				Ssl:  "disable",
-			},
-		},
-		"",
-		emptyCache(),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return db
-}
--- a/hscontrol/db/users.go
+++ b/hscontrol/db/users.go
@ -28,9 +28,11 @@ func CreateUser(tx *gorm.DB, name string) (*types.User, error) {
 	if err != nil {
 		return nil, err
 	}
-	user := types.User{
-		Name: name,
+	user := types.User{}
+	if err := tx.Where("name = ?", name).First(&user).Error; err == nil {
+		return nil, ErrUserExists
 	}
+	user.Name = name
 	if err := tx.Create(&user).Error; err != nil {
 		return nil, fmt.Errorf("creating user: %w", err)
 	}
@ -38,21 +40,21 @@ func CreateUser(tx *gorm.DB, name string) (*types.User, error) {
 	return &user, nil
 }

-func (hsdb *HSDatabase) DestroyUser(uid types.UserID) error {
+func (hsdb *HSDatabase) DestroyUser(name string) error {
 	return hsdb.Write(func(tx *gorm.DB) error {
-		return DestroyUser(tx, uid)
+		return DestroyUser(tx, name)
 	})
 }

 // DestroyUser destroys a User. Returns error if the User does
 // not exist or if there are nodes associated with it.
-func DestroyUser(tx *gorm.DB, uid types.UserID) error {
-	user, err := GetUserByID(tx, uid)
+func DestroyUser(tx *gorm.DB, name string) error {
+	user, err := GetUserByUsername(tx, name)
 	if err != nil {
-		return err
+		return ErrUserNotFound
 	}

-	nodes, err := ListNodesByUser(tx, uid)
+	nodes, err := ListNodesByUser(tx, name)
 	if err != nil {
 		return err
 	}
@ -60,7 +62,7 @@ func DestroyUser(tx *gorm.DB, uid types.UserID) error {
 		return ErrUserStillHasNodes
 	}

-	keys, err := ListPreAuthKeysByUser(tx, uid)
+	keys, err := ListPreAuthKeys(tx, name)
 	if err != nil {
 		return err
 	}
@ -78,17 +80,17 @@ func DestroyUser(tx *gorm.DB, uid types.UserID) error {
 	return nil
 }

-func (hsdb *HSDatabase) RenameUser(uid types.UserID, newName string) error {
+func (hsdb *HSDatabase) RenameUser(oldName, newName string) error {
 	return hsdb.Write(func(tx *gorm.DB) error {
-		return RenameUser(tx, uid, newName)
+		return RenameUser(tx, oldName, newName)
 	})
 }

 // RenameUser renames a User. Returns error if the User does
 // not exist or if another User exists with the new name.
-func RenameUser(tx *gorm.DB, uid types.UserID, newName string) error {
+func RenameUser(tx *gorm.DB, oldName, newName string) error {
 	var err error
-	oldUser, err := GetUserByID(tx, uid)
+	oldUser, err := GetUserByUsername(tx, oldName)
 	if err != nil {
 		return err
 	}
@ -96,25 +98,50 @@ func RenameUser(tx *gorm.DB, uid types.UserID, newName string) error {
 	if err != nil {
 		return err
 	}
+	_, err = GetUserByUsername(tx, newName)
+	if err == nil {
+		return ErrUserExists
+	}
+	if !errors.Is(err, ErrUserNotFound) {
+		return err
+	}

 	oldUser.Name = newName

-	if err := tx.Save(&oldUser).Error; err != nil {
-		return err
+	if result := tx.Save(&oldUser); result.Error != nil {
+		return result.Error
 	}

 	return nil
 }

-func (hsdb *HSDatabase) GetUserByID(uid types.UserID) (*types.User, error) {
+func (hsdb *HSDatabase) GetUserByName(name string) (*types.User, error) {
 	return Read(hsdb.DB, func(rx *gorm.DB) (*types.User, error) {
-		return GetUserByID(rx, uid)
+		return GetUserByUsername(rx, name)
 	})
 }

-func GetUserByID(tx *gorm.DB, uid types.UserID) (*types.User, error) {
+func GetUserByUsername(tx *gorm.DB, name string) (*types.User, error) {
 	user := types.User{}
-	if result := tx.First(&user, "id = ?", uid); errors.Is(
+	if result := tx.First(&user, "name = ?", name); errors.Is(
+		result.Error,
+		gorm.ErrRecordNotFound,
+	) {
+		return nil, ErrUserNotFound
+	}
+
+	return &user, nil
+}
+
+func (hsdb *HSDatabase) GetUserByID(id types.UserID) (*types.User, error) {
+	return Read(hsdb.DB, func(rx *gorm.DB) (*types.User, error) {
+		return GetUserByID(rx, id)
+	})
+}
+
+func GetUserByID(tx *gorm.DB, id types.UserID) (*types.User, error) {
+	user := types.User{}
+	if result := tx.First(&user, "id = ?", id); errors.Is(
 		result.Error,
 		gorm.ErrRecordNotFound,
 	) {
@ -142,69 +169,54 @@ func GetUserByOIDCIdentifier(tx *gorm.DB, id string) (*types.User, error) {
 	return &user, nil
 }

-func (hsdb *HSDatabase) ListUsers(where ...*types.User) ([]types.User, error) {
+func (hsdb *HSDatabase) ListUsers() ([]types.User, error) {
 	return Read(hsdb.DB, func(rx *gorm.DB) ([]types.User, error) {
-		return ListUsers(rx, where...)
+		return ListUsers(rx)
 	})
 }

 // ListUsers gets all the existing users.
-func ListUsers(tx *gorm.DB, where ...*types.User) ([]types.User, error) {
-	if len(where) > 1 {
-		return nil, fmt.Errorf("expect 0 or 1 where User structs, got %d", len(where))
-	}
-
-	var user *types.User
-	if len(where) == 1 {
-		user = where[0]
-	}
-
+func ListUsers(tx *gorm.DB) ([]types.User, error) {
 	users := []types.User{}
-	if err := tx.Where(user).Find(&users).Error; err != nil {
+	if err := tx.Find(&users).Error; err != nil {
 		return nil, err
 	}

 	return users, nil
 }

-// GetUserByName returns a user if the provided username is
-// unique, and otherwise an error.
-func (hsdb *HSDatabase) GetUserByName(name string) (*types.User, error) {
-	users, err := hsdb.ListUsers(&types.User{Name: name})
+// ListNodesByUser gets all the nodes in a given user.
+func ListNodesByUser(tx *gorm.DB, name string) (types.Nodes, error) {
+	err := util.CheckForFQDNRules(name)
+	if err != nil {
+		return nil, err
+	}
+	user, err := GetUserByUsername(tx, name)
 	if err != nil {
 		return nil, err
 	}

-	if len(users) == 0 {
-		return nil, ErrUserNotFound
-	}
-
-	if len(users) != 1 {
-		return nil, fmt.Errorf("expected exactly one user, found %d", len(users))
-	}
-
-	return &users[0], nil
-}
-
-// ListNodesByUser gets all the nodes in a given user.
-func ListNodesByUser(tx *gorm.DB, uid types.UserID) (types.Nodes, error) {
 	nodes := types.Nodes{}
-	if err := tx.Preload("AuthKey").Preload("AuthKey.User").Preload("User").Where(&types.Node{UserID: uint(uid)}).Find(&nodes).Error; err != nil {
+	if err := tx.Preload("AuthKey").Preload("AuthKey.User").Preload("User").Where(&types.Node{UserID: user.ID}).Find(&nodes).Error; err != nil {
 		return nil, err
 	}

 	return nodes, nil
 }

-func (hsdb *HSDatabase) AssignNodeToUser(node *types.Node, uid types.UserID) error {
+func (hsdb *HSDatabase) AssignNodeToUser(node *types.Node, username string) error {
 	return hsdb.Write(func(tx *gorm.DB) error {
-		return AssignNodeToUser(tx, node, uid)
+		return AssignNodeToUser(tx, node, username)
 	})
 }

 // AssignNodeToUser assigns a Node to a user.
-func AssignNodeToUser(tx *gorm.DB, node *types.Node, uid types.UserID) error {
-	user, err := GetUserByID(tx, uid)
+func AssignNodeToUser(tx *gorm.DB, node *types.Node, username string) error {
+	err := util.CheckForFQDNRules(username)
+	if err != nil {
+		return err
+	}
+	user, err := GetUserByUsername(tx, username)
 	if err != nil {
 		return err
 	}
--- a/hscontrol/db/users_test.go
+++ b/hscontrol/db/users_test.go
@ -1,8 +1,6 @@
 package db

 import (
-	"strings"
-
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/juanfont/headscale/hscontrol/util"
 	"gopkg.in/check.v1"
@ -19,24 +17,24 @@ func (s *Suite) TestCreateAndDestroyUser(c *check.C) {
 	c.Assert(err, check.IsNil)
 	c.Assert(len(users), check.Equals, 1)

-	err = db.DestroyUser(types.UserID(user.ID))
+	err = db.DestroyUser("test")
 	c.Assert(err, check.IsNil)

-	_, err = db.GetUserByID(types.UserID(user.ID))
+	_, err = db.GetUserByName("test")
 	c.Assert(err, check.NotNil)
 }

 func (s *Suite) TestDestroyUserErrors(c *check.C) {
-	err := db.DestroyUser(9998)
+	err := db.DestroyUser("test")
 	c.Assert(err, check.Equals, ErrUserNotFound)

 	user, err := db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

-	err = db.DestroyUser(types.UserID(user.ID))
+	err = db.DestroyUser("test")
 	c.Assert(err, check.IsNil)

 	result := db.DB.Preload("User").First(&pak, "key = ?", pak.Key)
@ -46,7 +44,7 @@ func (s *Suite) TestDestroyUserErrors(c *check.C) {
 	user, err = db.CreateUser("test")
 	c.Assert(err, check.IsNil)

-	pak, err = db.CreatePreAuthKey(types.UserID(user.ID), false, false, nil, nil)
+	pak, err = db.CreatePreAuthKey(user.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	node := types.Node{
@ -59,7 +57,7 @@ func (s *Suite) TestDestroyUserErrors(c *check.C) {
 	trx := db.DB.Save(&node)
 	c.Assert(trx.Error, check.IsNil)

-	err = db.DestroyUser(types.UserID(user.ID))
+	err = db.DestroyUser("test")
 	c.Assert(err, check.Equals, ErrUserStillHasNodes)
 }

@ -72,29 +70,24 @@ func (s *Suite) TestRenameUser(c *check.C) {
 	c.Assert(err, check.IsNil)
 	c.Assert(len(users), check.Equals, 1)

-	err = db.RenameUser(types.UserID(userTest.ID), "test-renamed")
+	err = db.RenameUser("test", "test-renamed")
 	c.Assert(err, check.IsNil)

-	users, err = db.ListUsers(&types.User{Name: "test"})
-	c.Assert(err, check.Equals, nil)
-	c.Assert(len(users), check.Equals, 0)
+	_, err = db.GetUserByName("test")
+	c.Assert(err, check.Equals, ErrUserNotFound)

-	users, err = db.ListUsers(&types.User{Name: "test-renamed"})
+	_, err = db.GetUserByName("test-renamed")
 	c.Assert(err, check.IsNil)
-	c.Assert(len(users), check.Equals, 1)

-	err = db.RenameUser(99988, "test")
+	err = db.RenameUser("test-does-not-exit", "test")
 	c.Assert(err, check.Equals, ErrUserNotFound)

 	userTest2, err := db.CreateUser("test2")
 	c.Assert(err, check.IsNil)
 	c.Assert(userTest2.Name, check.Equals, "test2")

-	want := "UNIQUE constraint failed"
-	err = db.RenameUser(types.UserID(userTest2.ID), "test-renamed")
-	if err == nil || !strings.Contains(err.Error(), want) {
-		c.Fatalf("expected failure with unique constraint, want: %q got: %q", want, err)
-	}
+	err = db.RenameUser("test2", "test-renamed")
+	c.Assert(err, check.Equals, ErrUserExists)
 }

 func (s *Suite) TestSetMachineUser(c *check.C) {
@ -104,7 +97,7 @@ func (s *Suite) TestSetMachineUser(c *check.C) {
 	newUser, err := db.CreateUser("new")
 	c.Assert(err, check.IsNil)

-	pak, err := db.CreatePreAuthKey(types.UserID(oldUser.ID), false, false, nil, nil)
+	pak, err := db.CreatePreAuthKey(oldUser.Name, false, false, nil, nil)
 	c.Assert(err, check.IsNil)

 	node := types.Node{
@ -118,15 +111,15 @@ func (s *Suite) TestSetMachineUser(c *check.C) {
 	c.Assert(trx.Error, check.IsNil)
 	c.Assert(node.UserID, check.Equals, oldUser.ID)

-	err = db.AssignNodeToUser(&node, types.UserID(newUser.ID))
+	err = db.AssignNodeToUser(&node, newUser.Name)
 	c.Assert(err, check.IsNil)
 	c.Assert(node.UserID, check.Equals, newUser.ID)
 	c.Assert(node.User.Name, check.Equals, newUser.Name)

-	err = db.AssignNodeToUser(&node, 9584849)
+	err = db.AssignNodeToUser(&node, "non-existing-user")
 	c.Assert(err, check.Equals, ErrUserNotFound)

-	err = db.AssignNodeToUser(&node, types.UserID(newUser.ID))
+	err = db.AssignNodeToUser(&node, newUser.Name)
 	c.Assert(err, check.IsNil)
 	c.Assert(node.UserID, check.Equals, newUser.ID)
 	c.Assert(node.User.Name, check.Equals, newUser.Name)
--- a/hscontrol/grpcv1.go
+++ b/hscontrol/grpcv1.go
@ -65,34 +65,24 @@ func (api headscaleV1APIServer) RenameUser(
 	ctx context.Context,
 	request *v1.RenameUserRequest,
 ) (*v1.RenameUserResponse, error) {
-	oldUser, err := api.h.db.GetUserByName(request.GetOldName())
+	err := api.h.db.RenameUser(request.GetOldName(), request.GetNewName())
 	if err != nil {
 		return nil, err
 	}

-	err = api.h.db.RenameUser(types.UserID(oldUser.ID), request.GetNewName())
+	user, err := api.h.db.GetUserByName(request.GetNewName())
 	if err != nil {
 		return nil, err
 	}

-	newUser, err := api.h.db.GetUserByName(request.GetNewName())
-	if err != nil {
-		return nil, err
-	}
-
-	return &v1.RenameUserResponse{User: newUser.Proto()}, nil
+	return &v1.RenameUserResponse{User: user.Proto()}, nil
 }

 func (api headscaleV1APIServer) DeleteUser(
 	ctx context.Context,
 	request *v1.DeleteUserRequest,
 ) (*v1.DeleteUserResponse, error) {
-	user, err := api.h.db.GetUserByName(request.GetName())
-	if err != nil {
-		return nil, err
-	}
-
-	err = api.h.db.DestroyUser(types.UserID(user.ID))
+	err := api.h.db.DestroyUser(request.GetName())
 	if err != nil {
 		return nil, err
 	}
@ -141,13 +131,8 @@ func (api headscaleV1APIServer) CreatePreAuthKey(
 		}
 	}

-	user, err := api.h.db.GetUserByName(request.GetUser())
-	if err != nil {
-		return nil, err
-	}
-
 	preAuthKey, err := api.h.db.CreatePreAuthKey(
-		types.UserID(user.ID),
+		request.GetUser(),
 		request.GetReusable(),
 		request.GetEphemeral(),
 		&expiration,
@ -183,12 +168,7 @@ func (api headscaleV1APIServer) ListPreAuthKeys(
 	ctx context.Context,
 	request *v1.ListPreAuthKeysRequest,
 ) (*v1.ListPreAuthKeysResponse, error) {
-	user, err := api.h.db.GetUserByName(request.GetUser())
-	if err != nil {
-		return nil, err
-	}
-
-	preAuthKeys, err := api.h.db.ListPreAuthKeys(types.UserID(user.ID))
+	preAuthKeys, err := api.h.db.ListPreAuthKeys(request.GetUser())
 	if err != nil {
 		return nil, err
 	}
@ -426,20 +406,10 @@ func (api headscaleV1APIServer) ListNodes(
 	ctx context.Context,
 	request *v1.ListNodesRequest,
 ) (*v1.ListNodesResponse, error) {
-	// TODO(kradalby): it looks like this can be simplified a lot,
-	// the filtering of nodes by user, vs nodes as a whole can
-	// probably be done once.
-	// TODO(kradalby): This should be done in one tx.
-
 	isLikelyConnected := api.h.nodeNotifier.LikelyConnectedMap()
 	if request.GetUser() != "" {
-		user, err := api.h.db.GetUserByName(request.GetUser())
-		if err != nil {
-			return nil, err
-		}
-
 		nodes, err := db.Read(api.h.db.DB, func(rx *gorm.DB) (types.Nodes, error) {
-			return db.ListNodesByUser(rx, types.UserID(user.ID))
+			return db.ListNodesByUser(rx, request.GetUser())
 		})
 		if err != nil {
 			return nil, err
@ -495,18 +465,12 @@ func (api headscaleV1APIServer) MoveNode(
 	ctx context.Context,
 	request *v1.MoveNodeRequest,
 ) (*v1.MoveNodeResponse, error) {
-	// TODO(kradalby): This should be done in one tx.
 	node, err := api.h.db.GetNodeByID(types.NodeID(request.GetNodeId()))
 	if err != nil {
 		return nil, err
 	}

-	user, err := api.h.db.GetUserByName(request.GetUser())
-	if err != nil {
-		return nil, err
-	}
-
-	err = api.h.db.AssignNodeToUser(node, types.UserID(user.ID))
+	err = api.h.db.AssignNodeToUser(node, request.GetUser())
 	if err != nil {
 		return nil, err
 	}
@ -773,18 +737,14 @@ func (api headscaleV1APIServer) SetPolicy(
 	if err != nil {
 		return nil, fmt.Errorf("loading nodes from database to validate policy: %w", err)
 	}
-	users, err := api.h.db.ListUsers()
-	if err != nil {
-		return nil, fmt.Errorf("loading users from database to validate policy: %w", err)
-	}

-	_, err = pol.CompileFilterRules(users, nodes)
+	_, err = pol.CompileFilterRules(nodes)
 	if err != nil {
 		return nil, fmt.Errorf("verifying policy rules: %w", err)
 	}

 	if len(nodes) > 0 {
-		_, err = pol.CompileSSHPolicy(nodes[0], users, nodes)
+		_, err = pol.CompileSSHPolicy(nodes[0], nodes)
 		if err != nil {
 			return nil, fmt.Errorf("verifying SSH rules: %w", err)
 		}
--- a/hscontrol/handlers.go
+++ b/hscontrol/handlers.go
@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
 	"net/http"
 	"strconv"
 	"strings"
@ -57,65 +56,6 @@ func parseCabailityVersion(req *http.Request) (tailcfg.CapabilityVersion, error)
 	return tailcfg.CapabilityVersion(clientCapabilityVersion), nil
 }

-func (h *Headscale) handleVerifyRequest(
-	req *http.Request,
-) (bool, error) {
-	body, err := io.ReadAll(req.Body)
-	if err != nil {
-		return false, fmt.Errorf("cannot read request body: %w", err)
-	}
-
-	var derpAdmitClientRequest tailcfg.DERPAdmitClientRequest
-	if err := json.Unmarshal(body, &derpAdmitClientRequest); err != nil {
-		return false, fmt.Errorf("cannot parse derpAdmitClientRequest: %w", err)
-	}
-
-	nodes, err := h.db.ListNodes()
-	if err != nil {
-		return false, fmt.Errorf("cannot list nodes: %w", err)
-	}
-
-	return nodes.ContainsNodeKey(derpAdmitClientRequest.NodePublic), nil
-}
-
-// see https://github.com/tailscale/tailscale/blob/964282d34f06ecc06ce644769c66b0b31d118340/derp/derp_server.go#L1159, Derp use verifyClientsURL to verify whether a client is allowed to connect to the DERP server.
-func (h *Headscale) VerifyHandler(
-	writer http.ResponseWriter,
-	req *http.Request,
-) {
-	if req.Method != http.MethodPost {
-		http.Error(writer, "Wrong method", http.StatusMethodNotAllowed)
-
-		return
-	}
-	log.Debug().
-		Str("handler", "/verify").
-		Msg("verify client")
-
-	allow, err := h.handleVerifyRequest(req)
-	if err != nil {
-		log.Error().
-			Caller().
-			Err(err).
-			Msg("Failed to verify client")
-		http.Error(writer, "Internal error", http.StatusInternalServerError)
-	}
-
-	resp := tailcfg.DERPAdmitClientResponse{
-		Allow: allow,
-	}
-
-	writer.Header().Set("Content-Type", "application/json")
-	writer.WriteHeader(http.StatusOK)
-	err = json.NewEncoder(writer).Encode(resp)
-	if err != nil {
-		log.Error().
-			Caller().
-			Err(err).
-			Msg("Failed to write response")
-	}
-}
-
 // KeyHandler provides the Headscale pub key
 // Listens in /key.
 func (h *Headscale) KeyHandler(
--- a/hscontrol/mapper/mapper.go
+++ b/hscontrol/mapper/mapper.go
@ -153,7 +153,6 @@ func addNextDNSMetadata(resolvers []*dnstype.Resolver, node *types.Node) {
 func (m *Mapper) fullMapResponse(
 	node *types.Node,
 	peers types.Nodes,
-	users []types.User,
 	pol *policy.ACLPolicy,
 	capVer tailcfg.CapabilityVersion,
 ) (*tailcfg.MapResponse, error) {
@ -168,7 +167,6 @@ func (m *Mapper) fullMapResponse(
 		pol,
 		node,
 		capVer,
-		users,
 		peers,
 		peers,
 		m.cfg,
@ -191,12 +189,8 @@ func (m *Mapper) FullMapResponse(
 	if err != nil {
 		return nil, err
 	}
-	users, err := m.db.ListUsers()
-	if err != nil {
-		return nil, err
-	}

-	resp, err := m.fullMapResponse(node, peers, users, pol, mapRequest.Version)
+	resp, err := m.fullMapResponse(node, peers, pol, mapRequest.Version)
 	if err != nil {
 		return nil, err
 	}
@ -259,11 +253,6 @@ func (m *Mapper) PeerChangedResponse(
 		return nil, err
 	}

-	users, err := m.db.ListUsers()
-	if err != nil {
-		return nil, fmt.Errorf("listing users for map response: %w", err)
-	}
-
 	var removedIDs []tailcfg.NodeID
 	var changedIDs []types.NodeID
 	for nodeID, nodeChanged := range changed {
@ -287,7 +276,6 @@ func (m *Mapper) PeerChangedResponse(
 		pol,
 		node,
 		mapRequest.Version,
-		users,
 		peers,
 		changedNodes,
 		m.cfg,
@ -520,17 +508,16 @@ func appendPeerChanges(
 	pol *policy.ACLPolicy,
 	node *types.Node,
 	capVer tailcfg.CapabilityVersion,
-	users []types.User,
 	peers types.Nodes,
 	changed types.Nodes,
 	cfg *types.Config,
 ) error {
-	packetFilter, err := pol.CompileFilterRules(users, append(peers, node))
+	packetFilter, err := pol.CompileFilterRules(append(peers, node))
 	if err != nil {
 		return err
 	}

-	sshPolicy, err := pol.CompileSSHPolicy(node, users, peers)
+	sshPolicy, err := pol.CompileSSHPolicy(node, peers)
 	if err != nil {
 		return err
 	}
--- a/hscontrol/mapper/mapper_test.go
+++ b/hscontrol/mapper/mapper_test.go
@ -159,9 +159,6 @@ func Test_fullMapResponse(t *testing.T) {
 	lastSeen := time.Date(2009, time.November, 10, 23, 9, 0, 0, time.UTC)
 	expire := time.Date(2500, time.November, 11, 23, 0, 0, 0, time.UTC)

-	user1 := types.User{Model: gorm.Model{ID: 0}, Name: "mini"}
-	user2 := types.User{Model: gorm.Model{ID: 1}, Name: "peer2"}
-
 	mini := &types.Node{
 		ID: 0,
 		MachineKey: mustMK(
@ -176,8 +173,8 @@ func Test_fullMapResponse(t *testing.T) {
 		IPv4:       iap("100.64.0.1"),
 		Hostname:   "mini",
 		GivenName:  "mini",
-		UserID:     user1.ID,
-		User:       user1,
+		UserID:     0,
+		User:       types.User{Name: "mini"},
 		ForcedTags: []string{},
 		AuthKey:    &types.PreAuthKey{},
 		LastSeen:   &lastSeen,
@ -256,8 +253,8 @@ func Test_fullMapResponse(t *testing.T) {
 		IPv4:       iap("100.64.0.2"),
 		Hostname:   "peer1",
 		GivenName:  "peer1",
-		UserID:     user1.ID,
-		User:       user1,
+		UserID:     0,
+		User:       types.User{Name: "mini"},
 		ForcedTags: []string{},
 		LastSeen:   &lastSeen,
 		Expiry:     &expire,
@ -311,8 +308,8 @@ func Test_fullMapResponse(t *testing.T) {
 		IPv4:       iap("100.64.0.3"),
 		Hostname:   "peer2",
 		GivenName:  "peer2",
-		UserID:     user2.ID,
-		User:       user2,
+		UserID:     1,
+		User:       types.User{Name: "peer2"},
 		ForcedTags: []string{},
 		LastSeen:   &lastSeen,
 		Expiry:     &expire,
@ -471,7 +468,6 @@ func Test_fullMapResponse(t *testing.T) {
 			got, err := mappy.fullMapResponse(
 				tt.node,
 				tt.peers,
-				[]types.User{user1, user2},
 				tt.pol,
 				0,
 			)
--- a/hscontrol/oidc.go
+++ b/hscontrol/oidc.go
@ -436,41 +436,24 @@ func (a *AuthProviderOIDC) createOrUpdateUserFromClaim(
 ) (*types.User, error) {
 	var user *types.User
 	var err error
-	user, err = a.db.GetUserByOIDCIdentifier(claims.Identifier())
+	user, err = a.db.GetUserByOIDCIdentifier(claims.Sub)
 	if err != nil && !errors.Is(err, db.ErrUserNotFound) {
 		return nil, fmt.Errorf("creating or updating user: %w", err)
 	}

 	// This check is for legacy, if the user cannot be found by the OIDC identifier
 	// look it up by username. This should only be needed once.
-	// This branch will presist for a number of versions after the OIDC migration and
-	// then be removed following a deprecation.
-	// TODO(kradalby): Remove when strip_email_domain and migration is removed
-	// after #2170 is cleaned up.
-	if a.cfg.MapLegacyUsers && user == nil {
-		log.Trace().Str("username", claims.Username).Str("sub", claims.Sub).Msg("user not found by OIDC identifier, looking up by username")
-		if oldUsername, err := getUserName(claims, a.cfg.StripEmaildomain); err == nil {
-			log.Trace().Str("old_username", oldUsername).Str("sub", claims.Sub).Msg("found username")
-			user, err = a.db.GetUserByName(oldUsername)
+	if user == nil {
+		user, err = a.db.GetUserByName(claims.Username)
 		if err != nil && !errors.Is(err, db.ErrUserNotFound) {
-				return nil, fmt.Errorf("getting user: %w", err)
-			}
-
-			// If the user exists, but it already has a provider identifier (OIDC sub), create a new user.
-			// This is to prevent users that have already been migrated to the new OIDC format
-			// to be updated with the new OIDC identifier inexplicitly which might be the cause of an
-			// account takeover.
-			if user != nil && user.ProviderIdentifier.Valid {
-				log.Info().Str("username", claims.Username).Str("sub", claims.Sub).Msg("user found by username, but has provider identifier, creating new user.")
-				user = &types.User{}
-			}
-		}
+			return nil, fmt.Errorf("creating or updating user: %w", err)
 		}

 		// if the user is still not found, create a new empty user.
 		if user == nil {
 			user = &types.User{}
 		}
+	}

 	user.FromClaim(claims)
 	err = a.db.DB.Save(user).Error
@ -505,7 +488,7 @@ func (a *AuthProviderOIDC) registerNode(
 }

 // TODO(kradalby):
-// Rewrite in elem-go.
+// Rewrite in elem-go
 func renderOIDCCallbackTemplate(
 	user *types.User,
 ) (*bytes.Buffer, error) {
@ -519,24 +502,3 @@ func renderOIDCCallbackTemplate(

 	return &content, nil
 }
-
-// TODO(kradalby): Reintroduce when strip_email_domain is removed
-// after #2170 is cleaned up
-// DEPRECATED: DO NOT USE
-func getUserName(
-	claims *types.OIDCClaims,
-	stripEmaildomain bool,
-) (string, error) {
-	if !claims.EmailVerified {
-		return "", fmt.Errorf("email not verified")
-	}
-	userName, err := util.NormalizeToFQDNRules(
-		claims.Email,
-		stripEmaildomain,
-	)
-	if err != nil {
-		return "", err
-	}
-
-	return userName, nil
-}
--- a/hscontrol/policy/acls.go
+++ b/hscontrol/policy/acls.go
@ -137,21 +137,20 @@ func GenerateFilterAndSSHRulesForTests(
 	policy *ACLPolicy,
 	node *types.Node,
 	peers types.Nodes,
-	users []types.User,
 ) ([]tailcfg.FilterRule, *tailcfg.SSHPolicy, error) {
 	// If there is no policy defined, we default to allow all
 	if policy == nil {
 		return tailcfg.FilterAllowAll, &tailcfg.SSHPolicy{}, nil
 	}

-	rules, err := policy.CompileFilterRules(users, append(peers, node))
+	rules, err := policy.CompileFilterRules(append(peers, node))
 	if err != nil {
 		return []tailcfg.FilterRule{}, &tailcfg.SSHPolicy{}, err
 	}

 	log.Trace().Interface("ACL", rules).Str("node", node.GivenName).Msg("ACL rules")

-	sshPolicy, err := policy.CompileSSHPolicy(node, users, peers)
+	sshPolicy, err := policy.CompileSSHPolicy(node, peers)
 	if err != nil {
 		return []tailcfg.FilterRule{}, &tailcfg.SSHPolicy{}, err
 	}
@ -162,7 +161,6 @@ func GenerateFilterAndSSHRulesForTests(
 // CompileFilterRules takes a set of nodes and an ACLPolicy and generates a
 // set of Tailscale compatible FilterRules used to allow traffic on clients.
 func (pol *ACLPolicy) CompileFilterRules(
-	users []types.User,
 	nodes types.Nodes,
 ) ([]tailcfg.FilterRule, error) {
 	if pol == nil {
@ -178,14 +176,9 @@ func (pol *ACLPolicy) CompileFilterRules(

 		var srcIPs []string
 		for srcIndex, src := range acl.Sources {
-			srcs, err := pol.expandSource(src, users, nodes)
+			srcs, err := pol.expandSource(src, nodes)
 			if err != nil {
-				return nil, fmt.Errorf(
-					"parsing policy, acl index: %d->%d: %w",
-					index,
-					srcIndex,
-					err,
-				)
+				return nil, fmt.Errorf("parsing policy, acl index: %d->%d: %w", index, srcIndex, err)
 			}
 			srcIPs = append(srcIPs, srcs...)
 		}
@ -204,7 +197,6 @@ func (pol *ACLPolicy) CompileFilterRules(

 			expanded, err := pol.ExpandAlias(
 				nodes,
-				users,
 				alias,
 			)
 			if err != nil {
@ -289,7 +281,6 @@ func ReduceFilterRules(node *types.Node, rules []tailcfg.FilterRule) []tailcfg.F

 func (pol *ACLPolicy) CompileSSHPolicy(
 	node *types.Node,
-	users []types.User,
 	peers types.Nodes,
 ) (*tailcfg.SSHPolicy, error) {
 	if pol == nil {
@ -321,7 +312,7 @@ func (pol *ACLPolicy) CompileSSHPolicy(
 	for index, sshACL := range pol.SSHs {
 		var dest netipx.IPSetBuilder
 		for _, src := range sshACL.Destinations {
-			expanded, err := pol.ExpandAlias(append(peers, node), users, src)
+			expanded, err := pol.ExpandAlias(append(peers, node), src)
 			if err != nil {
 				return nil, err
 			}
@ -344,21 +335,12 @@ func (pol *ACLPolicy) CompileSSHPolicy(
 		case "check":
 			checkAction, err := sshCheckAction(sshACL.CheckPeriod)
 			if err != nil {
-				return nil, fmt.Errorf(
-					"parsing SSH policy, parsing check duration, index: %d: %w",
-					index,
-					err,
-				)
+				return nil, fmt.Errorf("parsing SSH policy, parsing check duration, index: %d: %w", index, err)
 			} else {
 				action = *checkAction
 			}
 		default:
-			return nil, fmt.Errorf(
-				"parsing SSH policy, unknown action %q, index: %d: %w",
-				sshACL.Action,
-				index,
-				err,
-			)
+			return nil, fmt.Errorf("parsing SSH policy, unknown action %q, index: %d: %w", sshACL.Action, index, err)
 		}

 		principals := make([]*tailcfg.SSHPrincipal, 0, len(sshACL.Sources))
@ -381,7 +363,6 @@ func (pol *ACLPolicy) CompileSSHPolicy(
 			} else {
 				expandedSrcs, err := pol.ExpandAlias(
 					peers,
-					users,
 					rawSrc,
 				)
 				if err != nil {
@ -531,10 +512,9 @@ func parseProtocol(protocol string) ([]int, bool, error) {
 // with the given src alias.
 func (pol *ACLPolicy) expandSource(
 	src string,
-	users []types.User,
 	nodes types.Nodes,
 ) ([]string, error) {
-	ipSet, err := pol.ExpandAlias(nodes, users, src)
+	ipSet, err := pol.ExpandAlias(nodes, src)
 	if err != nil {
 		return []string{}, err
 	}
@ -558,7 +538,6 @@ func (pol *ACLPolicy) expandSource(
 // and transform these in IPAddresses.
 func (pol *ACLPolicy) ExpandAlias(
 	nodes types.Nodes,
-	users []types.User,
 	alias string,
 ) (*netipx.IPSet, error) {
 	if isWildcard(alias) {
@ -573,12 +552,12 @@ func (pol *ACLPolicy) ExpandAlias(

 	// if alias is a group
 	if isGroup(alias) {
-		return pol.expandIPsFromGroup(alias, users, nodes)
+		return pol.expandIPsFromGroup(alias, nodes)
 	}

 	// if alias is a tag
 	if isTag(alias) {
-		return pol.expandIPsFromTag(alias, users, nodes)
+		return pol.expandIPsFromTag(alias, nodes)
 	}

 	if isAutoGroup(alias) {
@ -586,7 +565,7 @@ func (pol *ACLPolicy) ExpandAlias(
 	}

 	// if alias is a user
-	if ips, err := pol.expandIPsFromUser(alias, users, nodes); ips != nil {
+	if ips, err := pol.expandIPsFromUser(alias, nodes); ips != nil {
 		return ips, err
 	}

@ -595,7 +574,7 @@ func (pol *ACLPolicy) ExpandAlias(
 	if h, ok := pol.Hosts[alias]; ok {
 		log.Trace().Str("host", h.String()).Msg("ExpandAlias got hosts entry")

-		return pol.ExpandAlias(nodes, users, h.String())
+		return pol.ExpandAlias(nodes, h.String())
 	}

 	// if alias is an IP
@ -620,7 +599,7 @@ func (pol *ACLPolicy) ExpandAlias(
 // TODO(kradalby): It is quite hard to understand what this function is doing,
 // it seems like it trying to ensure that we dont include nodes that are tagged
 // when we look up the nodes owned by a user.
-// This should be refactored to be more clear as part of the Tags work in #1369.
+// This should be refactored to be more clear as part of the Tags work in #1369
 func excludeCorrectlyTaggedNodes(
 	aclPolicy *ACLPolicy,
 	nodes types.Nodes,
@ -772,17 +751,16 @@ func (pol *ACLPolicy) expandUsersFromGroup(

 func (pol *ACLPolicy) expandIPsFromGroup(
 	group string,
-	users []types.User,
 	nodes types.Nodes,
 ) (*netipx.IPSet, error) {
 	var build netipx.IPSetBuilder

-	userTokens, err := pol.expandUsersFromGroup(group)
+	users, err := pol.expandUsersFromGroup(group)
 	if err != nil {
 		return &netipx.IPSet{}, err
 	}
-	for _, user := range userTokens {
-		filteredNodes := filterNodesByUser(nodes, users, user)
+	for _, user := range users {
+		filteredNodes := filterNodesByUser(nodes, user)
 		for _, node := range filteredNodes {
 			node.AppendToIPSet(&build)
 		}
@ -793,7 +771,6 @@ func (pol *ACLPolicy) expandIPsFromGroup(

 func (pol *ACLPolicy) expandIPsFromTag(
 	alias string,
-	users []types.User,
 	nodes types.Nodes,
 ) (*netipx.IPSet, error) {
 	var build netipx.IPSetBuilder
@ -826,7 +803,7 @@ func (pol *ACLPolicy) expandIPsFromTag(

 	// filter out nodes per tag owner
 	for _, user := range owners {
-		nodes := filterNodesByUser(nodes, users, user)
+		nodes := filterNodesByUser(nodes, user)
 		for _, node := range nodes {
 			if node.Hostinfo == nil {
 				continue
@ -843,12 +820,11 @@ func (pol *ACLPolicy) expandIPsFromTag(

 func (pol *ACLPolicy) expandIPsFromUser(
 	user string,
-	users []types.User,
 	nodes types.Nodes,
 ) (*netipx.IPSet, error) {
 	var build netipx.IPSetBuilder

-	filteredNodes := filterNodesByUser(nodes, users, user)
+	filteredNodes := filterNodesByUser(nodes, user)
 	filteredNodes = excludeCorrectlyTaggedNodes(pol, filteredNodes, user)

 	// shortcurcuit if we have no nodes to get ips from.
@ -977,43 +953,10 @@ func (pol *ACLPolicy) TagsOfNode(
 	return validTags, invalidTags
 }

-// filterNodesByUser returns a list of nodes that match the given userToken from a
-// policy.
-// Matching nodes are determined by first matching the user token to a user by checking:
-// - If it is an ID that mactches the user database ID
-// - It is the Provider Identifier from OIDC
-// - It matches the username or email of a user
-//
-// If the token matches more than one user, zero nodes will returned.
-func filterNodesByUser(nodes types.Nodes, users []types.User, userToken string) types.Nodes {
+func filterNodesByUser(nodes types.Nodes, user string) types.Nodes {
 	var out types.Nodes
-
-	var potentialUsers []types.User
-	for _, user := range users {
-		if user.ProviderIdentifier.Valid && user.ProviderIdentifier.String == userToken {
-			// If a user is matching with a known unique field,
-			// disgard all other users and only keep the current
-			// user.
-			potentialUsers = []types.User{user}
-
-			break
-		}
-		if user.Email == userToken {
-			potentialUsers = append(potentialUsers, user)
-		}
-		if user.Name == userToken {
-			potentialUsers = append(potentialUsers, user)
-		}
-	}
-
-	if len(potentialUsers) != 1 {
-		return nil
-	}
-
-	user := potentialUsers[0]
-
 	for _, node := range nodes {
-		if node.User.ID == user.ID {
+		if node.User.Username() == user {
 			out = append(out, node)
 		}
 	}
@ -1034,7 +977,10 @@ func FilterNodesByACL(
 			continue
 		}

+		log.Printf("Checking if %s can access %s", node.Hostname, peer.Hostname)
+
 		if node.CanAccess(filter, nodes[index]) || peer.CanAccess(filter, node) {
+			log.Printf("CAN ACCESS %s can access %s", node.Hostname, peer.Hostname)
 			result = append(result, peer)
 		}
 	}
--- a/hscontrol/policy/acls_test.go
+++ b/hscontrol/policy/acls_test.go
--- a/hscontrol/templates/windows.go
+++ b/hscontrol/templates/windows.go
@ -13,7 +13,7 @@ func Windows(url string) *elem.Element {
 			elem.Text("headscale - Windows"),
 		),
 		elem.Body(attrs.Props{
-			attrs.Style: bodyStyle.ToInline(),
+			attrs.Style : bodyStyle.ToInline(),
 		},
 			headerOne("headscale: Windows configuration"),
 			elem.P(nil,
@ -21,8 +21,7 @@ func Windows(url string) *elem.Element {
 				elem.A(attrs.Props{
 					attrs.Href:   "https://tailscale.com/download/windows",
 					attrs.Rel:    "noreferrer noopener",
-					attrs.Target: "_blank",
-				},
+					attrs.Target: "_blank"},
 					elem.Text("Tailscale for Windows ")),
 				elem.Text("and install it."),
 			),
--- a/hscontrol/types/config.go
+++ b/hscontrol/types/config.go
@ -28,9 +28,8 @@ const (
 	maxDuration           time.Duration = 1<<63 - 1
 )

-var (
-	errOidcMutuallyExclusive = errors.New("oidc_client_secret and oidc_client_secret_path are mutually exclusive")
-	errServerURLSuffix       = errors.New("server_url cannot be part of base_domain in a way that could make the DERP and headscale server unreachable")
+var errOidcMutuallyExclusive = errors.New(
+	"oidc_client_secret and oidc_client_secret_path are mutually exclusive",
 )

 type IPAllocationStrategy string
@ -105,7 +104,6 @@ type Nameservers struct {
 type SqliteConfig struct {
 	Path          string
 	WriteAheadLog bool
-	WALAutoCheckPoint int
 }

 type PostgresConfig struct {
@ -164,10 +162,8 @@ type OIDCConfig struct {
 	AllowedDomains             []string
 	AllowedUsers               []string
 	AllowedGroups              []string
-	StripEmaildomain           bool
 	Expiry                     time.Duration
 	UseExpiryFromToken         bool
-	MapLegacyUsers             bool
 }

 type DERPConfig struct {
@ -274,14 +270,11 @@ func LoadConfig(path string, isFile bool) error {
 	viper.SetDefault("database.postgres.conn_max_idle_time_secs", 3600)

 	viper.SetDefault("database.sqlite.write_ahead_log", true)
-	viper.SetDefault("database.sqlite.wal_autocheckpoint", 1000) // SQLite default

 	viper.SetDefault("oidc.scope", []string{oidc.ScopeOpenID, "profile", "email"})
-	viper.SetDefault("oidc.strip_email_domain", true)
 	viper.SetDefault("oidc.only_start_if_oidc_is_available", true)
 	viper.SetDefault("oidc.expiry", "180d")
 	viper.SetDefault("oidc.use_expiry_from_token", false)
-	viper.SetDefault("oidc.map_legacy_users", true)

 	viper.SetDefault("logtail.enabled", false)
 	viper.SetDefault("randomize_client_port", false)
@ -325,18 +318,14 @@ func validateServerConfig() error {
 	depr.warn("dns_config.use_username_in_magic_dns")
 	depr.warn("dns.use_username_in_magic_dns")

-	// TODO(kradalby): Reintroduce when strip_email_domain is removed
-	// after #2170 is cleaned up
-	// depr.fatal("oidc.strip_email_domain")
+	depr.fatal("oidc.strip_email_domain")
 	depr.fatal("dns.use_username_in_musername_in_magic_dns")
 	depr.fatal("dns_config.use_username_in_musername_in_magic_dns")

 	depr.Log()

 	for _, removed := range []string{
-		// TODO(kradalby): Reintroduce when strip_email_domain is removed
-		// after #2170 is cleaned up
-		// "oidc.strip_email_domain",
+		"oidc.strip_email_domain",
 		"dns_config.use_username_in_musername_in_magic_dns",
 	} {
 		if viper.IsSet(removed) {
@ -554,7 +543,6 @@ func databaseConfig() DatabaseConfig {
 				viper.GetString("database.sqlite.path"),
 			),
 			WriteAheadLog: viper.GetBool("database.sqlite.write_ahead_log"),
-			WALAutoCheckPoint: viper.GetInt("database.sqlite.wal_autocheckpoint"),
 		},
 		Postgres: PostgresConfig{
 			Host:               viper.GetString("database.postgres.host"),
@ -839,10 +827,11 @@ func LoadServerConfig() (*Config, error) {
 	// - DERP run on their own domains
 	// - Control plane runs on login.tailscale.com/controlplane.tailscale.com
 	// - MagicDNS (BaseDomain) for users is on a *.ts.net domain per tailnet (e.g. tail-scale.ts.net)
-	if dnsConfig.BaseDomain != "" {
-		if err := isSafeServerURL(serverURL, dnsConfig.BaseDomain); err != nil {
-			return nil, err
-		}
+	if dnsConfig.BaseDomain != "" &&
+		strings.Contains(serverURL, dnsConfig.BaseDomain) {
+		return nil, errors.New(
+			"server_url cannot contain the base_domain, this will cause the headscale server and embedded DERP to become unreachable from the Tailscale node.",
+		)
 	}

 	return &Config{
@ -908,10 +897,6 @@ func LoadServerConfig() (*Config, error) {
 				}
 			}(),
 			UseExpiryFromToken: viper.GetBool("oidc.use_expiry_from_token"),
-			// TODO(kradalby): Remove when strip_email_domain is removed
-			// after #2170 is cleaned up
-			StripEmaildomain: viper.GetBool("oidc.strip_email_domain"),
-			MapLegacyUsers:   viper.GetBool("oidc.map_legacy_users"),
 		},

 		LogTail:             logTailConfig,
@ -939,37 +924,6 @@ func LoadServerConfig() (*Config, error) {
 	}, nil
 }

-// BaseDomain cannot be a suffix of the server URL.
-// This is because Tailscale takes over the domain in BaseDomain,
-// causing the headscale server and DERP to be unreachable.
-// For Tailscale upstream, the following is true:
-// - DERP run on their own domains.
-// - Control plane runs on login.tailscale.com/controlplane.tailscale.com.
-// - MagicDNS (BaseDomain) for users is on a *.ts.net domain per tailnet (e.g. tail-scale.ts.net).
-func isSafeServerURL(serverURL, baseDomain string) error {
-	server, err := url.Parse(serverURL)
-	if err != nil {
-		return err
-	}
-
-	serverDomainParts := strings.Split(server.Host, ".")
-	baseDomainParts := strings.Split(baseDomain, ".")
-
-	if len(serverDomainParts) <= len(baseDomainParts) {
-		return nil
-	}
-
-	s := len(serverDomainParts)
-	b := len(baseDomainParts)
-	for i := range len(baseDomainParts) {
-		if serverDomainParts[s-i-1] != baseDomainParts[b-i-1] {
-			return nil
-		}
-	}
-
-	return errServerURLSuffix
-}
-
 type deprecator struct {
 	warns  set.Set[string]
 	fatals set.Set[string]
--- a/hscontrol/types/config_test.go
+++ b/hscontrol/types/config_test.go
@ -1,7 +1,6 @@
 package types

 import (
-	"fmt"
 	"os"
 	"path/filepath"
 	"testing"
@ -9,7 +8,6 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"tailscale.com/tailcfg"
 	"tailscale.com/types/dnstype"
 )
@ -37,17 +35,8 @@ func TestReadConfig(t *testing.T) {
 				MagicDNS:   true,
 				BaseDomain: "example.com",
 				Nameservers: Nameservers{
-					Global: []string{
-						"1.1.1.1",
-						"1.0.0.1",
-						"2606:4700:4700::1111",
-						"2606:4700:4700::1001",
-						"https://dns.nextdns.io/abc123",
-					},
-					Split: map[string][]string{
-						"darp.headscale.net": {"1.1.1.1", "8.8.8.8"},
-						"foo.bar.com":        {"1.1.1.1"},
-					},
+					Global: []string{"1.1.1.1", "1.0.0.1", "2606:4700:4700::1111", "2606:4700:4700::1001", "https://dns.nextdns.io/abc123"},
+					Split:  map[string][]string{"darp.headscale.net": {"1.1.1.1", "8.8.8.8"}, "foo.bar.com": {"1.1.1.1"}},
 				},
 				ExtraRecords: []tailcfg.DNSRecord{
 					{Name: "grafana.myvpn.example.com", Type: "A", Value: "100.64.0.3"},
@ -102,17 +91,8 @@ func TestReadConfig(t *testing.T) {
 				MagicDNS:   false,
 				BaseDomain: "example.com",
 				Nameservers: Nameservers{
-					Global: []string{
-						"1.1.1.1",
-						"1.0.0.1",
-						"2606:4700:4700::1111",
-						"2606:4700:4700::1001",
-						"https://dns.nextdns.io/abc123",
-					},
-					Split: map[string][]string{
-						"darp.headscale.net": {"1.1.1.1", "8.8.8.8"},
-						"foo.bar.com":        {"1.1.1.1"},
-					},
+					Global: []string{"1.1.1.1", "1.0.0.1", "2606:4700:4700::1111", "2606:4700:4700::1001", "https://dns.nextdns.io/abc123"},
+					Split:  map[string][]string{"darp.headscale.net": {"1.1.1.1", "8.8.8.8"}, "foo.bar.com": {"1.1.1.1"}},
 				},
 				ExtraRecords: []tailcfg.DNSRecord{
 					{Name: "grafana.myvpn.example.com", Type: "A", Value: "100.64.0.3"},
@ -159,7 +139,7 @@ func TestReadConfig(t *testing.T) {
 				return LoadServerConfig()
 			},
 			want:    nil,
-			wantErr: errServerURLSuffix.Error(),
+			wantErr: "server_url cannot contain the base_domain, this will cause the headscale server and embedded DERP to become unreachable from the Tailscale node.",
 		},
 		{
 			name:       "base-domain-not-in-server-url",
@ -206,7 +186,7 @@ func TestReadConfig(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			viper.Reset()
 			err := LoadConfig(tt.configPath, true)
-			require.NoError(t, err)
+			assert.NoError(t, err)

 			conf, err := tt.setup(t)

@ -216,7 +196,7 @@ func TestReadConfig(t *testing.T) {
 				return
 			}

-			require.NoError(t, err)
+			assert.NoError(t, err)

 			if diff := cmp.Diff(tt.want, conf); diff != "" {
 				t.Errorf("ReadConfig() mismatch (-want +got):\n%s", diff)
@ -296,10 +276,10 @@ func TestReadConfigFromEnv(t *testing.T) {

 			viper.Reset()
 			err := LoadConfig("testdata/minimal.yaml", true)
-			require.NoError(t, err)
+			assert.NoError(t, err)

 			conf, err := tt.setup(t)
-			require.NoError(t, err)
+			assert.NoError(t, err)

 			if diff := cmp.Diff(tt.want, conf); diff != "" {
 				t.Errorf("ReadConfig() mismatch (-want +got):\n%s", diff)
@ -330,25 +310,13 @@ noise:

 	// Check configuration validation errors (1)
 	err = LoadConfig(tmpDir, false)
-	require.NoError(t, err)
+	assert.NoError(t, err)

 	err = validateServerConfig()
-	require.Error(t, err)
-	assert.Contains(
-		t,
-		err.Error(),
-		"Fatal config error: set either tls_letsencrypt_hostname or tls_cert_path/tls_key_path, not both",
-	)
-	assert.Contains(
-		t,
-		err.Error(),
-		"Fatal config error: the only supported values for tls_letsencrypt_challenge_type are",
-	)
-	assert.Contains(
-		t,
-		err.Error(),
-		"Fatal config error: server_url must start with https:// or http://",
-	)
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "Fatal config error: set either tls_letsencrypt_hostname or tls_cert_path/tls_key_path, not both")
+	assert.Contains(t, err.Error(), "Fatal config error: the only supported values for tls_letsencrypt_challenge_type are")
+	assert.Contains(t, err.Error(), "Fatal config error: server_url must start with https:// or http://")

 	// Check configuration validation errors (2)
 	configYaml = []byte(`---
@ -363,66 +331,5 @@ tls_letsencrypt_challenge_type: TLS-ALPN-01
 		t.Fatalf("Couldn't write file %s", configFilePath)
 	}
 	err = LoadConfig(tmpDir, false)
-	require.NoError(t, err)
-}
-
-// OK
-// server_url: headscale.com, base: clients.headscale.com
-// server_url: headscale.com, base: headscale.net
-//
-// NOT OK
-// server_url: server.headscale.com, base: headscale.com.
-func TestSafeServerURL(t *testing.T) {
-	tests := []struct {
-		serverURL, baseDomain,
-		wantErr string
-	}{
-		{
-			serverURL:  "https://example.com",
-			baseDomain: "example.org",
-		},
-		{
-			serverURL:  "https://headscale.com",
-			baseDomain: "headscale.com",
-		},
-		{
-			serverURL:  "https://headscale.com",
-			baseDomain: "clients.headscale.com",
-		},
-		{
-			serverURL:  "https://headscale.com",
-			baseDomain: "clients.subdomain.headscale.com",
-		},
-		{
-			serverURL:  "https://headscale.kristoffer.com",
-			baseDomain: "mybase",
-		},
-		{
-			serverURL:  "https://server.headscale.com",
-			baseDomain: "headscale.com",
-			wantErr:    errServerURLSuffix.Error(),
-		},
-		{
-			serverURL:  "https://server.subdomain.headscale.com",
-			baseDomain: "headscale.com",
-			wantErr:    errServerURLSuffix.Error(),
-		},
-		{
-			serverURL: "http://foo\x00",
-			wantErr:   `parse "http://foo\x00": net/url: invalid control character in URL`,
-		},
-	}
-
-	for _, tt := range tests {
-		testName := fmt.Sprintf("server=%s domain=%s", tt.serverURL, tt.baseDomain)
-		t.Run(testName, func(t *testing.T) {
-			err := isSafeServerURL(tt.serverURL, tt.baseDomain)
-			if tt.wantErr != "" {
-				assert.EqualError(t, err, tt.wantErr)
-
-				return
-			}
 	assert.NoError(t, err)
-		})
-	}
 }
--- a/hscontrol/types/node.go
+++ b/hscontrol/types/node.go
@ -223,16 +223,6 @@ func (nodes Nodes) FilterByIP(ip netip.Addr) Nodes {
 	return found
 }

-func (nodes Nodes) ContainsNodeKey(nodeKey key.NodePublic) bool {
-	for _, node := range nodes {
-		if node.NodeKey == nodeKey {
-			return true
-		}
-	}
-
-	return false
-}
-
 func (node *Node) Proto() *v1.Node {
 	nodeProto := &v1.Node{
 		Id:         uint64(node.ID),
--- a/hscontrol/types/preauth_key.go
+++ b/hscontrol/types/preauth_key.go
@ -26,7 +26,7 @@ type PreAuthKey struct {

 func (key *PreAuthKey) Proto() *v1.PreAuthKey {
 	protoKey := v1.PreAuthKey{
-		User:      key.User.Username(),
+		User:      key.User.Name,
 		Id:        strconv.FormatUint(key.ID, util.Base10),
 		Key:       key.Key,
 		Ephemeral: key.Ephemeral,
--- a/hscontrol/types/testdata/base-domain-in-server-url.yaml
+++ b/hscontrol/types/testdata/base-domain-in-server-url.yaml
@ -8,7 +8,7 @@ prefixes:
 database:
  type: sqlite3

-server_url: "https://server.derp.no"
+server_url: "https://derp.no"

 dns:
  magic_dns: true
--- a/hscontrol/types/users.go
+++ b/hscontrol/types/users.go
@ -2,8 +2,6 @@ package types

 import (
 	"cmp"
-	"database/sql"
-	"net/mail"
 	"strconv"

 	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
@ -21,14 +19,10 @@ type UserID uint64
 // that contain our machines.
 type User struct {
 	gorm.Model
-	// The index `idx_name_provider_identifier` is to enforce uniqueness
-	// between Name and ProviderIdentifier. This ensures that
-	// you can have multiple users with the same name in OIDC,
-	// but not if you only run with CLI users.

 	// Username for the user, is used if email is empty
 	// Should not be used, please use Username().
-	Name string
+	Name string `gorm:"unique"`

 	// Typically the full name of the user
 	DisplayName string
@ -40,7 +34,7 @@ type User struct {
 	// Unique identifier of the user from OIDC,
 	// comes from `sub` claim in the OIDC token
 	// and is used to lookup the user.
-	ProviderIdentifier sql.NullString
+	ProviderIdentifier string `gorm:"index"`

 	// Provider is the origin of the user account,
 	// same as RegistrationMethod, without authkey.
@ -57,7 +51,7 @@ type User struct {
 // should be used throughout headscale, in information returned to the
 // user and the Policy engine.
 func (u *User) Username() string {
-	return cmp.Or(u.Email, u.Name, u.ProviderIdentifier.String, strconv.FormatUint(uint64(u.ID), 10))
+	return cmp.Or(u.Email, u.Name, u.ProviderIdentifier, strconv.FormatUint(uint64(u.ID), 10))
 }

 // DisplayNameOrUsername returns the DisplayName if it exists, otherwise
@ -113,7 +107,7 @@ func (u *User) Proto() *v1.User {
 		CreatedAt:     timestamppb.New(u.CreatedAt),
 		DisplayName:   u.DisplayName,
 		Email:         u.Email,
-		ProviderId:    u.ProviderIdentifier.String,
+		ProviderId:    u.ProviderIdentifier,
 		Provider:      u.Provider,
 		ProfilePicUrl: u.ProfilePicURL,
 	}
@ -122,7 +116,6 @@ func (u *User) Proto() *v1.User {
 type OIDCClaims struct {
 	// Sub is the user's unique identifier at the provider.
 	Sub string `json:"sub"`
-	Iss string `json:"iss"`

 	// Name is the user's full name.
 	Name              string   `json:"name,omitempty"`
@ -133,27 +126,13 @@ type OIDCClaims struct {
 	Username          string   `json:"preferred_username,omitempty"`
 }

-func (c *OIDCClaims) Identifier() string {
-	return c.Iss + "/" + c.Sub
-}
-
 // FromClaim overrides a User from OIDC claims.
 // All fields will be updated, except for the ID.
 func (u *User) FromClaim(claims *OIDCClaims) {
-	err := util.CheckForFQDNRules(claims.Username)
-	if err == nil {
-		u.Name = claims.Username
-	}
-
-	if claims.EmailVerified {
-		_, err = mail.ParseAddress(claims.Email)
-		if err == nil {
-			u.Email = claims.Email
-		}
-	}
-
-	u.ProviderIdentifier = sql.NullString{String: claims.Identifier(), Valid: true}
+	u.ProviderIdentifier = claims.Sub
 	u.DisplayName = claims.Name
+	u.Email = claims.Email
+	u.Name = claims.Username
 	u.ProfilePicURL = claims.ProfilePictureURL
 	u.Provider = util.RegisterMethodOIDC
 }
--- a/hscontrol/util/dns.go
+++ b/hscontrol/util/dns.go
@ -182,33 +182,3 @@ func GenerateIPv6DNSRootDomain(ipPrefix netip.Prefix) []dnsname.FQDN {

 	return fqdns
 }
-
-// TODO(kradalby): Reintroduce when strip_email_domain is removed
-// after #2170 is cleaned up
-// DEPRECATED: DO NOT USE
-// NormalizeToFQDNRules will replace forbidden chars in user
-// it can also return an error if the user doesn't respect RFC 952 and 1123.
-func NormalizeToFQDNRules(name string, stripEmailDomain bool) (string, error) {
-
-	name = strings.ToLower(name)
-	name = strings.ReplaceAll(name, "'", "")
-	atIdx := strings.Index(name, "@")
-	if stripEmailDomain && atIdx > 0 {
-		name = name[:atIdx]
-	} else {
-		name = strings.ReplaceAll(name, "@", ".")
-	}
-	name = invalidCharsInUserRegex.ReplaceAllString(name, "-")
-
-	for _, elt := range strings.Split(name, ".") {
-		if len(elt) > LabelHostnameLength {
-			return "", fmt.Errorf(
-				"label %v is more than 63 chars: %w",
-				elt,
-				ErrInvalidUserName,
-			)
-		}
-	}
-
-	return name, nil
-}
--- a/hscontrol/util/string_test.go
+++ b/hscontrol/util/string_test.go
@ -4,13 +4,12 @@ import (
 	"testing"

 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )

 func TestGenerateRandomStringDNSSafe(t *testing.T) {
 	for i := 0; i < 100000; i++ {
 		str, err := GenerateRandomStringDNSSafe(8)
-		require.NoError(t, err)
+		assert.Nil(t, err)
 		assert.Len(t, str, 8)
 	}
 }
--- a/integration/README.md
+++ b/integration/README.md
@ -11,10 +11,10 @@ Tests are located in files ending with `_test.go` and the framework are located

 ## Running integration tests locally

-The easiest way to run tests locally is to use [act](https://github.com/nektos/act), a local GitHub Actions runner:
+The easiest way to run tests locally is to use `[act](INSERT LINK)`, a local GitHub Actions runner:

 ```
-act pull_request -W .github/workflows/test-integration.yaml
+act pull_request -W .github/workflows/test-integration-v2-TestPingAllByIP.yaml
 ```

 Alternatively, the `docker run` command in each GitHub workflow file can be used.
--- a/integration/acl_test.go
+++ b/integration/acl_test.go
@ -12,7 +12,6 @@ import (
 	"github.com/juanfont/headscale/integration/hsic"
 	"github.com/juanfont/headscale/integration/tsic"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )

 var veryLargeDestination = []string{
@ -55,7 +54,7 @@ func aclScenario(
 ) *Scenario {
 	t.Helper()
 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	spec := map[string]int{
 		"user1": clientsPerUser,
@ -78,10 +77,10 @@ func aclScenario(
 		hsic.WithACLPolicy(policy),
 		hsic.WithTestName("acl"),
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	_, err = scenario.ListTailscaleClientsFQDNs()
-	require.NoError(t, err)
+	assertNoErrListFQDN(t, err)

 	return scenario
 }
@ -268,7 +267,7 @@ func TestACLHostsInNetMapTable(t *testing.T) {
 	for name, testCase := range tests {
 		t.Run(name, func(t *testing.T) {
 			scenario, err := NewScenario(dockertestMaxWait())
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			spec := testCase.users

@ -276,22 +275,22 @@ func TestACLHostsInNetMapTable(t *testing.T) {
 				[]tsic.Option{},
 				hsic.WithACLPolicy(&testCase.policy),
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)
 			defer scenario.ShutdownAssertNoPanics(t)

 			allClients, err := scenario.ListTailscaleClients()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			err = scenario.WaitForTailscaleSyncWithPeerCount(testCase.want["user1"])
-			require.NoError(t, err)
+			assertNoErrSync(t, err)

 			for _, client := range allClients {
 				status, err := client.Status()
-				require.NoError(t, err)
+				assertNoErr(t, err)

 				user := status.User[status.Self.UserID].LoginName

-				assert.Len(t, status.Peer, (testCase.want[user]))
+				assert.Equal(t, (testCase.want[user]), len(status.Peer))
 			}
 		})
 	}
@ -320,23 +319,23 @@ func TestACLAllowUser80Dst(t *testing.T) {
 	defer scenario.ShutdownAssertNoPanics(t)

 	user1Clients, err := scenario.ListTailscaleClients("user1")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	user2Clients, err := scenario.ListTailscaleClients("user2")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Test that user1 can visit all user2
 	for _, client := range user1Clients {
 		for _, peer := range user2Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Len(t, result, 13)
-			require.NoError(t, err)
+			assertNoErr(t, err)
 		}
 	}

@ -344,14 +343,14 @@ func TestACLAllowUser80Dst(t *testing.T) {
 	for _, client := range user2Clients {
 		for _, peer := range user1Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)
 		}
 	}
 }
@ -377,10 +376,10 @@ func TestACLDenyAllPort80(t *testing.T) {
 	defer scenario.ShutdownAssertNoPanics(t)

 	allClients, err := scenario.ListTailscaleClients()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	allHostnames, err := scenario.ListTailscaleClientsFQDNs()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	for _, client := range allClients {
 		for _, hostname := range allHostnames {
@ -395,7 +394,7 @@ func TestACLDenyAllPort80(t *testing.T) {

 			result, err := client.Curl(url)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)
 		}
 	}
 }
@ -421,23 +420,23 @@ func TestACLAllowUserDst(t *testing.T) {
 	defer scenario.ShutdownAssertNoPanics(t)

 	user1Clients, err := scenario.ListTailscaleClients("user1")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	user2Clients, err := scenario.ListTailscaleClients("user2")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Test that user1 can visit all user2
 	for _, client := range user1Clients {
 		for _, peer := range user2Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Len(t, result, 13)
-			require.NoError(t, err)
+			assertNoErr(t, err)
 		}
 	}

@ -445,14 +444,14 @@ func TestACLAllowUserDst(t *testing.T) {
 	for _, client := range user2Clients {
 		for _, peer := range user1Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)
 		}
 	}
 }
@ -477,23 +476,23 @@ func TestACLAllowStarDst(t *testing.T) {
 	defer scenario.ShutdownAssertNoPanics(t)

 	user1Clients, err := scenario.ListTailscaleClients("user1")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	user2Clients, err := scenario.ListTailscaleClients("user2")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Test that user1 can visit all user2
 	for _, client := range user1Clients {
 		for _, peer := range user2Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Len(t, result, 13)
-			require.NoError(t, err)
+			assertNoErr(t, err)
 		}
 	}

@ -501,14 +500,14 @@ func TestACLAllowStarDst(t *testing.T) {
 	for _, client := range user2Clients {
 		for _, peer := range user1Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)
 		}
 	}
 }
@ -538,23 +537,23 @@ func TestACLNamedHostsCanReachBySubnet(t *testing.T) {
 	defer scenario.ShutdownAssertNoPanics(t)

 	user1Clients, err := scenario.ListTailscaleClients("user1")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	user2Clients, err := scenario.ListTailscaleClients("user2")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Test that user1 can visit all user2
 	for _, client := range user1Clients {
 		for _, peer := range user2Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Len(t, result, 13)
-			require.NoError(t, err)
+			assertNoErr(t, err)
 		}
 	}

@ -562,14 +561,14 @@ func TestACLNamedHostsCanReachBySubnet(t *testing.T) {
 	for _, client := range user2Clients {
 		for _, peer := range user1Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Len(t, result, 13)
-			require.NoError(t, err)
+			assertNoErr(t, err)
 		}
 	}
 }
@ -680,10 +679,10 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 			test1ip4 := netip.MustParseAddr("100.64.0.1")
 			test1ip6 := netip.MustParseAddr("fd7a:115c:a1e0::1")
 			test1, err := scenario.FindTailscaleClientByIP(test1ip6)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			test1fqdn, err := test1.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)
 			test1ip4URL := fmt.Sprintf("http://%s/etc/hostname", test1ip4.String())
 			test1ip6URL := fmt.Sprintf("http://[%s]/etc/hostname", test1ip6.String())
 			test1fqdnURL := fmt.Sprintf("http://%s/etc/hostname", test1fqdn)
@ -691,10 +690,10 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 			test2ip4 := netip.MustParseAddr("100.64.0.2")
 			test2ip6 := netip.MustParseAddr("fd7a:115c:a1e0::2")
 			test2, err := scenario.FindTailscaleClientByIP(test2ip6)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			test2fqdn, err := test2.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)
 			test2ip4URL := fmt.Sprintf("http://%s/etc/hostname", test2ip4.String())
 			test2ip6URL := fmt.Sprintf("http://[%s]/etc/hostname", test2ip6.String())
 			test2fqdnURL := fmt.Sprintf("http://%s/etc/hostname", test2fqdn)
@ -702,10 +701,10 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 			test3ip4 := netip.MustParseAddr("100.64.0.3")
 			test3ip6 := netip.MustParseAddr("fd7a:115c:a1e0::3")
 			test3, err := scenario.FindTailscaleClientByIP(test3ip6)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			test3fqdn, err := test3.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)
 			test3ip4URL := fmt.Sprintf("http://%s/etc/hostname", test3ip4.String())
 			test3ip6URL := fmt.Sprintf("http://[%s]/etc/hostname", test3ip6.String())
 			test3fqdnURL := fmt.Sprintf("http://%s/etc/hostname", test3fqdn)
@ -720,7 +719,7 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				test3ip4URL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			result, err = test1.Curl(test3ip6URL)
 			assert.Lenf(
@ -731,7 +730,7 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				test3ip6URL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			result, err = test1.Curl(test3fqdnURL)
 			assert.Lenf(
@ -742,7 +741,7 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				test3fqdnURL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			// test2 can query test3
 			result, err = test2.Curl(test3ip4URL)
@ -754,7 +753,7 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				test3ip4URL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			result, err = test2.Curl(test3ip6URL)
 			assert.Lenf(
@ -765,7 +764,7 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				test3ip6URL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			result, err = test2.Curl(test3fqdnURL)
 			assert.Lenf(
@ -776,33 +775,33 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				test3fqdnURL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			// test3 cannot query test1
 			result, err = test3.Curl(test1ip4URL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			result, err = test3.Curl(test1ip6URL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			result, err = test3.Curl(test1fqdnURL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			// test3 cannot query test2
 			result, err = test3.Curl(test2ip4URL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			result, err = test3.Curl(test2ip6URL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			result, err = test3.Curl(test2fqdnURL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			// test1 can query test2
 			result, err = test1.Curl(test2ip4URL)
@ -815,7 +814,7 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				result,
 			)

-			require.NoError(t, err)
+			assertNoErr(t, err)
 			result, err = test1.Curl(test2ip6URL)
 			assert.Lenf(
 				t,
@ -825,7 +824,7 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				test2ip6URL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			result, err = test1.Curl(test2fqdnURL)
 			assert.Lenf(
@ -836,20 +835,20 @@ func TestACLNamedHostsCanReach(t *testing.T) {
 				test2fqdnURL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			// test2 cannot query test1
 			result, err = test2.Curl(test1ip4URL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			result, err = test2.Curl(test1ip6URL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			result, err = test2.Curl(test1fqdnURL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)
 		})
 	}
 }
@ -947,10 +946,10 @@ func TestACLDevice1CanAccessDevice2(t *testing.T) {
 			test1ip6 := netip.MustParseAddr("fd7a:115c:a1e0::1")
 			test1, err := scenario.FindTailscaleClientByIP(test1ip)
 			assert.NotNil(t, test1)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			test1fqdn, err := test1.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)
 			test1ipURL := fmt.Sprintf("http://%s/etc/hostname", test1ip.String())
 			test1ip6URL := fmt.Sprintf("http://[%s]/etc/hostname", test1ip6.String())
 			test1fqdnURL := fmt.Sprintf("http://%s/etc/hostname", test1fqdn)
@ -959,10 +958,10 @@ func TestACLDevice1CanAccessDevice2(t *testing.T) {
 			test2ip6 := netip.MustParseAddr("fd7a:115c:a1e0::2")
 			test2, err := scenario.FindTailscaleClientByIP(test2ip)
 			assert.NotNil(t, test2)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			test2fqdn, err := test2.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)
 			test2ipURL := fmt.Sprintf("http://%s/etc/hostname", test2ip.String())
 			test2ip6URL := fmt.Sprintf("http://[%s]/etc/hostname", test2ip6.String())
 			test2fqdnURL := fmt.Sprintf("http://%s/etc/hostname", test2fqdn)
@ -977,7 +976,7 @@ func TestACLDevice1CanAccessDevice2(t *testing.T) {
 				test2ipURL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			result, err = test1.Curl(test2ip6URL)
 			assert.Lenf(
@ -988,7 +987,7 @@ func TestACLDevice1CanAccessDevice2(t *testing.T) {
 				test2ip6URL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			result, err = test1.Curl(test2fqdnURL)
 			assert.Lenf(
@ -999,19 +998,19 @@ func TestACLDevice1CanAccessDevice2(t *testing.T) {
 				test2fqdnURL,
 				result,
 			)
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			result, err = test2.Curl(test1ipURL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			result, err = test2.Curl(test1ip6URL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)

 			result, err = test2.Curl(test1fqdnURL)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)
 		})
 	}
 }
@ -1021,7 +1020,7 @@ func TestPolicyUpdateWhileRunningWithCLIInDatabase(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -1047,19 +1046,19 @@ func TestPolicyUpdateWhileRunningWithCLIInDatabase(t *testing.T) {
 			"HEADSCALE_POLICY_MODE": "database",
 		}),
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	_, err = scenario.ListTailscaleClientsFQDNs()
-	require.NoError(t, err)
+	assertNoErrListFQDN(t, err)

 	err = scenario.WaitForTailscaleSync()
-	require.NoError(t, err)
+	assertNoErrSync(t, err)

 	user1Clients, err := scenario.ListTailscaleClients("user1")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	user2Clients, err := scenario.ListTailscaleClients("user2")
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	all := append(user1Clients, user2Clients...)

@ -1071,19 +1070,19 @@ func TestPolicyUpdateWhileRunningWithCLIInDatabase(t *testing.T) {
 			}

 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Len(t, result, 13)
-			require.NoError(t, err)
+			assertNoErr(t, err)
 		}
 	}

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	p := policy.ACLPolicy{
 		ACLs: []policy.ACL{
@ -1101,7 +1100,7 @@ func TestPolicyUpdateWhileRunningWithCLIInDatabase(t *testing.T) {
 	policyFilePath := "/etc/headscale/policy.json"

 	err = headscale.WriteFile(policyFilePath, pBytes)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// No policy is present at this time.
 	// Add a new policy from a file.
@ -1114,7 +1113,7 @@ func TestPolicyUpdateWhileRunningWithCLIInDatabase(t *testing.T) {
 			policyFilePath,
 		},
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Get the current policy and check
 	// if it is the same as the one we set.
@ -1130,7 +1129,7 @@ func TestPolicyUpdateWhileRunningWithCLIInDatabase(t *testing.T) {
 		},
 		&output,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	assert.Len(t, output.ACLs, 1)

@ -1142,14 +1141,14 @@ func TestPolicyUpdateWhileRunningWithCLIInDatabase(t *testing.T) {
 	for _, client := range user1Clients {
 		for _, peer := range user2Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Len(t, result, 13)
-			require.NoError(t, err)
+			assertNoErr(t, err)
 		}
 	}

@ -1157,14 +1156,14 @@ func TestPolicyUpdateWhileRunningWithCLIInDatabase(t *testing.T) {
 	for _, client := range user2Clients {
 		for _, peer := range user1Clients {
 			fqdn, err := peer.FQDN()
-			require.NoError(t, err)
+			assertNoErr(t, err)

 			url := fmt.Sprintf("http://%s/etc/hostname", fqdn)
 			t.Logf("url from %s to %s", client.Hostname(), url)

 			result, err := client.Curl(url)
 			assert.Empty(t, result)
-			require.Error(t, err)
+			assert.Error(t, err)
 		}
 	}
 }
--- a/integration/auth_oidc_test.go
+++ b/integration/auth_oidc_test.go
@ -3,7 +3,6 @@ package integration
 import (
 	"context"
 	"crypto/tls"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@ -11,19 +10,14 @@ import (
 	"net"
 	"net/http"
 	"net/netip"
-	"sort"
 	"strconv"
 	"testing"
 	"time"

-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/juanfont/headscale/integration/dockertestutil"
 	"github.com/juanfont/headscale/integration/hsic"
-	"github.com/oauth2-proxy/mockoidc"
 	"github.com/ory/dockertest/v3"
 	"github.com/ory/dockertest/v3/docker"
 	"github.com/samber/lo"
@ -54,34 +48,20 @@ func TestOIDCAuthenticationPingAll(t *testing.T) {
 	scenario := AuthOIDCScenario{
 		Scenario: baseScenario,
 	}
-	// defer scenario.ShutdownAssertNoPanics(t)
+	defer scenario.ShutdownAssertNoPanics(t)

-	// Logins to MockOIDC is served by a queue with a strict order,
-	// if we use more than one node per user, the order of the logins
-	// will not be deterministic and the test will fail.
 	spec := map[string]int{
-		"user1": 1,
-		"user2": 1,
+		"user1": len(MustTestVersions),
 	}

-	mockusers := []mockoidc.MockUser{
-		oidcMockUser("user1", true),
-		oidcMockUser("user2", false),
-	}
-
-	oidcConfig, err := scenario.runMockOIDC(defaultAccessTTL, mockusers)
+	oidcConfig, err := scenario.runMockOIDC(defaultAccessTTL)
 	assertNoErrf(t, "failed to run mock OIDC server: %s", err)
-	defer scenario.mockOIDC.Close()

 	oidcMap := map[string]string{
 		"HEADSCALE_OIDC_ISSUER":             oidcConfig.Issuer,
 		"HEADSCALE_OIDC_CLIENT_ID":          oidcConfig.ClientID,
 		"CREDENTIALS_DIRECTORY_TEST":        "/tmp",
 		"HEADSCALE_OIDC_CLIENT_SECRET_PATH": "${CREDENTIALS_DIRECTORY_TEST}/hs_client_oidc_secret",
-		// TODO(kradalby): Remove when strip_email_domain is removed
-		// after #2170 is cleaned up
-		"HEADSCALE_OIDC_MAP_LEGACY_USERS":   "0",
-		"HEADSCALE_OIDC_STRIP_EMAIL_DOMAIN": "0",
 	}

 	err = scenario.CreateHeadscaleEnv(
@ -111,55 +91,6 @@ func TestOIDCAuthenticationPingAll(t *testing.T) {

 	success := pingAllHelper(t, allClients, allAddrs)
 	t.Logf("%d successful pings out of %d", success, len(allClients)*len(allIps))
-
-	headscale, err := scenario.Headscale()
-	assertNoErr(t, err)
-
-	var listUsers []v1.User
-	err = executeAndUnmarshal(headscale,
-		[]string{
-			"headscale",
-			"users",
-			"list",
-			"--output",
-			"json",
-		},
-		&listUsers,
-	)
-	assertNoErr(t, err)
-
-	want := []v1.User{
-		{
-			Id:   "1",
-			Name: "user1",
-		},
-		{
-			Id:         "2",
-			Name:       "user1",
-			Email:      "user1@headscale.net",
-			Provider:   "oidc",
-			ProviderId: oidcConfig.Issuer + "/user1",
-		},
-		{
-			Id:   "3",
-			Name: "user2",
-		},
-		{
-			Id:         "4",
-			Name:       "user2",
-			Email:      "", // Unverified
-			Provider:   "oidc",
-			ProviderId: oidcConfig.Issuer + "/user2",
-		},
-	}
-
-	sort.Slice(listUsers, func(i, j int) bool {
-		return listUsers[i].Id < listUsers[j].Id
-	})
-
-	if diff := cmp.Diff(want, listUsers, cmpopts.IgnoreUnexported(v1.User{}), cmpopts.IgnoreFields(v1.User{}, "CreatedAt")); diff != "" {
-		t.Fatalf("unexpected users: %s", diff)
-	}
 }

 // This test is really flaky.
@ -180,16 +111,11 @@ func TestOIDCExpireNodesBasedOnTokenExpiry(t *testing.T) {
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
-		"user1": 1,
-		"user2": 1,
+		"user1": 3,
 	}

-	oidcConfig, err := scenario.runMockOIDC(shortAccessTTL, []mockoidc.MockUser{
-		oidcMockUser("user1", true),
-		oidcMockUser("user2", false),
-	})
+	oidcConfig, err := scenario.runMockOIDC(shortAccessTTL)
 	assertNoErrf(t, "failed to run mock OIDC server: %s", err)
-	defer scenario.mockOIDC.Close()

 	oidcMap := map[string]string{
 		"HEADSCALE_OIDC_ISSUER":                oidcConfig.Issuer,
@ -233,297 +159,6 @@ func TestOIDCExpireNodesBasedOnTokenExpiry(t *testing.T) {
 	assertTailscaleNodesLogout(t, allClients)
 }

-// TODO(kradalby):
-// - Test that creates a new user when one exists when migration is turned off
-// - Test that takes over a user when one exists when migration is turned on
-//   - But email is not verified
-//   - stripped email domain on/off
-func TestOIDC024UserCreation(t *testing.T) {
-	IntegrationSkip(t)
-
-	tests := []struct {
-		name          string
-		config        map[string]string
-		emailVerified bool
-		cliUsers      []string
-		oidcUsers     []string
-		want          func(iss string) []v1.User
-	}{
-		{
-			name: "no-migration-verified-email",
-			config: map[string]string{
-				"HEADSCALE_OIDC_MAP_LEGACY_USERS": "0",
-			},
-			emailVerified: true,
-			cliUsers:      []string{"user1", "user2"},
-			oidcUsers:     []string{"user1", "user2"},
-			want: func(iss string) []v1.User {
-				return []v1.User{
-					{
-						Id:   "1",
-						Name: "user1",
-					},
-					{
-						Id:         "2",
-						Name:       "user1",
-						Email:      "user1@headscale.net",
-						Provider:   "oidc",
-						ProviderId: iss + "/user1",
-					},
-					{
-						Id:   "3",
-						Name: "user2",
-					},
-					{
-						Id:         "4",
-						Name:       "user2",
-						Email:      "user2@headscale.net",
-						Provider:   "oidc",
-						ProviderId: iss + "/user2",
-					},
-				}
-			},
-		},
-		{
-			name: "no-migration-not-verified-email",
-			config: map[string]string{
-				"HEADSCALE_OIDC_MAP_LEGACY_USERS": "0",
-			},
-			emailVerified: false,
-			cliUsers:      []string{"user1", "user2"},
-			oidcUsers:     []string{"user1", "user2"},
-			want: func(iss string) []v1.User {
-				return []v1.User{
-					{
-						Id:   "1",
-						Name: "user1",
-					},
-					{
-						Id:         "2",
-						Name:       "user1",
-						Provider:   "oidc",
-						ProviderId: iss + "/user1",
-					},
-					{
-						Id:   "3",
-						Name: "user2",
-					},
-					{
-						Id:         "4",
-						Name:       "user2",
-						Provider:   "oidc",
-						ProviderId: iss + "/user2",
-					},
-				}
-			},
-		},
-		{
-			name: "migration-strip-domains-verified-email",
-			config: map[string]string{
-				"HEADSCALE_OIDC_MAP_LEGACY_USERS":   "1",
-				"HEADSCALE_OIDC_STRIP_EMAIL_DOMAIN": "1",
-			},
-			emailVerified: true,
-			cliUsers:      []string{"user1", "user2"},
-			oidcUsers:     []string{"user1", "user2"},
-			want: func(iss string) []v1.User {
-				return []v1.User{
-					{
-						Id:         "1",
-						Name:       "user1",
-						Email:      "user1@headscale.net",
-						Provider:   "oidc",
-						ProviderId: iss + "/user1",
-					},
-					{
-						Id:         "2",
-						Name:       "user2",
-						Email:      "user2@headscale.net",
-						Provider:   "oidc",
-						ProviderId: iss + "/user2",
-					},
-				}
-			},
-		},
-		{
-			name: "migration-strip-domains-not-verified-email",
-			config: map[string]string{
-				"HEADSCALE_OIDC_MAP_LEGACY_USERS":   "1",
-				"HEADSCALE_OIDC_STRIP_EMAIL_DOMAIN": "1",
-			},
-			emailVerified: false,
-			cliUsers:      []string{"user1", "user2"},
-			oidcUsers:     []string{"user1", "user2"},
-			want: func(iss string) []v1.User {
-				return []v1.User{
-					{
-						Id:   "1",
-						Name: "user1",
-					},
-					{
-						Id:         "2",
-						Name:       "user1",
-						Provider:   "oidc",
-						ProviderId: iss + "/user1",
-					},
-					{
-						Id:   "3",
-						Name: "user2",
-					},
-					{
-						Id:         "4",
-						Name:       "user2",
-						Provider:   "oidc",
-						ProviderId: iss + "/user2",
-					},
-				}
-			},
-		},
-		{
-			name: "migration-no-strip-domains-verified-email",
-			config: map[string]string{
-				"HEADSCALE_OIDC_MAP_LEGACY_USERS":   "1",
-				"HEADSCALE_OIDC_STRIP_EMAIL_DOMAIN": "0",
-			},
-			emailVerified: true,
-			cliUsers:      []string{"user1.headscale.net", "user2.headscale.net"},
-			oidcUsers:     []string{"user1", "user2"},
-			want: func(iss string) []v1.User {
-				return []v1.User{
-					// Hmm I think we will have to overwrite the initial name here
-					// createuser with "user1.headscale.net", but oidc with "user1"
-					{
-						Id:         "1",
-						Name:       "user1",
-						Email:      "user1@headscale.net",
-						Provider:   "oidc",
-						ProviderId: iss + "/user1",
-					},
-					{
-						Id:         "2",
-						Name:       "user2",
-						Email:      "user2@headscale.net",
-						Provider:   "oidc",
-						ProviderId: iss + "/user2",
-					},
-				}
-			},
-		},
-		{
-			name: "migration-no-strip-domains-not-verified-email",
-			config: map[string]string{
-				"HEADSCALE_OIDC_MAP_LEGACY_USERS":   "1",
-				"HEADSCALE_OIDC_STRIP_EMAIL_DOMAIN": "0",
-			},
-			emailVerified: false,
-			cliUsers:      []string{"user1.headscale.net", "user2.headscale.net"},
-			oidcUsers:     []string{"user1", "user2"},
-			want: func(iss string) []v1.User {
-				return []v1.User{
-					{
-						Id:   "1",
-						Name: "user1.headscale.net",
-					},
-					{
-						Id:         "2",
-						Name:       "user1",
-						Provider:   "oidc",
-						ProviderId: iss + "/user1",
-					},
-					{
-						Id:   "3",
-						Name: "user2.headscale.net",
-					},
-					{
-						Id:         "4",
-						Name:       "user2",
-						Provider:   "oidc",
-						ProviderId: iss + "/user2",
-					},
-				}
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			baseScenario, err := NewScenario(dockertestMaxWait())
-			assertNoErr(t, err)
-
-			scenario := AuthOIDCScenario{
-				Scenario: baseScenario,
-			}
-			defer scenario.ShutdownAssertNoPanics(t)
-
-			spec := map[string]int{}
-			for _, user := range tt.cliUsers {
-				spec[user] = 1
-			}
-
-			var mockusers []mockoidc.MockUser
-			for _, user := range tt.oidcUsers {
-				mockusers = append(mockusers, oidcMockUser(user, tt.emailVerified))
-			}
-
-			oidcConfig, err := scenario.runMockOIDC(defaultAccessTTL, mockusers)
-			assertNoErrf(t, "failed to run mock OIDC server: %s", err)
-			defer scenario.mockOIDC.Close()
-
-			oidcMap := map[string]string{
-				"HEADSCALE_OIDC_ISSUER":             oidcConfig.Issuer,
-				"HEADSCALE_OIDC_CLIENT_ID":          oidcConfig.ClientID,
-				"CREDENTIALS_DIRECTORY_TEST":        "/tmp",
-				"HEADSCALE_OIDC_CLIENT_SECRET_PATH": "${CREDENTIALS_DIRECTORY_TEST}/hs_client_oidc_secret",
-			}
-
-			for k, v := range tt.config {
-				oidcMap[k] = v
-			}
-
-			err = scenario.CreateHeadscaleEnv(
-				spec,
-				hsic.WithTestName("oidcmigration"),
-				hsic.WithConfigEnv(oidcMap),
-				hsic.WithTLS(),
-				hsic.WithHostnameAsServerURL(),
-				hsic.WithFileInContainer("/tmp/hs_client_oidc_secret", []byte(oidcConfig.ClientSecret)),
-			)
-			assertNoErrHeadscaleEnv(t, err)
-
-			// Ensure that the nodes have logged in, this is what
-			// triggers user creation via OIDC.
-			err = scenario.WaitForTailscaleSync()
-			assertNoErrSync(t, err)
-
-			headscale, err := scenario.Headscale()
-			assertNoErr(t, err)
-
-			want := tt.want(oidcConfig.Issuer)
-
-			var listUsers []v1.User
-			err = executeAndUnmarshal(headscale,
-				[]string{
-					"headscale",
-					"users",
-					"list",
-					"--output",
-					"json",
-				},
-				&listUsers,
-			)
-			assertNoErr(t, err)
-
-			sort.Slice(listUsers, func(i, j int) bool {
-				return listUsers[i].Id < listUsers[j].Id
-			})
-
-			if diff := cmp.Diff(want, listUsers, cmpopts.IgnoreUnexported(v1.User{}), cmpopts.IgnoreFields(v1.User{}, "CreatedAt")); diff != "" {
-				t.Errorf("unexpected users: %s", diff)
-			}
-		})
-	}
-}
-
 func (s *AuthOIDCScenario) CreateHeadscaleEnv(
 	users map[string]int,
 	opts ...hsic.Option,
@ -539,13 +174,6 @@ func (s *AuthOIDCScenario) CreateHeadscaleEnv(
 	}

 	for userName, clientCount := range users {
-		if clientCount != 1 {
-			// OIDC scenario only supports one client per user.
-			// This is because the MockOIDC server can only serve login
-			// requests based on a queue it has been given on startup.
-			// We currently only populates it with one login request per user.
-			return fmt.Errorf("client count must be 1 for OIDC scenario.")
-		}
 		log.Printf("creating user %s with %d clients", userName, clientCount)
 		err = s.CreateUser(userName)
 		if err != nil {
@ -566,7 +194,7 @@ func (s *AuthOIDCScenario) CreateHeadscaleEnv(
 	return nil
 }

-func (s *AuthOIDCScenario) runMockOIDC(accessTTL time.Duration, users []mockoidc.MockUser) (*types.OIDCConfig, error) {
+func (s *AuthOIDCScenario) runMockOIDC(accessTTL time.Duration) (*types.OIDCConfig, error) {
 	port, err := dockertestutil.RandomFreeHostPort()
 	if err != nil {
 		log.Fatalf("could not find an open port: %s", err)
@ -577,11 +205,6 @@ func (s *AuthOIDCScenario) runMockOIDC(accessTTL time.Duration, users []mockoidc

 	hostname := fmt.Sprintf("hs-oidcmock-%s", hash)

-	usersJSON, err := json.Marshal(users)
-	if err != nil {
-		return nil, err
-	}
-
 	mockOidcOptions := &dockertest.RunOptions{
 		Name:         hostname,
 		Cmd:          []string{"headscale", "mockoidc"},
@ -596,12 +219,11 @@ func (s *AuthOIDCScenario) runMockOIDC(accessTTL time.Duration, users []mockoidc
 			"MOCKOIDC_CLIENT_ID=superclient",
 			"MOCKOIDC_CLIENT_SECRET=supersecret",
 			fmt.Sprintf("MOCKOIDC_ACCESS_TTL=%s", accessTTL.String()),
-			fmt.Sprintf("MOCKOIDC_USERS=%s", string(usersJSON)),
 		},
 	}

 	headscaleBuildOptions := &dockertest.BuildOptions{
-		Dockerfile: hsic.IntegrationTestDockerFileName,
+		Dockerfile: "Dockerfile.debug",
 		ContextDir: dockerContextPath,
 	}

@ -688,6 +310,7 @@ func (s *AuthOIDCScenario) runTailscaleUp(

 				log.Printf("%s login url: %s\n", c.Hostname(), loginURL.String())

+				if err := s.pool.Retry(func() error {
 					log.Printf("%s logging in with url", c.Hostname())
 					httpClient := &http.Client{Transport: insecureTransport}
 					ctx := context.Background()
@ -706,8 +329,6 @@ func (s *AuthOIDCScenario) runTailscaleUp(

 					if resp.StatusCode != http.StatusOK {
 						log.Printf("%s response code of oidc login request was %s", c.Hostname(), resp.Status)
-					body, _ := io.ReadAll(resp.Body)
-					log.Printf("body: %s", body)

 						return errStatusCodeNotOK
 					}
@ -721,7 +342,13 @@ func (s *AuthOIDCScenario) runTailscaleUp(
 						return err
 					}

+					return nil
+				}); err != nil {
+					return err
+				}
+
 				log.Printf("Finished request for %s to join tailnet", c.Hostname())
+
 				return nil
 			})

@ -768,12 +395,3 @@ func assertTailscaleNodesLogout(t *testing.T, clients []TailscaleClient) {
 		assert.Equal(t, "NeedsLogin", status.BackendState)
 	}
 }
-
-func oidcMockUser(username string, emailVerified bool) mockoidc.MockUser {
-	return mockoidc.MockUser{
-		Subject:           username,
-		PreferredUsername: username,
-		Email:             fmt.Sprintf("%s@headscale.net", username),
-		EmailVerified:     emailVerified,
-	}
-}
--- a/integration/cli_test.go
+++ b/integration/cli_test.go
@ -13,7 +13,6 @@ import (
 	"github.com/juanfont/headscale/integration/hsic"
 	"github.com/juanfont/headscale/integration/tsic"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )

 func executeAndUnmarshal[T any](headscale ControlServer, command []string, result T) error {
@ -35,7 +34,7 @@ func TestUserCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -44,10 +43,10 @@ func TestUserCommand(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	var listUsers []v1.User
 	err = executeAndUnmarshal(headscale,
@ -60,7 +59,7 @@ func TestUserCommand(t *testing.T) {
 		},
 		&listUsers,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	result := []string{listUsers[0].GetName(), listUsers[1].GetName()}
 	sort.Strings(result)
@ -82,7 +81,7 @@ func TestUserCommand(t *testing.T) {
 			"newname",
 		},
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	var listAfterRenameUsers []v1.User
 	err = executeAndUnmarshal(headscale,
@ -95,7 +94,7 @@ func TestUserCommand(t *testing.T) {
 		},
 		&listAfterRenameUsers,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	result = []string{listAfterRenameUsers[0].GetName(), listAfterRenameUsers[1].GetName()}
 	sort.Strings(result)
@ -115,7 +114,7 @@ func TestPreAuthKeyCommand(t *testing.T) {
 	count := 3

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -123,13 +122,13 @@ func TestPreAuthKeyCommand(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clipak"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	keys := make([]*v1.PreAuthKey, count)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	for index := 0; index < count; index++ {
 		var preAuthKey v1.PreAuthKey
@ -151,7 +150,7 @@ func TestPreAuthKeyCommand(t *testing.T) {
 			},
 			&preAuthKey,
 		)
-		require.NoError(t, err)
+		assertNoErr(t, err)

 		keys[index] = &preAuthKey
 	}
@ -172,7 +171,7 @@ func TestPreAuthKeyCommand(t *testing.T) {
 		},
 		&listedPreAuthKeys,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// There is one key created by "scenario.CreateHeadscaleEnv"
 	assert.Len(t, listedPreAuthKeys, 4)
@ -213,9 +212,7 @@ func TestPreAuthKeyCommand(t *testing.T) {
 			continue
 		}

-		tags := listedPreAuthKeys[index].GetAclTags()
-		sort.Strings(tags)
-		assert.Equal(t, []string{"tag:test1", "tag:test2"}, tags)
+		assert.Equal(t, listedPreAuthKeys[index].GetAclTags(), []string{"tag:test1", "tag:test2"})
 	}

 	// Test key expiry
@ -229,7 +226,7 @@ func TestPreAuthKeyCommand(t *testing.T) {
 			listedPreAuthKeys[1].GetKey(),
 		},
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	var listedPreAuthKeysAfterExpire []v1.PreAuthKey
 	err = executeAndUnmarshal(
@ -245,7 +242,7 @@ func TestPreAuthKeyCommand(t *testing.T) {
 		},
 		&listedPreAuthKeysAfterExpire,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	assert.True(t, listedPreAuthKeysAfterExpire[1].GetExpiration().AsTime().Before(time.Now()))
 	assert.True(t, listedPreAuthKeysAfterExpire[2].GetExpiration().AsTime().After(time.Now()))
@ -259,7 +256,7 @@ func TestPreAuthKeyCommandWithoutExpiry(t *testing.T) {
 	user := "pre-auth-key-without-exp-user"

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -267,10 +264,10 @@ func TestPreAuthKeyCommandWithoutExpiry(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clipaknaexp"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	var preAuthKey v1.PreAuthKey
 	err = executeAndUnmarshal(
@ -287,7 +284,7 @@ func TestPreAuthKeyCommandWithoutExpiry(t *testing.T) {
 		},
 		&preAuthKey,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	var listedPreAuthKeys []v1.PreAuthKey
 	err = executeAndUnmarshal(
@ -303,7 +300,7 @@ func TestPreAuthKeyCommandWithoutExpiry(t *testing.T) {
 		},
 		&listedPreAuthKeys,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// There is one key created by "scenario.CreateHeadscaleEnv"
 	assert.Len(t, listedPreAuthKeys, 2)
@ -322,7 +319,7 @@ func TestPreAuthKeyCommandReusableEphemeral(t *testing.T) {
 	user := "pre-auth-key-reus-ephm-user"

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -330,10 +327,10 @@ func TestPreAuthKeyCommandReusableEphemeral(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clipakresueeph"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	var preAuthReusableKey v1.PreAuthKey
 	err = executeAndUnmarshal(
@ -350,7 +347,7 @@ func TestPreAuthKeyCommandReusableEphemeral(t *testing.T) {
 		},
 		&preAuthReusableKey,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	var preAuthEphemeralKey v1.PreAuthKey
 	err = executeAndUnmarshal(
@ -367,7 +364,7 @@ func TestPreAuthKeyCommandReusableEphemeral(t *testing.T) {
 		},
 		&preAuthEphemeralKey,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	assert.True(t, preAuthEphemeralKey.GetEphemeral())
 	assert.False(t, preAuthEphemeralKey.GetReusable())
@ -386,7 +383,7 @@ func TestPreAuthKeyCommandReusableEphemeral(t *testing.T) {
 		},
 		&listedPreAuthKeys,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// There is one key created by "scenario.CreateHeadscaleEnv"
 	assert.Len(t, listedPreAuthKeys, 3)
@ -400,7 +397,7 @@ func TestPreAuthKeyCorrectUserLoggedInCommand(t *testing.T) {
 	user2 := "user2"

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -416,10 +413,10 @@ func TestPreAuthKeyCorrectUserLoggedInCommand(t *testing.T) {
 		hsic.WithTLS(),
 		hsic.WithHostnameAsServerURL(),
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	var user2Key v1.PreAuthKey

@ -441,10 +438,10 @@ func TestPreAuthKeyCorrectUserLoggedInCommand(t *testing.T) {
 		},
 		&user2Key,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	allClients, err := scenario.ListTailscaleClients()
-	require.NoError(t, err)
+	assertNoErrListClients(t, err)

 	assert.Len(t, allClients, 1)

@ -452,22 +449,22 @@ func TestPreAuthKeyCorrectUserLoggedInCommand(t *testing.T) {

 	// Log out from user1
 	err = client.Logout()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	err = scenario.WaitForTailscaleLogout()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	status, err := client.Status()
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	if status.BackendState == "Starting" || status.BackendState == "Running" {
 		t.Fatalf("expected node to be logged out, backend state: %s", status.BackendState)
 	}

 	err = client.Login(headscale.GetEndpoint(), user2Key.GetKey())
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	status, err = client.Status()
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	if status.BackendState != "Running" {
 		t.Fatalf("expected node to be logged in, backend state: %s", status.BackendState)
 	}
@ -488,7 +485,7 @@ func TestPreAuthKeyCorrectUserLoggedInCommand(t *testing.T) {
 		},
 		&listNodes,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)
 	assert.Len(t, listNodes, 1)

 	assert.Equal(t, "user2", listNodes[0].GetUser().GetName())
@ -501,7 +498,7 @@ func TestApiKeyCommand(t *testing.T) {
 	count := 5

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -510,10 +507,10 @@ func TestApiKeyCommand(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	keys := make([]string, count)

@ -529,7 +526,7 @@ func TestApiKeyCommand(t *testing.T) {
 				"json",
 			},
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)
 		assert.NotEmpty(t, apiResult)

 		keys[idx] = apiResult
@ -548,7 +545,7 @@ func TestApiKeyCommand(t *testing.T) {
 		},
 		&listedAPIKeys,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listedAPIKeys, 5)

@ -604,7 +601,7 @@ func TestApiKeyCommand(t *testing.T) {
 				listedAPIKeys[idx].GetPrefix(),
 			},
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		expiredPrefixes[listedAPIKeys[idx].GetPrefix()] = true
 	}
@ -620,7 +617,7 @@ func TestApiKeyCommand(t *testing.T) {
 		},
 		&listedAfterExpireAPIKeys,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	for index := range listedAfterExpireAPIKeys {
 		if _, ok := expiredPrefixes[listedAfterExpireAPIKeys[index].GetPrefix()]; ok {
@ -646,7 +643,7 @@ func TestApiKeyCommand(t *testing.T) {
 			"--prefix",
 			listedAPIKeys[0].GetPrefix(),
 		})
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	var listedAPIKeysAfterDelete []v1.ApiKey
 	err = executeAndUnmarshal(headscale,
@ -659,7 +656,7 @@ func TestApiKeyCommand(t *testing.T) {
 		},
 		&listedAPIKeysAfterDelete,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listedAPIKeysAfterDelete, 4)
 }
@ -669,7 +666,7 @@ func TestNodeTagCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -677,17 +674,17 @@ func TestNodeTagCommand(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	machineKeys := []string{
 		"mkey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
 		"mkey:6abd00bb5fdda622db51387088c68e97e71ce58e7056aa54f592b6a8219d524c",
 	}
 	nodes := make([]*v1.Node, len(machineKeys))
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	for index, machineKey := range machineKeys {
 		_, err := headscale.Execute(
@ -705,7 +702,7 @@ func TestNodeTagCommand(t *testing.T) {
 				"json",
 			},
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		var node v1.Node
 		err = executeAndUnmarshal(
@ -723,7 +720,7 @@ func TestNodeTagCommand(t *testing.T) {
 			},
 			&node,
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		nodes[index] = &node
 	}
@ -742,7 +739,7 @@ func TestNodeTagCommand(t *testing.T) {
 		},
 		&node,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Equal(t, []string{"tag:test"}, node.GetForcedTags())

@ -756,7 +753,7 @@ func TestNodeTagCommand(t *testing.T) {
 			"--output", "json",
 		},
 	)
-	require.ErrorContains(t, err, "tag must start with the string 'tag:'")
+	assert.ErrorContains(t, err, "tag must start with the string 'tag:'")

 	// Test list all nodes after added seconds
 	resultMachines := make([]*v1.Node, len(machineKeys))
@ -770,7 +767,7 @@ func TestNodeTagCommand(t *testing.T) {
 		},
 		&resultMachines,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)
 	found := false
 	for _, node := range resultMachines {
 		if node.GetForcedTags() != nil {
@ -781,8 +778,9 @@ func TestNodeTagCommand(t *testing.T) {
 			}
 		}
 	}
-	assert.True(
+	assert.Equal(
 		t,
+		true,
 		found,
 		"should find a node with the tag 'tag:test' in the list of nodes",
 	)
@ -793,22 +791,18 @@ func TestNodeAdvertiseTagNoACLCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
 		"user1": 1,
 	}

-	err = scenario.CreateHeadscaleEnv(
-		spec,
-		[]tsic.Option{tsic.WithTags([]string{"tag:test"})},
-		hsic.WithTestName("cliadvtags"),
-	)
-	require.NoError(t, err)
+	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{tsic.WithTags([]string{"tag:test"})}, hsic.WithTestName("cliadvtags"))
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Test list all nodes after added seconds
 	resultMachines := make([]*v1.Node, spec["user1"])
@ -823,7 +817,7 @@ func TestNodeAdvertiseTagNoACLCommand(t *testing.T) {
 		},
 		&resultMachines,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)
 	found := false
 	for _, node := range resultMachines {
 		if node.GetInvalidTags() != nil {
@ -834,8 +828,9 @@ func TestNodeAdvertiseTagNoACLCommand(t *testing.T) {
 			}
 		}
 	}
-	assert.True(
+	assert.Equal(
 		t,
+		true,
 		found,
 		"should not find a node with the tag 'tag:test' in the list of nodes",
 	)
@ -846,18 +841,14 @@ func TestNodeAdvertiseTagWithACLCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
 		"user1": 1,
 	}

-	err = scenario.CreateHeadscaleEnv(
-		spec,
-		[]tsic.Option{tsic.WithTags([]string{"tag:exists"})},
-		hsic.WithTestName("cliadvtags"),
-		hsic.WithACLPolicy(
+	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{tsic.WithTags([]string{"tag:exists"})}, hsic.WithTestName("cliadvtags"), hsic.WithACLPolicy(
 		&policy.ACLPolicy{
 			ACLs: []policy.ACL{
 				{
@ -870,12 +861,11 @@ func TestNodeAdvertiseTagWithACLCommand(t *testing.T) {
 				"tag:exists": {"user1"},
 			},
 		},
-		),
-	)
-	require.NoError(t, err)
+	))
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Test list all nodes after added seconds
 	resultMachines := make([]*v1.Node, spec["user1"])
@ -890,7 +880,7 @@ func TestNodeAdvertiseTagWithACLCommand(t *testing.T) {
 		},
 		&resultMachines,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)
 	found := false
 	for _, node := range resultMachines {
 		if node.GetValidTags() != nil {
@ -901,8 +891,9 @@ func TestNodeAdvertiseTagWithACLCommand(t *testing.T) {
 			}
 		}
 	}
-	assert.True(
+	assert.Equal(
 		t,
+		true,
 		found,
 		"should not find a node with the tag 'tag:exists' in the list of nodes",
 	)
@ -913,7 +904,7 @@ func TestNodeCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -922,10 +913,10 @@ func TestNodeCommand(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Pregenerated machine keys
 	machineKeys := []string{
@ -936,7 +927,7 @@ func TestNodeCommand(t *testing.T) {
 		"mkey:cf7b0fd05da556fdc3bab365787b506fd82d64a70745db70e00e86c1b1c03084",
 	}
 	nodes := make([]*v1.Node, len(machineKeys))
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	for index, machineKey := range machineKeys {
 		_, err := headscale.Execute(
@ -954,7 +945,7 @@ func TestNodeCommand(t *testing.T) {
 				"json",
 			},
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		var node v1.Node
 		err = executeAndUnmarshal(
@ -972,7 +963,7 @@ func TestNodeCommand(t *testing.T) {
 			},
 			&node,
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		nodes[index] = &node
 	}
@ -992,7 +983,7 @@ func TestNodeCommand(t *testing.T) {
 		},
 		&listAll,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listAll, 5)

@ -1013,7 +1004,7 @@ func TestNodeCommand(t *testing.T) {
 		"mkey:dc721977ac7415aafa87f7d4574cbe07c6b171834a6d37375782bdc1fb6b3584",
 	}
 	otherUserMachines := make([]*v1.Node, len(otherUserMachineKeys))
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	for index, machineKey := range otherUserMachineKeys {
 		_, err := headscale.Execute(
@ -1031,7 +1022,7 @@ func TestNodeCommand(t *testing.T) {
 				"json",
 			},
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		var node v1.Node
 		err = executeAndUnmarshal(
@ -1049,7 +1040,7 @@ func TestNodeCommand(t *testing.T) {
 			},
 			&node,
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		otherUserMachines[index] = &node
 	}
@ -1069,7 +1060,7 @@ func TestNodeCommand(t *testing.T) {
 		},
 		&listAllWithotherUser,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	// All nodes, nodes + otherUser
 	assert.Len(t, listAllWithotherUser, 7)
@ -1095,7 +1086,7 @@ func TestNodeCommand(t *testing.T) {
 		},
 		&listOnlyotherUserMachineUser,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listOnlyotherUserMachineUser, 2)

@ -1127,7 +1118,7 @@ func TestNodeCommand(t *testing.T) {
 			"--force",
 		},
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	// Test: list main user after node is deleted
 	var listOnlyMachineUserAfterDelete []v1.Node
@ -1144,7 +1135,7 @@ func TestNodeCommand(t *testing.T) {
 		},
 		&listOnlyMachineUserAfterDelete,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listOnlyMachineUserAfterDelete, 4)
 }
@ -1154,7 +1145,7 @@ func TestNodeExpireCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -1162,10 +1153,10 @@ func TestNodeExpireCommand(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Pregenerated machine keys
 	machineKeys := []string{
@ -1193,7 +1184,7 @@ func TestNodeExpireCommand(t *testing.T) {
 				"json",
 			},
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		var node v1.Node
 		err = executeAndUnmarshal(
@ -1211,7 +1202,7 @@ func TestNodeExpireCommand(t *testing.T) {
 			},
 			&node,
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		nodes[index] = &node
 	}
@ -1230,7 +1221,7 @@ func TestNodeExpireCommand(t *testing.T) {
 		},
 		&listAll,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listAll, 5)

@ -1250,7 +1241,7 @@ func TestNodeExpireCommand(t *testing.T) {
 				fmt.Sprintf("%d", listAll[idx].GetId()),
 			},
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)
 	}

 	var listAllAfterExpiry []v1.Node
@ -1265,7 +1256,7 @@ func TestNodeExpireCommand(t *testing.T) {
 		},
 		&listAllAfterExpiry,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listAllAfterExpiry, 5)

@ -1281,7 +1272,7 @@ func TestNodeRenameCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -1289,10 +1280,10 @@ func TestNodeRenameCommand(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Pregenerated machine keys
 	machineKeys := []string{
@ -1303,7 +1294,7 @@ func TestNodeRenameCommand(t *testing.T) {
 		"mkey:9b2ffa7e08cc421a3d2cca9012280f6a236fd0de0b4ce005b30a98ad930306fe",
 	}
 	nodes := make([]*v1.Node, len(machineKeys))
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	for index, machineKey := range machineKeys {
 		_, err := headscale.Execute(
@ -1321,7 +1312,7 @@ func TestNodeRenameCommand(t *testing.T) {
 				"json",
 			},
 		)
-		require.NoError(t, err)
+		assertNoErr(t, err)

 		var node v1.Node
 		err = executeAndUnmarshal(
@ -1339,7 +1330,7 @@ func TestNodeRenameCommand(t *testing.T) {
 			},
 			&node,
 		)
-		require.NoError(t, err)
+		assertNoErr(t, err)

 		nodes[index] = &node
 	}
@ -1358,7 +1349,7 @@ func TestNodeRenameCommand(t *testing.T) {
 		},
 		&listAll,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listAll, 5)

@ -1379,7 +1370,7 @@ func TestNodeRenameCommand(t *testing.T) {
 				fmt.Sprintf("newnode-%d", idx+1),
 			},
 		)
-		require.NoError(t, err)
+		assert.Nil(t, err)

 		assert.Contains(t, res, "Node renamed")
 	}
@ -1396,7 +1387,7 @@ func TestNodeRenameCommand(t *testing.T) {
 		},
 		&listAllAfterRename,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listAllAfterRename, 5)

@ -1417,7 +1408,7 @@ func TestNodeRenameCommand(t *testing.T) {
 			strings.Repeat("t", 64),
 		},
 	)
-	require.ErrorContains(t, err, "not be over 63 chars")
+	assert.ErrorContains(t, err, "not be over 63 chars")

 	var listAllAfterRenameAttempt []v1.Node
 	err = executeAndUnmarshal(
@ -1431,7 +1422,7 @@ func TestNodeRenameCommand(t *testing.T) {
 		},
 		&listAllAfterRenameAttempt,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, listAllAfterRenameAttempt, 5)

@ -1447,7 +1438,7 @@ func TestNodeMoveCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -1456,10 +1447,10 @@ func TestNodeMoveCommand(t *testing.T) {
 	}

 	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{}, hsic.WithTestName("clins"))
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Randomly generated node key
 	machineKey := "mkey:688411b767663479632d44140f08a9fde87383adc7cdeb518f62ce28a17ef0aa"
@ -1479,7 +1470,7 @@ func TestNodeMoveCommand(t *testing.T) {
 			"json",
 		},
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	var node v1.Node
 	err = executeAndUnmarshal(
@ -1497,11 +1488,11 @@ func TestNodeMoveCommand(t *testing.T) {
 		},
 		&node,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Equal(t, uint64(1), node.GetId())
 	assert.Equal(t, "nomad-node", node.GetName())
-	assert.Equal(t, "old-user", node.GetUser().GetName())
+	assert.Equal(t, node.GetUser().GetName(), "old-user")

 	nodeID := fmt.Sprintf("%d", node.GetId())

@ -1520,9 +1511,9 @@ func TestNodeMoveCommand(t *testing.T) {
 		},
 		&node,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

-	assert.Equal(t, "new-user", node.GetUser().GetName())
+	assert.Equal(t, node.GetUser().GetName(), "new-user")

 	var allNodes []v1.Node
 	err = executeAndUnmarshal(
@ -1536,13 +1527,13 @@ func TestNodeMoveCommand(t *testing.T) {
 		},
 		&allNodes,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	assert.Len(t, allNodes, 1)

 	assert.Equal(t, allNodes[0].GetId(), node.GetId())
 	assert.Equal(t, allNodes[0].GetUser(), node.GetUser())
-	assert.Equal(t, "new-user", allNodes[0].GetUser().GetName())
+	assert.Equal(t, allNodes[0].GetUser().GetName(), "new-user")

 	_, err = headscale.Execute(
 		[]string{
@ -1557,12 +1548,12 @@ func TestNodeMoveCommand(t *testing.T) {
 			"json",
 		},
 	)
-	require.ErrorContains(
+	assert.ErrorContains(
 		t,
 		err,
 		"user not found",
 	)
-	assert.Equal(t, "new-user", node.GetUser().GetName())
+	assert.Equal(t, node.GetUser().GetName(), "new-user")

 	err = executeAndUnmarshal(
 		headscale,
@ -1579,9 +1570,9 @@ func TestNodeMoveCommand(t *testing.T) {
 		},
 		&node,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

-	assert.Equal(t, "old-user", node.GetUser().GetName())
+	assert.Equal(t, node.GetUser().GetName(), "old-user")

 	err = executeAndUnmarshal(
 		headscale,
@ -1598,9 +1589,9 @@ func TestNodeMoveCommand(t *testing.T) {
 		},
 		&node,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

-	assert.Equal(t, "old-user", node.GetUser().GetName())
+	assert.Equal(t, node.GetUser().GetName(), "old-user")
 }

 func TestPolicyCommand(t *testing.T) {
@ -1608,7 +1599,7 @@ func TestPolicyCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -1623,10 +1614,10 @@ func TestPolicyCommand(t *testing.T) {
 			"HEADSCALE_POLICY_MODE": "database",
 		}),
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	p := policy.ACLPolicy{
 		ACLs: []policy.ACL{
@ -1646,7 +1637,7 @@ func TestPolicyCommand(t *testing.T) {
 	policyFilePath := "/etc/headscale/policy.json"

 	err = headscale.WriteFile(policyFilePath, pBytes)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// No policy is present at this time.
 	// Add a new policy from a file.
@ -1660,7 +1651,7 @@ func TestPolicyCommand(t *testing.T) {
 		},
 	)

-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// Get the current policy and check
 	// if it is the same as the one we set.
@ -1676,11 +1667,11 @@ func TestPolicyCommand(t *testing.T) {
 		},
 		&output,
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	assert.Len(t, output.TagOwners, 1)
 	assert.Len(t, output.ACLs, 1)
-	assert.Equal(t, []string{"policy-user"}, output.TagOwners["tag:exists"])
+	assert.Equal(t, output.TagOwners["tag:exists"], []string{"policy-user"})
 }

 func TestPolicyBrokenConfigCommand(t *testing.T) {
@ -1688,7 +1679,7 @@ func TestPolicyBrokenConfigCommand(t *testing.T) {
 	t.Parallel()

 	scenario, err := NewScenario(dockertestMaxWait())
-	require.NoError(t, err)
+	assertNoErr(t, err)
 	defer scenario.ShutdownAssertNoPanics(t)

 	spec := map[string]int{
@ -1703,10 +1694,10 @@ func TestPolicyBrokenConfigCommand(t *testing.T) {
 			"HEADSCALE_POLICY_MODE": "database",
 		}),
 	)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	headscale, err := scenario.Headscale()
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	p := policy.ACLPolicy{
 		ACLs: []policy.ACL{
@ -1728,7 +1719,7 @@ func TestPolicyBrokenConfigCommand(t *testing.T) {
 	policyFilePath := "/etc/headscale/policy.json"

 	err = headscale.WriteFile(policyFilePath, pBytes)
-	require.NoError(t, err)
+	assertNoErr(t, err)

 	// No policy is present at this time.
 	// Add a new policy from a file.
@ -1741,7 +1732,7 @@ func TestPolicyBrokenConfigCommand(t *testing.T) {
 			policyFilePath,
 		},
 	)
-	require.ErrorContains(t, err, "verifying policy rules: invalid action")
+	assert.ErrorContains(t, err, "verifying policy rules: invalid action")

 	// The new policy was invalid, the old one should still be in place, which
 	// is none.
@ -1754,5 +1745,5 @@ func TestPolicyBrokenConfigCommand(t *testing.T) {
 			"json",
 		},
 	)
-	require.ErrorContains(t, err, "acl policy not found")
+	assert.ErrorContains(t, err, "acl policy not found")
 }
--- a/integration/derp_verify_endpoint_test.go
+++ b/integration/derp_verify_endpoint_test.go
@ -1,96 +0,0 @@
-package integration
-
-import (
-	"encoding/json"
-	"fmt"
-	"net"
-	"strconv"
-	"strings"
-	"testing"
-
-	"github.com/juanfont/headscale/hscontrol/util"
-	"github.com/juanfont/headscale/integration/dsic"
-	"github.com/juanfont/headscale/integration/hsic"
-	"github.com/juanfont/headscale/integration/integrationutil"
-	"github.com/juanfont/headscale/integration/tsic"
-	"tailscale.com/tailcfg"
-)
-
-func TestDERPVerifyEndpoint(t *testing.T) {
-	IntegrationSkip(t)
-
-	// Generate random hostname for the headscale instance
-	hash, err := util.GenerateRandomStringDNSSafe(6)
-	assertNoErr(t, err)
-	testName := "derpverify"
-	hostname := fmt.Sprintf("hs-%s-%s", testName, hash)
-
-	headscalePort := 8080
-
-	// Create cert for headscale
-	certHeadscale, keyHeadscale, err := integrationutil.CreateCertificate(hostname)
-	assertNoErr(t, err)
-
-	scenario, err := NewScenario(dockertestMaxWait())
-	assertNoErr(t, err)
-	defer scenario.ShutdownAssertNoPanics(t)
-
-	spec := map[string]int{
-		"user1": len(MustTestVersions),
-	}
-
-	derper, err := scenario.CreateDERPServer("head",
-		dsic.WithCACert(certHeadscale),
-		dsic.WithVerifyClientURL(fmt.Sprintf("https://%s/verify", net.JoinHostPort(hostname, strconv.Itoa(headscalePort)))),
-	)
-	assertNoErr(t, err)
-
-	derpMap := tailcfg.DERPMap{
-		Regions: map[int]*tailcfg.DERPRegion{
-			900: {
-				RegionID:   900,
-				RegionCode: "test-derpverify",
-				RegionName: "TestDerpVerify",
-				Nodes: []*tailcfg.DERPNode{
-					{
-						Name:     "TestDerpVerify",
-						RegionID: 900,
-						HostName: derper.GetHostname(),
-						STUNPort: derper.GetSTUNPort(),
-						STUNOnly: false,
-						DERPPort: derper.GetDERPPort(),
-					},
-				},
-			},
-		},
-	}
-
-	err = scenario.CreateHeadscaleEnv(spec, []tsic.Option{tsic.WithCACert(derper.GetCert())},
-		hsic.WithHostname(hostname),
-		hsic.WithPort(headscalePort),
-		hsic.WithCustomTLS(certHeadscale, keyHeadscale),
-		hsic.WithHostnameAsServerURL(),
-		hsic.WithDERPConfig(derpMap))
-	assertNoErrHeadscaleEnv(t, err)
-
-	allClients, err := scenario.ListTailscaleClients()
-	assertNoErrListClients(t, err)
-
-	for _, client := range allClients {
-		report, err := client.DebugDERPRegion("test-derpverify")
-		assertNoErr(t, err)
-		successful := false
-		for _, line := range report.Info {
-			if strings.Contains(line, "Successfully established a DERP connection with node") {
-				successful = true
-
-				break
-			}
-		}
-		if !successful {
-			stJSON, err := json.Marshal(report)
-			assertNoErr(t, err)
-			t.Errorf("Client %s could not establish a DERP connection: %s", client.Hostname(), string(stJSON))
-		}
-	}
-}
--- a/integration/dockertestutil/execute.go
+++ b/integration/dockertestutil/execute.go
@ -74,7 +74,7 @@ func ExecuteCommand(
 	select {
 	case res := <-resultChan:
 		if res.err != nil {
-			return stdout.String(), stderr.String(), fmt.Errorf("command failed, stderr: %s: %w", stderr.String(), res.err)
+			return stdout.String(), stderr.String(), res.err
 		}

 		if res.exitCode != 0 {
@ -83,12 +83,12 @@ func ExecuteCommand(
 			// log.Println("stdout: ", stdout.String())
 			// log.Println("stderr: ", stderr.String())

-			return stdout.String(), stderr.String(), fmt.Errorf("command failed, stderr: %s: %w", stderr.String(), ErrDockertestCommandFailed)
+			return stdout.String(), stderr.String(), ErrDockertestCommandFailed
 		}

 		return stdout.String(), stderr.String(), nil
 	case <-time.After(execConfig.timeout):

-		return stdout.String(), stderr.String(), fmt.Errorf("command failed, stderr: %s: %w", stderr.String(), ErrDockertestCommandTimeout)
+		return stdout.String(), stderr.String(), ErrDockertestCommandTimeout
 	}
 }
--- a/integration/dsic/dsic.go
+++ b/integration/dsic/dsic.go
@ -1,321 +0,0 @@
-package dsic
-
-import (
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"log"
-	"net"
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/juanfont/headscale/hscontrol/util"
-	"github.com/juanfont/headscale/integration/dockertestutil"
-	"github.com/juanfont/headscale/integration/integrationutil"
-	"github.com/ory/dockertest/v3"
-	"github.com/ory/dockertest/v3/docker"
-)
-
-const (
-	dsicHashLength       = 6
-	dockerContextPath    = "../."
-	caCertRoot           = "/usr/local/share/ca-certificates"
-	DERPerCertRoot       = "/usr/local/share/derper-certs"
-	dockerExecuteTimeout = 60 * time.Second
-)
-
-var errDERPerStatusCodeNotOk = errors.New("DERPer status code not OK")
-
-// DERPServerInContainer represents DERP Server in Container (DSIC).
-type DERPServerInContainer struct {
-	version  string
-	hostname string
-
-	pool      *dockertest.Pool
-	container *dockertest.Resource
-	network   *dockertest.Network
-
-	stunPort            int
-	derpPort            int
-	caCerts             [][]byte
-	tlsCert             []byte
-	tlsKey              []byte
-	withExtraHosts      []string
-	withVerifyClientURL string
-	workdir             string
-}
-
-// Option represent optional settings that can be given to a
-// DERPer instance.
-type Option = func(c *DERPServerInContainer)
-
-// WithCACert adds it to the trusted surtificate of the Tailscale container.
-func WithCACert(cert []byte) Option {
-	return func(dsic *DERPServerInContainer) {
-		dsic.caCerts = append(dsic.caCerts, cert)
-	}
-}
-
-// WithOrCreateNetwork sets the Docker container network to use with
-// the DERPer instance, if the parameter is nil, a new network,
-// isolating the DERPer, will be created. If a network is
-// passed, the DERPer instance will join the given network.
-func WithOrCreateNetwork(network *dockertest.Network) Option {
-	return func(tsic *DERPServerInContainer) {
-		if network != nil {
-			tsic.network = network
-
-			return
-		}
-
-		network, err := dockertestutil.GetFirstOrCreateNetwork(
-			tsic.pool,
-			tsic.hostname+"-network",
-		)
-		if err != nil {
-			log.Fatalf("failed to create network: %s", err)
-		}
-
-		tsic.network = network
-	}
-}
-
-// WithDockerWorkdir allows the docker working directory to be set.
-func WithDockerWorkdir(dir string) Option {
-	return func(tsic *DERPServerInContainer) {
-		tsic.workdir = dir
-	}
-}
-
-// WithVerifyClientURL sets the URL to verify the client.
-func WithVerifyClientURL(url string) Option {
-	return func(tsic *DERPServerInContainer) {
-		tsic.withVerifyClientURL = url
-	}
-}
-
-// WithExtraHosts adds extra hosts to the container.
-func WithExtraHosts(hosts []string) Option {
-	return func(tsic *DERPServerInContainer) {
-		tsic.withExtraHosts = hosts
-	}
-}
-
-// New returns a new TailscaleInContainer instance.
-func New(
-	pool *dockertest.Pool,
-	version string,
-	network *dockertest.Network,
-	opts ...Option,
-) (*DERPServerInContainer, error) {
-	hash, err := util.GenerateRandomStringDNSSafe(dsicHashLength)
-	if err != nil {
-		return nil, err
-	}
-
-	hostname := fmt.Sprintf("derp-%s-%s", strings.ReplaceAll(version, ".", "-"), hash)
-	tlsCert, tlsKey, err := integrationutil.CreateCertificate(hostname)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create certificates for headscale test: %w", err)
-	}
-	dsic := &DERPServerInContainer{
-		version:  version,
-		hostname: hostname,
-		pool:     pool,
-		network:  network,
-		tlsCert:  tlsCert,
-		tlsKey:   tlsKey,
-		stunPort: 3478, //nolint
-		derpPort: 443,  //nolint
-	}
-
-	for _, opt := range opts {
-		opt(dsic)
-	}
-
-	var cmdArgs strings.Builder
-	fmt.Fprintf(&cmdArgs, "--hostname=%s", hostname)
-	fmt.Fprintf(&cmdArgs, " --certmode=manual")
-	fmt.Fprintf(&cmdArgs, " --certdir=%s", DERPerCertRoot)
-	fmt.Fprintf(&cmdArgs, " --a=:%d", dsic.derpPort)
-	fmt.Fprintf(&cmdArgs, " --stun=true")
-	fmt.Fprintf(&cmdArgs, " --stun-port=%d", dsic.stunPort)
-	if dsic.withVerifyClientURL != "" {
-		fmt.Fprintf(&cmdArgs, " --verify-client-url=%s", dsic.withVerifyClientURL)
-	}
-
-	runOptions := &dockertest.RunOptions{
-		Name:       hostname,
-		Networks:   []*dockertest.Network{dsic.network},
-		ExtraHosts: dsic.withExtraHosts,
-		// we currently need to give us some time to inject the certificate further down.
-		Entrypoint: []string{"/bin/sh", "-c", "/bin/sleep 3 ; update-ca-certificates ; derper " + cmdArgs.String()},
-		ExposedPorts: []string{
-			"80/tcp",
-			fmt.Sprintf("%d/tcp", dsic.derpPort),
-			fmt.Sprintf("%d/udp", dsic.stunPort),
-		},
-	}
-
-	if dsic.workdir != "" {
-		runOptions.WorkingDir = dsic.workdir
-	}
-
-	// dockertest isnt very good at handling containers that has already
-	// been created, this is an attempt to make sure this container isnt
-	// present.
-	err = pool.RemoveContainerByName(hostname)
-	if err != nil {
-		return nil, err
-	}
-
-	var container *dockertest.Resource
-	buildOptions := &dockertest.BuildOptions{
-		Dockerfile: "Dockerfile.derper",
-		ContextDir: dockerContextPath,
-		BuildArgs:  []docker.BuildArg{},
-	}
-	switch version {
-	case "head":
-		buildOptions.BuildArgs = append(buildOptions.BuildArgs, docker.BuildArg{
-			Name:  "VERSION_BRANCH",
-			Value: "main",
-		})
-	default:
-		buildOptions.BuildArgs = append(buildOptions.BuildArgs, docker.BuildArg{
-			Name:  "VERSION_BRANCH",
-			Value: "v" + version,
-		})
-	}
-	container, err = pool.BuildAndRunWithBuildOptions(
-		buildOptions,
-		runOptions,
-		dockertestutil.DockerRestartPolicy,
-		dockertestutil.DockerAllowLocalIPv6,
-		dockertestutil.DockerAllowNetworkAdministration,
-	)
-	if err != nil {
-		return nil, fmt.Errorf(
-			"%s could not start tailscale DERPer container (version: %s): %w",
-			hostname,
-			version,
-			err,
-		)
-	}
-	log.Printf("Created %s container\n", hostname)
-
-	dsic.container = container
-
-	for i, cert := range dsic.caCerts {
-		err = dsic.WriteFile(fmt.Sprintf("%s/user-%d.crt", caCertRoot, i), cert)
-		if err != nil {
-			return nil, fmt.Errorf("failed to write TLS certificate to container: %w", err)
-		}
-	}
-	if len(dsic.tlsCert) != 0 {
-		err = dsic.WriteFile(fmt.Sprintf("%s/%s.crt", DERPerCertRoot, dsic.hostname), dsic.tlsCert)
-		if err != nil {
-			return nil, fmt.Errorf("failed to write TLS certificate to container: %w", err)
-		}
-	}
-	if len(dsic.tlsKey) != 0 {
-		err = dsic.WriteFile(fmt.Sprintf("%s/%s.key", DERPerCertRoot, dsic.hostname), dsic.tlsKey)
-		if err != nil {
-			return nil, fmt.Errorf("failed to write TLS key to container: %w", err)
-		}
-	}
-
-	return dsic, nil
-}
-
-// Shutdown stops and cleans up the DERPer container.
-func (t *DERPServerInContainer) Shutdown() error {
-	err := t.SaveLog("/tmp/control")
-	if err != nil {
-		log.Printf(
-			"Failed to save log from %s: %s",
-			t.hostname,
-			fmt.Errorf("failed to save log: %w", err),
-		)
-	}
-
-	return t.pool.Purge(t.container)
-}
-
-// GetCert returns the TLS certificate of the DERPer instance.
-func (t *DERPServerInContainer) GetCert() []byte {
-	return t.tlsCert
-}
-
-// Hostname returns the hostname of the DERPer instance.
-func (t *DERPServerInContainer) Hostname() string {
-	return t.hostname
-}
-
-// Version returns the running DERPer version of the instance.
-func (t *DERPServerInContainer) Version() string {
-	return t.version
-}
-
-// ID returns the Docker container ID of the DERPServerInContainer
-// instance.
-func (t *DERPServerInContainer) ID() string {
-	return t.container.Container.ID
-}
-
-func (t *DERPServerInContainer) GetHostname() string {
-	return t.hostname
-}
-
-// GetSTUNPort returns the STUN port of the DERPer instance.
-func (t *DERPServerInContainer) GetSTUNPort() int {
-	return t.stunPort
-}
-
-// GetDERPPort returns the DERP port of the DERPer instance.
-func (t *DERPServerInContainer) GetDERPPort() int {
-	return t.derpPort
-}
-
-// WaitForRunning blocks until the DERPer instance is ready to be used.
-func (t *DERPServerInContainer) WaitForRunning() error {
-	url := "https://" + net.JoinHostPort(t.GetHostname(), strconv.Itoa(t.GetDERPPort())) + "/"
-	log.Printf("waiting for DERPer to be ready at %s", url)
-
-	insecureTransport := http.DefaultTransport.(*http.Transport).Clone()      //nolint
-	insecureTransport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true} //nolint
-	client := &http.Client{Transport: insecureTransport}
-
-	return t.pool.Retry(func() error {
-		resp, err := client.Get(url) //nolint
-		if err != nil {
-			return fmt.Errorf("headscale is not ready: %w", err)
-		}
-
-		if resp.StatusCode != http.StatusOK {
-			return errDERPerStatusCodeNotOk
-		}
-
-		return nil
-	})
-}
-
-// ConnectToNetwork connects the DERPer instance to a network.
-func (t *DERPServerInContainer) ConnectToNetwork(network *dockertest.Network) error {
-	return t.container.ConnectToNetwork(network)
-}
-
-// WriteFile save file inside the container.
-func (t *DERPServerInContainer) WriteFile(path string, data []byte) error {
-	return integrationutil.WriteFileToContainer(t.pool, t.container, path, data)
-}
-
-// SaveLog saves the current stdout log of the container to a path
-// on the host system.
-func (t *DERPServerInContainer) SaveLog(path string) error {
-	_, _, err := dockertestutil.SaveLog(t.pool, t.container, path)
-
-	return err
-}
--- a/integration/embedded_derp_test.go
+++ b/integration/embedded_derp_test.go
@ -55,7 +55,7 @@ func TestDERPServerWebsocketScenario(t *testing.T) {
 	spec := map[string]ClientsSpec{
 		"user1": {
 			Plain:         0,
-			WebsocketDERP: 2,
+			WebsocketDERP: len(MustTestVersions),
 		},
 	}

@ -239,13 +239,10 @@ func (s *EmbeddedDERPServerScenario) CreateHeadscaleEnv(

 		if clientCount.WebsocketDERP > 0 {
 			// Containers that use DERP-over-WebSocket
-			// Note that these clients *must* be built
-			// from source, which is currently
-			// only done for HEAD.
 			err = s.CreateTailscaleIsolatedNodesInUser(
 				hash,
 				userName,
-				tsic.VersionHead,
+				"all",
 				clientCount.WebsocketDERP,
 				tsic.WithWebsocketDERP(true),
 			)
@ -310,7 +307,7 @@ func (s *EmbeddedDERPServerScenario) CreateTailscaleIsolatedNodesInUser(
 			cert := hsServer.GetCert()

 			opts = append(opts,
-				tsic.WithCACert(cert),
+				tsic.WithHeadscaleTLS(cert),
 			)

 			user.createWaitGroup.Go(func() error {
--- a/integration/general_test.go
+++ b/integration/general_test.go
@ -18,7 +18,6 @@ import (
 	"github.com/rs/zerolog/log"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"golang.org/x/sync/errgroup"
 	"tailscale.com/client/tailscale/apitype"
 	"tailscale.com/types/key"
@ -245,11 +244,7 @@ func TestEphemeral(t *testing.T) {
 }

 func TestEphemeralInAlternateTimezone(t *testing.T) {
-	testEphemeralWithOptions(
-		t,
-		hsic.WithTestName("ephemeral-tz"),
-		hsic.WithTimezone("America/Los_Angeles"),
-	)
+	testEphemeralWithOptions(t, hsic.WithTestName("ephemeral-tz"), hsic.WithTimezone("America/Los_Angeles"))
 }

 func testEphemeralWithOptions(t *testing.T, opts ...hsic.Option) {
@ -1169,10 +1164,10 @@ func Test2118DeletingOnlineNodePanics(t *testing.T) {
 		},
 		&nodeList,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)
 	assert.Len(t, nodeList, 2)
-	assert.True(t, nodeList[0].GetOnline())
-	assert.True(t, nodeList[1].GetOnline())
+	assert.True(t, nodeList[0].Online)
+	assert.True(t, nodeList[1].Online)

 	// Delete the first node, which is online
 	_, err = headscale.Execute(
@ -1182,13 +1177,13 @@ func Test2118DeletingOnlineNodePanics(t *testing.T) {
 			"delete",
 			"--identifier",
 			// Delete the last added machine
-			fmt.Sprintf("%d", nodeList[0].GetId()),
+			fmt.Sprintf("%d", nodeList[0].Id),
 			"--output",
 			"json",
 			"--force",
 		},
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)

 	time.Sleep(2 * time.Second)

@ -1205,8 +1200,9 @@ func Test2118DeletingOnlineNodePanics(t *testing.T) {
 		},
 		&nodeListAfter,
 	)
-	require.NoError(t, err)
+	assert.Nil(t, err)
 	assert.Len(t, nodeListAfter, 1)
-	assert.True(t, nodeListAfter[0].GetOnline())
-	assert.Equal(t, nodeList[1].GetId(), nodeListAfter[0].GetId())
+	assert.True(t, nodeListAfter[0].Online)
+	assert.Equal(t, nodeList[1].Id, nodeListAfter[0].Id)
+
 }
--- a/integration/hsic/hsic.go
+++ b/integration/hsic/hsic.go
@ -1,12 +1,19 @@
 package hsic

 import (
+	"bytes"
+	"crypto/rand"
+	"crypto/rsa"
 	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
 	"encoding/json"
+	"encoding/pem"
 	"errors"
 	"fmt"
 	"io"
 	"log"
+	"math/big"
 	"net"
 	"net/http"
 	"net/url"
@ -25,19 +32,15 @@ import (
 	"github.com/juanfont/headscale/integration/integrationutil"
 	"github.com/ory/dockertest/v3"
 	"github.com/ory/dockertest/v3/docker"
-	"gopkg.in/yaml.v3"
-	"tailscale.com/tailcfg"
 )

 const (
 	hsicHashLength       = 6
 	dockerContextPath    = "../."
-  caCertRoot                    = "/usr/local/share/ca-certificates"
 	aclPolicyPath        = "/etc/headscale/acl.hujson"
 	tlsCertPath          = "/etc/headscale/tls.cert"
 	tlsKeyPath           = "/etc/headscale/tls.key"
 	headscaleDefaultPort = 8080
-	IntegrationTestDockerFileName = "Dockerfile.integration"
 )

 var errHeadscaleStatusCodeNotOk = errors.New("headscale status code not ok")
@ -61,7 +64,6 @@ type HeadscaleInContainer struct {
 	// optional config
 	port             int
 	extraPorts       []string
-	caCerts          [][]byte
 	hostPortBindings map[string][]string
 	aclPolicy        *policy.ACLPolicy
 	env              map[string]string
@ -86,29 +88,18 @@ func WithACLPolicy(acl *policy.ACLPolicy) Option {
 	}
 }

-// WithCACert adds it to the trusted surtificate of the container.
-func WithCACert(cert []byte) Option {
-	return func(hsic *HeadscaleInContainer) {
-		hsic.caCerts = append(hsic.caCerts, cert)
-	}
-}
-
 // WithTLS creates certificates and enables HTTPS.
 func WithTLS() Option {
 	return func(hsic *HeadscaleInContainer) {
-		cert, key, err := integrationutil.CreateCertificate(hsic.hostname)
+		cert, key, err := createCertificate(hsic.hostname)
 		if err != nil {
 			log.Fatalf("failed to create certificates for headscale test: %s", err)
 		}

-		hsic.tlsCert = cert
-		hsic.tlsKey = key
-	}
-}
+		// TODO(kradalby): Move somewhere appropriate
+		hsic.env["HEADSCALE_TLS_CERT_PATH"] = tlsCertPath
+		hsic.env["HEADSCALE_TLS_KEY_PATH"] = tlsKeyPath

-// WithCustomTLS uses the given certificates for the Headscale instance.
-func WithCustomTLS(cert, key []byte) Option {
-	return func(hsic *HeadscaleInContainer) {
 		hsic.tlsCert = cert
 		hsic.tlsKey = key
 	}
@ -155,13 +146,6 @@ func WithTestName(testName string) Option {
 	}
 }

-// WithHostname sets the hostname of the Headscale instance.
-func WithHostname(hostname string) Option {
-	return func(hsic *HeadscaleInContainer) {
-		hsic.hostname = hostname
-	}
-}
-
 // WithHostnameAsServerURL sets the Headscale ServerURL based on
 // the Hostname.
 func WithHostnameAsServerURL() Option {
@ -219,34 +203,6 @@ func WithEmbeddedDERPServerOnly() Option {
 	}
 }

-// WithDERPConfig configures Headscale use a custom
-// DERP server only.
-func WithDERPConfig(derpMap tailcfg.DERPMap) Option {
-	return func(hsic *HeadscaleInContainer) {
-		contents, err := yaml.Marshal(derpMap)
-		if err != nil {
-			log.Fatalf("failed to marshal DERP map: %s", err)
-
-			return
-		}
-
-		hsic.env["HEADSCALE_DERP_PATHS"] = "/etc/headscale/derp.yml"
-		hsic.filesInContainer = append(hsic.filesInContainer,
-			fileInContainer{
-				path:     "/etc/headscale/derp.yml",
-				contents: contents,
-			})
-
-		// Disable global DERP server and embedded DERP server
-		hsic.env["HEADSCALE_DERP_URLS"] = ""
-		hsic.env["HEADSCALE_DERP_SERVER_ENABLED"] = "false"
-
-		// Envknob for enabling DERP debug logs
-		hsic.env["DERP_DEBUG_LOGS"] = "true"
-		hsic.env["DERP_PROBER_DEBUG_LOGS"] = "true"
-	}
-}
-
 // WithTuning allows changing the tuning settings easily.
 func WithTuning(batchTimeout time.Duration, mapSessionChanSize int) Option {
 	return func(hsic *HeadscaleInContainer) {
@ -304,7 +260,7 @@ func New(
 	}

 	headscaleBuildOptions := &dockertest.BuildOptions{
-		Dockerfile: IntegrationTestDockerFileName,
+		Dockerfile: "Dockerfile.debug",
 		ContextDir: dockerContextPath,
 	}

@ -344,10 +300,6 @@ func New(
 		"HEADSCALE_DEBUG_HIGH_CARDINALITY_METRICS=1",
 		"HEADSCALE_DEBUG_DUMP_CONFIG=1",
 	}
-	if hsic.hasTLS() {
-		hsic.env["HEADSCALE_TLS_CERT_PATH"] = tlsCertPath
-		hsic.env["HEADSCALE_TLS_KEY_PATH"] = tlsKeyPath
-	}
 	for key, value := range hsic.env {
 		env = append(env, fmt.Sprintf("%s=%s", key, value))
 	}
@ -361,7 +313,7 @@ func New(
 		// Cmd:          []string{"headscale", "serve"},
 		// TODO(kradalby): Get rid of this hack, we currently need to give us some
 		// to inject the headscale configuration further down.
-		Entrypoint: []string{"/bin/bash", "-c", "/bin/sleep 3 ; update-ca-certificates ; headscale serve ; /bin/sleep 30"},
+		Entrypoint: []string{"/bin/bash", "-c", "/bin/sleep 3 ; headscale serve ; /bin/sleep 30"},
 		Env:        env,
 	}

@ -399,14 +351,6 @@ func New(

 	hsic.container = container

-	// Write the CA certificates to the container
-	for i, cert := range hsic.caCerts {
-		err = hsic.WriteFile(fmt.Sprintf("%s/user-%d.crt", caCertRoot, i), cert)
-		if err != nil {
-			return nil, fmt.Errorf("failed to write TLS certificate to container: %w", err)
-		}
-	}
-
 	err = hsic.WriteFile("/etc/headscale/config.yaml", []byte(MinimumConfigYAML()))
 	if err != nil {
 		return nil, fmt.Errorf("failed to write headscale config to container: %w", err)
@ -805,3 +749,86 @@ func (t *HeadscaleInContainer) SendInterrupt() error {

 	return nil
 }
+
+// nolint
+func createCertificate(hostname string) ([]byte, []byte, error) {
+	// From:
+	// https://shaneutt.com/blog/golang-ca-and-signed-cert-go/
+
+	ca := &x509.Certificate{
+		SerialNumber: big.NewInt(2019),
+		Subject: pkix.Name{
+			Organization: []string{"Headscale testing INC"},
+			Country:      []string{"NL"},
+			Locality:     []string{"Leiden"},
+		},
+		NotBefore: time.Now(),
+		NotAfter:  time.Now().Add(60 * time.Hour),
+		IsCA:      true,
+		ExtKeyUsage: []x509.ExtKeyUsage{
+			x509.ExtKeyUsageClientAuth,
+			x509.ExtKeyUsageServerAuth,
+		},
+		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
+		BasicConstraintsValid: true,
+	}
+
+	caPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cert := &x509.Certificate{
+		SerialNumber: big.NewInt(1658),
+		Subject: pkix.Name{
+			CommonName:   hostname,
+			Organization: []string{"Headscale testing INC"},
+			Country:      []string{"NL"},
+			Locality:     []string{"Leiden"},
+		},
+		NotBefore:    time.Now(),
+		NotAfter:     time.Now().Add(60 * time.Minute),
+		SubjectKeyId: []byte{1, 2, 3, 4, 6},
+		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
+		KeyUsage:     x509.KeyUsageDigitalSignature,
+		DNSNames:     []string{hostname},
+	}
+
+	certPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	certBytes, err := x509.CreateCertificate(
+		rand.Reader,
+		cert,
+		ca,
+		&certPrivKey.PublicKey,
+		caPrivKey,
+	)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	certPEM := new(bytes.Buffer)
+
+	err = pem.Encode(certPEM, &pem.Block{
+		Type:  "CERTIFICATE",
+		Bytes: certBytes,
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	certPrivKeyPEM := new(bytes.Buffer)
+
+	err = pem.Encode(certPrivKeyPEM, &pem.Block{
+		Type:  "RSA PRIVATE KEY",
+		Bytes: x509.MarshalPKCS1PrivateKey(certPrivKey),
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return certPEM.Bytes(), certPrivKeyPEM.Bytes(), nil
+}
--- a/integration/integrationutil/util.go
+++ b/integration/integrationutil/util.go
@ -3,16 +3,9 @@ package integrationutil
 import (
 	"archive/tar"
 	"bytes"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
 	"fmt"
 	"io"
-	"math/big"
 	"path/filepath"
-	"time"

 	"github.com/juanfont/headscale/integration/dockertestutil"
 	"github.com/ory/dockertest/v3"
@ -100,86 +93,3 @@ func FetchPathFromContainer(

 	return buf.Bytes(), nil
 }
-
-// nolint
-func CreateCertificate(hostname string) ([]byte, []byte, error) {
-	// From:
-	// https://shaneutt.com/blog/golang-ca-and-signed-cert-go/
-
-	ca := &x509.Certificate{
-		SerialNumber: big.NewInt(2019),
-		Subject: pkix.Name{
-			Organization: []string{"Headscale testing INC"},
-			Country:      []string{"NL"},
-			Locality:     []string{"Leiden"},
-		},
-		NotBefore: time.Now(),
-		NotAfter:  time.Now().Add(60 * time.Hour),
-		IsCA:      true,
-		ExtKeyUsage: []x509.ExtKeyUsage{
-			x509.ExtKeyUsageClientAuth,
-			x509.ExtKeyUsageServerAuth,
-		},
-		KeyUsage:              x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
-		BasicConstraintsValid: true,
-	}
-
-	caPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	cert := &x509.Certificate{
-		SerialNumber: big.NewInt(1658),
-		Subject: pkix.Name{
-			CommonName:   hostname,
-			Organization: []string{"Headscale testing INC"},
-			Country:      []string{"NL"},
-			Locality:     []string{"Leiden"},
-		},
-		NotBefore:    time.Now(),
-		NotAfter:     time.Now().Add(60 * time.Minute),
-		SubjectKeyId: []byte{1, 2, 3, 4, 6},
-		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageClientAuth, x509.ExtKeyUsageServerAuth},
-		KeyUsage:     x509.KeyUsageDigitalSignature,
-		DNSNames:     []string{hostname},
-	}
-
-	certPrivKey, err := rsa.GenerateKey(rand.Reader, 4096)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	certBytes, err := x509.CreateCertificate(
-		rand.Reader,
-		cert,
-		ca,
-		&certPrivKey.PublicKey,
-		caPrivKey,
-	)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	certPEM := new(bytes.Buffer)
-
-	err = pem.Encode(certPEM, &pem.Block{
-		Type:  "CERTIFICATE",
-		Bytes: certBytes,
-	})
-	if err != nil {
-		return nil, nil, err
-	}
-
-	certPrivKeyPEM := new(bytes.Buffer)
-
-	err = pem.Encode(certPrivKeyPEM, &pem.Block{
-		Type:  "RSA PRIVATE KEY",
-		Bytes: x509.MarshalPKCS1PrivateKey(certPrivKey),
-	})
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return certPEM.Bytes(), certPrivKeyPEM.Bytes(), nil
-}
--- a/integration/route_test.go
+++ b/integration/route_test.go
@ -92,9 +92,9 @@ func TestEnablingRoutes(t *testing.T) {
 	assert.Len(t, routes, 3)

 	for _, route := range routes {
-		assert.True(t, route.GetAdvertised())
-		assert.False(t, route.GetEnabled())
-		assert.False(t, route.GetIsPrimary())
+		assert.Equal(t, true, route.GetAdvertised())
+		assert.Equal(t, false, route.GetEnabled())
+		assert.Equal(t, false, route.GetIsPrimary())
 	}

 	// Verify that no routes has been sent to the client,
@ -139,9 +139,9 @@ func TestEnablingRoutes(t *testing.T) {
 	assert.Len(t, enablingRoutes, 3)

 	for _, route := range enablingRoutes {
-		assert.True(t, route.GetAdvertised())
-		assert.True(t, route.GetEnabled())
-		assert.True(t, route.GetIsPrimary())
+		assert.Equal(t, true, route.GetAdvertised())
+		assert.Equal(t, true, route.GetEnabled())
+		assert.Equal(t, true, route.GetIsPrimary())
 	}

 	time.Sleep(5 * time.Second)
@ -212,18 +212,18 @@ func TestEnablingRoutes(t *testing.T) {
 	assertNoErr(t, err)

 	for _, route := range disablingRoutes {
-		assert.True(t, route.GetAdvertised())
+		assert.Equal(t, true, route.GetAdvertised())

 		if route.GetId() == routeToBeDisabled.GetId() {
-			assert.False(t, route.GetEnabled())
+			assert.Equal(t, false, route.GetEnabled())

 			// since this is the only route of this cidr,
 			// it will not failover, and remain Primary
 			// until something can replace it.
-			assert.True(t, route.GetIsPrimary())
+			assert.Equal(t, true, route.GetIsPrimary())
 		} else {
-			assert.True(t, route.GetEnabled())
-			assert.True(t, route.GetIsPrimary())
+			assert.Equal(t, true, route.GetEnabled())
+			assert.Equal(t, true, route.GetIsPrimary())
 		}
 	}

@ -342,9 +342,9 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	t.Logf("initial routes %#v", routes)

 	for _, route := range routes {
-		assert.True(t, route.GetAdvertised())
-		assert.False(t, route.GetEnabled())
-		assert.False(t, route.GetIsPrimary())
+		assert.Equal(t, true, route.GetAdvertised())
+		assert.Equal(t, false, route.GetEnabled())
+		assert.Equal(t, false, route.GetIsPrimary())
 	}

 	// Verify that no routes has been sent to the client,
@ -391,14 +391,14 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	assert.Len(t, enablingRoutes, 2)

 	// Node 1 is primary
-	assert.True(t, enablingRoutes[0].GetAdvertised())
-	assert.True(t, enablingRoutes[0].GetEnabled())
-	assert.True(t, enablingRoutes[0].GetIsPrimary(), "both subnet routers are up, expected r1 to be primary")
+	assert.Equal(t, true, enablingRoutes[0].GetAdvertised())
+	assert.Equal(t, true, enablingRoutes[0].GetEnabled())
+	assert.Equal(t, true, enablingRoutes[0].GetIsPrimary(), "both subnet routers are up, expected r1 to be primary")

 	// Node 2 is not primary
-	assert.True(t, enablingRoutes[1].GetAdvertised())
-	assert.True(t, enablingRoutes[1].GetEnabled())
-	assert.False(t, enablingRoutes[1].GetIsPrimary(), "both subnet routers are up, expected r2 to be non-primary")
+	assert.Equal(t, true, enablingRoutes[1].GetAdvertised())
+	assert.Equal(t, true, enablingRoutes[1].GetEnabled())
+	assert.Equal(t, false, enablingRoutes[1].GetIsPrimary(), "both subnet routers are up, expected r2 to be non-primary")

 	// Verify that the client has routes from the primary machine
 	srs1, err := subRouter1.Status()
@ -446,14 +446,14 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	assert.Len(t, routesAfterMove, 2)

 	// Node 1 is not primary
-	assert.True(t, routesAfterMove[0].GetAdvertised())
-	assert.True(t, routesAfterMove[0].GetEnabled())
-	assert.False(t, routesAfterMove[0].GetIsPrimary(), "r1 is down, expected r2 to be primary")
+	assert.Equal(t, true, routesAfterMove[0].GetAdvertised())
+	assert.Equal(t, true, routesAfterMove[0].GetEnabled())
+	assert.Equal(t, false, routesAfterMove[0].GetIsPrimary(), "r1 is down, expected r2 to be primary")

 	// Node 2 is primary
-	assert.True(t, routesAfterMove[1].GetAdvertised())
-	assert.True(t, routesAfterMove[1].GetEnabled())
-	assert.True(t, routesAfterMove[1].GetIsPrimary(), "r1 is down, expected r2 to be primary")
+	assert.Equal(t, true, routesAfterMove[1].GetAdvertised())
+	assert.Equal(t, true, routesAfterMove[1].GetEnabled())
+	assert.Equal(t, true, routesAfterMove[1].GetIsPrimary(), "r1 is down, expected r2 to be primary")

 	srs2, err = subRouter2.Status()

@ -501,16 +501,16 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	assert.Len(t, routesAfterBothDown, 2)

 	// Node 1 is not primary
-	assert.True(t, routesAfterBothDown[0].GetAdvertised())
-	assert.True(t, routesAfterBothDown[0].GetEnabled())
-	assert.False(t, routesAfterBothDown[0].GetIsPrimary(), "r1 and r2 is down, expected r2 to _still_ be primary")
+	assert.Equal(t, true, routesAfterBothDown[0].GetAdvertised())
+	assert.Equal(t, true, routesAfterBothDown[0].GetEnabled())
+	assert.Equal(t, false, routesAfterBothDown[0].GetIsPrimary(), "r1 and r2 is down, expected r2 to _still_ be primary")

 	// Node 2 is primary
 	// if the node goes down, but no other suitable route is
 	// available, keep the last known good route.
-	assert.True(t, routesAfterBothDown[1].GetAdvertised())
-	assert.True(t, routesAfterBothDown[1].GetEnabled())
-	assert.True(t, routesAfterBothDown[1].GetIsPrimary(), "r1 and r2 is down, expected r2 to _still_ be primary")
+	assert.Equal(t, true, routesAfterBothDown[1].GetAdvertised())
+	assert.Equal(t, true, routesAfterBothDown[1].GetEnabled())
+	assert.Equal(t, true, routesAfterBothDown[1].GetIsPrimary(), "r1 and r2 is down, expected r2 to _still_ be primary")

 	// TODO(kradalby): Check client status
 	// Both are expected to be down
@ -560,14 +560,14 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	assert.Len(t, routesAfter1Up, 2)

 	// Node 1 is primary
-	assert.True(t, routesAfter1Up[0].GetAdvertised())
-	assert.True(t, routesAfter1Up[0].GetEnabled())
-	assert.True(t, routesAfter1Up[0].GetIsPrimary(), "r1 is back up, expected r1 to become be primary")
+	assert.Equal(t, true, routesAfter1Up[0].GetAdvertised())
+	assert.Equal(t, true, routesAfter1Up[0].GetEnabled())
+	assert.Equal(t, true, routesAfter1Up[0].GetIsPrimary(), "r1 is back up, expected r1 to become be primary")

 	// Node 2 is not primary
-	assert.True(t, routesAfter1Up[1].GetAdvertised())
-	assert.True(t, routesAfter1Up[1].GetEnabled())
-	assert.False(t, routesAfter1Up[1].GetIsPrimary(), "r1 is back up, expected r1 to become be primary")
+	assert.Equal(t, true, routesAfter1Up[1].GetAdvertised())
+	assert.Equal(t, true, routesAfter1Up[1].GetEnabled())
+	assert.Equal(t, false, routesAfter1Up[1].GetIsPrimary(), "r1 is back up, expected r1 to become be primary")

 	// Verify that the route is announced from subnet router 1
 	clientStatus, err = client.Status()
@ -614,14 +614,14 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	assert.Len(t, routesAfter2Up, 2)

 	// Node 1 is not primary
-	assert.True(t, routesAfter2Up[0].GetAdvertised())
-	assert.True(t, routesAfter2Up[0].GetEnabled())
-	assert.True(t, routesAfter2Up[0].GetIsPrimary(), "r1 and r2 is back up, expected r1 to _still_ be primary")
+	assert.Equal(t, true, routesAfter2Up[0].GetAdvertised())
+	assert.Equal(t, true, routesAfter2Up[0].GetEnabled())
+	assert.Equal(t, true, routesAfter2Up[0].GetIsPrimary(), "r1 and r2 is back up, expected r1 to _still_ be primary")

 	// Node 2 is primary
-	assert.True(t, routesAfter2Up[1].GetAdvertised())
-	assert.True(t, routesAfter2Up[1].GetEnabled())
-	assert.False(t, routesAfter2Up[1].GetIsPrimary(), "r1 and r2 is back up, expected r1 to _still_ be primary")
+	assert.Equal(t, true, routesAfter2Up[1].GetAdvertised())
+	assert.Equal(t, true, routesAfter2Up[1].GetEnabled())
+	assert.Equal(t, false, routesAfter2Up[1].GetIsPrimary(), "r1 and r2 is back up, expected r1 to _still_ be primary")

 	// Verify that the route is announced from subnet router 1
 	clientStatus, err = client.Status()
@ -677,14 +677,14 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	t.Logf("routes after disabling r1 %#v", routesAfterDisabling1)

 	// Node 1 is not primary
-	assert.True(t, routesAfterDisabling1[0].GetAdvertised())
-	assert.False(t, routesAfterDisabling1[0].GetEnabled())
-	assert.False(t, routesAfterDisabling1[0].GetIsPrimary())
+	assert.Equal(t, true, routesAfterDisabling1[0].GetAdvertised())
+	assert.Equal(t, false, routesAfterDisabling1[0].GetEnabled())
+	assert.Equal(t, false, routesAfterDisabling1[0].GetIsPrimary())

 	// Node 2 is primary
-	assert.True(t, routesAfterDisabling1[1].GetAdvertised())
-	assert.True(t, routesAfterDisabling1[1].GetEnabled())
-	assert.True(t, routesAfterDisabling1[1].GetIsPrimary())
+	assert.Equal(t, true, routesAfterDisabling1[1].GetAdvertised())
+	assert.Equal(t, true, routesAfterDisabling1[1].GetEnabled())
+	assert.Equal(t, true, routesAfterDisabling1[1].GetIsPrimary())

 	// Verify that the route is announced from subnet router 1
 	clientStatus, err = client.Status()
@ -735,14 +735,14 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	assert.Len(t, routesAfterEnabling1, 2)

 	// Node 1 is not primary
-	assert.True(t, routesAfterEnabling1[0].GetAdvertised())
-	assert.True(t, routesAfterEnabling1[0].GetEnabled())
-	assert.False(t, routesAfterEnabling1[0].GetIsPrimary())
+	assert.Equal(t, true, routesAfterEnabling1[0].GetAdvertised())
+	assert.Equal(t, true, routesAfterEnabling1[0].GetEnabled())
+	assert.Equal(t, false, routesAfterEnabling1[0].GetIsPrimary())

 	// Node 2 is primary
-	assert.True(t, routesAfterEnabling1[1].GetAdvertised())
-	assert.True(t, routesAfterEnabling1[1].GetEnabled())
-	assert.True(t, routesAfterEnabling1[1].GetIsPrimary())
+	assert.Equal(t, true, routesAfterEnabling1[1].GetAdvertised())
+	assert.Equal(t, true, routesAfterEnabling1[1].GetEnabled())
+	assert.Equal(t, true, routesAfterEnabling1[1].GetIsPrimary())

 	// Verify that the route is announced from subnet router 1
 	clientStatus, err = client.Status()
@ -795,9 +795,9 @@ func TestHASubnetRouterFailover(t *testing.T) {
 	t.Logf("routes after deleting r2 %#v", routesAfterDeleting2)

 	// Node 1 is primary
-	assert.True(t, routesAfterDeleting2[0].GetAdvertised())
-	assert.True(t, routesAfterDeleting2[0].GetEnabled())
-	assert.True(t, routesAfterDeleting2[0].GetIsPrimary())
+	assert.Equal(t, true, routesAfterDeleting2[0].GetAdvertised())
+	assert.Equal(t, true, routesAfterDeleting2[0].GetEnabled())
+	assert.Equal(t, true, routesAfterDeleting2[0].GetIsPrimary())

 	// Verify that the route is announced from subnet router 1
 	clientStatus, err = client.Status()
@ -893,9 +893,9 @@ func TestEnableDisableAutoApprovedRoute(t *testing.T) {
 	assert.Len(t, routes, 1)

 	// All routes should be auto approved and enabled
-	assert.True(t, routes[0].GetAdvertised())
-	assert.True(t, routes[0].GetEnabled())
-	assert.True(t, routes[0].GetIsPrimary())
+	assert.Equal(t, true, routes[0].GetAdvertised())
+	assert.Equal(t, true, routes[0].GetEnabled())
+	assert.Equal(t, true, routes[0].GetIsPrimary())

 	// Stop advertising route
 	command = []string{
@ -924,9 +924,9 @@ func TestEnableDisableAutoApprovedRoute(t *testing.T) {
 	assert.Len(t, notAdvertisedRoutes, 1)

 	// Route is no longer advertised
-	assert.False(t, notAdvertisedRoutes[0].GetAdvertised())
-	assert.False(t, notAdvertisedRoutes[0].GetEnabled())
-	assert.True(t, notAdvertisedRoutes[0].GetIsPrimary())
+	assert.Equal(t, false, notAdvertisedRoutes[0].GetAdvertised())
+	assert.Equal(t, false, notAdvertisedRoutes[0].GetEnabled())
+	assert.Equal(t, true, notAdvertisedRoutes[0].GetIsPrimary())

 	// Advertise route again
 	command = []string{
@ -955,9 +955,9 @@ func TestEnableDisableAutoApprovedRoute(t *testing.T) {
 	assert.Len(t, reAdvertisedRoutes, 1)

 	// All routes should be auto approved and enabled
-	assert.True(t, reAdvertisedRoutes[0].GetAdvertised())
-	assert.True(t, reAdvertisedRoutes[0].GetEnabled())
-	assert.True(t, reAdvertisedRoutes[0].GetIsPrimary())
+	assert.Equal(t, true, reAdvertisedRoutes[0].GetAdvertised())
+	assert.Equal(t, true, reAdvertisedRoutes[0].GetEnabled())
+	assert.Equal(t, true, reAdvertisedRoutes[0].GetIsPrimary())
 }

 func TestAutoApprovedSubRoute2068(t *testing.T) {
@ -1163,9 +1163,9 @@ func TestSubnetRouteACL(t *testing.T) {
 	assert.Len(t, routes, 1)

 	for _, route := range routes {
-		assert.True(t, route.GetAdvertised())
-		assert.False(t, route.GetEnabled())
-		assert.False(t, route.GetIsPrimary())
+		assert.Equal(t, true, route.GetAdvertised())
+		assert.Equal(t, false, route.GetEnabled())
+		assert.Equal(t, false, route.GetIsPrimary())
 	}

 	// Verify that no routes has been sent to the client,
@ -1212,9 +1212,9 @@ func TestSubnetRouteACL(t *testing.T) {
 	assert.Len(t, enablingRoutes, 1)

 	// Node 1 has active route
-	assert.True(t, enablingRoutes[0].GetAdvertised())
-	assert.True(t, enablingRoutes[0].GetEnabled())
-	assert.True(t, enablingRoutes[0].GetIsPrimary())
+	assert.Equal(t, true, enablingRoutes[0].GetAdvertised())
+	assert.Equal(t, true, enablingRoutes[0].GetEnabled())
+	assert.Equal(t, true, enablingRoutes[0].GetIsPrimary())

 	// Verify that the client has routes from the primary machine
 	srs1, _ := subRouter1.Status()
--- a/integration/scenario.go
+++ b/integration/scenario.go
@ -14,14 +14,12 @@ import (
 	v1 "github.com/juanfont/headscale/gen/go/headscale/v1"
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/juanfont/headscale/integration/dockertestutil"
-	"github.com/juanfont/headscale/integration/dsic"
 	"github.com/juanfont/headscale/integration/hsic"
 	"github.com/juanfont/headscale/integration/tsic"
 	"github.com/ory/dockertest/v3"
 	"github.com/puzpuzpuz/xsync/v3"
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 	"golang.org/x/sync/errgroup"
 	"tailscale.com/envknob"
 )
@ -142,7 +140,6 @@ type Scenario struct {
 	// TODO(kradalby): support multiple headcales for later, currently only
 	// use one.
 	controlServers *xsync.MapOf[string, ControlServer]
-	derpServers    []*dsic.DERPServerInContainer

 	users map[string]*User

@ -206,11 +203,11 @@ func (s *Scenario) ShutdownAssertNoPanics(t *testing.T) {

 		if t != nil {
 			stdout, err := os.ReadFile(stdoutPath)
-			require.NoError(t, err)
+			assert.NoError(t, err)
 			assert.NotContains(t, string(stdout), "panic")

 			stderr, err := os.ReadFile(stderrPath)
-			require.NoError(t, err)
+			assert.NoError(t, err)
 			assert.NotContains(t, string(stderr), "panic")
 		}

@ -227,13 +224,6 @@ func (s *Scenario) ShutdownAssertNoPanics(t *testing.T) {
 		}
 	}

-	for _, derp := range s.derpServers {
-		err := derp.Shutdown()
-		if err != nil {
-			log.Printf("failed to tear down derp server: %s", err)
-		}
-	}
-
 	if err := s.pool.RemoveNetwork(s.network); err != nil {
 		log.Printf("failed to remove network: %s", err)
 	}
@ -362,7 +352,7 @@ func (s *Scenario) CreateTailscaleNodesInUser(
 			hostname := headscale.GetHostname()

 			opts = append(opts,
-				tsic.WithCACert(cert),
+				tsic.WithHeadscaleTLS(cert),
 				tsic.WithHeadscaleName(hostname),
 			)

@ -661,20 +651,3 @@ func (s *Scenario) WaitForTailscaleLogout() error {

 	return nil
 }
-
-// CreateDERPServer creates a new DERP server in a container.
-func (s *Scenario) CreateDERPServer(version string, opts ...dsic.Option) (*dsic.DERPServerInContainer, error) {
-	derp, err := dsic.New(s.pool, version, s.network, opts...)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create DERP server: %w", err)
-	}
-
-	err = derp.WaitForRunning()
-	if err != nil {
-		return nil, fmt.Errorf("failed to reach DERP server: %w", err)
-	}
-
-	s.derpServers = append(s.derpServers, derp)
-
-	return derp, nil
-}
--- a/integration/tailscale.go
+++ b/integration/tailscale.go
@ -30,7 +30,6 @@ type TailscaleClient interface {
 	FQDN() (string, error)
 	Status(...bool) (*ipnstate.Status, error)
 	Netmap() (*netmap.NetworkMap, error)
-	DebugDERPRegion(region string) (*ipnstate.DebugDERPRegionReport, error)
 	Netcheck() (*netcheck.Report, error)
 	WaitForNeedsLogin() error
 	WaitForRunning() error
--- a/integration/tsic/tsic.go
+++ b/integration/tsic/tsic.go
@ -12,7 +12,6 @@ import (
 	"net/netip"
 	"net/url"
 	"os"
-	"reflect"
 	"strconv"
 	"strings"
 	"time"
@ -33,7 +32,7 @@ const (
 	defaultPingTimeout   = 300 * time.Millisecond
 	defaultPingCount     = 10
 	dockerContextPath    = "../."
-	caCertRoot           = "/usr/local/share/ca-certificates"
+	headscaleCertPath    = "/usr/local/share/ca-certificates/headscale.crt"
 	dockerExecuteTimeout = 60 * time.Second
 )

@ -45,11 +44,6 @@ var (
 	errTailscaleCannotUpWithoutAuthkey = errors.New("cannot up without authkey")
 	errTailscaleNotConnected           = errors.New("tailscale not connected")
 	errTailscaledNotReadyForLogin      = errors.New("tailscaled not ready for login")
-	errInvalidClientConfig             = errors.New("verifiably invalid client config requested")
-)
-
-const (
-	VersionHead = "head"
 )

 func errTailscaleStatus(hostname string, err error) error {
@ -71,7 +65,7 @@ type TailscaleInContainer struct {
 	fqdn string

 	// optional config
-	caCerts           [][]byte
+	headscaleCert     []byte
 	headscaleHostname string
 	withWebsocketDERP bool
 	withSSH           bool
@ -80,23 +74,17 @@ type TailscaleInContainer struct {
 	withExtraHosts    []string
 	workdir           string
 	netfilter         string
-
-	// build options, solely for HEAD
-	buildConfig TailscaleInContainerBuildConfig
-}
-
-type TailscaleInContainerBuildConfig struct {
-	tags []string
 }

 // Option represent optional settings that can be given to a
 // Tailscale instance.
 type Option = func(c *TailscaleInContainer)

-// WithCACert adds it to the trusted surtificate of the Tailscale container.
-func WithCACert(cert []byte) Option {
+// WithHeadscaleTLS takes the certificate of the Headscale instance
+// and adds it to the trusted surtificate of the Tailscale container.
+func WithHeadscaleTLS(cert []byte) Option {
 	return func(tsic *TailscaleInContainer) {
-		tsic.caCerts = append(tsic.caCerts, cert)
+		tsic.headscaleCert = cert
 	}
 }

@ -125,7 +113,7 @@ func WithOrCreateNetwork(network *dockertest.Network) Option {
 }

 // WithHeadscaleName set the name of the headscale instance,
-// mostly useful in combination with TLS and WithCACert.
+// mostly useful in combination with TLS and WithHeadscaleTLS.
 func WithHeadscaleName(hsName string) Option {
 	return func(tsic *TailscaleInContainer) {
 		tsic.headscaleHostname = hsName
@ -187,22 +175,6 @@ func WithNetfilter(state string) Option {
 	}
 }

-// WithBuildTag adds an additional value to the `-tags=` parameter
-// of the Go compiler, allowing callers to customize the Tailscale client build.
-// This option is only meaningful when invoked on **HEAD** versions of the client.
-// Attempts to use it with any other version is a bug in the calling code.
-func WithBuildTag(tag string) Option {
-	return func(tsic *TailscaleInContainer) {
-		if tsic.version != VersionHead {
-			panic(errInvalidClientConfig)
-		}
-
-		tsic.buildConfig.tags = append(
-			tsic.buildConfig.tags, tag,
-		)
-	}
-}
-
 // New returns a new TailscaleInContainer instance.
 func New(
 	pool *dockertest.Pool,
@ -247,20 +219,18 @@ func New(
 	}

 	if tsic.withWebsocketDERP {
-		if version != VersionHead {
-			return tsic, errInvalidClientConfig
-		}
-
-		WithBuildTag("ts_debug_websockets")(tsic)
-
 		tailscaleOptions.Env = append(
 			tailscaleOptions.Env,
 			fmt.Sprintf("TS_DEBUG_DERP_WS_CLIENT=%t", tsic.withWebsocketDERP),
 		)
 	}

-	tailscaleOptions.ExtraHosts = append(tailscaleOptions.ExtraHosts,
-		"host.docker.internal:host-gateway")
+	if tsic.headscaleHostname != "" {
+		tailscaleOptions.ExtraHosts = []string{
+			"host.docker.internal:host-gateway",
+			fmt.Sprintf("%s:host-gateway", tsic.headscaleHostname),
+		}
+	}

 	if tsic.workdir != "" {
 		tailscaleOptions.WorkingDir = tsic.workdir
@ -275,36 +245,14 @@ func New(
 	}

 	var container *dockertest.Resource
-
-	if version != VersionHead {
-		// build options are not meaningful with pre-existing images,
-		// let's not lead anyone astray by pretending otherwise.
-		defaultBuildConfig := TailscaleInContainerBuildConfig{}
-		hasBuildConfig := !reflect.DeepEqual(defaultBuildConfig, tsic.buildConfig)
-		if hasBuildConfig {
-			return tsic, errInvalidClientConfig
-		}
-	}
-
 	switch version {
-	case VersionHead:
+	case "head":
 		buildOptions := &dockertest.BuildOptions{
 			Dockerfile: "Dockerfile.tailscale-HEAD",
 			ContextDir: dockerContextPath,
 			BuildArgs:  []docker.BuildArg{},
 		}

-		buildTags := strings.Join(tsic.buildConfig.tags, ",")
-		if len(buildTags) > 0 {
-			buildOptions.BuildArgs = append(
-				buildOptions.BuildArgs,
-				docker.BuildArg{
-					Name:  "BUILD_TAGS",
-					Value: buildTags,
-				},
-			)
-		}
-
 		container, err = pool.BuildAndRunWithBuildOptions(
 			buildOptions,
 			tailscaleOptions,
@ -346,8 +294,8 @@ func New(

 	tsic.container = container

-	for i, cert := range tsic.caCerts {
-		err = tsic.WriteFile(fmt.Sprintf("%s/user-%d.crt", caCertRoot, i), cert)
+	if tsic.hasTLS() {
+		err = tsic.WriteFile(headscaleCertPath, tsic.headscaleCert)
 		if err != nil {
 			return nil, fmt.Errorf("failed to write TLS certificate to container: %w", err)
 		}
@ -356,6 +304,10 @@ func New(
 	return tsic, nil
 }

+func (t *TailscaleInContainer) hasTLS() bool {
+	return len(t.headscaleCert) != 0
+}
+
 // Shutdown stops and cleans up the Tailscale container.
 func (t *TailscaleInContainer) Shutdown() error {
 	err := t.SaveLog("/tmp/control")
@ -730,34 +682,6 @@ func (t *TailscaleInContainer) watchIPN(ctx context.Context) (*ipn.Notify, error
 	}
 }

-func (t *TailscaleInContainer) DebugDERPRegion(region string) (*ipnstate.DebugDERPRegionReport, error) {
-	if !util.TailscaleVersionNewerOrEqual("1.34", t.version) {
-		panic("tsic.DebugDERPRegion() called with unsupported version: " + t.version)
-	}
-
-	command := []string{
-		"tailscale",
-		"debug",
-		"derp",
-		region,
-	}
-
-	result, stderr, err := t.Execute(command)
-	if err != nil {
-		fmt.Printf("stderr: %s\n", stderr) // nolint
-
-		return nil, fmt.Errorf("failed to execute tailscale debug derp command: %w", err)
-	}
-
-	var report ipnstate.DebugDERPRegionReport
-	err = json.Unmarshal([]byte(result), &report)
-	if err != nil {
-		return nil, fmt.Errorf("failed to unmarshal tailscale derp region report: %w", err)
-	}
-
-	return &report, err
-}
-
 // Netcheck returns the current Netcheck Report (netcheck.Report) of the Tailscale instance.
 func (t *TailscaleInContainer) Netcheck() (*netcheck.Report, error) {
 	command := []string{
--- a/mkdocs.yml
+++ b/mkdocs.yml
@ -1,6 +1,5 @@
---
 site_name: Headscale
-site_url: https://juanfont.github.io/headscale/
+site_url: https://juanfont.github.io/headscale
 edit_uri: blob/main/docs/ # Change the master branch to main as we are using main as a main branch
 site_author: Headscale authors
 site_description: >-