diff --git a/hscontrol/db/api_key_test.go b/hscontrol/db/api_key_test.go
index 6899da6c..5b1f1f1d 100644
--- a/hscontrol/db/api_key_test.go
+++ b/hscontrol/db/api_key_test.go
@@ -9,89 +9,103 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/crypto/bcrypt"
-	"gopkg.in/check.v1"
 )
 
-func (*Suite) TestCreateAPIKey(c *check.C) {
+func TestCreateAPIKey(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	apiKeyStr, apiKey, err := db.CreateAPIKey(nil)
-	c.Assert(err, check.IsNil)
-	c.Assert(apiKey, check.NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, apiKey)
 
 	// Did we get a valid key?
-	c.Assert(apiKey.Prefix, check.NotNil)
-	c.Assert(apiKey.Hash, check.NotNil)
-	c.Assert(apiKeyStr, check.Not(check.Equals), "")
+	assert.NotNil(t, apiKey.Prefix)
+	assert.NotNil(t, apiKey.Hash)
+	assert.NotEmpty(t, apiKeyStr)
 
 	_, err = db.ListAPIKeys()
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 
 	keys, err := db.ListAPIKeys()
-	c.Assert(err, check.IsNil)
-	c.Assert(len(keys), check.Equals, 1)
+	require.NoError(t, err)
+	assert.Len(t, keys, 1)
 }
 
-func (*Suite) TestAPIKeyDoesNotExist(c *check.C) {
+func TestAPIKeyDoesNotExist(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	key, err := db.GetAPIKey("does-not-exist")
-	c.Assert(err, check.NotNil)
-	c.Assert(key, check.IsNil)
+	require.Error(t, err)
+	assert.Nil(t, key)
 }
 
-func (*Suite) TestValidateAPIKeyOk(c *check.C) {
+func TestValidateAPIKeyOk(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	nowPlus2 := time.Now().Add(2 * time.Hour)
 	apiKeyStr, apiKey, err := db.CreateAPIKey(&nowPlus2)
-	c.Assert(err, check.IsNil)
-	c.Assert(apiKey, check.NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, apiKey)
 
 	valid, err := db.ValidateAPIKey(apiKeyStr)
-	c.Assert(err, check.IsNil)
-	c.Assert(valid, check.Equals, true)
+	require.NoError(t, err)
+	assert.True(t, valid)
 }
 
-func (*Suite) TestValidateAPIKeyNotOk(c *check.C) {
+func TestValidateAPIKeyNotOk(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	nowMinus2 := time.Now().Add(time.Duration(-2) * time.Hour)
 	apiKeyStr, apiKey, err := db.CreateAPIKey(&nowMinus2)
-	c.Assert(err, check.IsNil)
-	c.Assert(apiKey, check.NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, apiKey)
 
 	valid, err := db.ValidateAPIKey(apiKeyStr)
-	c.Assert(err, check.IsNil)
-	c.Assert(valid, check.Equals, false)
+	require.NoError(t, err)
+	assert.False(t, valid)
 
 	now := time.Now()
 	apiKeyStrNow, apiKey, err := db.CreateAPIKey(&now)
-	c.Assert(err, check.IsNil)
-	c.Assert(apiKey, check.NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, apiKey)
 
 	validNow, err := db.ValidateAPIKey(apiKeyStrNow)
-	c.Assert(err, check.IsNil)
-	c.Assert(validNow, check.Equals, false)
+	require.NoError(t, err)
+	assert.False(t, validNow)
 
 	validSilly, err := db.ValidateAPIKey("nota.validkey")
-	c.Assert(err, check.NotNil)
-	c.Assert(validSilly, check.Equals, false)
+	require.Error(t, err)
+	assert.False(t, validSilly)
 
 	validWithErr, err := db.ValidateAPIKey("produceerrorkey")
-	c.Assert(err, check.NotNil)
-	c.Assert(validWithErr, check.Equals, false)
+	require.Error(t, err)
+	assert.False(t, validWithErr)
 }
 
-func (*Suite) TestExpireAPIKey(c *check.C) {
+func TestExpireAPIKey(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	nowPlus2 := time.Now().Add(2 * time.Hour)
 	apiKeyStr, apiKey, err := db.CreateAPIKey(&nowPlus2)
-	c.Assert(err, check.IsNil)
-	c.Assert(apiKey, check.NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, apiKey)
 
 	valid, err := db.ValidateAPIKey(apiKeyStr)
-	c.Assert(err, check.IsNil)
-	c.Assert(valid, check.Equals, true)
+	require.NoError(t, err)
+	assert.True(t, valid)
 
 	err = db.ExpireAPIKey(apiKey)
-	c.Assert(err, check.IsNil)
-	c.Assert(apiKey.Expiration, check.NotNil)
+	require.NoError(t, err)
+	assert.NotNil(t, apiKey.Expiration)
 
 	notValid, err := db.ValidateAPIKey(apiKeyStr)
-	c.Assert(err, check.IsNil)
-	c.Assert(notValid, check.Equals, false)
+	require.NoError(t, err)
+	assert.False(t, notValid)
 }
 
 func TestAPIKeyWithPrefix(t *testing.T) {
diff --git a/hscontrol/db/db_test.go b/hscontrol/db/db_test.go
index c50ad37c..9d534269 100644
--- a/hscontrol/db/db_test.go
+++ b/hscontrol/db/db_test.go
@@ -255,7 +255,7 @@ func TestPostgresMigrationAndDataValidation(t *testing.T) {
 				t.Fatalf("failed to restore postgres database: %s", err)
 			}
 
-			db = newHeadscaleDBFromPostgresURL(t, u)
+			db := newHeadscaleDBFromPostgresURL(t, u)
 
 			if tt.wantFunc != nil {
 				tt.wantFunc(t, db)
diff --git a/hscontrol/db/node_test.go b/hscontrol/db/node_test.go
index f3580e65..7e00f9ca 100644
--- a/hscontrol/db/node_test.go
+++ b/hscontrol/db/node_test.go
@@ -18,7 +18,6 @@ import (
 	"github.com/juanfont/headscale/hscontrol/util"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"gopkg.in/check.v1"
 	"gorm.io/gorm"
 	"tailscale.com/net/tsaddr"
 	"tailscale.com/tailcfg"
@@ -26,70 +25,85 @@ import (
 	"tailscale.com/types/ptr"
 )
 
-func (s *Suite) TestGetNode(c *check.C) {
+func TestGetNode(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	user := db.CreateUserForTest("test")
 
-	_, err := db.getNode(types.UserID(user.ID), "testnode")
-	c.Assert(err, check.NotNil)
+	_, err = db.getNode(types.UserID(user.ID), "testnode")
+	require.Error(t, err)
 
 	node := db.CreateNodeForTest(user, "testnode")
 
 	_, err = db.getNode(types.UserID(user.ID), "testnode")
-	c.Assert(err, check.IsNil)
-	c.Assert(node.Hostname, check.Equals, "testnode")
+	require.NoError(t, err)
+	assert.Equal(t, "testnode", node.Hostname)
 }
 
-func (s *Suite) TestGetNodeByID(c *check.C) {
+func TestGetNodeByID(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	user := db.CreateUserForTest("test")
 
-	_, err := db.GetNodeByID(0)
-	c.Assert(err, check.NotNil)
+	_, err = db.GetNodeByID(0)
+	require.Error(t, err)
 
 	node := db.CreateNodeForTest(user, "testnode")
 
 	retrievedNode, err := db.GetNodeByID(node.ID)
-	c.Assert(err, check.IsNil)
-	c.Assert(retrievedNode.Hostname, check.Equals, "testnode")
+	require.NoError(t, err)
+	assert.Equal(t, "testnode", retrievedNode.Hostname)
 }
 
-func (s *Suite) TestHardDeleteNode(c *check.C) {
+func TestHardDeleteNode(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	user := db.CreateUserForTest("test")
 	node := db.CreateNodeForTest(user, "testnode3")
 
-	err := db.DeleteNode(node)
-	c.Assert(err, check.IsNil)
+	err = db.DeleteNode(node)
+	require.NoError(t, err)
 
 	_, err = db.getNode(types.UserID(user.ID), "testnode3")
-	c.Assert(err, check.NotNil)
+	require.Error(t, err)
 }
 
-func (s *Suite) TestListPeers(c *check.C) {
+func TestListPeersManyNodes(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	user := db.CreateUserForTest("test")
 
-	_, err := db.GetNodeByID(0)
-	c.Assert(err, check.NotNil)
+	_, err = db.GetNodeByID(0)
+	require.Error(t, err)
 
 	nodes := db.CreateNodesForTest(user, 11, "testnode")
 
 	firstNode := nodes[0]
 	peersOfFirstNode, err := db.ListPeers(firstNode.ID)
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 
-	c.Assert(len(peersOfFirstNode), check.Equals, 10)
-	c.Assert(peersOfFirstNode[0].Hostname, check.Equals, "testnode-1")
-	c.Assert(peersOfFirstNode[5].Hostname, check.Equals, "testnode-6")
-	c.Assert(peersOfFirstNode[9].Hostname, check.Equals, "testnode-10")
+	assert.Len(t, peersOfFirstNode, 10)
+	assert.Equal(t, "testnode-1", peersOfFirstNode[0].Hostname)
+	assert.Equal(t, "testnode-6", peersOfFirstNode[5].Hostname)
+	assert.Equal(t, "testnode-10", peersOfFirstNode[9].Hostname)
 }
 
-func (s *Suite) TestExpireNode(c *check.C) {
+func TestExpireNode(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	user, err := db.CreateUser(types.User{Name: "test"})
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 
 	pak, err := db.CreatePreAuthKey(user.TypedID(), false, false, nil, nil)
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 
 	_, err = db.getNode(types.UserID(user.ID), "testnode")
-	c.Assert(err, check.NotNil)
+	require.Error(t, err)
 
 	nodeKey := key.NewNode()
 	machineKey := key.NewMachine()
@@ -107,30 +121,33 @@ func (s *Suite) TestExpireNode(c *check.C) {
 	db.DB.Save(node)
 
 	nodeFromDB, err := db.getNode(types.UserID(user.ID), "testnode")
-	c.Assert(err, check.IsNil)
-	c.Assert(nodeFromDB, check.NotNil)
+	require.NoError(t, err)
+	require.NotNil(t, nodeFromDB)
 
-	c.Assert(nodeFromDB.IsExpired(), check.Equals, false)
+	assert.False(t, nodeFromDB.IsExpired())
 
 	now := time.Now()
 	err = db.NodeSetExpiry(nodeFromDB.ID, now)
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 
 	nodeFromDB, err = db.getNode(types.UserID(user.ID), "testnode")
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 
-	c.Assert(nodeFromDB.IsExpired(), check.Equals, true)
+	assert.True(t, nodeFromDB.IsExpired())
 }
 
-func (s *Suite) TestSetTags(c *check.C) {
+func TestSetTags(t *testing.T) {
+	db, err := newSQLiteTestDB()
+	require.NoError(t, err)
+
 	user, err := db.CreateUser(types.User{Name: "test"})
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 
 	pak, err := db.CreatePreAuthKey(user.TypedID(), false, false, nil, nil)
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 
 	_, err = db.getNode(types.UserID(user.ID), "testnode")
-	c.Assert(err, check.NotNil)
+	require.Error(t, err)
 
 	nodeKey := key.NewNode()
 	machineKey := key.NewMachine()
@@ -146,27 +163,23 @@ func (s *Suite) TestSetTags(c *check.C) {
 	}
 
 	trx := db.DB.Save(node)
-	c.Assert(trx.Error, check.IsNil)
+	require.NoError(t, trx.Error)
 
 	// assign simple tags
 	sTags := []string{"tag:test", "tag:foo"}
 	err = db.SetTags(node.ID, sTags)
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 	node, err = db.getNode(types.UserID(user.ID), "testnode")
-	c.Assert(err, check.IsNil)
-	c.Assert(node.Tags, check.DeepEquals, sTags)
+	require.NoError(t, err)
+	assert.Equal(t, sTags, node.Tags)
 
 	// assign duplicate tags, expect no errors but no doubles in DB
 	eTags := []string{"tag:bar", "tag:test", "tag:unknown", "tag:test"}
 	err = db.SetTags(node.ID, eTags)
-	c.Assert(err, check.IsNil)
+	require.NoError(t, err)
 	node, err = db.getNode(types.UserID(user.ID), "testnode")
-	c.Assert(err, check.IsNil)
-	c.Assert(
-		node.Tags,
-		check.DeepEquals,
-		[]string{"tag:bar", "tag:test", "tag:unknown"},
-	)
+	require.NoError(t, err)
+	assert.Equal(t, []string{"tag:bar", "tag:test", "tag:unknown"}, node.Tags)
 }
 
 func TestHeadscale_generateGivenName(t *testing.T) {
diff --git a/hscontrol/db/suite_test.go b/hscontrol/db/suite_test.go
index e28d4076..4ebccbdd 100644
--- a/hscontrol/db/suite_test.go
+++ b/hscontrol/db/suite_test.go
@@ -10,48 +10,11 @@ import (
 
 	"github.com/juanfont/headscale/hscontrol/types"
 	"github.com/rs/zerolog"
-	"gopkg.in/check.v1"
 	"zombiezen.com/go/postgrestest"
 )
 
-func Test(t *testing.T) {
-	check.TestingT(t)
-}
-
-var _ = check.Suite(&Suite{})
-
-type Suite struct{}
-
-var (
-	tmpDir string
-	db     *HSDatabase
-)
-
-func (s *Suite) SetUpTest(c *check.C) {
-	s.ResetDB(c)
-}
-
-func (s *Suite) TearDownTest(c *check.C) {
-	// os.RemoveAll(tmpDir)
-}
-
-func (s *Suite) ResetDB(c *check.C) {
-	// if len(tmpDir) != 0 {
-	// 	os.RemoveAll(tmpDir)
-	// }
-
-	var err error
-	db, err = newSQLiteTestDB()
-	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) {
-	var err error
-	tmpDir, err = os.MkdirTemp("", "headscale-db-test-*")
+	tmpDir, err := os.MkdirTemp("", "headscale-db-test-*")
 	if err != nil {
 		return nil, err
 	}
@@ -59,7 +22,7 @@ func newSQLiteTestDB() (*HSDatabase, error) {
 	log.Printf("database path: %s", tmpDir+"/headscale_test.db")
 	zerolog.SetGlobalLevel(zerolog.Disabled)
 
-	db, err = NewHeadscaleDatabase(
+	db, err := NewHeadscaleDatabase(
 		types.DatabaseConfig{
 			Type: types.DatabaseSqlite,
 			Sqlite: types.SqliteConfig{
diff --git a/hscontrol/mapper/suite_test.go b/hscontrol/mapper/suite_test.go
deleted file mode 100644
index c9b1a580..00000000
--- a/hscontrol/mapper/suite_test.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package mapper
-
-import (
-	"testing"
-
-	"gopkg.in/check.v1"
-)
-
-func Test(t *testing.T) {
-	check.TestingT(t)
-}
-
-var _ = check.Suite(&Suite{})
-
-type Suite struct{}
diff --git a/hscontrol/suite_test.go b/hscontrol/suite_test.go
deleted file mode 100644
index fb64d18e..00000000
--- a/hscontrol/suite_test.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package hscontrol
-
-import (
-	"os"
-	"testing"
-
-	"github.com/juanfont/headscale/hscontrol/types"
-	"gopkg.in/check.v1"
-)
-
-func Test(t *testing.T) {
-	check.TestingT(t)
-}
-
-var _ = check.Suite(&Suite{})
-
-type Suite struct{}
-
-var (
-	tmpDir string
-	app    *Headscale
-)
-
-func (s *Suite) SetUpTest(c *check.C) {
-	s.ResetDB(c)
-}
-
-func (s *Suite) TearDownTest(c *check.C) {
-	os.RemoveAll(tmpDir)
-}
-
-func (s *Suite) ResetDB(c *check.C) {
-	if len(tmpDir) != 0 {
-		os.RemoveAll(tmpDir)
-	}
-	var err error
-	tmpDir, err = os.MkdirTemp("", "autoygg-client-test2")
-	if err != nil {
-		c.Fatal(err)
-	}
-	cfg := types.Config{
-		NoisePrivateKeyPath: tmpDir + "/noise_private.key",
-		Database: types.DatabaseConfig{
-			Type: "sqlite3",
-			Sqlite: types.SqliteConfig{
-				Path: tmpDir + "/headscale_test.db",
-			},
-		},
-		OIDC: types.OIDCConfig{},
-	}
-
-	app, err = NewHeadscale(&cfg)
-	if err != nil {
-		c.Fatal(err)
-	}
-}