mirror of
https://github.com/caddyserver/caddy.git
synced 2024-12-23 22:27:38 -05:00
202 lines
4.7 KiB
Go
202 lines
4.7 KiB
Go
// 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 caddyhttp
|
|
|
|
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,
|
|
},
|
|
} {
|
|
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",
|
|
},
|
|
} {
|
|
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)
|
|
}
|
|
}
|
|
}
|