From d846f4952a6b5888ad39b648b7f041f430041e95 Mon Sep 17 00:00:00 2001
From: phm07 <22707808+phm07@users.noreply.github.com>
Date: Fri, 31 Jan 2025 16:59:54 +0100
Subject: [PATCH] refactor: split up label command into separate
 Fetch/GetLabels/GetIDOrName (#967)

This change is intended for an upcoming resource that has labels but
doesn't have numeric IDs.
---
 internal/cmd/base/labels.go                | 38 +++++++++++++---------
 internal/cmd/certificate/labels.go         | 21 ++++++++----
 internal/cmd/certificate/labels_test.go    | 16 +++++----
 internal/cmd/firewall/labels.go            | 21 ++++++++----
 internal/cmd/firewall/labels_test.go       | 16 +++++----
 internal/cmd/floatingip/labels.go          | 21 ++++++++----
 internal/cmd/floatingip/labels_test.go     | 16 +++++----
 internal/cmd/image/labels.go               | 22 ++++++++-----
 internal/cmd/image/labels_test.go          | 16 +++++----
 internal/cmd/loadbalancer/labels.go        | 21 ++++++++----
 internal/cmd/loadbalancer/labels_test.go   | 16 +++++----
 internal/cmd/network/labels.go             | 21 ++++++++----
 internal/cmd/network/labels_test.go        | 16 +++++----
 internal/cmd/placementgroup/labels.go      | 21 ++++++++----
 internal/cmd/placementgroup/labels_test.go | 16 +++++----
 internal/cmd/primaryip/labels.go           | 21 ++++++++----
 internal/cmd/primaryip/labels_test.go      | 16 +++++----
 internal/cmd/server/labels.go              | 21 ++++++++----
 internal/cmd/server/labels_test.go         | 36 +++++++++++---------
 internal/cmd/sshkey/labels.go              | 21 ++++++++----
 internal/cmd/sshkey/labels_test.go         | 16 +++++----
 internal/cmd/volume/labels.go              | 21 ++++++++----
 internal/cmd/volume/labels_test.go         | 22 ++++++++-----
 23 files changed, 290 insertions(+), 182 deletions(-)

diff --git a/internal/cmd/base/labels.go b/internal/cmd/base/labels.go
index 5feadeff..78094e54 100644
--- a/internal/cmd/base/labels.go
+++ b/internal/cmd/base/labels.go
@@ -14,18 +14,20 @@ import (
 )
 
 // LabelCmds allows defining commands for adding labels to resources.
-type LabelCmds struct {
+type LabelCmds[T any] struct {
 	ResourceNameSingular   string
 	ShortDescriptionAdd    string
 	ShortDescriptionRemove string
 	NameSuggestions        func(client hcapi2.Client) func() []string
 	LabelKeySuggestions    func(client hcapi2.Client) func(idOrName string) []string
-	FetchLabels            func(s state.State, idOrName string) (map[string]string, int64, error)
-	SetLabels              func(s state.State, id int64, labels map[string]string) error
+	Fetch                  func(s state.State, idOrName string) (T, error)
+	SetLabels              func(s state.State, resource T, labels map[string]string) error
+	GetLabels              func(resource T) map[string]string
+	GetIDOrName            func(resource T) string
 }
 
 // AddCobraCommand creates a command that can be registered with cobra.
-func (lc *LabelCmds) AddCobraCommand(s state.State) *cobra.Command {
+func (lc *LabelCmds[T]) AddCobraCommand(s state.State) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:                   fmt.Sprintf("add-label [--overwrite] <%s> <label>...", util.ToKebabCase(lc.ResourceNameSingular)),
 		Short:                 lc.ShortDescriptionAdd,
@@ -43,15 +45,17 @@ func (lc *LabelCmds) AddCobraCommand(s state.State) *cobra.Command {
 }
 
 // RunAdd executes an add label command
-func (lc *LabelCmds) RunAdd(s state.State, cmd *cobra.Command, args []string) error {
+func (lc *LabelCmds[T]) RunAdd(s state.State, cmd *cobra.Command, args []string) error {
 	overwrite, _ := cmd.Flags().GetBool("overwrite")
 	idOrName := args[0]
 
-	labels, id, err := lc.FetchLabels(s, idOrName)
+	resource, err := lc.Fetch(s, idOrName)
 	if err != nil {
 		return err
 	}
 
+	labels, idOrName := lc.GetLabels(resource), lc.GetIDOrName(resource)
+
 	if labels == nil {
 		labels = map[string]string{}
 	}
@@ -62,17 +66,17 @@ func (lc *LabelCmds) RunAdd(s state.State, cmd *cobra.Command, args []string) er
 		keys = append(keys, key)
 
 		if _, ok := labels[key]; ok && !overwrite {
-			return fmt.Errorf("label %s on %s %d already exists", key, lc.ResourceNameSingular, id)
+			return fmt.Errorf("label %s on %s %s already exists", key, lc.ResourceNameSingular, idOrName)
 		}
 
 		labels[key] = val
 	}
 
-	if err := lc.SetLabels(s, id, labels); err != nil {
+	if err := lc.SetLabels(s, resource, labels); err != nil {
 		return err
 	}
 
-	cmd.Printf("Label(s) %s added to %s %d\n", strings.Join(keys, ", "), lc.ResourceNameSingular, id)
+	cmd.Printf("Label(s) %s added to %s %s\n", strings.Join(keys, ", "), lc.ResourceNameSingular, idOrName)
 	return nil
 }
 
@@ -87,7 +91,7 @@ func validateAddLabel(_ *cobra.Command, args []string) error {
 }
 
 // RemoveCobraCommand creates a command that can be registered with cobra.
-func (lc *LabelCmds) RemoveCobraCommand(s state.State) *cobra.Command {
+func (lc *LabelCmds[T]) RemoveCobraCommand(s state.State) *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   fmt.Sprintf("remove-label <%s> (--all | <label>...)", util.ToKebabCase(lc.ResourceNameSingular)),
 		Short: lc.ShortDescriptionRemove,
@@ -113,34 +117,36 @@ func (lc *LabelCmds) RemoveCobraCommand(s state.State) *cobra.Command {
 }
 
 // RunRemove executes a remove label command
-func (lc *LabelCmds) RunRemove(s state.State, cmd *cobra.Command, args []string) error {
+func (lc *LabelCmds[T]) RunRemove(s state.State, cmd *cobra.Command, args []string) error {
 	all, _ := cmd.Flags().GetBool("all")
 	idOrName := args[0]
 
-	labels, id, err := lc.FetchLabels(s, idOrName)
+	resource, err := lc.Fetch(s, idOrName)
 	if err != nil {
 		return err
 	}
 
+	labels, idOrName := lc.GetLabels(resource), lc.GetIDOrName(resource)
+
 	if all {
 		labels = make(map[string]string)
 	} else {
 		for _, key := range args[1:] {
 			if _, ok := labels[key]; !ok {
-				return fmt.Errorf("label %s on %s %d does not exist", key, lc.ResourceNameSingular, id)
+				return fmt.Errorf("label %s on %s %s does not exist", key, lc.ResourceNameSingular, idOrName)
 			}
 			delete(labels, key)
 		}
 	}
 
-	if err := lc.SetLabels(s, id, labels); err != nil {
+	if err := lc.SetLabels(s, resource, labels); err != nil {
 		return err
 	}
 
 	if all {
-		cmd.Printf("All labels removed from %s %d\n", lc.ResourceNameSingular, id)
+		cmd.Printf("All labels removed from %s %s\n", lc.ResourceNameSingular, idOrName)
 	} else {
-		cmd.Printf("Label(s) %s removed from %s %d\n", strings.Join(args[1:], ", "), lc.ResourceNameSingular, id)
+		cmd.Printf("Label(s) %s removed from %s %s\n", strings.Join(args[1:], ", "), lc.ResourceNameSingular, idOrName)
 	}
 
 	return nil
diff --git a/internal/cmd/certificate/labels.go b/internal/cmd/certificate/labels.go
index 60d1305d..5f396e2b 100644
--- a/internal/cmd/certificate/labels.go
+++ b/internal/cmd/certificate/labels.go
@@ -2,6 +2,7 @@ package certificate
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.Certificate]{
 	ResourceNameSingular:   "certificate",
 	ShortDescriptionAdd:    "Add a label to an certificate",
 	ShortDescriptionRemove: "Remove a label from an certificate",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.Certificate().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.Certificate().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.Certificate, error) {
 		certificate, _, err := s.Client().Certificate().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if certificate == nil {
-			return nil, 0, fmt.Errorf("certificate not found: %s", idOrName)
+			return nil, fmt.Errorf("certificate not found: %s", idOrName)
 		}
-		return certificate.Labels, certificate.ID, nil
+		return certificate, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, cert *hcloud.Certificate, labels map[string]string) error {
 		opts := hcloud.CertificateUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().Certificate().Update(s, &hcloud.Certificate{ID: id}, opts)
+		_, _, err := s.Client().Certificate().Update(s, cert, opts)
 		return err
 	},
+	GetLabels: func(cert *hcloud.Certificate) map[string]string {
+		return cert.Labels
+	},
+	GetIDOrName: func(cert *hcloud.Certificate) string {
+		return strconv.FormatInt(cert.ID, 10)
+	},
 }
diff --git a/internal/cmd/certificate/labels_test.go b/internal/cmd/certificate/labels_test.go
index 08c63c08..bd456864 100644
--- a/internal/cmd/certificate/labels_test.go
+++ b/internal/cmd/certificate/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := certificate.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	cert := &hcloud.Certificate{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.CertificateClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.Certificate{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(cert, nil, nil)
 	fx.Client.CertificateClient.EXPECT().
-		Update(gomock.Any(), &hcloud.Certificate{ID: 123}, hcloud.CertificateUpdateOpts{
+		Update(gomock.Any(), cert, hcloud.CertificateUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
diff --git a/internal/cmd/firewall/labels.go b/internal/cmd/firewall/labels.go
index 4c1f9883..83092f4f 100644
--- a/internal/cmd/firewall/labels.go
+++ b/internal/cmd/firewall/labels.go
@@ -2,6 +2,7 @@ package firewall
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.Firewall]{
 	ResourceNameSingular:   "firewall",
 	ShortDescriptionAdd:    "Add a label to an firewall",
 	ShortDescriptionRemove: "Remove a label from an firewall",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.Firewall().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.Firewall().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.Firewall, error) {
 		firewall, _, err := s.Client().Firewall().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if firewall == nil {
-			return nil, 0, fmt.Errorf("firewall not found: %s", idOrName)
+			return nil, fmt.Errorf("firewall not found: %s", idOrName)
 		}
-		return firewall.Labels, firewall.ID, nil
+		return firewall, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, firewall *hcloud.Firewall, labels map[string]string) error {
 		opts := hcloud.FirewallUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().Firewall().Update(s, &hcloud.Firewall{ID: id}, opts)
+		_, _, err := s.Client().Firewall().Update(s, firewall, opts)
 		return err
 	},
+	GetLabels: func(firewall *hcloud.Firewall) map[string]string {
+		return firewall.Labels
+	},
+	GetIDOrName: func(firewall *hcloud.Firewall) string {
+		return strconv.FormatInt(firewall.ID, 10)
+	},
 }
diff --git a/internal/cmd/firewall/labels_test.go b/internal/cmd/firewall/labels_test.go
index e07e1b0b..e5b68e24 100644
--- a/internal/cmd/firewall/labels_test.go
+++ b/internal/cmd/firewall/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := firewall.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	fw := &hcloud.Firewall{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.FirewallClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.Firewall{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(fw, nil, nil)
 	fx.Client.FirewallClient.EXPECT().
-		Update(gomock.Any(), &hcloud.Firewall{ID: 123}, hcloud.FirewallUpdateOpts{
+		Update(gomock.Any(), fw, hcloud.FirewallUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
diff --git a/internal/cmd/floatingip/labels.go b/internal/cmd/floatingip/labels.go
index a63a7598..8ac01bee 100644
--- a/internal/cmd/floatingip/labels.go
+++ b/internal/cmd/floatingip/labels.go
@@ -2,6 +2,7 @@ package floatingip
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.FloatingIP]{
 	ResourceNameSingular:   "Floating IP",
 	ShortDescriptionAdd:    "Add a label to an Floating IP",
 	ShortDescriptionRemove: "Remove a label from an Floating IP",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.FloatingIP().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.FloatingIP().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.FloatingIP, error) {
 		floatingIP, _, err := s.Client().FloatingIP().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if floatingIP == nil {
-			return nil, 0, fmt.Errorf("floating IP not found: %s", idOrName)
+			return nil, fmt.Errorf("floating IP not found: %s", idOrName)
 		}
-		return floatingIP.Labels, floatingIP.ID, nil
+		return floatingIP, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, floatingIP *hcloud.FloatingIP, labels map[string]string) error {
 		opts := hcloud.FloatingIPUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().FloatingIP().Update(s, &hcloud.FloatingIP{ID: id}, opts)
+		_, _, err := s.Client().FloatingIP().Update(s, floatingIP, opts)
 		return err
 	},
+	GetLabels: func(floatingIP *hcloud.FloatingIP) map[string]string {
+		return floatingIP.Labels
+	},
+	GetIDOrName: func(floatingIP *hcloud.FloatingIP) string {
+		return strconv.FormatInt(floatingIP.ID, 10)
+	},
 }
diff --git a/internal/cmd/floatingip/labels_test.go b/internal/cmd/floatingip/labels_test.go
index abda87d9..1015d951 100644
--- a/internal/cmd/floatingip/labels_test.go
+++ b/internal/cmd/floatingip/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := floatingip.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	floatingIP := &hcloud.FloatingIP{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.FloatingIPClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.FloatingIP{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(floatingIP, nil, nil)
 	fx.Client.FloatingIPClient.EXPECT().
-		Update(gomock.Any(), &hcloud.FloatingIP{ID: 123}, hcloud.FloatingIPUpdateOpts{
+		Update(gomock.Any(), floatingIP, hcloud.FloatingIPUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
diff --git a/internal/cmd/image/labels.go b/internal/cmd/image/labels.go
index 1c4f4640..6c41084c 100644
--- a/internal/cmd/image/labels.go
+++ b/internal/cmd/image/labels.go
@@ -10,31 +10,37 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.Image]{
 	ResourceNameSingular:   "image",
 	ShortDescriptionAdd:    "Add a label to an image",
 	ShortDescriptionRemove: "Remove a label from an image",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.Image().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.Image().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.Image, error) {
 		id, err := strconv.ParseInt(idOrName, 10, 64)
 		if err != nil {
-			return nil, 0, fmt.Errorf("invalid snapshot or backup ID %q", idOrName)
+			return nil, fmt.Errorf("invalid snapshot or backup ID %q", idOrName)
 		}
 		image, _, err := s.Client().Image().GetByID(s, id)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if image == nil {
-			return nil, 0, fmt.Errorf("image not found: %s", idOrName)
+			return nil, fmt.Errorf("image not found: %s", idOrName)
 		}
-		return image.Labels, image.ID, nil
+		return image, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, image *hcloud.Image, labels map[string]string) error {
 		opts := hcloud.ImageUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().Image().Update(s, &hcloud.Image{ID: id}, opts)
+		_, _, err := s.Client().Image().Update(s, image, opts)
 		return err
 	},
+	GetLabels: func(image *hcloud.Image) map[string]string {
+		return image.Labels
+	},
+	GetIDOrName: func(image *hcloud.Image) string {
+		return strconv.FormatInt(image.ID, 10)
+	},
 }
diff --git a/internal/cmd/image/labels_test.go b/internal/cmd/image/labels_test.go
index 33f5a065..322e07b3 100644
--- a/internal/cmd/image/labels_test.go
+++ b/internal/cmd/image/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := image.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	img := &hcloud.Image{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.ImageClient.EXPECT().
 		GetByID(gomock.Any(), int64(123)).
-		Return(&hcloud.Image{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(img, nil, nil)
 	fx.Client.ImageClient.EXPECT().
-		Update(gomock.Any(), &hcloud.Image{ID: 123}, hcloud.ImageUpdateOpts{
+		Update(gomock.Any(), img, hcloud.ImageUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
diff --git a/internal/cmd/loadbalancer/labels.go b/internal/cmd/loadbalancer/labels.go
index c7c19d74..845fb1c2 100644
--- a/internal/cmd/loadbalancer/labels.go
+++ b/internal/cmd/loadbalancer/labels.go
@@ -2,6 +2,7 @@ package loadbalancer
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.LoadBalancer]{
 	ResourceNameSingular:   "Load Balancer",
 	ShortDescriptionAdd:    "Add a label to a Load Balancer",
 	ShortDescriptionRemove: "Remove a label from a Load Balancer",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.LoadBalancer().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.LoadBalancer().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.LoadBalancer, error) {
 		loadBalancer, _, err := s.Client().LoadBalancer().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if loadBalancer == nil {
-			return nil, 0, fmt.Errorf("load balancer not found: %s", idOrName)
+			return nil, fmt.Errorf("load balancer not found: %s", idOrName)
 		}
-		return loadBalancer.Labels, loadBalancer.ID, nil
+		return loadBalancer, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, loadBalancer *hcloud.LoadBalancer, labels map[string]string) error {
 		opts := hcloud.LoadBalancerUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().LoadBalancer().Update(s, &hcloud.LoadBalancer{ID: id}, opts)
+		_, _, err := s.Client().LoadBalancer().Update(s, loadBalancer, opts)
 		return err
 	},
+	GetLabels: func(loadBalancer *hcloud.LoadBalancer) map[string]string {
+		return loadBalancer.Labels
+	},
+	GetIDOrName: func(loadBalancer *hcloud.LoadBalancer) string {
+		return strconv.FormatInt(loadBalancer.ID, 10)
+	},
 }
diff --git a/internal/cmd/loadbalancer/labels_test.go b/internal/cmd/loadbalancer/labels_test.go
index c1cd356c..bf843832 100644
--- a/internal/cmd/loadbalancer/labels_test.go
+++ b/internal/cmd/loadbalancer/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := loadbalancer.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	lb := &hcloud.LoadBalancer{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.LoadBalancerClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.LoadBalancer{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(lb, nil, nil)
 	fx.Client.LoadBalancerClient.EXPECT().
-		Update(gomock.Any(), &hcloud.LoadBalancer{ID: 123}, hcloud.LoadBalancerUpdateOpts{
+		Update(gomock.Any(), lb, hcloud.LoadBalancerUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
diff --git a/internal/cmd/network/labels.go b/internal/cmd/network/labels.go
index 415d70ae..16ebdb51 100644
--- a/internal/cmd/network/labels.go
+++ b/internal/cmd/network/labels.go
@@ -2,6 +2,7 @@ package network
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.Network]{
 	ResourceNameSingular:   "Network",
 	ShortDescriptionAdd:    "Add a label to a Network",
 	ShortDescriptionRemove: "Remove a label from a Network",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.Network().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.Network().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.Network, error) {
 		network, _, err := s.Client().Network().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if network == nil {
-			return nil, 0, fmt.Errorf("network not found: %s", idOrName)
+			return nil, fmt.Errorf("network not found: %s", idOrName)
 		}
-		return network.Labels, network.ID, nil
+		return network, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, network *hcloud.Network, labels map[string]string) error {
 		opts := hcloud.NetworkUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().Network().Update(s, &hcloud.Network{ID: id}, opts)
+		_, _, err := s.Client().Network().Update(s, network, opts)
 		return err
 	},
+	GetLabels: func(network *hcloud.Network) map[string]string {
+		return network.Labels
+	},
+	GetIDOrName: func(network *hcloud.Network) string {
+		return strconv.FormatInt(network.ID, 10)
+	},
 }
diff --git a/internal/cmd/network/labels_test.go b/internal/cmd/network/labels_test.go
index 85894ff5..33e36993 100644
--- a/internal/cmd/network/labels_test.go
+++ b/internal/cmd/network/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := network.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	net := &hcloud.Network{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.NetworkClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.Network{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(net, nil, nil)
 	fx.Client.NetworkClient.EXPECT().
-		Update(gomock.Any(), &hcloud.Network{ID: 123}, hcloud.NetworkUpdateOpts{
+		Update(gomock.Any(), net, hcloud.NetworkUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
diff --git a/internal/cmd/placementgroup/labels.go b/internal/cmd/placementgroup/labels.go
index fc6dfe2a..91158b35 100644
--- a/internal/cmd/placementgroup/labels.go
+++ b/internal/cmd/placementgroup/labels.go
@@ -2,6 +2,7 @@ package placementgroup
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.PlacementGroup]{
 	ResourceNameSingular:   "placement group",
 	ShortDescriptionAdd:    "Add a label to a placement group",
 	ShortDescriptionRemove: "Remove a label from a placement group",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.PlacementGroup().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.PlacementGroup().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.PlacementGroup, error) {
 		placementGroup, _, err := s.Client().PlacementGroup().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if placementGroup == nil {
-			return nil, 0, fmt.Errorf("placement group not found: %s", idOrName)
+			return nil, fmt.Errorf("placement group not found: %s", idOrName)
 		}
-		return placementGroup.Labels, placementGroup.ID, nil
+		return placementGroup, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, placementGroup *hcloud.PlacementGroup, labels map[string]string) error {
 		opts := hcloud.PlacementGroupUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().PlacementGroup().Update(s, &hcloud.PlacementGroup{ID: id}, opts)
+		_, _, err := s.Client().PlacementGroup().Update(s, placementGroup, opts)
 		return err
 	},
+	GetLabels: func(placementGroup *hcloud.PlacementGroup) map[string]string {
+		return placementGroup.Labels
+	},
+	GetIDOrName: func(placementGroup *hcloud.PlacementGroup) string {
+		return strconv.FormatInt(placementGroup.ID, 10)
+	},
 }
diff --git a/internal/cmd/placementgroup/labels_test.go b/internal/cmd/placementgroup/labels_test.go
index b2dcf6a5..adf2b6e5 100644
--- a/internal/cmd/placementgroup/labels_test.go
+++ b/internal/cmd/placementgroup/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := placementgroup.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	pg := &hcloud.PlacementGroup{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.PlacementGroupClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.PlacementGroup{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(pg, nil, nil)
 	fx.Client.PlacementGroupClient.EXPECT().
-		Update(gomock.Any(), &hcloud.PlacementGroup{ID: 123}, hcloud.PlacementGroupUpdateOpts{
+		Update(gomock.Any(), pg, hcloud.PlacementGroupUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
diff --git a/internal/cmd/primaryip/labels.go b/internal/cmd/primaryip/labels.go
index 5a84f92d..342d8b8a 100644
--- a/internal/cmd/primaryip/labels.go
+++ b/internal/cmd/primaryip/labels.go
@@ -2,6 +2,7 @@ package primaryip
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.PrimaryIP]{
 	ResourceNameSingular:   "primary-ip",
 	ShortDescriptionAdd:    "Add a label to a Primary IP",
 	ShortDescriptionRemove: "Remove a label from a Primary IP",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.PrimaryIP().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.PrimaryIP().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.PrimaryIP, error) {
 		primaryIP, _, err := s.Client().PrimaryIP().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if primaryIP == nil {
-			return nil, 0, fmt.Errorf("primaryIP not found: %s", idOrName)
+			return nil, fmt.Errorf("primaryIP not found: %s", idOrName)
 		}
-		return primaryIP.Labels, primaryIP.ID, nil
+		return primaryIP, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, primaryIP *hcloud.PrimaryIP, labels map[string]string) error {
 		opts := hcloud.PrimaryIPUpdateOpts{
 			Labels: &labels,
 		}
-		_, _, err := s.Client().PrimaryIP().Update(s, &hcloud.PrimaryIP{ID: id}, opts)
+		_, _, err := s.Client().PrimaryIP().Update(s, primaryIP, opts)
 		return err
 	},
+	GetLabels: func(primaryIP *hcloud.PrimaryIP) map[string]string {
+		return primaryIP.Labels
+	},
+	GetIDOrName: func(primaryIP *hcloud.PrimaryIP) string {
+		return strconv.FormatInt(primaryIP.ID, 10)
+	},
 }
diff --git a/internal/cmd/primaryip/labels_test.go b/internal/cmd/primaryip/labels_test.go
index b0c662fb..d77e9144 100644
--- a/internal/cmd/primaryip/labels_test.go
+++ b/internal/cmd/primaryip/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := primaryip.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	primaryIP := &hcloud.PrimaryIP{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.PrimaryIPClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.PrimaryIP{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(primaryIP, nil, nil)
 	fx.Client.PrimaryIPClient.EXPECT().
-		Update(gomock.Any(), &hcloud.PrimaryIP{ID: 123}, hcloud.PrimaryIPUpdateOpts{
+		Update(gomock.Any(), primaryIP, hcloud.PrimaryIPUpdateOpts{
 			Labels: hcloud.Ptr(make(map[string]string)),
 		})
 
diff --git a/internal/cmd/server/labels.go b/internal/cmd/server/labels.go
index ecb5ede0..c46ac880 100644
--- a/internal/cmd/server/labels.go
+++ b/internal/cmd/server/labels.go
@@ -2,6 +2,7 @@ package server
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.Server]{
 	ResourceNameSingular:   "server",
 	ShortDescriptionAdd:    "Add a label to a server",
 	ShortDescriptionRemove: "Remove a label from a server",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.Server().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.Server().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.Server, error) {
 		server, _, err := s.Client().Server().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if server == nil {
-			return nil, 0, fmt.Errorf("server not found: %s", idOrName)
+			return nil, fmt.Errorf("server not found: %s", idOrName)
 		}
-		return server.Labels, server.ID, nil
+		return server, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, server *hcloud.Server, labels map[string]string) error {
 		opts := hcloud.ServerUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().Server().Update(s, &hcloud.Server{ID: id}, opts)
+		_, _, err := s.Client().Server().Update(s, server, opts)
 		return err
 	},
+	GetLabels: func(server *hcloud.Server) map[string]string {
+		return server.Labels
+	},
+	GetIDOrName: func(server *hcloud.Server) string {
+		return strconv.FormatInt(server.ID, 10)
+	},
 }
diff --git a/internal/cmd/server/labels_test.go b/internal/cmd/server/labels_test.go
index f1a4746c..634ad9fe 100644
--- a/internal/cmd/server/labels_test.go
+++ b/internal/cmd/server/labels_test.go
@@ -72,16 +72,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := server.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	srv := &hcloud.Server{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.ServerClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.Server{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(srv, nil, nil)
 	fx.Client.ServerClient.EXPECT().
-		Update(gomock.Any(), &hcloud.Server{ID: 123}, hcloud.ServerUpdateOpts{
+		Update(gomock.Any(), srv, hcloud.ServerUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
@@ -101,18 +103,20 @@ func TestMultiLabelRemove(t *testing.T) {
 	cmd := server.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	srv := &hcloud.Server{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+			"foo": "bar",
+			"baz": "qux",
+		},
+	}
+
 	fx.Client.ServerClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.Server{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-				"foo": "bar",
-				"baz": "qux",
-			},
-		}, nil, nil)
+		Return(srv, nil, nil)
 	fx.Client.ServerClient.EXPECT().
-		Update(gomock.Any(), &hcloud.Server{ID: 123}, hcloud.ServerUpdateOpts{
+		Update(gomock.Any(), srv, hcloud.ServerUpdateOpts{
 			Labels: map[string]string{
 				"key": "value",
 			},
diff --git a/internal/cmd/sshkey/labels.go b/internal/cmd/sshkey/labels.go
index 3bfaf396..4bb46c31 100644
--- a/internal/cmd/sshkey/labels.go
+++ b/internal/cmd/sshkey/labels.go
@@ -2,6 +2,7 @@ package sshkey
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.SSHKey]{
 	ResourceNameSingular:   "SSH Key",
 	ShortDescriptionAdd:    "Add a label to a SSH Key",
 	ShortDescriptionRemove: "Remove a label from a SSH Key",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.SSHKey().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.SSHKey().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.SSHKey, error) {
 		sshKey, _, err := s.Client().SSHKey().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if sshKey == nil {
-			return nil, 0, fmt.Errorf("ssh key not found: %s", idOrName)
+			return nil, fmt.Errorf("ssh key not found: %s", idOrName)
 		}
-		return sshKey.Labels, sshKey.ID, nil
+		return sshKey, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, sshKey *hcloud.SSHKey, labels map[string]string) error {
 		opts := hcloud.SSHKeyUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().SSHKey().Update(s, &hcloud.SSHKey{ID: id}, opts)
+		_, _, err := s.Client().SSHKey().Update(s, sshKey, opts)
 		return err
 	},
+	GetLabels: func(sshKey *hcloud.SSHKey) map[string]string {
+		return sshKey.Labels
+	},
+	GetIDOrName: func(sshKey *hcloud.SSHKey) string {
+		return strconv.FormatInt(sshKey.ID, 10)
+	},
 }
diff --git a/internal/cmd/sshkey/labels_test.go b/internal/cmd/sshkey/labels_test.go
index fdcd4069..01afb189 100644
--- a/internal/cmd/sshkey/labels_test.go
+++ b/internal/cmd/sshkey/labels_test.go
@@ -45,16 +45,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := sshkey.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	sshKey := &hcloud.SSHKey{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.SSHKeyClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.SSHKey{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(sshKey, nil, nil)
 	fx.Client.SSHKeyClient.EXPECT().
-		Update(gomock.Any(), &hcloud.SSHKey{ID: 123}, hcloud.SSHKeyUpdateOpts{
+		Update(gomock.Any(), sshKey, hcloud.SSHKeyUpdateOpts{
 			Labels: make(map[string]string),
 		})
 
diff --git a/internal/cmd/volume/labels.go b/internal/cmd/volume/labels.go
index 57a8d972..6cac47a0 100644
--- a/internal/cmd/volume/labels.go
+++ b/internal/cmd/volume/labels.go
@@ -2,6 +2,7 @@ package volume
 
 import (
 	"fmt"
+	"strconv"
 
 	"github.com/hetznercloud/cli/internal/cmd/base"
 	"github.com/hetznercloud/cli/internal/hcapi2"
@@ -9,27 +10,33 @@ import (
 	"github.com/hetznercloud/hcloud-go/v2/hcloud"
 )
 
-var LabelCmds = base.LabelCmds{
+var LabelCmds = base.LabelCmds[*hcloud.Volume]{
 	ResourceNameSingular:   "Volume",
 	ShortDescriptionAdd:    "Add a label to a Volume",
 	ShortDescriptionRemove: "Remove a label from a Volume",
 	NameSuggestions:        func(c hcapi2.Client) func() []string { return c.Volume().Names },
 	LabelKeySuggestions:    func(c hcapi2.Client) func(idOrName string) []string { return c.Volume().LabelKeys },
-	FetchLabels: func(s state.State, idOrName string) (map[string]string, int64, error) {
+	Fetch: func(s state.State, idOrName string) (*hcloud.Volume, error) {
 		volume, _, err := s.Client().Volume().Get(s, idOrName)
 		if err != nil {
-			return nil, 0, err
+			return nil, err
 		}
 		if volume == nil {
-			return nil, 0, fmt.Errorf("volume not found: %s", idOrName)
+			return nil, fmt.Errorf("volume not found: %s", idOrName)
 		}
-		return volume.Labels, volume.ID, nil
+		return volume, nil
 	},
-	SetLabels: func(s state.State, id int64, labels map[string]string) error {
+	SetLabels: func(s state.State, volume *hcloud.Volume, labels map[string]string) error {
 		opts := hcloud.VolumeUpdateOpts{
 			Labels: labels,
 		}
-		_, _, err := s.Client().Volume().Update(s, &hcloud.Volume{ID: id}, opts)
+		_, _, err := s.Client().Volume().Update(s, volume, opts)
 		return err
 	},
+	GetLabels: func(volume *hcloud.Volume) map[string]string {
+		return volume.Labels
+	},
+	GetIDOrName: func(volume *hcloud.Volume) string {
+		return strconv.FormatInt(volume.ID, 10)
+	},
 }
diff --git a/internal/cmd/volume/labels_test.go b/internal/cmd/volume/labels_test.go
index 94b80299..2df3c7a4 100644
--- a/internal/cmd/volume/labels_test.go
+++ b/internal/cmd/volume/labels_test.go
@@ -19,11 +19,13 @@ func TestLabelAdd(t *testing.T) {
 	cmd := volume.LabelCmds.AddCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	vol := &hcloud.Volume{ID: 123}
+
 	fx.Client.VolumeClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.Volume{ID: 123}, nil, nil)
+		Return(vol, nil, nil)
 	fx.Client.VolumeClient.EXPECT().
-		Update(gomock.Any(), &hcloud.Volume{ID: 123}, hcloud.VolumeUpdateOpts{
+		Update(gomock.Any(), vol, hcloud.VolumeUpdateOpts{
 			Labels: map[string]string{
 				"key": "value",
 			},
@@ -45,16 +47,18 @@ func TestLabelRemove(t *testing.T) {
 	cmd := volume.LabelCmds.RemoveCobraCommand(fx.State())
 	fx.ExpectEnsureToken()
 
+	vol := &hcloud.Volume{
+		ID: 123,
+		Labels: map[string]string{
+			"key": "value",
+		},
+	}
+
 	fx.Client.VolumeClient.EXPECT().
 		Get(gomock.Any(), "123").
-		Return(&hcloud.Volume{
-			ID: 123,
-			Labels: map[string]string{
-				"key": "value",
-			},
-		}, nil, nil)
+		Return(vol, nil, nil)
 	fx.Client.VolumeClient.EXPECT().
-		Update(gomock.Any(), &hcloud.Volume{ID: 123}, hcloud.VolumeUpdateOpts{
+		Update(gomock.Any(), vol, hcloud.VolumeUpdateOpts{
 			Labels: make(map[string]string),
 		})