Add some tests and fix vet warning

internal/caddyscript/lib/regex.go

@@ -45,6 +45,6 @@ func (r Regexp) MatchString(thread *starlark.Thread, fn *starlark.Builtin, args
 
 func (r Regexp) Freeze()               {}
 func (r Regexp) Hash() (uint32, error) { return 0, fmt.Errorf("unhashable: Regexp") }
-func (r Regexp) String() string        { return fmt.Sprint(r) }
+func (r Regexp) String() string        { return "Regexp" }
 func (r Regexp) Type() string          { return "Regexp" }
 func (r Regexp) Truth() starlark.Bool  { return true }

modules/caddyhttp/caddyhttp_test.go

@@ -5,73 +5,181 @@ import (
 	"testing"
 )
 
-func TestParseListenerAddr(t *testing.T) {
+func TestSplitListenerAddr(t *testing.T) {
 	for i, tc := range []struct {
-		input       string
+		input         string
-		expectProto string
+		expectNetwork string
-		expectAddrs []string
+		expectHost    string
-		expectErr   bool
+		expectPort    string
+		expectErr     bool
 	}{
 		{
-			input:       "",
+			input:     "",
-			expectProto: "tcp",
+			expectErr: true,
-			expectErr:   true,
 		},
 		{
-			input:       ":",
+			input:     "foo",
-			expectProto: "tcp",
+			expectErr: true,
-			expectErr:   true,
 		},
 		{
-			input:       ":1234",
+			input:      "foo:1234",
-			expectProto: "tcp",
+			expectHost: "foo",
-			expectAddrs: []string{":1234"},
+			expectPort: "1234",
 		},
 		{
-			input:       "tcp/:1234",
+			input:      "foo:1234-5678",
-			expectProto: "tcp",
+			expectHost: "foo",
-			expectAddrs: []string{":1234"},
+			expectPort: "1234-5678",
 		},
 		{
-			input:       "tcp6/:1234",
+			input:         "udp/foo:1234",
-			expectProto: "tcp6",
+			expectNetwork: "udp",
-			expectAddrs: []string{":1234"},
+			expectHost:    "foo",
+			expectPort:    "1234",
 		},
 		{
-			input:       "tcp4/localhost:1234",
+			input:         "tcp6/foo:1234-5678",
-			expectProto: "tcp4",
+			expectNetwork: "tcp6",
-			expectAddrs: []string{"localhost:1234"},
+			expectHost:    "foo",
+			expectPort:    "1234-5678",
 		},
 		{
-			input:       "unix/localhost:1234-1236",
+			input:         "udp/",
-			expectProto: "unix",
+			expectNetwork: "udp",
-			expectAddrs: []string{"localhost:1234", "localhost:1235", "localhost:1236"},
+			expectErr:     true,
-		},
-		{
-			input:       "localhost:1234-1234",
-			expectProto: "tcp",
-			expectAddrs: []string{"localhost:1234"},
-		},
-		{
-			input:       "localhost:2-1",
-			expectProto: "tcp",
-			expectErr:   true,
-		},
-		{
-			input:       "localhost:0",
-			expectProto: "tcp",
-			expectAddrs: []string{"localhost:0"},
 		},
 	} {
-		actualProto, actualAddrs, err := parseListenAddr(tc.input)
+		actualNetwork, actualHost, actualPort, err := splitListenAddr(tc.input)
 		if tc.expectErr && err == nil {
 			t.Errorf("Test %d: Expected error but got: %v", i, err)
 		}
 		if !tc.expectErr && err != nil {
 			t.Errorf("Test %d: Expected no error but got: %v", i, err)
 		}
-		if actualProto != tc.expectProto {
+		if actualNetwork != tc.expectNetwork {
-			t.Errorf("Test %d: Expeceted protocol '%s' but got '%s'", i, tc.expectProto, actualProto)
+			t.Errorf("Test %d: Expected network '%s' but got '%s'", i, tc.expectNetwork, actualNetwork)
+		}
+		if actualHost != tc.expectHost {
+			t.Errorf("Test %d: Expected host '%s' but got '%s'", i, tc.expectHost, actualHost)
+		}
+		if actualPort != tc.expectPort {
+			t.Errorf("Test %d: Expected port '%s' but got '%s'", i, tc.expectPort, actualPort)
+		}
+	}
+}
+
+func TestJoinListenerAddr(t *testing.T) {
+	for i, tc := range []struct {
+		network, host, port string
+		expect              string
+	}{
+		{
+			network: "", host: "", port: "",
+			expect: "",
+		},
+		{
+			network: "tcp", host: "", port: "",
+			expect: "tcp/",
+		},
+		{
+			network: "", host: "foo", port: "",
+			expect: "foo",
+		},
+		{
+			network: "", host: "", port: "1234",
+			expect: ":1234",
+		},
+		{
+			network: "", host: "", port: "1234-5678",
+			expect: ":1234-5678",
+		},
+		{
+			network: "", host: "foo", port: "1234",
+			expect: "foo:1234",
+		},
+		{
+			network: "udp", host: "foo", port: "1234",
+			expect: "udp/foo:1234",
+		},
+		{
+			network: "udp", host: "", port: "1234",
+			expect: "udp/:1234",
+		},
+	} {
+		actual := joinListenAddr(tc.network, tc.host, tc.port)
+		if actual != tc.expect {
+			t.Errorf("Test %d: Expected '%s' but got '%s'", i, tc.expect, actual)
+		}
+	}
+}
+
+func TestParseListenerAddr(t *testing.T) {
+	for i, tc := range []struct {
+		input         string
+		expectNetwork string
+		expectAddrs   []string
+		expectErr     bool
+	}{
+		{
+			input:         "",
+			expectNetwork: "tcp",
+			expectErr:     true,
+		},
+		{
+			input:         ":",
+			expectNetwork: "tcp",
+			expectErr:     true,
+		},
+		{
+			input:         ":1234",
+			expectNetwork: "tcp",
+			expectAddrs:   []string{":1234"},
+		},
+		{
+			input:         "tcp/:1234",
+			expectNetwork: "tcp",
+			expectAddrs:   []string{":1234"},
+		},
+		{
+			input:         "tcp6/:1234",
+			expectNetwork: "tcp6",
+			expectAddrs:   []string{":1234"},
+		},
+		{
+			input:         "tcp4/localhost:1234",
+			expectNetwork: "tcp4",
+			expectAddrs:   []string{"localhost:1234"},
+		},
+		{
+			input:         "unix/localhost:1234-1236",
+			expectNetwork: "unix",
+			expectAddrs:   []string{"localhost:1234", "localhost:1235", "localhost:1236"},
+		},
+		{
+			input:         "localhost:1234-1234",
+			expectNetwork: "tcp",
+			expectAddrs:   []string{"localhost:1234"},
+		},
+		{
+			input:         "localhost:2-1",
+			expectNetwork: "tcp",
+			expectErr:     true,
+		},
+		{
+			input:         "localhost:0",
+			expectNetwork: "tcp",
+			expectAddrs:   []string{"localhost:0"},
+		},
+	} {
+		actualNetwork, actualAddrs, err := parseListenAddr(tc.input)
+		if tc.expectErr && err == nil {
+			t.Errorf("Test %d: Expected error but got: %v", i, err)
+		}
+		if !tc.expectErr && err != nil {
+			t.Errorf("Test %d: Expected no error but got: %v", i, err)
+		}
+		if actualNetwork != tc.expectNetwork {
+			t.Errorf("Test %d: Expected network '%s' but got '%s'", i, tc.expectNetwork, actualNetwork)
 		}
 		if !reflect.DeepEqual(tc.expectAddrs, actualAddrs) {
 			t.Errorf("Test %d: Expected addresses %v but got %v", i, tc.expectAddrs, actualAddrs)