diff --git a/acls_test.go b/acls_test.go
index c178805..cca39ce 100644
--- a/acls_test.go
+++ b/acls_test.go
@@ -5,58 +5,58 @@ import (
 )
 
 func (s *Suite) TestWrongPath(c *check.C) {
-	err := h.LoadACLPolicy("asdfg")
+	err := app.LoadACLPolicy("asdfg")
 	c.Assert(err, check.NotNil)
 }
 
 func (s *Suite) TestBrokenHuJson(c *check.C) {
-	err := h.LoadACLPolicy("./tests/acls/broken.hujson")
+	err := app.LoadACLPolicy("./tests/acls/broken.hujson")
 	c.Assert(err, check.NotNil)
 }
 
 func (s *Suite) TestInvalidPolicyHuson(c *check.C) {
-	err := h.LoadACLPolicy("./tests/acls/invalid.hujson")
+	err := app.LoadACLPolicy("./tests/acls/invalid.hujson")
 	c.Assert(err, check.NotNil)
 	c.Assert(err, check.Equals, errorEmptyPolicy)
 }
 
 func (s *Suite) TestParseHosts(c *check.C) {
-	var hs Hosts
-	err := hs.UnmarshalJSON(
+	var hosts Hosts
+	err := hosts.UnmarshalJSON(
 		[]byte(
 			`{"example-host-1": "100.100.100.100","example-host-2": "100.100.101.100/24"}`,
 		),
 	)
-	c.Assert(hs, check.NotNil)
+	c.Assert(hosts, check.NotNil)
 	c.Assert(err, check.IsNil)
 }
 
 func (s *Suite) TestParseInvalidCIDR(c *check.C) {
-	var hs Hosts
-	err := hs.UnmarshalJSON([]byte(`{"example-host-1": "100.100.100.100/42"}`))
-	c.Assert(hs, check.IsNil)
+	var hosts Hosts
+	err := hosts.UnmarshalJSON([]byte(`{"example-host-1": "100.100.100.100/42"}`))
+	c.Assert(hosts, check.IsNil)
 	c.Assert(err, check.NotNil)
 }
 
 func (s *Suite) TestRuleInvalidGeneration(c *check.C) {
-	err := h.LoadACLPolicy("./tests/acls/acl_policy_invalid.hujson")
+	err := app.LoadACLPolicy("./tests/acls/acl_policy_invalid.hujson")
 	c.Assert(err, check.NotNil)
 }
 
 func (s *Suite) TestBasicRule(c *check.C) {
-	err := h.LoadACLPolicy("./tests/acls/acl_policy_basic_1.hujson")
+	err := app.LoadACLPolicy("./tests/acls/acl_policy_basic_1.hujson")
 	c.Assert(err, check.IsNil)
 
-	rules, err := h.generateACLRules()
+	rules, err := app.generateACLRules()
 	c.Assert(err, check.IsNil)
 	c.Assert(rules, check.NotNil)
 }
 
 func (s *Suite) TestPortRange(c *check.C) {
-	err := h.LoadACLPolicy("./tests/acls/acl_policy_basic_range.hujson")
+	err := app.LoadACLPolicy("./tests/acls/acl_policy_basic_range.hujson")
 	c.Assert(err, check.IsNil)
 
-	rules, err := h.generateACLRules()
+	rules, err := app.generateACLRules()
 	c.Assert(err, check.IsNil)
 	c.Assert(rules, check.NotNil)
 
@@ -67,10 +67,10 @@ func (s *Suite) TestPortRange(c *check.C) {
 }
 
 func (s *Suite) TestPortWildcard(c *check.C) {
-	err := h.LoadACLPolicy("./tests/acls/acl_policy_basic_wildcards.hujson")
+	err := app.LoadACLPolicy("./tests/acls/acl_policy_basic_wildcards.hujson")
 	c.Assert(err, check.IsNil)
 
-	rules, err := h.generateACLRules()
+	rules, err := app.generateACLRules()
 	c.Assert(err, check.IsNil)
 	c.Assert(rules, check.NotNil)
 
@@ -83,33 +83,35 @@ func (s *Suite) TestPortWildcard(c *check.C) {
 }
 
 func (s *Suite) TestPortNamespace(c *check.C) {
-	n, err := h.CreateNamespace("testnamespace")
+	namespace, err := app.CreateNamespace("testnamespace")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine("testnamespace", "testmachine")
+	_, err = app.GetMachine("testnamespace", "testmachine")
 	c.Assert(err, check.NotNil)
-	ip, _ := h.getAvailableIP()
-	m := Machine{
+	ip, _ := app.getAvailableIP()
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      ip.String(),
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	err = h.LoadACLPolicy("./tests/acls/acl_policy_basic_namespace_as_user.hujson")
+	err = app.LoadACLPolicy(
+		"./tests/acls/acl_policy_basic_namespace_as_user.hujson",
+	)
 	c.Assert(err, check.IsNil)
 
-	rules, err := h.generateACLRules()
+	rules, err := app.generateACLRules()
 	c.Assert(err, check.IsNil)
 	c.Assert(rules, check.NotNil)
 
@@ -123,33 +125,33 @@ func (s *Suite) TestPortNamespace(c *check.C) {
 }
 
 func (s *Suite) TestPortGroup(c *check.C) {
-	n, err := h.CreateNamespace("testnamespace")
+	namespace, err := app.CreateNamespace("testnamespace")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine("testnamespace", "testmachine")
+	_, err = app.GetMachine("testnamespace", "testmachine")
 	c.Assert(err, check.NotNil)
-	ip, _ := h.getAvailableIP()
-	m := Machine{
+	ip, _ := app.getAvailableIP()
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      ip.String(),
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	err = h.LoadACLPolicy("./tests/acls/acl_policy_basic_groups.hujson")
+	err = app.LoadACLPolicy("./tests/acls/acl_policy_basic_groups.hujson")
 	c.Assert(err, check.IsNil)
 
-	rules, err := h.generateACLRules()
+	rules, err := app.generateACLRules()
 	c.Assert(err, check.IsNil)
 	c.Assert(rules, check.NotNil)
 
diff --git a/app_test.go b/app_test.go
index ec23282..947062b 100644
--- a/app_test.go
+++ b/app_test.go
@@ -19,7 +19,7 @@ type Suite struct{}
 
 var (
 	tmpDir string
-	h      Headscale
+	app    Headscale
 )
 
 func (s *Suite) SetUpTest(c *check.C) {
@@ -43,18 +43,18 @@ func (s *Suite) ResetDB(c *check.C) {
 		IPPrefix: netaddr.MustParseIPPrefix("10.27.0.0/23"),
 	}
 
-	h = Headscale{
+	app = Headscale{
 		cfg:      cfg,
 		dbType:   "sqlite3",
 		dbString: tmpDir + "/headscale_test.db",
 	}
-	err = h.initDB()
+	err = app.initDB()
 	if err != nil {
 		c.Fatal(err)
 	}
-	db, err := h.openDB()
+	db, err := app.openDB()
 	if err != nil {
 		c.Fatal(err)
 	}
-	h.db = db
+	app.db = db
 }
diff --git a/cli_test.go b/cli_test.go
index 6c0b2bb..44ef9f0 100644
--- a/cli_test.go
+++ b/cli_test.go
@@ -7,34 +7,34 @@ import (
 )
 
 func (s *Suite) TestRegisterMachine(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
 	now := time.Now().UTC()
 
-	m := Machine{
+	machine := Machine{
 		ID:              0,
 		MachineKey:      "8ce002a935f8c394e55e78fbbb410576575ff8ec5cfa2e627e4b807f1be15b0e",
 		NodeKey:         "bar",
 		DiscoKey:        "faa",
 		Name:            "testmachine",
-		NamespaceID:     n.ID,
+		NamespaceID:     namespace.ID,
 		IPAddress:       "10.0.0.1",
 		Expiry:          &now,
 		RequestedExpiry: &now,
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	_, err = h.GetMachine("test", "testmachine")
+	_, err = app.GetMachine("test", "testmachine")
 	c.Assert(err, check.IsNil)
 
-	m2, err := h.RegisterMachine(
+	machineAfterRegistering, err := app.RegisterMachine(
 		"8ce002a935f8c394e55e78fbbb410576575ff8ec5cfa2e627e4b807f1be15b0e",
-		n.Name,
+		namespace.Name,
 	)
 	c.Assert(err, check.IsNil)
-	c.Assert(m2.Registered, check.Equals, true)
+	c.Assert(machineAfterRegistering.Registered, check.Equals, true)
 
-	_, err = m2.GetHostInfo()
+	_, err = machineAfterRegistering.GetHostInfo()
 	c.Assert(err, check.IsNil)
 }
diff --git a/dns_test.go b/dns_test.go
index dfde863..a2f7a65 100644
--- a/dns_test.go
+++ b/dns_test.go
@@ -70,100 +70,120 @@ func (s *Suite) TestMagicDNSRootDomains172(c *check.C) {
 }
 
 func (s *Suite) TestDNSConfigMapResponseWithMagicDNS(c *check.C) {
-	n1, err := h.CreateNamespace("shared1")
+	namespaceShared1, err := app.CreateNamespace("shared1")
 	c.Assert(err, check.IsNil)
 
-	n2, err := h.CreateNamespace("shared2")
+	namespaceShared2, err := app.CreateNamespace("shared2")
 	c.Assert(err, check.IsNil)
 
-	n3, err := h.CreateNamespace("shared3")
+	namespaceShared3, err := app.CreateNamespace("shared3")
 	c.Assert(err, check.IsNil)
 
-	pak1n1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	preAuthKeyInShared1, err := app.CreatePreAuthKey(
+		namespaceShared1.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak2n2, err := h.CreatePreAuthKey(n2.Name, false, false, nil)
+	preAuthKeyInShared2, err := app.CreatePreAuthKey(
+		namespaceShared2.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak3n3, err := h.CreatePreAuthKey(n3.Name, false, false, nil)
+	preAuthKeyInShared3, err := app.CreatePreAuthKey(
+		namespaceShared3.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak4n1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	PreAuthKey2InShared1, err := app.CreatePreAuthKey(
+		namespaceShared1.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine(n1.Name, "test_get_shared_nodes_1")
+	_, err = app.GetMachine(namespaceShared1.Name, "test_get_shared_nodes_1")
 	c.Assert(err, check.NotNil)
 
-	m1 := &Machine{
+	machineInShared1 := &Machine{
 		ID:             1,
 		MachineKey:     "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		NodeKey:        "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		DiscoKey:       "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		Name:           "test_get_shared_nodes_1",
-		NamespaceID:    n1.ID,
-		Namespace:      *n1,
+		NamespaceID:    namespaceShared1.ID,
+		Namespace:      *namespaceShared1,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.1",
-		AuthKeyID:      uint(pak1n1.ID),
+		AuthKeyID:      uint(preAuthKeyInShared1.ID),
 	}
-	h.db.Save(m1)
+	app.db.Save(machineInShared1)
 
-	_, err = h.GetMachine(n1.Name, m1.Name)
+	_, err = app.GetMachine(namespaceShared1.Name, machineInShared1.Name)
 	c.Assert(err, check.IsNil)
 
-	m2 := &Machine{
+	machineInShared2 := &Machine{
 		ID:             2,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_2",
-		NamespaceID:    n2.ID,
-		Namespace:      *n2,
+		NamespaceID:    namespaceShared2.ID,
+		Namespace:      *namespaceShared2,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.2",
-		AuthKeyID:      uint(pak2n2.ID),
+		AuthKeyID:      uint(preAuthKeyInShared2.ID),
 	}
-	h.db.Save(m2)
+	app.db.Save(machineInShared2)
 
-	_, err = h.GetMachine(n2.Name, m2.Name)
+	_, err = app.GetMachine(namespaceShared2.Name, machineInShared2.Name)
 	c.Assert(err, check.IsNil)
 
-	m3 := &Machine{
+	machineInShared3 := &Machine{
 		ID:             3,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_3",
-		NamespaceID:    n3.ID,
-		Namespace:      *n3,
+		NamespaceID:    namespaceShared3.ID,
+		Namespace:      *namespaceShared3,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.3",
-		AuthKeyID:      uint(pak3n3.ID),
+		AuthKeyID:      uint(preAuthKeyInShared3.ID),
 	}
-	h.db.Save(m3)
+	app.db.Save(machineInShared3)
 
-	_, err = h.GetMachine(n3.Name, m3.Name)
+	_, err = app.GetMachine(namespaceShared3.Name, machineInShared3.Name)
 	c.Assert(err, check.IsNil)
 
-	m4 := &Machine{
+	machine2InShared1 := &Machine{
 		ID:             4,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_4",
-		NamespaceID:    n1.ID,
-		Namespace:      *n1,
+		NamespaceID:    namespaceShared1.ID,
+		Namespace:      *namespaceShared1,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.4",
-		AuthKeyID:      uint(pak4n1.ID),
+		AuthKeyID:      uint(PreAuthKey2InShared1.ID),
 	}
-	h.db.Save(m4)
+	app.db.Save(machine2InShared1)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machineInShared2, namespaceShared1)
 	c.Assert(err, check.IsNil)
 
 	baseDomain := "foobar.headscale.net"
@@ -173,121 +193,146 @@ func (s *Suite) TestDNSConfigMapResponseWithMagicDNS(c *check.C) {
 		Proxied: true,
 	}
 
-	m1peers, err := h.getPeers(m1)
+	peersOfMachineInShared1, err := app.getPeers(machineInShared1)
 	c.Assert(err, check.IsNil)
 
-	dnsConfig := getMapResponseDNSConfig(&dnsConfigOrig, baseDomain, *m1, m1peers)
+	dnsConfig := getMapResponseDNSConfig(
+		&dnsConfigOrig,
+		baseDomain,
+		*machineInShared1,
+		peersOfMachineInShared1,
+	)
 	c.Assert(dnsConfig, check.NotNil)
 	c.Assert(len(dnsConfig.Routes), check.Equals, 2)
 
-	routeN1 := fmt.Sprintf("%s.%s", n1.Name, baseDomain)
-	_, ok := dnsConfig.Routes[routeN1]
+	domainRouteShared1 := fmt.Sprintf("%s.%s", namespaceShared1.Name, baseDomain)
+	_, ok := dnsConfig.Routes[domainRouteShared1]
 	c.Assert(ok, check.Equals, true)
 
-	routeN2 := fmt.Sprintf("%s.%s", n2.Name, baseDomain)
-	_, ok = dnsConfig.Routes[routeN2]
+	domainRouteShared2 := fmt.Sprintf("%s.%s", namespaceShared2.Name, baseDomain)
+	_, ok = dnsConfig.Routes[domainRouteShared2]
 	c.Assert(ok, check.Equals, true)
 
-	routeN3 := fmt.Sprintf("%s.%s", n3.Name, baseDomain)
-	_, ok = dnsConfig.Routes[routeN3]
+	domainRouteShared3 := fmt.Sprintf("%s.%s", namespaceShared3.Name, baseDomain)
+	_, ok = dnsConfig.Routes[domainRouteShared3]
 	c.Assert(ok, check.Equals, false)
 }
 
 func (s *Suite) TestDNSConfigMapResponseWithoutMagicDNS(c *check.C) {
-	n1, err := h.CreateNamespace("shared1")
+	namespaceShared1, err := app.CreateNamespace("shared1")
 	c.Assert(err, check.IsNil)
 
-	n2, err := h.CreateNamespace("shared2")
+	namespaceShared2, err := app.CreateNamespace("shared2")
 	c.Assert(err, check.IsNil)
 
-	n3, err := h.CreateNamespace("shared3")
+	namespaceShared3, err := app.CreateNamespace("shared3")
 	c.Assert(err, check.IsNil)
 
-	pak1n1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	preAuthKeyInShared1, err := app.CreatePreAuthKey(
+		namespaceShared1.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak2n2, err := h.CreatePreAuthKey(n2.Name, false, false, nil)
+	preAuthKeyInShared2, err := app.CreatePreAuthKey(
+		namespaceShared2.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak3n3, err := h.CreatePreAuthKey(n3.Name, false, false, nil)
+	preAuthKeyInShared3, err := app.CreatePreAuthKey(
+		namespaceShared3.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak4n1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	preAuthKey2InShared1, err := app.CreatePreAuthKey(
+		namespaceShared1.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine(n1.Name, "test_get_shared_nodes_1")
+	_, err = app.GetMachine(namespaceShared1.Name, "test_get_shared_nodes_1")
 	c.Assert(err, check.NotNil)
 
-	m1 := &Machine{
+	machineInShared1 := &Machine{
 		ID:             1,
 		MachineKey:     "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		NodeKey:        "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		DiscoKey:       "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		Name:           "test_get_shared_nodes_1",
-		NamespaceID:    n1.ID,
-		Namespace:      *n1,
+		NamespaceID:    namespaceShared1.ID,
+		Namespace:      *namespaceShared1,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.1",
-		AuthKeyID:      uint(pak1n1.ID),
+		AuthKeyID:      uint(preAuthKeyInShared1.ID),
 	}
-	h.db.Save(m1)
+	app.db.Save(machineInShared1)
 
-	_, err = h.GetMachine(n1.Name, m1.Name)
+	_, err = app.GetMachine(namespaceShared1.Name, machineInShared1.Name)
 	c.Assert(err, check.IsNil)
 
-	m2 := &Machine{
+	machineInShared2 := &Machine{
 		ID:             2,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_2",
-		NamespaceID:    n2.ID,
-		Namespace:      *n2,
+		NamespaceID:    namespaceShared2.ID,
+		Namespace:      *namespaceShared2,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.2",
-		AuthKeyID:      uint(pak2n2.ID),
+		AuthKeyID:      uint(preAuthKeyInShared2.ID),
 	}
-	h.db.Save(m2)
+	app.db.Save(machineInShared2)
 
-	_, err = h.GetMachine(n2.Name, m2.Name)
+	_, err = app.GetMachine(namespaceShared2.Name, machineInShared2.Name)
 	c.Assert(err, check.IsNil)
 
-	m3 := &Machine{
+	machineInShared3 := &Machine{
 		ID:             3,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_3",
-		NamespaceID:    n3.ID,
-		Namespace:      *n3,
+		NamespaceID:    namespaceShared3.ID,
+		Namespace:      *namespaceShared3,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.3",
-		AuthKeyID:      uint(pak3n3.ID),
+		AuthKeyID:      uint(preAuthKeyInShared3.ID),
 	}
-	h.db.Save(m3)
+	app.db.Save(machineInShared3)
 
-	_, err = h.GetMachine(n3.Name, m3.Name)
+	_, err = app.GetMachine(namespaceShared3.Name, machineInShared3.Name)
 	c.Assert(err, check.IsNil)
 
-	m4 := &Machine{
+	machine2InShared1 := &Machine{
 		ID:             4,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_4",
-		NamespaceID:    n1.ID,
-		Namespace:      *n1,
+		NamespaceID:    namespaceShared1.ID,
+		Namespace:      *namespaceShared1,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.4",
-		AuthKeyID:      uint(pak4n1.ID),
+		AuthKeyID:      uint(preAuthKey2InShared1.ID),
 	}
-	h.db.Save(m4)
+	app.db.Save(machine2InShared1)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machineInShared2, namespaceShared1)
 	c.Assert(err, check.IsNil)
 
 	baseDomain := "foobar.headscale.net"
@@ -297,10 +342,15 @@ func (s *Suite) TestDNSConfigMapResponseWithoutMagicDNS(c *check.C) {
 		Proxied: false,
 	}
 
-	m1peers, err := h.getPeers(m1)
+	peersOfMachine1Shared1, err := app.getPeers(machineInShared1)
 	c.Assert(err, check.IsNil)
 
-	dnsConfig := getMapResponseDNSConfig(&dnsConfigOrig, baseDomain, *m1, m1peers)
+	dnsConfig := getMapResponseDNSConfig(
+		&dnsConfigOrig,
+		baseDomain,
+		*machineInShared1,
+		peersOfMachine1Shared1,
+	)
 	c.Assert(dnsConfig, check.NotNil)
 	c.Assert(len(dnsConfig.Routes), check.Equals, 0)
 	c.Assert(len(dnsConfig.Domains), check.Equals, 1)
diff --git a/integration_test.go b/integration_test.go
index ddbf19d..a9125a0 100644
--- a/integration_test.go
+++ b/integration_test.go
@@ -185,7 +185,7 @@ func (s *IntegrationTestSuite) tailscaleContainer(
 
 func (s *IntegrationTestSuite) SetupSuite() {
 	var err error
-	h = Headscale{
+	app = Headscale{
 		dbType:   "sqlite3",
 		dbString: "integration_test_db.sqlite3",
 	}
diff --git a/machine_test.go b/machine_test.go
index dfe84d3..cf36740 100644
--- a/machine_test.go
+++ b/machine_test.go
@@ -8,152 +8,159 @@ import (
 )
 
 func (s *Suite) TestGetMachine(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine("test", "testmachine")
+	_, err = app.GetMachine("test", "testmachine")
 	c.Assert(err, check.NotNil)
 
-	m := &Machine{
+	machine := &Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(m)
+	app.db.Save(machine)
 
-	m1, err := h.GetMachine("test", "testmachine")
+	machineFromDB, err := app.GetMachine("test", "testmachine")
 	c.Assert(err, check.IsNil)
 
-	_, err = m1.GetHostInfo()
+	_, err = machineFromDB.GetHostInfo()
 	c.Assert(err, check.IsNil)
 }
 
 func (s *Suite) TestGetMachineByID(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachineByID(0)
+	_, err = app.GetMachineByID(0)
 	c.Assert(err, check.NotNil)
 
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	m1, err := h.GetMachineByID(0)
+	machineByID, err := app.GetMachineByID(0)
 	c.Assert(err, check.IsNil)
 
-	_, err = m1.GetHostInfo()
+	_, err = machineByID.GetHostInfo()
 	c.Assert(err, check.IsNil)
 }
 
 func (s *Suite) TestDeleteMachine(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(1),
 	}
-	h.db.Save(&m)
-	err = h.DeleteMachine(&m)
+	app.db.Save(&machine)
+
+	err = app.DeleteMachine(&machine)
 	c.Assert(err, check.IsNil)
-	v, err := h.getValue("namespaces_pending_updates")
+
+	namespacesPendingUpdates, err := app.getValue("namespaces_pending_updates")
 	c.Assert(err, check.IsNil)
+
 	names := []string{}
-	err = json.Unmarshal([]byte(v), &names)
+	err = json.Unmarshal([]byte(namespacesPendingUpdates), &names)
 	c.Assert(err, check.IsNil)
-	c.Assert(names, check.DeepEquals, []string{n.Name})
-	h.checkForNamespacesPendingUpdates()
-	v, _ = h.getValue("namespaces_pending_updates")
-	c.Assert(v, check.Equals, "")
-	_, err = h.GetMachine(n.Name, "testmachine")
+	c.Assert(names, check.DeepEquals, []string{namespace.Name})
+
+	app.checkForNamespacesPendingUpdates()
+
+	namespacesPendingUpdates, _ = app.getValue("namespaces_pending_updates")
+	c.Assert(namespacesPendingUpdates, check.Equals, "")
+	_, err = app.GetMachine(namespace.Name, "testmachine")
 	c.Assert(err, check.NotNil)
 }
 
 func (s *Suite) TestHardDeleteMachine(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine3",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(1),
 	}
-	h.db.Save(&m)
-	err = h.HardDeleteMachine(&m)
+	app.db.Save(&machine)
+
+	err = app.HardDeleteMachine(&machine)
 	c.Assert(err, check.IsNil)
-	_, err = h.GetMachine(n.Name, "testmachine3")
+
+	_, err = app.GetMachine(namespace.Name, "testmachine3")
 	c.Assert(err, check.NotNil)
 }
 
 func (s *Suite) TestGetDirectPeers(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachineByID(0)
+	_, err = app.GetMachineByID(0)
 	c.Assert(err, check.NotNil)
 
-	for i := 0; i <= 10; i++ {
-		m := Machine{
-			ID:             uint64(i),
-			MachineKey:     "foo" + strconv.Itoa(i),
-			NodeKey:        "bar" + strconv.Itoa(i),
-			DiscoKey:       "faa" + strconv.Itoa(i),
-			Name:           "testmachine" + strconv.Itoa(i),
-			NamespaceID:    n.ID,
+	for index := 0; index <= 10; index++ {
+		machine := Machine{
+			ID:             uint64(index),
+			MachineKey:     "foo" + strconv.Itoa(index),
+			NodeKey:        "bar" + strconv.Itoa(index),
+			DiscoKey:       "faa" + strconv.Itoa(index),
+			Name:           "testmachine" + strconv.Itoa(index),
+			NamespaceID:    namespace.ID,
 			Registered:     true,
 			RegisterMethod: "authKey",
 			AuthKeyID:      uint(pak.ID),
 		}
-		h.db.Save(&m)
+		app.db.Save(&machine)
 	}
 
-	m1, err := h.GetMachineByID(0)
+	machine0ByID, err := app.GetMachineByID(0)
 	c.Assert(err, check.IsNil)
 
-	_, err = m1.GetHostInfo()
+	_, err = machine0ByID.GetHostInfo()
 	c.Assert(err, check.IsNil)
 
-	peers, err := h.getDirectPeers(m1)
+	peersOfMachine0, err := app.getDirectPeers(machine0ByID)
 	c.Assert(err, check.IsNil)
 
-	c.Assert(len(peers), check.Equals, 9)
-	c.Assert(peers[0].Name, check.Equals, "testmachine2")
-	c.Assert(peers[5].Name, check.Equals, "testmachine7")
-	c.Assert(peers[8].Name, check.Equals, "testmachine10")
+	c.Assert(len(peersOfMachine0), check.Equals, 9)
+	c.Assert(peersOfMachine0[0].Name, check.Equals, "testmachine2")
+	c.Assert(peersOfMachine0[5].Name, check.Equals, "testmachine7")
+	c.Assert(peersOfMachine0[8].Name, check.Equals, "testmachine10")
 }
diff --git a/namespaces_test.go b/namespaces_test.go
index 502bc36..7ac1f06 100644
--- a/namespaces_test.go
+++ b/namespaces_test.go
@@ -7,197 +7,220 @@ import (
 )
 
 func (s *Suite) TestCreateAndDestroyNamespace(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
-	c.Assert(n.Name, check.Equals, "test")
+	c.Assert(namespace.Name, check.Equals, "test")
 
-	ns, err := h.ListNamespaces()
+	namespaces, err := app.ListNamespaces()
 	c.Assert(err, check.IsNil)
-	c.Assert(len(ns), check.Equals, 1)
+	c.Assert(len(namespaces), check.Equals, 1)
 
-	err = h.DestroyNamespace("test")
+	err = app.DestroyNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetNamespace("test")
+	_, err = app.GetNamespace("test")
 	c.Assert(err, check.NotNil)
 }
 
 func (s *Suite) TestDestroyNamespaceErrors(c *check.C) {
-	err := h.DestroyNamespace("test")
+	err := app.DestroyNamespace("test")
 	c.Assert(err, check.Equals, errorNamespaceNotFound)
 
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	err = h.DestroyNamespace("test")
+	err = app.DestroyNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	result := h.db.Preload("Namespace").First(&pak, "key = ?", pak.Key)
+	result := app.db.Preload("Namespace").First(&pak, "key = ?", pak.Key)
 	// destroying a namespace also deletes all associated preauthkeys
 	c.Assert(result.Error, check.Equals, gorm.ErrRecordNotFound)
 
-	n, err = h.CreateNamespace("test")
+	namespace, err = app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	pak, err = h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err = app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	err = h.DestroyNamespace("test")
+	err = app.DestroyNamespace("test")
 	c.Assert(err, check.Equals, errorNamespaceNotEmptyOfNodes)
 }
 
 func (s *Suite) TestRenameNamespace(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespaceTest, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
-	c.Assert(n.Name, check.Equals, "test")
+	c.Assert(namespaceTest.Name, check.Equals, "test")
 
-	ns, err := h.ListNamespaces()
+	namespaces, err := app.ListNamespaces()
 	c.Assert(err, check.IsNil)
-	c.Assert(len(ns), check.Equals, 1)
+	c.Assert(len(namespaces), check.Equals, 1)
 
-	err = h.RenameNamespace("test", "test_renamed")
+	err = app.RenameNamespace("test", "test_renamed")
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetNamespace("test")
+	_, err = app.GetNamespace("test")
 	c.Assert(err, check.Equals, errorNamespaceNotFound)
 
-	_, err = h.GetNamespace("test_renamed")
+	_, err = app.GetNamespace("test_renamed")
 	c.Assert(err, check.IsNil)
 
-	err = h.RenameNamespace("test_does_not_exit", "test")
+	err = app.RenameNamespace("test_does_not_exit", "test")
 	c.Assert(err, check.Equals, errorNamespaceNotFound)
 
-	n2, err := h.CreateNamespace("test2")
+	namespaceTest2, err := app.CreateNamespace("test2")
 	c.Assert(err, check.IsNil)
-	c.Assert(n2.Name, check.Equals, "test2")
+	c.Assert(namespaceTest2.Name, check.Equals, "test2")
 
-	err = h.RenameNamespace("test2", "test_renamed")
+	err = app.RenameNamespace("test2", "test_renamed")
 	c.Assert(err, check.Equals, errorNamespaceExists)
 }
 
 func (s *Suite) TestGetMapResponseUserProfiles(c *check.C) {
-	n1, err := h.CreateNamespace("shared1")
+	namespaceShared1, err := app.CreateNamespace("shared1")
 	c.Assert(err, check.IsNil)
 
-	n2, err := h.CreateNamespace("shared2")
+	namespaceShared2, err := app.CreateNamespace("shared2")
 	c.Assert(err, check.IsNil)
 
-	n3, err := h.CreateNamespace("shared3")
+	namespaceShared3, err := app.CreateNamespace("shared3")
 	c.Assert(err, check.IsNil)
 
-	pak1n1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	preAuthKeyShared1, err := app.CreatePreAuthKey(
+		namespaceShared1.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak2n2, err := h.CreatePreAuthKey(n2.Name, false, false, nil)
+	preAuthKeyShared2, err := app.CreatePreAuthKey(
+		namespaceShared2.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak3n3, err := h.CreatePreAuthKey(n3.Name, false, false, nil)
+	preAuthKeyShared3, err := app.CreatePreAuthKey(
+		namespaceShared3.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	pak4n1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	preAuthKey2Shared1, err := app.CreatePreAuthKey(
+		namespaceShared1.Name,
+		false,
+		false,
+		nil,
+	)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine(n1.Name, "test_get_shared_nodes_1")
+	_, err = app.GetMachine(namespaceShared1.Name, "test_get_shared_nodes_1")
 	c.Assert(err, check.NotNil)
 
-	m1 := &Machine{
+	machineInShared1 := &Machine{
 		ID:             1,
 		MachineKey:     "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		NodeKey:        "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		DiscoKey:       "686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		Name:           "test_get_shared_nodes_1",
-		NamespaceID:    n1.ID,
-		Namespace:      *n1,
+		NamespaceID:    namespaceShared1.ID,
+		Namespace:      *namespaceShared1,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.1",
-		AuthKeyID:      uint(pak1n1.ID),
+		AuthKeyID:      uint(preAuthKeyShared1.ID),
 	}
-	h.db.Save(m1)
+	app.db.Save(machineInShared1)
 
-	_, err = h.GetMachine(n1.Name, m1.Name)
+	_, err = app.GetMachine(namespaceShared1.Name, machineInShared1.Name)
 	c.Assert(err, check.IsNil)
 
-	m2 := &Machine{
+	machineInShared2 := &Machine{
 		ID:             2,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_2",
-		NamespaceID:    n2.ID,
-		Namespace:      *n2,
+		NamespaceID:    namespaceShared2.ID,
+		Namespace:      *namespaceShared2,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.2",
-		AuthKeyID:      uint(pak2n2.ID),
+		AuthKeyID:      uint(preAuthKeyShared2.ID),
 	}
-	h.db.Save(m2)
+	app.db.Save(machineInShared2)
 
-	_, err = h.GetMachine(n2.Name, m2.Name)
+	_, err = app.GetMachine(namespaceShared2.Name, machineInShared2.Name)
 	c.Assert(err, check.IsNil)
 
-	m3 := &Machine{
+	machineInShared3 := &Machine{
 		ID:             3,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_3",
-		NamespaceID:    n3.ID,
-		Namespace:      *n3,
+		NamespaceID:    namespaceShared3.ID,
+		Namespace:      *namespaceShared3,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.3",
-		AuthKeyID:      uint(pak3n3.ID),
+		AuthKeyID:      uint(preAuthKeyShared3.ID),
 	}
-	h.db.Save(m3)
+	app.db.Save(machineInShared3)
 
-	_, err = h.GetMachine(n3.Name, m3.Name)
+	_, err = app.GetMachine(namespaceShared3.Name, machineInShared3.Name)
 	c.Assert(err, check.IsNil)
 
-	m4 := &Machine{
+	machine2InShared1 := &Machine{
 		ID:             4,
 		MachineKey:     "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		NodeKey:        "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		DiscoKey:       "dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		Name:           "test_get_shared_nodes_4",
-		NamespaceID:    n1.ID,
-		Namespace:      *n1,
+		NamespaceID:    namespaceShared1.ID,
+		Namespace:      *namespaceShared1,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.4",
-		AuthKeyID:      uint(pak4n1.ID),
+		AuthKeyID:      uint(preAuthKey2Shared1.ID),
 	}
-	h.db.Save(m4)
+	app.db.Save(machine2InShared1)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machineInShared2, namespaceShared1)
 	c.Assert(err, check.IsNil)
-	m1peers, err := h.getPeers(m1)
+	peersOfMachine1InShared1, err := app.getPeers(machineInShared1)
 	c.Assert(err, check.IsNil)
 
-	userProfiles := getMapResponseUserProfiles(*m1, m1peers)
+	userProfiles := getMapResponseUserProfiles(
+		*machineInShared1,
+		peersOfMachine1InShared1,
+	)
 
 	log.Trace().Msgf("userProfiles %#v", userProfiles)
 	c.Assert(len(userProfiles), check.Equals, 2)
 
 	found := false
-	for _, up := range userProfiles {
-		if up.DisplayName == n1.Name {
+	for _, userProfiles := range userProfiles {
+		if userProfiles.DisplayName == namespaceShared1.Name {
 			found = true
 
 			break
@@ -206,8 +229,8 @@ func (s *Suite) TestGetMapResponseUserProfiles(c *check.C) {
 	c.Assert(found, check.Equals, true)
 
 	found = false
-	for _, up := range userProfiles {
-		if up.DisplayName == n2.Name {
+	for _, userProfile := range userProfiles {
+		if userProfile.DisplayName == namespaceShared2.Name {
 			found = true
 
 			break
diff --git a/oidc_test.go b/oidc_test.go
index 6b01924..21a4357 100644
--- a/oidc_test.go
+++ b/oidc_test.go
@@ -145,36 +145,36 @@ func TestHeadscale_getNamespaceFromEmail(t *testing.T) {
 		},
 	}
 	//nolint
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			h := &Headscale{
-				cfg:             tt.fields.cfg,
-				db:              tt.fields.db,
-				dbString:        tt.fields.dbString,
-				dbType:          tt.fields.dbType,
-				dbDebug:         tt.fields.dbDebug,
-				publicKey:       tt.fields.publicKey,
-				privateKey:      tt.fields.privateKey,
-				aclPolicy:       tt.fields.aclPolicy,
-				aclRules:        tt.fields.aclRules,
-				lastStateChange: tt.fields.lastStateChange,
-				oidcProvider:    tt.fields.oidcProvider,
-				oauth2Config:    tt.fields.oauth2Config,
-				oidcStateCache:  tt.fields.oidcStateCache,
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			app := &Headscale{
+				cfg:             test.fields.cfg,
+				db:              test.fields.db,
+				dbString:        test.fields.dbString,
+				dbType:          test.fields.dbType,
+				dbDebug:         test.fields.dbDebug,
+				publicKey:       test.fields.publicKey,
+				privateKey:      test.fields.privateKey,
+				aclPolicy:       test.fields.aclPolicy,
+				aclRules:        test.fields.aclRules,
+				lastStateChange: test.fields.lastStateChange,
+				oidcProvider:    test.fields.oidcProvider,
+				oauth2Config:    test.fields.oauth2Config,
+				oidcStateCache:  test.fields.oidcStateCache,
 			}
-			got, got1 := h.getNamespaceFromEmail(tt.args.email)
-			if got != tt.want {
+			got, got1 := app.getNamespaceFromEmail(test.args.email)
+			if got != test.want {
 				t.Errorf(
 					"Headscale.getNamespaceFromEmail() got = %v, want %v",
 					got,
-					tt.want,
+					test.want,
 				)
 			}
-			if got1 != tt.want1 {
+			if got1 != test.want1 {
 				t.Errorf(
 					"Headscale.getNamespaceFromEmail() got1 = %v, want %v",
 					got1,
-					tt.want1,
+					test.want1,
 				)
 			}
 		})
diff --git a/preauth_keys_test.go b/preauth_keys_test.go
index dceec00..6a6a79b 100644
--- a/preauth_keys_test.go
+++ b/preauth_keys_test.go
@@ -7,189 +7,189 @@ import (
 )
 
 func (*Suite) TestCreatePreAuthKey(c *check.C) {
-	_, err := h.CreatePreAuthKey("bogus", true, false, nil)
+	_, err := app.CreatePreAuthKey("bogus", true, false, nil)
 
 	c.Assert(err, check.NotNil)
 
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	k, err := h.CreatePreAuthKey(n.Name, true, false, nil)
+	key, err := app.CreatePreAuthKey(namespace.Name, true, false, nil)
 	c.Assert(err, check.IsNil)
 
 	// Did we get a valid key?
-	c.Assert(k.Key, check.NotNil)
-	c.Assert(len(k.Key), check.Equals, 48)
+	c.Assert(key.Key, check.NotNil)
+	c.Assert(len(key.Key), check.Equals, 48)
 
 	// Make sure the Namespace association is populated
-	c.Assert(k.Namespace.Name, check.Equals, n.Name)
+	c.Assert(key.Namespace.Name, check.Equals, namespace.Name)
 
-	_, err = h.ListPreAuthKeys("bogus")
+	_, err = app.ListPreAuthKeys("bogus")
 	c.Assert(err, check.NotNil)
 
-	keys, err := h.ListPreAuthKeys(n.Name)
+	keys, err := app.ListPreAuthKeys(namespace.Name)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(keys), check.Equals, 1)
 
 	// Make sure the Namespace association is populated
-	c.Assert((keys)[0].Namespace.Name, check.Equals, n.Name)
+	c.Assert((keys)[0].Namespace.Name, check.Equals, namespace.Name)
 }
 
 func (*Suite) TestExpiredPreAuthKey(c *check.C) {
-	n, err := h.CreateNamespace("test2")
+	namespace, err := app.CreateNamespace("test2")
 	c.Assert(err, check.IsNil)
 
 	now := time.Now()
-	pak, err := h.CreatePreAuthKey(n.Name, true, false, &now)
+	pak, err := app.CreatePreAuthKey(namespace.Name, true, false, &now)
 	c.Assert(err, check.IsNil)
 
-	p, err := h.checkKeyValidity(pak.Key)
+	key, err := app.checkKeyValidity(pak.Key)
 	c.Assert(err, check.Equals, errorAuthKeyExpired)
-	c.Assert(p, check.IsNil)
+	c.Assert(key, check.IsNil)
 }
 
 func (*Suite) TestPreAuthKeyDoesNotExist(c *check.C) {
-	p, err := h.checkKeyValidity("potatoKey")
+	key, err := app.checkKeyValidity("potatoKey")
 	c.Assert(err, check.Equals, errorAuthKeyNotFound)
-	c.Assert(p, check.IsNil)
+	c.Assert(key, check.IsNil)
 }
 
 func (*Suite) TestValidateKeyOk(c *check.C) {
-	n, err := h.CreateNamespace("test3")
+	namespace, err := app.CreateNamespace("test3")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, true, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, true, false, nil)
 	c.Assert(err, check.IsNil)
 
-	p, err := h.checkKeyValidity(pak.Key)
+	key, err := app.checkKeyValidity(pak.Key)
 	c.Assert(err, check.IsNil)
-	c.Assert(p.ID, check.Equals, pak.ID)
+	c.Assert(key.ID, check.Equals, pak.ID)
 }
 
 func (*Suite) TestAlreadyUsedKey(c *check.C) {
-	n, err := h.CreateNamespace("test4")
+	namespace, err := app.CreateNamespace("test4")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testest",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	p, err := h.checkKeyValidity(pak.Key)
+	key, err := app.checkKeyValidity(pak.Key)
 	c.Assert(err, check.Equals, errSingleUseAuthKeyHasBeenUsed)
-	c.Assert(p, check.IsNil)
+	c.Assert(key, check.IsNil)
 }
 
 func (*Suite) TestReusableBeingUsedKey(c *check.C) {
-	n, err := h.CreateNamespace("test5")
+	namespace, err := app.CreateNamespace("test5")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, true, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, true, false, nil)
 	c.Assert(err, check.IsNil)
 
-	m := Machine{
+	machine := Machine{
 		ID:             1,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testest",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	p, err := h.checkKeyValidity(pak.Key)
+	key, err := app.checkKeyValidity(pak.Key)
 	c.Assert(err, check.IsNil)
-	c.Assert(p.ID, check.Equals, pak.ID)
+	c.Assert(key.ID, check.Equals, pak.ID)
 }
 
 func (*Suite) TestNotReusableNotBeingUsedKey(c *check.C) {
-	n, err := h.CreateNamespace("test6")
+	namespace, err := app.CreateNamespace("test6")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	p, err := h.checkKeyValidity(pak.Key)
+	key, err := app.checkKeyValidity(pak.Key)
 	c.Assert(err, check.IsNil)
-	c.Assert(p.ID, check.Equals, pak.ID)
+	c.Assert(key.ID, check.Equals, pak.ID)
 }
 
 func (*Suite) TestEphemeralKey(c *check.C) {
-	n, err := h.CreateNamespace("test7")
+	namespace, err := app.CreateNamespace("test7")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, true, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, true, nil)
 	c.Assert(err, check.IsNil)
 
 	now := time.Now()
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testest",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		LastSeen:       &now,
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	_, err = h.checkKeyValidity(pak.Key)
+	_, err = app.checkKeyValidity(pak.Key)
 	// Ephemeral keys are by definition reusable
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine("test7", "testest")
+	_, err = app.GetMachine("test7", "testest")
 	c.Assert(err, check.IsNil)
 
-	h.expireEphemeralNodesWorker()
+	app.expireEphemeralNodesWorker()
 
 	// The machine record should have been deleted
-	_, err = h.GetMachine("test7", "testest")
+	_, err = app.GetMachine("test7", "testest")
 	c.Assert(err, check.NotNil)
 }
 
 func (*Suite) TestExpirePreauthKey(c *check.C) {
-	n, err := h.CreateNamespace("test3")
+	namespace, err := app.CreateNamespace("test3")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, true, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, true, false, nil)
 	c.Assert(err, check.IsNil)
 	c.Assert(pak.Expiration, check.IsNil)
 
-	err = h.ExpirePreAuthKey(pak)
+	err = app.ExpirePreAuthKey(pak)
 	c.Assert(err, check.IsNil)
 	c.Assert(pak.Expiration, check.NotNil)
 
-	p, err := h.checkKeyValidity(pak.Key)
+	key, err := app.checkKeyValidity(pak.Key)
 	c.Assert(err, check.Equals, errorAuthKeyExpired)
-	c.Assert(p, check.IsNil)
+	c.Assert(key, check.IsNil)
 }
 
 func (*Suite) TestNotReusableMarkedAsUsed(c *check.C) {
-	n, err := h.CreateNamespace("test6")
+	namespace, err := app.CreateNamespace("test6")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 	pak.Used = true
-	h.db.Save(&pak)
+	app.db.Save(&pak)
 
-	_, err = h.checkKeyValidity(pak.Key)
+	_, err = app.checkKeyValidity(pak.Key)
 	c.Assert(err, check.Equals, errSingleUseAuthKeyHasBeenUsed)
 }
diff --git a/routes_test.go b/routes_test.go
index a120eda..0742754 100644
--- a/routes_test.go
+++ b/routes_test.go
@@ -10,57 +10,57 @@ import (
 )
 
 func (s *Suite) TestGetRoutes(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine("test", "test_get_route_machine")
+	_, err = app.GetMachine("test", "test_get_route_machine")
 	c.Assert(err, check.NotNil)
 
 	route, err := netaddr.ParseIPPrefix("10.0.0.0/24")
 	c.Assert(err, check.IsNil)
 
-	hi := tailcfg.Hostinfo{
+	hostInfo := tailcfg.Hostinfo{
 		RoutableIPs: []netaddr.IPPrefix{route},
 	}
-	hostinfo, err := json.Marshal(hi)
+	hostinfo, err := json.Marshal(hostInfo)
 	c.Assert(err, check.IsNil)
 
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "test_get_route_machine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       datatypes.JSON(hostinfo),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	r, err := h.GetAdvertisedNodeRoutes("test", "test_get_route_machine")
+	advertisedRoutes, err := app.GetAdvertisedNodeRoutes("test", "test_get_route_machine")
 	c.Assert(err, check.IsNil)
-	c.Assert(len(*r), check.Equals, 1)
+	c.Assert(len(*advertisedRoutes), check.Equals, 1)
 
-	err = h.EnableNodeRoute("test", "test_get_route_machine", "192.168.0.0/24")
+	err = app.EnableNodeRoute("test", "test_get_route_machine", "192.168.0.0/24")
 	c.Assert(err, check.NotNil)
 
-	err = h.EnableNodeRoute("test", "test_get_route_machine", "10.0.0.0/24")
+	err = app.EnableNodeRoute("test", "test_get_route_machine", "10.0.0.0/24")
 	c.Assert(err, check.IsNil)
 }
 
 func (s *Suite) TestGetEnableRoutes(c *check.C) {
-	n, err := h.CreateNamespace("test")
+	namespace, err := app.CreateNamespace("test")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine("test", "test_enable_route_machine")
+	_, err = app.GetMachine("test", "test_enable_route_machine")
 	c.Assert(err, check.NotNil)
 
 	route, err := netaddr.ParseIPPrefix(
@@ -73,59 +73,65 @@ func (s *Suite) TestGetEnableRoutes(c *check.C) {
 	)
 	c.Assert(err, check.IsNil)
 
-	hi := tailcfg.Hostinfo{
+	hostInfo := tailcfg.Hostinfo{
 		RoutableIPs: []netaddr.IPPrefix{route, route2},
 	}
-	hostinfo, err := json.Marshal(hi)
+	hostinfo, err := json.Marshal(hostInfo)
 	c.Assert(err, check.IsNil)
 
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "test_enable_route_machine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 		HostInfo:       datatypes.JSON(hostinfo),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	availableRoutes, err := h.GetAdvertisedNodeRoutes(
+	availableRoutes, err := app.GetAdvertisedNodeRoutes(
 		"test",
 		"test_enable_route_machine",
 	)
 	c.Assert(err, check.IsNil)
 	c.Assert(len(*availableRoutes), check.Equals, 2)
 
-	enabledRoutes, err := h.GetEnabledNodeRoutes("test", "test_enable_route_machine")
+	noEnabledRoutes, err := app.GetEnabledNodeRoutes("test", "test_enable_route_machine")
 	c.Assert(err, check.IsNil)
-	c.Assert(len(enabledRoutes), check.Equals, 0)
+	c.Assert(len(noEnabledRoutes), check.Equals, 0)
 
-	err = h.EnableNodeRoute("test", "test_enable_route_machine", "192.168.0.0/24")
+	err = app.EnableNodeRoute("test", "test_enable_route_machine", "192.168.0.0/24")
 	c.Assert(err, check.NotNil)
 
-	err = h.EnableNodeRoute("test", "test_enable_route_machine", "10.0.0.0/24")
+	err = app.EnableNodeRoute("test", "test_enable_route_machine", "10.0.0.0/24")
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes1, err := h.GetEnabledNodeRoutes("test", "test_enable_route_machine")
+	enabledRoutes, err := app.GetEnabledNodeRoutes("test", "test_enable_route_machine")
 	c.Assert(err, check.IsNil)
-	c.Assert(len(enabledRoutes1), check.Equals, 1)
+	c.Assert(len(enabledRoutes), check.Equals, 1)
 
 	// Adding it twice will just let it pass through
-	err = h.EnableNodeRoute("test", "test_enable_route_machine", "10.0.0.0/24")
+	err = app.EnableNodeRoute("test", "test_enable_route_machine", "10.0.0.0/24")
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes2, err := h.GetEnabledNodeRoutes("test", "test_enable_route_machine")
+	enableRoutesAfterDoubleApply, err := app.GetEnabledNodeRoutes(
+		"test",
+		"test_enable_route_machine",
+	)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(enabledRoutes2), check.Equals, 1)
+	c.Assert(len(enableRoutesAfterDoubleApply), check.Equals, 1)
 
-	err = h.EnableNodeRoute("test", "test_enable_route_machine", "150.0.10.0/25")
+	err = app.EnableNodeRoute("test", "test_enable_route_machine", "150.0.10.0/25")
 	c.Assert(err, check.IsNil)
 
-	enabledRoutes3, err := h.GetEnabledNodeRoutes("test", "test_enable_route_machine")
+	enabledRoutesWithAdditionalRoute, err := app.GetEnabledNodeRoutes(
+		"test",
+		"test_enable_route_machine",
+	)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(enabledRoutes3), check.Equals, 2)
+	c.Assert(len(enabledRoutesWithAdditionalRoute), check.Equals, 2)
 }
diff --git a/sharing_test.go b/sharing_test.go
index 395b833..b180621 100644
--- a/sharing_test.go
+++ b/sharing_test.go
@@ -6,46 +6,46 @@ import (
 
 func CreateNodeNamespace(
 	c *check.C,
-	namespace, node, key, ip string,
+	namespaceName, node, key, ip string,
 ) (*Namespace, *Machine) {
-	n1, err := h.CreateNamespace(namespace)
+	namespace, err := app.CreateNamespace(namespaceName)
 	c.Assert(err, check.IsNil)
 
-	pak1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	pak1, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine(n1.Name, node)
+	_, err = app.GetMachine(namespace.Name, node)
 	c.Assert(err, check.NotNil)
 
-	m1 := &Machine{
+	machine := &Machine{
 		ID:             0,
 		MachineKey:     key,
 		NodeKey:        key,
 		DiscoKey:       key,
 		Name:           node,
-		NamespaceID:    n1.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      ip,
 		AuthKeyID:      uint(pak1.ID),
 	}
-	h.db.Save(m1)
+	app.db.Save(machine)
 
-	_, err = h.GetMachine(n1.Name, m1.Name)
+	_, err = app.GetMachine(namespace.Name, machine.Name)
 	c.Assert(err, check.IsNil)
 
-	return n1, m1
+	return namespace, machine
 }
 
 func (s *Suite) TestBasicSharedNodesInNamespace(c *check.C) {
-	n1, m1 := CreateNodeNamespace(
+	namespace1, machine1 := CreateNodeNamespace(
 		c,
 		"shared1",
 		"test_get_shared_nodes_1",
 		"686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		"100.64.0.1",
 	)
-	_, m2 := CreateNodeNamespace(
+	_, machine2 := CreateNodeNamespace(
 		c,
 		"shared2",
 		"test_get_shared_nodes_2",
@@ -53,21 +53,21 @@ func (s *Suite) TestBasicSharedNodesInNamespace(c *check.C) {
 		"100.64.0.2",
 	)
 
-	p1s, err := h.getPeers(m1)
+	peersOfMachine1BeforeShared, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 0)
+	c.Assert(len(peersOfMachine1BeforeShared), check.Equals, 0)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machine2, namespace1)
 	c.Assert(err, check.IsNil)
 
-	p1sAfter, err := h.getPeers(m1)
+	peersOfMachine1AfterShared, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1sAfter), check.Equals, 1)
-	c.Assert(p1sAfter[0].ID, check.Equals, m2.ID)
+	c.Assert(len(peersOfMachine1AfterShared), check.Equals, 1)
+	c.Assert(peersOfMachine1AfterShared[0].ID, check.Equals, machine2.ID)
 }
 
 func (s *Suite) TestSameNamespace(c *check.C) {
-	n1, m1 := CreateNodeNamespace(
+	namespace1, machine1 := CreateNodeNamespace(
 		c,
 		"shared1",
 		"test_get_shared_nodes_1",
@@ -75,23 +75,23 @@ func (s *Suite) TestSameNamespace(c *check.C) {
 		"100.64.0.1",
 	)
 
-	p1s, err := h.getPeers(m1)
+	peersOfMachine1BeforeShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 0)
+	c.Assert(len(peersOfMachine1BeforeShare), check.Equals, 0)
 
-	err = h.AddSharedMachineToNamespace(m1, n1)
+	err = app.AddSharedMachineToNamespace(machine1, namespace1)
 	c.Assert(err, check.Equals, errorSameNamespace)
 }
 
 func (s *Suite) TestUnshare(c *check.C) {
-	n1, m1 := CreateNodeNamespace(
+	namespace1, machine1 := CreateNodeNamespace(
 		c,
 		"shared1",
 		"test_unshare_1",
 		"686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		"100.64.0.1",
 	)
-	_, m2 := CreateNodeNamespace(
+	_, machine2 := CreateNodeNamespace(
 		c,
 		"shared2",
 		"test_unshare_2",
@@ -99,40 +99,40 @@ func (s *Suite) TestUnshare(c *check.C) {
 		"100.64.0.2",
 	)
 
-	p1s, err := h.getPeers(m1)
+	peersOfMachine1BeforeShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 0)
+	c.Assert(len(peersOfMachine1BeforeShare), check.Equals, 0)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machine2, namespace1)
 	c.Assert(err, check.IsNil)
 
-	p1s, err = h.getShared(m1)
+	peersOfMachine1BeforeShare, err = app.getShared(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 1)
+	c.Assert(len(peersOfMachine1BeforeShare), check.Equals, 1)
 
-	err = h.RemoveSharedMachineFromNamespace(m2, n1)
+	err = app.RemoveSharedMachineFromNamespace(machine2, namespace1)
 	c.Assert(err, check.IsNil)
 
-	p1s, err = h.getShared(m1)
+	peersOfMachine1BeforeShare, err = app.getShared(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 0)
+	c.Assert(len(peersOfMachine1BeforeShare), check.Equals, 0)
 
-	err = h.RemoveSharedMachineFromNamespace(m2, n1)
+	err = app.RemoveSharedMachineFromNamespace(machine2, namespace1)
 	c.Assert(err, check.Equals, errorMachineNotShared)
 
-	err = h.RemoveSharedMachineFromNamespace(m1, n1)
+	err = app.RemoveSharedMachineFromNamespace(machine1, namespace1)
 	c.Assert(err, check.Equals, errorMachineNotShared)
 }
 
 func (s *Suite) TestAlreadyShared(c *check.C) {
-	n1, m1 := CreateNodeNamespace(
+	namespace1, machine1 := CreateNodeNamespace(
 		c,
 		"shared1",
 		"test_get_shared_nodes_1",
 		"686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		"100.64.0.1",
 	)
-	_, m2 := CreateNodeNamespace(
+	_, machine2 := CreateNodeNamespace(
 		c,
 		"shared2",
 		"test_get_shared_nodes_2",
@@ -140,25 +140,25 @@ func (s *Suite) TestAlreadyShared(c *check.C) {
 		"100.64.0.2",
 	)
 
-	p1s, err := h.getPeers(m1)
+	peersOfMachine1BeforeShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 0)
+	c.Assert(len(peersOfMachine1BeforeShare), check.Equals, 0)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machine2, namespace1)
 	c.Assert(err, check.IsNil)
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machine2, namespace1)
 	c.Assert(err, check.Equals, errorMachineAlreadyShared)
 }
 
 func (s *Suite) TestDoNotIncludeRoutesOnShared(c *check.C) {
-	n1, m1 := CreateNodeNamespace(
+	namespace1, machine1 := CreateNodeNamespace(
 		c,
 		"shared1",
 		"test_get_shared_nodes_1",
 		"686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		"100.64.0.1",
 	)
-	_, m2 := CreateNodeNamespace(
+	_, machine2 := CreateNodeNamespace(
 		c,
 		"shared2",
 		"test_get_shared_nodes_2",
@@ -166,35 +166,35 @@ func (s *Suite) TestDoNotIncludeRoutesOnShared(c *check.C) {
 		"100.64.0.2",
 	)
 
-	p1s, err := h.getPeers(m1)
+	peersOfMachine1BeforeShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 0)
+	c.Assert(len(peersOfMachine1BeforeShare), check.Equals, 0)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machine2, namespace1)
 	c.Assert(err, check.IsNil)
 
-	p1sAfter, err := h.getPeers(m1)
+	peersOfMachine1AfterShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1sAfter), check.Equals, 1)
-	c.Assert(p1sAfter[0].Name, check.Equals, "test_get_shared_nodes_2")
+	c.Assert(len(peersOfMachine1AfterShare), check.Equals, 1)
+	c.Assert(peersOfMachine1AfterShare[0].Name, check.Equals, "test_get_shared_nodes_2")
 }
 
 func (s *Suite) TestComplexSharingAcrossNamespaces(c *check.C) {
-	n1, m1 := CreateNodeNamespace(
+	namespace1, machine1 := CreateNodeNamespace(
 		c,
 		"shared1",
 		"test_get_shared_nodes_1",
 		"686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		"100.64.0.1",
 	)
-	_, m2 := CreateNodeNamespace(
+	_, machine2 := CreateNodeNamespace(
 		c,
 		"shared2",
 		"test_get_shared_nodes_2",
 		"dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		"100.64.0.2",
 	)
-	_, m3 := CreateNodeNamespace(
+	_, machine3 := CreateNodeNamespace(
 		c,
 		"shared3",
 		"test_get_shared_nodes_3",
@@ -202,80 +202,80 @@ func (s *Suite) TestComplexSharingAcrossNamespaces(c *check.C) {
 		"100.64.0.3",
 	)
 
-	pak4, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	pak4, err := app.CreatePreAuthKey(namespace1.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	m4 := &Machine{
+	machine4 := &Machine{
 		ID:             4,
 		MachineKey:     "4c3e07c3ecd40e9c945bb6797557c451850691c0409740578325e17009dd298f",
 		NodeKey:        "4c3e07c3ecd40e9c945bb6797557c451850691c0409740578325e17009dd298f",
 		DiscoKey:       "4c3e07c3ecd40e9c945bb6797557c451850691c0409740578325e17009dd298f",
 		Name:           "test_get_shared_nodes_4",
-		NamespaceID:    n1.ID,
+		NamespaceID:    namespace1.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.4",
 		AuthKeyID:      uint(pak4.ID),
 	}
-	h.db.Save(m4)
+	app.db.Save(machine4)
 
-	_, err = h.GetMachine(n1.Name, m4.Name)
+	_, err = app.GetMachine(namespace1.Name, machine4.Name)
 	c.Assert(err, check.IsNil)
 
-	p1s, err := h.getPeers(m1)
+	peersOfMachine1BeforeShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 1) // node1 can see node4
-	c.Assert(p1s[0].Name, check.Equals, m4.Name)
+	c.Assert(len(peersOfMachine1BeforeShare), check.Equals, 1) // node1 can see node4
+	c.Assert(peersOfMachine1BeforeShare[0].Name, check.Equals, machine4.Name)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machine2, namespace1)
 	c.Assert(err, check.IsNil)
 
-	p1sAfter, err := h.getPeers(m1)
+	peersOfMachine1AfterShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
 	c.Assert(
-		len(p1sAfter),
+		len(peersOfMachine1AfterShare),
 		check.Equals,
 		2,
 	) // node1 can see node2 (shared) and node4 (same namespace)
-	c.Assert(p1sAfter[0].Name, check.Equals, m2.Name)
-	c.Assert(p1sAfter[1].Name, check.Equals, m4.Name)
+	c.Assert(peersOfMachine1AfterShare[0].Name, check.Equals, machine2.Name)
+	c.Assert(peersOfMachine1AfterShare[1].Name, check.Equals, machine4.Name)
 
-	node1shared, err := h.getShared(m1)
+	sharedOfMachine1, err := app.getShared(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(node1shared), check.Equals, 1) // node1 can see node2 as shared
-	c.Assert(node1shared[0].Name, check.Equals, m2.Name)
+	c.Assert(len(sharedOfMachine1), check.Equals, 1) // node1 can see node2 as shared
+	c.Assert(sharedOfMachine1[0].Name, check.Equals, machine2.Name)
 
-	pAlone, err := h.getPeers(m3)
+	peersOfMachine3, err := app.getPeers(machine3)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(pAlone), check.Equals, 0) // node3 is alone
+	c.Assert(len(peersOfMachine3), check.Equals, 0) // node3 is alone
 
-	pSharedTo, err := h.getPeers(m2)
+	peersOfMachine2, err := app.getPeers(machine2)
 	c.Assert(err, check.IsNil)
 	c.Assert(
-		len(pSharedTo),
+		len(peersOfMachine2),
 		check.Equals,
 		2,
 	) // node2 should see node1 (sharedTo) and node4 (sharedTo), as is shared in namespace1
-	c.Assert(pSharedTo[0].Name, check.Equals, m1.Name)
-	c.Assert(pSharedTo[1].Name, check.Equals, m4.Name)
+	c.Assert(peersOfMachine2[0].Name, check.Equals, machine1.Name)
+	c.Assert(peersOfMachine2[1].Name, check.Equals, machine4.Name)
 }
 
 func (s *Suite) TestDeleteSharedMachine(c *check.C) {
-	n1, m1 := CreateNodeNamespace(
+	namespace1, machine1 := CreateNodeNamespace(
 		c,
 		"shared1",
 		"test_get_shared_nodes_1",
 		"686824e749f3b7f2a5927ee6c1e422aee5292592d9179a271ed7b3e659b44a66",
 		"100.64.0.1",
 	)
-	_, m2 := CreateNodeNamespace(
+	_, machine2 := CreateNodeNamespace(
 		c,
 		"shared2",
 		"test_get_shared_nodes_2",
 		"dec46ef9dc45c7d2f03bfcd5a640d9e24e3cc68ce3d9da223867c9bc6d5e9863",
 		"100.64.0.2",
 	)
-	_, m3 := CreateNodeNamespace(
+	_, machine3 := CreateNodeNamespace(
 		c,
 		"shared3",
 		"test_get_shared_nodes_3",
@@ -283,56 +283,56 @@ func (s *Suite) TestDeleteSharedMachine(c *check.C) {
 		"100.64.0.3",
 	)
 
-	pak4n1, err := h.CreatePreAuthKey(n1.Name, false, false, nil)
+	pak4n1, err := app.CreatePreAuthKey(namespace1.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
-	m4 := &Machine{
+	machine4 := &Machine{
 		ID:             4,
 		MachineKey:     "4c3e07c3ecd40e9c945bb6797557c451850691c0409740578325e17009dd298f",
 		NodeKey:        "4c3e07c3ecd40e9c945bb6797557c451850691c0409740578325e17009dd298f",
 		DiscoKey:       "4c3e07c3ecd40e9c945bb6797557c451850691c0409740578325e17009dd298f",
 		Name:           "test_get_shared_nodes_4",
-		NamespaceID:    n1.ID,
+		NamespaceID:    namespace1.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		IPAddress:      "100.64.0.4",
 		AuthKeyID:      uint(pak4n1.ID),
 	}
-	h.db.Save(m4)
+	app.db.Save(machine4)
 
-	_, err = h.GetMachine(n1.Name, m4.Name)
+	_, err = app.GetMachine(namespace1.Name, machine4.Name)
 	c.Assert(err, check.IsNil)
 
-	p1s, err := h.getPeers(m1)
+	peersOfMachine1BeforeShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1s), check.Equals, 1) // nodes 1 and 4
-	c.Assert(p1s[0].Name, check.Equals, m4.Name)
+	c.Assert(len(peersOfMachine1BeforeShare), check.Equals, 1) // nodes 1 and 4
+	c.Assert(peersOfMachine1BeforeShare[0].Name, check.Equals, machine4.Name)
 
-	err = h.AddSharedMachineToNamespace(m2, n1)
+	err = app.AddSharedMachineToNamespace(machine2, namespace1)
 	c.Assert(err, check.IsNil)
 
-	p1sAfter, err := h.getPeers(m1)
+	peersOfMachine1AfterShare, err := app.getPeers(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(p1sAfter), check.Equals, 2) // nodes 1, 2, 4
-	c.Assert(p1sAfter[0].Name, check.Equals, m2.Name)
-	c.Assert(p1sAfter[1].Name, check.Equals, m4.Name)
+	c.Assert(len(peersOfMachine1AfterShare), check.Equals, 2) // nodes 1, 2, 4
+	c.Assert(peersOfMachine1AfterShare[0].Name, check.Equals, machine2.Name)
+	c.Assert(peersOfMachine1AfterShare[1].Name, check.Equals, machine4.Name)
 
-	node1shared, err := h.getShared(m1)
+	sharedOfMachine1, err := app.getShared(machine1)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(node1shared), check.Equals, 1) // nodes 1, 2, 4
-	c.Assert(node1shared[0].Name, check.Equals, m2.Name)
+	c.Assert(len(sharedOfMachine1), check.Equals, 1) // nodes 1, 2, 4
+	c.Assert(sharedOfMachine1[0].Name, check.Equals, machine2.Name)
 
-	pAlone, err := h.getPeers(m3)
+	peersOfMachine3, err := app.getPeers(machine3)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(pAlone), check.Equals, 0) // node 3 is alone
+	c.Assert(len(peersOfMachine3), check.Equals, 0) // node 3 is alone
 
-	sharedMachines, err := h.ListSharedMachinesInNamespace(n1.Name)
+	sharedMachinesInNamespace1, err := app.ListSharedMachinesInNamespace(namespace1.Name)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(sharedMachines), check.Equals, 1)
+	c.Assert(len(sharedMachinesInNamespace1), check.Equals, 1)
 
-	err = h.DeleteMachine(m2)
+	err = app.DeleteMachine(machine2)
 	c.Assert(err, check.IsNil)
 
-	sharedMachines, err = h.ListSharedMachinesInNamespace(n1.Name)
+	sharedMachinesInNamespace1, err = app.ListSharedMachinesInNamespace(namespace1.Name)
 	c.Assert(err, check.IsNil)
-	c.Assert(len(sharedMachines), check.Equals, 0)
+	c.Assert(len(sharedMachinesInNamespace1), check.Equals, 0)
 }
diff --git a/utils_test.go b/utils_test.go
index f50cd11..dcda613 100644
--- a/utils_test.go
+++ b/utils_test.go
@@ -6,7 +6,7 @@ import (
 )
 
 func (s *Suite) TestGetAvailableIp(c *check.C) {
-	ip, err := h.getAvailableIP()
+	ip, err := app.getAvailableIP()
 
 	c.Assert(err, check.IsNil)
 
@@ -16,33 +16,33 @@ func (s *Suite) TestGetAvailableIp(c *check.C) {
 }
 
 func (s *Suite) TestGetUsedIps(c *check.C) {
-	ip, err := h.getAvailableIP()
+	ip, err := app.getAvailableIP()
 	c.Assert(err, check.IsNil)
 
-	n, err := h.CreateNamespace("test_ip")
+	namespace, err := app.CreateNamespace("test_ip")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine("test", "testmachine")
+	_, err = app.GetMachine("test", "testmachine")
 	c.Assert(err, check.NotNil)
 
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 		IPAddress:      ip.String(),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	ips, err := h.getUsedIPs()
+	ips, err := app.getUsedIPs()
 
 	c.Assert(err, check.IsNil)
 
@@ -50,42 +50,42 @@ func (s *Suite) TestGetUsedIps(c *check.C) {
 
 	c.Assert(ips[0], check.Equals, expected)
 
-	m1, err := h.GetMachineByID(0)
+	machine1, err := app.GetMachineByID(0)
 	c.Assert(err, check.IsNil)
 
-	c.Assert(m1.IPAddress, check.Equals, expected.String())
+	c.Assert(machine1.IPAddress, check.Equals, expected.String())
 }
 
 func (s *Suite) TestGetMultiIp(c *check.C) {
-	n, err := h.CreateNamespace("test-ip-multi")
+	namespace, err := app.CreateNamespace("test-ip-multi")
 	c.Assert(err, check.IsNil)
 
-	for i := 1; i <= 350; i++ {
-		ip, err := h.getAvailableIP()
+	for index := 1; index <= 350; index++ {
+		ip, err := app.getAvailableIP()
 		c.Assert(err, check.IsNil)
 
-		pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+		pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 		c.Assert(err, check.IsNil)
 
-		_, err = h.GetMachine("test", "testmachine")
+		_, err = app.GetMachine("test", "testmachine")
 		c.Assert(err, check.NotNil)
 
-		m := Machine{
-			ID:             uint64(i),
+		machine := Machine{
+			ID:             uint64(index),
 			MachineKey:     "foo",
 			NodeKey:        "bar",
 			DiscoKey:       "faa",
 			Name:           "testmachine",
-			NamespaceID:    n.ID,
+			NamespaceID:    namespace.ID,
 			Registered:     true,
 			RegisterMethod: "authKey",
 			AuthKeyID:      uint(pak.ID),
 			IPAddress:      ip.String(),
 		}
-		h.db.Save(&m)
+		app.db.Save(&machine)
 	}
 
-	ips, err := h.getUsedIPs()
+	ips, err := app.getUsedIPs()
 
 	c.Assert(err, check.IsNil)
 
@@ -96,59 +96,67 @@ func (s *Suite) TestGetMultiIp(c *check.C) {
 	c.Assert(ips[300], check.Equals, netaddr.MustParseIP("10.27.1.47"))
 
 	// Check that we can read back the IPs
-	m1, err := h.GetMachineByID(1)
+	machine1, err := app.GetMachineByID(1)
 	c.Assert(err, check.IsNil)
-	c.Assert(m1.IPAddress, check.Equals, netaddr.MustParseIP("10.27.0.1").String())
+	c.Assert(
+		machine1.IPAddress,
+		check.Equals,
+		netaddr.MustParseIP("10.27.0.1").String(),
+	)
 
-	m50, err := h.GetMachineByID(50)
+	machine50, err := app.GetMachineByID(50)
 	c.Assert(err, check.IsNil)
-	c.Assert(m50.IPAddress, check.Equals, netaddr.MustParseIP("10.27.0.50").String())
+	c.Assert(
+		machine50.IPAddress,
+		check.Equals,
+		netaddr.MustParseIP("10.27.0.50").String(),
+	)
 
 	expectedNextIP := netaddr.MustParseIP("10.27.1.97")
-	nextIP, err := h.getAvailableIP()
+	nextIP, err := app.getAvailableIP()
 	c.Assert(err, check.IsNil)
 
 	c.Assert(nextIP.String(), check.Equals, expectedNextIP.String())
 
 	// If we call get Available again, we should receive
 	// the same IP, as it has not been reserved.
-	nextIP2, err := h.getAvailableIP()
+	nextIP2, err := app.getAvailableIP()
 	c.Assert(err, check.IsNil)
 
 	c.Assert(nextIP2.String(), check.Equals, expectedNextIP.String())
 }
 
 func (s *Suite) TestGetAvailableIpMachineWithoutIP(c *check.C) {
-	ip, err := h.getAvailableIP()
+	ip, err := app.getAvailableIP()
 	c.Assert(err, check.IsNil)
 
 	expected := netaddr.MustParseIP("10.27.0.1")
 
 	c.Assert(ip.String(), check.Equals, expected.String())
 
-	n, err := h.CreateNamespace("test_ip")
+	namespace, err := app.CreateNamespace("test_ip")
 	c.Assert(err, check.IsNil)
 
-	pak, err := h.CreatePreAuthKey(n.Name, false, false, nil)
+	pak, err := app.CreatePreAuthKey(namespace.Name, false, false, nil)
 	c.Assert(err, check.IsNil)
 
-	_, err = h.GetMachine("test", "testmachine")
+	_, err = app.GetMachine("test", "testmachine")
 	c.Assert(err, check.NotNil)
 
-	m := Machine{
+	machine := Machine{
 		ID:             0,
 		MachineKey:     "foo",
 		NodeKey:        "bar",
 		DiscoKey:       "faa",
 		Name:           "testmachine",
-		NamespaceID:    n.ID,
+		NamespaceID:    namespace.ID,
 		Registered:     true,
 		RegisterMethod: "authKey",
 		AuthKeyID:      uint(pak.ID),
 	}
-	h.db.Save(&m)
+	app.db.Save(&machine)
 
-	ip2, err := h.getAvailableIP()
+	ip2, err := app.getAvailableIP()
 	c.Assert(err, check.IsNil)
 
 	c.Assert(ip2.String(), check.Equals, expected.String())