From d25008d2c8e2eb5f96b2b37a1cca5b4e140cfe8d Mon Sep 17 00:00:00 2001
From: Matthew Holt <mholt@users.noreply.github.com>
Date: Mon, 8 Jul 2019 16:46:38 -0600
Subject: Move listen address functions into caddy package; fix unix bug

---
 listeners_test.go | 211 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 211 insertions(+)
 create mode 100644 listeners_test.go

(limited to 'listeners_test.go')

diff --git a/listeners_test.go b/listeners_test.go
new file mode 100644
index 0000000..7c5a2fc
--- /dev/null
+++ b/listeners_test.go
@@ -0,0 +1,211 @@
+// Copyright 2015 Matthew Holt and The Caddy Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package caddy
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestSplitListenerAddr(t *testing.T) {
+	for i, tc := range []struct {
+		input         string
+		expectNetwork string
+		expectHost    string
+		expectPort    string
+		expectErr     bool
+	}{
+		{
+			input:     "",
+			expectErr: true,
+		},
+		{
+			input:     "foo",
+			expectErr: true,
+		},
+		{
+			input:      "foo:1234",
+			expectHost: "foo",
+			expectPort: "1234",
+		},
+		{
+			input:      "foo:1234-5678",
+			expectHost: "foo",
+			expectPort: "1234-5678",
+		},
+		{
+			input:         "udp/foo:1234",
+			expectNetwork: "udp",
+			expectHost:    "foo",
+			expectPort:    "1234",
+		},
+		{
+			input:         "tcp6/foo:1234-5678",
+			expectNetwork: "tcp6",
+			expectHost:    "foo",
+			expectPort:    "1234-5678",
+		},
+		{
+			input:         "udp/",
+			expectNetwork: "udp",
+			expectErr:     true,
+		},
+		{
+			input:         "unix//foo/bar",
+			expectNetwork: "unix",
+			expectHost:    "/foo/bar",
+		},
+	} {
+		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 actualNetwork != tc.expectNetwork {
+			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",
+		},
+		{
+			network: "unix", host: "/foo/bar", port: "",
+			expect: "unix//foo/bar",
+		},
+	} {
+		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//foo/bar",
+			expectNetwork: "unix",
+			expectAddrs:   []string{"/foo/bar"},
+		},
+		{
+			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)
+		}
+	}
+}
-- 
cgit v1.2.3