diff --git a/e2e_test/combined_test.go b/e2e_test/combined_test.go
index e7c10d38..7b2d1a04 100644
--- a/e2e_test/combined_test.go
+++ b/e2e_test/combined_test.go
@@ -15,49 +15,60 @@ func TestCombined(t *testing.T) {
 	// combined tests combine multiple resources and can thus not be run in parallel
 	serverName := withSuffix("test-server")
 	serverID, err := createServer(t, serverName, TestServerType, TestImage)
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	firewallName := withSuffix("test-firewall")
 	firewallID, err := createFirewall(t, firewallName)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	out, err := runCommand(t, "firewall", "apply-to-resource", "--type", "server", "--server", serverName, strconv.FormatInt(firewallID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Firewall %d applied to resource\n", firewallID), out)
-
-	out, err = runCommand(t, "firewall", "delete", strconv.FormatInt(firewallID, 10))
-	assert.Regexp(t, `^firewall with ID [0-9]+ is still in use \(resource_in_use, [0-9a-f]+\)$`, err.Error())
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "firewall", "remove-from-resource", "--type", "server", "--server", serverName, strconv.FormatInt(firewallID, 10))
 	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Firewall %d removed from resource\n", firewallID), out)
 
-	out, err = runCommand(t, "firewall", "delete", strconv.FormatInt(firewallID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("firewall %d deleted\n", firewallID), out)
+	t.Run("firewall", func(t *testing.T) {
+		t.Run("apply-to-server", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "apply-to-resource", "--type", "server", "--server", serverName, strconv.FormatInt(firewallID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Firewall %d applied to resource\n", firewallID), out)
+		})
+
+		t.Run("delete-in-use", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "delete", strconv.FormatInt(firewallID, 10))
+			assert.Regexp(t, `^firewall with ID [0-9]+ is still in use \(resource_in_use, [0-9a-f]+\)$`, err.Error())
+			assert.Empty(t, out)
+		})
+
+		t.Run("remove-from-server", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "remove-from-resource", "--type", "server", "--server", serverName, strconv.FormatInt(firewallID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Firewall %d removed from resource\n", firewallID), out)
+		})
+
+		t.Run("delete", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "delete", strconv.FormatInt(firewallID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("firewall %d deleted\n", firewallID), out)
+		})
+
+	})
 
 	floatingIPName := withSuffix("test-floating-ip")
 	floatingIP, err := createFloatingIP(t, floatingIPName, "ipv4", "--server", strconv.FormatInt(serverID, 10))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	out, err = runCommand(t, "floating-ip", "unassign", strconv.FormatInt(floatingIP, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Floating IP %d unassigned\n", floatingIP), out)
-
-	out, err = runCommand(t, "floating-ip", "assign", strconv.FormatInt(floatingIP, 10), strconv.FormatInt(serverID, 10))
 	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Floating IP %d assigned to server %d\n", floatingIP, serverID), out)
 
-	out, err = runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIP, 10))
-	require.NoError(t, err)
-	assert.Regexp(t, `ID:\s+[0-9]+
+	t.Run("floating-ip", func(t *testing.T) {
+		t.Run("unassign", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "unassign", strconv.FormatInt(floatingIP, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Floating IP %d unassigned\n", floatingIP), out)
+		})
+
+		t.Run("assign", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "assign", strconv.FormatInt(floatingIP, 10), strconv.FormatInt(serverID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Floating IP %d assigned to server %d\n", floatingIP, serverID), out)
+		})
+
+		t.Run("describe", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIP, 10))
+			require.NoError(t, err)
+			assert.Regexp(t, `ID:\s+[0-9]+
 Type:\s+ipv4
 Name:\s+test-floating-ip-[0-9a-f]{8}
 Description:\s+-
@@ -75,16 +86,24 @@ Protection:
 Labels:
 \s+No labels
 `, out)
-
-	out, err = runCommand(t, "floating-ip", "list", "-o", "columns=server", "-o", "noheader")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("%s\n", serverName), out)
-
-	out, err = runCommand(t, "floating-ip", "delete", strconv.FormatInt(floatingIP, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Floating IP %d deleted\n", floatingIP), out)
-
-	out, err = runCommand(t, "server", "delete", strconv.FormatInt(serverID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Server %d deleted\n", serverID), out)
+		})
+
+		t.Run("list", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "list", "-o", "columns=server", "-o", "noheader")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("%s\n", serverName), out)
+		})
+
+		t.Run("delete", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "delete", strconv.FormatInt(floatingIP, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Floating IP %d deleted\n", floatingIP), out)
+		})
+	})
+
+	t.Run("delete-server", func(t *testing.T) {
+		out, err := runCommand(t, "server", "delete", strconv.FormatInt(serverID, 10))
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("Server %d deleted\n", serverID), out)
+	})
 }
diff --git a/e2e_test/datacenter_test.go b/e2e_test/datacenter_test.go
index 151883fc..8c4deb21 100644
--- a/e2e_test/datacenter_test.go
+++ b/e2e_test/datacenter_test.go
@@ -13,22 +13,32 @@ import (
 func TestDatacenter(t *testing.T) {
 	t.Parallel()
 
-	out, err := runCommand(t, "datacenter", "list")
-	require.NoError(t, err)
-	assert.Regexp(t, `ID +NAME +DESCRIPTION +LOCATION
+	t.Run("list", func(t *testing.T) {
+		t.Run("table", func(t *testing.T) {
+			out, err := runCommand(t, "datacenter", "list")
+			require.NoError(t, err)
+			assert.Regexp(t, `ID +NAME +DESCRIPTION +LOCATION
 ([0-9]+ +[a-z0-9\-]+ +[a-zA-Z0-9\- ]+ +[a-z0-9\-]+\n)+`, out)
-
-	out, err = runCommand(t, "datacenter", "list", "-o=json")
-	require.NoError(t, err)
-	require.NoError(t, json.Unmarshal([]byte(out), new([]any)))
-
-	out, err = runCommand(t, "datacenter", "describe", "123456")
-	require.EqualError(t, err, "datacenter not found: 123456")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "datacenter", "describe", TestDatacenterID)
-	require.NoError(t, err)
-	assert.Regexp(t, `ID:\s+[0-9]+
+		})
+
+		t.Run("json", func(t *testing.T) {
+			out, err := runCommand(t, "datacenter", "list", "-o=json")
+			require.NoError(t, err)
+			require.NoError(t, json.Unmarshal([]byte(out), new([]any)))
+		})
+	})
+
+	t.Run("describe", func(t *testing.T) {
+		t.Run("non-existing", func(t *testing.T) {
+			out, err := runCommand(t, "datacenter", "describe", "123456")
+			require.EqualError(t, err, "datacenter not found: 123456")
+			assert.Empty(t, out)
+		})
+
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "datacenter", "describe", TestDatacenterID)
+			require.NoError(t, err)
+			assert.Regexp(t, `ID:\s+[0-9]+
 Name:\s+[a-z0-9\-]+
 Description:\s+[a-zA-Z0-9\- ]+
 Location:
@@ -41,4 +51,6 @@ Location:
 Server Types:
 (\s+- ID: [0-9]+\s+Name: [a-z0-9]+\s+Supported: (true|false)\s+Available: (true|false))+
 `, out)
+		})
+	})
 }
diff --git a/e2e_test/firewall_test.go b/e2e_test/firewall_test.go
index 52f8b508..8bc27705 100644
--- a/e2e_test/firewall_test.go
+++ b/e2e_test/firewall_test.go
@@ -19,31 +19,41 @@ func TestFirewall(t *testing.T) {
 
 	firewallName := withSuffix("test-firewall")
 	firewallID, err := createFirewall(t, firewallName, "--rules-file", "rules_file.json")
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
-	out, err := runCommand(t, "firewall", "add-label", "non-existing-firewall", "foo=bar")
-	require.EqualError(t, err, "firewall not found: non-existing-firewall")
-	assert.Empty(t, out)
+	t.Run("add-label", func(t *testing.T) {
+		t.Run("non-existing", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "add-label", "non-existing-firewall", "foo=bar")
+			require.EqualError(t, err, "firewall not found: non-existing-firewall")
+			assert.Empty(t, out)
+		})
 
-	out, err = runCommand(t, "firewall", "add-label", strconv.FormatInt(firewallID, 10), "foo=bar")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) foo added to firewall %d\n", firewallID), out)
+		t.Run("1", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "add-label", strconv.FormatInt(firewallID, 10), "foo=bar")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Label(s) foo added to firewall %d\n", firewallID), out)
+		})
 
-	out, err = runCommand(t, "firewall", "add-label", strconv.FormatInt(firewallID, 10), "baz=qux")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) baz added to firewall %d\n", firewallID), out)
+		t.Run("2", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "add-label", strconv.FormatInt(firewallID, 10), "baz=qux")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Label(s) baz added to firewall %d\n", firewallID), out)
+		})
+	})
 
-	firewallName = withSuffix("new-test-firewall")
+	t.Run("update-name", func(t *testing.T) {
+		firewallName = withSuffix("new-test-firewall")
 
-	out, err = runCommand(t, "firewall", "update", strconv.FormatInt(firewallID, 10), "--name", firewallName)
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Firewall %d updated\n", firewallID), out)
+		out, err := runCommand(t, "firewall", "update", strconv.FormatInt(firewallID, 10), "--name", firewallName)
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("Firewall %d updated\n", firewallID), out)
+	})
 
-	out, err = runCommand(t, "firewall", "remove-label", firewallName, "baz")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) baz removed from firewall %d\n", firewallID), out)
+	t.Run("remove-label", func(t *testing.T) {
+		out, err := runCommand(t, "firewall", "remove-label", firewallName, "baz")
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("Label(s) baz removed from firewall %d\n", firewallID), out)
+	})
 
 	t.Run("add-rule", func(t *testing.T) {
 		t.Run("missing-args", func(t *testing.T) {
@@ -113,26 +123,31 @@ func TestFirewall(t *testing.T) {
 			require.EqualError(t, err, "unknown type non-existing-type")
 			assert.Empty(t, out)
 		})
+
 		t.Run("missing-server", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "apply-to-resource", "--type", "server", strconv.FormatInt(firewallID, 10))
 			require.EqualError(t, err, "type server need a --server specific")
 			assert.Empty(t, out)
 		})
+
 		t.Run("missing-label-selector", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "apply-to-resource", "--type", "label_selector", strconv.FormatInt(firewallID, 10))
 			require.EqualError(t, err, "type label_selector need a --label-selector specific")
 			assert.Empty(t, out)
 		})
+
 		t.Run("unknown-firewall", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "apply-to-resource", "--type", "server", "--server", "non-existing-server", "non-existing-firewall")
 			require.EqualError(t, err, "Firewall not found: non-existing-firewall")
 			assert.Empty(t, out)
 		})
+
 		t.Run("unknown-server", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "apply-to-resource", "--type", "server", "--server", "non-existing-server", strconv.FormatInt(firewallID, 10))
 			require.EqualError(t, err, "Server not found: non-existing-server")
 			assert.Empty(t, out)
 		})
+
 		t.Run("label-selector", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "apply-to-resource", "--type", "label_selector", "--label-selector", "foo=bar", strconv.FormatInt(firewallID, 10))
 			require.NoError(t, err)
@@ -140,9 +155,10 @@ func TestFirewall(t *testing.T) {
 		})
 	})
 
-	out, err = runCommand(t, "firewall", "describe", strconv.FormatInt(firewallID, 10))
-	require.NoError(t, err)
-	assert.Regexp(t, `ID:\s+[0-9]+
+	t.Run("describe", func(t *testing.T) {
+		out, err := runCommand(t, "firewall", "describe", strconv.FormatInt(firewallID, 10))
+		require.NoError(t, err)
+		assert.Regexp(t, `ID:\s+[0-9]+
 Name:\s+new-test-firewall-[0-9a-f]{8}
 Created:\s+.*?
 Labels:
@@ -184,6 +200,7 @@ Applied To:
 \s+- Type:\s+label_selector
 \s+Label Selector:\s+foo=bar
 `, out)
+	})
 
 	t.Run("remove-from-resource", func(t *testing.T) {
 		t.Run("unknown-type", func(t *testing.T) {
@@ -191,26 +208,31 @@ Applied To:
 			require.EqualError(t, err, "unknown type non-existing-type")
 			assert.Empty(t, out)
 		})
+
 		t.Run("missing-server", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "remove-from-resource", "--type", "server", strconv.FormatInt(firewallID, 10))
 			require.EqualError(t, err, "type server need a --server specific")
 			assert.Empty(t, out)
 		})
+
 		t.Run("missing-label-selector", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "remove-from-resource", "--type", "label_selector", strconv.FormatInt(firewallID, 10))
 			require.EqualError(t, err, "type label_selector need a --label-selector specific")
 			assert.Empty(t, out)
 		})
+
 		t.Run("unknown-firewall", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "remove-from-resource", "--type", "server", "--server", "non-existing-server", "non-existing-firewall")
 			require.EqualError(t, err, "Firewall not found: non-existing-firewall")
 			assert.Empty(t, out)
 		})
+
 		t.Run("unknown-server", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "remove-from-resource", "--type", "server", "--server", "non-existing-server", strconv.FormatInt(firewallID, 10))
 			require.EqualError(t, err, "Server not found: non-existing-server")
 			assert.Empty(t, out)
 		})
+
 		t.Run("label-selector", func(t *testing.T) {
 			out, err := runCommand(t, "firewall", "remove-from-resource", "--type", "label_selector", "--label-selector", "foo=bar", strconv.FormatInt(firewallID, 10))
 			require.NoError(t, err)
@@ -256,17 +278,25 @@ Applied To:
 		})
 	})
 
-	out, err = runCommand(t, "firewall", "replace-rules", "non-existing-firewall", "--rules-file", "rules_file.json")
-	require.EqualError(t, err, "Firewall not found: non-existing-firewall")
-	assert.Empty(t, out)
+	t.Run("replace-rules", func(t *testing.T) {
+		t.Run("non-existing-firewall", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "replace-rules", "non-existing-firewall", "--rules-file", "rules_file.json")
+			require.EqualError(t, err, "Firewall not found: non-existing-firewall")
+			assert.Empty(t, out)
+		})
 
-	out, err = runCommand(t, "firewall", "replace-rules", strconv.FormatInt(firewallID, 10), "--rules-file", "rules_file.json")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Firewall Rules for Firewall %d updated\n", firewallID), out)
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "firewall", "replace-rules", strconv.FormatInt(firewallID, 10), "--rules-file", "rules_file.json")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Firewall Rules for Firewall %d updated\n", firewallID), out)
+		})
+	})
 
-	out, err = runCommand(t, "firewall", "delete", strconv.FormatInt(firewallID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("firewall %d deleted\n", firewallID), out)
+	t.Run("delete", func(t *testing.T) {
+		out, err := runCommand(t, "firewall", "delete", strconv.FormatInt(firewallID, 10))
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("firewall %d deleted\n", firewallID), out)
+	})
 }
 
 func createFirewall(t *testing.T, name string, args ...string) (int64, error) {
diff --git a/e2e_test/floatingip_test.go b/e2e_test/floatingip_test.go
index 8ce02de7..26c710fc 100644
--- a/e2e_test/floatingip_test.go
+++ b/e2e_test/floatingip_test.go
@@ -20,86 +20,102 @@ import (
 func TestFloatingIP(t *testing.T) {
 	t.Parallel()
 
-	floatingIPName := withSuffix("test-floating-ip")
+	t.Run("ipv4", func(t *testing.T) {
+		floatingIPName := withSuffix("test-floating-ip")
+		_, err := createFloatingIP(t, floatingIPName, "")
+		require.EqualError(t, err, "type is required")
 
-	_, err := createFloatingIP(t, floatingIPName, "")
-	require.EqualError(t, err, "type is required")
+		_, err = createFloatingIP(t, floatingIPName, "ipv4")
+		require.EqualError(t, err, "one of --home-location or --server is required")
 
-	_, err = createFloatingIP(t, floatingIPName, "ipv4")
-	require.EqualError(t, err, "one of --home-location or --server is required")
+		_, err = createFloatingIP(t, floatingIPName, "ipv4", "--server", "non-existing-server")
+		require.EqualError(t, err, "server not found: non-existing-server")
 
-	_, err = createFloatingIP(t, floatingIPName, "ipv4", "--server", "non-existing-server")
-	require.EqualError(t, err, "server not found: non-existing-server")
-
-	floatingIPId, err := createFloatingIP(t, floatingIPName, "ipv4", "--home-location", TestLocationName)
-	if err != nil {
-		t.Fatal(err)
-	}
+		floatingIPId, err := createFloatingIP(t, floatingIPName, "ipv4", "--home-location", TestLocationName)
+		require.NoError(t, err)
 
-	t.Run("labels", func(t *testing.T) {
-		t.Run("add-label-non-existing-floating-ip", func(t *testing.T) {
-			out, err := runCommand(t, "floating-ip", "add-label", "non-existing-floating-ip", "foo=bar")
-			require.EqualError(t, err, "floating IP not found: non-existing-floating-ip")
-			assert.Empty(t, out)
+		t.Run("labels", func(t *testing.T) {
+			t.Run("add-label-non-existing-floating-ip", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "add-label", "non-existing-floating-ip", "foo=bar")
+				require.EqualError(t, err, "floating IP not found: non-existing-floating-ip")
+				assert.Empty(t, out)
+			})
+
+			t.Run("add-label", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "add-label", strconv.FormatInt(floatingIPId, 10), "foo=bar")
+				require.NoError(t, err)
+				assert.Equal(t, fmt.Sprintf("Label(s) foo added to Floating IP %d\n", floatingIPId), out)
+			})
 		})
 
-		t.Run("add-label", func(t *testing.T) {
-			out, err := runCommand(t, "floating-ip", "add-label", strconv.FormatInt(floatingIPId, 10), "foo=bar")
+		t.Run("update-name", func(t *testing.T) {
+			floatingIPName = withSuffix("new-test-floating-ip")
+			out, err := runCommand(t, "floating-ip", "update", strconv.FormatInt(floatingIPId, 10), "--name", floatingIPName, "--description", "Some description")
 			require.NoError(t, err)
-			assert.Equal(t, fmt.Sprintf("Label(s) foo added to Floating IP %d\n", floatingIPId), out)
+			assert.Equal(t, fmt.Sprintf("Floating IP %d updated\n", floatingIPId), out)
 		})
-	})
-
-	floatingIPName = withSuffix("new-test-floating-ip")
-
-	out, err := runCommand(t, "floating-ip", "update", strconv.FormatInt(floatingIPId, 10), "--name", floatingIPName, "--description", "Some description")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Floating IP %d updated\n", floatingIPId), out)
-
-	out, err = runCommand(t, "floating-ip", "set-rdns", strconv.FormatInt(floatingIPId, 10), "--hostname", "s1.example.com")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Reverse DNS of Floating IP %d changed\n", floatingIPId), out)
-
-	out, err = runCommand(t, "floating-ip", "unassign", "non-existing-floating-ip")
-	require.EqualError(t, err, "Floating IP not found: non-existing-floating-ip")
-	assert.Empty(t, out)
 
-	out, err = runCommand(t, "floating-ip", "assign", "non-existing-floating-ip", "non-existing-server")
-	require.EqualError(t, err, "Floating IP not found: non-existing-floating-ip")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "floating-ip", "assign", strconv.FormatInt(floatingIPId, 10), "non-existing-server")
-	require.EqualError(t, err, "server not found: non-existing-server")
-	assert.Empty(t, out)
-
-	t.Run("enable-protection", func(t *testing.T) {
-		t.Run("unknown-protection-level", func(t *testing.T) {
-			out, err := runCommand(t, "floating-ip", "enable-protection", strconv.FormatInt(floatingIPId, 10), "unknown-protection-level")
-			require.EqualError(t, err, "unknown protection level: unknown-protection-level")
-			assert.Empty(t, out)
+		t.Run("set-rnds", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "set-rdns", strconv.FormatInt(floatingIPId, 10), "--hostname", "s1.example.com")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Reverse DNS of Floating IP %d changed\n", floatingIPId), out)
 		})
 
-		t.Run("non-existing-floating-ip", func(t *testing.T) {
-			out, err := runCommand(t, "floating-ip", "enable-protection", "non-existing-floating-ip", "delete")
+		t.Run("unassign-non-existing", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "unassign", "non-existing-floating-ip")
 			require.EqualError(t, err, "Floating IP not found: non-existing-floating-ip")
 			assert.Empty(t, out)
 		})
 
-		t.Run("enable-delete-protection", func(t *testing.T) {
-			out, err := runCommand(t, "floating-ip", "enable-protection", strconv.FormatInt(floatingIPId, 10), "delete")
-			require.NoError(t, err)
-			assert.Equal(t, fmt.Sprintf("Resource protection enabled for floating IP %d\n", floatingIPId), out)
+		t.Run("assign", func(t *testing.T) {
+			t.Run("non-existing-ip", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "assign", "non-existing-floating-ip", "non-existing-server")
+				require.EqualError(t, err, "Floating IP not found: non-existing-floating-ip")
+				assert.Empty(t, out)
+			})
+
+			t.Run("non-existing-server", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "assign", strconv.FormatInt(floatingIPId, 10), "non-existing-server")
+				require.EqualError(t, err, "server not found: non-existing-server")
+				assert.Empty(t, out)
+			})
 		})
-	})
 
-	ipStr, err := runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIPId, 10), "--output", "format={{.IP}}")
-	require.NoError(t, err)
-	ipStr = strings.TrimSpace(ipStr)
-	assert.Regexp(t, `^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$`, ipStr)
+		t.Run("enable-protection", func(t *testing.T) {
+			t.Run("unknown-protection-level", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "enable-protection", strconv.FormatInt(floatingIPId, 10), "unknown-protection-level")
+				require.EqualError(t, err, "unknown protection level: unknown-protection-level")
+				assert.Empty(t, out)
+			})
+
+			t.Run("non-existing-floating-ip", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "enable-protection", "non-existing-floating-ip", "delete")
+				require.EqualError(t, err, "Floating IP not found: non-existing-floating-ip")
+				assert.Empty(t, out)
+			})
+
+			t.Run("enable-delete-protection", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "enable-protection", strconv.FormatInt(floatingIPId, 10), "delete")
+				require.NoError(t, err)
+				assert.Equal(t, fmt.Sprintf("Resource protection enabled for floating IP %d\n", floatingIPId), out)
+			})
+		})
 
-	out, err = runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIPId, 10))
-	require.NoError(t, err)
-	assert.Regexp(t, `ID:\s+[0-9]+
+		var ipStr string
+
+		t.Run("describe", func(t *testing.T) {
+			t.Run("format", func(t *testing.T) {
+				var err error
+				ipStr, err = runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIPId, 10), "--output", "format={{.IP}}")
+				require.NoError(t, err)
+				ipStr = strings.TrimSpace(ipStr)
+				assert.Regexp(t, `^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$`, ipStr)
+			})
+
+			t.Run("normal", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIPId, 10))
+				require.NoError(t, err)
+				assert.Regexp(t, `ID:\s+[0-9]+
 Type:\s+ipv4
 Name:\s+new-test-floating-ip-[0-9a-f]{8}
 Description:\s+Some description
@@ -116,16 +132,22 @@ Protection:
 Labels:
 \s+foo: bar
 `, out)
+			})
+		})
 
-	out, err = runCommand(t, "floating-ip", "list", "--output", "columns=id,name,type,ip,dns,server,home,blocked,protection,labels,created,age")
-	require.NoError(t, err)
-	assert.Regexp(t, `^ID +NAME +TYPE +IP +DNS +SERVER +HOME +BLOCKED +PROTECTION +LABELS +CREATED +AGE
+		t.Run("list", func(t *testing.T) {
+			t.Run("table", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "list", "--output", "columns=id,name,type,ip,dns,server,home,blocked,protection,labels,created,age")
+				require.NoError(t, err)
+				assert.Regexp(t, `^ID +NAME +TYPE +IP +DNS +SERVER +HOME +BLOCKED +PROTECTION +LABELS +CREATED +AGE
 [0-9]+ +new-test-floating-ip-[0-9a-f]{8} +ipv4 +(?:[0-9]{1,3}\.){3}[0-9]{1,3} +s1\.example\.com +- +[a-z]{3}[0-9]* +no +delete +foo=bar.*?
 $`, out)
+			})
 
-	out, err = runCommand(t, "floating-ip", "list", "-o=json")
-	require.NoError(t, err)
-	assertjson.Equal(t, []byte(fmt.Sprintf(`
+			t.Run("json", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "list", "-o=json")
+				require.NoError(t, err)
+				assertjson.Equal(t, []byte(fmt.Sprintf(`
 [
   {
     "id": %d,
@@ -161,44 +183,62 @@ $`, out)
   }
 ]
 `, floatingIPId, ipStr, ipStr, TestLocationName, floatingIPName)), []byte(out))
+			})
+		})
 
-	out, err = runCommand(t, "floating-ip", "delete", strconv.FormatInt(floatingIPId, 10))
-	assert.Regexp(t, `^Floating IP deletion is protected \(protected, [0-9a-f]+\)$`, err.Error())
-	assert.Empty(t, out)
-
-	t.Run("disable-protection", func(t *testing.T) {
-		t.Run("non-existing-floating-ip", func(t *testing.T) {
-			out, err := runCommand(t, "floating-ip", "disable-protection", "non-existing-floating-ip", "delete")
-			require.EqualError(t, err, "Floating IP not found: non-existing-floating-ip")
+		t.Run("delete-protected", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "delete", strconv.FormatInt(floatingIPId, 10))
+			assert.Regexp(t, `^Floating IP deletion is protected \(protected, [0-9a-f]+\)$`, err.Error())
 			assert.Empty(t, out)
 		})
 
-		t.Run("unknown-protection-level", func(t *testing.T) {
-			out, err := runCommand(t, "floating-ip", "disable-protection", strconv.FormatInt(floatingIPId, 10), "unknown-protection-level")
-			require.EqualError(t, err, "unknown protection level: unknown-protection-level")
-			assert.Empty(t, out)
+		t.Run("disable-protection", func(t *testing.T) {
+			t.Run("non-existing-floating-ip", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "disable-protection", "non-existing-floating-ip", "delete")
+				require.EqualError(t, err, "Floating IP not found: non-existing-floating-ip")
+				assert.Empty(t, out)
+			})
+
+			t.Run("unknown-protection-level", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "disable-protection", strconv.FormatInt(floatingIPId, 10), "unknown-protection-level")
+				require.EqualError(t, err, "unknown protection level: unknown-protection-level")
+				assert.Empty(t, out)
+			})
+
+			t.Run("disable-delete-protection", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "disable-protection", strconv.FormatInt(floatingIPId, 10), "delete")
+				require.NoError(t, err)
+				assert.Equal(t, fmt.Sprintf("Resource protection disabled for floating IP %d\n", floatingIPId), out)
+			})
 		})
 
-		t.Run("disable-delete-protection", func(t *testing.T) {
-			out, err = runCommand(t, "floating-ip", "disable-protection", strconv.FormatInt(floatingIPId, 10), "delete")
+		t.Run("delete", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "delete", strconv.FormatInt(floatingIPId, 10))
 			require.NoError(t, err)
-			assert.Equal(t, fmt.Sprintf("Resource protection disabled for floating IP %d\n", floatingIPId), out)
+			assert.Equal(t, fmt.Sprintf("Floating IP %d deleted\n", floatingIPId), out)
 		})
 	})
 
-	out, err = runCommand(t, "floating-ip", "delete", strconv.FormatInt(floatingIPId, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Floating IP %d deleted\n", floatingIPId), out)
-
-	floatingIPName = withSuffix("test-floating-ipv6")
-	floatingIPId, err = createFloatingIP(t, floatingIPName, "ipv6", "--home-location", TestLocationName)
-	if err != nil {
-		t.Fatal(err)
-	}
+	t.Run("ipv6", func(t *testing.T) {
+		floatingIPName := withSuffix("test-floating-ipv6")
+		floatingIPId, err := createFloatingIP(t, floatingIPName, "ipv6", "--home-location", TestLocationName)
+		require.NoError(t, err)
 
-	out, err = runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIPId, 10))
-	require.NoError(t, err)
-	assert.Regexp(t, `ID:\s+[0-9]+
+		var ipStr string
+
+		t.Run("describe", func(t *testing.T) {
+			t.Run("format", func(t *testing.T) {
+				var err error
+				ipStr, err = runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIPId, 10), "--output", "format={{.IP}}")
+				require.NoError(t, err)
+				ipStr = strings.TrimSpace(ipStr)
+				assert.NotNil(t, net.ParseIP(ipStr))
+			})
+
+			t.Run("normal", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIPId, 10))
+				require.NoError(t, err)
+				assert.Regexp(t, `ID:\s+[0-9]+
 Type:\s+ipv6
 Name:\s+test-floating-ipv6-[0-9a-f]{8}
 Description:\s+-
@@ -215,32 +255,37 @@ Protection:
 Labels:
 \s+No labels
 `, out)
+			})
+		})
 
-	out, err = runCommand(t, "floating-ip", "describe", strconv.FormatInt(floatingIPId, 10), "--output", "format={{.IP}}")
-	require.NoError(t, err)
-	out = strings.TrimSpace(out)
-	ipv6 := net.ParseIP(out)
-	if ipv6 != nil {
-		out, err = runCommand(t, "floating-ip", "set-rdns", strconv.FormatInt(floatingIPId, 10), "--ip", ipv6.String()+"1", "--hostname", "s1.example.com")
-		require.NoError(t, err)
-		assert.Equal(t, fmt.Sprintf("Reverse DNS of Floating IP %d changed\n", floatingIPId), out)
-
-		out, err = runCommand(t, "floating-ip", "set-rdns", strconv.FormatInt(floatingIPId, 10), "--ip", ipv6.String()+"2", "--hostname", "s2.example.com")
-		require.NoError(t, err)
-		assert.Equal(t, fmt.Sprintf("Reverse DNS of Floating IP %d changed\n", floatingIPId), out)
-	} else {
-		t.Errorf("invalid IPv6 address: %s", out)
-	}
+		t.Run("set-rdns", func(t *testing.T) {
+			t.Run("1", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "set-rdns", strconv.FormatInt(floatingIPId, 10), "--ip", ipStr+"1", "--hostname", "s1.example.com")
+				require.NoError(t, err)
+				assert.Equal(t, fmt.Sprintf("Reverse DNS of Floating IP %d changed\n", floatingIPId), out)
+			})
+
+			t.Run("2", func(t *testing.T) {
+				out, err := runCommand(t, "floating-ip", "set-rdns", strconv.FormatInt(floatingIPId, 10), "--ip", ipStr+"2", "--hostname", "s2.example.com")
+				require.NoError(t, err)
+				assert.Equal(t, fmt.Sprintf("Reverse DNS of Floating IP %d changed\n", floatingIPId), out)
+			})
+		})
 
-	out, err = runCommand(t, "floating-ip", "list", "-o", "columns=ip,dns")
-	require.NoError(t, err)
-	assert.Regexp(t, fmt.Sprintf(`^IP +DNS
+		t.Run("list", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "list", "-o", "columns=ip,dns")
+			require.NoError(t, err)
+			assert.Regexp(t, fmt.Sprintf(`^IP +DNS
 %s\/64 +2 entries
-`, ipv6), out)
+`, ipStr), out)
+		})
 
-	out, err = runCommand(t, "floating-ip", "delete", strconv.FormatInt(floatingIPId, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Floating IP %d deleted\n", floatingIPId), out)
+		t.Run("delete", func(t *testing.T) {
+			out, err := runCommand(t, "floating-ip", "delete", strconv.FormatInt(floatingIPId, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Floating IP %d deleted\n", floatingIPId), out)
+		})
+	})
 }
 
 func createFloatingIP(t *testing.T, name, ipType string, args ...string) (int64, error) {
diff --git a/e2e_test/network_test.go b/e2e_test/network_test.go
index 8cf1985c..c632aae1 100644
--- a/e2e_test/network_test.go
+++ b/e2e_test/network_test.go
@@ -30,90 +30,144 @@ func TestNetwork(t *testing.T) {
 	require.Error(t, err)
 	assert.Regexp(t, `^name is already used \(uniqueness_error, [0-9a-f]+\)$`, err.Error())
 
-	out, err = runCommand(t, "network", "enable-protection", strconv.FormatInt(networkID, 10), "non-existing-protection")
-	require.EqualError(t, err, "unknown protection level: non-existing-protection")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "network", "enable-protection", "non-existing-network", "delete")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "network", "enable-protection", strconv.FormatInt(networkID, 10), "delete")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Resource protection enabled for network %d\n", networkID), out)
+	t.Run("enable-protection", func(t *testing.T) {
+		t.Run("non-existing-protection", func(t *testing.T) {
+			out, err := runCommand(t, "network", "enable-protection", strconv.FormatInt(networkID, 10), "non-existing-protection")
+			require.EqualError(t, err, "unknown protection level: non-existing-protection")
+			assert.Empty(t, out)
+		})
+
+		t.Run("non-existing-network", func(t *testing.T) {
+			out, err := runCommand(t, "network", "enable-protection", "non-existing-network", "delete")
+			require.EqualError(t, err, "network not found: non-existing-network")
+			assert.Empty(t, out)
+		})
+
+		t.Run("delete", func(t *testing.T) {
+			out, err := runCommand(t, "network", "enable-protection", strconv.FormatInt(networkID, 10), "delete")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Resource protection enabled for network %d\n", networkID), out)
+		})
+	})
 
-	out, err = runCommand(t, "network", "list", "-o=columns=servers,ip_range,labels,protection,created,age")
-	require.NoError(t, err)
-	assert.Regexp(t, `SERVERS +IP RANGE +LABELS +PROTECTION +CREATED +AGE
+	t.Run("list", func(t *testing.T) {
+		out, err := runCommand(t, "network", "list", "-o=columns=servers,ip_range,labels,protection,created,age")
+		require.NoError(t, err)
+		assert.Regexp(t, `SERVERS +IP RANGE +LABELS +PROTECTION +CREATED +AGE
 0 servers +10\.0\.0\.0/24 +delete .*? (?:just now|[0-9]+s)
 `, out)
+	})
 
-	out, err = runCommand(t, "network", "change-ip-range", "--ip-range", "10.0.2.0/16", "non-existing-network")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "network", "change-ip-range", "--ip-range", "10.0.2.0/16", networkName)
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("IP range of network %d changed\n", networkID), out)
-
-	out, err = runCommand(t, "network", "add-label", "non-existing-network", "foo=bar")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "network", "add-label", networkName, "foo=bar")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) foo added to Network %d\n", networkID), out)
-
-	out, err = runCommand(t, "network", "add-label", networkName, "baz=qux")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) baz added to Network %d\n", networkID), out)
+	t.Run("change-ip-range", func(t *testing.T) {
+		t.Run("non-existing-network", func(t *testing.T) {
+			out, err := runCommand(t, "network", "change-ip-range", "--ip-range", "10.0.2.0/16", "non-existing-network")
+			require.EqualError(t, err, "network not found: non-existing-network")
+			assert.Empty(t, out)
+		})
+
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "network", "change-ip-range", "--ip-range", "10.0.2.0/16", networkName)
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("IP range of network %d changed\n", networkID), out)
+		})
+	})
 
-	out, err = runCommand(t, "network", "remove-label", networkName, "baz")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) baz removed from Network %d\n", networkID), out)
+	t.Run("labels", func(t *testing.T) {
+		t.Run("add", func(t *testing.T) {
+			t.Run("non-existing-network", func(t *testing.T) {
+				out, err := runCommand(t, "network", "add-label", "non-existing-network", "foo=bar")
+				require.EqualError(t, err, "network not found: non-existing-network")
+				assert.Empty(t, out)
+			})
+
+			t.Run("1", func(t *testing.T) {
+				out, err := runCommand(t, "network", "add-label", networkName, "foo=bar")
+				require.NoError(t, err)
+				assert.Equal(t, fmt.Sprintf("Label(s) foo added to Network %d\n", networkID), out)
+			})
+
+			t.Run("2", func(t *testing.T) {
+				out, err := runCommand(t, "network", "add-label", networkName, "baz=qux")
+				require.NoError(t, err)
+				assert.Equal(t, fmt.Sprintf("Label(s) baz added to Network %d\n", networkID), out)
+			})
+		})
+
+		t.Run("remove", func(t *testing.T) {
+			out, err := runCommand(t, "network", "remove-label", networkName, "baz")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Label(s) baz removed from Network %d\n", networkID), out)
+		})
+	})
 
 	oldNetworkName := networkName
 	networkName = withSuffix("new-test-network")
 
-	out, err = runCommand(t, "network", "update", oldNetworkName, "--name", networkName)
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Network %s updated\n", oldNetworkName), out)
-
-	out, err = runCommand(t, "network", "delete", strconv.FormatInt(networkID, 10))
-	assert.Empty(t, out)
-	assert.Regexp(t, `^network is delete protected \(protected, [0-9a-f]+\)$`, err.Error())
-
-	out, err = runCommand(t, "network", "add-subnet", "--type", "cloud", "--network-zone", "eu-central", "--ip-range", "10.0.16.0/24", "non-existing-network")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
+	t.Run("update-name", func(t *testing.T) {
+		out, err := runCommand(t, "network", "update", oldNetworkName, "--name", networkName)
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("Network %s updated\n", oldNetworkName), out)
+	})
 
-	out, err = runCommand(t, "network", "add-subnet", "--type", "vswitch", "--vswitch-id", "42", "--network-zone", "eu-central", "--ip-range", "10.0.17.0/24", strconv.FormatInt(networkID, 10))
-	assert.Empty(t, out)
-	assert.Regexp(t, `^vswitch not found \(service_error, [0-9a-f]+\)$`, err.Error())
+	t.Run("delete-protected", func(t *testing.T) {
+		out, err := runCommand(t, "network", "delete", strconv.FormatInt(networkID, 10))
+		assert.Empty(t, out)
+		assert.Regexp(t, `^network is delete protected \(protected, [0-9a-f]+\)$`, err.Error())
+	})
 
-	out, err = runCommand(t, "network", "add-subnet", "--type", "cloud", "--network-zone", "eu-central", "--ip-range", "10.0.16.0/24", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Subnet added to network %d\n", networkID), out)
+	t.Run("add-subnet", func(t *testing.T) {
+		t.Run("non-existing-network", func(t *testing.T) {
+			out, err := runCommand(t, "network", "add-subnet", "--type", "cloud", "--network-zone", "eu-central", "--ip-range", "10.0.16.0/24", "non-existing-network")
+			require.EqualError(t, err, "network not found: non-existing-network")
+			assert.Empty(t, out)
+		})
+
+		t.Run("non-existing-vswitch", func(t *testing.T) {
+			out, err := runCommand(t, "network", "add-subnet", "--type", "vswitch", "--vswitch-id", "42", "--network-zone", "eu-central", "--ip-range", "10.0.17.0/24", strconv.FormatInt(networkID, 10))
+			assert.Empty(t, out)
+			assert.Regexp(t, `^vswitch not found \(service_error, [0-9a-f]+\)$`, err.Error())
+		})
+
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "network", "add-subnet", "--type", "cloud", "--network-zone", "eu-central", "--ip-range", "10.0.16.0/24", strconv.FormatInt(networkID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Subnet added to network %d\n", networkID), out)
+		})
+	})
 
-	out, err = runCommand(t, "network", "add-route", "--destination", "10.100.1.0/24", "--gateway", "10.0.1.1", "non-existing-network")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
+	t.Run("add-route", func(t *testing.T) {
+		t.Run("non-existing-network", func(t *testing.T) {
+			out, err := runCommand(t, "network", "add-route", "--destination", "10.100.1.0/24", "--gateway", "10.0.1.1", "non-existing-network")
+			require.EqualError(t, err, "network not found: non-existing-network")
+			assert.Empty(t, out)
 
-	out, err = runCommand(t, "network", "add-route", "--destination", "10.100.1.0/24", "--gateway", "10.0.1.1", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Route added to network %d\n", networkID), out)
+		})
 
-	out, err = runCommand(t, "network", "expose-routes-to-vswitch", "non-existing-network")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "network", "add-route", "--destination", "10.100.1.0/24", "--gateway", "10.0.1.1", strconv.FormatInt(networkID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Route added to network %d\n", networkID), out)
+		})
+	})
 
-	out, err = runCommand(t, "network", "expose-routes-to-vswitch", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Exposing routes to connected vSwitch of network %s enabled\n", networkName), out)
+	t.Run("expose-routes-to-vswitch", func(t *testing.T) {
+		t.Run("non-existing-network", func(t *testing.T) {
+			out, err := runCommand(t, "network", "expose-routes-to-vswitch", "non-existing-network")
+			require.EqualError(t, err, "network not found: non-existing-network")
+			assert.Empty(t, out)
+		})
+
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "network", "expose-routes-to-vswitch", strconv.FormatInt(networkID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Exposing routes to connected vSwitch of network %s enabled\n", networkName), out)
+		})
+	})
 
-	out, err = runCommand(t, "network", "describe", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Regexp(t, `^ID:\s+[0-9]+
+	t.Run("describe", func(t *testing.T) {
+		out, err := runCommand(t, "network", "describe", strconv.FormatInt(networkID, 10))
+		require.NoError(t, err)
+		assert.Regexp(t, `^ID:\s+[0-9]+
 Name:\s+new-test-network-[0-9a-f]{8}
 Created:\s+.*?
 IP Range:\s+10\.0\.0\.0\/16
@@ -131,10 +185,12 @@ Protection:
 Labels:
 \s+foo: bar
 $`, out)
+	})
 
-	out, err = runCommand(t, "network", "list", "-o=json")
-	require.NoError(t, err)
-	assertjson.Equal(t, []byte(fmt.Sprintf(`
+	t.Run("list", func(t *testing.T) {
+		out, err := runCommand(t, "network", "list", "-o=json")
+		require.NoError(t, err)
+		assertjson.Equal(t, []byte(fmt.Sprintf(`
 [
   {
     "id": %d,
@@ -166,42 +222,66 @@ $`, out)
   }
 ]
 `, networkID, networkName)), []byte(out))
+	})
 
-	out, err = runCommand(t, "network", "remove-route", "--destination", "10.100.1.0/24", "--gateway", "10.0.1.1", "non-existing-network")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "network", "remove-route", "--destination", "10.100.1.0/24", "--gateway", "10.0.1.1", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Route removed from network %d\n", networkID), out)
-
-	out, err = runCommand(t, "network", "remove-subnet", "--ip-range", "10.0.16.0/24", "non-existing-network")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "network", "remove-subnet", "--ip-range", "10.0.16.0/24", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Subnet 10.0.16.0/24 removed from network %d\n", networkID), out)
+	t.Run("remove-route", func(t *testing.T) {
+		t.Run("non-existing-network", func(t *testing.T) {
+			out, err := runCommand(t, "network", "remove-route", "--destination", "10.100.1.0/24", "--gateway", "10.0.1.1", "non-existing-network")
+			require.EqualError(t, err, "network not found: non-existing-network")
+			assert.Empty(t, out)
+		})
+
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "network", "remove-route", "--destination", "10.100.1.0/24", "--gateway", "10.0.1.1", strconv.FormatInt(networkID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Route removed from network %d\n", networkID), out)
+		})
+	})
 
-	out, err = runCommand(t, "network", "disable-protection", "non-existing-network", "delete")
-	require.EqualError(t, err, "network not found: non-existing-network")
-	assert.Empty(t, out)
+	t.Run("remove-subnet", func(t *testing.T) {
+		t.Run("non-existing-network", func(t *testing.T) {
+			out, err := runCommand(t, "network", "remove-subnet", "--ip-range", "10.0.16.0/24", "non-existing-network")
+			require.EqualError(t, err, "network not found: non-existing-network")
+			assert.Empty(t, out)
+		})
+
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "network", "remove-subnet", "--ip-range", "10.0.16.0/24", strconv.FormatInt(networkID, 10))
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Subnet 10.0.16.0/24 removed from network %d\n", networkID), out)
+		})
+	})
 
-	out, err = runCommand(t, "network", "disable-protection", strconv.FormatInt(networkID, 10), "delete")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Resource protection disabled for network %d\n", networkID), out)
+	t.Run("disable-protection", func(t *testing.T) {
+		t.Run("non-existing-network", func(t *testing.T) {
+			out, err := runCommand(t, "network", "disable-protection", "non-existing-network", "delete")
+			require.EqualError(t, err, "network not found: non-existing-network")
+			assert.Empty(t, out)
+		})
+
+		t.Run("normal", func(t *testing.T) {
+			out, err := runCommand(t, "network", "disable-protection", strconv.FormatInt(networkID, 10), "delete")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Resource protection disabled for network %d\n", networkID), out)
+		})
+	})
 
-	out, err = runCommand(t, "network", "remove-label", strconv.FormatInt(networkID, 10), "foo")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) foo removed from Network %d\n", networkID), out)
+	t.Run("remove-label", func(t *testing.T) {
+		out, err := runCommand(t, "network", "remove-label", strconv.FormatInt(networkID, 10), "foo")
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("Label(s) foo removed from Network %d\n", networkID), out)
+	})
 
-	out, err = runCommand(t, "network", "expose-routes-to-vswitch", "--disable", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Exposing routes to connected vSwitch of network %s disabled\n", networkName), out)
+	t.Run("disable-expose-routes-to-vswitch", func(t *testing.T) {
+		out, err := runCommand(t, "network", "expose-routes-to-vswitch", "--disable", strconv.FormatInt(networkID, 10))
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("Exposing routes to connected vSwitch of network %s disabled\n", networkName), out)
+	})
 
-	out, err = runCommand(t, "network", "describe", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Regexp(t, `^ID:\s+[0-9]+
+	t.Run("describe", func(t *testing.T) {
+		out, err := runCommand(t, "network", "describe", strconv.FormatInt(networkID, 10))
+		require.NoError(t, err)
+		assert.Regexp(t, `^ID:\s+[0-9]+
 Name:\s+new-test-network-[0-9a-f]{8}
 Created:\s+.*?
 IP Range:\s+10\.0\.0\.0\/16
@@ -215,10 +295,13 @@ Protection:
 Labels:
 \s+No labels
 $`, out)
+	})
 
-	out, err = runCommand(t, "network", "delete", strconv.FormatInt(networkID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Network %d deleted\n", networkID), out)
+	t.Run("delete", func(t *testing.T) {
+		out, err := runCommand(t, "network", "delete", strconv.FormatInt(networkID, 10))
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("Network %d deleted\n", networkID), out)
+	})
 }
 
 func createNetwork(t *testing.T, name string, args ...string) (int64, error) {
diff --git a/e2e_test/placement_group_test.go b/e2e_test/placement_group_test.go
index d9bb2415..4225ac55 100644
--- a/e2e_test/placement_group_test.go
+++ b/e2e_test/placement_group_test.go
@@ -26,46 +26,48 @@ func TestPlacementGroup(t *testing.T) {
 	pgID, err := createPlacementGroup(t, pgName, "--type", "spread")
 	require.NoError(t, err)
 
-	out, err = runCommand(t, "placement-group", "add-label", "non-existing-placement-group", "foo=bar")
-	require.EqualError(t, err, "placement group not found: non-existing-placement-group")
-	assert.Empty(t, out)
-
-	out, err = runCommand(t, "placement-group", "add-label", pgName, "foo=bar")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) foo added to placement group %d\n", pgID), out)
-
-	out, err = runCommand(t, "placement-group", "add-label", pgName, "baz=qux")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) baz added to placement group %d\n", pgID), out)
+	t.Run("add-label", func(t *testing.T) {
+		t.Run("non-existing-placement-group", func(t *testing.T) {
+			out, err = runCommand(t, "placement-group", "add-label", "non-existing-placement-group", "foo=bar")
+			require.EqualError(t, err, "placement group not found: non-existing-placement-group")
+			assert.Empty(t, out)
+		})
+
+		t.Run("1", func(t *testing.T) {
+			out, err = runCommand(t, "placement-group", "add-label", pgName, "foo=bar")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Label(s) foo added to placement group %d\n", pgID), out)
+		})
+
+		t.Run("2", func(t *testing.T) {
+			out, err = runCommand(t, "placement-group", "add-label", pgName, "baz=qux")
+			require.NoError(t, err)
+			assert.Equal(t, fmt.Sprintf("Label(s) baz added to placement group %d\n", pgID), out)
+		})
+	})
 
 	oldPgName := pgName
 	pgName = withSuffix("new-test-placement-group")
 
-	out, err = runCommand(t, "placement-group", "update", oldPgName, "--name", pgName)
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("placement group %s updated\n", oldPgName), out)
+	t.Run("update-name", func(t *testing.T) {
+		out, err := runCommand(t, "placement-group", "update", oldPgName, "--name", pgName)
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("placement group %s updated\n", oldPgName), out)
+	})
 
-	out, err = runCommand(t, "placement-group", "list", "-o=columns=id,name,servers,type,created,age")
-	require.NoError(t, err)
-	assert.Regexp(t, `ID +NAME +SERVERS +TYPE +CREATED +AGE
+	t.Run("list", func(t *testing.T) {
+		t.Run("table", func(t *testing.T) {
+			out, err := runCommand(t, "placement-group", "list", "-o=columns=id,name,servers,type,created,age")
+			require.NoError(t, err)
+			assert.Regexp(t, `ID +NAME +SERVERS +TYPE +CREATED +AGE
 [0-9]+ +new-test-placement-group-[0-9a-f]{8} +0 servers +spread .*? (?:just now|[0-9]+s)
 `, out)
+		})
 
-	out, err = runCommand(t, "placement-group", "describe", strconv.FormatInt(pgID, 10))
-	require.NoError(t, err)
-	assert.Regexp(t, `^ID:\s+[0-9]+
-Name:\s+new-test-placement-group-[0-9a-f]{8}
-Created:\s+.*?
-Labels:
-\s+(baz: qux|foo: bar)
-\s+(baz: qux|foo: bar)
-Servers:
-Type:\s+spread
-$`, out)
-
-	out, err = runCommand(t, "placement-group", "list", "-o=json")
-	require.NoError(t, err)
-	assertjson.Equal(t, []byte(fmt.Sprintf(`
+		t.Run("json", func(t *testing.T) {
+			out, err := runCommand(t, "placement-group", "list", "-o=json")
+			require.NoError(t, err)
+			assertjson.Equal(t, []byte(fmt.Sprintf(`
 [
   {
     "id": %d,
@@ -79,14 +81,34 @@ $`, out)
     "type": "spread"
   }
 ]`, pgID, pgName)), []byte(out))
+		})
+	})
 
-	out, err = runCommand(t, "placement-group", "remove-label", pgName, "baz")
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("Label(s) baz removed from placement group %d\n", pgID), out)
+	t.Run("describe", func(t *testing.T) {
+		out, err := runCommand(t, "placement-group", "describe", strconv.FormatInt(pgID, 10))
+		require.NoError(t, err)
+		assert.Regexp(t, `^ID:\s+[0-9]+
+Name:\s+new-test-placement-group-[0-9a-f]{8}
+Created:\s+.*?
+Labels:
+\s+(baz: qux|foo: bar)
+\s+(baz: qux|foo: bar)
+Servers:
+Type:\s+spread
+$`, out)
+	})
 
-	out, err = runCommand(t, "placement-group", "delete", strconv.FormatInt(pgID, 10))
-	require.NoError(t, err)
-	assert.Equal(t, fmt.Sprintf("placement group %d deleted\n", pgID), out)
+	t.Run("remove-label", func(t *testing.T) {
+		out, err := runCommand(t, "placement-group", "remove-label", pgName, "baz")
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("Label(s) baz removed from placement group %d\n", pgID), out)
+	})
+
+	t.Run("delete", func(t *testing.T) {
+		out, err := runCommand(t, "placement-group", "delete", strconv.FormatInt(pgID, 10))
+		require.NoError(t, err)
+		assert.Equal(t, fmt.Sprintf("placement group %d deleted\n", pgID), out)
+	})
 }
 
 func createPlacementGroup(t *testing.T, name string, args ...string) (int64, error) {