Skip to content

Commit

Permalink
use require where possible, nesting using t.Run
Browse files Browse the repository at this point in the history
  • Loading branch information
@phm07
phm07 committed Sep 18, 2024
1 parent 801e7ab commit 68ea4f5
Show file tree
Hide file tree
Showing 6 changed files with 561 additions and 350 deletions.
109 changes: 64 additions & 45 deletions e2e_test/combined_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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+-
Expand All @@ -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)
})
}
42 changes: 27 additions & 15 deletions e2e_test/datacenter_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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:
Expand All @@ -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)
})
})
}
92 changes: 61 additions & 31 deletions e2e_test/firewall_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Expand Down Expand Up @@ -113,36 +123,42 @@ 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)
assert.Equal(t, fmt.Sprintf("Firewall %d applied to resource\n", firewallID), out)
})
})

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:
Expand Down Expand Up @@ -184,33 +200,39 @@ 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) {
out, err := runCommand(t, "firewall", "remove-from-resource", "--type", "non-existing-type", strconv.FormatInt(firewallID, 10))
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)
Expand Down Expand Up @@ -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) {
Expand Down
Loading

0 comments on commit 68ea4f5

Please sign in to comment.